claude-use 11.67.2 → 11.67.4

package/dist/cli.cjs

@@ -37387,7 +37387,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.67.2",
+      version: "11.67.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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -66349,27 +66349,27 @@ var init_ensure2 = __esm({
 });
 
 // src/frontdoor/probe.ts
-function probeFrontDoorSync(port, caPem) {
+function probeFrontDoorSync(port, caPem, timeoutMs = PROBE_TIMEOUT_MS) {
   refuseToBlockInRole("a synchronous probe of the front door");
-  return runProbeWorker(PROBE_SOURCE, { port, ca: caPem });
+  return runProbeWorker(PROBE_SOURCE, { port, ca: caPem }, timeoutMs);
 }
-function probeListenerAcceptSync(port) {
+function probeListenerAcceptSync(port, timeoutMs = PROBE_TIMEOUT_MS) {
   refuseToBlockInRole("a synchronous probe of a front door listener");
-  return runProbeWorker(ACCEPT_PROBE_SOURCE, { port });
+  return runProbeWorker(ACCEPT_PROBE_SOURCE, { port }, timeoutMs);
 }
-function runProbeWorker(source, data) {
+function runProbeWorker(source, data, timeoutMs) {
   const shared = new SharedArrayBuffer(HEADER_SLOTS * INT32_BYTES + REASON_BYTES);
   const header = new Int32Array(shared, 0, HEADER_SLOTS);
   const worker = new import_node_worker_threads.Worker(source, {
     eval: true,
-    workerData: { ...data, timeoutMs: PROBE_TIMEOUT_MS, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
+    workerData: { ...data, timeoutMs, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
   });
   worker.unref();
   try {
-    const waited = Atomics.wait(header, 0, VERDICT_PENDING, PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS);
+    const waited = Atomics.wait(header, 0, VERDICT_PENDING, timeoutMs + PROBE_WAIT_MARGIN_MS);
     const verdict = Atomics.load(header, 0);
     if (waited === "timed-out" || verdict === VERDICT_PENDING) {
-      return { ok: false, reason: `the probe did not finish within ${String(PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS)}ms` };
+      return { ok: false, reason: `the probe did not finish within ${String(timeoutMs + PROBE_WAIT_MARGIN_MS)}ms` };
     }
     if (verdict === VERDICT_OK) {
       return { ok: true };
@@ -119565,8 +119565,8 @@ function unregisterSupervised(fs31, paths, pool, sessionId) {
   fs31.removeRecursive(sessionFileOf(paths, pool, sessionId));
   fs31.removeRecursive(sessionStatePath(paths, pool, sessionId));
 }
-function liveSupervised(fs31, paths, pool, isRunning) {
-  const live = [];
+function listSupervised(fs31, paths, pool) {
+  const listed = [];
   for (const name of fs31.readdir(sessionsDirOf(paths, pool))) {
     const file2 = import_node_path36.default.join(sessionsDirOf(paths, pool), name);
     const raw = fs31.readFileUtf8(file2);
@@ -119580,8 +119580,19 @@ function liveSupervised(fs31, paths, pool, isRunning) {
       fs31.removeRecursive(file2);
       continue;
     }
-    if (parsed.success && isRunning(parsed.data.pid)) {
-      live.push(parsed.data);
+    if (parsed.success) {
+      listed.push({ file: file2, session: parsed.data });
+    } else {
+      fs31.removeRecursive(file2);
+    }
+  }
+  return listed;
+}
+function liveSupervised(fs31, paths, pool, isRunning) {
+  const live = [];
+  for (const { file: file2, session } of listSupervised(fs31, paths, pool)) {
+    if (isRunning(session.pid)) {
+      live.push(session);
     } else {
       fs31.removeRecursive(file2);
     }
@@ -119631,15 +119642,17 @@ function readModelMove(fs31, paths, sessionId) {
 function removeModelMove(fs31, paths, sessionId) {
   fs31.removeRecursive(import_node_path36.default.join(paths.modelMovesDir, `${sessionId}.json`));
 }
-function supervisedSessionOf(fs31, paths, sessionId, isRunning) {
-  for (const pool of fs31.readdir(paths.superviseDir)) {
-    const sessions = liveSupervised(fs31, paths, pool, isRunning);
-    const found = sessions.find((session) => session.sessionId === sessionId);
-    if (found !== void 0) {
-      return found;
+async function supervisedSessionOf(fs31, paths, sessionId, runningAmong) {
+  const listed = fs31.readdir(paths.superviseDir).flatMap((pool) => listSupervised(fs31, paths, pool));
+  const running = await runningAmong(listed.map(({ session }) => session.pid));
+  const live = listed.filter(({ file: file2, session }) => {
+    if (running.has(session.pid)) {
+      return true;
     }
-  }
-  return void 0;
+    fs31.removeRecursive(file2);
+    return false;
+  });
+  return live.find(({ session }) => session.sessionId === sessionId)?.session;
 }
 
 // src/selection/targetStore.ts
@@ -136103,7 +136116,7 @@ function createProviderRouteResolver(deps) {
         const account = scan2.model === void 0 ? void 0 : resolveAccountTarget(scan2.model, deps.models?.(current.session));
         if (account !== void 0) {
           const sessionId = current.session.sessionId ?? "";
-          const moved = sessionId !== "" && (deps.accountMoves?.(sessionId, account.identity, account.model) ?? false);
+          const moved = sessionId !== "" && (await deps.accountMoves?.(sessionId, account.identity, account.model) ?? false);
           return {
             ok: false,
             status: HTTP_STATUS.badRequest,
@@ -139648,8 +139661,8 @@ function realFrontDoorSupervisorPorts(paths, respawnGeneration, lifecycle, track
       usageSnapshotOf: (identity) => identity === void 0 ? void 0 : routingSnapshots.get(identity) ?? readUsageSnapshot(realFarmFs, paths.usageSnapshotsDir, identity),
       // An `acct:` model member is served by relaunch: the door leaves a move request for the session's supervisor (found across every pool's registry, since the door does not know which pool launched the session) and answers the request with what is happening. A session nothing supervises gets the message naming the command to run instead.
       observations: (target) => observations.observation(target),
-      accountMoves: (sessionId, to2, model) => {
-        if (supervisedSessionOf(realFarmFs, paths, sessionId, realIsProcessRunning) === void 0) {
+      accountMoves: async (sessionId, to2, model) => {
+        if (await supervisedSessionOf(realFarmFs, paths, sessionId, realRunningAmong) === void 0) {
           return false;
         }
         writeModelMove(realFarmFs, paths, { sessionId, to: to2, model, at: (/* @__PURE__ */ new Date()).toISOString() });
@@ -140315,6 +140328,10 @@ function windowsOf(states, nowMs) {
 function isObject4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
+function isoOf(ms2) {
+  const instant = new Date(ms2);
+  return Number.isNaN(instant.getTime()) ? void 0 : instant.toISOString();
+}
 function payloadWindow(rateLimits, key) {
   const window = rateLimits[key];
   if (!isObject4(window) || typeof window.used_percentage !== "number" || !Number.isFinite(window.used_percentage)) {
@@ -140323,7 +140340,7 @@ function payloadWindow(rateLimits, key) {
   const resetsAt = window.resets_at;
   return {
     used: Math.min(FULL_PERCENT2, Math.max(0, window.used_percentage)),
-    resetAt: typeof resetsAt === "number" && Number.isFinite(resetsAt) ? new Date(resetsAt * MS_PER_SECOND17).toISOString() : void 0
+    resetAt: typeof resetsAt === "number" && Number.isFinite(resetsAt) ? isoOf(resetsAt * MS_PER_SECOND17) : void 0
   };
 }
 function payloadWindowsOf(payload) {
@@ -140351,7 +140368,7 @@ function antigravityQuotaMapOf(payload) {
 function bucketView(bucket, nowMs) {
   return {
     used: bucket?.remaining_fraction === void 0 || !Number.isFinite(bucket.remaining_fraction) ? void 0 : (1 - Math.min(1, Math.max(0, bucket.remaining_fraction))) * FULL_PERCENT2,
-    resetAt: bucket?.reset_in_seconds === void 0 || !Number.isFinite(bucket.reset_in_seconds) ? void 0 : new Date(nowMs + bucket.reset_in_seconds * MS_PER_SECOND17).toISOString()
+    resetAt: bucket?.reset_in_seconds === void 0 || !Number.isFinite(bucket.reset_in_seconds) ? void 0 : isoOf(nowMs + bucket.reset_in_seconds * MS_PER_SECOND17)
   };
 }
 function antigravityWindowsOf(payload, nowMs) {

package/dist/index.cjs

@@ -4762,7 +4762,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.67.2",
+      version: "11.67.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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -10110,27 +10110,27 @@ var init_targets = __esm({
 });
 
 // src/frontdoor/probe.ts
-function probeFrontDoorSync(port, caPem) {
+function probeFrontDoorSync(port, caPem, timeoutMs = PROBE_TIMEOUT_MS) {
   refuseToBlockInRole("a synchronous probe of the front door");
-  return runProbeWorker(PROBE_SOURCE, { port, ca: caPem });
+  return runProbeWorker(PROBE_SOURCE, { port, ca: caPem }, timeoutMs);
 }
-function probeListenerAcceptSync(port) {
+function probeListenerAcceptSync(port, timeoutMs = PROBE_TIMEOUT_MS) {
   refuseToBlockInRole("a synchronous probe of a front door listener");
-  return runProbeWorker(ACCEPT_PROBE_SOURCE, { port });
+  return runProbeWorker(ACCEPT_PROBE_SOURCE, { port }, timeoutMs);
 }
-function runProbeWorker(source, data) {
+function runProbeWorker(source, data, timeoutMs) {
   const shared = new SharedArrayBuffer(HEADER_SLOTS * INT32_BYTES + REASON_BYTES);
   const header = new Int32Array(shared, 0, HEADER_SLOTS);
   const worker = new import_node_worker_threads.Worker(source, {
     eval: true,
-    workerData: { ...data, timeoutMs: PROBE_TIMEOUT_MS, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
+    workerData: { ...data, timeoutMs, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
   });
   worker.unref();
   try {
-    const waited = Atomics.wait(header, 0, VERDICT_PENDING, PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS);
+    const waited = Atomics.wait(header, 0, VERDICT_PENDING, timeoutMs + PROBE_WAIT_MARGIN_MS);
     const verdict = Atomics.load(header, 0);
     if (waited === "timed-out" || verdict === VERDICT_PENDING) {
-      return { ok: false, reason: `the probe did not finish within ${String(PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS)}ms` };
+      return { ok: false, reason: `the probe did not finish within ${String(timeoutMs + PROBE_WAIT_MARGIN_MS)}ms` };
     }
     if (verdict === VERDICT_OK) {
       return { ok: true };

package/dist/index.mjs

@@ -4738,7 +4738,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.67.2",
+      version: "11.67.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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -10084,27 +10084,27 @@ var init_targets = __esm({
 
 // src/frontdoor/probe.ts
 import { Worker } from "node:worker_threads";
-function probeFrontDoorSync(port, caPem) {
+function probeFrontDoorSync(port, caPem, timeoutMs = PROBE_TIMEOUT_MS) {
   refuseToBlockInRole("a synchronous probe of the front door");
-  return runProbeWorker(PROBE_SOURCE, { port, ca: caPem });
+  return runProbeWorker(PROBE_SOURCE, { port, ca: caPem }, timeoutMs);
 }
-function probeListenerAcceptSync(port) {
+function probeListenerAcceptSync(port, timeoutMs = PROBE_TIMEOUT_MS) {
   refuseToBlockInRole("a synchronous probe of a front door listener");
-  return runProbeWorker(ACCEPT_PROBE_SOURCE, { port });
+  return runProbeWorker(ACCEPT_PROBE_SOURCE, { port }, timeoutMs);
 }
-function runProbeWorker(source, data) {
+function runProbeWorker(source, data, timeoutMs) {
   const shared = new SharedArrayBuffer(HEADER_SLOTS * INT32_BYTES + REASON_BYTES);
   const header = new Int32Array(shared, 0, HEADER_SLOTS);
   const worker = new Worker(source, {
     eval: true,
-    workerData: { ...data, timeoutMs: PROBE_TIMEOUT_MS, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
+    workerData: { ...data, timeoutMs, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
   });
   worker.unref();
   try {
-    const waited = Atomics.wait(header, 0, VERDICT_PENDING, PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS);
+    const waited = Atomics.wait(header, 0, VERDICT_PENDING, timeoutMs + PROBE_WAIT_MARGIN_MS);
     const verdict = Atomics.load(header, 0);
     if (waited === "timed-out" || verdict === VERDICT_PENDING) {
-      return { ok: false, reason: `the probe did not finish within ${String(PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS)}ms` };
+      return { ok: false, reason: `the probe did not finish within ${String(timeoutMs + PROBE_WAIT_MARGIN_MS)}ms` };
     }
     if (verdict === VERDICT_OK) {
       return { ok: true };

package/package.json

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