claude-use 7.5.0 → 7.6.0

package/README.md

@@ -63,8 +63,8 @@ Every top-level entry in `~/.claude` is classified into one of five categories,
 
 | Category | Default shared? | Example entries |
 |---|---|---|
-| `secret` | **Never** — hardcoded, cannot be overridden by any configuration layer | `.credentials.json`, `backups` |
-| `runtime` | No | `daemon*`, `.git*`, `.DS_Store`, `mcp-needs-auth-cache.json`, `shell-snapshots`, `statsig`, `telemetry`, `stats-cache.json`, `usage-data`, `ide`, `cache`, `scheduled_tasks.lock` |
+| `secret` | **Never** — hardcoded, cannot be overridden by any configuration layer | `.credentials.json`, `backups`, `settings.json.bak*` |
+| `runtime` | No | `daemon*`, `.git*`, `.DS_Store`, `mcp-needs-auth-cache.json`, `codex-quota.json`, `file-transfers`, `shell-snapshots`, `statsig`, `telemetry`, `stats-cache.json`, `usage-data`, `ide`, `cache`, `scheduled_tasks.lock` |
 | `history` | Yes | `projects`, `sessions`, `session-env`, `teams`, `tasks`, `todos`, `history.jsonl`, `transcripts`, `paste-cache`, `file-history`, `plans`, `workflows`, `jobs`, `debug`, `downloads`, `chrome` |
 | `knowledge` | Yes | `skills`, `agents`, `rules`, `memory`, `commands`, `plugins`, `hooks`, `AGENTS.md`, `CLAUDE.md`, `README.md` |
 | `settings` | Yes | `settings.json`, `settings.local.json` |

package/dist/cli.cjs

