@standardagents/code 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import os6 from 'os';
+import os6, { homedir } from 'os';
 import fs4 from 'fs';
 import path3 from 'path';
 import readline2 from 'readline/promises';
@@ -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) {
@@ -2105,6 +2106,19 @@ var SUBAGENT_COLORS = [
 ];
 var COMPACTION_COLOR = "\x1B[38;5;208m";
 var COMPACTION_AGENT = "compaction_agent";
+function isWideCodePoint(cp) {
+  return cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp >= 11904 && cp <= 42191 || // CJK radicals … Yi
+  cp >= 44032 && cp <= 55203 || // Hangul syllables
+  cp >= 63744 && cp <= 64255 || // CJK compatibility ideographs
+  cp >= 65072 && cp <= 65103 || // CJK compatibility forms
+  cp >= 65280 && cp <= 65376 || // fullwidth forms
+  cp >= 65504 && cp <= 65510 || cp >= 127744 && cp <= 129791 || // emoji
+  cp >= 131072;
+}
+function sanitizeHudRow(s) {
+  return s.replace(/\x1b(?!\[)/g, "").replace(/[\x00-\x1a\x1c-\x1f\x7f]/g, " ");
+}
 var Tui = class _Tui {
   constructor(level = 1) {
     this.level = level;
@@ -2741,7 +2755,50 @@ var Tui = class _Tui {
     return `${q}${bg}${this.levelColor()}\u276F${C.reset} `;
   }
   visibleWidth(s) {
-    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+    let w = 0;
+    for (const ch of s.replace(/\x1b\[[0-9;]*m/g, "")) {
+      w += isWideCodePoint(ch.codePointAt(0)) ? 2 : 1;
+    }
+    return w;
+  }
+  /**
+   * Truncate a styled string to at most `max` VISIBLE columns, copying ANSI
+   * escape sequences through without counting them and appending a reset if it
+   * cut mid-style. The redraw's whole height math assumes every HUD row is
+   * exactly ONE physical terminal row — true only while each row's visible
+   * width is strictly less than `cols`. A row of width == cols hits the
+   * terminal's auto-wrap boundary: many terminals push the cursor to the next
+   * line, so the following CR/LF yields an EXTRA physical row we didn't count,
+   * and the region marches down the screen leaving a trail on every tick. Every
+   * HUD row is clamped through here to keep that invariant no matter what any
+   * individual line builder produces.
+   */
+  clampVisible(s, max) {
+    let out = "";
+    let width = 0;
+    let i = 0;
+    let truncated = false;
+    while (i < s.length) {
+      if (s[i] === "\x1B" && s[i + 1] === "[") {
+        let j = i + 2;
+        while (j < s.length && !/[a-zA-Z]/.test(s[j])) j++;
+        out += s.slice(i, j + 1);
+        i = j + 1;
+        continue;
+      }
+      const cp = s.codePointAt(i);
+      const chLen = cp > 65535 ? 2 : 1;
+      const chWidth = isWideCodePoint(cp) ? 2 : 1;
+      if (width + chWidth > max) {
+        truncated = true;
+        break;
+      }
+      out += s.slice(i, i + chLen);
+      width += chWidth;
+      i += chLen;
+    }
+    if (truncated) out += C.reset;
+    return out;
   }
   /**
    * The slash-palette block rendered BELOW the input. While the palette is open
@@ -2754,7 +2811,7 @@ var Tui = class _Tui {
    */
   paletteBlockLines(cols2) {
     if (!this.paletteOpen()) return [];
-    const rows = this.paletteLines(cols2);
+    const rows = this.paletteLines(cols2).map((r) => this.clampVisible(r, Math.max(1, cols2 - 1)));
     const reserved = Math.max(this.commands.length, rows.length);
     while (rows.length < reserved) rows.push("");
     return rows;
@@ -2823,11 +2880,13 @@ var Tui = class _Tui {
     if (!this.started || this.takeoverHandler) return;
     const cols2 = process.stdout.columns || 80;
     this.moveToRegionTop();
-    process.stdout.write("\x1B[J");
     const hudWidths = [];
+    const hudRows = [];
+    const rowCap = Math.max(1, cols2 - 1);
     const writeHudRow = (line) => {
-      hudWidths.push(this.visibleWidth(line));
-      process.stdout.write(line + "\r\n");
+      const row = this.clampVisible(sanitizeHudRow(line), rowCap);
+      hudWidths.push(this.visibleWidth(row));
+      hudRows.push(row);
     };
     const previewLines = this.streamPreviewLines(cols2);
     for (const line of previewLines) writeHudRow(line);
@@ -2858,8 +2917,8 @@ var Tui = class _Tui {
     const prefix = this.promptPrefix();
     const pw = this.visibleWidth(prefix);
     const lines = this.inputBuffer.split("\n");
-    process.stdout.write(prefix + lines[0]);
-    for (let i = 1; i < lines.length; i++) process.stdout.write("\r\n" + lines[i]);
+    const tail = [prefix + lines[0]];
+    for (let i = 1; i < lines.length; i++) tail.push("\r\n" + lines[i]);
     const rowsOf = (len, lead) => Math.max(1, Math.ceil((lead + len) / cols2));
     const lineRows = lines.map((l, i) => rowsOf(l.length, i === 0 ? pw : 0));
     const inputRows = lineRows.reduce((a, b) => a + b, 0);
@@ -2874,18 +2933,18 @@ var Tui = class _Tui {
     for (let i = 0; i < caretLine; i++) caretRow += lineRows[i];
     const caretCol = caretCell % cols2;
     const paletteBlock = this.paletteBlockLines(cols2);
-    for (const line of paletteBlock) process.stdout.write("\r\n" + line);
+    for (const line of paletteBlock) tail.push("\r\n" + line);
     if (paletteBlock.length > 0) {
-      process.stdout.write("\r");
+      tail.push("\r");
       const up = inputRows - 1 + paletteBlock.length - caretRow;
-      if (up > 0) process.stdout.write(`\x1B[${up}A`);
-      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      if (up > 0) tail.push(`\x1B[${up}A`);
+      if (caretCol > 0) tail.push(`\x1B[${caretCol}C`);
       this.lastCursorRow = aboveRows + caretRow;
     } else if (this.cursorPos < this.inputBuffer.length) {
-      process.stdout.write("\r");
+      tail.push("\r");
       const up = inputRows - 1 - caretRow;
-      if (up > 0) process.stdout.write(`\x1B[${up}A`);
-      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      if (up > 0) tail.push(`\x1B[${up}A`);
+      if (caretCol > 0) tail.push(`\x1B[${caretCol}C`);
       this.lastCursorRow = aboveRows + caretRow;
     } else {
       this.lastCursorRow = aboveRows + (inputRows - 1);
@@ -2893,6 +2952,8 @@ var Tui = class _Tui {
     this.drawnHudWidths = hudWidths;
     this.lastDrawnCols = cols2;
     this.bottomDrawn = true;
+    const out = "\x1B[J" + hudRows.join("\r\n") + "\r\n" + tail.join("");
+    process.stdout.write(out);
   }
   clearBottom() {
     if (!this.bottomDrawn) return;
@@ -3206,7 +3267,7 @@ var Tui = class _Tui {
    * resets whenever the label changes.
    */
   setStep(label, outTokens) {
-    const next = label && label.trim() ? label.trim() : null;
+    const next = label && label.trim() ? label.replace(/\s+/g, " ").trim() : null;
     if (next !== this.step) {
       this.step = next;
       this.stepStart = Date.now();
@@ -4032,6 +4093,172 @@ function saveDefaultEndpoint(endpoint) {
   } catch {
   }
 }
+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);
+}
+function cachePath() {
+  return path3.join(cacheDir(), CACHE_FILE);
+}
+function readCache() {
+  try {
+    const raw = fs4.readFileSync(cachePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(latest) {
+  try {
+    const dir = cacheDir();
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(cachePath(), JSON.stringify({ latest, timestamp: Date.now() }));
+  } catch {
+  }
+}
+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 {
+    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();
+    return data["dist-tags"]?.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+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 };
+    }
+    return null;
+  }
+  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 runUpdate(pm) {
+  return new Promise((resolve) => {
+    const { cmd, args } = updateCommand(pm);
+    const child = spawn(cmd, args, {
+      shell: process.platform === "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    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) }));
+  });
+}
 
 // src/index.ts
 var AGENT_ID = "standard_code_agent";
@@ -4316,6 +4543,44 @@ ${c.dim}Press Control-C again to exit${c.reset}
 
 `);
   }
+  const version = readVersion();
+  let updateAvailable = null;
+  {
+    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) {
+      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);
   let api = stored ? new ApiClient(endpoint, stored.access_token) : null;
   let storedCheck = null;
@@ -4675,7 +4940,8 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
       for (const s of subs) {
         const status = (s.status || "").trim();
         if (status === "idle" || status === "terminated") continue;
-        const detail = status && status !== "running" ? ` \u2014 ${status.slice(0, 80)}` : "";
+        const oneLineStatus = status.replace(/\s+/g, " ");
+        const detail = oneLineStatus && oneLineStatus !== "running" ? ` \u2014 ${oneLineStatus.slice(0, 80)}` : "";
         activeSubagents.set(s.id, {
           label: `${subagentLabel(s, agentTitles)}${detail}`,
           agentName: s.agent_name ?? void 0
@@ -4871,6 +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 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() }
   ]);
@@ -5127,6 +5394,41 @@ function showKeybindings(tui) {
   tui.print(`${c.gray}  \u2190${c.reset}          from the start of the input: select the [\u2699 n bg] badge (enter opens it)`);
   tui.print(`${c.gray}  ctrl-c${c.reset}     quit`);
 }
+async function runUpdateCommand(tui) {
+  const version = readVersion();
+  const result = await forceCheckForUpdate(version);
+  if (!result) {
+    tui.print(`${c.green}\u2713${c.reset} ${c.gray}@standardagents/code${c.reset} is up to date (v${version})`);
+    return;
+  }
+  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 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 ${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}`);
+      }
+    }
+  } else {
+    tui.print(`  ${c.gray}Skipped. Run /update later.${c.reset}`);
+  }
+}
 async function runProcessMenu(tui, bg) {
   const procs = await bg.list();
   if (!procs.length) {