claude-use 7.4.0 → 7.6.0

package/dist/index.mjs

@@ -248,10 +248,18 @@ import { cosmiconfigSync } from "cosmiconfig";
 
 // src/cliError.ts
 var EXIT_FAILURE = 1;
+var EXIT_USAGE = 2;
 var CliError = class extends Error {
   /** The process exit status this failure maps to. `EXIT_FAILURE` unless a subclass says otherwise. */
   exitCode = EXIT_FAILURE;
 };
+var UsageError = class extends CliError {
+  exitCode = EXIT_USAGE;
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
 
 // src/config/classify.ts
 var GLOB_METACHARACTERS = /[*?[\]{}!()]/;
@@ -1212,6 +1220,8 @@ function planReconciliation(params) {
 }
 
 // src/legacy.ts
+var HOME_DIRNAME = ".agent-shim";
+var LEGACY_HOME_DIRNAME = ".claude-use";
 var LEGACY_FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
 
 // src/launcher/lock.ts
@@ -1313,8 +1323,8 @@ var FarmManifestSchema = z2.strictObject({
   materialised: z2.array(z2.string()),
   links: z2.array(z2.strictObject({ rel: z2.string(), target: z2.string() }))
 });
-function readFarmManifest(fs2, farmRoot) {
-  const raw = fs2.readFileUtf8(path4.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs2.readFileUtf8(path4.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs3, farmRoot) {
+  const raw = fs3.readFileUtf8(path4.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs3.readFileUtf8(path4.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -1372,9 +1382,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs2, root, rel) {
+function listSubtree(fs3, root, rel) {
   const absolute = path4.join(root, rel);
-  const stat = fs2.lstat(absolute);
+  const stat = fs3.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -1382,10 +1392,10 @@ function listSubtree(fs2, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs2.readdir(absolute)].sort().flatMap((name) => listSubtree(fs2, root, `${rel}/${name}`));
+    const children = [...fs3.readdir(absolute)].sort().flatMap((name) => listSubtree(fs3, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs2.hashFile(absolute);
+  const contentHash = fs3.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -1399,25 +1409,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs2, farmRoot, manifest) {
+function reconciliationScope(fs3, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs2.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs2.lstat(path4.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs3.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs3.lstat(path4.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs2, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs2, farmRoot, root));
+function collectFarmListing(fs3, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs3, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs2, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs3, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
     const absolute = path4.join(claudeHome, entry.rel);
-    const stat = fs2.lstat(absolute);
+    const stat = fs3.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs2.hashFile(absolute);
+      const contentHash = fs3.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -1777,10 +1787,6 @@ function recoveryDiagnostics(recovery, identity) {
 // src/frontdoor/connect.ts
 import { X509Certificate as X509Certificate2, createPrivateKey as createPrivateKey2 } from "node:crypto";
 import * as fs from "node:fs";
-import * as http from "node:http";
-import * as https from "node:https";
-import * as net2 from "node:net";
-import * as tls from "node:tls";
 
 // src/frontdoor/x509.ts
 import { createHash, createPrivateKey, generateKeyPairSync, randomBytes, sign, X509Certificate } from "node:crypto";
@@ -2053,6 +2059,54 @@ function issueLeafCertificate(ca, names, notBefore, notAfter) {
   return { certPem: toPem("CERTIFICATE", der), keyPem: keyPem(privateKey) };
 }
 
+// src/frontdoor/tap.ts
+function pumpTapSession(secure, openUpstream, tap) {
+  let upstream;
+  let ended = false;
+  const end = () => {
+    if (!ended) {
+      ended = true;
+      tap?.onEnd();
+    }
+  };
+  const drop = () => {
+    end();
+    secure.destroy();
+    upstream?.destroy();
+  };
+  secure.once("close", () => {
+    end();
+    upstream?.destroy();
+  });
+  secure.once("error", drop);
+  const clientAlpn = "alpnProtocol" in secure && typeof secure.alpnProtocol === "string" ? secure.alpnProtocol : void 0;
+  void (async () => {
+    try {
+      upstream = await openUpstream(clientAlpn);
+    } catch {
+      drop();
+      return;
+    }
+    if (secure.destroyed) {
+      end();
+      upstream.destroy();
+      return;
+    }
+    if (tap !== void 0) {
+      secure.on("data", (chunk) => {
+        tap.onChunk("client-to-server", chunk);
+      });
+      upstream.on("data", (chunk) => {
+        tap.onChunk("server-to-client", chunk);
+      });
+    }
+    secure.pipe(upstream);
+    upstream.pipe(secure);
+    upstream.once("close", drop);
+    upstream.once("error", drop);
+  })();
+}
+
 // src/frontdoor/capability.ts
 var CONNECT_PROXY_REALM = "agent-shim front door";
 var BASIC_SCHEME = "basic";
@@ -2101,10 +2155,10 @@ var FrontDoorStateSchema = z3.strictObject({
   /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
   lastError: z3.string().optional()
 });
-function readFrontDoorState(fs2, stateFile) {
+function readFrontDoorState(fs3, stateFile) {
   let raw;
   try {
-    raw = fs2.readFileUtf8(stateFile);
+    raw = fs3.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -2118,28 +2172,28 @@ function readFrontDoorState(fs2, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs2, stateFile, state) {
-  fs2.mkdirp(path5.dirname(stateFile));
-  fs2.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs3, stateFile, state) {
+  fs3.mkdirp(path5.dirname(stateFile));
+  fs3.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
   return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
 }
-function writeFrontDoorSession(fs2, sessionsDir, session) {
-  fs2.mkdirPrivate(sessionsDir);
-  fs2.writeFilePrivate(path5.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs3, sessionsDir, session) {
+  fs3.mkdirPrivate(sessionsDir);
+  fs3.writeFilePrivate(path5.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function listFrontDoorSessions(fs2, sessionsDir) {
+function listFrontDoorSessions(fs3, sessionsDir) {
   const sessions = [];
-  for (const name of fs2.readdir(sessionsDir)) {
+  for (const name of fs3.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs2.readFileUtf8(path5.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs3.readFileUtf8(path5.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
       }
@@ -2149,14 +2203,14 @@ function listFrontDoorSessions(fs2, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs2, sessionsDir, pid) {
-  fs2.removeRecursive(path5.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs3, sessionsDir, pid) {
+  fs3.removeRecursive(path5.join(sessionsDir, `${String(pid)}.json`));
 }
-function pruneDeadFrontDoorSessions(fs2, sessionsDir, isRunning) {
+function pruneDeadFrontDoorSessions(fs3, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listFrontDoorSessions(fs2, sessionsDir)) {
+  for (const session of listFrontDoorSessions(fs3, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs2, sessionsDir, session.pid);
+      removeFrontDoorSession(fs3, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
@@ -2168,8 +2222,8 @@ var FRONTDOOR_SUPERVISOR_STILL_RUNNING = -1;
 var FRONTDOOR_POLL_MS = 1e3;
 var MS_PER_MINUTE = 6e4;
 async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {}) {
-  const { fs: fs2, paths } = ports;
-  const previous = readFrontDoorState(fs2, paths.frontdoorStateFile);
+  const { fs: fs3, paths } = ports;
+  const previous = readFrontDoorState(fs3, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -2179,12 +2233,12 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ...lastDirectPort === void 0 ? {} : { lastDirectPort }
   });
   const fail = (message) => {
-    writeFrontDoorState(fs2, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-    fs2.removeRecursive(paths.frontdoorLockFile);
+    writeFrontDoorState(fs3, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+    fs3.removeRecursive(paths.frontdoorLockFile);
     ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
-  writeFrontDoorState(fs2, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+  writeFrontDoorState(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   const previousSticky = lastPort;
   let http2;
   try {
@@ -2197,23 +2251,23 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
   }
   lastPort = http2.port;
   const previousStickyConnect = lastConnectPort;
-  let connect2;
+  let connect3;
   try {
-    connect2 = await ports.startConnectListener(lastConnectPort);
+    connect3 = await ports.startConnectListener(lastConnectPort);
   } catch (error) {
     await http2.close();
     return fail(`could not start the CONNECT surface: ${error instanceof Error ? error.message : String(error)}`);
   }
-  if (previousStickyConnect !== void 0 && connect2.port !== previousStickyConnect) {
-    ports.log(`agent-shim frontdoor supervisor: sticky CONNECT port ${String(previousStickyConnect)} was occupied; moving to ${String(connect2.port)} (OAuth sessions launched against the old port are stale until they relaunch)`);
+  if (previousStickyConnect !== void 0 && connect3.port !== previousStickyConnect) {
+    ports.log(`agent-shim frontdoor supervisor: sticky CONNECT port ${String(previousStickyConnect)} was occupied; moving to ${String(connect3.port)} (OAuth sessions launched against the old port are stale until they relaunch)`);
   }
-  lastConnectPort = connect2.port;
+  lastConnectPort = connect3.port;
   const previousStickyDirect = lastDirectPort;
   let direct;
   try {
     direct = await ports.startDirectListener(lastDirectPort);
   } catch (error) {
-    await connect2.close();
+    await connect3.close();
     await http2.close();
     return fail(`could not start the direct listener: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -2221,9 +2275,9 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ports.log(`agent-shim frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom must be restarted to admit the new address)`);
   }
   lastDirectPort = direct.port;
-  writeFrontDoorState(fs2, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http2.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
-  fs2.removeRecursive(paths.frontdoorLockFile);
-  ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http2.port)}, CONNECT surface on 127.0.0.1:${String(connect2.port)}`);
+  writeFrontDoorState(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http2.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
+  fs3.removeRecursive(paths.frontdoorLockFile);
+  ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http2.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
   let idleSince;
   let ticks = 0;
   for (; ; ) {
@@ -2231,15 +2285,15 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
-    pruneDeadFrontDoorSessions(fs2, paths.frontdoorSessionsDir, ports.isRunning);
-    if (listFrontDoorSessions(fs2, paths.frontdoorSessionsDir).length === 0) {
+    pruneDeadFrontDoorSessions(fs3, paths.frontdoorSessionsDir, ports.isRunning);
+    if (listFrontDoorSessions(fs3, paths.frontdoorSessionsDir).length === 0) {
       idleSince ??= ports.now();
       if (ports.now() - idleSince >= idleShutdownMinutes * MS_PER_MINUTE) {
         ports.log(`agent-shim frontdoor supervisor: no sessions for ${String(idleShutdownMinutes)} minute(s); closing the front door and exiting`);
         await direct.close();
-        await connect2.close();
+        await connect3.close();
         await http2.close();
-        writeFrontDoorState(fs2, paths.frontdoorStateFile, sticky());
+        writeFrontDoorState(fs3, paths.frontdoorStateFile, sticky());
         return 0;
       }
     } else {
@@ -2294,8 +2348,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path8) {
-  return path8?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path9) {
+  return path9?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -2361,9 +2415,20 @@ function caParses(ca) {
     return false;
   }
 }
+var TAP_ALPN_PROTOCOLS = ["h2", "http/1.1"];
 async function startConnectServer(config, effects, preferredPort) {
   const onUpgrade = config.capture === void 0 ? void 0 : (request3) => config.capture?.upgrade(request3);
   const sessions = config.interceptHosts.map((host) => {
+    if (config.tapHosts.includes(host)) {
+      const tlsAcceptor2 = effects.createTlsAcceptor(
+        config.leafFor(host),
+        (secure) => {
+          pumpTapSession(secure, async (clientAlpn) => await effects.connectTlsUpstream(host, HTTPS_PORT, clientAlpn), config.capture?.tapStream?.(host));
+        },
+        TAP_ALPN_PROTOCOLS
+      );
+      return { host, tlsAcceptor: tlsAcceptor2 };
+    }
     const handler = (request3, response) => {
       if (host === config.routedHost && servedByPipeline(request3.url)) {
         config.serveRouted(request3, response);
@@ -2388,7 +2453,7 @@ async function startConnectServer(config, effects, preferredPort) {
       await listener.close();
       for (const { httpSession, tlsAcceptor } of sessions) {
         tlsAcceptor.close();
-        httpSession.close();
+        httpSession?.close();
       }
     }
   };
@@ -2564,6 +2629,40 @@ async function blindTunnel(socket, target, effects) {
     socket.destroy();
   });
 }
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function realConnectCertStore(paths) {
+  const read = (file) => {
+    try {
+      return fs.readFileSync(file, "utf8");
+    } catch (error) {
+      if (isEnoent(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+  };
+  return {
+    loadCa: () => {
+      const certPem = read(paths.frontdoorCaCertFile);
+      const keyPem2 = read(paths.frontdoorCaKeyFile);
+      return certPem === void 0 || keyPem2 === void 0 ? void 0 : { certPem, keyPem: keyPem2 };
+    },
+    writeCa: (ca) => {
+      fs.mkdirSync(paths.frontdoorCaDir, { recursive: true });
+      fs.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
+      fs.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
+      fs.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
+    }
+  };
+}
+
+// src/frontdoor/connectEffects.ts
+import * as http from "node:http";
+import * as https from "node:https";
+import * as net2 from "node:net";
+import * as tls from "node:tls";
 function realConnectEffects() {
   const plainAgent = new http.Agent({ keepAlive: true });
   const tlsAgent = new https.Agent({ keepAlive: true });
@@ -2609,10 +2708,13 @@ function realConnectEffects() {
       }
       return await listenOnce(0, onSocket);
     },
-    createTlsAcceptor: (leaf, onSecure) => {
-      const server = tls.createServer({ key: leaf.keyPem, cert: leaf.certPem }, (secure) => {
-        onSecure(secure);
-      });
+    createTlsAcceptor: (leaf, onSecure, alpnProtocols) => {
+      const server = tls.createServer(
+        { key: leaf.keyPem, cert: leaf.certPem, ...alpnProtocols === void 0 ? {} : { ALPNProtocols: [...alpnProtocols] } },
+        (secure) => {
+          onSecure(secure);
+        }
+      );
       server.on("clientError", (_error, socket) => {
         socket.destroy();
       });
@@ -2647,6 +2749,13 @@ function realConnectEffects() {
         }
       };
     },
+    connectTlsUpstream: async (host, port, clientAlpn) => await new Promise((resolve, reject) => {
+      const socket = tls.connect({ host, port, servername: host, ...clientAlpn === void 0 ? {} : { ALPNProtocols: [clientAlpn] } });
+      socket.once("secureConnect", () => {
+        resolve(socket);
+      });
+      socket.once("error", reject);
+    }),
     connectTcp: async (host, port) => await new Promise((resolve, reject) => {
       const socket = net2.connect({ host, port });
       socket.once("connect", () => {
@@ -2710,34 +2819,6 @@ function realConnectEffects() {
     }
   };
 }
-function isEnoent(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-function realConnectCertStore(paths) {
-  const read = (file) => {
-    try {
-      return fs.readFileSync(file, "utf8");
-    } catch (error) {
-      if (isEnoent(error)) {
-        return void 0;
-      }
-      throw error;
-    }
-  };
-  return {
-    loadCa: () => {
-      const certPem = read(paths.frontdoorCaCertFile);
-      const keyPem2 = read(paths.frontdoorCaKeyFile);
-      return certPem === void 0 || keyPem2 === void 0 ? void 0 : { certPem, keyPem: keyPem2 };
-    },
-    writeCa: (ca) => {
-      fs.mkdirSync(paths.frontdoorCaDir, { recursive: true });
-      fs.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
-      fs.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
-      fs.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
-    }
-  };
-}
 
 // src/frontdoor/ensure.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -2778,16 +2859,16 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs2, stateFile) {
+function readHeadroomState(fs3, stateFile) {
   try {
-    return parseJson(fs2.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs3.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs2, stateFile, state) {
-  fs2.mkdirp(path6.dirname(stateFile));
-  fs2.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs3, stateFile, state) {
+  fs3.mkdirp(path6.dirname(stateFile));
+  fs3.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function headroomAllowlist(providers) {
@@ -2807,14 +2888,14 @@ function headroomUpstreams(providers, frontDoorOrigin2) {
 function hashAllowlist(allowlist) {
   return createHash2("sha256").update(allowlist.join("\n")).digest("hex");
 }
-function readAllProviders(fs2, providersDir) {
+function readAllProviders(fs3, providersDir) {
   const result = [];
-  for (const name of fs2.readdir(providersDir)) {
+  for (const name of fs3.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs2.readFileUtf8(path6.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs3.readFileUtf8(path6.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -2824,22 +2905,22 @@ function readAllProviders(fs2, providersDir) {
   }
   return result;
 }
-function writeSession(fs2, sessionsDir, session) {
-  fs2.mkdirp(sessionsDir);
-  fs2.writeFileUtf8(path6.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs3, sessionsDir, session) {
+  fs3.mkdirp(sessionsDir);
+  fs3.writeFileUtf8(path6.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs2, sessionsDir, pid) {
-  fs2.removeRecursive(path6.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs3, sessionsDir, pid) {
+  fs3.removeRecursive(path6.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs2, sessionsDir) {
+function listSessions(fs3, sessionsDir) {
   const sessions = [];
-  for (const name of fs2.readdir(sessionsDir)) {
+  for (const name of fs3.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs2.readFileUtf8(path6.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs3.readFileUtf8(path6.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -2849,22 +2930,22 @@ function listSessions(fs2, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function sessionsForSupervisor(fs2, sessionsDir, supervisorPid) {
-  return listSessions(fs2, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs3, sessionsDir, supervisorPid) {
+  return listSessions(fs3, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs2, sessionsDir, isRunning) {
+function pruneDeadSessions(fs3, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs2, sessionsDir)) {
+  for (const session of listSessions(fs3, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs2, sessionsDir, session.pid);
+      removeSession(fs3, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs2, lockFile) {
+function readStartLock(fs3, lockFile) {
   try {
-    return parseJson(fs2.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs3.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -3101,9 +3182,9 @@ function snapshotPath(snapshotsDir, identity) {
   }
   return path7.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs2, snapshotsDir, identity) {
+function readUsageSnapshot(fs3, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
-  const raw = fs2.readFileUtf8(file);
+  const raw = fs3.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -3119,8 +3200,8 @@ function readUsageSnapshot(fs2, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs2, snapshotsDir) {
-  return fs2.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs3, snapshotsDir) {
+  return fs3.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -3128,7 +3209,7 @@ function listUsageSnapshots(fs2, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs2, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs3, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -3295,9 +3376,9 @@ function compareVersions(a, b) {
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs2, paths } = ports;
+  const { fs: fs3, paths } = ports;
   let config = initialConfig;
-  const previousState = readHeadroomState(fs2, paths.headroomStateFile);
+  const previousState = readHeadroomState(fs3, paths.headroomStateFile);
   if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
     ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
     return 0;
@@ -3306,19 +3387,19 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
   const ownsState = () => {
-    const owner = readHeadroomState(fs2, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs3, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs2, paths.headroomStateFile, state);
+    writeHeadroomState(fs3, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message, ...sticky() })) {
-      fs2.removeRecursive(paths.headroomLockFile);
+      fs3.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
@@ -3367,7 +3448,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const settingsHash = hashSettings(config.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs2, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs3, paths.headroomSessionsDir, ports.isRunning);
     const ownsNow = ownsState();
     if (!ownsNow && !superseded) {
       ports.log("agent-shim headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
@@ -3419,7 +3500,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           ...sticky()
         });
         if (recorded) {
-          fs2.removeRecursive(paths.headroomLockFile);
+          fs3.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
@@ -3434,7 +3515,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+        if (sessionsForSupervisor(fs3, paths.headroomSessionsDir, ports.ownPid).length === 0) {
           ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
@@ -3443,7 +3524,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs3, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -3465,9 +3546,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-function currentHeadroomAllowlist(fs2, paths) {
-  const providers = readAllProviders(fs2, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs2, paths.frontdoorStateFile))));
+function currentHeadroomAllowlist(fs3, paths) {
+  const providers = readAllProviders(fs3, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs3, paths.frontdoorStateFile))));
 }
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
@@ -3531,18 +3612,99 @@ function evaluateAmbientCredentialGuard(params) {
     message: formatAmbientCredentialGuardMessage(detected.variable, params.identityName)
   };
 }
+
+// src/paths.ts
+import fs2 from "node:fs";
+import os from "node:os";
+import path8 from "node:path";
+function resolveAgentShimHome(env = process.env, home = os.homedir(), isDirectory = isExistingDirectory) {
+  const fromEnv = env.AGENT_SHIM_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  const current = path8.join(home, HOME_DIRNAME);
+  const legacy = path8.join(home, LEGACY_HOME_DIRNAME);
+  return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
+}
+function isExistingDirectory(candidate) {
+  return fs2.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
+}
+function resolveClaudeHome() {
+  const fromEnv = process.env.AGENT_SHIM_CLAUDE_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  return path8.join(os.homedir(), ".claude");
+}
+function buildLayoutPaths(root) {
+  return {
+    root,
+    identitiesDir: path8.join(root, "identities"),
+    configProfilesDir: path8.join(root, "config-profiles"),
+    providersDir: path8.join(root, "providers"),
+    directoryRulesFile: path8.join(root, "directory-rules.json"),
+    activeIdentityFile: path8.join(root, "active-identity"),
+    globalConfigFile: path8.join(root, "config.json"),
+    categoriesLocalFile: path8.join(root, "categories.local.json"),
+    claudeShimFile: path8.join(root, "claude-shim.json"),
+    headroomDir: path8.join(root, "headroom"),
+    headroomStateFile: path8.join(root, "headroom", "state.json"),
+    headroomLockFile: path8.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: path8.join(root, "headroom", "sessions"),
+    logsDir: path8.join(root, "logs"),
+    headroomLogPath: path8.join(root, "logs", "headroom.log"),
+    frontdoorDir: path8.join(root, "frontdoor"),
+    frontdoorCaDir: path8.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: path8.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: path8.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: path8.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: path8.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: path8.join(root, "frontdoor", "start.lock"),
+    frontdoorSessionsDir: path8.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: path8.join(root, "logs", "frontdoor.log"),
+    usageDir: path8.join(root, "usage"),
+    usageLogDir: path8.join(root, "usage", "log"),
+    usageSnapshotsDir: path8.join(root, "usage", "snapshots"),
+    usagePicksFile: path8.join(root, "usage", "picks.json")
+  };
+}
+function resolveLayoutPaths() {
+  return buildLayoutPaths(resolveAgentShimHome());
+}
 export {
   AMBIENT_CREDENTIAL_VARS,
   CONNECT_INTERCEPT_HOST,
   CONNECT_INTERCEPT_HOSTS,
   CONNECT_LIMITS,
+  CategoryClassificationOverlaySchema,
+  CategoryClassificationSchema,
+  CategoryMapSchema,
+  CliError,
+  ConfigProfileSchema,
+  CredentialCacheSchema,
+  CredentialSchema,
+  CredentialSourceSchema,
+  DirectoryRuleSchema,
+  DirectoryRulesSchema,
+  EXIT_FAILURE,
+  EXIT_USAGE,
+  EntryValueSchema,
   FARM_MANIFEST_FILENAME,
   FrontDoorStartError,
+  GlobalConfigSchema,
   HeadroomStartError,
+  IdentitySchema,
+  PoolNameSchema,
+  PoolSchema,
+  PortableConfigSchema,
+  ProviderSchema,
   ROUTED_PATH_PREFIX,
+  UsageError,
   UsageSnapshotError,
   UsageSnapshotSchema,
+  WhenSchema,
   buildEntryFacts,
+  buildLayoutPaths,
   carryOver,
   createLeafCache,
   detectAmbientCredential,
@@ -3563,7 +3725,10 @@ export {
   realConnectEffects,
   recoverFarm,
   recoveryDiagnostics,
+  resolveAgentShimHome,
+  resolveClaudeHome,
   resolveDecisions,
+  resolveLayoutPaths,
   resolveSupervisorConfig,
   resyncFarm,
   runFrontDoorSupervisor,