claude-use 11.6.2 → 11.7.0

package/dist/cli.cjs

@@ -34007,7 +34007,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.6.2",
+      version: "11.7.0",
       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>",
@@ -114230,6 +114230,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
   ports.doorHealth.generation({ providerPort: http8.port, connectPort: connect3.port, directPort: direct.port });
   fs23.removeRecursive(paths.frontdoorLockFile);
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http8.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
+  const watchdog = ports.startWatchdog?.();
   let idleSince;
   let ticks = 0;
   const supersedingOwner = () => {
@@ -114243,6 +114244,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return current !== void 0 && servingBinary !== void 0 && (current.dev !== servingBinary.dev || current.ino !== servingBinary.ino || current.size !== servingBinary.size || current.mtimeMs !== servingBinary.mtimeMs);
   };
   const closeServing = async () => {
+    watchdog?.stop();
     await direct.close();
     await connect3.close();
     await http8.close();
@@ -114257,7 +114259,9 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return 0;
   };
   for (; ; ) {
+    watchdog?.beat();
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
+      watchdog?.stop();
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
@@ -130991,6 +130995,93 @@ function createRcStreamHub(deps) {
   };
 }
 
+// src/frontdoor/watchdog.ts
+var import_node_worker_threads2 = require("node:worker_threads");
+init_ensure2();
+init_probe();
+var DOOR_STALL_BOUND_MS = 2 * FRONTDOOR_PROBE_ATTEMPTS * PROBE_TIMEOUT_MS;
+var CHECKS_PER_PROBE_DEADLINE = 2;
+var DOOR_WATCHDOG_CHECK_MS = PROBE_TIMEOUT_MS / CHECKS_PER_PROBE_DEADLINE;
+var WATCHDOG_SOURCE = `
+const { workerData, parentPort } = require("node:worker_threads");
+const fs = require("node:fs");
+const { shared, boundMs, checkEveryMs, stateFile, ownPid, action } = workerData;
+const counter = new Int32Array(shared);
+let lastValue = Atomics.load(counter, 0);
+let lastChangeAt = Date.now();
+let lastCheckAt = Date.now();
+let stopped = false;
+const record = (message) => {
+  try {
+    const existing = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    const next = Object.assign({}, existing, { lastError: message });
+    const temporary = stateFile + "." + String(ownPid) + ".watchdog";
+    fs.writeFileSync(temporary, JSON.stringify(next, null, 2) + "\\n", { mode: 0o600 });
+    fs.renameSync(temporary, stateFile);
+  } catch (error) {
+    // The state file is a courtesy to whoever looks next; the process still has to end.
+  }
+};
+const timer = setInterval(() => {
+  if (stopped) return;
+  const now = Date.now();
+  const sinceLastCheck = now - lastCheckAt;
+  lastCheckAt = now;
+  const value = Atomics.load(counter, 0);
+  if (value !== lastValue || sinceLastCheck > checkEveryMs * 2) {
+    lastValue = value;
+    lastChangeAt = now;
+    return;
+  }
+  if (now - lastChangeAt >= boundMs) {
+    const message = "the front door's event loop did not run for " + String(now - lastChangeAt) + "ms; its watchdog ended the process so the next launch starts a fresh door on the same ports";
+    record(message);
+    stopped = true;
+    clearInterval(timer);
+    if (action === "kill-process") {
+      process.kill(ownPid, "SIGKILL");
+    } else {
+      parentPort.postMessage({ stalled: true, message });
+    }
+  }
+}, checkEveryMs);
+parentPort.on("message", (message) => {
+  if (message === "stop") {
+    stopped = true;
+    clearInterval(timer);
+    process.exit(0);
+  }
+});
+`;
+function startThreadWatchdog(params) {
+  const shared = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
+  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, stateFile: params.stateFile, ownPid: params.ownPid, action: params.action }
+  });
+  worker.unref();
+  worker.on("message", (message) => {
+    if (typeof message === "object" && message !== null && "message" in message && typeof message.message === "string") {
+      params.onReport?.(message.message);
+    }
+  });
+  let stopped = false;
+  return {
+    beat: () => {
+      Atomics.add(counter, 0, 1);
+    },
+    stop: () => {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      worker.postMessage("stop");
+      void worker.terminate();
+    }
+  };
+}
+
 // src/frontdoor/status.ts
 init_socket();
 init_state2();
@@ -131482,6 +131573,7 @@ function realFrontDoorSupervisorPorts(paths) {
       return { port: handle.port, close: handle.close };
     },
     closeRcStreamHub: rcHub.close,