@@ -8756,7 +8756,7 @@ var require_connect = __commonJS({
       const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
       timeout = timeout == null ? 1e4 : timeout;
       allowH2 = allowH2 != null ? allowH2 : false;
-      return function connect2({ hostname: hostname3, host, protocol, port, servername, localAddress, httpSocket }, callback) {
+      return function connect3({ hostname: hostname3, host, protocol, port, servername, localAddress, httpSocket }, callback) {
         let socket;
         if (protocol === "https:") {
           if (!tls2) {
@@ -14554,7 +14554,7 @@ var require_client = __commonJS({
         tls: tls2,
         strictContentLength,
         maxCachedSessions,
-        connect: connect3,
+        connect: connect4,
         maxRequestsPerClient,
         localAddress,
         maxResponseSize,
@@ -14612,7 +14612,7 @@ var require_client = __commonJS({
         if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
           throw new InvalidArgumentError2("bodyTimeout must be a positive integer or zero");
         }
-        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
+        if (connect4 != null && typeof connect4 !== "function" && typeof connect4 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
         if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
@@ -14646,8 +14646,8 @@ var require_client = __commonJS({
           throw new InvalidArgumentError2("pingInterval must be a positive integer, greater or equal to 0");
         }
         super({ webSocket });
-        if (typeof connect3 !== "function") {
-          connect3 = buildConnector({
+        if (typeof connect4 !== "function") {
+          connect4 = buildConnector({
             ...tls2,
             maxCachedSessions,
             allowH2,
@@ -14655,18 +14655,18 @@ var require_client = __commonJS({
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect3
+            ...connect4
           });
         } else {
-          const customConnect = connect3;
-          connect3 = (opts, callback) => customConnect({
+          const customConnect = connect4;
+          connect4 = (opts, callback) => customConnect({
             ...opts,
             ...socketPath != null ? { socketPath } : null,
             ...allowH2 != null ? { allowH2 } : null
           }, callback);
         }
         this[kUrl] = util.parseOrigin(url2);
-        this[kConnector] = connect3;
+        this[kConnector] = connect4;
         this[kPipelining] = pipelining != null ? pipelining : 1;
         this[kMaxHeadersSize] = maxHeaderSize;
         this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
@@ -14724,7 +14724,7 @@ var require_client = __commonJS({
         );
       }
       [kConnect](cb) {
-        connect2(this);
+        connect3(this);
         this.once("connect", cb);
       }
       [kDispatch](opts, handler) {
@@ -14790,7 +14790,7 @@ var require_client = __commonJS({
         assert2(client[kSize] === 0);
       }
     }
-    function connect2(client) {
+    function connect3(client) {
       assert2(!client[kConnecting]);
       assert2(!client[kHTTPContext]);
       let { host, hostname: hostname3, protocol, port } = client[kUrl];
@@ -14969,7 +14969,7 @@ var require_client = __commonJS({
           return;
         }
         if (!client[kHTTPContext]) {
-          connect2(client);
+          connect3(client);
           return;
         }
         if (client[kHTTPContext].destroyed) {
@@ -15265,7 +15265,7 @@ var require_pool = __commonJS({
       constructor(origin, {
         connections,
         factory = defaultFactory,
-        connect: connect2,
+        connect: connect3,
         connectTimeout,
         tls: tls2,
         maxCachedSessions,
@@ -15282,24 +15282,24 @@ var require_pool = __commonJS({
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
-        if (typeof connect2 !== "function") {
-          connect2 = buildConnector({
+        if (typeof connect3 !== "function") {
+          connect3 = buildConnector({
             ...tls2,
             maxCachedSessions,
             allowH2,
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect2
+            ...connect3
           });
         }
         super(options);
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect: connect2, allowH2, clientTtl, socketPath };
+        this[kOptions] = { ...util.deepClone(options), connect: connect3, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this.on("connect", (origin2, targets) => {
@@ -15378,14 +15378,14 @@ var require_balanced_pool = __commonJS({
       return new Pool(origin, opts);
     }
     var BalancedPool = class extends PoolBase {
-      constructor(upstreams = [], { factory = defaultFactory, connect: connect2, tls: tls2, ...opts } = {}) {
+      constructor(upstreams = [], { factory = defaultFactory, connect: connect3, tls: tls2, ...opts } = {}) {
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
         super(opts);
-        if (connect2 && typeof connect2 !== "function") connect2 = { ...connect2 };
+        if (connect3 && typeof connect3 !== "function") connect3 = { ...connect3 };
         if (tls2 && typeof tls2 !== "function") tls2 = { ...tls2 };
-        this[kOptions] = { ...util.deepClone(opts), connect: connect2, tls: tls2 };
+        this[kOptions] = { ...util.deepClone(opts), connect: connect3, tls: tls2 };
         this[kOptions].interceptors = opts.interceptors ? { ...opts.interceptors } : void 0;
         this[kIndex] = -1;
         this[kCurrentWeight] = 0;
@@ -15518,7 +15518,7 @@ var require_round_robin_pool = __commonJS({
       constructor(origin, {
         connections,
         factory = defaultFactory,
-        connect: connect2,
+        connect: connect3,
         connectTimeout,
         tls: tls2,
         maxCachedSessions,
@@ -15535,24 +15535,24 @@ var require_round_robin_pool = __commonJS({
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
-        if (typeof connect2 !== "function") {
-          connect2 = buildConnector({
+        if (typeof connect3 !== "function") {
+          connect3 = buildConnector({
             ...tls2,
             maxCachedSessions,
             allowH2,
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect2
+            ...connect3
           });
         }
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect: connect2, allowH2, clientTtl, socketPath };
+        this[kOptions] = { ...util.deepClone(options), connect: connect3, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this[kIndex] = -1;
@@ -15626,21 +15626,21 @@ var require_agent = __commonJS({
       return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
     }
     var Agent6 = class extends DispatcherBase {
-      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect: connect2, ...options } = {}) {
+      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect: connect3, ...options } = {}) {
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
         if (typeof maxOrigins !== "number" || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
           throw new InvalidArgumentError2("maxOrigins must be a number greater than 0");
         }
         super(options);
-        if (connect2 && typeof connect2 !== "function") {
-          connect2 = { ...connect2 };
+        if (connect3 && typeof connect3 !== "function") {
+          connect3 = { ...connect3 };
         }
-        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect: connect2 };
+        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect: connect3 };
         this[kFactory] = factory;
         this[kClients] = /* @__PURE__ */ new Map();
         this[kOrigins] = /* @__PURE__ */ new Set();
@@ -16471,16 +16471,16 @@ var require_proxy_agent = __commonJS({
     }
     var Http1ProxyWrapper = class extends DispatcherBase {
       #client;
-      constructor(proxyUrl, { headers = {}, connect: connect2, factory }) {
+      constructor(proxyUrl, { headers = {}, connect: connect3, factory }) {
         if (!proxyUrl) {
           throw new InvalidArgumentError2("Proxy URL is mandatory");
         }
         super();
         this[kProxyHeaders] = headers;
         if (factory) {
-          this.#client = factory(proxyUrl, { connect: connect2 });
+          this.#client = factory(proxyUrl, { connect: connect3 });
         } else {
-          this.#client = new Client(proxyUrl, { connect: connect2 });
+          this.#client = new Client(proxyUrl, { connect: connect3 });
         }
       }
       [kDispatch](opts, handler) {
@@ -16541,7 +16541,7 @@ var require_proxy_agent = __commonJS({
         } else if (username && password) {
           this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
         }
-        const connect2 = buildConnector({ ...opts.proxyTls });
+        const connect3 = buildConnector({ ...opts.proxyTls });
         this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
         const agentFactory = opts.factory || defaultAgentFactory;
         const factory = (origin2, options) => {
@@ -16549,7 +16549,7 @@ var require_proxy_agent = __commonJS({
           if (this[kProxy].protocol === "socks5:" || this[kProxy].protocol === "socks:") {
             return new Socks5ProxyAgent(this[kProxy].uri, {
               headers: this[kProxyHeaders],
-              connect: connect2,
+              connect: connect3,
               factory: agentFactory,
               username: opts.username || username,
               password: opts.password || password,
@@ -16560,7 +16560,7 @@ var require_proxy_agent = __commonJS({
           if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") {
             return new Http1ProxyWrapper(this[kProxy].uri, {
               headers: this[kProxyHeaders],
-              connect: connect2,
+              connect: connect3,
               factory: agentFactory
             });
           }
@@ -16569,7 +16569,7 @@ var require_proxy_agent = __commonJS({
         if (protocol === "socks5:" || protocol === "socks:") {
           this[kClient] = null;
         } else {
-          this[kClient] = clientFactory(url2, { connect: connect2 });
+          this[kClient] = clientFactory(url2, { connect: connect3 });
         }
         this[kAgent] = new Agent6({
           ...opts,
@@ -18402,10 +18402,10 @@ var require_api_connect = __commonJS({
         }
       }
     };
-    function connect2(opts, callback) {
+    function connect3(opts, callback) {
       if (callback === void 0) {
         return new Promise((resolve, reject) => {
-          connect2.call(this, opts, (err, data) => {
+          connect3.call(this, opts, (err, data) => {
             return err ? reject(err) : resolve(data);
           });
         });
@@ -18422,7 +18422,7 @@ var require_api_connect = __commonJS({
         queueMicrotask(() => callback(err, { opaque }));
       }
     }
-    module2.exports = connect2;
+    module2.exports = connect3;
   }
 });
 
@@ -57330,12 +57330,14 @@ var import_picomatch = __toESM(require_picomatch2(), 1);
 
 // src/config/categories.default.json
 var categories_default_default = {
-  secret: [".credentials.json", "backups"],
+  secret: [".credentials.json", "backups", "settings.json.bak*"],
   runtime: [
     "daemon*",
     ".git*",
     ".DS_Store",
     "mcp-needs-auth-cache.json",
+    "codex-quota.json",
+    "file-transfers",
     "shell-snapshots",
     "statsig",
     "telemetry",
@@ -61051,7 +61053,7 @@ function resolveLaunchIdentity(paths, cwd) {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "7.5.0",
+  version: "7.6.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>",
@@ -64450,6 +64452,39 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
     upgrade: (request6) => {
       append({ kind: "upgrade", method: request6.method ?? "?", url: request6.url ?? "?", headers: redactHeaders(request6.headers) });
     },
+    tapStream: (host) => {
+      nextId += 1;
+      const id = nextId;
+      append({ kind: "stream", id, host });
+      const stored = { "client-to-server": 0, "server-to-client": 0 };
+      const sequences = { "client-to-server": 0, "server-to-client": 0 };
+      return {
+        onChunk: (direction, chunk) => {
+          sequences[direction] += 1;
+          const budget = STREAM_LOG_CAP_BYTES - stored[direction];
+          if (budget <= 0) {
+            return;
+          }
+          const excerpt = chunk.subarray(0, Math.min(CHUNK_LOG_CAP_BYTES, budget));
+          stored[direction] += excerpt.length;
+          const text2 = excerpt.toString("utf8");
+          const faithful = Buffer.from(text2, "utf8").equals(excerpt);
+          append({
+            kind: "stream-chunk",
+            id,
+            dir: direction,
+            seq: sequences[direction],
+            bytes: chunk.length,
+            stored: excerpt.length,
+            truncated: excerpt.length < chunk.length,
+            ...faithful ? { body: redactText(text2) } : { b64: excerpt.toString("base64") }
+          });
+        },
+        onEnd: () => {
+          append({ kind: "stream-end", id, clientToServerCapped: stored["client-to-server"] >= STREAM_LOG_CAP_BYTES, serverToClientCapped: stored["server-to-client"] >= STREAM_LOG_CAP_BYTES });
+        }
+      };
+    },
     observePassthrough: (request6) => {
       nextId += 1;
       const id = nextId;
@@ -64495,10 +64530,6 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
 // src/frontdoor/connect.ts
 var import_node_crypto10 = require("node:crypto");
 var fs12 = __toESM(require("node:fs"), 1);
-var http = __toESM(require("node:http"), 1);
-var https = __toESM(require("node:https"), 1);
-var net3 = __toESM(require("node:net"), 1);
-var tls = __toESM(require("node:tls"), 1);
 
 // src/frontdoor/x509.ts
 var import_node_crypto9 = require("node:crypto");
@@ -64771,6 +64802,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/supervisor.ts
 var FRONTDOOR_SUPERVISOR_STILL_RUNNING = -1;
 var FRONTDOOR_POLL_MS = 1e3;
@@ -64805,23 +64884,23 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
   }
   lastPort = http5.port;
   const previousStickyConnect = lastConnectPort;
-  let connect2;
+  let connect3;
   try {
-    connect2 = await ports.startConnectListener(lastConnectPort);
+    connect3 = await ports.startConnectListener(lastConnectPort);
   } catch (error62) {
     await http5.close();
     return fail(`could not start the CONNECT surface: ${error62 instanceof Error ? error62.message : String(error62)}`);
   }
-  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 (error62) {
-    await connect2.close();
+    await connect3.close();
     await http5.close();
     return fail(`could not start the direct listener: ${error62 instanceof Error ? error62.message : String(error62)}`);
   }
@@ -64829,9 +64908,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(fs18, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http5.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
+  writeFrontDoorState(fs18, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http5.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
   fs18.removeRecursive(paths.frontdoorLockFile);
-  ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http5.port)}, CONNECT surface on 127.0.0.1:${String(connect2.port)}`);
+  ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http5.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
   let idleSince;
   let ticks = 0;
   for (; ; ) {
@@ -64845,7 +64924,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       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 http5.close();
         writeFrontDoorState(fs18, paths.frontdoorStateFile, sticky());
         return 0;
@@ -64860,6 +64939,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
 // src/frontdoor/connect.ts
 var CONNECT_INTERCEPT_HOST = "api.anthropic.com";
 var CONNECT_INTERCEPT_HOSTS = [CONNECT_INTERCEPT_HOST, "platform.claude.com"];
+var CONNECT_TAP_HOSTS = ["platform.claude.com"];
 var ROUTED_PATH_PREFIX = "/v1/";
 var HTTPS_PORT = 443;
 var MAX_PORT = 65535;
@@ -64967,9 +65047,20 @@ function caParses(ca) {
     return false;
   }
 }
+var TAP_ALPN_PROTOCOLS = ["h2", "http/1.1"];
 async function startConnectServer(config2, effects, preferredPort) {
   const onUpgrade = config2.capture === void 0 ? void 0 : (request6) => config2.capture?.upgrade(request6);
   const sessions = config2.interceptHosts.map((host) => {
+    if (config2.tapHosts.includes(host)) {
+      const tlsAcceptor2 = effects.createTlsAcceptor(
+        config2.leafFor(host),
+        (secure) => {
+          pumpTapSession(secure, async (clientAlpn) => await effects.connectTlsUpstream(host, HTTPS_PORT, clientAlpn), config2.capture?.tapStream?.(host));
+        },
+        TAP_ALPN_PROTOCOLS
+      );
+      return { host, tlsAcceptor: tlsAcceptor2 };
+    }
     const handler = (request6, response) => {
       if (host === config2.routedHost && servedByPipeline(request6.url)) {
         config2.serveRouted(request6, response);
@@ -64994,7 +65085,7 @@ async function startConnectServer(config2, effects, preferredPort) {
       await listener.close();
       for (const { httpSession, tlsAcceptor } of sessions) {
         tlsAcceptor.close();
-        httpSession.close();
+        httpSession?.close();
       }
     }
   };
@@ -65170,6 +65261,40 @@ async function blindTunnel(socket, target, effects) {
     socket.destroy();
   });
 }
+function isEnoent5(error62) {
+  return typeof error62 === "object" && error62 !== null && "code" in error62 && error62.code === "ENOENT";
+}
+function realConnectCertStore(paths) {
+  const read = (file2) => {
+    try {
+      return fs12.readFileSync(file2, "utf8");
+    } catch (error62) {
+      if (isEnoent5(error62)) {
+        return void 0;
+      }
+      throw error62;
+    }
+  };
+  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) => {
+      fs12.mkdirSync(paths.frontdoorCaDir, { recursive: true });
+      fs12.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
+      fs12.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
+      fs12.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
+    }
+  };
+}
+
+// src/frontdoor/connectEffects.ts
+var http = __toESM(require("node:http"), 1);
+var https = __toESM(require("node:https"), 1);
+var net3 = __toESM(require("node:net"), 1);
+var tls = __toESM(require("node:tls"), 1);
 function realConnectEffects() {
   const plainAgent = new http.Agent({ keepAlive: true });
   const tlsAgent = new https.Agent({ keepAlive: true });
@@ -65215,10 +65340,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();
       });
@@ -65253,6 +65381,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 = net3.connect({ host, port });
       socket.once("connect", () => {
@@ -65316,34 +65451,6 @@ function realConnectEffects() {
     }
   };
 }
-function isEnoent5(error62) {
-  return typeof error62 === "object" && error62 !== null && "code" in error62 && error62.code === "ENOENT";
-}
-function realConnectCertStore(paths) {
-  const read = (file2) => {
-    try {
-      return fs12.readFileSync(file2, "utf8");
-    } catch (error62) {
-      if (isEnoent5(error62)) {
-        return void 0;
-      }
-      throw error62;
-    }
-  };
-  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) => {
-      fs12.mkdirSync(paths.frontdoorCaDir, { recursive: true });
-      fs12.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
-      fs12.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
-      fs12.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
-    }
-  };
-}
 
 // src/frontdoor/ensure.ts
 var import_node_crypto11 = require("node:crypto");
@@ -66973,6 +67080,7 @@ function realFrontDoorSupervisorPorts(paths) {
       const server = await startConnectServer(
         {
           interceptHosts: CONNECT_INTERCEPT_HOSTS,
+          tapHosts: CONNECT_TAP_HOSTS,
           routedHost: CONNECT_INTERCEPT_HOST,
           serveRouted: (request6, response) => {
             const abort = new AbortController();

package/dist/index.cjs

@@ -1887,10 +1887,6 @@ function recoveryDiagnostics(recovery, identity) {
 // src/frontdoor/connect.ts
 var import_node_crypto3 = require("node:crypto");
 var fs = __toESM(require("node:fs"), 1);
-var http = __toESM(require("node:http"), 1);
-var https = __toESM(require("node:https"), 1);
-var net2 = __toESM(require("node:net"), 1);
-var tls = __toESM(require("node:tls"), 1);
 
 // src/frontdoor/x509.ts
 var import_node_crypto2 = require("node:crypto");
@@ -2163,6 +2159,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";
@@ -2307,23 +2351,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)}`);
   }
@@ -2331,9 +2375,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(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http2.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
+  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(connect2.port)}`);
+  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 (; ; ) {
@@ -2347,7 +2391,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       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(fs3, paths.frontdoorStateFile, sticky());
         return 0;
@@ -2471,9 +2515,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);
@@ -2498,7 +2553,7 @@ async function startConnectServer(config, effects, preferredPort) {
       await listener.close();
       for (const { httpSession, tlsAcceptor } of sessions) {
         tlsAcceptor.close();
-        httpSession.close();
+        httpSession?.close();
       }
     }
   };
@@ -2674,6 +2729,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
+var http = __toESM(require("node:http"), 1);
+var https = __toESM(require("node:https"), 1);
+var net2 = __toESM(require("node:net"), 1);
+var tls = __toESM(require("node:tls"), 1);
 function realConnectEffects() {
   const plainAgent = new http.Agent({ keepAlive: true });
   const tlsAgent = new https.Agent({ keepAlive: true });
@@ -2719,10 +2808,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();
       });
@@ -2757,6 +2849,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", () => {
@@ -2820,34 +2919,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
 var import_node_crypto5 = require("node:crypto");

package/dist/index.mjs

@@ -1787,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";
@@ -2063,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";
@@ -2207,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)}`);
   }
@@ -2231,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(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http2.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
+  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(connect2.port)}`);
+  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 (; ; ) {
@@ -2247,7 +2291,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       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(fs3, paths.frontdoorStateFile, sticky());
         return 0;
@@ -2371,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);
@@ -2398,7 +2453,7 @@ async function startConnectServer(config, effects, preferredPort) {
       await listener.close();
       for (const { httpSession, tlsAcceptor } of sessions) {
         tlsAcceptor.close();
-        httpSession.close();
+        httpSession?.close();
       }
     }
   };
@@ -2574,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 });
@@ -2619,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();
       });
@@ -2657,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", () => {
@@ -2720,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";

package/dist/types/frontdoor/capture.d.ts

@@ -20,8 +20,17 @@ export interface PassthroughObserver {
     readonly onResponseChunk: (chunk: Buffer) => void;
     readonly onEnd: () => void;
 }
+/** The direction one tapped byte chunk flowed, named from the session's point of view. */
+type StreamDirection = "client-to-server" | "server-to-client";
+/** The byte-level tap for one terminated stream whose protocol the surface does not parse: every chunk both directions, then the end. */
+export interface StreamTap {
+    readonly onChunk: (direction: StreamDirection, chunk: Readonly<Buffer>) => void;
+    readonly onEnd: () => void;
+}
 /** The tap the connect surface drives. `undefined` everywhere means "not capturing"; one object covers the whole door process. */
 export interface ConnectCapture {
+    /** Opens the byte-level tap for one host's terminated stream, whose chunks are recorded verbatim (text, or base64 when not valid UTF-8) under the same caps as piped bodies. Optional because a capture can be stream-silent by construction. */
+    readonly tapStream?: (host: string) => StreamTap;
     /** Records one authenticated CONNECT target: the host and port only, since a blind tunnel's bytes are unreadable by construction. */
     readonly connect: (target: {
         readonly host: string;

package/dist/types/frontdoor/connect.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "node:http";
-import * as net from "node:net";
+import type * as net from "node:net";
 import type { ConnectCapture, PassthroughObserver } from "./capture";
 /**
  * The front door's CONNECT surface, so an OAuth session can have agent-shim's routing AND Claude Code's Remote Control at once: Remote Control refuses any `ANTHROPIC_BASE_URL` other than the real API, but happily honours `HTTPS_PROXY`, so OAuth launches route at the proxy layer instead.
@@ -14,10 +14,16 @@ export declare const CONNECT_INTERCEPT_HOST = "api.anthropic.com";
  * Every CONNECT host whose TLS this surface terminates, each with its own leaf and its own HTTP parser: the API host above, and `platform.claude.com`, the claude.ai control plane where Remote Control's long-lived channel and its handshake live. Terminating the second one is what makes a Remote Control login rejection observable at all: its bytes cross this surface either way, and blind-tunnelling them hides exactly the exchange that failed. Only the API host's `/v1/` paths ever reach the routed pipeline; everything else on either session is piped to that session's own real upstream, so the pipeline's identification and authorisation are never asked to serve another host's traffic.
  */
 export declare const CONNECT_INTERCEPT_HOSTS: readonly string[];
+/**
+ * The intercept hosts the surface never parses as HTTP: terminated with ALPN for HTTP/2 and HTTP/1.1 both offered, pumped byte for byte to the real host over TLS (offering upstream only the protocol the client negotiated), and teed into the capture's stream tap when capturing is on. The claude.ai control plane's channel mixes an HTTP/1.1-shaped request with binary HTTP/2 frames, so parsing it as either protocol would destroy or distort it; tapping preserves the channel exactly as a blind tunnel served it while making its bytes observable.
+ */
+export declare const CONNECT_TAP_HOSTS: readonly string[];
 /** Paths under this prefix are what the routed pipeline serves; everything else on the terminated session goes to the real upstream. */
 export declare const ROUTED_PATH_PREFIX = "/v1/";
 /** The port HTTPS is served on, both the default when a CONNECT authority names none and the port non-headroom paths are piped to on the real upstream. */
 export declare const HTTPS_PORT = 443;
+/** What the forwarding effect answers with when the upstream is unreachable. */
+export declare const HTTP_BAD_GATEWAY = 502;
 /** Largest CONNECT request head accepted before the connection is refused: a real head is a request line and a few short headers (Host, the proxy credential, a User-Agent), so anything this size is a confused or hostile client. 8 KiB is also the per-header-line limit common HTTP servers apply by default (nginx's `large_client_header_buffers` buffer, Apache's `LimitRequestFieldSize` of 8190 bytes), so no client is built to need a longer line, and a CONNECT head is a few such lines at most. */
 export declare const MAX_CONNECT_HEAD_BYTES = 8192;
 /**
@@ -112,7 +118,7 @@ interface ConnectForwardTarget {
 /** Handles one parsed HTTP request on a terminated TLS session. */
 type ConnectRequestHandler = (request: IncomingMessage, response: ServerResponse) => void;
 /** A bound loopback listener and how to stop it. */
-interface ConnectListenerHandle {
+export interface ConnectListenerHandle {
     readonly port: number;
     /** Stops accepting, ends every live connection, and resolves once the port is released. */
     readonly close: () => Promise<void>;
@@ -135,8 +141,10 @@ interface HttpParserSession {
 export interface ConnectEffects {
     /** Binds a loopback TCP listener; `preferredPort` is tried first and any free port used when it is taken (bind, do not probe: check-then-bind races). Resolves with the bound port and a close handle. */
     readonly listenLoopback: (preferredPort: number | undefined, onSocket: (socket: net.Socket) => void) => Promise<ConnectListenerHandle>;
-    /** Builds the TLS terminator for one leaf, handing each successfully handshaked session to `onSecure`. */
-    readonly createTlsAcceptor: (leaf: LeafCert, onSecure: (secure: net.Socket) => void) => TlsAcceptor;
+    /** Builds the TLS terminator for one leaf, handing each successfully handshaked session to `onSecure`. `alpnProtocols`, when given, is advertised during the handshake, which is how a tap host's session can offer HTTP/2 the way its real server does. */
+    readonly createTlsAcceptor: (leaf: LeafCert, onSecure: (secure: net.Socket) => void, alpnProtocols?: readonly string[]) => TlsAcceptor;
+    /** Opens a TLS connection to a real host, presenting its name as SNI, for a tap session's upstream half. `clientAlpn`, when given, is the protocol the client negotiated with the surface and the only one offered upstream, so the tap never changes the channel's protocol. */
+    readonly connectTlsUpstream: (host: string, port: number, clientAlpn: string | undefined) => Promise<net.Socket>;
     /** Builds the HTTP parser bound to one request handler. `onUpgrade`, when given, sees every HTTP upgrade request arriving on a terminated session; the session destroys the socket afterwards either way, with or without one, matching Node's own no-listener behaviour. */
     readonly createHttpSession: (handler: ConnectRequestHandler, onUpgrade?: (request: IncomingMessage) => void) => HttpParserSession;
     /** Opens a raw TCP connection for a blind tunnel. */
@@ -162,6 +170,8 @@ export interface ConnectServerConfig {
     readonly upstreamFor: (host: string) => ConnectForwardTarget;
     /** Whether a capability presented as a CONNECT request's proxy credential belongs to a live launch: the same constant-time check against the same registry the routed pipeline's admission makes, read fresh on every call because launches come and go. */
     readonly isLiveCapability: (token: string) => boolean;
+    /** The intercept hosts that are never HTTP-parsed: terminated, tapped at the byte level, and pumped to their real host. */
+    readonly tapHosts: readonly string[];
     /** The connection deadlines and caps; production passes `CONNECT_LIMITS`. */
     readonly limits: ConnectLimits;
     /** The diagnostic tap, when capturing is enabled; absent means nothing is recorded. */
@@ -179,8 +189,6 @@ export interface ConnectServerHandle {
  * The connection flow: read the CONNECT head within the deadline (never more of the stream than that, so an early ClientHello glued to the head is pushed back with `unshift` and still seen by whatever consumes the socket next), authenticate it, then either blind-tunnel the target or terminate its TLS and parse HTTP on the session. Every network effect flows through `effects`; nothing here touches the network or filesystem itself.
  */
 export declare function startConnectServer(config: ConnectServerConfig, effects: ConnectEffects, preferredPort: number | undefined): Promise<ConnectServerHandle>;
-/** The real `ConnectEffects` over node's own net, tls, and http. `connectTcp` opens real connections to the CONNECTed host, so tests that want a blind tunnel redirect it. */
-export declare function realConnectEffects(): ConnectEffects;
 /** The real `ConnectCertStore` on the filesystem: `ca.pem` world-readable (it is public material), `ca.key` mode 0600 exactly, chmod'ed after the write because a create's mode bits pass through the process umask. */
 export declare function realConnectCertStore(paths: {
     readonly frontdoorCaDir: string;

package/dist/types/frontdoor/connectEffects.d.ts

@@ -0,0 +1,3 @@
+import { type ConnectEffects } from "./connect";
+/** The real `ConnectEffects` over node's own net, tls, and http. `connectTcp` opens real connections to the CONNECTed host, so tests that want a blind tunnel redirect it. */
+export declare function realConnectEffects(): ConnectEffects;

package/dist/types/frontdoor/tap.d.ts

@@ -0,0 +1,8 @@
+import type * as net from "node:net";
+import type { StreamTap } from "./capture";
+/**
+ * Pumps one already-TLS-terminated stream byte for byte to its real host over a fresh TLS connection, teeing every chunk in both directions into `tap` when one is given. This is the instrumentation for a host whose protocol the surface does not parse: the claude.ai control plane carries Remote Control on a channel that mixes shapes (observed under capture: an HTTP/1.1-shaped token request first, then binary HTTP/2 frames around it), so parsing it as either protocol would destroy or distort it. Pass everything through unchanged and record, never interpret: the frames are decoded offline, and a protocol the door does not understand keeps working exactly as the blind tunnel served it.
+ *
+ * Lifecycle mirrors `blindTunnel`: whoever goes away first takes the other side with it, so neither half of a tap session ever outlives its peer. The tap's listeners ride beside the pipes, additive like every other observer in this surface, so a recording failure fails loudly rather than silently stopping a diagnostic.
+ */
+export declare function pumpTapSession(secure: net.Socket, openUpstream: (clientAlpn: string | undefined) => Promise<net.Socket>, tap: StreamTap | undefined): void;

package/dist/types/index.d.ts

@@ -12,7 +12,8 @@
 export { resolveDecisions, topLevelNames, type ResolveDecisionsInput, type ResolvedState } from "./resolve/pipeline";
 export type { CompiledRule, Decision, Diagnostic, EliminatedRule, EntryFact, EntryFacts, FlattenedCascade, Layer, LayerId } from "./resolve/types";
 export { buildEntryFacts, carryOver, FARM_MANIFEST_FILENAME, readFarmManifest, recoverFarm, recoveryDiagnostics, resyncFarm, type BuildEntryFactsParams, type CarryOverParams, type CarryOverResult, type RecoverFarmParams, type RecoveryResult, type ResyncFarmParams, type ResyncFarmResult, } from "./launcher/farm";
-export { CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, createLeafCache, ensureCa, forwardableHeaders, generateCa, isInterceptedHost, mintLeaf, parseConnectTarget, realConnectCertStore, realConnectEffects, ROUTED_PATH_PREFIX, servedByPipeline, startConnectServer, type CaMaterial, type ConnectCertStore, type ConnectEffects, type ConnectLimits, type ConnectServerConfig, type ConnectServerHandle, type ConnectTarget, type LeafCert, } from "./frontdoor/connect";
+export { CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, createLeafCache, ensureCa, forwardableHeaders, generateCa, isInterceptedHost, mintLeaf, parseConnectTarget, realConnectCertStore, ROUTED_PATH_PREFIX, servedByPipeline, startConnectServer, type CaMaterial, type ConnectCertStore, type ConnectEffects, type ConnectLimits, type ConnectServerConfig, type ConnectServerHandle, type ConnectTarget, type LeafCert, } from "./frontdoor/connect";
+export { realConnectEffects } from "./frontdoor/connectEffects";
 export { ensureFrontDoor, FrontDoorStartError, type EnsureFrontDoorPorts } from "./frontdoor/ensure";
 export { runFrontDoorSupervisor, type FrontDoorSupervisorPorts, type RunFrontDoorSupervisorOptions } from "./frontdoor/supervisor";
 export { listUsageSnapshots, readUsageSnapshot, snapshotPath, UsageSnapshotError, type UsageReadFs } from "./usage/read";

package/package.json

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