@standardagents/code 0.5.1 → 0.6.0

package/dist/index.js

@@ -8,6 +8,7 @@ import { stdout, stdin } from 'process';
 import fsp from 'fs/promises';
 import crypto from 'crypto';
 import readline from 'readline';
+import { fileURLToPath } from 'url';
 
 // src/api.ts
 function classifyConnectError(err, endpoint) {
@@ -4096,8 +4097,10 @@ var PKG_NAME = "@standardagents/code";
 var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PKG_NAME)}`;
 var CACHE_REL_DIR = ".config/standardagents-cli";
 var CACHE_FILE = "update-check.json";
+var STATE_FILE = "auto-update.json";
 var CACHE_TTL_MS = 1e3 * 60 * 60 * 24;
 var CHECK_TIMEOUT_MS = 4e3;
+var IN_FLIGHT_TTL_MS = 15 * 60 * 1e3;
 function cacheDir() {
   return path3.join(homedir(), CACHE_REL_DIR);
 }
@@ -4120,16 +4123,86 @@ function writeCache(latest) {
   } catch {
   }
 }
-async function checkForUpdate(currentVersion) {
-  if (!currentVersion) return null;
-  if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return null;
-  const cached = readCache();
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-    if (cached.latest !== currentVersion) {
-      return { current: currentVersion, latest: cached.latest };
-    }
+function readAutoUpdateState(dir = cacheDir()) {
+  try {
+    const raw = fs4.readFileSync(path3.join(dir, STATE_FILE), "utf-8");
+    const state = JSON.parse(raw);
+    return typeof state?.version === "string" ? state : null;
+  } catch {
     return null;
   }
+}
+function writeAutoUpdateState(state, dir = cacheDir()) {
+  try {
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(path3.join(dir, STATE_FILE), JSON.stringify(state));
+  } catch {
+  }
+}
+function clearAutoUpdateState(dir = cacheDir()) {
+  try {
+    fs4.unlinkSync(path3.join(dir, STATE_FILE));
+  } catch {
+  }
+}
+function detectPackageManager(selfPath = fileURLToPath(import.meta.url), env = process.env) {
+  const norm = selfPath.split(/[\\/]/).join("/");
+  if (!norm.includes("node_modules/@standardagents/code")) return null;
+  const pnpmHome = (env.PNPM_HOME || "").split(/[\\/]/).join("/");
+  if (pnpmHome && norm.startsWith(pnpmHome)) return "pnpm";
+  if (norm.includes("/.pnpm/") || /\/pnpm\/global\//.test(norm)) return "pnpm";
+  if (norm.includes("/.bun/")) return "bun";
+  if (norm.includes("/.config/yarn/") || norm.includes("/.yarn/")) return "yarn";
+  return "npm";
+}
+function updateCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return { cmd: "pnpm", args: ["add", "-g", `${PKG_NAME}@latest`], display: `pnpm add -g ${PKG_NAME}@latest` };
+    case "yarn":
+      return { cmd: "yarn", args: ["global", "add", `${PKG_NAME}@latest`], display: `yarn global add ${PKG_NAME}@latest` };
+    case "bun":
+      return { cmd: "bun", args: ["add", "-g", `${PKG_NAME}@latest`], display: `bun add -g ${PKG_NAME}@latest` };
+    default:
+      return { cmd: "npm", args: ["i", "-g", `${PKG_NAME}@latest`], display: `npm i -g ${PKG_NAME}@latest` };
+  }
+}
+function decideAutoUpdate(info, opts) {
+  const env = opts.env ?? process.env;
+  if (env.STANDARD_CODE_NO_AUTO_UPDATE) return "disabled";
+  if (!opts.pm) return "dev_checkout";
+  const state = opts.state;
+  if (state && state.version === info.latest) {
+    if (state.exitCode === null) {
+      const now = opts.now ?? Date.now();
+      return now - state.startedAt < IN_FLIGHT_TTL_MS ? "in_flight" : "start";
+    }
+    return state.exitCode === 0 ? "path_shadowed" : "already_failed";
+  }
+  return "start";
+}
+function startBackgroundUpdate(latest, pm, dir = cacheDir()) {
+  const startedAt = Date.now();
+  writeAutoUpdateState({ version: latest, startedAt, exitCode: null }, dir);
+  const stateFile = path3.join(dir, STATE_FILE);
+  const { cmd, args } = updateCommand(pm);
+  const script = `const cp=require('child_process');const fs=require('fs');const r=cp.spawnSync(${JSON.stringify(cmd)},${JSON.stringify(args)},{shell:process.platform==='win32',encoding:'utf8'});const out=((r.stdout||'')+(r.stderr||'')).slice(-2000);fs.writeFileSync(${JSON.stringify(stateFile)},JSON.stringify({version:${JSON.stringify(latest)},startedAt:${startedAt},exitCode:r.status==null?-1:r.status,finishedAt:Date.now(),output:out}));`;
+  try {
+    const child = spawn(process.execPath, ["-e", script], { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch {
+    writeAutoUpdateState({ version: latest, startedAt, exitCode: -1, finishedAt: Date.now() }, dir);
+    return false;
+  }
+}
+function consumeAppliedUpdate(currentVersion, dir = cacheDir()) {
+  const state = readAutoUpdateState(dir);
+  if (!state || state.version !== currentVersion) return null;
+  clearAutoUpdateState(dir);
+  return state.exitCode === 0 ? state : null;
+}
+async function fetchLatest(currentVersion) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
   try {
@@ -4142,55 +4215,48 @@ async function checkForUpdate(currentVersion) {
     });
     if (!res.ok) return null;
     const data = await res.json();
-    const latest = data["dist-tags"]?.latest;
-    if (!latest) return null;
-    writeCache(latest);
-    if (latest !== currentVersion) {
-      return { current: currentVersion, latest };
-    }
-    return null;
+    return data["dist-tags"]?.latest ?? null;
   } catch {
     return null;
   } finally {
     clearTimeout(timeout);
   }
 }
-async function forceCheckForUpdate(currentVersion) {
+async function checkForUpdate(currentVersion) {
   if (!currentVersion) return null;
   if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return null;
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-  try {
-    const res = await fetch(REGISTRY_URL, {
-      signal: controller.signal,
-      headers: {
-        Accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*",
-        "User-Agent": `${PKG_NAME}/${currentVersion}`
-      }
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    const latest = data["dist-tags"]?.latest;
-    if (!latest) return null;
-    writeCache(latest);
-    if (latest !== currentVersion) {
-      return { current: currentVersion, latest };
+  const cached = readCache();
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    if (cached.latest !== currentVersion) {
+      return { current: currentVersion, latest: cached.latest };
     }
     return null;
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeout);
   }
+  const latest = await fetchLatest(currentVersion);
+  if (!latest) return null;
+  writeCache(latest);
+  return latest !== currentVersion ? { current: currentVersion, latest } : null;
+}
+async function forceCheckForUpdate(currentVersion) {
+  if (!currentVersion) return null;
+  if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return null;
+  const latest = await fetchLatest(currentVersion);
+  if (!latest) return null;
+  writeCache(latest);
+  return latest !== currentVersion ? { current: currentVersion, latest } : null;
 }
-function runNpmUpdate() {
+function runUpdate(pm) {
   return new Promise((resolve) => {
-    const child = spawn("npm", ["i", "-g", `${PKG_NAME}@latest`], {
-      stdio: "inherit",
-      shell: true
+    const { cmd, args } = updateCommand(pm);
+    const child = spawn(cmd, args, {
+      shell: process.platform === "win32",
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    child.on("close", (code) => resolve(code === 0));
-    child.on("error", () => resolve(false));
+    let out = "";
+    child.stdout?.on("data", (d) => out += d);
+    child.stderr?.on("data", (d) => out += d);
+    child.on("close", (code) => resolve({ ok: code === 0, output: out }));
+    child.on("error", (err) => resolve({ ok: false, output: String(err) }));
   });
 }
 
@@ -4483,13 +4549,36 @@ ${c.dim}Press Control-C again to exit${c.reset}
     const loading = startLoader("Checking for updates");
     updateAvailable = await checkForUpdate(version);
     loading.stop();
+    const applied = consumeAppliedUpdate(version);
+    if (applied) {
+      stdout.write(`  ${c.green}\u2713${c.reset} ${c.dim}Standard Code updated to v${version}.${c.reset}
+
+`);
+    }
     if (updateAvailable) {
-      stdout.write(
-        `  ${c.teal}\u25C7${c.reset} ${c.dim}Update available:${c.reset} ${c.dim}v${updateAvailable.current}${c.reset} \u2192 ${c.bold}v${updateAvailable.latest}${c.reset}
-  ${c.dim}Run ${c.reset}${c.bold}npm i -g @standardagents/code@latest${c.reset}${c.dim} to update${c.reset}
+      const pm = detectPackageManager();
+      const decision = decideAutoUpdate(updateAvailable, { state: readAutoUpdateState(), pm });
+      if (decision === "start" && pm && startBackgroundUpdate(updateAvailable.latest, pm)) {
+        stdout.write(
+          `  ${c.teal}\u27F3${c.reset} ${c.dim}Standard Code ${c.reset}${c.bold}v${updateAvailable.latest}${c.reset}${c.dim} is installing in the background \u2014 it applies on your next launch.${c.reset}
 
 `
-      );
+        );
+      } else if (decision === "in_flight") {
+        stdout.write(
+          `  ${c.teal}\u27F3${c.reset} ${c.dim}Standard Code v${updateAvailable.latest} is still installing in the background.${c.reset}
+
+`
+        );
+      } else {
+        const display = updateCommand(pm ?? "npm").display;
+        stdout.write(
+          `  ${c.teal}\u25C7${c.reset} ${c.dim}Update available:${c.reset} ${c.dim}v${updateAvailable.current}${c.reset} \u2192 ${c.bold}v${updateAvailable.latest}${c.reset}
+  ${c.dim}Run ${c.reset}${c.bold}${display}${c.reset}${c.dim} to update${c.reset}
+
+`
+        );
+      }
     }
   }
   const stored = getCredential(endpoint);
