@ex-machina/opencode-anthropic-auth 1.1.2 → 1.3.0

package/README.md

@@ -21,7 +21,7 @@ Add the plugin to your OpenCode configuration:
 
 ```json
 {
-  "plugin": ["@ex-machina/opencode-anthropic-auth@1.1.1"]
+  "plugin": ["@ex-machina/opencode-anthropic-auth@1.2.0"]
 }
 ```
 
@@ -41,10 +41,46 @@ For Claude Pro/Max authentication, the plugin:
 2. Exchanges the authorization code for access and refresh tokens
 3. Automatically refreshes expired tokens
 4. Injects the required OAuth headers and beta flags into API requests
-5. Zeros out model costs (since usage is covered by the subscription)
+5. Sanitizes the system prompt for compatibility (see below)
+6. Zeros out model costs (since usage is covered by the subscription)
+
+### System Prompt Sanitization
+
+The Anthropic API for Max subscriptions requires the system prompt to identify as Claude Code. The plugin rewrites the system prompt on each request using an **anchor-based** approach that minimizes what gets changed:
+
+1. **Identity swap** — The OpenCode identity line is removed and replaced with the Claude Code identity.
+2. **Paragraph removal by anchor** — Any paragraph containing a known URL anchor (e.g. `github.com/anomalyco/opencode`, `opencode.ai/docs`) is removed entirely. This is resilient to upstream rewording — as long as the anchor URL appears somewhere in the paragraph, the removal works regardless of surrounding text changes.
+3. **Inline text replacements** — Short branded strings inside paragraphs we want to keep are replaced (e.g. "OpenCode" → "the assistant" in the professional objectivity section).
+
+Everything else in the system prompt is preserved: tone/style guidance, task management instructions, tool usage policy, environment info, skills, user/project instructions, and file paths containing "opencode".
 
 ## Development
 
