@dadado/agent-kit-cli 5.15.0 → 5.16.0

package/dist/chunk-VGZBARQC.js

@@ -0,0 +1,318 @@
+import {
+  assessEnvironment
+} from "./chunk-4IWG5CVE.js";
+import {
+  compareSemver,
+  normalizeSemver
+} from "./chunk-XZZAVHH4.js";
+import {
+  MANIFEST_RELATIVE_PATH
+} from "./chunk-VS2JD2XC.js";
+import {
+  KIT_VERSION,
+  pinnedCliSpec
+} from "./chunk-7HDQEK6T.js";
+import {
+  fileExists
+} from "./chunk-77V75A7O.js";
+
+// src/utils/terminal.ts
+import { readdir } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { confirm, isCancel } from "@clack/prompts";
+function isNonInteractive() {
+  if (process.env.CI === "true" || process.env.CI === "1") return true;
+  if (process.env.AGENT_KIT_YES === "1") return true;
+  return !process.stdin.isTTY;
+}
+var NESTED_REPO_AMBIGUITY_THRESHOLD = 2;
+var NESTED_REPO_SCAN_LIMIT = 200;
+async function findNestedRepoChildren(resolved) {
+  let entries;
+  try {
+    entries = await readdir(resolved, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const nested = [];
+  let scanned = 0;
+  for (const entry of entries) {
+    if (nested.length >= NESTED_REPO_AMBIGUITY_THRESHOLD) break;
+    if (scanned >= NESTED_REPO_SCAN_LIMIT) break;
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    scanned += 1;
+    if (await fileExists(path.join(resolved, entry.name, ".git"))) {
+      nested.push(entry.name);
+    }
+  }
+  return nested;
+}
+async function validateProjectRoot(resolved) {
+  const home = path.resolve(homedir());
+  if (resolved === "/" || resolved === home) {
+    return {
+      ok: false,
+      reason: `Refused to use ${resolved} as a project root.`,
+      recovery: "Change into a project directory and re-run. Agent Kit installs per project."
+    };
+  }
+  const hasGit = await fileExists(path.join(resolved, ".git"));
+  const hasManifest = await fileExists(path.join(resolved, MANIFEST_RELATIVE_PATH));
+  if (!hasGit && !hasManifest) {
+    return {
+      ok: false,
+      reason: `Refused ${resolved}: no .git and no ${MANIFEST_RELATIVE_PATH}.`,
+      recovery: [
+        "Starting from an empty folder? Pick one of these:",
+        "  1. git init          - then re-run. Recommended: readiness and the",
+        "                         staging -> prod flow both want Git.",
+        "  2. --force-root      - install without Git. /agent-kit-onboard will",
+        "                         still offer to initialize it later.",
+        "  3. Answer yes to the 'Proceed anyway?' prompt in an interactive terminal.",
+        "Or re-run from the project directory you actually meant."
+      ].join("\n")
+    };
+  }
+  if (hasGit && !hasManifest) {
+    const nested = await findNestedRepoChildren(resolved);
+    if (nested.length >= NESTED_REPO_AMBIGUITY_THRESHOLD) {
+      return {
+        ok: false,
+        reason: `Refused ${resolved}: it has .git but also contains child repositories (${nested.join(", ")}). This looks like a parent-of-repos folder, not a project root.`,
+        recovery: [
+          "L0 belongs in one project, not in the folder that holds several.",
+          "  1. cd into the project you meant, then re-run.",
+          "  2. --force-root - only if this parent folder really is the project root."
+        ].join("\n")
+      };
+    }
+  }
+  return { ok: true };
+}
+async function confirmProjectRoot(cwd, opts) {
+  const resolved = path.resolve(cwd);
+  if (opts.forceRoot) {
+    return resolved;
+  }
+  const validation = await validateProjectRoot(resolved);
+  if (!validation.ok) {
+    if (opts.nonInteractive) {
+      throw new RootRefusedError(resolved, validation.reason, validation.recovery);
+    }
+    const ok2 = await confirm({
+      message: `${validation.reason} Proceed anyway?`,
+      initialValue: false
+    });
+    if (isCancel(ok2) || !ok2) {
+      throw new RootRefusedError(resolved, validation.reason, validation.recovery);
+    }
+    return resolved;
+  }
+  if (opts.nonInteractive) {
+    return resolved;
+  }
+  const ok = await confirm({
+    message: `${opts.command === "install" ? "Install" : "Update"} Agent Kit in: ${resolved}`,
+    initialValue: true
+  });
+  if (isCancel(ok) || !ok) {
+    throw new RootRefusedError(resolved);
+  }
+  return resolved;
+}
+var RootRefusedError = class extends Error {
+  constructor(root, reason, recovery) {
+    super(reason ?? `Refused to write into ${root}. Re-run from the correct project directory.`);
+    this.root = root;
+    this.recovery = recovery;
+    this.name = "RootRefusedError";
+  }
+  root;
+  recovery;
+};
+var NPM_GLOBAL_PREFIX_PATH_RE = /\/lib\/node_modules|Program Files\\nodejs\\node_modules/;
+var NPM_GLOBAL_NODE_MODULES_RE = /node_modules/;
+function isNpmGlobalPrefixError(msg, code) {
+  const isPermissionError = code === "EPERM" || code === "EACCES" || /EPERM|EACCES/.test(msg);
+  if (!isPermissionError) return false;
+  return NPM_GLOBAL_PREFIX_PATH_RE.test(msg) || NPM_GLOBAL_NODE_MODULES_RE.test(msg);
+}
+function classifyInstallError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const code = err?.code;
+  if (isNpmGlobalPrefixError(msg, code)) {
+    return {
+      kind: "npm-global-eacces",
+      message: `Permission error (root-owned npm prefix): ${msg}`,
+      recovery: [
+        "npm's global install prefix (e.g. /usr/local/lib/node_modules) is owned by root, so global installs fail.",
+        "Recovery options:",
+        "  1. Run: npx @dadado/agent-kit-cli@latest setup-global (relocates npm's prefix to a folder you own, fixes PATH, reinstalls)",
+        '  2. Manual fix: mkdir -p ~/.npm-global && npm config set prefix "~/.npm-global" && export PATH="~/.npm-global/bin:$PATH" (add to your shell profile) && npm i -g @dadado/agent-kit-cli@latest',
+        "  3. Use Port B fallback: drag install.md into the Cursor chat"
+      ].join("\n")
+    };
+  }
+  if (code === "EPERM" || code === "EACCES" || /EPERM|EACCES/.test(msg)) {
+    return {
+      kind: "eperm",
+      message: `Permission error: ${msg}`,
+      recovery: [
+        "The npm cache may have ownership drift (root-written files in a user dir).",
+        "Recovery options:",
+        "  1. npx --cache .npm-cache @dadado/agent-kit-cli@latest install",
+        "  2. npm cache clean --force && npx @dadado/agent-kit-cli@latest install",
+        "  3. Use Port B fallback: drag install.md into the Cursor chat"
+      ].join("\n")
+    };
+  }
+  if (/403|Forbidden|unauthorized|E401|ENEEDAUTH/.test(msg)) {
+    return {
+      kind: "registry-auth",
+      message: `Registry access denied: ${msg}`,
+      recovery: [
+        "The npm registry returned 403/401 for the scoped package.",
+        "Recovery options:",
+        "  1. Check npm auth: npm whoami (login if needed: npm login)",
+        "  2. If using a private registry, verify .npmrc scope config",
+        "  3. Use Port B fallback: drag install.md into the Cursor chat"
+      ].join("\n")
+    };
+  }
+  if (/ENOTFOUND|ETIMEDOUT|ECONNREFUSED|ECONNRESET|EAI_AGAIN|fetch failed/.test(msg) || code === "ENOTFOUND" || code === "ETIMEDOUT") {
+    return {
+      kind: "network",
+      message: `Network error: ${msg}`,
+      recovery: [
+        "Could not reach the registry or git remote.",
+        "Recovery options:",
+        "  1. Check network/proxy/VPN settings",
+        "  2. Retry: npx @dadado/agent-kit-cli@latest install",
+        "  3. Use --registry <local-path> if you have a local checkout"
+      ].join("\n")
+    };
+  }
+  return {
+    kind: "unknown",
+    message: msg,
+    recovery: "Unexpected error. Check the message above and retry, or use Port B fallback."
+  };
+}
+
+// src/lifecycle/path-cli.ts
+import { spawn } from "child_process";
+import path2 from "path";
+function npxPinned(runtimeVersion, subcommand) {
+  return `npx -y ${pinnedCliSpec(runtimeVersion)} ${subcommand}`;
+}
+function isBinUnderPrefix(binPath, prefix) {
+  const bin = path2.resolve(binPath);
+  const root = path2.resolve(prefix);
+  return bin === root || bin.startsWith(`${root}${path2.sep}`);
+}
+function pathCliStatus(env, runtimeVersion) {
+  if (!env.binOnPath || !env.binPath) return "missing";
+  const running = normalizeSemver(runtimeVersion);
+  const pathVer = env.binVersion ? normalizeSemver(env.binVersion) : null;
+  if (!pathVer || !running) return "unknown";
+  try {
+    return compareSemver(pathVer, running) >= 0 ? "current" : "behind";
+  } catch {
+    return "unknown";
+  }
+}
+function driftLines(env, runtimeVersion) {
+  const pathVer = env.binVersion ?? "unknown";
+  const where = env.binPath ?? "(unresolved)";
+  return [
+    `This CLI is v${runtimeVersion}. PATH \`agent-kit\` is v${pathVer} at:`,
+    `  ${where}`,
+    "Do not run bare `agent-kit update` or `init` from that binary. It re-stamps the old version.",
+    "Keep using the pinned npx form until PATH matches:",
+    `  ${npxPinned(runtimeVersion, "update")}`,
+    `  ${npxPinned(runtimeVersion, "status")}`
+  ];
+}
+function isShadow(env) {
+  if (!env.binPath || !env.npmPrefix.prefix) return false;
+  return !isBinUnderPrefix(env.binPath, env.npmPrefix.prefix);
+}
+async function spawnNpmGlobalInstall(spec) {
+  return new Promise((resolve) => {
+    const child = spawn("npm", ["i", "-g", spec], { stdio: "inherit" });
+    child.on("error", (error) => resolve({ ok: false, error }));
+    child.on("close", (code) => {
+      if (code === 0) resolve({ ok: true });
+      else resolve({ ok: false, error: new Error(`npm exited with code ${code ?? "unknown"}`) });
+    });
+  });
+}
+async function syncPathCliToRuntime(options = {}) {
+  const runtimeVersion = options.runtimeVersion ?? KIT_VERSION;
+  const assess = options.assessEnvironmentImpl ?? assessEnvironment;
+  let env = options.env ?? await assess();
+  const autoInstall = options.autoInstall ?? !isNonInteractive();
+  const lines = [];
+  let status = pathCliStatus(env, runtimeVersion);
+  if (status === "current") {
+    return { status, env, upgraded: false, lines };
+  }
+  if (status === "behind" || status === "unknown") {
+    lines.push(...driftLines(env, runtimeVersion));
+    if (isShadow(env)) {
+      lines.push(
+        "That PATH hit is not npm's global bin, so `npm i -g` may not replace it.",
+        "Run `hash -r` and `which -a agent-kit`. Put npm's global bin first, or remove the stale shim."
+      );
+    }
+  }
+  if (!autoInstall) {
+    return { status, env, upgraded: false, lines };
+  }
+  if (status === "missing") {
+    lines.push("No bare `agent-kit` on PATH yet (npx is ephemeral).");
+  }
+  if (!env.npmPrefixWritable) {
+    lines.push(
+      "npm's global prefix is not writable, so this process cannot upgrade PATH.",
+      `Run ${npxPinned(runtimeVersion, "setup-global")} (or fix prefix permissions).`
+    );
+    return { status, env, upgraded: false, lines };
+  }
+  const spec = pinnedCliSpec(runtimeVersion);
+  const install = options.npmInstallImpl ?? spawnNpmGlobalInstall;
+  lines.push(`Installing ${spec} into the writable npm prefix...`);
+  const outcome = await install(spec);
+  if (!outcome.ok) {
+    const detail = outcome.error instanceof Error ? outcome.error.message : "npm i -g failed";
+    lines.push(`Global install failed: ${detail}`);
+    return { status, env, upgraded: false, lines };
+  }
+  env = await assess();
+  status = pathCliStatus(env, runtimeVersion);
+  if (status === "current") {
+    lines.push(
+      `PATH \`agent-kit\` is now v${env.binVersion ?? runtimeVersion}.`,
+      "If this shell still shows the old version, run `hash -r` or open a new terminal."
+    );
+    return { status, env, upgraded: true, lines };
+  }
+  lines.push(
+    `Installed ${spec}, but PATH still resolves to v${env.binVersion ?? "unknown"} at:`,
+    `  ${env.binPath ?? "(unresolved)"}`,
+    "Run `hash -r` and `which -a agent-kit`. Until PATH matches, keep using the npx pin above."
+  );
+  return { status, env, upgraded: true, lines };
+}
+
+export {
+  isNonInteractive,
+  confirmProjectRoot,
+  RootRefusedError,
+  classifyInstallError,
+  npxPinned,
+  pathCliStatus,
+  syncPathCliToRuntime
+};