+    startWatchdog: () => startThreadWatchdog({ stateFile: paths.frontdoorStateFile, ownPid: process.pid, boundMs: DOOR_STALL_BOUND_MS, checkEveryMs: DOOR_WATCHDOG_CHECK_MS, action: "kill-process" }),
     // 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,
     doorHealth,

package/dist/index.cjs

@@ -2787,7 +2787,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.6.2",
+      version: "11.7.0",
       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>",
@@ -9512,6 +9512,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
   ports.doorHealth.generation({ providerPort: http3.port, connectPort: connect3.port, directPort: direct.port });
   fs12.removeRecursive(paths.frontdoorLockFile);
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http3.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
+  const watchdog = ports.startWatchdog?.();
   let idleSince;
   let ticks = 0;
   const supersedingOwner = () => {
@@ -9525,6 +9526,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return current !== void 0 && servingBinary !== void 0 && (current.dev !== servingBinary.dev || current.ino !== servingBinary.ino || current.size !== servingBinary.size || current.mtimeMs !== servingBinary.mtimeMs);
   };
   const closeServing = async () => {
+    watchdog?.stop();
     await direct.close();
     await connect3.close();
     await http3.close();
@@ -9539,7 +9541,9 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return 0;
   };
   for (; ; ) {
+    watchdog?.beat();
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
+      watchdog?.stop();
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;

package/dist/index.mjs

@@ -2763,7 +2763,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.6.2",
+      version: "11.7.0",
       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>",
@@ -9099,6 +9099,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
   ports.doorHealth.generation({ providerPort: http3.port, connectPort: connect3.port, directPort: direct.port });
   fs12.removeRecursive(paths.frontdoorLockFile);
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http3.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
+  const watchdog = ports.startWatchdog?.();
   let idleSince;
   let ticks = 0;
   const supersedingOwner = () => {
@@ -9112,6 +9113,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return current !== void 0 && servingBinary !== void 0 && (current.dev !== servingBinary.dev || current.ino !== servingBinary.ino || current.size !== servingBinary.size || current.mtimeMs !== servingBinary.mtimeMs);
   };
   const closeServing = async () => {
+    watchdog?.stop();
     await direct.close();
     await connect3.close();
     await http3.close();
@@ -9126,7 +9128,9 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return 0;
   };
   for (; ; ) {
+    watchdog?.beat();
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
+      watchdog?.stop();
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;

package/dist/types/index.d.ts

@@ -12555,6 +12555,14 @@ declare function ensureFrontDoor(params: {
     readonly token: string;
 };
 
+/** What the supervisor holds: a beat from each tick of its main loop, and a stop when it begins to retire. */
+interface DoorWatchdog {
+    /** Records that the main event loop ran. Called from the supervisor's tick, which only runs while the loop serves. */
+    readonly beat: () => void;
+    /** Ends the watchdog before the door begins an orderly retirement, so a slow close is never taken for a stall. Idempotent. */
+    readonly stop: () => void;
+}
+
 /** A bound front-door listener in this process, and how to stop it. */
 interface FrontDoorListenerHandle {
     readonly port: number;
@@ -12600,6 +12608,10 @@ interface FrontDoorSupervisorPorts {
      * Stops the Remote Control stream hub: persists every live attachment's sequence cursor synchronously, then frees the dials. Called exactly once on every exit the supervisor owns, after every listener it started is down (a live listener could still settle an observed Remote Control exchange, and the reconcile that follows would re-attach a stream the close had just ended) and before the final state write and the process's exit.
      */
     readonly closeRcStreamHub: () => void;
+    /**
+     * Starts the watchdog that ends this process when its main event loop stops running: it lives on its own thread, so a loop that is blocked cannot stall it. The supervisor beats it every tick and stops it before it begins to retire, so it only ever judges a door that is meant to be serving. Optional because ending the process is only right when the process is the door: the CLI's `__frontdoor-supervisor` supplies it, and a library host that runs the door inside its own process does not get its application killed by default.
+     */
+    readonly startWatchdog?: () => DoorWatchdog;
     /**
      * Reports one tick's session-registry facts to the door's event backbone: the sessions the tick's listing saw (taken before the prune, so a pruned launch's record is still there to name its start time) and the pids the tick's prune removed. The launch lifecycle publisher turns the diff between ticks into source-tagged events; the listing is also this loop's own idle input, so the two read one fact instead of two.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "11.6.2",
+  "version": "11.7.0",
   "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>",