oc-auth-switcher 0.9.2 → 0.9.4

package/dist/cli.js

@@ -49,6 +49,11 @@ var OAUTH_SCOPES = [
   "user:mcp_servers",
   "user:file_upload"
 ];
+var CLAUDE_CODE_VERSION = "2.1.280";
+function formatUserAgent(version) {
+  return `claude-cli/${version} (external, cli)`;
+}
+var USER_AGENT = formatUserAgent(CLAUDE_CODE_VERSION);
 
 // src/accounts.ts
 function isAccessTokenFresh(account, nowMs = Date.now()) {
@@ -1063,7 +1068,7 @@ var PROBE_MODELS = [
 var PROBE_BETA_HEADERS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
 var PROBE_USER_AGENT = "claude-cli/2.1.87 (external, cli)";
 var PROBE_VERSION = "2023-06-01";
-var CLAUDE_CODE_VERSION = "2.1.87";
+var CLAUDE_CODE_VERSION2 = "2.1.87";
 var CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 var CCH_SALT = "59cf53e54c78";
 var CCH_POSITIONS = [4, 7, 20];
@@ -1072,12 +1077,12 @@ function computeCCH(messageText) {
 }
 function computeVersionSuffix(messageText) {
   const chars = CCH_POSITIONS.map((i) => messageText[i] || "0").join("");
-  return createHash("sha256").update(`${CCH_SALT}${chars}${CLAUDE_CODE_VERSION}`).digest("hex").slice(0, 3);
+  return createHash("sha256").update(`${CCH_SALT}${chars}${CLAUDE_CODE_VERSION2}`).digest("hex").slice(0, 3);
 }
 function buildBillingHeader(messageText) {
   const suffix = computeVersionSuffix(messageText);
   const cch = computeCCH(messageText);
-  return "x-anthropic-billing-header: " + `cc_version=${CLAUDE_CODE_VERSION}.${suffix}; ` + `cc_entrypoint=sdk-cli; ` + `cch=${cch};`;
+  return "x-anthropic-billing-header: " + `cc_version=${CLAUDE_CODE_VERSION2}.${suffix}; ` + `cc_entrypoint=sdk-cli; ` + `cch=${cch};`;
 }
 async function fetchAndApplyOAuthUsage(account, state, result) {
   const oauthResult = await fetchOAuthUsage(account.access);

package/dist/index.js

@@ -26,9 +26,12 @@ var OPENCODE_IDENTITY_PREFIX = "You are OpenCode";
 var CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 var CCH_SALT = "59cf53e54c78";
 var CCH_POSITIONS = [4, 7, 20];
-var CLAUDE_CODE_VERSION = "2.1.87";
+var CLAUDE_CODE_VERSION = "2.1.280";
 var CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
-var USER_AGENT = "claude-cli/2.1.87 (external, cli)";
+function formatUserAgent(version) {
+  return `claude-cli/${version} (external, cli)`;
+}
+var USER_AGENT = formatUserAgent(CLAUDE_CODE_VERSION);
 var PARAGRAPH_REMOVAL_ANCHORS = [
   "github.com/anomalyco/opencode",
   "opencode.ai/docs"
@@ -71,6 +74,193 @@ function buildBillingHeaderValue(messages, version = CLAUDE_CODE_VERSION, entryp
 }
 
 // node_modules/@ex-machina/opencode-anthropic-auth/dist/transform.js
+var 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;
+}
+var JSON_NAME_KEY_SUFFIX = new TextEncoder().encode('name"');
+var JSON_TOOL_PREFIX = new TextEncoder().encode(TOOL_PREFIX);
+var UTF8_ENCODER = new TextEncoder;
+var UTF8_FATAL_DECODER = new TextDecoder("utf-8", { fatal: true });
+var MAX_JSON_TOOL_NAME_BYTES = 1024;
+function isJsonWhitespace(byte) {
+  return byte === 32 || byte === 9 || byte === 10 || byte === 13;
+}
+function createJsonToolNameStream(body) {
+  let state = "outside";
+  let held = [];
+  let candidateIndex = 0;
+  let escaped = false;
+  const enterStringAfter = (byte) => {
+    if (byte === 34) {
+      state = "outside";
+      escaped = false;
+      return;
+    }
+    state = "string";
+    escaped = byte === 92;
+  };
+  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 === 34) {
+          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 === 92) {
+            escaped = true;
+          } else if (byte === 34) {
+            state = "outside";
+          }
+          continue;
+        }
+        if (state === "after-name-key") {
+          if (isJsonWhitespace(byte)) {
+            write(byte);
+          } else if (byte === 58) {
+            write(byte);
+            state = "after-colon";
+          } else {
+            processOutside(byte);
+          }
+          continue;
+        }
+        if (state === "after-colon") {
+          if (isJsonWhitespace(byte)) {
+            write(byte);
+          } else if (byte === 34) {
+            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 === 92) {
+          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 === 34) {
+          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);
+    }
+  }));
+}
 function prefixName(name) {
   return `${TOOL_PREFIX}${name.charAt(0).toUpperCase()}${name.slice(1)}`;
 }
@@ -115,10 +305,10 @@ function mergeBetaHeaders(headers) {
   const incomingBetasList = incomingBeta.split(",").map((b) => b.trim()).filter(Boolean);
   return [...new Set([...REQUIRED_BETAS, ...incomingBetasList])].join(",");
 }
-function setOAuthHeaders(headers, accessToken) {
+function setOAuthHeaders(headers, accessToken, version = CLAUDE_CODE_VERSION) {
   headers.set("authorization", `Bearer ${accessToken}`);
   headers.set("anthropic-beta", mergeBetaHeaders(headers));
-  headers.set("user-agent", USER_AGENT);
+  headers.set("user-agent", formatUserAgent(version));
   headers.delete("x-api-key");
   return headers;
 }
@@ -256,10 +446,10 @@ function prependClaudeCodeIdentity(system) {
   }
   return [identityBlock, ...sanitized];
 }
-function rewriteRequestBody(body) {
+function rewriteRequestBody(body, version = CLAUDE_CODE_VERSION) {
   try {
     const parsed = JSON.parse(body);
-    const billingHeader = Array.isArray(parsed.messages) && parsed.messages.some((message) => message.role === "user") ? buildBillingHeaderValue(parsed.messages, undefined, CLAUDE_CODE_ENTRYPOINT) : null;
+    const billingHeader = Array.isArray(parsed.messages) && parsed.messages.some((message) => message.role === "user") ? buildBillingHeaderValue(parsed.messages, version, CLAUDE_CODE_ENTRYPOINT) : null;
     parsed.system = prependClaudeCodeIdentity(parsed.system);
     if (billingHeader && Array.isArray(parsed.system)) {
       parsed.system.unshift({ type: "text", text: billingHeader });
@@ -270,27 +460,79 @@ function rewriteRequestBody(body) {
   }
 }
 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 stream2 = createJsonToolNameStream(response.body);
+    const headers2 = headersAfterBodyTransform(response.headers);
+    return new Response(stream2, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: headers2
+    });
+  }
+  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] === 10 || chunk[index] === 13) {
+          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,6 +1,6 @@
 {
   "name": "oc-auth-switcher",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
     "@opencode-ai/plugin": "*"
   },
   "dependencies": {
-    "@ex-machina/opencode-anthropic-auth": "1.8.3"
+    "@ex-machina/opencode-anthropic-auth": "1.8.5"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "latest",