@@ -5048,7 +5137,7 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
     },
     { name: "background", label: "Background processes", hint: "list / stop", run: () => runProcessMenu(tui, bgMgr) },
     { name: "keybindings", label: "Keyboard shortcuts", run: () => showKeybindings(tui) },
-    { name: "update", label: "Check for updates", hint: "check npm for a newer version", run: () => runUpdateCommand(tui) },
+    { name: "update", label: "Check for updates", hint: "check for a newer version", run: () => runUpdateCommand(tui) },
     { name: "logout", label: "Sign out", hint: "delete the saved token & quit", run: () => logout() },
     { name: "quit", label: "Quit", run: () => quit() }
   ]);
@@ -5315,21 +5404,26 @@ async function runUpdateCommand(tui) {
   const { latest } = result;
   tui.print(`
   ${c.yellow}\u27F3${c.reset} Update available: ${c.gray}v${version}${c.reset} \u2192 ${c.green}v${latest}${c.reset}`);
-  const choice = await tui.select(`Update now with \`npm i -g @standardagents/code@latest\`?`, [
+  const pm = detectPackageManager();
+  if (!pm) {
+    tui.print(`  ${c.gray}This is a source checkout \u2014 pull the repo to update.${c.reset}`);
+    return;
+  }
+  const { display } = updateCommand(pm);
+  const choice = await tui.select(`Update now with \`${display}\`?`, [
     { label: "Yes, update now", value: "yes" },
     { label: "No, skip", value: "no" }
   ]);
   if (choice === "yes") {
-    tui.print(`  ${c.gray}Running npm i -g @standardagents/code@latest\u2026${c.reset}`);
-    try {
-      const ok = await runNpmUpdate();
-      if (ok) {
-        tui.print(`  ${c.green}\u2713${c.reset} Updated to v${latest}. Restart to use the new version.`);
-      } else {
-        tui.print(`  ${c.red}\u2717${c.reset} Update failed.`);
+    tui.print(`  ${c.gray}Running ${display}\u2026${c.reset}`);
+    const { ok, output: pmOutput } = await runUpdate(pm);
+    if (ok) {
+      tui.print(`  ${c.green}\u2713${c.reset} Updated to v${latest}. Restart to use the new version.`);
+    } else {
+      tui.print(`  ${c.red}\u2717${c.reset} Update failed:`);
+      for (const line of pmOutput.trim().split("\n").slice(-6)) {
+        tui.print(`  ${c.dim}${line}${c.reset}`);
       }
-    } catch (e) {
-      tui.print(`  ${c.red}\u2717${c.reset} Update failed: ${e}`);
     }
   } else {
     tui.print(`  ${c.gray}Skipped. Run /update later.${c.reset}`);