@ex-machina/opencode-anthropic-auth 2.0.0-next.1 → 2.0.0-next.3

package/README.md

@@ -114,9 +114,9 @@ The plugin reads the following environment variables:
 - **`ANTHROPIC_INSECURE`** — Skips TLS certificate verification. Behavior differs by OpenCode version:
     - **OpenCode v1** — Set to `1` or `true` to skip verification. Only effective when `ANTHROPIC_BASE_URL` is also set.
     - **OpenCode v2** — Not supported. OpenCode v2 plugin request hooks cannot disable TLS verification. If set, the plugin logs a warning and leaves verification enabled; requests to an untrusted or self-signed `ANTHROPIC_BASE_URL` will fail.
-- **`ANTHROPIC_CLAUDE_CODE_VERSION`** — Overrides the Claude Code version reported to Anthropic for both release lines. Must be `major.minor.patch` (for example, `2.1.258`). Defaults to the bundled version; a malformed value is logged and the bundled version is used instead. A value older than the bundled version is honored but logs a warning, since reporting an older version can make newer models reject the request. Read once when the plugin loads, so restart OpenCode after changing it.
+- **`ANTHROPIC_CLAUDE_CODE_VERSION`** — Overrides the Claude Code version reported to Anthropic for both release lines. Must be `major.minor.patch` (for example, `2.1.280`). Defaults to the bundled version; a malformed value logs an actionable error without echoing its contents, and the bundled version is used instead. A value older than the bundled version is honored but logs a warning, since reporting an older version can make newer models reject the request. Read once when the plugin loads, so restart OpenCode after changing it.
 
-Anthropic gates model access on the reported Claude Code version server-side, returning a 400 `claude_code_version_too_old` error for models that require a newer client. `ANTHROPIC_CLAUDE_CODE_VERSION` lets you raise the reported version without waiting for a plugin release.
+Anthropic gates model access on the reported Claude Code version server-side, returning a 400 `claude_code_version_too_old` error for models that require a newer client. On OpenCode v2, when the exact structured rejection names a newer minimum, the plugin adopts that real version for the rest of the process and retries the initial request once. Other 400 responses and valid explicit `ANTHROPIC_CLAUDE_CODE_VERSION` overrides are never changed automatically. A malformed override is ignored, so its bundled fallback remains eligible for exact-response recovery. The override remains an escape hatch for both release lines.
 
 ## How It Works
 

package/dist/auth.d.ts

@@ -25,8 +25,8 @@ export type RefreshResult = {
 };
 /**
  * Exchange a refresh token for a new access/refresh token pair.
- * Retries transient (5xx, network) failures with exponential backoff;
- * non-transient failures (e.g. 403 on a revoked/rotated-away token)
- * are returned immediately as `{ type: 'failed' }`.
+ * Refresh tokens may rotate after a request reaches the provider. Retrying an
+ * ambiguous 5xx, timeout, network failure, or response-body failure can replay
+ * an already consumed token, so each call makes exactly one token request.
  */
 export declare function refreshToken(refreshTokenValue: string): Promise<RefreshResult>;

package/dist/auth.js

@@ -1,6 +1,37 @@
+import { BodyLimitError, contentLength, InvalidUtf8Error, readBoundedText, } from "./bounded.js";
 import { AUTHORIZE_URLS, CLIENT_ID, CODE_CALLBACK_URL, OAUTH_SCOPES, TOKEN_URL, } from "./constants.js";
 import { generatePKCE } from "./pkce.js";
