claude-use 11.44.4 → 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.4",
+      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>",
@@ -135075,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();
@@ -135139,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)));
@@ -135198,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) => {
@@ -135774,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,

package/dist/index.cjs

@@ -3151,7 +3151,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.44.4",
+      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>",

package/dist/index.mjs

@@ -3127,7 +3127,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.44.4",
+      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>",