@datacore-one/cli 1.0.7 → 1.0.9

package/dist/index.js

@@ -8502,7 +8502,7 @@ function checkNode(platform2) {
   if (installed) {
     version = getVersion("node", "-v");
     const major = parseInt(version?.replace("v", "").split(".")[0] ?? "0", 10);
-    meetsMin = major >= 18;
+    meetsMin = major >= 20;
   }
   return {
     name: "node",
@@ -9687,6 +9687,38 @@ function runArgs(cmd, args, opts) {
     return false;
   }
 }
+function runArgsWithError(cmd, args, opts) {
+  try {
+    execFileSync2(cmd, args, { stdio: "pipe", cwd: opts?.cwd, timeout: opts?.timeout });
+    return { ok: true };
+  } catch (err) {
+    const stderr = err?.stderr?.toString().trim() || "";
+    return { ok: false, stderr };
+  }
+}
+function initGitInDir(repoUrl, dir, timeout = 300000) {
+  let r = runArgsWithError("git", ["init"], { cwd: dir, timeout: 30000 });
+  if (!r.ok)
+    return r;
+  r = runArgsWithError("git", ["remote", "add", "origin", repoUrl], { cwd: dir, timeout: 5000 });
+  if (!r.ok) {
+    r = runArgsWithError("git", ["remote", "set-url", "origin", repoUrl], { cwd: dir, timeout: 5000 });
+    if (!r.ok)
+      return r;
+  }
+  r = runArgsWithError("git", ["fetch", "origin"], { cwd: dir, timeout });
+  if (!r.ok)
+    return r;
+  const headRef = runArgsOutput("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { timeout: 5000 });
+  const branch = headRef?.replace("refs/remotes/origin/", "") || "main";
+  r = runArgsWithError("git", ["reset", `origin/${branch}`], { cwd: dir, timeout: 30000 });
+  if (!r.ok)
+    return r;
+  runArgs("git", ["branch", "-M", branch], { cwd: dir });
+  runArgs("git", ["branch", "--set-upstream-to", `origin/${branch}`], { cwd: dir });
+  runArgs("git", ["checkout", "--", "."], { cwd: dir, timeout: 60000 });
+  return { ok: true };
+}
 function runArgsOutput(cmd, args, opts) {
   try {
     return execFileSync2(cmd, args, { encoding: "utf-8", stdio: "pipe", timeout: opts?.timeout }).trim();
@@ -9870,7 +9902,7 @@ function isInitialized() {
   }
 }
 async function initDatacore(options = {}) {
-  const { nonInteractive = false, skipChecks = false, stream = false, verbose = false } = options;
+  const { nonInteractive = false, skipChecks = false, stream = false, verbose = false, force = false } = options;
   const isTTY = stream && process.stdout.isTTY;
   const interactive = isTTY && !nonInteractive;
   const platform2 = detectPlatform();
@@ -10065,94 +10097,151 @@ async function initDatacore(options = {}) {
       console.log();
     }
     const ghAuth = checkGhAuth();
-    if (existsSync9(join10(DATA_DIR8, ".git"))) {
+    const upstreamUrl = `https://github.com/${UPSTREAM_REPO}.git`;
+    let ghUser;
+    if (ghAuth.available) {
+      ghUser = ghAuth.user || runArgsOutput("gh", ["api", "user", "-q", ".login"], { timeout: 15000 });
+      const forkSpinner = isTTY ? new Spinner("Checking fork...") : null;
+      forkSpinner?.start();
+      const forkExists = runArgs("gh", ["repo", "view", `${ghUser}/datacore`], { cwd: process.env.HOME, timeout: 30000 });
+      if (!forkExists) {
+        forkSpinner?.update("Forking repository...");
+        const forked = runArgs("gh", ["repo", "fork", UPSTREAM_REPO, "--clone=false"], { timeout: 30000 });
+        if (forked) {
+          forkSpinner?.succeed(`Forked to ${ghUser}/datacore`);
+        } else {
+          forkSpinner?.fail("Fork failed (will clone upstream directly)");
+          result.warnings.push("Could not fork repository - will clone directly");
+          ghUser = undefined;
+        }
+      } else {
+        forkSpinner?.succeed(`Fork exists: ${ghUser}/datacore`);
+      }
+    }
+    const cloneUrls = [];
+    if (ghUser) {
+      cloneUrls.push(`https://github.com/${ghUser}/datacore.git`);
+      cloneUrls.push(`git@github.com:${ghUser}/datacore.git`);
+    }
+    if (!ghAuth.available && interactive) {
+      const customUrl = await prompt("  Repository URL", upstreamUrl);
+      cloneUrls.push(customUrl);
+      const sshUrl = customUrl.replace("https://github.com/", "git@github.com:");
+      if (sshUrl !== customUrl)
+        cloneUrls.push(sshUrl);
+    } else {
+      cloneUrls.push(upstreamUrl);
+      cloneUrls.push(`git@github.com:${UPSTREAM_REPO}.git`);
+    }
+    if (!ghAuth.available && interactive) {
+      console.log(`  ${c2.dim}GitHub CLI not authenticated. Cloning upstream directly.${c2.reset}`);
+      console.log(`  ${c2.dim}You can fork later with: gh repo fork --remote${c2.reset}`);
+      console.log();
+    }
+    const hasGitDir = existsSync9(join10(DATA_DIR8, ".git"));
+    const hasValidGit = hasGitDir && runArgs("git", ["rev-parse", "HEAD"], { cwd: DATA_DIR8, timeout: 5000 });
+    if (hasValidGit) {
       if (isTTY)
         console.log(`  ${c2.green}✓${c2.reset} Found existing repository at ~/Data`);
-      const spinner = isTTY ? new Spinner("Pulling latest changes...") : null;
-      spinner?.start();
+      const pullSpinner = isTTY ? new Spinner("Pulling latest changes...") : null;
+      pullSpinner?.start();
       if (runArgs("git", ["pull", "--rebase", "--autostash"], { cwd: DATA_DIR8, timeout: 60000 })) {
-        spinner?.succeed("Repository up to date");
+        pullSpinner?.succeed("Repository up to date");
       } else {
-        spinner?.fail("Pull failed (non-fatal, continuing)");
+        pullSpinner?.fail("Pull failed (non-fatal, continuing)");
         result.warnings.push("Could not pull latest changes");
       }
-    } else if (!existsSync9(DATA_DIR8) || readdirSync3(DATA_DIR8).filter((f) => !f.startsWith(".")).length === 0) {
-      if (ghAuth.available) {
-        const spinner = isTTY ? new Spinner("Forking repository...") : null;
-        spinner?.start();
-        const ghUser = ghAuth.user || runArgsOutput("gh", ["api", "user", "-q", ".login"], { timeout: 15000 });
-        const forkExists = runArgs("gh", ["repo", "view", `${ghUser}/datacore`], { cwd: process.env.HOME, timeout: 30000 });
-        if (!forkExists) {
-          const forked = runArgs("gh", ["repo", "fork", UPSTREAM_REPO, "--clone=false"], { timeout: 30000 });
-          if (forked) {
-            spinner?.succeed(`Forked to ${ghUser}/datacore`);
-          } else {
-            spinner?.fail("Fork failed");
-            result.warnings.push("Could not fork repository - will clone directly");
+      const currentUpstream = runArgsOutput("git", ["remote", "get-url", "upstream"]);
+      if (!currentUpstream) {
+        runArgs("git", ["remote", "add", "upstream", upstreamUrl], { cwd: DATA_DIR8 });
+      }
+    } else {
+      mkdirSync6(DATA_DIR8, { recursive: true });
+      const cloneSpinner = isTTY ? new Spinner("Cloning into ~/Data...") : null;
+      cloneSpinner?.start();
+      let lastCloneErr = "";
+      let cloned = false;
+      for (const url of cloneUrls) {
+        const r = runArgsWithError("git", ["clone", url, "."], { cwd: DATA_DIR8, timeout: 300000 });
+        if (r.ok) {
+          cloned = true;
+          break;
+        }
+        lastCloneErr = r.stderr || "";
+        if (lastCloneErr.includes("already exists and is not an empty directory"))
+          break;
+      }
+      if (cloned) {
+        cloneSpinner?.succeed("Cloned into ~/Data");
+        result.created.push(DATA_DIR8);
+        if (ghUser) {
+          runArgs("git", ["remote", "add", "upstream", upstreamUrl], { cwd: DATA_DIR8 });
+        }
+      } else if (lastCloneErr.includes("already exists and is not an empty directory")) {
+        if (!force) {
+          cloneSpinner?.fail("~/Data is not empty");
+          const entries = readdirSync3(DATA_DIR8);
+          if (isTTY) {
+            console.log(`    ${c2.dim}~/Data contains ${entries.length} items but is not a git repository.${c2.reset}`);
+            console.log(`    ${c2.dim}Use --force to initialize git in the existing directory.${c2.reset}`);
+            console.log(`    ${c2.dim}Or remove/rename ~/Data for a fresh install.${c2.reset}`);
           }
-        } else {
-          spinner?.succeed(`Fork exists: ${ghUser}/datacore`);
-        }
-        const cloneSpinner = isTTY ? new Spinner("Cloning into ~/Data...") : null;
-        cloneSpinner?.start();
-        mkdirSync6(DATA_DIR8, { recursive: true });
-        const cloneUrl = `https://github.com/${ghUser}/datacore.git`;
-        let cloned = runArgs("git", ["clone", cloneUrl, "."], { cwd: DATA_DIR8, timeout: 300000 });
-        if (!cloned) {
-          cloned = runArgs("git", ["clone", `git@github.com:${ghUser}/datacore.git`, "."], { cwd: DATA_DIR8, timeout: 300000 });
-        }
-        if (!cloned) {
-          cloned = runArgs("git", ["clone", `https://github.com/${UPSTREAM_REPO}.git`, "."], { cwd: DATA_DIR8, timeout: 300000 });
-          if (!cloned) {
-            cloned = runArgs("git", ["clone", `git@github.com:${UPSTREAM_REPO}.git`, "."], { cwd: DATA_DIR8, timeout: 300000 });
+          result.errors.push("~/Data exists and is not empty. Use --force to re-initialize.");
+          op.failStep("clone_repo", "Directory not empty");
+          op.fail("~/Data is not empty");
+          return result;
+        }
+        cloneSpinner?.update("Initializing git in existing ~/Data...");
+        let initOk = false;
+        let lastInitErr = "";
+        for (const url of cloneUrls) {
+          const r = initGitInDir(url, DATA_DIR8);
+          if (r.ok) {
+            initOk = true;
+            break;
           }
+          lastInitErr = r.stderr || "";
         }
-        if (cloned) {
-          cloneSpinner?.succeed("Cloned into ~/Data");
-          result.created.push(DATA_DIR8);
-          runArgs("git", ["remote", "add", "upstream", `https://github.com/${UPSTREAM_REPO}.git`], { cwd: DATA_DIR8 });
+        if (initOk) {
+          cloneSpinner?.succeed("Git initialized in existing ~/Data");
+          if (ghUser) {
+            runArgs("git", ["remote", "add", "upstream", upstreamUrl], { cwd: DATA_DIR8 });
+          }
         } else {
-          cloneSpinner?.fail("Clone failed");
-          result.errors.push("Could not clone repository");
-          op.failStep("clone_repo", "Clone failed");
-          op.fail("Clone failed");
+          cloneSpinner?.fail("Could not initialize git");
+          result.errors.push(`Git init failed: ${lastInitErr}`);
+          if (lastInitErr.includes("Authentication") || lastInitErr.includes("403") || lastInitErr.includes("401")) {
+            if (isTTY)
+              console.log(`    ${c2.dim}Check your GitHub access: gh auth status${c2.reset}`);
+          }
+          op.failStep("clone_repo", "Git init failed");
+          op.fail("Git init failed");
           return result;
         }
       } else {
-        let repoUrl;
-        if (interactive) {
-          console.log(`  ${c2.dim}GitHub CLI not authenticated. Cloning upstream directly.${c2.reset}`);
-          console.log(`  ${c2.dim}You can fork later with: gh repo fork --remote${c2.reset}`);
-          console.log();
-          repoUrl = await prompt("  Repository URL", `https://github.com/${UPSTREAM_REPO}.git`);
-        } else {
-          repoUrl = `https://github.com/${UPSTREAM_REPO}.git`;
-        }
-        mkdirSync6(DATA_DIR8, { recursive: true });
-        const spinner = isTTY ? new Spinner("Cloning into ~/Data...") : null;
-        spinner?.start();
-        let cloned = runArgs("git", ["clone", repoUrl, "."], { cwd: DATA_DIR8, timeout: 300000 });
-        if (!cloned) {
-          const sshUrl = repoUrl.replace("https://github.com/", "git@github.com:");
-          cloned = runArgs("git", ["clone", sshUrl, "."], { cwd: DATA_DIR8, timeout: 300000 });
-        }
-        if (cloned) {
-          spinner?.succeed("Cloned into ~/Data");
-          result.created.push(DATA_DIR8);
+        cloneSpinner?.fail("Clone failed");
+        if (lastCloneErr.includes("not found") || lastCloneErr.includes("not exist") || lastCloneErr.includes("does not appear to be a git repository")) {
+          result.errors.push("Repository not found");
+          if (isTTY) {
+            if (ghUser) {
+              console.log(`    ${c2.dim}Neither ${ghUser}/datacore nor ${UPSTREAM_REPO} could be cloned.${c2.reset}`);
+            }
+            console.log(`    ${c2.dim}Ensure you have access to ${UPSTREAM_REPO} and try again.${c2.reset}`);
+            console.log(`    ${c2.dim}Check access: gh repo view ${UPSTREAM_REPO}${c2.reset}`);
+          }
+        } else if (lastCloneErr.includes("Authentication") || lastCloneErr.includes("Permission") || lastCloneErr.includes("403") || lastCloneErr.includes("401")) {
+          result.errors.push("Authentication failed");
+          if (isTTY) {
+            console.log(`    ${c2.dim}Could not authenticate with GitHub.${c2.reset}`);
+            console.log(`    ${c2.dim}Try: gh auth login${c2.reset}`);
+          }
         } else {
-          spinner?.fail("Clone failed");
-          result.errors.push(`Could not clone from ${repoUrl}`);
-          op.failStep("clone_repo", "Clone failed");
-          op.fail("Clone failed");
-          return result;
+          result.errors.push(`Clone failed: ${lastCloneErr}`);
         }
+        op.failStep("clone_repo", "Clone failed");
+        op.fail("Clone failed");
+        return result;
       }
-    } else {
-      if (isTTY) {
-        console.log(`  ${c2.yellow}⚠${c2.reset} ~/Data exists but is not a git repository`);
-        console.log(`    ${c2.dim}Expected a cloned Datacore repo. Some features may not work.${c2.reset}`);
-      }
-      result.warnings.push(`${DATA_DIR8} is not a git repository`);
     }
     const dipsDir = join10(DATACORE_DIR, "dips");
     if (existsSync9(DATACORE_DIR) && !existsSync9(join10(dipsDir, ".git"))) {
@@ -10924,7 +11013,7 @@ async function initDatacore(options = {}) {
 }
 
 // src/index.ts
-var VERSION = "1.0.7";
+var VERSION = "1.0.9";
 var args = process.argv.slice(2);
 var parsed = parseArgs(args);
 async function handleMeta(command, cmdArgs, flags, format) {
@@ -10948,7 +11037,8 @@ async function handleMeta(command, cmdArgs, flags, format) {
         nonInteractive: flags.yes === true,
         skipChecks: flags["skip-checks"] === true,
         stream: format === "human",
-        verbose: flags.verbose === true
+        verbose: flags.verbose === true,
+        force: flags.force === true
       });
       if (format === "json") {
         output(result, format);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datacore-one/cli",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CLI for setting up and managing Datacore installations",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
     "prepublishOnly": "bun run build"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "keywords": [
     "datacore",