+### Local Testing
+
+Use `bun run dev` to test plugin changes locally without publishing to npm:
+
+```bash
+bun run dev
+```
+
+This does three things:
+
+1. Builds the plugin
+2. Symlinks the build output into `.opencode/plugins/` so OpenCode loads it as a local plugin
+3. Starts `tsc --watch` for automatic rebuilds on source changes
+
+After starting the dev script, restart OpenCode in this project directory to pick up the local build. Any edits to `src/` will trigger a rebuild — restart OpenCode again to load the new version.
+
+Ctrl+C stops the watcher and cleans up the symlink. If the process was killed without cleanup (e.g. `kill -9`), you can manually remove the symlink:
+
+```bash
+bun run dev:clean
+```
+
+> [!NOTE]
+> If you have the npm version of this plugin in your global OpenCode config, both will load. The local version takes precedence for auth handling.
+
 ### Publishing
 
 This project uses [changesets](https://github.com/changesets/changesets) for versioning and publishing. See the [changeset README](.changeset/README.md) for more details.

package/dist/constants.d.ts

@@ -8,4 +8,25 @@ export declare const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
 export declare const OAUTH_SCOPES: string[];
 export declare const TOOL_PREFIX = "mcp_";
 export declare const REQUIRED_BETAS: string[];
+export declare const OPENCODE_IDENTITY = "You are OpenCode, the best coding agent on the planet.";
+export declare const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 export declare const USER_AGENT = "claude-cli/2.1.2 (external, cli)";
+/**
+ * Anchors that identify paragraphs to remove from the system prompt.
+ * Any paragraph (text between blank lines) containing one of these
+ * strings is removed entirely.
+ *
+ * This is resilient to upstream rewording — as long as the anchor
+ * string (typically a URL) still appears somewhere in the paragraph,
+ * the removal works regardless of how the surrounding text changes.
+ */
+export declare const PARAGRAPH_REMOVAL_ANCHORS: string[];
+/**
+ * Inline text replacements applied after paragraph removal.
+ * These handle cases where "OpenCode" appears inside a paragraph
+ * we want to keep (so we can't remove the whole paragraph).
+ */
+export declare const TEXT_REPLACEMENTS: {
+    match: string;
+    replacement: string;
+}[];

package/dist/constants.js

@@ -18,4 +18,29 @@ export const REQUIRED_BETAS = [
     'oauth-2025-04-20',
     'interleaved-thinking-2025-05-14',
 ];
+export const OPENCODE_IDENTITY = 'You are OpenCode, the best coding agent on the planet.';
+export const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 export const USER_AGENT = 'claude-cli/2.1.2 (external, cli)';
+/**
+ * Anchors that identify paragraphs to remove from the system prompt.
+ * Any paragraph (text between blank lines) containing one of these
+ * strings is removed entirely.
+ *
+ * This is resilient to upstream rewording — as long as the anchor
+ * string (typically a URL) still appears somewhere in the paragraph,
+ * the removal works regardless of how the surrounding text changes.
+ */
+export const PARAGRAPH_REMOVAL_ANCHORS = [
+    // Help/feedback block — references the OpenCode GitHub repo
+    'github.com/anomalyco/opencode',
+    // OpenCode docs guidance — references the OpenCode docs URL
+    'opencode.ai/docs',
+];
+/**
+ * Inline text replacements applied after paragraph removal.
+ * These handle cases where "OpenCode" appears inside a paragraph
+ * we want to keep (so we can't remove the whole paragraph).
+ */
+export const TEXT_REPLACEMENTS = [
+    { match: 'if OpenCode honestly', replacement: 'if the assistant honestly' },
+];

package/dist/index.js

@@ -1,16 +1,8 @@
 import { authorize, exchange } from './auth';
 import { CLIENT_ID, TOKEN_URL } from './constants';
-import { createStrippedStream, isInsecure, mergeHeaders, prefixToolNames, rewriteUrl, setOAuthHeaders, } from './transform';
+import { createStrippedStream, isInsecure, mergeHeaders, rewriteRequestBody, rewriteUrl, setOAuthHeaders, } from './transform';
 export const AnthropicAuthPlugin = async ({ client }) => {
     return {
-        'experimental.chat.system.transform': (input, output) => {
-            const prefix = "You are Claude Code, Anthropic's official CLI for Claude.";
-            if (input.model?.providerID === 'anthropic') {
-                output.system.unshift(prefix);
-                if (output.system[1])
-                    output.system[1] = `${prefix}\n\n${output.system[1]}`;
-            }
-        },
         auth: {
             provider: 'anthropic',
             async loader(getAuth, provider) {
@@ -111,14 +103,13 @@ export const AnthropicAuthPlugin = async ({ client }) => {
                             setOAuthHeaders(requestHeaders, auth.access);
                             let body = init?.body;
                             if (body && typeof body === 'string') {
-                                body = prefixToolNames(body);
+                                body = rewriteRequestBody(body);
                             }
                             const rewritten = rewriteUrl(input);
                             const response = await fetch(rewritten.input, {
                                 ...init,
                                 body,
                                 headers: requestHeaders,
-                                // biome-ignore lint/suspicious/noExplicitAny: tls option is Bun-specific, not in standard RequestInit
                                 ...(isInsecure() && { tls: { rejectUnauthorized: false } }),
                             });
                             return createStrippedStream(response);

package/dist/transform.d.ts

@@ -37,7 +37,37 @@ export declare function rewriteUrl(input: FetchInput): {
     input: FetchInput;
     url: URL | null;
 };
+/**
+ * Sanitize OpenCode-branded strings from the system prompt text.
+ *
+ * 1. Removes the OPENCODE_IDENTITY line.
+ * 2. Removes any paragraph (text between blank lines) that contains
+ *    one of the PARAGRAPH_REMOVAL_ANCHORS — typically URLs that
+ *    identify OpenCode-specific content.
+ * 3. Applies TEXT_REPLACEMENTS for inline occurrences of "OpenCode"
+ *    inside paragraphs we want to keep.
+ *
+ * This approach is resilient to upstream rewording of the OpenCode
+ * prompt — as long as the anchor strings (URLs, etc.) still appear
+ * somewhere in the paragraph, the removal works.
+ */
+export declare function sanitizeSystemText(text: string): string;
+type SystemBlock = {
+    type: string;
+    text: string;
+    [k: string]: unknown;
+};
+/**
+ * Sanitize system prompt and prepend Claude Code identity.
+ * Handles all Anthropic API system formats: undefined, string, or array of text blocks.
+ */
+export declare function prependClaudeCodeIdentity(system: unknown): SystemBlock[];
+/**
+ * Rewrite the full request body: sanitize system prompt and prefix tool names.
+ */
+export declare function rewriteRequestBody(body: string): string;
 /**
  * Create a streaming response that strips the tool prefix from tool names.
  */
 export declare function createStrippedStream(response: Response): Response;
+export {};

package/dist/transform.js

@@ -1,4 +1,4 @@
-import { REQUIRED_BETAS, TOOL_PREFIX, USER_AGENT } from './constants';
+import { CLAUDE_CODE_IDENTITY, OPENCODE_IDENTITY, PARAGRAPH_REMOVAL_ANCHORS, REQUIRED_BETAS, TEXT_REPLACEMENTS, TOOL_PREFIX, USER_AGENT, } from './constants';
 /**
  * Merge headers from a Request object and/or a RequestInit headers value
  * into a single Headers instance.
@@ -168,6 +168,131 @@ export function rewriteUrl(input) {
         : requestUrl;
     return { input: newInput, url: requestUrl };
 }
+/**
+ * Sanitize OpenCode-branded strings from the system prompt text.
+ *
+ * 1. Removes the OPENCODE_IDENTITY line.
+ * 2. Removes any paragraph (text between blank lines) that contains
+ *    one of the PARAGRAPH_REMOVAL_ANCHORS — typically URLs that
+ *    identify OpenCode-specific content.
+ * 3. Applies TEXT_REPLACEMENTS for inline occurrences of "OpenCode"
+ *    inside paragraphs we want to keep.
+ *
+ * This approach is resilient to upstream rewording of the OpenCode
+ * prompt — as long as the anchor strings (URLs, etc.) still appear
+ * somewhere in the paragraph, the removal works.
+ */
+export function sanitizeSystemText(text) {
+    if (!text.includes(OPENCODE_IDENTITY))
+        return text;
+    // Split into paragraphs (separated by one or more blank lines)
+    const paragraphs = text.split(/\n\n+/);
+    const filtered = paragraphs.filter((paragraph) => {
+        // Remove the identity line (may be its own paragraph or part of one)
+        if (paragraph.includes(OPENCODE_IDENTITY)) {
+            // If the paragraph is JUST the identity, drop it entirely
+            if (paragraph.trim() === OPENCODE_IDENTITY)
+                return false;
+            // Otherwise it's mixed — we'll handle inline below
+        }
+        // Remove paragraphs containing any removal anchor
+        for (const anchor of PARAGRAPH_REMOVAL_ANCHORS) {
+            if (paragraph.includes(anchor))
+                return false;
+        }
+        return true;
+    });
+    let result = filtered.join('\n\n');
+    // Remove the identity line if it was part of a larger paragraph
+    result = result.replace(OPENCODE_IDENTITY, '').replace(/\n{3,}/g, '\n\n');
+    // Apply inline text replacements
+    for (const rule of TEXT_REPLACEMENTS) {
+        result = result.replace(rule.match, rule.replacement);
+    }
+    return result.trim();
+}
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Sanitize system prompt and prepend Claude Code identity.
+ * Handles all Anthropic API system formats: undefined, string, or array of text blocks.
+ */
+export function prependClaudeCodeIdentity(system) {
+    const identityBlock = {
+        type: 'text',
+        text: CLAUDE_CODE_IDENTITY,
+    };
+    if (system == null)
+        return [identityBlock];
+    if (typeof system === 'string') {
+        const sanitized = sanitizeSystemText(system);
+        if (sanitized === CLAUDE_CODE_IDENTITY)
+            return [identityBlock];
+        return [identityBlock, { type: 'text', text: sanitized }];
+    }
+    if (isRecord(system)) {
+        const type = typeof system.type === 'string' ? system.type : 'text';
+        const text = typeof system.text === 'string' ? system.text : '';
+        return [identityBlock, { ...system, type, text: sanitizeSystemText(text) }];
+    }
+    if (!Array.isArray(system))
+        return [identityBlock];
+    const sanitized = system.map((item) => {
+        if (typeof item === 'string') {
+            return { type: 'text', text: sanitizeSystemText(item) };
+        }
+        if (isRecord(item) &&
+            item.type === 'text' &&
+            typeof item.text === 'string') {
+            return {
+                ...item,
+                type: 'text',
+                text: sanitizeSystemText(item.text),
+            };
+        }
+        return { type: 'text', text: String(item) };
+    });
+    // Idempotency: don't double-prepend if first block already has the identity
+    if (sanitized[0]?.text === CLAUDE_CODE_IDENTITY) {
+        return sanitized;
+    }
+    return [identityBlock, ...sanitized];
+}
+/**
+ * Rewrite the full request body: sanitize system prompt and prefix tool names.
+ */
+export function rewriteRequestBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        // Sanitize system prompt and prepend Claude Code identity
+        parsed.system = prependClaudeCodeIdentity(parsed.system);
+        // Prefix tool names
+        if (parsed.tools && Array.isArray(parsed.tools)) {
+            parsed.tools = parsed.tools.map((tool) => ({
+                ...tool,
+                name: tool.name ? `${TOOL_PREFIX}${tool.name}` : tool.name,
+            }));
+        }
+        if (parsed.messages && Array.isArray(parsed.messages)) {
+            parsed.messages = parsed.messages.map((msg) => {
+                if (msg.content && Array.isArray(msg.content)) {
+                    msg.content = msg.content.map((block) => {
+                        if (block.type === 'tool_use' && block.name) {
+                            return { ...block, name: `${TOOL_PREFIX}${block.name}` };
+                        }
+                        return block;
+                    });
+                }
+                return msg;
+            });
+        }
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return body;
+    }
+}
 /**
  * Create a streaming response that strips the tool prefix from tool names.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ex-machina/opencode-anthropic-auth",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/ex-machina-co/opencode-anthropic-auth"
@@ -13,6 +13,8 @@
   "scripts": {
     "prepare": "tsc -p tsconfig.build.json",
     "build": "tsc -p tsconfig.build.json",
+    "dev": "bun scripts/dev.ts",
+    "dev:clean": "bun scripts/dev-clean.ts",
     "test": "bun test",
     "types": "tsc",
     "format": "biome format --write .",
@@ -28,6 +30,7 @@
     "@opencode-ai/plugin": "1.3.13",
     "@tsconfig/bun": "1.0.10",
     "@types/bun": "1.3.11",
+    "dedent": "^1.7.2",
     "lefthook": "2.1.4",
     "typescript": "6.0.2"
   }