claude-use 2.5.1 → 2.5.3

package/dist/cli.cjs

@@ -221824,7 +221824,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "2.5.1",
+  version: "2.5.3",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "Apache-2.0",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -241707,7 +241707,7 @@ var HeadroomGlobalConfigSchema = external_exports.strictObject({
   /** How long the daemon may sit with no registered sessions before the supervisor stops it. Defaults to HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
   idleShutdownMinutes: external_exports.number().int().positive().optional()
 });
-var HEADROOM_DEFAULT_SOURCE = "headroom[proxy] @ git+https://github.com/ExaDev/headroom";
+var HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@feat/per-session-savings";
 var HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
 var GlobalConfigSchema = external_exports.strictObject({
   $schema: external_exports.string().optional(),
@@ -243134,7 +243134,7 @@ function acquireIdentityLock(params) {
     }
     lastHolderPid = existing.pid;
     const expired = params.nowMs() - existing.acquiredAtMs > staleAfterMs;
-    if (expired || !params.isProcessAlive(existing.pid)) {
+    if (expired || !params.isRunning(existing.pid)) {
       params.fs.removeRecursive(lockPath);
       continue;
     }
@@ -243394,7 +243394,7 @@ function recoverFarm(params) {
     fs: params.fs,
     nowMs: params.now,
     pid: params.lock.pid,
-    isProcessAlive: params.lock.isProcessAlive,
+    isRunning: params.lock.isRunning,
     sleep: params.lock.sleep,
     ...params.lock.staleAfterMs === void 0 ? {} : { staleAfterMs: params.lock.staleAfterMs },
     ...params.lock.retryDelayMs === void 0 ? {} : { retryDelayMs: params.lock.retryDelayMs },
@@ -243487,7 +243487,7 @@ function resyncFarm(params) {
     fs: params.fs,
     nowMs: params.now,
     pid: params.lock.pid,
-    isProcessAlive: params.lock.isProcessAlive,
+    isRunning: params.lock.isRunning,
     sleep: params.lock.sleep,
     ...params.lock.staleAfterMs === void 0 ? {} : { staleAfterMs: params.lock.staleAfterMs },
     ...params.lock.retryDelayMs === void 0 ? {} : { retryDelayMs: params.lock.retryDelayMs },
@@ -243911,10 +243911,10 @@ function listSessions(fs11, sessionsDir) {
   }
   return sessions.sort((a2, b) => a2.pid - b.pid);
 }
-function pruneDeadSessions(fs11, sessionsDir, isProcessAlive) {
+function pruneDeadSessions(fs11, sessionsDir, isRunning) {
   const removed = [];
   for (const session of listSessions(fs11, sessionsDir)) {
-    if (!isProcessAlive(session.pid)) {
+    if (!isRunning(session.pid)) {
       removeSession(fs11, sessionsDir, session.pid);
       removed.push(session.pid);
     }
@@ -243944,8 +243944,8 @@ function ensureHeadroom(params) {
   let spawnedSupervisor = false;
   for (; ; ) {
     const state = readHeadroomState(ports.fs, paths.headroomStateFile);
-    if (state?.supervisorPid !== void 0 && ports.isProcessAlive(state.supervisorPid)) {
-      const daemonUp = state.port !== void 0 && state.headroomPid !== void 0 && ports.isProcessAlive(state.headroomPid);
+    if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
+      const daemonUp = state.port !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
       if (daemonUp && state.port !== void 0) {
         writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now() });
         return { port: state.port };
@@ -243967,7 +243967,7 @@ function ensureHeadroom(params) {
         spawnedSupervisor = true;
       } else {
         const lock = readStartLock(ports.fs, paths.headroomLockFile);
-        if (lock === void 0 || !ports.isProcessAlive(lock.pid)) {
+        if (lock === void 0 || !ports.isRunning(lock.pid)) {
           ports.fs.removeRecursive(paths.headroomLockFile);
           continue;
         }
@@ -244099,6 +244099,13 @@ function realIsProcessAlive(pid) {
     return isErrorWithCode(error62, "EPERM");
   }
 }
+function realIsProcessZombie(pid) {
+  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
+  return result.status === 0 && result.stdout.trim().startsWith("Z");
+}
+function realIsProcessRunning(pid) {
+  return realIsProcessAlive(pid) && !realIsProcessZombie(pid);
+}
 var realRunPort = {
   run(command, args) {
     const result = (0, import_node_child_process2.spawnSync)(command, [...args], { encoding: "utf8" });
@@ -244154,7 +244161,8 @@ function realHeadroomPort(paths) {
         launcherPid: process.pid,
         ports: {
           fs: realFarmFs,
-          isProcessAlive: realIsProcessAlive,
+          // Zombie-aware on purpose: a supervisor that died while still a child of this launcher sits unreaped until the launcher itself exits, and a defunct supervisor answering signal 0 as alive would stretch every launch to the full start timeout.
+          isRunning: realIsProcessRunning,
           now: () => Date.now(),
           sleep: realSleepSync,
           spawnSupervisor: spawnHeadroomSupervisor
@@ -247223,8 +247231,8 @@ function runDoctor(params) {
       push("headroom", "fail", validated.message);
     } else {
       const state = validated.data;
-      const supervisorAlive = state.supervisorPid !== void 0 && params.headroom.isProcessAlive(state.supervisorPid);
-      const headroomAlive = state.headroomPid !== void 0 && params.headroom.isProcessAlive(state.headroomPid);
+      const supervisorAlive = state.supervisorPid !== void 0 && params.headroom.isRunning(state.supervisorPid);
+      const headroomAlive = state.headroomPid !== void 0 && params.headroom.isRunning(state.headroomPid);
       if (state.supervisorPid === void 0) {
         if (state.lastError === void 0) {
           push("headroom", "pass", "Headroom daemon is stopped (idle shutdown) with no recorded error.");
@@ -247400,7 +247408,7 @@ function registerDoctorCommand(program2, paths) {
       },
       run: realRunPort,
       platform: process.platform,
-      headroom: { state: { path: paths.headroomStateFile, raw: realFsPort.readFileUtf8(paths.headroomStateFile) }, isProcessAlive: realIsProcessAlive }
+      headroom: { state: { path: paths.headroomStateFile, raw: realFsPort.readFileUtf8(paths.headroomStateFile) }, isRunning: realIsProcessRunning }
     });
     for (const line of formatDoctorReport(report)) {
       console.log(line);
@@ -247429,6 +247437,36 @@ var HEADROOM_START_RETRY_BUDGET = 5;
 var HEADROOM_READY_TIMEOUT_MS = 15e3;
 var HEADROOM_POLL_MS = 1e3;
 var MS_PER_MINUTE = 6e4;
+var STOP_POLL_MS = 100;
+var TERM_GRACE_MS = 1500;
+var KILL_GRACE_MS = 1500;
+function stopSupervisedProcess(pid, primitives) {
+  const send = (signal) => {
+    try {
+      primitives.signal(pid, signal);
+    } catch {
+    }
+  };
+  send("SIGTERM");
+  if (awaitExit(pid, primitives, TERM_GRACE_MS)) {
+    return "exited-on-term";
+  }
+  send("SIGKILL");
+  if (awaitExit(pid, primitives, KILL_GRACE_MS)) {
+    return "killed";
+  }
+  return "still-running";
+}
+function awaitExit(pid, primitives, budgetMs) {
+  const deadline = primitives.now() + budgetMs;
+  while (primitives.isRunning(pid)) {
+    if (primitives.now() >= deadline) {
+      return false;
+    }
+    primitives.waitMs(STOP_POLL_MS);
+  }
+  return true;
+}
 function backoffForAttempt(attempt) {
   return Math.min(HEADROOM_BACKOFF_CAP_MS, HEADROOM_BACKOFF_BASE_MS * 2 ** (attempt - 1));
 }
@@ -247491,7 +247529,8 @@ async function runSupervisor(config2, ports, options = {}) {
     ports.log(`claude-use headroom supervisor: ${message}`);
     return 1;
   };
-  let installedSource = readHeadroomState(fs11, paths.headroomStateFile)?.installedSource;
+  const previousState = readHeadroomState(fs11, paths.headroomStateFile);
+  let installedSource = previousState?.installedSource;
   const ensureInstalled = () => {
     const version3 = ports.headroomVersion();
     const versionOk = version3 !== void 0 && versionSatisfies(version3, config2.source);
@@ -247513,6 +247552,11 @@ async function runSupervisor(config2, ports, options = {}) {
   const version2 = ports.headroomVersion() ?? "unknown";
   writeHeadroomState(fs11, paths.headroomStateFile, { supervisorPid: ports.ownPid, version: version2, installedSource });
   ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
+  const orphanPid = previousState?.headroomPid;
+  if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
+    ports.log(`claude-use headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
+    ports.stopProcess(orphanPid);
+  }
   let headroomPid;
   let runningHash;
   let consecutiveFailures = 0;
@@ -247525,13 +247569,14 @@ async function runSupervisor(config2, ports, options = {}) {
     ticks += 1;
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs11, paths.headroomSessionsDir, ports.isProcessAlive);
-    const crashed = headroomPid !== void 0 && !ports.isProcessAlive(headroomPid);
+    pruneDeadSessions(fs11, paths.headroomSessionsDir, ports.isRunning);
+    const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
     if (headroomPid === void 0 || crashed) {
       if (crashed) {
         ports.log(`claude-use headroom supervisor: headroom pid ${String(headroomPid)} died`);
         headroomPid = void 0;
         runningHash = void 0;
+        writeHeadroomState(fs11, paths.headroomStateFile, { supervisorPid: ports.ownPid, version: version2, installedSource });
       }
       if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
         return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
@@ -247563,7 +247608,7 @@ async function runSupervisor(config2, ports, options = {}) {
         ports.log(
           `claude-use headroom supervisor: headroom did not become ready on port ${String(port)} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
         );
-        ports.sleep(backoffForAttempt(consecutiveFailures));
+        await ports.sleep(backoffForAttempt(consecutiveFailures));
         continue;
       }
     } else {
@@ -247592,7 +247637,7 @@ async function runSupervisor(config2, ports, options = {}) {
         idleSince = void 0;
       }
     }
-    ports.sleep(HEADROOM_POLL_MS);
+    await ports.sleep(HEADROOM_POLL_MS);
   }
 }
 function allowlistOf(ports) {
@@ -247607,21 +247652,21 @@ async function waitUntilReady(ports, port) {
     if (ports.now() >= deadline) {
       return false;
     }
-    ports.sleep(HEADROOM_POLL_MS);
+    await ports.sleep(HEADROOM_POLL_MS);
   }
 }
 
 // src/headroom/commands.ts
-function collectHeadroomStatus(fsPort, paths, isProcessAlive) {
+function collectHeadroomStatus(fsPort, paths, isRunning) {
   const state = readHeadroomState(fsPort, paths.headroomStateFile) ?? {};
   const allowlist = headroomAllowlist(readAllProviders(fsPort, paths.providersDir).map((entry) => entry.provider));
   return {
     state,
-    supervisorAlive: state.supervisorPid !== void 0 && isProcessAlive(state.supervisorPid),
-    headroomAlive: state.headroomPid !== void 0 && isProcessAlive(state.headroomPid),
+    supervisorAlive: state.supervisorPid !== void 0 && isRunning(state.supervisorPid),
+    headroomAlive: state.headroomPid !== void 0 && isRunning(state.headroomPid),
     sessions: listSessions(fsPort, paths.headroomSessionsDir).map((session) => ({
       ...session,
-      alive: isProcessAlive(session.pid)
+      alive: isRunning(session.pid)
     })),
     allowlist,
     allowlistDrifted: state.allowlistHash !== void 0 && state.allowlistHash !== hashAllowlist(allowlist),
@@ -247677,17 +247722,25 @@ async function realFreePort() {
     });
   });
 }
-var supervisedHeadroomPid;
-var STOP_GRACE_MS = 1500;
+var ownedHeadroom = /* @__PURE__ */ new Map();
+var exitedHeadroom = /* @__PURE__ */ new Set();
 var READY_FETCH_TIMEOUT_MS = 2e3;
+function headroomPidRunning(pid) {
+  return !exitedHeadroom.has(pid) && realIsProcessRunning(pid);
+}
 function realSupervisorPorts(paths) {
   return {
     fs: realFarmFs,
     paths,
     ownPid: process.pid,
     now: () => Date.now(),
-    sleep: realSleepSync,
-    isProcessAlive: realIsProcessAlive,
+    // A real timer, not the launcher's blocking Atomics.wait: the supervisor lives on its event loop, and the child's exit event can only be delivered while the loop turns.
+    sleep: async (ms) => {
+      await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+      });
+    },
+    isRunning: headroomPidRunning,
     freePort: realFreePort,
     spawnHeadroom: (port, allowlist) => {
       import_node_fs9.default.mkdirSync(paths.logsDir, { recursive: true });
@@ -247698,28 +247751,37 @@ function realSupervisorPorts(paths) {
           stdio: ["ignore", logFd, logFd],
           env: { ...process.env, HEADROOM_ALLOWED_BASE_URLS: allowlist.join(",") }
         });
-        child.unref();
         if (child.pid === void 0) {
           throw new Error("spawning headroom returned no pid");
         }
-        supervisedHeadroomPid = child.pid;
-        return child.pid;
+        const pid = child.pid;
+        ownedHeadroom.set(pid, child);
+        child.once("exit", (code, signal) => {
+          ownedHeadroom.delete(pid);
+          exitedHeadroom.add(pid);
+          import_node_fs9.default.appendFileSync(paths.headroomLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} claude-use headroom supervisor: headroom exited (${signal ?? `code ${String(code)}`})
+`);
+        });
+        return pid;
       } finally {
         import_node_fs9.default.closeSync(logFd);
       }
     },
     stopProcess: (pid) => {
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch {
-      }
-      realSleepSync(STOP_GRACE_MS);
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-      }
-      if (supervisedHeadroomPid === pid) {
-        supervisedHeadroomPid = void 0;
+      const outcome = stopSupervisedProcess(pid, {
+        signal: (target, signal) => {
+          process.kill(target, signal);
+        },
+        isRunning: headroomPidRunning,
+        waitMs: realSleepSync,
+        now: () => Date.now()
+      });
+      if (outcome === "still-running") {
+        import_node_fs9.default.appendFileSync(
+          paths.headroomLogPath,
+          `${(/* @__PURE__ */ new Date()).toISOString()} claude-use headroom supervisor: pid ${String(pid)} survived SIGKILL within its grace; it is stuck uninterruptibly
+`
+        );
       }
     },
     ready: async (port) => {
@@ -247757,7 +247819,7 @@ function realSupervisorPorts(paths) {
 function registerHeadroomCommand(program2, paths) {
   const headroom = program2.command("headroom").description("Inspect the headroom routing daemon.");
   headroom.command("status").description("Report the headroom daemon's supervisor, process, port, sessions, and last error. Read-only.").action(() => {
-    for (const line of formatHeadroomStatus(collectHeadroomStatus(realFarmFs, paths, realIsProcessAlive))) {
+    for (const line of formatHeadroomStatus(collectHeadroomStatus(realFarmFs, paths, realIsProcessRunning))) {
       console.log(line);
     }
   });
@@ -247765,13 +247827,19 @@ function registerHeadroomCommand(program2, paths) {
     const globalConfig2 = readGlobalConfig(paths);
     const config2 = resolveSupervisorConfig(globalConfig2?.headroom ?? {});
     process.on("exit", () => {
-      if (supervisedHeadroomPid !== void 0) {
+      for (const pid of ownedHeadroom.keys()) {
         try {
-          process.kill(supervisedHeadroomPid, "SIGTERM");
+          process.kill(pid, "SIGKILL");
         } catch {
         }
       }
     });
+    process.on("SIGTERM", () => {
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      process.exit(0);
+    });
     const code = await runSupervisor(config2, realSupervisorPorts(paths));
     process.exit(code);
   });
@@ -248462,7 +248530,8 @@ function buildFarmRuntime(paths) {
       }).input,
       now: () => Date.now(),
       uniqueSuffix: `${String(process.pid)}.${(0, import_node_crypto5.randomUUID)()}`,
-      lock: { pid: process.pid, isProcessAlive: realIsProcessAlive, sleep: realSleepSync }
+      // Zombie-aware on purpose: a previous launcher that crashed out of a resync without releasing the lock may sit unreaped, still answering signal 0 as alive, and must read as a dead holder so this launch takes the lock over instead of timing out.
+      lock: { pid: process.pid, isRunning: realIsProcessRunning, sleep: realSleepSync }
     },
     ...selections.identity === void 0 ? {} : { directoryIdentity: selections.identity },
     ...selections.configProfile === void 0 ? {} : { directoryConfigProfile: selections.configProfile },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",