@ex-machina/opencode-anthropic-auth 1.8.2 → 1.8.3

package/README.md

@@ -31,7 +31,7 @@ Add the plugin to your OpenCode configuration:
 
 ```json
 {
-  "plugin": ["@ex-machina/opencode-anthropic-auth@1.8.1"]
+  "plugin": ["@ex-machina/opencode-anthropic-auth@1.8.2"]
 }
 ```
 

package/dist/transform.d.ts

@@ -1,3 +1,5 @@
+export declare const MAX_SSE_LINE_BYTES: number;
+export declare const MAX_JSON_TOOL_NAME_BYTES = 1024;
 export type FetchInput = string | URL | Request;
 /**
  * Merge headers from a Request object and/or a RequestInit headers value

package/dist/transform.js

@@ -1,5 +1,208 @@
 import { buildBillingHeaderValue } from "./cch.js";
 import { CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY_PREFIX, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, USER_AGENT, } from "./constants.js";
+// Bound an incomplete SSE line so malformed streams cannot grow memory forever.
+export const MAX_SSE_LINE_BYTES = 5 * 1024 * 1024;
+function headersAfterBodyTransform(source) {
+    const headers = new Headers(source);
+    for (const name of [
+        'content-digest',
+        'content-encoding',
+        'content-length',
+        'content-md5',
+        'content-range',
+        'digest',
+        'etag',
+    ]) {
+        headers.delete(name);
+    }
+    return headers;
+}
+const JSON_NAME_KEY_SUFFIX = new TextEncoder().encode('name"');
+const JSON_TOOL_PREFIX = new TextEncoder().encode(TOOL_PREFIX);
+const UTF8_ENCODER = new TextEncoder();
+const UTF8_FATAL_DECODER = new TextDecoder('utf-8', { fatal: true });
+export const MAX_JSON_TOOL_NAME_BYTES = 1024;
+function isJsonWhitespace(byte) {
+    return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
+}
+/**
+ * Rewrite JSON `name` string values without buffering the whole document.
+ * Only a bounded tool-name candidate is retained across chunks; all document
+ * content outside that string value is emitted immediately.
+ */
+function createJsonToolNameStream(body) {
+    let state = 'outside';
+    let held = [];
+    let candidateIndex = 0;
+    let escaped = false;
+    const enterStringAfter = (byte) => {
+        if (byte === 0x22) {
+            state = 'outside';
+            escaped = false;
+            return;
+        }
+        state = 'string';
+        escaped = byte === 0x5c;
+    };
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            const output = new Uint8Array(chunk.byteLength + 32);
+            let outputLength = 0;
+            const write = (byte) => {
+                output[outputLength++] = byte;
+            };
+            const enqueueOutput = () => {
+                if (outputLength === 0)
+                    return;
+                controller.enqueue(output.slice(0, outputLength));
+                outputLength = 0;
+            };
+            const writeHeld = () => {
+                for (const byte of held)
+                    write(byte);
+                held = [];
+            };
+            const processOutside = (byte) => {
+                if (byte === 0x22) {
+                    held = [byte];
+                    candidateIndex = 0;
+                    state = 'key-candidate';
+                    return;
+                }
+                write(byte);
+            };
+            for (const byte of chunk) {
+                if (state === 'outside') {
+                    processOutside(byte);
+                    continue;
+                }
+                if (state === 'key-candidate') {
+                    if (byte === JSON_NAME_KEY_SUFFIX[candidateIndex]) {
+                        held.push(byte);
+                        candidateIndex++;
+                        if (candidateIndex === JSON_NAME_KEY_SUFFIX.byteLength) {
+                            writeHeld();
+                            state = 'after-name-key';
+                        }
+                        continue;
+                    }
+                    writeHeld();
+                    write(byte);
+                    enterStringAfter(byte);
+                    continue;
+                }
+                if (state === 'string') {
+                    write(byte);
+                    if (escaped) {
+                        escaped = false;
+                    }
+                    else if (byte === 0x5c) {
+                        escaped = true;
+                    }
+                    else if (byte === 0x22) {
+                        state = 'outside';
+                    }
+                    continue;
+                }
+                if (state === 'after-name-key') {
+                    if (isJsonWhitespace(byte)) {
+                        write(byte);
+                    }
+                    else if (byte === 0x3a) {
+                        write(byte);
+                        state = 'after-colon';
+                    }
+                    else {
+                        processOutside(byte);
+                    }
+                    continue;
+                }
+                if (state === 'after-colon') {
+                    if (isJsonWhitespace(byte)) {
+                        write(byte);
+                    }
+                    else if (byte === 0x22) {
+                        write(byte);
+                        held = [];
+                        candidateIndex = 0;
+                        state = 'prefix-candidate';
+                    }
+                    else {
+                        processOutside(byte);
+                    }
+                    continue;
+                }
+                if (state === 'prefix-candidate') {
+                    if (byte === JSON_TOOL_PREFIX[candidateIndex]) {
+                        held.push(byte);
+                        candidateIndex++;
+                        if (candidateIndex === JSON_TOOL_PREFIX.byteLength) {
+                            held = [];
+                            candidateIndex = 0;
+                            escaped = false;
+                            state = 'tool-name-candidate';
+                        }
+                        continue;
+                    }
+                    writeHeld();
+                    write(byte);
+                    enterStringAfter(byte);
+                    continue;
+                }
+                if (escaped) {
+                    held.push(byte);
+                    escaped = false;
+                    if (held.length > MAX_JSON_TOOL_NAME_BYTES) {
+                        throw new Error(`JSON tool name exceeds ${MAX_JSON_TOOL_NAME_BYTES} byte limit`);
+                    }
+                    continue;
+                }
+                if (byte === 0x5c) {
+                    held.push(byte);
+                    escaped = true;
+                    if (held.length > MAX_JSON_TOOL_NAME_BYTES) {
+                        throw new Error(`JSON tool name exceeds ${MAX_JSON_TOOL_NAME_BYTES} byte limit`);
+                    }
+                    continue;
+                }
+                if (byte === 0x22) {
+                    let replacement;
+                    if (held.length === 0) {
+                        replacement = JSON_TOOL_PREFIX;
+                    }
+                    else {
+                        try {
+                            replacement = UTF8_ENCODER.encode(unprefixName(UTF8_FATAL_DECODER.decode(Uint8Array.from(held))));
+                        }
+                        catch {
+                            replacement = Uint8Array.from([...JSON_TOOL_PREFIX, ...held]);
+                        }
+                    }
+                    enqueueOutput();
+                    controller.enqueue(replacement);
+                    write(byte);
+                    held = [];
+                    candidateIndex = 0;
+                    state = 'outside';
+                    continue;
+                }
+                held.push(byte);
+                if (held.length > MAX_JSON_TOOL_NAME_BYTES) {
+                    throw new Error(`JSON tool name exceeds ${MAX_JSON_TOOL_NAME_BYTES} byte limit`);
+                }
+            }
+            enqueueOutput();
+        },
+        flush(controller) {
+            const trailing = Uint8Array.from(state === 'tool-name-candidate'
+                ? [...JSON_TOOL_PREFIX, ...held]
+                : held);
+            if (trailing.byteLength === 0)
+                return;
+            controller.enqueue(trailing);
+        },
+    }));
+}
 /**
  * Prefix a tool name with TOOL_PREFIX and uppercase the first character.
  * Claude Code uses PascalCase tool names (e.g. mcp_Bash, mcp_Read);
@@ -289,26 +492,83 @@ export function rewriteRequestBody(body) {
  * Create a streaming response that strips the tool prefix from tool names.
  */
 export function createStrippedStream(response) {
+    const mediaType = response.headers
+        .get('content-type')
+        ?.split(';', 1)[0]
+        ?.trim()
+        .toLowerCase();
     if (!response.body)
         return response;
-    const reader = response.body.getReader();
+    if (mediaType === 'application/json' || mediaType?.endsWith('+json')) {
+        const stream = createJsonToolNameStream(response.body);
+        const headers = headersAfterBodyTransform(response.headers);
+        return new Response(stream, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    if (mediaType !== 'text/event-stream')
+        return response;
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-        async pull(controller) {
-            const { done, value } = await reader.read();
-            if (done) {
-                controller.close();
+    let pending = new Uint8Array(0);
+    let pendingLength = 0;
+    const appendPending = (bytes) => {
+        const requiredLength = pendingLength + bytes.byteLength;
+        if (requiredLength > MAX_SSE_LINE_BYTES) {
+            throw new Error(`SSE line exceeds ${MAX_SSE_LINE_BYTES} byte limit`);
+        }
+        if (requiredLength > pending.byteLength) {
+            let capacity = Math.max(1024, pending.byteLength);
+            while (capacity < requiredLength) {
+                capacity = Math.min(MAX_SSE_LINE_BYTES, capacity * 2);
+            }
+            const expanded = new Uint8Array(capacity);
+            expanded.set(pending.subarray(0, pendingLength));
+            pending = expanded;
+        }
+        pending.set(bytes, pendingLength);
+        pendingLength = requiredLength;
+    };
+    const stream = response.body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            let lastLineBreak = -1;
+            let lineLength = pendingLength;
+            for (let index = 0; index < chunk.byteLength; index++) {
+                if (chunk[index] === 0x0a || chunk[index] === 0x0d) {
+                    lastLineBreak = index;
+                    lineLength = 0;
+                }
+                else {
+                    lineLength++;
+                    if (lineLength > MAX_SSE_LINE_BYTES) {
+                        throw new Error(`SSE line exceeds ${MAX_SSE_LINE_BYTES} byte limit`);
+                    }
+                }
+            }
+            if (lastLineBreak < 0) {
+                appendPending(chunk);
                 return;
             }
-            let text = decoder.decode(value, { stream: true });
-            text = stripToolPrefix(text);
-            controller.enqueue(encoder.encode(text));
+            const completeLines = decoder.decode(pending.subarray(0, pendingLength), {
+                stream: true,
+            }) + decoder.decode(chunk.subarray(0, lastLineBreak + 1));
+            pendingLength = 0;
+            appendPending(chunk.subarray(lastLineBreak + 1));
+            controller.enqueue(encoder.encode(stripToolPrefix(completeLines)));
         },
-    });
+        flush(controller) {
+            const trailing = decoder.decode(pending.subarray(0, pendingLength));
+            if (trailing) {
+                controller.enqueue(encoder.encode(stripToolPrefix(trailing)));
+            }
+        },
+    }));
+    const headers = headersAfterBodyTransform(response.headers);
     return new Response(stream, {
         status: response.status,
         statusText: response.statusText,
-        headers: response.headers,
+        headers,
     });
 }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ex-machina/opencode-anthropic-auth",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/ex-machina-co/opencode-anthropic-auth"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "packageManager": "bun@1.3.14",
   "engines": {
     "bun": "1.3.14"
   },
@@ -19,11 +20,12 @@
     "dev": "bun scripts/dev.ts",
     "dev:clean": "bun scripts/dev-clean.ts",
     "extract": "bun scripts/extract-system-prompt.ts",
+    "check": "bun turbo check:all",
     "test": "bun test",
     "types": "tsc",
     "format": "biome check --write --unsafe",
     "format:check": "biome format .",
-    "lint": "biome lint .",
+    "lint": "biome lint --error-on-warnings .",
     "change": "changeset",
     "release": "bun run build && bun change publish"
   },
@@ -39,6 +41,7 @@
     "@types/bun": "1.3.14",
     "dedent": "^1.7.2",
     "lefthook": "2.1.9",
+    "turbo": "2.9.18",
     "typescript": "6.0.3"
   }
 }