-const REFRESH_TIMEOUT_MS = 30_000;
+const TOKEN_TIMEOUT_MS = 30_000;
+const MAX_TOKEN_RESPONSE_BYTES = 64 * 1024;
+const MAX_TOKEN_LENGTH = 8 * 1024;
+const MAX_CALLBACK_INPUT_BYTES = 16 * 1024;
+const MAX_VERIFIER_BYTES = 1024;
+const MAX_REDIRECT_URI_BYTES = 2 * 1024;
+function isWellFormedUtf16(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const unit = value.charCodeAt(index);
+        if (unit >= 0xd800 && unit <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (unit >= 0xdc00 && unit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function isBoundedUtf8(value, maxBytes) {
+    if (value.length === 0 ||
+        value.length > maxBytes ||
+        !isWellFormedUtf16(value)) {
+        return false;
+    }
+    return new TextEncoder().encode(value).byteLength <= maxBytes;
+}
 function isTokenResponse(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -9,16 +40,23 @@ function isTokenResponse(value) {
     if (!('expires_in' in value))
         return false;
     return (typeof value.refresh_token === 'string' &&
-        value.refresh_token.length > 0 &&
+        isBoundedUtf8(value.refresh_token, MAX_TOKEN_LENGTH) &&
         typeof value.access_token === 'string' &&
-        value.access_token.length > 0 &&
+        isBoundedUtf8(value.access_token, MAX_TOKEN_LENGTH) &&
         typeof value.expires_in === 'number' &&
         Number.isSafeInteger(value.expires_in) &&
         value.expires_in > 0);
 }
 async function parseTokenResponse(response) {
+    const declaredLength = contentLength(response.headers);
+    if (declaredLength !== undefined &&
+        declaredLength > MAX_TOKEN_RESPONSE_BYTES) {
+        await response.body?.cancel().catch(() => { });
+        return undefined;
+    }
     try {
-        const value = await response.json();
+        const text = await readBoundedText(response.body, MAX_TOKEN_RESPONSE_BYTES, 'Anthropic token response');
+        const value = JSON.parse(text);
         if (!isTokenResponse(value))
             return undefined;
         const expires = Date.now() + value.expires_in * 1000;
@@ -31,11 +69,54 @@ async function parseTokenResponse(response) {
         };
     }
     catch (error) {
-        if (error instanceof SyntaxError)
+        if (error instanceof SyntaxError ||
+            error instanceof BodyLimitError ||
+            error instanceof InvalidUtf8Error) {
             return undefined;
+        }
         throw error;
     }
 }
+function isTransientNetworkError(error) {
+    const seen = new WeakSet();
+    let current = error;
+    for (let depth = 0; depth < 8; depth++) {
+        if (typeof current !== 'object' || current === null)
+            return false;
+        if (seen.has(current))
+            return false;
+        seen.add(current);
+        if ('name' in current &&
+            (current.name === 'TimeoutError' || current.name === 'AbortError')) {
+            return true;
+        }
+        if ('code' in current) {
+            const code = current.code;
+            if (code === 'ECONNRESET' ||
+                code === 'ECONNREFUSED' ||
+                code === 'ETIMEDOUT' ||
+                code === 'EPIPE' ||
+                code === 'ENETUNREACH' ||
+                code === 'EAI_AGAIN' ||
+                code === 'UND_ERR_CONNECT_TIMEOUT' ||
+                code === 'UND_ERR_SOCKET') {
+                return true;
+            }
+        }
+        const message = current instanceof Error ? current.message.toLowerCase() : '';
+        if (message === 'fetch failed' ||
+            message === 'terminated' ||
+            message === 'network error' ||
+            message.includes('socket hang up') ||
+            message.includes('other side closed')) {
+            return true;
+        }
+        if (!('cause' in current))
+            return false;
+        current = current.cause;
+    }
+    return false;
+}
 function generateState() {
     return crypto.randomUUID().replace(/-/g, '');
 }
@@ -65,23 +146,34 @@ function parseCallbackInput(input) {
     return null;
 }
 async function exchangeCode(callback, verifier, redirectUri) {
-    const result = await fetch(TOKEN_URL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Accept: 'application/json, text/plain, */*',
-            'User-Agent': 'axios/1.13.6',
-        },
-        body: JSON.stringify({
-            code: callback.code,
-            state: callback.state,
-            grant_type: 'authorization_code',
-            client_id: CLIENT_ID,
-            redirect_uri: redirectUri,
-            code_verifier: verifier,
-        }),
-    });
+    let result;
+    try {
+        result = await fetch(TOKEN_URL, {
+            method: 'POST',
+            signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+            redirect: 'error',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/plain, */*',
+                'User-Agent': 'axios/1.13.6',
+            },
+            body: JSON.stringify({
+                code: callback.code,
+                state: callback.state,
+                grant_type: 'authorization_code',
+                client_id: CLIENT_ID,
+                redirect_uri: redirectUri,
+                code_verifier: verifier,
+            }),
+        });
+    }
+    catch (error) {
+        if (isTransientNetworkError(error))
+            return { type: 'failed' };
+        throw error;
+    }
     if (!result.ok) {
+        await result.body?.cancel().catch(() => { });
         return {
             type: 'failed',
         };
@@ -114,6 +206,13 @@ export async function authorize(mode) {
     };
 }
 export async function exchange(input, verifier, redirectUri, expectedState) {
+    if (!isBoundedUtf8(input, MAX_CALLBACK_INPUT_BYTES) ||
+        !isBoundedUtf8(verifier, MAX_VERIFIER_BYTES) ||
+        !isBoundedUtf8(redirectUri, MAX_REDIRECT_URI_BYTES) ||
+        (expectedState !== undefined &&
+            !isBoundedUtf8(expectedState, MAX_TOKEN_LENGTH))) {
+        return { type: 'failed' };
+    }
     const callback = parseCallbackInput(input);
     if (!callback) {
         return {
@@ -125,73 +224,53 @@ export async function exchange(input, verifier, redirectUri, expectedState) {
             type: 'failed',
         };
     }
+    if (!isBoundedUtf8(callback.code, MAX_TOKEN_LENGTH) ||
+        !isBoundedUtf8(callback.state, MAX_TOKEN_LENGTH)) {
+        return { type: 'failed' };
+    }
     return exchangeCode(callback, verifier, redirectUri);
 }
 /**
  * Exchange a refresh token for a new access/refresh token pair.
- * Retries transient (5xx, network) failures with exponential backoff;
- * non-transient failures (e.g. 403 on a revoked/rotated-away token)
- * are returned immediately as `{ type: 'failed' }`.
+ * Refresh tokens may rotate after a request reaches the provider. Retrying an
+ * ambiguous 5xx, timeout, network failure, or response-body failure can replay
+ * an already consumed token, so each call makes exactly one token request.
  */
 export async function refreshToken(refreshTokenValue) {
-    const maxRetries = 2;
-    const baseDelayMs = 500;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            if (attempt > 0) {
-                const delay = baseDelayMs * 2 ** (attempt - 1);
-                await new Promise((resolve) => setTimeout(resolve, delay));
-            }
-            const response = await fetch(TOKEN_URL, {
-                method: 'POST',
-                signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json, text/plain, */*',
-                    'User-Agent': 'axios/1.13.6',
-                },
-                body: JSON.stringify({
-                    grant_type: 'refresh_token',
-                    refresh_token: refreshTokenValue,
-                    client_id: CLIENT_ID,
-                }),
-            });
-            if (!response.ok) {
-                if (response.status >= 500 && attempt < maxRetries) {
-                    await response.body?.cancel();
-                    continue;
-                }
-                await response.body?.cancel();
-                return { type: 'failed', status: response.status };
-            }
-            const tokens = await parseTokenResponse(response);
-            if (!tokens) {
-                return { type: 'failed', status: response.status };
-            }
-            return {
-                type: 'success',
-                ...tokens,
-            };
-        }
-        catch (error) {
-            const isNetworkError = (typeof error === 'object' &&
-                error !== null &&
-                'name' in error &&
-                (error.name === 'TimeoutError' || error.name === 'AbortError')) ||
-                (error instanceof Error &&
-                    (error.message.includes('fetch failed') ||
-                        ('code' in error &&
-                            (error.code === 'ECONNRESET' ||
-                                error.code === 'ECONNREFUSED' ||
-                                error.code === 'ETIMEDOUT' ||
-                                error.code === 'UND_ERR_CONNECT_TIMEOUT'))));
-            if (attempt < maxRetries && isNetworkError) {
-                continue;
-            }
-            throw error;
+    if (!isBoundedUtf8(refreshTokenValue, MAX_TOKEN_LENGTH)) {
+        return { type: 'failed', status: 400 };
+    }
+    try {
+        const response = await fetch(TOKEN_URL, {
+            method: 'POST',
+            signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+            redirect: 'error',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/plain, */*',
+                'User-Agent': 'axios/1.13.6',
+            },
+            body: JSON.stringify({
+                grant_type: 'refresh_token',
+                refresh_token: refreshTokenValue,
+                client_id: CLIENT_ID,
+            }),
+        });
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => { });
+            return { type: 'failed', status: response.status };
         }
+        const tokens = await parseTokenResponse(response);
+        if (!tokens)
+            return { type: 'failed', status: response.status };
+        return {
+            type: 'success',
+            ...tokens,
+        };
+    }
+    catch (error) {
+        if (isTransientNetworkError(error))
+            return { type: 'failed', status: 0 };
+        throw error;
     }
-    // Unreachable — each iteration either returns or throws.
-    // Kept as a TypeScript exhaustiveness guard.
-    throw new Error('Token refresh exhausted all retries');
 }

package/dist/bounded.d.ts

@@ -0,0 +1,8 @@
+export declare class BodyLimitError extends Error {
+    constructor(label: string, limit: number);
+}
+export declare class InvalidUtf8Error extends Error {
+    constructor(label: string);
+}
+export declare function contentLength(headers: Headers): number | undefined;
+export declare function readBoundedText(body: ReadableStream<Uint8Array> | null, limit: number, label: string): Promise<string>;

package/dist/bounded.js

@@ -0,0 +1,59 @@
+export class BodyLimitError extends Error {
+    constructor(label, limit) {
+        super(`${label} exceeds ${limit} byte limit`);
+        this.name = 'BodyLimitError';
+    }
+}
+export class InvalidUtf8Error extends Error {
+    constructor(label) {
+        super(`${label} is not valid UTF-8`);
+        this.name = 'InvalidUtf8Error';
+    }
+}
+export function contentLength(headers) {
+    const raw = headers.get('content-length');
+    if (!raw || !/^\d+$/.test(raw))
+        return undefined;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? value : undefined;
+}
+export async function readBoundedText(body, limit, label) {
+    if (!body)
+        return '';
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    const parts = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > limit) {
+                await reader.cancel().catch(() => { });
+                throw new BodyLimitError(label, limit);
+            }
+            try {
+                parts.push(decoder.decode(value, { stream: true }));
+            }
+            catch {
+                throw new InvalidUtf8Error(label);
+            }
+        }
+        try {
+            parts.push(decoder.decode());
+        }
+        catch {
+            throw new InvalidUtf8Error(label);
+        }
+        return parts.join('');
+    }
+    catch (error) {
+        await reader.cancel(error).catch(() => { });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/config.d.ts

@@ -7,6 +7,16 @@
  * waiting for a published bump.
  */
 export declare const ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR = "ANTHROPIC_CLAUDE_CODE_VERSION";
+export declare function isValidClaudeCodeVersion(candidate: string): boolean;
+/**
+ * Compare two validated Claude Code releases.
+ *
+ * Components are compared numerically rather than lexically — `2.1.99` sorts
+ * after `2.1.280` as a string but is the older release — and as `BigInt`, so a
+ * large bounded component cannot silently lose precision the way `Number`
+ * would. Invalid input has no ordering and returns `undefined`.
+ */
+export declare function compareClaudeCodeVersions(candidate: string, baseline: string): -1 | 0 | 1 | undefined;
 /**
  * Outcome of reading the version override.
  *

package/dist/config.js

@@ -11,19 +11,27 @@ export const ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR = 'ANTHROPIC_CLAUDE_CODE_VERS
 /**
  * Claude Code releases are `major.minor.patch` with numeric components.
  *
- * Leading zeros are rejected: `02.1.258` is not a release Anthropic publishes,
+ * Leading zeros are rejected: `02.1.280` is not a release Anthropic publishes,
  * so accepting it would report a version string no server-side gate expects.
  */
 const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+const MAX_VERSION_LENGTH = 64;
+export function isValidClaudeCodeVersion(candidate) {
+    return (candidate.length <= MAX_VERSION_LENGTH && VERSION_PATTERN.test(candidate));
+}
 /**
- * Is `candidate` an older Claude Code release than `baseline`?
+ * Compare two validated Claude Code releases.
  *
- * Both arguments must already match `VERSION_PATTERN`. Components are compared
- * numerically rather than lexically — `2.1.99` sorts after `2.1.258` as a
- * string but is the older release — and as `BigInt`, so an unbounded component
- * cannot silently lose precision the way `Number` would.
+ * Components are compared numerically rather than lexically — `2.1.99` sorts
+ * after `2.1.280` as a string but is the older release — and as `BigInt`, so a
+ * large bounded component cannot silently lose precision the way `Number`
+ * would. Invalid input has no ordering and returns `undefined`.
  */
-function isOlderVersion(candidate, baseline) {
+export function compareClaudeCodeVersions(candidate, baseline) {
+    if (!isValidClaudeCodeVersion(candidate) ||
+        !isValidClaudeCodeVersion(baseline)) {
+        return undefined;
+    }
     // The `0n` defaults are unreachable — `VERSION_PATTERN` guarantees exactly
     // three components — but they keep the destructuring free of assertions.
     const [major = 0n, minor = 0n, patch = 0n] = candidate
@@ -33,10 +41,12 @@ function isOlderVersion(candidate, baseline) {
         .split('.')
         .map((part) => BigInt(part));
     if (major !== baseMajor)
-        return major < baseMajor;
+        return major < baseMajor ? -1 : 1;
     if (minor !== baseMinor)
-        return minor < baseMinor;
-    return patch < basePatch;
+        return minor < baseMinor ? -1 : 1;
+    if (patch !== basePatch)
+        return patch < basePatch ? -1 : 1;
+    return 0;
 }
 /**
  * Resolve the Claude Code version to report to Anthropic.
@@ -52,17 +62,17 @@ export function resolveClaudeCodeVersion(raw = process.env[ANTHROPIC_CLAUDE_CODE
     if (raw === undefined) {
         return { type: 'success', version: CLAUDE_CODE_VERSION };
     }
-    const trimmed = raw.trim();
-    if (!VERSION_PATTERN.test(trimmed)) {
+    const trimmed = raw.length <= MAX_VERSION_LENGTH ? raw.trim() : '';
+    if (!isValidClaudeCodeVersion(trimmed)) {
         return {
             type: 'invalid',
-            error: `${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} is set to ${JSON.stringify(raw)}, which is not a ` +
-                `Claude Code version. Expected major.minor.patch (for example, ${CLAUDE_CODE_VERSION}). ` +
+            error: `${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} is not a valid Claude Code version. ` +
+                `Expected major.minor.patch (for example, ${CLAUDE_CODE_VERSION}). ` +
                 `Reporting the bundled version ${CLAUDE_CODE_VERSION} instead; correct or unset ` +
                 `${ANTHROPIC_CLAUDE_CODE_VERSION_ENV_VAR} and restart OpenCode to use the override.`,
         };
     }
-    if (isOlderVersion(trimmed, CLAUDE_CODE_VERSION)) {
+    if (compareClaudeCodeVersions(trimmed, CLAUDE_CODE_VERSION) === -1) {
         return {
             type: 'outdated',
             version: trimmed,

package/dist/constants.d.ts

@@ -22,7 +22,7 @@ export declare const CCH_POSITIONS: number[];
  * newer is required"). Keep this at or above the latest published
  * `@anthropic-ai/claude-code` release, otherwise new models are unreachable.
  */
-export declare const CLAUDE_CODE_VERSION = "2.1.258";
+export declare const CLAUDE_CODE_VERSION = "2.1.280";
 export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
 /**
  * Build the `user-agent` value for a reported Claude Code version.

package/dist/constants.js

@@ -32,7 +32,7 @@ export const CCH_POSITIONS = [4, 7, 20];
  * newer is required"). Keep this at or above the latest published
  * `@anthropic-ai/claude-code` release, otherwise new models are unreachable.
  */
-export const CLAUDE_CODE_VERSION = '2.1.258';
+export const CLAUDE_CODE_VERSION = '2.1.280';
 export const CLAUDE_CODE_ENTRYPOINT = 'sdk-cli';
 /**
  * Build the `user-agent` value for a reported Claude Code version.

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { Plugin } from '@opencode-ai/plugin';
+import { Plugin } from '@opencode/plugin';
 declare const _default: Plugin.Plugin;
 export default _default;