@caddis/cli 0.4.57 → 0.4.59

package/dist/cli.js

@@ -1209,7 +1209,7 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path6 = __require("path");
+    var path7 = __require("path");
     var fs = __require("fs");
     var process3 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2222,9 +2222,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path6.resolve(baseDir, baseName);
+          const localBin = path7.resolve(baseDir, baseName);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path6.extname(baseName))) return void 0;
+          if (sourceExt.includes(path7.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs.existsSync(`${localBin}${ext}`)
           );
@@ -2242,17 +2242,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path6.resolve(
-            path6.dirname(resolvedScriptPath),
+          executableDir = path7.resolve(
+            path7.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path6.basename(
+            const legacyName = path7.basename(
               this._scriptPath,
-              path6.extname(this._scriptPath)
+              path7.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2263,7 +2263,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path6.extname(executableFile));
+        launchWithNode = sourceExt.includes(path7.extname(executableFile));
         let proc;
         if (process3.platform !== "win32") {
           if (launchWithNode) {
@@ -3178,7 +3178,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path6.basename(filename, path6.extname(filename));
+        this._name = path7.basename(filename, path7.extname(filename));
         return this;
       }
       /**
@@ -3192,9 +3192,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path7) {
-        if (path7 === void 0) return this._executableDir;
-        this._executableDir = path7;
+      executableDir(path8) {
+        if (path8 === void 0) return this._executableDir;
+        this._executableDir = path8;
         return this;
       }
       /**
@@ -4644,6 +4644,7 @@ async function driveAgents(entries, options) {
       spinner?.stop(`${label} \u2014 ${color.green("done")}`, 0);
       if (!spinner) item("ok", `${label} \u2014 done`);
       for (const step of result.steps) detail(step.command);
+      if (result.message) detail(result.message);
       continue;
     }
     outcome.failed += 1;
@@ -4873,10 +4874,10 @@ function keysFilePath(env) {
   const expanded = expandHome(configured);
   return isAbsolute(expanded) ? expanded : expanded;
 }
-function parseKeysFile(path6) {
+function parseKeysFile(path7) {
   let text;
   try {
-    text = readFileSync3(path6, "utf8");
+    text = readFileSync3(path7, "utf8");
   } catch {
     return {};
   }
@@ -4934,7 +4935,7 @@ __export(keys_exports, {
   probeKey: () => probeKey,
   upsertKeyLines: () => upsertKeyLines
 });
-import { chmodSync, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { chmodSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { dirname } from "path";
 async function probeKey(baseUrl, model, apiKey) {
   if (!baseUrl) return { ok: false, rejected: false, detail: "no endpoint for this provider" };
@@ -4988,18 +4989,18 @@ function upsertKeyLines(existing, updates) {
   if (!text.endsWith("\n")) text += "\n";
   return text;
 }
-function restrictPermissions(path6) {
+function restrictPermissions(path7) {
   if (process.platform === "win32") return null;
   try {
-    chmodSync(path6, 384);
+    chmodSync(path7, 384);
     return null;
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
   }
 }
 async function keys(options = {}) {
-  const path6 = keysFilePath(process.env);
-  const fileKeys = parseKeysFile(path6);
+  const path7 = keysFilePath(process.env);
+  const fileKeys = parseKeysFile(path7);
   const names = Object.keys(PROVIDERS).sort();
   const current = names.map((name) => {
     const preset = PROVIDERS[name];
@@ -5015,7 +5016,7 @@ async function keys(options = {}) {
   if (options.check) {
     const configured = current.filter((entry) => entry.value);
     if (!configured.length) {
-      process.stdout.write(`no provider keys configured (looked in $ENV and ${path6})
+      process.stdout.write(`no provider keys configured (looked in $ENV and ${path7})
 `);
       return 1;
     }
@@ -5030,7 +5031,7 @@ async function keys(options = {}) {
     return bad ? 1 : 0;
   }
   Ie("caddis keys");
-  process.stdout.write(`  keys file: ${path6}
+  process.stdout.write(`  keys file: ${path7}
 
 `);
   for (const entry of current) {
@@ -5090,20 +5091,20 @@ async function keys(options = {}) {
     return 0;
   }
   if (options.dryRun) {
-    Se(`dry run \u2014 would write ${Object.keys(collected).join(", ")} to ${path6}`);
+    Se(`dry run \u2014 would write ${Object.keys(collected).join(", ")} to ${path7}`);
     return 0;
   }
   let existing = "";
   try {
-    existing = readFileSync4(path6, "utf8");
+    existing = readFileSync4(path7, "utf8");
   } catch {
     existing = "";
   }
-  mkdirSync(dirname(path6), { recursive: true });
-  writeFileSync(path6, upsertKeyLines(existing, collected), { encoding: "utf8" });
-  const permWarning = restrictPermissions(path6);
+  mkdirSync2(dirname(path7), { recursive: true });
+  writeFileSync(path7, upsertKeyLines(existing, collected), { encoding: "utf8" });
+  const permWarning = restrictPermissions(path7);
   process.stdout.write(`
-  wrote ${Object.keys(collected).join(", ")} to ${path6}
+  wrote ${Object.keys(collected).join(", ")} to ${path7}
 `);
   if (permWarning) process.stdout.write(color.yellow(`  could not set 0600 on the keys file: ${permWarning}
 `));
@@ -5172,26 +5173,102 @@ var init_update = __esm({
   }
 });
 
+// src/util/sessions.ts
+import { readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import os3 from "os";
+import path5 from "path";
+function caddisHome() {
+  return process.env.CADDIS_HOME || os3.homedir();
+}
+function sessionsDir(home = caddisHome()) {
+  return path5.join(home, ".caddis", "sessions");
+}
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parse2(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r2 = raw;
+  const pid = Number(r2.pid);
+  const lastSeen = Number(r2.last_seen);
+  if (typeof r2.session_id !== "string" || !Number.isInteger(pid) || !Number.isFinite(lastSeen)) return null;
+  return {
+    sessionId: r2.session_id,
+    harness: typeof r2.harness === "string" ? r2.harness : "claude",
+    caddisVersion: typeof r2.caddis_version === "string" && r2.caddis_version ? r2.caddis_version : null,
+    pid,
+    started: (Number(r2.started) || lastSeen) * 1e3,
+    lastSeen: lastSeen * 1e3
+  };
+}
+function liveSessions(home = caddisHome(), now = Date.now(), alive = pidAlive) {
+  const dir = sessionsDir(home);
+  let names;
+  try {
+    names = readdirSync2(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith(".json") || name.startsWith(".")) continue;
+    let beat = null;
+    try {
+      beat = parse2(JSON.parse(readFileSync5(path5.join(dir, name), "utf8")));
+    } catch {
+      continue;
+    }
+    if (beat && now - beat.lastSeen <= STALE_AFTER_MS && alive(beat.pid)) out.push(beat);
+  }
+  return out.sort((a, b3) => a.started - b3.started);
+}
+function olderSessions(sessions, installed) {
+  const out = [];
+  for (const session of sessions) {
+    const current = Object.hasOwn(installed, session.harness) ? installed[session.harness] : void 0;
+    if (typeof current !== "string" || !current || !session.caddisVersion) continue;
+    const order = compareVersions(session.caddisVersion, current);
+    if (order !== null && order < 0) out.push({ ...session, installed: current });
+  }
+  return out;
+}
+var STALE_AFTER_MS;
+var init_sessions = __esm({
+  "src/util/sessions.ts"() {
+    "use strict";
+    init_semver();
+    STALE_AFTER_MS = 7 * 24 * 3600 * 1e3;
+  }
+});
+
 // src/commands/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
   doctor: () => doctor
 });
 import { existsSync as existsSync5 } from "fs";
-import os3 from "os";
+import os4 from "os";
 import process2 from "process";
-import path5 from "path";
+import path6 from "path";
 async function doctor(options) {
   const report = await gather(options.adapters, { checkCliUpdate: true });
   const findings = [];
+  const older = olderSessions(liveSessions(options.home ?? caddisHome()), installedVersions(report));
   if (options.json) {
     const project = await renderProject(findings, { quiet: true });
-    line(JSON.stringify(toJson(report, project), null, 2));
+    line(JSON.stringify({ ...toJson(report, project), olderSessions: older }, null, 2));
     return 0;
   }
   renderBanner({ cliVersion: report.cliVersion, poolVersion: report.poolVersion });
   renderEnvironment(report, findings);
   renderAgents(report, findings);
+  renderSessions(older, findings);
   await renderProject(findings);
   renderSummary(report, findings);
   return options.strict && findings.some((f) => f.kind === "problem") ? 1 : 0;
@@ -5205,7 +5282,7 @@ function renderEnvironment(report, problems) {
     detail(`caddis requires node >= ${REQUIRED_NODE_MAJOR}.${REQUIRED_NODE_MINOR}`);
     problems.push({ kind: "problem", text: `node ${process2.versions.node} is below the required ${REQUIRED_NODE_MAJOR}.${REQUIRED_NODE_MINOR}`, fix: "upgrade node" });
   }
-  item("info", `platform ${process2.platform} ${process2.arch} (${os3.release()})`);
+  item("info", `platform ${process2.platform} ${process2.arch} (${os4.release()})`);
   if (report.cliUpdate) {
     item("warn", `@caddis/cli ${report.cliVersion} ${color.dim("\u2192")} ${color.bold(report.cliUpdate.latest)} available`);
     detail('so EVERY "current" below may be wrong \u2014 it only means "matches the pool this install carries"');
@@ -5257,6 +5334,35 @@ function renderAgents(report, problems) {
     }
   }
 }
+function installedVersions(report) {
+  const out = {};
+  for (const entry of report.agents) {
+    if (entry.status.version) out[entry.adapter.id] = entry.status.version;
+  }
+  return out;
+}
+function renderSessions(older, problems) {
+  heading("Sessions");
+  if (older.length === 0) {
+    item("ok", "no live session runs an older caddis");
+    return;
+  }
+  for (const session of older) {
+    const date = new Date(session.started);
+    const started = Number.isNaN(date.getTime()) ? "unknown" : `${date.toISOString().replace("T", " ").slice(0, 16)} UTC`;
+    item(
+      "warn",
+      `${session.harness} session ${color.bold(session.sessionId)} (pid ${session.pid}, started ${started}) runs caddis ${color.yellow(session.caddisVersion ?? "?")}, installed ${color.bold(session.installed)}`
+    );
+  }
+  const fix = "restart these sessions (or run /reload-plugins in each) to load the installed caddis";
+  hint(color.bold(fix));
+  problems.push({
+    kind: "problem",
+    text: `${older.length} live session${older.length === 1 ? "" : "s"} still run${older.length === 1 ? "s" : ""} an older caddis`,
+    fix
+  });
+}
 async function renderProject(problems, options) {
   const quiet = options?.quiet ?? false;
   const python = await findBin("python");
@@ -5273,7 +5379,7 @@ async function renderProject(problems, options) {
     return { ran: false, exitCode: null };
   }
   const bundle = bundlePath("antigravity-plugin", { requireManifest: false });
-  const script = bundle ? path5.join(bundle, "scripts", "claudster_doctor.py") : null;
+  const script = bundle ? path6.join(bundle, "scripts", "claudster_doctor.py") : null;
   if (!script || !existsSync5(script)) {
     if (!quiet) {
       heading("Project");
@@ -5473,6 +5579,7 @@ var init_doctor = __esm({
     init_exec();
     init_pkg();
     init_which();
+    init_sessions();
     init_report();
     REQUIRED_NODE_MAJOR = 20;
     REQUIRED_NODE_MINOR = 19;
@@ -5655,14 +5762,14 @@ function* pluginBlocks(stdout) {
   if (current) yield current;
 }
 async function detect() {
-  const path6 = await findBin(BIN);
-  if (!path6) {
+  const path7 = await findBin(BIN);
+  if (!path7) {
     return { present: false, note: "no `claude` binary on PATH" };
   }
   const version = await run(BIN, ["--version"], { timeout: 2e4 });
   return {
     present: true,
-    path: path6,
+    path: path7,
     agentVersion: version.ok ? version.stdout.trim().split(/\s+/)[0] || void 0 : void 0,
     note: version.ok ? void 0 : "binary found but `claude --version` failed"
   };
@@ -5761,7 +5868,7 @@ var claudeAdapter = {
 // src/agents/agy.ts
 init_exec();
 init_which();
-import { readFileSync as readFileSync2, existsSync as existsSync2, mkdtempSync, cpSync, rmSync } from "fs";
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync2, mkdtempSync, mkdirSync, cpSync, rmSync, renameSync } from "fs";
 import os from "os";
 import path2 from "path";
 
@@ -5832,6 +5939,133 @@ function backupInstalledPlugin(home) {
     }
   };
 }
+function agyStagingDir(home = os.homedir(), plugin = PLUGIN2) {
+  return path2.join(home, ".caddis", "agy-staged", plugin);
+}
+function errorText(error) {
+  if (!(error instanceof Error)) return String(error);
+  const code = error.code;
+  const kind = code ?? error.constructor.name;
+  const message = code && error.message.startsWith(`${code}: `) ? error.message.slice(code.length + 2) : error.message;
+  return `${kind}: ${message}`;
+}
+function stampMs(stamp) {
+  const n = Number(stamp);
+  if (!Number.isFinite(n)) return -1;
+  return n > 1e15 ? (n - 621355968e9) / 1e4 : n;
+}
+function isWhole(dir, required) {
+  return existsSync2(dir) && required.every((file) => existsSync2(path2.join(dir, file)));
+}
+function recoverInterruptedSwap(home, plugin, required) {
+  const live = pluginDirFor(home, plugin);
+  const staged = agyStagingDir(home, plugin);
+  const parent = path2.dirname(staged);
+  const prefix = `${path2.basename(staged)}.old-`;
+  let olds;
+  try {
+    olds = readdirSync(parent).filter((name) => name.startsWith(prefix)).sort((x2, y3) => stampMs(y3.slice(prefix.length)) - stampMs(x2.slice(prefix.length))).map((name) => path2.join(parent, name));
+  } catch {
+    return null;
+  }
+  if (isWhole(live, required)) {
+    for (const dir of olds) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    return null;
+  }
+  const source = olds.find((dir) => isWhole(dir, required));
+  if (!source) return null;
+  try {
+    if (existsSync2(live)) renameSync(live, `${staged}.broken-${Date.now()}`);
+    mkdirSync(path2.dirname(live), { recursive: true });
+    renameSync(source, live);
+    return `restored the previous plugin from ${source}`;
+  } catch (error) {
+    return `could not restore the previous plugin from ${source} (${errorText(error)}); it is kept there`;
+  }
+}
+function stageAndSwap(bundleDir, home, plugin, required, rename = renameSync) {
+  const live = pluginDirFor(home, plugin);
+  const staged = agyStagingDir(home, plugin);
+  const recovered = recoverInterruptedSwap(home, plugin, required);
+  const note = (detail2) => recovered ? `${recovered}; ${detail2}` : detail2;
+  try {
+    rmSync(staged, { recursive: true, force: true });
+    mkdirSync(path2.dirname(staged), { recursive: true });
+    cpSync(bundleDir, staged, { recursive: true });
+  } catch (error) {
+    return { swapped: false, reason: "stage-failed", staged: null, detail: note(`staging failed (${errorText(error)})`) };
+  }
+  const missing = required.filter((file) => !existsSync2(path2.join(staged, file)));
+  if (missing.length > 0) {
+    return {
+      swapped: false,
+      reason: "stage-rejected",
+      staged: null,
+      kept: staged,
+      detail: note(`the staged copy lacks ${missing.join(", ")}; the live plugin was not touched`)
+    };
+  }
+  if (!existsSync2(live)) {
+    return {
+      swapped: false,
+      reason: "first-install",
+      staged,
+      detail: note("first install: agy must register the plugin with `agy plugin install`")
+    };
+  }
+  const old = `${staged}.old-${Date.now()}`;
+  try {
+    rename(live, old);
+  } catch (error) {
+    return {
+      swapped: false,
+      reason: "in-use",
+      staged,
+      detail: note(`could not move the live plugin aside (${errorText(error)}); agy may be using it`)
+    };
+  }
+  try {
+    rename(staged, live);
+  } catch (error) {
+    const why = `the swap failed (${errorText(error)})`;
+    try {
+      rename(old, live);
+      return { swapped: false, reason: "swap-failed", staged: existsSync2(staged) ? staged : null, detail: `${why}; the old plugin is back` };
+    } catch (backError) {
+      return {
+        swapped: false,
+        reason: "swap-failed",
+        staged: existsSync2(staged) ? staged : null,
+        detail: `${why}; putting the old plugin back FAILED (${errorText(backError)}), it is kept at ${old}`
+      };
+    }
+  }
+  try {
+    rmSync(old, { recursive: true, force: true });
+  } catch {
+  }
+  return { swapped: true, reason: "swapped", staged: live, detail: note("swapped in by rename") };
+}
+function runningAgyMessage(pids, plugin, outcome, alreadySwapped = []) {
+  let text = `agy is running (${pids}), so ${plugin} was not installed: ${outcome.detail}.`;
+  if (alreadySwapped.length > 0) text += ` ${alreadySwapped.join(", ")} was already swapped in.`;
+  if (outcome.kept) {
+    text += ` Nothing was installed; the rejected copy is kept at ${outcome.kept}.`;
+  } else if (outcome.staged && existsSync2(outcome.staged)) {
+    text += ` The new version is staged at ${outcome.staged}. Stop agy and run \`caddis update\` again to put it in place.`;
+  } else {
+    text += " Nothing is staged. Stop agy and run `caddis update` again.";
+  }
+  if (outcome.reason === "first-install") {
+    text += ` Or set ${ALLOW_RUNNING_ENV}=1 if you know no agy holds the plugin folder.`;
+  }
+  return text;
+}
 function pluginManifestPath(home = os.homedir(), plugin = PLUGIN2) {
   return path2.join(home, ".gemini", "config", "plugins", plugin, "plugin.json");
 }
@@ -5952,18 +6186,16 @@ async function drive2(_action, options) {
       message: "dry run \u2014 nothing executed"
     };
   }
+  const home = options.home ?? os.homedir();
+  const recovered = [
+    recoverInterruptedSwap(home, PLUGIN2, REQUIRED_PLUGIN_FILES),
+    recoverInterruptedSwap(home, EXTRAS_PLUGIN, ["plugin.json"])
+  ].filter((note) => note !== null);
+  const withRecovery = (result) => recovered.length === 0 ? result : { ...result, message: [...recovered, result.message].filter(Boolean).join("; ") };
   if (process.env[ALLOW_RUNNING_ENV] !== "1") {
     const running = await listAgyPids();
-    if (running.length > 0) {
-      return {
-        ok: false,
-        skipped: false,
-        steps: [],
-        message: `agy is running (PID ${running.join(", ")}). Installing now can empty the caddis plugin under it, and agy then refuses every edit. Stop agy and run this again, or set ${ALLOW_RUNNING_ENV}=1 if you know no agy holds the plugin folder.`
-      };
-    }
+    if (running.length > 0) return withRecovery(swapUnderRunningAgy(planned, bundle, home, running));
   }
-  const home = options.home ?? os.homedir();
   const backup = backupInstalledPlugin(home);
   const cleanups = [];
   if (backup) cleanups.push(backup.cleanup);
@@ -6002,11 +6234,43 @@ async function drive2(_action, options) {
         return { ok: false, skipped: false, steps: steps3, message: `\`${command}\` failed` };
       }
     }
-    return { ok: true, skipped: false, steps: steps3 };
+    for (const plugin of [PLUGIN2, EXTRAS_PLUGIN]) {
+      try {
+        rmSync(agyStagingDir(home, plugin), { recursive: true, force: true });
+      } catch {
+      }
+    }
+    return withRecovery({ ok: true, skipped: false, steps: steps3 });
   } finally {
     cleanups.forEach((fn) => fn());
   }
 }
+function swapUnderRunningAgy(planned, bundle, home, running) {
+  const pids = `PID ${running.join(", ")}`;
+  const steps3 = [];
+  const swapped = [];
+  for (const step of planned) {
+    const core = step.bundleDir === bundle;
+    const plugin = core ? PLUGIN2 : EXTRAS_PLUGIN;
+    const outcome = stageAndSwap(step.bundleDir, home, plugin, core ? REQUIRED_PLUGIN_FILES : ["plugin.json"]);
+    steps3.push({
+      command: `stage ${step.bundleDir} and swap it into ${pluginDirFor(home, plugin)}`,
+      ok: outcome.swapped,
+      code: null,
+      output: outcome.swapped ? void 0 : outcome.detail
+    });
+    if (!outcome.swapped) {
+      return { ok: false, skipped: false, steps: steps3, message: runningAgyMessage(pids, plugin, outcome, swapped) };
+    }
+    swapped.push(plugin);
+  }
+  return {
+    ok: true,
+    skipped: false,
+    steps: steps3,
+    message: `agy is running (${pids}): the new plugin was staged and swapped in by rename; new agy sessions load it.`
+  };
+}
 var agyAdapter = {
   id: "agy",
   name: "agy (Antigravity)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caddis/cli",
-  "version": "0.4.57",
+  "version": "0.4.59",
   "description": "Install, update and diagnose the caddis dev harness across every coding agent you use (Claude Code, agy/Antigravity, and more).",
   "keywords": [
     "caddis",