agent-shim 11.62.2 → 11.62.3

package/dist/cli.cjs

@@ -36471,7 +36471,6 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return 0;
   };
   for (; ; ) {
-    watchdog?.beat();
     if (ports.retire?.aborted === true) {
       return await retireByDrain();
     }
@@ -37032,7 +37031,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.62.2",
+      version: "11.62.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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -136861,12 +136860,19 @@ 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, cooldownStepMs, cooldownCapMs, startLockFile, awaitPidEnv, respawnGenerationEnv, delayEnv, nativeSample } = workerData;
+const { shared, boundMs, checkEveryMs, pauseWaitMs, stateFile, ownPid, action, logFile, respawn, respawnGeneration, respawnMaxGeneration, cooldownStepMs, cooldownCapMs, startLockFile, awaitPidEnv, respawnGenerationEnv, delayEnv, nativeSample, machineLoad } = workerData;
 const counter = new Int32Array(shared);
 let lastValue = Atomics.load(counter, 0);
 let lastChangeAt = Date.now();
 let lastCheckAt = Date.now();
+// The processor time the machine's load left the main thread since the counter last moved: what the bound is judged against.
+let scheduledMs = 0;
+// Set once a silence has outlasted the bound in wall time while the counted time has not, so the wait is logged once and its end is logged too.
+let waitingOutStarvation = false;
 let stopped = false;
+const readLoad = () => machineLoad === undefined ? { loadAverage: os.loadavg()[0], cpus: os.cpus().length } : machineLoad;
+const processorShare = (reading) => reading.loadAverage <= reading.cpus ? 1 : reading.cpus / reading.loadAverage;
+const describeLoad = (reading) => reading.loadAverage.toFixed(1) + " across " + String(reading.cpus) + " cpus";
 const record = (message) => {
   try {
     const existing = JSON.parse(fs.readFileSync(stateFile, "utf8"));
@@ -136886,6 +136892,7 @@ const log = (line) => {
     // Nowhere left to report a failed log write to; the process still has to end.
   }
 };
+const MS_PER_SECOND = 1000;
 // Enough of the stack to read the caller chain from the timer or socket callback down to the call that held the loop.
 const STACK_FRAMES_LOGGED = 12;
 // Asks the main thread where it is, through the inspector: a pause request interrupts JavaScript that is running (a loop, or a synchronous call that can be interrupted), so the top frames name what held the loop. A main thread that cannot be paused within the wait is not at such a point (it is idle in the event loop, which means it was not scheduled, or blocked inside a native call), and the answer says so rather than guessing. \`resume\` lets a thread that is not about to be killed run on again.
@@ -136981,22 +136988,37 @@ const spawnReplacement = () => {
     log("could not start a replacement door: " + (error instanceof Error ? error.message : String(error)));
   }
 };
-// Captures where a main thread that could not be paused is held natively, with the platform's own sampler, so a stall the inspector cannot name still leaves a stack to read. The wait is bounded by the sampling time plus its start-up, and the capture never delays the process ending beyond that.
+// Captures where a main thread that could not be paused is held natively, with the platform's own sampler, so a stall the inspector cannot name still leaves a stack to read. The wait is the sampling time plus the sampler's start-up and symbolication, stretched by the processor share the machine's load leaves it, and the capture never delays the process ending beyond that. The sampler writes its report only once it has finished, so one ended at the deadline, or one that failed, leaves no file, and the log says which rather than naming a file that is not there.
 const takeNativeSample = () => new Promise((resolve) => {
   if (nativeSample === undefined) { resolve(); return; }
   try {
     fs.mkdirSync(nativeSample.directory, { recursive: true });
     const file = require("node:path").join(nativeSample.directory, String(ownPid) + ".txt");
     const args = nativeSample.args.map((arg) => arg.replace("{pid}", String(ownPid)).replace("{seconds}", String(nativeSample.seconds)).replace("{file}", file));
-    const child = require("node:child_process").spawn(nativeSample.command, args, { stdio: "ignore" });
-    const giveUp = setTimeout(() => { child.kill(); log("the native sampler did not finish in time"); resolve(); }, (nativeSample.seconds + 2) * 1000);
-    child.once("error", (error) => { clearTimeout(giveUp); log("could not sample the main thread natively: " + error.message); resolve(); });
-    child.once("close", () => {
+    const child = require("node:child_process").spawn(nativeSample.command, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    let settled = false;
+    const settle = (line) => {
+      if (settled) return;
+      settled = true;
       clearTimeout(giveUp);
-      log("native stack of the blocked main thread written to " + file);
+      log(line);
+      resolve();
+    };
+    const deadlineMs = Math.ceil((nativeSample.seconds * MS_PER_SECOND + nativeSample.overheadMs) / processorShare(readLoad()));
+    const giveUp = setTimeout(() => { child.kill(); settle("the native sampler did not finish within " + String(deadlineMs) + "ms, so no native stack was written"); }, deadlineMs);
+    child.once("error", (error) => { settle("could not sample the main thread natively: " + error.message); });
+    child.once("close", (code, signal) => {
+      if (code !== 0 || !fs.existsSync(file)) {
+        const detail = stderr.trim();
+        settle("the native sampler " + (signal === null ? "exited with status " + String(code) : "was ended by " + signal) + " and wrote no native stack" + (detail === "" ? "" : ": " + detail));
+        return;
+      }
       const kept = fs.readdirSync(nativeSample.directory).filter((name) => name.endsWith(".txt")).map((name) => ({ name, at: fs.statSync(require("node:path").join(nativeSample.directory, name)).mtimeMs })).sort((a, b) => b.at - a.at);
       for (const old of kept.slice(nativeSample.keep)) fs.rmSync(require("node:path").join(nativeSample.directory, old.name), { force: true });
-      resolve();
+      settle("native stack of the blocked main thread written to " + file);
     });
   } catch (error) {
     log("could not sample the main thread natively: " + (error instanceof Error ? error.message : String(error)));
@@ -137010,29 +137032,40 @@ const timer = setInterval(() => {
   lastCheckAt = now;
   const value = Atomics.load(counter, 0);
   if (value !== lastValue || sinceLastCheck > checkEveryMs * 2) {
+    if (waitingOutStarvation && value !== lastValue) log("the front door's event loop ran again after " + String(now - lastChangeAt) + "ms; the machine's load had starved it, so the watchdog kept the door");
+    waitingOutStarvation = false;
     lastValue = value;
     lastChangeAt = now;
+    scheduledMs = 0;
     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";
-    stopped = true;
-    clearInterval(timer);
-    record(message);
-    log(message);
-    const [oneMinute, fiveMinutes, fifteenMinutes] = os.loadavg();
-    log("machine load at the stall: " + oneMinute.toFixed(1) + " (1m), " + fiveMinutes.toFixed(1) + " (5m), " + fifteenMinutes.toFixed(1) + " (15m) across " + String(os.cpus().length) + " cpus");
-    spawnReplacement();
-    describeMainThread(pauseWaitMs, action !== "kill-process").then(async (where) => {
-      log(where);
-      if (where.startsWith("the main thread could not be paused")) await takeNativeSample();
-      if (action === "kill-process") {
-        process.kill(ownPid, "SIGKILL");
-      } else {
-        parentPort.postMessage({ stalled: true, message });
-      }
-    });
+  const reading = readLoad();
+  scheduledMs += sinceLastCheck * processorShare(reading);
+  const silentMs = now - lastChangeAt;
+  if (scheduledMs < boundMs) {
+    if (silentMs >= boundMs && !waitingOutStarvation) {
+      waitingOutStarvation = true;
+      log("the front door's event loop has not run for " + String(silentMs) + "ms, but the machine's load (" + describeLoad(reading) + ") left it only " + String(Math.round(scheduledMs)) + "ms of processor time, so the watchdog waits until it has had " + String(boundMs) + "ms rather than replacing a door the machine did not schedule");
+    }
+    return;
   }
+  const message = "the front door's event loop did not run for " + String(silentMs) + "ms, " + String(Math.round(scheduledMs)) + "ms of it with a processor to run on; its watchdog ended the process so the next launch starts a fresh door on the same ports";
+  stopped = true;
+  clearInterval(timer);
+  record(message);
+  log(message);
+  const [oneMinute, fiveMinutes, fifteenMinutes] = os.loadavg();
+  log("machine load at the stall: " + oneMinute.toFixed(1) + " (1m), " + fiveMinutes.toFixed(1) + " (5m), " + fifteenMinutes.toFixed(1) + " (15m) across " + String(os.cpus().length) + " cpus");
+  spawnReplacement();
+  describeMainThread(pauseWaitMs, action !== "kill-process").then(async (where) => {
+    log(where);
+    if (where.startsWith("the main thread could not be paused")) await takeNativeSample();
+    if (action === "kill-process") {
+      process.kill(ownPid, "SIGKILL");
+    } else {
+      parentPort.postMessage({ stalled: true, message });
+    }
+  });
 }, checkEveryMs);
 parentPort.on("message", (message) => {
   if (message === "stop") {
@@ -137047,9 +137080,13 @@ 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, cooldownStepMs: params.cooldownStepMs, cooldownCapMs: params.cooldownCapMs, startLockFile: params.startLockFile, awaitPidEnv: DOOR_AWAIT_PID_ENV, respawnGenerationEnv: DOOR_RESPAWN_GENERATION_ENV, delayEnv: DOOR_RESPAWN_DELAY_ENV, nativeSample: params.nativeSample }
+    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, cooldownStepMs: params.cooldownStepMs, cooldownCapMs: params.cooldownCapMs, startLockFile: params.startLockFile, awaitPidEnv: DOOR_AWAIT_PID_ENV, respawnGenerationEnv: DOOR_RESPAWN_GENERATION_ENV, delayEnv: DOOR_RESPAWN_DELAY_ENV, nativeSample: params.nativeSample, machineLoad: params.machineLoad }
   });
   worker.unref();
+  const beat = setInterval(() => {
+    Atomics.add(counter, 0, 1);
+  }, params.checkEveryMs);
+  beat.unref();
   worker.on("message", (message) => {
     if (typeof message === "object" && message !== null && "message" in message && typeof message.message === "string") {
       params.onReport?.(message.message);
@@ -137057,20 +137094,21 @@ function startThreadWatchdog(params) {
   });
   let stopped = false;
   return {
-    beat: () => {
-      Atomics.add(counter, 0, 1);
-    },
     stop: () => {
       if (stopped) {
         return;
       }
       stopped = true;
+      clearInterval(beat);
       worker.postMessage("stop");
       void worker.terminate();
     }
   };
 }
 
+// src/frontdoor/commands.ts
+init_probe();
+
 // src/frontdoor/status.ts
 init_socket();
 init_state2();
@@ -137656,7 +137694,7 @@ function realFrontDoorSupervisorPorts(paths, respawnGeneration, retire, trackTun
       cooldownStepMs: DOOR_STALL_BOUND_MS,
       cooldownCapMs: DOOR_RESPAWN_COOLDOWN_CAP_MS,
       startLockFile: paths.frontdoorLockFile,
-      ...process.platform === "darwin" ? { nativeSample: { command: MACOS_SAMPLER, args: ["{pid}", "{seconds}", "-file", "{file}"], directory: import_node_path52.default.join(import_node_path52.default.dirname(paths.frontdoorLogPath), "stall-samples"), seconds: Math.max(1, Math.ceil(DOOR_WATCHDOG_CHECK_MS / MS_PER_SECOND16)), keep: DOOR_RESPAWN_MAX_GENERATIONS + 1 } } : {}
+      ...process.platform === "darwin" ? { nativeSample: { command: MACOS_SAMPLER, args: ["{pid}", "{seconds}", "-file", "{file}"], directory: import_node_path52.default.join(import_node_path52.default.dirname(paths.frontdoorLogPath), "stall-samples"), seconds: Math.max(1, Math.ceil(DOOR_WATCHDOG_CHECK_MS / MS_PER_SECOND16)), overheadMs: PROBE_TIMEOUT_MS, keep: DOOR_RESPAWN_MAX_GENERATIONS + 1 } } : {}
     }),
     // 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

@@ -4135,7 +4135,6 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return 0;
   };
   for (; ; ) {
-    watchdog?.beat();
     if (ports.retire?.aborted === true) {
       return await retireByDrain();
     }
@@ -4652,7 +4651,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.62.2",
+      version: "11.62.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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",

package/dist/index.mjs

@@ -4112,7 +4112,6 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     return 0;
   };
   for (; ; ) {
-    watchdog?.beat();
     if (ports.retire?.aborted === true) {
       return await retireByDrain();
     }
@@ -4628,7 +4627,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.62.2",
+      version: "11.62.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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",

package/dist/types/index.d.ts

@@ -23869,10 +23869,8 @@ 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. */
+/** What the supervisor holds: a stop for when it begins to retire. The beat that tells the watchdog the main event loop ran comes from the watchdog's own timer on that loop (see `startThreadWatchdog`), not from the supervisor's tick, so nothing a tick awaits (a `ps` run a loaded machine is slow to finish) is taken for a loop that did not run. */
 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;
 }
@@ -23929,7 +23927,7 @@ interface FrontDoorSupervisorPorts {
      */
     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.
+     * 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. It beats from its own timer on the main loop rather than from the tick, so a tick waiting on a slow `ps` is never taken for a loop that stopped, and the supervisor 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;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-shim",
-  "version": "11.62.2",
+  "version": "11.62.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": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",