opencode-cluade-auth 1.0.0

package/README.md

@@ -0,0 +1,104 @@
+# opencode-cluade-auth
+
+Claude Code CLI-backed Anthropic auth plugin for OpenCode.
+
+This package registers an `anthropic` auth hook and translates Anthropic-style
+`/v1/messages` requests into local `claude` CLI executions instead of reusing
+Claude OAuth or API-key transport directly.
+
+## Quick Start
+
+1. Install the package where OpenCode can resolve it.
+2. Make sure the local `claude` CLI is installed and already logged in.
+3. Add the plugin to your OpenCode config.
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-cluade-auth@latest"],
+  "provider": {
+    "anthropic": {
+      "name": "Anthropic",
+      "npm": "@ai-sdk/anthropic"
+    }
+  }
+}
+```
+
+For local development, you can also point OpenCode at the built entry directly:
+
+```json
+{
+  "plugin": ["/absolute/path/to/opencode-cluade-auth/dist/index.js"]
+}
+```
+
+## What It Does
+
+- seeds a local `anthropic` auth entry for OpenCode
+- proxies Anthropic-style `/v1/messages` requests to the local `claude` CLI
+- converts Claude CLI output back into Anthropic-style JSON or buffered SSE
+- supports normal text replies and tool-calling-compatible response envelopes
+
+## Requirements
+
+- Claude Code CLI installed and logged in on the same machine
+- `claude --help` must expose the safe flags used by the adapter:
+  - `-p` or `--print`
+  - `--output-format`
+  - `--permission-mode plan`
+  - `--tools`
+  - `--no-session-persistence`
+
+## Runtime Behavior
+
+- the main user prompt is sent over `stdin`
+- large system prompts are written to a temporary file and passed via `--system-prompt-file`
+- the adapter runs Claude in non-interactive print mode with conservative flags
+- the plugin returns structured fetch errors when the local CLI is missing or exits unsuccessfully
+
+## Configuration
+
+Optional binary overrides:
+
+```bash
+export OPENCODE_CLAUDE_AUTH_BIN="/path/to/claude"
+# legacy/internal compatibility alias
+export AEGIS_CLAUDE_CODE_CLI_BIN="/path/to/claude"
+```
+
+Programmatic usage:
+
+```ts
+import ClaudeCodeCLIAuthPlugin from "opencode-cluade-auth";
+
+const plugin = await ClaudeCodeCLIAuthPlugin();
+```
+
+## Verification
+
+These checks are used during development before publish:
+
+```bash
+npm run build
+bun run typecheck
+bun test
+bun run smoke -- "Reply with exactly SMOKE_OK"
+bun run smoke -- --stream "Reply with exactly SMOKE_OK"
+npm pack --dry-run
+npm publish --dry-run
+```
+
+## Limitations
+
+- streaming responses are exposed as buffered Anthropic SSE, not live token passthrough
+- the package depends on the local `claude` CLI login state
+- this package does not bundle the Claude CLI itself
+
+## Development
+
+- `npm run build`
+- `bun run typecheck`
+- `bun test`
+- `bun run smoke -- "Reply with exactly SMOKE_OK"`
+- `bun run smoke -- --stream "Reply with exactly SMOKE_OK"`

package/dist/anthropic-compat.d.ts

@@ -0,0 +1,71 @@
+type AnthropicMessageRole = "user" | "assistant";
+export type AnthropicMessage = {
+    role: AnthropicMessageRole;
+    content: string;
+};
+export type AnthropicTool = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export type ClaudePreparedRequest = {
+    systemPrompt?: string;
+    userPrompt: string;
+    outputFormat: "text" | "json";
+};
+type ClaudeResponseEnvelope = {
+    type: "final";
+    content: string;
+} | {
+    type: "tool-calls";
+    tool_calls: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+};
+export declare function extractAnthropicRequest(raw: unknown): {
+    ok: true;
+    model: string;
+    system: string;
+    messages: AnthropicMessage[];
+    tools: AnthropicTool[];
+    stream: boolean;
+} | {
+    ok: false;
+    status: number;
+    reason: string;
+};
+export declare function buildClaudeUserPrompt(messages: AnthropicMessage[]): string;
+export declare function buildClaudePreparedRequest(params: {
+    system: string;
+    messages: AnthropicMessage[];
+    tools: AnthropicTool[];
+}): ClaudePreparedRequest;
+export declare function parseClaudeResponseEnvelope(text: string): ClaudeResponseEnvelope | null;
+export declare function buildAnthropicMessageResponse(params: {
+    model: string;
+    content: string;
+}): Response;
+export declare function buildAnthropicToolUseResponse(params: {
+    model: string;
+    toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+}): Response;
+export declare function buildAnthropicErrorResponse(status: number, message: string): Response;
+export declare function buildAnthropicMessageStreamResponse(params: {
+    model: string;
+    content: string;
+}): Response;
+export declare function buildAnthropicToolUseStreamResponse(params: {
+    model: string;
+    toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+}): Response;
+export {};

package/dist/anthropic-compat.js

@@ -0,0 +1,342 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asText(value) {
+    return typeof value === "string" ? value : "";
+}
+function pushSection(lines, title, content) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return;
+    }
+    lines.push(`${title}:`, trimmed, "");
+}
+function extractContentText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const block of content) {
+        if (!isRecord(block)) {
+            continue;
+        }
+        if (block.type === "text") {
+            const text = asText(block.text).trim();
+            if (text) {
+                parts.push(text);
+            }
+            continue;
+        }
+        if (block.type === "tool_result") {
+            const toolUseId = asText(block.tool_use_id).trim();
+            const toolText = extractContentText(block.content).trim();
+            const prefix = toolUseId ? `[tool_result ${toolUseId}]` : "[tool_result]";
+            parts.push(toolText ? `${prefix} ${toolText}` : prefix);
+            continue;
+        }
+        if (block.type === "tool_use") {
+            const name = asText(block.name).trim();
+            const id = asText(block.id).trim();
+            const input = isRecord(block.input) ? JSON.stringify(block.input) : "{}";
+            const label = ["[tool_use", name, id].filter(Boolean).join(" ");
+            parts.push(`${label}] ${input}`);
+        }
+    }
+    return parts.join("\n");
+}
+export function extractAnthropicRequest(raw) {
+    if (!isRecord(raw)) {
+        return { ok: false, status: 400, reason: "invalid request body" };
+    }
+    const model = asText(raw.model).trim();
+    if (!model) {
+        return { ok: false, status: 400, reason: "model is required" };
+    }
+    const messagesValue = raw.messages;
+    if (!Array.isArray(messagesValue) || messagesValue.length === 0) {
+        return { ok: false, status: 400, reason: "messages are required" };
+    }
+    const messages = [];
+    for (const entry of messagesValue) {
+        if (!isRecord(entry)) {
+            return { ok: false, status: 400, reason: "invalid messages" };
+        }
+        const role = entry.role;
+        if (role !== "user" && role !== "assistant") {
+            return { ok: false, status: 400, reason: "unsupported message role" };
+        }
+        messages.push({ role, content: extractContentText(entry.content) });
+    }
+    const tools = [];
+    if (Array.isArray(raw.tools)) {
+        for (const tool of raw.tools) {
+            if (!isRecord(tool)) {
+                continue;
+            }
+            const name = asText(tool.name).trim();
+            if (!name) {
+                continue;
+            }
+            tools.push({
+                name,
+                description: asText(tool.description).trim() || undefined,
+                inputSchema: isRecord(tool.input_schema) ? tool.input_schema : undefined,
+            });
+        }
+    }
+    return {
+        ok: true,
+        model,
+        system: extractContentText(raw.system),
+        messages,
+        tools,
+        stream: raw.stream === true,
+    };
+}
+export function buildClaudeUserPrompt(messages) {
+    if (messages.length === 1 && messages[0]?.role === "user") {
+        return messages[0].content;
+    }
+    const lines = [
+        "Continue the conversation below and produce the next assistant reply.",
+        "",
+        "Conversation:",
+    ];
+    for (const message of messages) {
+        const speaker = message.role === "assistant" ? "Assistant" : "User";
+        lines.push(`${speaker}: ${message.content}`);
+    }
+    return lines.join("\n");
+}
+function buildToolSystemPrompt(params) {
+    const lines = [];
+    pushSection(lines, "System requirements", params.system);
+    lines.push("You are preparing the next assistant turn for an outer Anthropic-compatible orchestrator.", "Tool execution is disabled in this local Claude Code session.", "If a tool is needed, return a tool-calls object for the outer orchestrator to execute.", "If no tool is needed, return a final object with the assistant text.", "Only use the provided tool names and their declared input schema.", "Return only a single JSON object and no surrounding prose.", 'Allowed shapes:', '{"type":"final","content":"..."}', '{"type":"tool-calls","tool_calls":[{"id":"call_1","name":"toolName","arguments":{}}]}', "", "Available tools:", JSON.stringify(params.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? "",
+        input_schema: tool.inputSchema ?? { type: "object", properties: {} },
+    }))));
+    return lines.join("\n").trim();
+}
+export function buildClaudePreparedRequest(params) {
+    const userPrompt = buildClaudeUserPrompt(params.messages);
+    if (params.tools.length > 0) {
+        return {
+            systemPrompt: buildToolSystemPrompt({ system: params.system, tools: params.tools }),
+            userPrompt,
+            outputFormat: "text",
+        };
+    }
+    return {
+        systemPrompt: params.system.trim() || undefined,
+        userPrompt,
+        outputFormat: "text",
+    };
+}
+export function parseClaudeResponseEnvelope(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (isRecord(parsed) && isRecord(parsed.structured_output)) {
+        parsed = parsed.structured_output;
+    }
+    if (isRecord(parsed) && typeof parsed.result === "string") {
+        return {
+            type: "final",
+            content: parsed.result,
+        };
+    }
+    if (!isRecord(parsed)) {
+        return null;
+    }
+    if (parsed.type === "final") {
+        return {
+            type: "final",
+            content: asText(parsed.content),
+        };
+    }
+    if (parsed.type !== "tool-calls" || !Array.isArray(parsed.tool_calls)) {
+        return null;
+    }
+    const toolCalls = parsed.tool_calls.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const id = asText(entry.id).trim();
+        const name = asText(entry.name).trim();
+        const args = isRecord(entry.arguments) ? entry.arguments : null;
+        if (!id || !name || !args) {
+            return [];
+        }
+        return [{ id, name, arguments: args }];
+    });
+    return toolCalls.length > 0 ? { type: "tool-calls", tool_calls: toolCalls } : null;
+}
+export function buildAnthropicMessageResponse(params) {
+    return new Response(JSON.stringify({
+        id: `msg_${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: params.model,
+        content: [{ type: "text", text: params.content }],
+        stop_reason: "end_turn",
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+    }), {
+        status: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+export function buildAnthropicToolUseResponse(params) {
+    return new Response(JSON.stringify({
+        id: `msg_${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        model: params.model,
+        content: params.toolCalls.map((toolCall) => ({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.name,
+            input: toolCall.arguments,
+        })),
+        stop_reason: "tool_use",
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+    }), {
+        status: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+export function buildAnthropicErrorResponse(status, message) {
+    return new Response(JSON.stringify({
+        type: "error",
+        error: {
+            type: status >= 500 ? "api_error" : "invalid_request_error",
+            message,
+        },
+    }), {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+function encodeSSEEvent(event, payload) {
+    return `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`;
+}
+function buildSSEHeaders() {
+    return {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+    };
+}
+export function buildAnthropicMessageStreamResponse(params) {
+    const messageId = `msg_${Date.now()}`;
+    const body = [
+        encodeSSEEvent("message_start", {
+            type: "message_start",
+            message: {
+                id: messageId,
+                type: "message",
+                role: "assistant",
+                model: params.model,
+                content: [],
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 },
+            },
+        }),
+        encodeSSEEvent("content_block_start", {
+            type: "content_block_start",
+            index: 0,
+            content_block: {
+                type: "text",
+                text: "",
+            },
+        }),
+        encodeSSEEvent("content_block_delta", {
+            type: "content_block_delta",
+            index: 0,
+            delta: {
+                type: "text_delta",
+                text: params.content,
+            },
+        }),
+        encodeSSEEvent("content_block_stop", {
+            type: "content_block_stop",
+            index: 0,
+        }),
+        encodeSSEEvent("message_delta", {
+            type: "message_delta",
+            delta: {
+                stop_reason: "end_turn",
+                stop_sequence: null,
+            },
+            usage: { output_tokens: 0 },
+        }),
+        encodeSSEEvent("message_stop", {
+            type: "message_stop",
+        }),
+    ].join("");
+    return new Response(body, {
+        status: 200,
+        headers: buildSSEHeaders(),
+    });
+}
+export function buildAnthropicToolUseStreamResponse(params) {
+    const messageId = `msg_${Date.now()}`;
+    const bodyParts = [
+        encodeSSEEvent("message_start", {
+            type: "message_start",
+            message: {
+                id: messageId,
+                type: "message",
+                role: "assistant",
+                model: params.model,
+                content: [],
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 },
+            },
+        }),
+    ];
+    params.toolCalls.forEach((toolCall, index) => {
+        bodyParts.push(encodeSSEEvent("content_block_start", {
+            type: "content_block_start",
+            index,
+            content_block: {
+                type: "tool_use",
+                id: toolCall.id,
+                name: toolCall.name,
+                input: toolCall.arguments,
+            },
+        }), encodeSSEEvent("content_block_stop", {
+            type: "content_block_stop",
+            index,
+        }));
+    });
+    bodyParts.push(encodeSSEEvent("message_delta", {
+        type: "message_delta",
+        delta: {
+            stop_reason: "tool_use",
+            stop_sequence: null,
+        },
+        usage: { output_tokens: 0 },
+    }), encodeSSEEvent("message_stop", {
+        type: "message_stop",
+    }));
+    return new Response(bodyParts.join(""), {
+        status: 200,
+        headers: buildSSEHeaders(),
+    });
+}

package/dist/claude-cli.d.ts

@@ -0,0 +1,21 @@
+export type ClaudeCodeRunResult = {
+    ok: boolean;
+    responseText?: string;
+    reason?: string;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+};
+export declare function runClaudeCode(params: {
+    prompt: string;
+    systemPrompt?: string;
+    model?: string;
+    effort?: "low" | "medium" | "high";
+    outputFormat?: "text" | "json" | "stream-json";
+    jsonSchema?: Record<string, unknown>;
+    verbose?: boolean;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    maxOutputChars?: number;
+}): Promise<ClaudeCodeRunResult>;

package/dist/claude-cli.js

@@ -0,0 +1,274 @@
+import { spawn as spawnNode } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, resolve } from "node:path";
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function truncate(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return text.slice(0, maxChars);
+}
+function summarizeProcessFailure(stdout, stderr) {
+    const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join(" | ");
+    return detail ? truncate(detail, 400) : "no process output";
+}
+async function createTempTextFile(prefix, fileName, text) {
+    const dir = await mkdtemp(resolve(tmpdir(), prefix));
+    const path = resolve(dir, fileName);
+    await writeFile(path, text, "utf-8");
+    return {
+        path,
+        cleanup: async () => {
+            await rm(dir, { recursive: true, force: true });
+        },
+    };
+}
+function parseHelpCapabilities(helpText) {
+    const text = helpText || "";
+    const lines = text.split(/\r?\n/);
+    const permissionModeLine = lines.find((line) => /\B--permission-mode\b/i.test(line)) ?? "";
+    return {
+        hasPrintFlag: /(^|\s)-p(\s|,|$)|\B--print\b/i.test(text),
+        hasOutputFormat: /\B--output-format\b/i.test(text),
+        hasPermissionMode: /\B--permission-mode\b/i.test(text),
+        hasPermissionModePlanSupport: /\bplan\b/i.test(permissionModeLine),
+        hasToolsFlag: /\B--tools\b/i.test(text),
+        hasNoSessionPersistenceFlag: /\B--no-session-persistence\b/i.test(text),
+        hasModelFlag: /\B--model\b/i.test(text),
+        hasEffortFlag: /\B--effort\b/i.test(text),
+    };
+}
+function normalizeEffort(value) {
+    if (!nonEmpty(value)) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "low" || normalized === "medium" || normalized === "high") {
+        return normalized;
+    }
+    return undefined;
+}
+function resolveClaudeModelAlias(model) {
+    if (!nonEmpty(model)) {
+        return undefined;
+    }
+    const normalized = model.trim().toLowerCase();
+    if (normalized.startsWith("anthropic/")) {
+        return resolveClaudeModelAlias(normalized.slice("anthropic/".length));
+    }
+    if (normalized.startsWith("claude-opus")) {
+        return "opus";
+    }
+    if (normalized.startsWith("claude-haiku")) {
+        return "haiku";
+    }
+    if (normalized.startsWith("claude-sonnet")) {
+        return "sonnet";
+    }
+    return model.trim();
+}
+async function collectStream(stream, maxChars) {
+    if (!stream) {
+        return "";
+    }
+    const chunks = [];
+    let total = 0;
+    try {
+        for await (const chunk of stream) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            chunks.push(buffer);
+            total += buffer.length;
+            if (total >= maxChars * 2) {
+                break;
+            }
+        }
+    }
+    catch (error) {
+        const typed = error;
+        if (typed.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+            throw error;
+        }
+    }
+    return truncate(Buffer.concat(chunks).toString("utf-8"), maxChars);
+}
+async function spawnAndCollect(params) {
+    const isWindows = process.platform === "win32";
+    const ext = extname(params.bin).toLowerCase();
+    const shouldWrapNode = isWindows && (ext === ".js" || ext === ".mjs" || ext === ".cjs");
+    const actualBin = shouldWrapNode ? "node" : params.bin;
+    const actualArgs = shouldWrapNode ? [params.bin, ...params.args] : params.args;
+    let child;
+    try {
+        child = spawnNode(actualBin, actualArgs, {
+            cwd: params.cwd,
+            env: {
+                ...params.env,
+                CI: "true",
+                NO_COLOR: "1",
+                TERM: "dumb",
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const typed = error;
+        return {
+            exitCode: 127,
+            stdout: "",
+            stderr: typed.message || String(error),
+            timedOut: false,
+            spawnErrorCode: typeof typed.code === "string" ? typed.code : undefined,
+        };
+    }
+    if (typeof params.stdinText === "string") {
+        child.stdin?.end(params.stdinText);
+    }
+    else {
+        child.stdin?.end();
+    }
+    let timedOut = false;
+    let spawnErrorCode;
+    child.once("error", (error) => {
+        const typed = error;
+        spawnErrorCode = typeof typed.code === "string" ? typed.code : undefined;
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+    });
+    const timer = setTimeout(() => {
+        timedOut = true;
+        if (!child.killed) {
+            child.kill();
+        }
+    }, Math.max(100, params.timeoutMs));
+    const exitCodePromise = new Promise((resolveExit) => {
+        child.once("close", (code) => resolveExit(typeof code === "number" ? code : 1));
+        child.once("error", () => resolveExit(127));
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        collectStream(child.stdout, params.maxOutputChars),
+        collectStream(child.stderr, params.maxOutputChars),
+        exitCodePromise,
+    ]);
+    clearTimeout(timer);
+    return { exitCode, stdout, stderr, timedOut, spawnErrorCode };
+}
+export async function runClaudeCode(params) {
+    const prompt = nonEmpty(params.prompt) ? params.prompt.trim() : "";
+    if (!prompt) {
+        return { ok: false, reason: "prompt is required" };
+    }
+    const env = params.env ?? process.env;
+    const bin = nonEmpty(env.OPENCODE_CLAUDE_AUTH_BIN)
+        ? env.OPENCODE_CLAUDE_AUTH_BIN.trim()
+        : nonEmpty(env.AEGIS_CLAUDE_CODE_CLI_BIN)
+            ? env.AEGIS_CLAUDE_CODE_CLI_BIN.trim()
+            : "claude";
+    const cwd = nonEmpty(params.cwd) ? resolve(params.cwd) : process.cwd();
+    const timeoutMs = typeof params.timeoutMs === "number" ? Math.max(100, Math.floor(params.timeoutMs)) : 60_000;
+    const maxOutputChars = typeof params.maxOutputChars === "number" ? Math.max(1_000, Math.floor(params.maxOutputChars)) : 20_000;
+    const outputFormat = params.outputFormat ?? "text";
+    const help = await spawnAndCollect({
+        bin,
+        args: ["--help"],
+        cwd,
+        env,
+        timeoutMs: Math.min(timeoutMs, 10_000),
+        maxOutputChars,
+    });
+    if (help.timedOut) {
+        return { ok: false, reason: "claude --help timed out", exitCode: 124, stdout: help.stdout, stderr: help.stderr };
+    }
+    if (help.spawnErrorCode === "ENOENT") {
+        return { ok: false, reason: `Claude Code CLI binary not found: ${bin}`, exitCode: 127 };
+    }
+    if (help.exitCode !== 0) {
+        return {
+            ok: false,
+            reason: `claude --help failed (exit=${help.exitCode}): ${summarizeProcessFailure(help.stdout, help.stderr)}`,
+            exitCode: help.exitCode,
+            stdout: help.stdout,
+            stderr: help.stderr,
+        };
+    }
+    const capabilities = parseHelpCapabilities(`${help.stdout}\n${help.stderr}`);
+    const missing = [];
+    if (!capabilities.hasPrintFlag)
+        missing.push("-p/--print");
+    if (!capabilities.hasOutputFormat)
+        missing.push("--output-format");
+    if (!capabilities.hasPermissionMode)
+        missing.push("--permission-mode");
+    if (!capabilities.hasPermissionModePlanSupport)
+        missing.push("--permission-mode plan");
+    if (!capabilities.hasToolsFlag)
+        missing.push("--tools");
+    if (!capabilities.hasNoSessionPersistenceFlag)
+        missing.push("--no-session-persistence");
+    if (missing.length > 0) {
+        return { ok: false, reason: `Claude Code CLI is missing required safe flags: ${missing.join(", ")}` };
+    }
+    const args = [
+        "-p",
+        "--output-format",
+        outputFormat,
+        "--permission-mode",
+        "plan",
+        "--tools",
+        "",
+        "--no-session-persistence",
+    ];
+    if (params.verbose) {
+        args.push("--verbose");
+    }
+    let systemPromptFile;
+    if (nonEmpty(params.systemPrompt)) {
+        systemPromptFile = await createTempTextFile("opencode-claude-system-", "system-prompt.txt", params.systemPrompt.trim());
+        args.push("--system-prompt-file", systemPromptFile.path);
+    }
+    if (params.jsonSchema && typeof params.jsonSchema === "object") {
+        args.push("--json-schema", JSON.stringify(params.jsonSchema));
+    }
+    const model = resolveClaudeModelAlias(params.model);
+    if (model && capabilities.hasModelFlag) {
+        args.push("--model", model);
+    }
+    const effort = normalizeEffort(params.effort);
+    if (effort && capabilities.hasEffortFlag) {
+        args.push("--effort", effort);
+    }
+    const run = await (async () => {
+        try {
+            return await spawnAndCollect({
+                bin,
+                args,
+                cwd,
+                env,
+                timeoutMs,
+                maxOutputChars,
+                stdinText: prompt,
+            });
+        }
+        finally {
+            await systemPromptFile?.cleanup();
+        }
+    })();
+    if (run.timedOut) {
+        return { ok: false, reason: `Claude Code CLI timed out after ${timeoutMs}ms`, exitCode: 124, stdout: run.stdout, stderr: run.stderr };
+    }
+    if (run.spawnErrorCode === "ENOENT") {
+        return { ok: false, reason: `Claude Code CLI binary not found: ${bin}`, exitCode: 127 };
+    }
+    if (run.exitCode !== 0) {
+        return {
+            ok: false,
+            reason: `claude exited with code ${run.exitCode}: ${summarizeProcessFailure(run.stdout, run.stderr)}`,
+            exitCode: run.exitCode,
+            stdout: run.stdout,
+            stderr: run.stderr,
+        };
+    }
+    return { ok: true, responseText: run.stdout.trim(), exitCode: 0, stdout: run.stdout, stderr: run.stderr };
+}

package/dist/fetch.d.ts

@@ -0,0 +1,5 @@
+import { runClaudeCode } from "./claude-cli.js";
+export type ClaudeCodeFetchDeps = {
+    runClaudeCodeImpl?: typeof runClaudeCode;
+};
+export declare function createClaudeCodeFetch(deps?: ClaudeCodeFetchDeps): (_input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/fetch.js

@@ -0,0 +1,70 @@
+import { buildAnthropicErrorResponse, buildAnthropicMessageResponse, buildAnthropicMessageStreamResponse, buildAnthropicToolUseResponse, buildAnthropicToolUseStreamResponse, buildClaudePreparedRequest, extractAnthropicRequest, parseClaudeResponseEnvelope, } from "./anthropic-compat.js";
+import { runClaudeCode } from "./claude-cli.js";
+function effortFromRequest(_raw) {
+    return undefined;
+}
+function errorFromRunResult(result) {
+    const status = result.exitCode === 124 ? 504 : 502;
+    return buildAnthropicErrorResponse(status, result.reason ?? "Claude Code CLI failed");
+}
+export function createClaudeCodeFetch(deps = {}) {
+    const runClaudeCodeImpl = deps.runClaudeCodeImpl ?? runClaudeCode;
+    return async (_input, init) => {
+        if (init?.body !== undefined && typeof init.body !== "string") {
+            return buildAnthropicErrorResponse(400, "request body must be a JSON string");
+        }
+        if (typeof init?.body !== "string" || !init.body.trim()) {
+            return buildAnthropicErrorResponse(400, "request body is required");
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(init.body);
+        }
+        catch {
+            return buildAnthropicErrorResponse(400, "request body must be valid JSON");
+        }
+        const request = extractAnthropicRequest(parsed);
+        if (!request.ok) {
+            return buildAnthropicErrorResponse(request.status, request.reason);
+        }
+        const prepared = buildClaudePreparedRequest({
+            system: request.system,
+            messages: request.messages,
+            tools: request.tools,
+        });
+        const result = await runClaudeCodeImpl({
+            prompt: prepared.userPrompt,
+            systemPrompt: prepared.systemPrompt,
+            outputFormat: prepared.outputFormat,
+            model: request.model,
+            effort: effortFromRequest(parsed),
+        });
+        if (!result.ok) {
+            return errorFromRunResult(result);
+        }
+        const responseText = result.responseText ?? "";
+        const envelope = parseClaudeResponseEnvelope(responseText);
+        if (envelope?.type === "tool-calls") {
+            if (request.stream) {
+                return buildAnthropicToolUseStreamResponse({
+                    model: request.model,
+                    toolCalls: envelope.tool_calls,
+                });
+            }
+            return buildAnthropicToolUseResponse({
+                model: request.model,
+                toolCalls: envelope.tool_calls,
+            });
+        }
+        if (request.stream) {
+            return buildAnthropicMessageStreamResponse({
+                model: request.model,
+                content: envelope?.type === "final" ? envelope.content : responseText,
+            });
+        }
+        return buildAnthropicMessageResponse({
+            model: request.model,
+            content: envelope?.type === "final" ? envelope.content : responseText,
+        });
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export type AuthMethod = {
+    provider?: string;
+    label: string;
+    type: "api" | "oauth";
+};
+export type LoaderResult = {
+    apiKey: string;
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+};
+export type AuthHook = {
+    provider: string;
+    loader(getAuth?: unknown, provider?: unknown): Promise<LoaderResult | null>;
+    methods: AuthMethod[];
+};
+export type ClaudeAuthPlugin = {
+    auth: AuthHook;
+};
+type PluginContext = {
+    client?: {
+        auth?: {
+            set(input: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    type: "api";
+                    key: string;
+                    apiKey: string;
+                };
+            }): Promise<unknown>;
+        };
+    };
+};
+declare function ClaudeCodeCLIAuthPlugin(context?: PluginContext): Promise<ClaudeAuthPlugin>;
+export default ClaudeCodeCLIAuthPlugin;

package/dist/index.js

@@ -0,0 +1,36 @@
+import { createClaudeCodeFetch } from "./fetch.js";
+const CLAUDE_PROVIDER_ID = "anthropic";
+async function seedLocalAnthropicAuth(context) {
+    const auth = context?.client?.auth;
+    if (!auth?.set) {
+        return;
+    }
+    await auth.set({
+        path: { id: CLAUDE_PROVIDER_ID },
+        body: {
+            type: "api",
+            key: "claude-code-cli",
+            apiKey: "claude-code-cli",
+        },
+    });
+}
+async function ClaudeCodeCLIAuthPlugin(context) {
+    await seedLocalAnthropicAuth(context);
+    return {
+        auth: {
+            provider: CLAUDE_PROVIDER_ID,
+            loader: async () => ({
+                apiKey: "claude-code-cli",
+                fetch: createClaudeCodeFetch(),
+            }),
+            methods: [
+                {
+                    provider: CLAUDE_PROVIDER_ID,
+                    label: "Claude Code CLI (local)",
+                    type: "api",
+                },
+            ],
+        },
+    };
+}
+export default ClaudeCodeCLIAuthPlugin;

package/dist/smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/smoke.js

@@ -0,0 +1,27 @@
+import ClaudeCodeCLIAuthPlugin from "./index.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const stream = args.includes("--stream");
+    const prompt = args.filter((arg) => arg !== "--stream").join(" ").trim() || "Reply with exactly SMOKE_OK";
+    const plugin = await ClaudeCodeCLIAuthPlugin();
+    const loader = await plugin.auth.loader();
+    if (!loader) {
+        throw new Error("auth loader returned null");
+    }
+    const response = await loader.fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            model: "claude-sonnet-4-5",
+            max_tokens: 128,
+            stream,
+            messages: [{ role: "user", content: prompt }],
+        }),
+    });
+    const bodyText = await response.text();
+    process.stdout.write(`${bodyText}\n`);
+    if (!response.ok) {
+        process.exitCode = 1;
+    }
+}
+void main();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "opencode-cluade-auth",
+  "version": "1.0.0",
+  "description": "Claude Code CLI-backed Anthropic auth plugin for OpenCode.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "anthropic",
+    "claude",
+    "claude-code",
+    "opencode",
+    "plugin",
+    "auth"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GunP4ng/openocde-claude-auth.git"
+  },
+  "homepage": "https://github.com/GunP4ng/openocde-claude-auth#readme",
+  "bugs": {
+    "url": "https://github.com/GunP4ng/openocde-claude-auth/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "bun test",
+    "smoke": "bun run src/smoke.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^22.10.2",
+    "typescript": "^5.5.4"
+  }
+}