claude-use 9.4.0 → 9.4.1

package/dist/cli.cjs

@@ -20585,7 +20585,7 @@ var require_snippet = __commonJS({
   "node_modules/.pnpm/js-yaml@4.3.2/node_modules/js-yaml/lib/snippet.js"(exports2, module2) {
     "use strict";
     var common = require_common();
-    function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+    function getLine(buffer2, lineStart, lineEnd, position, maxLineLength) {
       let head = "";
       let tail = "";
       const maxHalfLength = Math.floor(maxLineLength / 2) - 1;
@@ -20598,7 +20598,7 @@ var require_snippet = __commonJS({
         lineEnd = position + maxHalfLength - tail.length;
       }
       return {
-        str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail,
+        str: head + buffer2.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail,
         pos: position - lineStart + head.length
         // relative position
       };
@@ -23828,14 +23828,14 @@ var require_util = __commonJS({
       }, source);
     }
     exports2.getPropertyByPath = getPropertyByPath;
-    function decodeFileContent(buffer) {
-      if (buffer[0] === 255 && buffer[1] === 254) {
-        return new TextDecoder("utf-16le").decode(buffer);
+    function decodeFileContent(buffer2) {
+      if (buffer2[0] === 255 && buffer2[1] === 254) {
+        return new TextDecoder("utf-16le").decode(buffer2);
       }
-      if (buffer[0] === 254 && buffer[1] === 255) {
-        return new TextDecoder("utf-16be").decode(buffer);
+      if (buffer2[0] === 254 && buffer2[1] === 255) {
+        return new TextDecoder("utf-16be").decode(buffer2);
       }
-      return buffer.toString("utf-8");
+      return buffer2.toString("utf-8");
     }
     exports2.decodeFileContent = decodeFileContent;
     function removeUndefinedValuesFromObject(options) {
@@ -33224,7 +33224,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.4.0",
+      version: "9.4.1",
       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>",
@@ -35947,11 +35947,11 @@ var require_constants2 = __commonJS({
     var wellknownHeaderNameBuffers = {};
     Object.setPrototypeOf(wellknownHeaderNameBuffers, null);
     function getHeaderNameAsBuffer(header) {
-      let buffer = wellknownHeaderNameBuffers[header];
-      if (buffer === void 0) {
-        buffer = Buffer.from(header);
+      let buffer2 = wellknownHeaderNameBuffers[header];
+      if (buffer2 === void 0) {
+        buffer2 = Buffer.from(header);
       }
-      return buffer;
+      return buffer2;
     }
     for (let i10 = 0; i10 < wellknownHeaderNames.length; ++i10) {
       const key = wellknownHeaderNames[i10];
@@ -36382,8 +36382,8 @@ var require_util2 = __commonJS({
       }
       return headers.map((x) => Buffer.from(x));
     }
-    function isBuffer(buffer) {
-      return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
+    function isBuffer(buffer2) {
+      return buffer2 instanceof Uint8Array || Buffer.isBuffer(buffer2);
     }
     function assertRequestHandler(handler, method, upgrade) {
       if (!handler || typeof handler !== "object") {
@@ -38984,14 +38984,14 @@ var require_encoding = __commonJS({
   "node_modules/.pnpm/undici@7.29.1/node_modules/undici/lib/encoding/index.js"(exports2, module2) {
     "use strict";
     var textDecoder = new TextDecoder();
-    function utf8DecodeBytes(buffer) {
-      if (buffer.length === 0) {
+    function utf8DecodeBytes(buffer2) {
+      if (buffer2.length === 0) {
         return "";
       }
-      if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
-        buffer = buffer.subarray(3);
+      if (buffer2[0] === 239 && buffer2[1] === 187 && buffer2[2] === 191) {
+        buffer2 = buffer2.subarray(3);
       }
-      const output2 = textDecoder.decode(buffer);
+      const output2 = textDecoder.decode(buffer2);
       return output2;
     }
     module2.exports = {
@@ -39042,8 +39042,8 @@ var require_infra = __commonJS({
       if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
         return "failure";
       }
-      const buffer = Buffer.from(data, "base64");
-      return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const buffer2 = Buffer.from(data, "base64");
+      return new Uint8Array(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength);
     }
     function isASCIIWhitespace(char) {
       return char === 9 || // \t
@@ -41309,12 +41309,12 @@ var require_formdata_parser = __commonJS({
       }
       return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1);
     }
-    function bufferStartsWith(buffer, start, position) {
-      if (buffer.length < start.length) {
+    function bufferStartsWith(buffer2, start, position) {
+      if (buffer2.length < start.length) {
         return false;
       }
       for (let i10 = 0; i10 < start.length; i10++) {
-        if (start[i10] !== buffer[position.position + i10]) {
+        if (start[i10] !== buffer2[position.position + i10]) {
           return false;
         }
       }
@@ -42739,14 +42739,14 @@ upgrade: ${upgrade}\r
         if (contentLength != null && contentLength !== body.size) {
           throw new RequestContentLengthMismatchError();
         }
-        const buffer = Buffer.from(await body.arrayBuffer());
+        const buffer2 = Buffer.from(await body.arrayBuffer());
         socket.cork();
         socket.write(`${header}content-length: ${contentLength}\r
 \r
 `, "latin1");
-        socket.write(buffer);
+        socket.write(buffer2);
         socket.uncork();
-        request7.onBodySent(buffer);
+        request7.onBodySent(buffer2);
         request7.onRequestSent();
         if (!expectsPayload && request7.reset !== false) {
           socket[kReset] = true;
@@ -43622,12 +43622,12 @@ var require_client_h2 = __commonJS({
         if (contentLength != null && contentLength !== body.size) {
           throw new RequestContentLengthMismatchError();
         }
-        const buffer = Buffer.from(await body.arrayBuffer());
+        const buffer2 = Buffer.from(await body.arrayBuffer());
         h2stream.cork();
-        h2stream.write(buffer);
+        h2stream.write(buffer2);
         h2stream.uncork();
         h2stream.end();
-        request7.onBodySent(buffer);
+        request7.onBodySent(buffer2);
         request7.onRequestSent();
         if (!expectsPayload) {
           socket[kReset] = true;
@@ -44997,7 +44997,7 @@ var require_socks5_utils = __commonJS({
       };
     }
     function parseIPv6(address) {
-      const buffer = Buffer3.alloc(16);
+      const buffer2 = Buffer3.alloc(16);
       let normalizedAddress = address;
       if (address.includes(".")) {
         const lastColonIndex = address.lastIndexOf(":");
@@ -45017,21 +45017,21 @@ var require_socks5_utils = __commonJS({
         const afterParts = after === "" ? [] : after.split(":");
         let bufferIndex = 0;
         for (const part of beforeParts) {
-          buffer.writeUInt16BE(parseInt(part, 16), bufferIndex);
+          buffer2.writeUInt16BE(parseInt(part, 16), bufferIndex);
           bufferIndex += 2;
         }
         bufferIndex = 16 - afterParts.length * 2;
         for (const part of afterParts) {
-          buffer.writeUInt16BE(parseInt(part, 16), bufferIndex);
+          buffer2.writeUInt16BE(parseInt(part, 16), bufferIndex);
           bufferIndex += 2;
         }
       } else {
         const parts = normalizedAddress.split(":");
         for (let i10 = 0; i10 < parts.length; i10++) {
-          buffer.writeUInt16BE(parseInt(parts[i10], 16), i10 * 2);
+          buffer2.writeUInt16BE(parseInt(parts[i10], 16), i10 * 2);
         }
       }
-      return buffer;
+      return buffer2;
     }
     function buildAddressBuffer(type2, addressBuffer, port) {
       const portBuffer = Buffer3.allocUnsafe(2);
@@ -45042,42 +45042,42 @@ var require_socks5_utils = __commonJS({
         portBuffer
       ]);
     }
-    function parseResponseAddress(buffer, offset = 0) {
-      if (buffer.length < offset + 1) {
+    function parseResponseAddress(buffer2, offset = 0) {
+      if (buffer2.length < offset + 1) {
         throw new InvalidArgumentError2("Buffer too small to contain address type");
       }
-      const addressType = buffer[offset];
+      const addressType = buffer2[offset];
       let address;
       let currentOffset = offset + 1;
       switch (addressType) {
         case 1: {
-          if (buffer.length < currentOffset + 6) {
+          if (buffer2.length < currentOffset + 6) {
             throw new InvalidArgumentError2("Buffer too small for IPv4 address");
           }
-          address = Array.from(buffer.subarray(currentOffset, currentOffset + 4)).join(".");
+          address = Array.from(buffer2.subarray(currentOffset, currentOffset + 4)).join(".");
           currentOffset += 4;
           break;
         }
         case 3: {
-          if (buffer.length < currentOffset + 1) {
+          if (buffer2.length < currentOffset + 1) {
             throw new InvalidArgumentError2("Buffer too small for domain length");
           }
-          const domainLength = buffer[currentOffset];
+          const domainLength = buffer2[currentOffset];
           currentOffset += 1;
-          if (buffer.length < currentOffset + domainLength + 2) {
+          if (buffer2.length < currentOffset + domainLength + 2) {
             throw new InvalidArgumentError2("Buffer too small for domain address");
           }
-          address = buffer.subarray(currentOffset, currentOffset + domainLength).toString("utf8");
+          address = buffer2.subarray(currentOffset, currentOffset + domainLength).toString("utf8");
           currentOffset += domainLength;
           break;
         }
         case 4: {
-          if (buffer.length < currentOffset + 18) {
+          if (buffer2.length < currentOffset + 18) {
             throw new InvalidArgumentError2("Buffer too small for IPv6 address");
           }
           const parts = [];
           for (let i10 = 0; i10 < 8; i10++) {
-            const value2 = buffer.readUInt16BE(currentOffset + i10 * 2);
+            const value2 = buffer2.readUInt16BE(currentOffset + i10 * 2);
             parts.push(value2.toString(16));
           }
           address = parts.join(":");
@@ -45087,10 +45087,10 @@ var require_socks5_utils = __commonJS({
         default:
           throw new InvalidArgumentError2(`Invalid address type: ${addressType}`);
       }
-      if (buffer.length < currentOffset + 2) {
+      if (buffer2.length < currentOffset + 2) {
         throw new InvalidArgumentError2("Buffer too small for port");
       }
-      const port = buffer.readUInt16BE(currentOffset);
+      const port = buffer2.readUInt16BE(currentOffset);
       currentOffset += 2;
       return {
         address,
@@ -46803,13 +46803,13 @@ var require_readable = __commonJS({
       if (chunks.length === 0 || length === 0) {
         return "";
       }
-      const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length);
-      const bufferLength = buffer.length;
-      const start = bufferLength > 2 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191 ? 3 : 0;
+      const buffer2 = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length);
+      const bufferLength = buffer2.length;
+      const start = bufferLength > 2 && buffer2[0] === 239 && buffer2[1] === 187 && buffer2[2] === 191 ? 3 : 0;
       if (!encoding || encoding === "utf8" || encoding === "utf-8") {
-        return buffer.utf8Slice(start, bufferLength);
+        return buffer2.utf8Slice(start, bufferLength);
       } else {
-        return buffer.subarray(start, bufferLength).toString(encoding);
+        return buffer2.subarray(start, bufferLength).toString(encoding);
       }
     }
     function chunksConcat(chunks, length) {
@@ -46819,14 +46819,14 @@ var require_readable = __commonJS({
       if (chunks.length === 1) {
         return new Uint8Array(chunks[0]);
       }
-      const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer);
+      const buffer2 = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer);
       let offset = 0;
       for (let i10 = 0; i10 < chunks.length; ++i10) {
         const chunk = chunks[i10];
-        buffer.set(chunk, offset);
+        buffer2.set(chunk, offset);
         offset += chunk.length;
       }
-      return buffer;
+      return buffer2;
     }
     function consumeEnd(consume2, encoding) {
       const { type: type2, body, resolve: resolve2, stream, length } = consume2;
@@ -56525,9 +56525,9 @@ var require_fetch = __commonJS({
             fetchParams.controller.terminate(bytes);
             return;
           }
-          const buffer = new Uint8Array(bytes);
-          if (buffer.byteLength) {
-            fetchParams.controller.controller.enqueue(buffer);
+          const buffer2 = new Uint8Array(bytes);
+          if (buffer2.byteLength) {
+            fetchParams.controller.controller.enqueue(buffer2);
           }
           if (isErrored(stream)) {
             fetchParams.controller.terminate();
@@ -58279,11 +58279,11 @@ var require_util6 = __commonJS({
     function websocketMessageReceived(handler, type2, data) {
       handler.onMessage(type2, data);
     }
-    function toArrayBuffer(buffer) {
-      if (buffer.byteLength === buffer.buffer.byteLength) {
-        return buffer.buffer;
+    function toArrayBuffer(buffer2) {
+      if (buffer2.byteLength === buffer2.buffer.byteLength) {
+        return buffer2.buffer;
       }
-      return new Uint8Array(buffer).buffer;
+      return new Uint8Array(buffer2).buffer;
     }
     function isValidSubprotocol(protocol) {
       if (protocol.length === 0) {
@@ -58399,9 +58399,9 @@ var require_util6 = __commonJS({
         const fatalDecoder = new TextDecoder("utf-8", { fatal: true });
         return fatalDecoder.decode.bind(fatalDecoder);
       }
-      return function(buffer) {
-        if (isUtf8(buffer)) {
-          return buffer.toString("utf-8");
+      return function(buffer2) {
+        if (isUtf8(buffer2)) {
+          return buffer2.toString("utf-8");
         }
         throw new TypeError("Invalid utf-8 received.");
       };
@@ -58436,20 +58436,20 @@ var require_frame = __commonJS({
     var { runtimeFeatures } = require_runtime_features();
     var { maxUnsigned16Bit, opcodes } = require_constants6();
     var BUFFER_SIZE = 8 * 1024;
-    var buffer = null;
+    var buffer2 = null;
     var bufIdx = BUFFER_SIZE;
-    var randomFillSync = runtimeFeatures.has("crypto") ? require("node:crypto").randomFillSync : function randomFillSync2(buffer2, _offset, _size2) {
-      for (let i10 = 0; i10 < buffer2.length; ++i10) {
-        buffer2[i10] = Math.random() * 255 | 0;
+    var randomFillSync = runtimeFeatures.has("crypto") ? require("node:crypto").randomFillSync : function randomFillSync2(buffer3, _offset, _size2) {
+      for (let i10 = 0; i10 < buffer3.length; ++i10) {
+        buffer3[i10] = Math.random() * 255 | 0;
       }
-      return buffer2;
+      return buffer3;
     };
     function generateMask() {
       if (bufIdx === BUFFER_SIZE) {
         bufIdx = 0;
-        randomFillSync(buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE), 0, BUFFER_SIZE);
+        randomFillSync(buffer2 ??= Buffer.allocUnsafeSlow(BUFFER_SIZE), 0, BUFFER_SIZE);
       }
-      return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]];
+      return [buffer2[bufIdx++], buffer2[bufIdx++], buffer2[bufIdx++], buffer2[bufIdx++]];
     }
     var WebsocketFrameSend = class {
       /**
@@ -58471,35 +58471,35 @@ var require_frame = __commonJS({
           offset += 2;
           payloadLength = 126;
         }
-        const buffer2 = Buffer.allocUnsafe(bodyLength + offset);
-        buffer2[0] = buffer2[1] = 0;
-        buffer2[0] |= 128;
-        buffer2[0] = (buffer2[0] & 240) + opcode;
-        buffer2[offset - 4] = maskKey[0];
-        buffer2[offset - 3] = maskKey[1];
-        buffer2[offset - 2] = maskKey[2];
-        buffer2[offset - 1] = maskKey[3];
-        buffer2[1] = payloadLength;
+        const buffer3 = Buffer.allocUnsafe(bodyLength + offset);
+        buffer3[0] = buffer3[1] = 0;
+        buffer3[0] |= 128;
+        buffer3[0] = (buffer3[0] & 240) + opcode;
+        buffer3[offset - 4] = maskKey[0];
+        buffer3[offset - 3] = maskKey[1];
+        buffer3[offset - 2] = maskKey[2];
+        buffer3[offset - 1] = maskKey[3];
+        buffer3[1] = payloadLength;
         if (payloadLength === 126) {
-          buffer2.writeUInt16BE(bodyLength, 2);
+          buffer3.writeUInt16BE(bodyLength, 2);
         } else if (payloadLength === 127) {
-          buffer2[2] = buffer2[3] = 0;
-          buffer2.writeUIntBE(bodyLength, 4, 6);
+          buffer3[2] = buffer3[3] = 0;
+          buffer3.writeUIntBE(bodyLength, 4, 6);
         }
-        buffer2[1] |= 128;
+        buffer3[1] |= 128;
         for (let i10 = 0; i10 < bodyLength; ++i10) {
-          buffer2[offset + i10] = frameData[i10] ^ maskKey[i10 & 3];
+          buffer3[offset + i10] = frameData[i10] ^ maskKey[i10 & 3];
         }
-        return buffer2;
+        return buffer3;
       }
       /**
        * @param {Uint8Array} buffer
        */
-      static createFastTextFrame(buffer2) {
+      static createFastTextFrame(buffer3) {
         const maskKey = generateMask();
-        const bodyLength = buffer2.length;
+        const bodyLength = buffer3.length;
         for (let i10 = 0; i10 < bodyLength; ++i10) {
-          buffer2[i10] ^= maskKey[i10 & 3];
+          buffer3[i10] ^= maskKey[i10 & 3];
         }
         let payloadLength = bodyLength;
         let offset = 6;
@@ -58523,7 +58523,7 @@ var require_frame = __commonJS({
           head[2] = head[3] = 0;
           head.writeUIntBE(bodyLength, 4, 6);
         }
-        return [head, buffer2];
+        return [head, buffer3];
       }
     };
     module2.exports = {
@@ -58851,15 +58851,15 @@ var require_receiver = __commonJS({
             if (this.#byteOffset < 2) {
               return callback();
             }
-            const buffer = this.consume(2);
-            const fin = (buffer[0] & 128) !== 0;
-            const opcode = buffer[0] & 15;
-            const masked = (buffer[1] & 128) === 128;
+            const buffer2 = this.consume(2);
+            const fin = (buffer2[0] & 128) !== 0;
+            const opcode = buffer2[0] & 15;
+            const masked = (buffer2[1] & 128) === 128;
             const fragmented = !fin && opcode !== opcodes.CONTINUATION;
-            const payloadLength = buffer[1] & 127;
-            const rsv1 = buffer[0] & 64;
-            const rsv2 = buffer[0] & 32;
-            const rsv3 = buffer[0] & 16;
+            const payloadLength = buffer2[1] & 127;
+            const rsv1 = buffer2[0] & 64;
+            const rsv2 = buffer2[0] & 32;
+            const rsv3 = buffer2[0] & 16;
             if (!isValidOpcode(opcode)) {
               failWebsocketConnection(this.#handler, 1002, "Invalid opcode received");
               return callback();
@@ -58919,8 +58919,8 @@ var require_receiver = __commonJS({
             if (this.#byteOffset < 2) {
               return callback();
             }
-            const buffer = this.consume(2);
-            this.#info.payloadLength = buffer.readUInt16BE(0);
+            const buffer2 = this.consume(2);
+            this.#info.payloadLength = buffer2.readUInt16BE(0);
             this.#state = parserStates.READ_DATA;
             if (!this.#validatePayloadLength()) {
               return;
@@ -58929,9 +58929,9 @@ var require_receiver = __commonJS({
             if (this.#byteOffset < 8) {
               return callback();
             }
-            const buffer = this.consume(8);
-            const upper = buffer.readUInt32BE(0);
-            const lower = buffer.readUInt32BE(4);
+            const buffer2 = this.consume(8);
+            const upper = buffer2.readUInt32BE(0);
+            const lower = buffer2.readUInt32BE(4);
             if (upper !== 0 || lower > 2 ** 31 - 1) {
               failWebsocketConnection(this.#handler, 1009, "Received payload length > 2^31 bytes.");
               return;
@@ -59015,23 +59015,23 @@ var require_receiver = __commonJS({
           return this.#buffers.shift();
         } else {
           let offset = 0;
-          const buffer = Buffer.allocUnsafeSlow(n10);
+          const buffer2 = Buffer.allocUnsafeSlow(n10);
           while (offset !== n10) {
             const next = this.#buffers[0];
             const length = next.length;
             if (length + offset === n10) {
-              buffer.set(this.#buffers.shift(), offset);
+              buffer2.set(this.#buffers.shift(), offset);
               break;
             } else if (length + offset > n10) {
-              buffer.set(next.subarray(0, n10 - offset), offset);
+              buffer2.set(next.subarray(0, n10 - offset), offset);
               this.#buffers[0] = next.subarray(n10 - offset);
               break;
             } else {
-              buffer.set(this.#buffers.shift(), offset);
+              buffer2.set(this.#buffers.shift(), offset);
               offset += length;
             }
           }
-          return buffer;
+          return buffer2;
         }
       }
       writeFragments(fragment) {
@@ -59052,9 +59052,9 @@ var require_receiver = __commonJS({
         let offset = 0;
         const output2 = Buffer.allocUnsafeSlow(this.#fragmentsBytes);
         for (let i10 = 0; i10 < fragments.length; ++i10) {
-          const buffer = fragments[i10];
-          output2.set(buffer, offset);
-          offset += buffer.length;
+          const buffer2 = fragments[i10];
+          output2.set(buffer2, offset);
+          offset += buffer2.length;
         }
         this.#fragments = [];
         this.#fragmentsBytes = 0;
@@ -59381,10 +59381,10 @@ var require_websocket = __commonJS({
           return;
         }
         if (typeof data === "string") {
-          const buffer = Buffer.from(data);
-          this.#bufferedAmount += buffer.byteLength;
-          this.#sendQueue.add(buffer, () => {
-            this.#bufferedAmount -= buffer.byteLength;
+          const buffer2 = Buffer.from(data);
+          this.#bufferedAmount += buffer2.byteLength;
+          this.#sendQueue.add(buffer2, () => {
+            this.#bufferedAmount -= buffer2.byteLength;
           }, sendHints.text);
         } else if (isArrayBuffer(data)) {
           this.#bufferedAmount += data.byteLength;
@@ -59608,17 +59608,17 @@ var require_websocket = __commonJS({
        * @param {WebSocket} ws
        * @param {Buffer|undefined} buffer
        */
-      static ping(ws, buffer) {
-        if (Buffer.isBuffer(buffer)) {
-          if (buffer.length > 125) {
+      static ping(ws, buffer2) {
+        if (Buffer.isBuffer(buffer2)) {
+          if (buffer2.length > 125) {
             throw new TypeError("A PING frame cannot have a body larger than 125 bytes.");
           }
-        } else if (buffer !== void 0) {
+        } else if (buffer2 !== void 0) {
           throw new TypeError("Expected buffer payload");
         }
         const readyState = ws.#handler.readyState;
         if (isEstablished(readyState) && !isClosing(readyState) && !isClosed(readyState)) {
-          const frame = new WebsocketFrameSend(buffer);
+          const frame = new WebsocketFrameSend(buffer2);
           ws.#handler.socket.write(frame.createFrame(opcodes.PING));
         }
       }
@@ -60135,20 +60135,20 @@ var require_eventsource_stream = __commonJS({
     var EVENT = Buffer.from("event");
     var ID2 = Buffer.from("id");
     var RETRY = Buffer.from("retry");
-    function isASCIINumberBytes(buffer, start) {
-      if (start >= buffer.length) {
+    function isASCIINumberBytes(buffer2, start) {
+      if (start >= buffer2.length) {
         return false;
       }
-      for (let i10 = start; i10 < buffer.length; i10++) {
-        if (buffer[i10] < 48 || buffer[i10] > 57) {
+      for (let i10 = start; i10 < buffer2.length; i10++) {
+        if (buffer2[i10] < 48 || buffer2[i10] > 57) {
           return false;
         }
       }
       return true;
     }
-    function isValidLastEventIdBytes(buffer, start) {
-      for (let i10 = start; i10 < buffer.length; i10++) {
-        if (buffer[i10] === 0) {
+    function isValidLastEventIdBytes(buffer2, start) {
+      for (let i10 = start; i10 < buffer2.length; i10++) {
+        if (buffer2[i10] === 0) {
           return false;
         }
       }
@@ -104432,9 +104432,9 @@ function ipBytes(address) {
 function keyIdentifier(publicKey) {
   return (0, import_node_crypto16.createHash)("sha1").update(publicKey.export({ type: "pkcs1", format: "der" })).digest();
 }
-function readElement(buffer, offset) {
-  const tag = buffer[offset];
-  const first = buffer[offset + 1];
+function readElement(buffer2, offset) {
+  const tag = buffer2[offset];
+  const first = buffer2[offset + 1];
   if (tag === void 0 || first === void 0) {
     throw new Error("truncated DER");
   }
@@ -104444,7 +104444,7 @@ function readElement(buffer, offset) {
     const count = first & BASE_128_PAYLOAD_MASK;
     length = 0;
     for (let index = 0; index < count; index += 1) {
-      length = length * (BYTE_MASK + 1) + (buffer[offset + 2 + index] ?? 0);
+      length = length * (BYTE_MASK + 1) + (buffer2[offset + 2 + index] ?? 0);
     }
     contentStart = offset + 2 + count;
   }
@@ -105000,11 +105000,11 @@ function handleConnect(socket, context) {
     socket.destroy();
   });
   context.ledger.accept(socket);
-  let buffer = Buffer.alloc(0);
+  let buffer2 = Buffer.alloc(0);
   const onData = (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-    const headEnd = buffer.indexOf(HEAD_TERMINATOR);
-    if (headEnd === -1 ? buffer.length > MAX_CONNECT_HEAD_BYTES : headEnd > MAX_CONNECT_HEAD_BYTES) {
+    buffer2 = Buffer.concat([buffer2, chunk]);
+    const headEnd = buffer2.indexOf(HEAD_TERMINATOR);
+    if (headEnd === -1 ? buffer2.length > MAX_CONNECT_HEAD_BYTES : headEnd > MAX_CONNECT_HEAD_BYTES) {
       context.ledger.headReceived(socket);
       refuse(socket, REFUSAL.headTooLarge);
       return;
@@ -105015,8 +105015,8 @@ function handleConnect(socket, context) {
     socket.removeListener("data", onData);
     socket.pause();
     context.ledger.headReceived(socket);
-    const head = buffer.subarray(0, headEnd).toString("utf8");
-    socket.unshift(buffer.subarray(headEnd + HEAD_TERMINATOR.length));
+    const head = buffer2.subarray(0, headEnd).toString("utf8");
+    socket.unshift(buffer2.subarray(headEnd + HEAD_TERMINATOR.length));
     routeConnect(socket, head, context);
   };
   socket.on("data", onData);
@@ -113315,6 +113315,7 @@ function createLaunchEventPublisher(hub, now) {
 
 // src/frontdoor/headroomHop.ts
 var http4 = __toESM(require("node:http"), 1);
+var import_consumers = require("node:stream/consumers");
 init_route();
 var HTTP_BAD_GATEWAY2 = HTTP_STATUS.badGateway;
 function responseHeaders(headers) {
@@ -113376,9 +113377,31 @@ async function answerBadGateway(response, message) {
   response.end();
 }
 var HOP_AGENT = new http4.Agent({ keepAlive: false });
+var HOP_RESET_RETRIES = 1;
+var HOP_RESET_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "EPIPE"]);
+async function collectBody(request7) {
+  try {
+    return await (0, import_consumers.buffer)(request7.body);
+  } catch {
+    return void 0;
+  }
+}
 async function forwardThroughHeadroom(request7, response, target) {
+  const body = await collectBody(request7);
+  if (body === void 0) {
+    response.destroy();
+    return;
+  }
+  for (let retriesLeft = HOP_RESET_RETRIES; ; retriesLeft -= 1) {
+    const outcome = await hopOnce(request7, response, target, body, retriesLeft > 0);
+    if (outcome === "settled") {
+      return;
+    }
+  }
+}
+async function hopOnce(request7, response, target, body, mayRetry) {
   const { socketPath, headers } = target;
-  await new Promise((resolve2) => {
+  return await new Promise((resolve2) => {
     const onUpstreamResponse = (upstreamResponse) => {
       response.start(upstreamResponse.statusCode ?? HTTP_BAD_GATEWAY2, responseHeaders(upstreamResponse.headers));
       response.flush();
@@ -113399,12 +113422,18 @@ async function forwardThroughHeadroom(request7, response, target) {
           }
           response.destroy();
         }
-        resolve2(void 0);
+        resolve2("settled");
       };
       void stream();
     };
     const hop = http4.request({ socketPath, method: request7.method, path: request7.url, headers, agent: HOP_AGENT }, onUpstreamResponse);
     hop.on("error", (error62) => {
+      const resetCode = "code" in error62 && typeof error62.code === "string" ? error62.code : void 0;
+      if (mayRetry && !response.headersSent && !request7.signal.aborted && resetCode !== void 0 && HOP_RESET_CODES.has(resetCode)) {
+        target.log(`front door: headroom hop to ${socketPath} reset before the response started (${request7.method} ${new URL(request7.url, "http://127.0.0.1").pathname}, ${String(body.length)} request bytes): ${error62.message} ${resetCode}; replaying once`);
+        resolve2("retry");
+        return;
+      }
       const phase = response.headersSent ? "mid-stream" : "before the response started";
       const code = "code" in error62 && typeof error62.code === "string" ? ` ${error62.code}` : "";
       target.log(`front door: headroom hop to ${socketPath} failed (${request7.method} ${new URL(request7.url, "http://127.0.0.1").pathname}, ${phase}): ${error62.message}${code}`);
@@ -113416,15 +113445,12 @@ async function forwardThroughHeadroom(request7, response, target) {
       } else {
         response.destroy();
       }
-      resolve2(void 0);
+      resolve2("settled");
     });
     request7.signal.addEventListener("abort", () => {
       hop.destroy();
     });
-    request7.body.pipe(hop);
-    request7.body.on("error", () => {
-      hop.destroy();
-    });
+    hop.end(body);
   });
 }
 
@@ -113906,7 +113932,7 @@ var CodexErrorEnvelopeSchema = external_exports.looseObject({
 });
 async function* parseSse(body) {
   const decoder = new TextDecoder();
-  let buffer = "";
+  let buffer2 = "";
   let data = "";
   const parsed = function* (raw) {
     try {
@@ -113915,11 +113941,11 @@ async function* parseSse(body) {
     }
   };
   for await (const chunk of body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    let newline = buffer.indexOf("\n");
+    buffer2 += decoder.decode(chunk, { stream: true });
+    let newline = buffer2.indexOf("\n");
     while (newline !== -1) {
-      const line = buffer.slice(0, newline).replace(/\r$/, "");
-      buffer = buffer.slice(newline + 1);
+      const line = buffer2.slice(0, newline).replace(/\r$/, "");
+      buffer2 = buffer2.slice(newline + 1);
       if (line === "") {
         if (data !== "") {
           yield* parsed(data);
@@ -113928,10 +113954,10 @@ async function* parseSse(body) {
       } else if (line.startsWith("data:")) {
         data += line.slice("data:".length).trimStart();
       }
-      newline = buffer.indexOf("\n");
+      newline = buffer2.indexOf("\n");
     }
   }
-  const tail = (buffer + decoder.decode()).replace(/\r$/, "");
+  const tail = (buffer2 + decoder.decode()).replace(/\r$/, "");
   if (tail.startsWith("data:")) {
     data += tail.slice("data:".length).trimStart();
   }
@@ -117168,7 +117194,7 @@ function isSuccessful4(status) {
   return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE4;
 }
 function createSseParser() {
-  let buffer = "";
+  let buffer2 = "";
   let eventName;
   let eventId;
   let dataLines = [];
@@ -117180,21 +117206,21 @@ function createSseParser() {
         seenAnyText = true;
         incoming = incoming.charCodeAt(0) === SSE_BYTE_ORDER_MARK ? incoming.slice(1) : incoming;
       }
-      buffer += incoming;
+      buffer2 += incoming;
       const completed = [];
       for (; ; ) {
-        const carriage = buffer.indexOf("\r");
-        const lineFeed = buffer.indexOf("\n");
+        const carriage = buffer2.indexOf("\r");
+        const lineFeed = buffer2.indexOf("\n");
         const end = carriage === -1 ? lineFeed : lineFeed === -1 ? carriage : carriage < lineFeed ? carriage : lineFeed;
         if (end === -1) {
           break;
         }
-        if (buffer[end] === "\r" && end === buffer.length - 1) {
+        if (buffer2[end] === "\r" && end === buffer2.length - 1) {
           break;
         }
-        const after = buffer[end] === "\r" && buffer[end + 1] === "\n" ? end + 2 : end + 1;
-        const line = buffer.slice(0, end);
-        buffer = buffer.slice(after);
+        const after = buffer2[end] === "\r" && buffer2[end + 1] === "\n" ? end + 2 : end + 1;
+        const line = buffer2.slice(0, end);
+        buffer2 = buffer2.slice(after);
         if (line === "") {
           if (dataLines.length > 0) {
             completed.push({ event: eventName, id: eventId, data: dataLines.join("\n") });
@@ -119000,9 +119026,9 @@ var realUpdatePorts = {
         throw error62;
       }
       try {
-        const buffer = Buffer.alloc(length);
-        const read = import_node_fs18.default.readSync(descriptor, buffer, 0, length, 0);
-        return read === 0 ? "" : buffer.toString("latin1", 0, read);
+        const buffer2 = Buffer.alloc(length);
+        const read = import_node_fs18.default.readSync(descriptor, buffer2, 0, length, 0);
+        return read === 0 ? "" : buffer2.toString("latin1", 0, read);
       } finally {
         import_node_fs18.default.closeSync(descriptor);
       }

package/dist/index.cjs

@@ -2649,7 +2649,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.4.0",
+      version: "9.4.1",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",

package/dist/index.mjs

@@ -2625,7 +2625,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.4.0",
+      version: "9.4.1",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",

package/package.json

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