claude-use 11.44.3 → 11.44.5

package/dist/cli.cjs

@@ -34701,7 +34701,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.44.3",
+      version: "11.44.5",
       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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -115419,7 +115419,7 @@ function collectCodexStatus(fsPort, paths, isRunning) {
     usageSnapshotPath: codexUsageSnapshotPath(),
     usageSnapshotExists: fsPort.readFileUtf8(codexUsageSnapshotPath()) !== void 0,
     logPath: paths.frontdoorLogPath,
-    logExists: fsPort.readFileUtf8(paths.frontdoorLogPath) !== void 0
+    logExists: fsPort.lstat(paths.frontdoorLogPath) !== void 0
   };
 }
 function formatSignIn(signIn) {
@@ -119379,6 +119379,8 @@ function frontDoorRcControl(transport, token) {
 var HEALTH_TIMEOUT_MS = 2e3;
 var HEALTH_START_BUDGET_MS = 5e3;
 var HEALTH_RETRY_MS = 50;
+var PREFERRED_PORT_MAX_ATTEMPTS = 6;
+var PREFERRED_PORT_RETRY_MS = 50;
 function createFrontDoorServer(pipeline, log, tls2, control, apis) {
   const handler = (request7, response) => {
     if (request7.method === "GET" && request7.url === "/healthz") {
@@ -119474,16 +119476,25 @@ async function listenFrontDoor(server, options = {}) {
       resolve2(bound2);
     });
   });
-  let bound;
-  if (preferredPort !== void 0) {
-    try {
-      bound = await tryListen(preferredPort);
-    } catch {
-      bound = await tryListen(0);
+  const bindListener = async () => {
+    if (preferredPort === void 0) {
+      return await tryListen(0);
     }
-  } else {
-    bound = await tryListen(0);
-  }
+    for (let attempt = 1; attempt <= PREFERRED_PORT_MAX_ATTEMPTS; attempt += 1) {
+      try {
+        return await tryListen(preferredPort);
+      } catch {
+        if (attempt === PREFERRED_PORT_MAX_ATTEMPTS) {
+          return await tryListen(0);
+        }
+        await new Promise((resolve2) => {
+          setTimeout(resolve2, PREFERRED_PORT_RETRY_MS);
+        });
+      }
+    }
+    return await tryListen(0);
+  };
+  const bound = await bindListener();
   options.onBound?.(bound);
   if (options.onError !== void 0) {
     server.on("error", options.onError);
@@ -135064,7 +135075,7 @@ const { workerData, parentPort } = require("node:worker_threads");
 const fs = require("node:fs");
 const os = require("node:os");
 const inspector = require("node:inspector");
-const { shared, boundMs, checkEveryMs, pauseWaitMs, stateFile, ownPid, action, logFile, respawn, respawnGeneration, respawnMaxGeneration, awaitPidEnv, respawnGenerationEnv } = workerData;
+const { shared, boundMs, checkEveryMs, pauseWaitMs, stateFile, ownPid, action, logFile, respawn, respawnGeneration, respawnMaxGeneration, startLockFile, awaitPidEnv, respawnGenerationEnv } = workerData;
 const counter = new Int32Array(shared);
 let lastValue = Atomics.load(counter, 0);
 let lastChangeAt = Date.now();
@@ -135128,17 +135139,59 @@ const describeMainThread = (waitMs, resume) => new Promise((resolve) => {
     finish("the main thread could not be inspected: " + (error instanceof Error ? error.message : String(error)));
   }
 });
+// Whether a process is alive: signal 0 only tests, and EPERM means it exists under another user.
+const isRunning = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+// The pid holding the start lock when that holder is alive, which means a door is already being started and another must not be: the launcher's ensure and this respawn are the two things that start a door, and the lock is the one protocol that keeps them from starting two. A dead holder's lock is litter and is cleared, exactly as the launcher's ensure clears it.
+const liveLockHolder = () => {
+  let holder;
+  try {
+    holder = JSON.parse(fs.readFileSync(startLockFile, "utf8")).pid;
+  } catch (error) {
+    return undefined;
+  }
+  if (typeof holder === "number" && isRunning(holder)) return holder;
+  fs.rmSync(startLockFile, { force: true });
+  return undefined;
+};
+// Creates the lock naming the replacement as its holder, atomically (the wx flag), so the launcher's ensure sees a live holder while the replacement boots and waits for it instead of starting a door of its own; the replacement removes the lock once it is serving, as every door does.
+const claimStartLock = (holder) => {
+  try {
+    fs.writeFileSync(startLockFile, JSON.stringify({ pid: holder, at: Date.now() }) + "\\n", { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+};
 const spawnReplacement = () => {
   if (respawn === undefined || logFile === undefined) return;
   if (respawnGeneration >= respawnMaxGeneration) {
     log("not starting another replacement: this door was replacement generation " + String(respawnGeneration) + " of " + String(respawnMaxGeneration) + ", so the stall has recurred through consecutive doors and the machine, not the door, is the one refusing to serve; leaving the next launch's ensure to start one");
     return;
   }
+  const startingBy = liveLockHolder();
+  if (startingBy !== undefined) {
+    log("not starting a replacement: process " + String(startingBy) + " holds the start lock, so a door is already being started and a second one would race it for the sticky ports");
+    return;
+  }
   try {
     const out = fs.openSync(logFile, "a");
     const child = require("node:child_process").spawn(respawn.command, respawn.args, { detached: true, stdio: ["ignore", out, out], env: Object.assign({}, respawn.env, { [awaitPidEnv]: String(ownPid), [respawnGenerationEnv]: String(respawnGeneration + 1) }) });
     child.unref();
     fs.closeSync(out);
+    if (!claimStartLock(child.pid)) {
+      // A launcher took the lock between the check and the spawn, so its door is the one that is starting: this one must not also bind.
+      process.kill(child.pid, "SIGKILL");
+      log("withdrew replacement door " + String(child.pid) + ": a launcher took the start lock first and its door is the one starting");
+      return;
+    }
     log("started replacement door " + String(child.pid) + " of generation " + String(respawnGeneration + 1) + ", which binds once this process is gone");
   } catch (error) {
     log("could not start a replacement door: " + (error instanceof Error ? error.message : String(error)));
@@ -135187,7 +135240,7 @@ function startThreadWatchdog(params) {
   const counter = new Int32Array(shared);
   const worker = new import_node_worker_threads2.Worker(WATCHDOG_SOURCE, {
     eval: true,
-    workerData: { shared, boundMs: params.boundMs, checkEveryMs: params.checkEveryMs, pauseWaitMs: params.pauseWaitMs, stateFile: params.stateFile, ownPid: params.ownPid, action: params.action, logFile: params.logFile, respawn: params.respawn, respawnGeneration: params.respawnGeneration, respawnMaxGeneration: params.respawnMaxGeneration, awaitPidEnv: DOOR_AWAIT_PID_ENV, respawnGenerationEnv: DOOR_RESPAWN_GENERATION_ENV }
+    workerData: { shared, boundMs: params.boundMs, checkEveryMs: params.checkEveryMs, pauseWaitMs: params.pauseWaitMs, stateFile: params.stateFile, ownPid: params.ownPid, action: params.action, logFile: params.logFile, respawn: params.respawn, respawnGeneration: params.respawnGeneration, respawnMaxGeneration: params.respawnMaxGeneration, startLockFile: params.startLockFile, awaitPidEnv: DOOR_AWAIT_PID_ENV, respawnGenerationEnv: DOOR_RESPAWN_GENERATION_ENV }
   });
   worker.unref();
   worker.on("message", (message) => {
@@ -135227,7 +135280,7 @@ function collectFrontDoorStatus(fsPort, socketTrust, paths, isRunning) {
     sessions: listFrontDoorSessions(fsPort, paths.frontdoorSessionsDir).map((session) => ({ ...session, alive: isRunning(session.pid) })),
     headroomSocket: headroomSocketTarget(fsPort, socketTrust, paths),
     logPath: paths.frontdoorLogPath,
-    logExists: fsPort.readFileUtf8(paths.frontdoorLogPath) !== void 0
+    logExists: fsPort.lstat(paths.frontdoorLogPath) !== void 0
   };
 }
 function formatFrontDoorStatus(status, caCertPath) {
@@ -135763,7 +135816,8 @@ function realFrontDoorSupervisorPorts(paths, respawnGeneration) {
       logFile: paths.frontdoorLogPath,
       respawn: respawnInvocation(paths),
       respawnGeneration,
-      respawnMaxGeneration: DOOR_RESPAWN_MAX_GENERATIONS
+      respawnMaxGeneration: DOOR_RESPAWN_MAX_GENERATIONS,
+      startLockFile: paths.frontdoorLockFile
     }),
     // The launch lifecycle publisher over the same backbone the typed API serves: the tick's registry facts go in here, and the door's own register, prune and end moments come out as source-tagged events.
     observeLaunchRegistry: createLaunchEventPublisher(doorEvents, () => Date.now()).observe,
@@ -147003,7 +147057,7 @@ function collectHeadroomStatus(fsPort, paths, processes) {
     settings: settings2,
     settingsDrifted: state.settingsHash !== void 0 && state.settingsHash !== hashSettings(settings2),
     logPath: paths.headroomLogPath,
-    logExists: fsPort.readFileUtf8(paths.headroomLogPath) !== void 0
+    logExists: fsPort.lstat(paths.headroomLogPath) !== void 0
   };
 }
 function formatHeadroomStatus(status) {

package/dist/index.cjs

@@ -3151,7 +3151,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.44.3",
+      version: "11.44.5",
       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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -17729,7 +17729,7 @@ function collectFrontDoorStatus(fsPort, socketTrust, paths, isRunning) {
     sessions: listFrontDoorSessions(fsPort, paths.frontdoorSessionsDir).map((session) => ({ ...session, alive: isRunning(session.pid) })),
     headroomSocket: headroomSocketTarget(fsPort, socketTrust, paths),
     logPath: paths.frontdoorLogPath,
-    logExists: fsPort.readFileUtf8(paths.frontdoorLogPath) !== void 0
+    logExists: fsPort.lstat(paths.frontdoorLogPath) !== void 0
   };
 }
 function formatFrontDoorStatus(status, caCertPath) {

package/dist/index.mjs

@@ -3127,7 +3127,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.44.3",
+      version: "11.44.5",
       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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -17316,7 +17316,7 @@ function collectFrontDoorStatus(fsPort, socketTrust, paths, isRunning) {
     sessions: listFrontDoorSessions(fsPort, paths.frontdoorSessionsDir).map((session) => ({ ...session, alive: isRunning(session.pid) })),
     headroomSocket: headroomSocketTarget(fsPort, socketTrust, paths),
     logPath: paths.frontdoorLogPath,
-    logExists: fsPort.readFileUtf8(paths.frontdoorLogPath) !== void 0
+    logExists: fsPort.lstat(paths.frontdoorLogPath) !== void 0
   };
 }
 function formatFrontDoorStatus(status, caCertPath) {

package/dist/types/index.d.ts

@@ -2648,7 +2648,7 @@ declare class UsageError extends CliError {
 type ConfigFileReader = (filepath: string) => unknown;
 
 /** The filesystem operations headroom coordination needs: the same shape as `FarmFs`, injected so every decision over state, sessions, and the start lock runs against an in-memory fake in tests. */
-type HeadroomFs = Pick<FarmFs, "mkdirp" | "mkdirPrivate" | "readFileUtf8" | "writeFileUtf8" | "writeFilePrivate" | "writeFileExclusive" | "readdir" | "removeRecursive">;
+type HeadroomFs = Pick<FarmFs, "lstat" | "mkdirp" | "mkdirPrivate" | "readFileUtf8" | "writeFileUtf8" | "writeFilePrivate" | "writeFileExclusive" | "readdir" | "removeRecursive">;
 
 /**
  * The record held in one front-door session-registry file: the launcher's pid plus the per-launch capability token its child presents on every request, and the supervisor of the door the launch was sent to. `sessionId` is the id the launch's requests carry in their session header, and `models` the models block this launch resolved when its directory, profile or committed file added definitions of its own to the global block (absent otherwise, so the door follows the global block live). `supervisorPid` is absent on a record written before it existed and on a door's own transparent-surface record; such a launch cannot be attributed to a door, so a superseded door treats it as its own.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "11.44.3",
+  "version": "11.44.5",
   "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": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",