claude-use 11.67.1 → 11.67.3

package/README.md

@@ -266,7 +266,7 @@ pnpm schema      # regenerate schema/*.schema.json from src/config/schema.ts; CI
 
 Run a single test file directly with `pnpm exec vitest run <path>`. Tests never touch a real identity: `vitest.config.ts` sets `AGENT_SHIM_HOME` to a throwaway directory, and a setup file refuses to run at all if that variable is unset or resolves to the real `~/.agent-shim`.
 
-Commits are gated by Husky hooks: `commit-msg` enforces conventional-commit format, `pre-commit` runs `eslint --fix` on staged files and rejects merge/squash commits and mass deletions on `main`, and `pre-push` runs the full test suite and also rejects a push that would delete more than 100 files on the remote.
+Commits are gated by Husky hooks: `commit-msg` enforces conventional-commit format, `pre-commit` runs `eslint --fix` on staged files and rejects merge/squash commits and mass deletions on `main`, and `pre-push` runs typecheck, the schema drift check, knip and the tests related to what the push changes (CI runs the full suite) and also rejects a push that would delete more than 100 files on the remote.
 
 A fresh clone needs one extra step before committing anything, since git stores filter definitions in `.git/config` rather than in the repository:
 

package/dist/cli.cjs

@@ -37387,7 +37387,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.67.1",
+      version: "11.67.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>",
@@ -119461,11 +119461,16 @@ function createHeadroomKeeper(deps) {
       ports.fs.removeRecursive(paths.headroomLockFile);
     }
   };
-  const tick = () => {
-    const state = resolveServingHeadroomState(ports.fs, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning)?.state;
+  const tick = async () => {
+    const stateFiles = { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile };
+    const sessions = listSessions(ports.fs, paths.headroomSessionsDir);
+    const asked = new Set([readHeadroomState(ports.fs, stateFiles.stateFile)?.supervisorPid, readHeadroomState(ports.fs, stateFiles.legacyStateFile)?.supervisorPid, readStartLock(ports.fs, paths.headroomLockFile)?.pid, ...sessions.flatMap((session) => [session.pid, session.supervisorPid])].filter((pid) => pid !== void 0));
+    const running = await ports.runningAmong([...asked]);
+    const isRunning = (pid) => !asked.has(pid) || running.has(pid);
+    const state = resolveServingHeadroomState(ports.fs, stateFiles, isRunning)?.state;
     const supervisorPid = state?.supervisorPid;
-    const orphans = listSessions(ports.fs, paths.headroomSessionsDir).filter((session) => ports.isRunning(session.pid) && !ports.isRunning(session.supervisorPid));
-    if (supervisorPid !== void 0 && ports.isRunning(supervisorPid)) {
+    const orphans = sessions.filter((session) => isRunning(session.pid) && !isRunning(session.supervisorPid));
+    if (supervisorPid !== void 0 && isRunning(supervisorPid)) {
       lastAttemptAt = void 0;
       releaseOwnLock();
       for (const session of orphans) {
@@ -119484,7 +119489,7 @@ function createHeadroomKeeper(deps) {
     }
     releaseOwnLock();
     lastAttemptAt = ports.now();
-    const start = startSupervisorUnderLock({ paths, holderPid: deps.ownPid, ports });
+    const start = startSupervisorUnderLock({ paths, holderPid: deps.ownPid, ports: { fs: ports.fs, now: ports.now, isRunning, spawnSupervisor: ports.spawnSupervisor } });
     log(`front door: headroom supervisor is not running and ${String(orphans.length)} launcher(s) are registered against it (${start})`);
     return { kind: "starting", start, waiting: orphans.length };
   };
@@ -119560,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);
@@ -119575,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);
     }
@@ -119626,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
@@ -136098,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,
@@ -139643,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() });
@@ -139682,15 +139700,20 @@ function realFrontDoorSupervisorPorts(paths, respawnGeneration, lifecycle, track
   const headroomKeeper = createHeadroomKeeper({
     paths,
     ownPid: process.pid,
-    ports: { fs: realFarmFs, now: () => Date.now(), isRunning: realIsProcessRunning, spawnSupervisor: (layout) => spawnDetachedSupervisor(layout, "__headroom-supervisor", layout.headroomLogPath) },
+    ports: { fs: realFarmFs, now: () => Date.now(), runningAmong: realRunningAmong, spawnSupervisor: (layout) => spawnDetachedSupervisor(layout, "__headroom-supervisor", layout.headroomLogPath) },
     log
   });
+  let headroomKeeperTicking = false;
   const headroomKeeperTimer = setInterval(() => {
-    try {
-      headroomKeeper.tick();
-    } catch (error63) {
-      log(`headroom keeper failed: ${error63 instanceof Error ? error63.message : String(error63)}`);
+    if (headroomKeeperTicking) {
+      return;
     }
+    headroomKeeperTicking = true;
+    headroomKeeper.tick().catch((error63) => {
+      log(`headroom keeper failed: ${error63 instanceof Error ? error63.message : String(error63)}`);
+    }).finally(() => {
+      headroomKeeperTicking = false;
+    });
   }, HEADROOM_POLL_MS);
   headroomKeeperTimer.unref();
   keeperTimers.push(headroomKeeperTimer);

package/dist/index.cjs

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

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

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