claude-use 2.5.2 → 2.5.4

package/dist/cli.cjs

@@ -221824,7 +221824,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "2.5.2",
+  version: "2.5.4",
   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>",
@@ -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 },
@@ -243749,6 +243749,7 @@ function resolveLayoutPaths() {
 var import_node_child_process2 = require("node:child_process");
 var import_node_crypto4 = require("node:crypto");
 var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_net = __toESM(require("node:net"), 1);
 var import_node_path13 = __toESM(require("node:path"), 1);
 var import_node_sea = require("node:sea");
 
@@ -243829,6 +243830,10 @@ var HeadroomStateSchema = external_exports.strictObject({
   headroomPid: external_exports.number().int().positive().optional(),
   /** The loopback port the proxy listens on. Absent until the proxy has passed its readiness check, so "port is set" is itself the ready signal a launcher polls for. */
   port: external_exports.number().int().positive().optional(),
+  /**
+   * The sticky port preference: the address the daemon last served on, kept across crashes, restarts, and idle shutdowns so the next start reuses it. Distinct from `port` on purpose: `port` is the ready signal (absent whenever nothing is serving), while `lastPort` survives every shutdown, because every live session's environment was frozen at launch pointing at this address and a restart that moves strands them.
+   */
+  lastPort: external_exports.number().int().positive().optional(),
   /** The `headroom --version` output of the running install. */
   version: external_exports.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
@@ -243911,10 +243916,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 +243949,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 +243972,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 +244104,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" });
@@ -244146,6 +244158,21 @@ function spawnHeadroomSupervisor(paths) {
     import_node_fs3.default.closeSync(logFd);
   }
 }
+async function realIsPortFree(port) {
+  return await new Promise((resolve) => {
+    const server2 = import_node_net.default.createServer();
+    server2.unref();
+    server2.once("error", () => {
+      resolve(false);
+    });
+    server2.once("close", () => {
+      resolve(true);
+    });
+    server2.listen(port, "127.0.0.1", () => {
+      server2.close();
+    });
+  });
+}
 function realHeadroomPort(paths) {
   return {
     ensure: () => {
@@ -244154,7 +244181,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 +247251,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 +247428,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);
@@ -247413,7 +247441,7 @@ function registerDoctorCommand(program2, paths) {
 
 // src/headroom/commands.ts
 var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_net = __toESM(require("node:net"), 1);
+var import_node_net2 = __toESM(require("node:net"), 1);
 var import_node_child_process3 = require("node:child_process");
 
 // src/headroom/supervisor.ts
@@ -247429,6 +247457,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));
 }
@@ -247485,13 +247543,18 @@ function compareVersions2(a2, b) {
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
 async function runSupervisor(config2, ports, options = {}) {
   const { fs: fs11, paths } = ports;
+  const previousState = readHeadroomState(fs11, paths.headroomStateFile);
+  let installedSource = previousState?.installedSource;
+  let lastPort = previousState?.lastPort;
   const fail = (message) => {
-    writeHeadroomState(fs11, paths.headroomStateFile, { lastError: message });
+    writeHeadroomState(fs11, paths.headroomStateFile, {
+      lastError: message,
+      ...lastPort === void 0 ? {} : { lastPort }
+    });
     fs11.removeRecursive(paths.headroomLockFile);
     ports.log(`claude-use headroom supervisor: ${message}`);
     return 1;
   };
-  let installedSource = readHeadroomState(fs11, paths.headroomStateFile)?.installedSource;
   const ensureInstalled = () => {
     const version3 = ports.headroomVersion();
     const versionOk = version3 !== void 0 && versionSatisfies(version3, config2.source);
@@ -247511,8 +247574,13 @@ async function runSupervisor(config2, ports, options = {}) {
     return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
   }
   const version2 = ports.headroomVersion() ?? "unknown";
-  writeHeadroomState(fs11, paths.headroomStateFile, { supervisorPid: ports.ownPid, version: version2, installedSource });
+  writeHeadroomState(fs11, paths.headroomStateFile, { supervisorPid: ports.ownPid, version: version2, installedSource, ...lastPort === void 0 ? {} : { lastPort } });
   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 +247593,19 @@ 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,
+          ...lastPort === void 0 ? {} : { lastPort }
+        });
       }
       if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
         return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
@@ -247539,17 +247613,25 @@ async function runSupervisor(config2, ports, options = {}) {
       if (installedSource !== config2.source && !ensureInstalled()) {
         return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
       }
-      const port = await ports.freePort();
+      const previousSticky = lastPort;
+      const port = lastPort !== void 0 && await ports.isPortFree(lastPort) ? lastPort : await ports.freePort();
       const pid = ports.spawnHeadroom(port, allowlist);
       const ready = await waitUntilReady(ports, port);
       if (ready) {
         consecutiveFailures = 0;
         headroomPid = pid;
         runningHash = allowlistHash;
+        lastPort = port;
+        if (previousSticky !== void 0 && port !== previousSticky) {
+          ports.log(
+            `claude-use headroom supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(port)} (sessions launched against the old port are stale until they relaunch)`
+          );
+        }
         writeHeadroomState(fs11, paths.headroomStateFile, {
           supervisorPid: ports.ownPid,
           headroomPid: pid,
           port,
+          lastPort: port,
           version: version2,
           allowlistHash,
           installedSource: config2.source
@@ -247563,7 +247645,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 {
@@ -247585,14 +247667,17 @@ async function runSupervisor(config2, ports, options = {}) {
             `claude-use headroom supervisor: no sessions for ${String(config2.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
           );
           ports.stopProcess(headroomPid);
-          writeHeadroomState(fs11, paths.headroomStateFile, { version: version2 });
+          writeHeadroomState(fs11, paths.headroomStateFile, {
+            version: version2,
+            ...lastPort === void 0 ? {} : { lastPort }
+          });
           return 0;
         }
       } else {
         idleSince = void 0;
       }
     }
-    ports.sleep(HEADROOM_POLL_MS);
+    await ports.sleep(HEADROOM_POLL_MS);
   }
 }
 function allowlistOf(ports) {
@@ -247607,21 +247692,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),
@@ -247661,7 +247746,7 @@ function formatHeadroomStatus(status) {
 }
 async function realFreePort() {
   return await new Promise((resolve, reject) => {
-    const server2 = import_node_net.default.createServer();
+    const server2 = import_node_net2.default.createServer();
     server2.unref();
     server2.on("error", reject);
     server2.listen(0, "127.0.0.1", () => {
@@ -247677,18 +247762,27 @@ 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,
+    isPortFree: realIsPortFree,
     spawnHeadroom: (port, allowlist) => {
       import_node_fs9.default.mkdirSync(paths.logsDir, { recursive: true });
       const logFd = import_node_fs9.default.openSync(paths.headroomLogPath, "a");
@@ -247698,28 +247792,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 +247860,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 +247868,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 +248571,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.2",
+  "version": "2.5.4",
   "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>",