opencode-claude-code-wrapper 0.0.1

package/index.mjs

@@ -0,0 +1,268 @@
+import {
+  transformRequestToCLIArgs,
+  spawnClaudeCode,
+  generateId,
+} from "./lib/cli-runner.mjs";
+import {
+  JSONLToSSETransformer,
+  buildCompleteResponse,
+} from "./lib/transformer.mjs";
+
+/**
+ * Create an error response
+ * @param {Error|string} error - The error
+ * @param {number} statusCode - HTTP status code
+ * @returns {Response} Error response
+ */
+function createErrorResponse(error, statusCode = 500) {
+  return new Response(
+    JSON.stringify({
+      type: "error",
+      error: {
+        type: "api_error",
+        message: error.message || String(error),
+      },
+    }),
+    {
+      status: statusCode,
+      headers: { "Content-Type": "application/json" },
+    }
+  );
+}
+
+/**
+ * Create a streaming response from Claude Code process
+ * @param {ChildProcess} child - Claude Code child process
+ * @param {object} requestBody - Original request body
+ * @returns {Response} Streaming response
+ */
+function createStreamingResponse(child, requestBody) {
+  const transformer = new JSONLToSSETransformer(requestBody);
+  const encoder = new TextEncoder();
+
+  let buffer = "";
+  let finalized = false;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      child.stdout.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          const sseEvents = transformer.transformLine(line);
+          if (sseEvents) {
+            controller.enqueue(encoder.encode(sseEvents));
+          }
+        }
+      });
+
+      child.stderr.on("data", (chunk) => {
+        // Log stderr for debugging but don't fail
+        console.error("[claude-code-wrapper] stderr:", chunk.toString());
+      });
+
+      child.on("close", (code) => {
+        // Process any remaining buffer
+        if (buffer.trim()) {
+          const sseEvents = transformer.transformLine(buffer);
+          if (sseEvents) {
+            controller.enqueue(encoder.encode(sseEvents));
+          }
+        }
+
+        // Send final events if not already sent
+        if (!finalized) {
+          finalized = true;
+          const finalEvents = transformer.finalize();
+          controller.enqueue(encoder.encode(finalEvents));
+        }
+
+        controller.close();
+      });
+
+      child.on("error", (err) => {
+        console.error("[claude-code-wrapper] process error:", err);
+        controller.error(err);
+      });
+    },
+
+    cancel() {
+      child.kill();
+    },
+  });
+
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}
+
+/**
+ * Create a non-streaming response from Claude Code process
+ * @param {ChildProcess} child - Claude Code child process
+ * @param {object} requestBody - Original request body
+ * @returns {Promise<Response>} Complete response
+ */
+async function createNonStreamingResponse(child, requestBody) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0 && !stdout.trim()) {
+        resolve(
+          new Response(
+            JSON.stringify({
+              type: "error",
+              error: {
+                type: "api_error",
+                message: `Claude Code exited with code ${code}: ${stderr}`,
+              },
+            }),
+            {
+              status: 500,
+              headers: { "Content-Type": "application/json" },
+            }
+          )
+        );
+        return;
+      }
+
+      const response = buildCompleteResponse(stdout, requestBody);
+      resolve(
+        new Response(JSON.stringify(response), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      );
+    });
+
+    child.on("error", (err) => {
+      resolve(createErrorResponse(err));
+    });
+  });
+}
+
+/**
+ * Handle incoming request and route to Claude Code CLI
+ * @param {Request|string} input - Fetch input
+ * @param {RequestInit} init - Fetch init options
+ * @returns {Promise<Response>} Response
+ */
+async function handleClaudeCodeRequest(input, init) {
+  // Parse the incoming request URL
+  let requestUrl;
+  try {
+    if (typeof input === "string" || input instanceof URL) {
+      requestUrl = new URL(input.toString());
+    } else if (input instanceof Request) {
+      requestUrl = new URL(input.url);
+    }
+  } catch {
+    requestUrl = null;
+  }
+
+  // Only intercept messages endpoint
+  if (!requestUrl || !requestUrl.pathname.includes("/v1/messages")) {
+    return fetch(input, init);
+  }
+
+  // Parse request body
+  let requestBody;
+  try {
+    let bodyStr = "";
+    if (init?.body) {
+      bodyStr = init.body;
+    } else if (input instanceof Request) {
+      bodyStr = await input.text();
+    }
+    requestBody = JSON.parse(bodyStr);
+  } catch (e) {
+    return new Response(JSON.stringify({ error: "Invalid request body" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  // Check if streaming is requested
+  const isStreaming = requestBody.stream === true;
+
+  // Transform request to CLI args
+  const cliArgs = transformRequestToCLIArgs(requestBody);
+
+  // Spawn Claude Code process
+  const child = spawnClaudeCode(cliArgs, { streaming: isStreaming });
+
+  if (isStreaming) {
+    return createStreamingResponse(child, requestBody);
+  } else {
+    return createNonStreamingResponse(child, requestBody);
+  }
+}
+
+/**
+ * OpenCode plugin that wraps Claude Code CLI
+ * @type {import('@opencode-ai/plugin').Plugin}
+ */
+export async function ClaudeCodeWrapperPlugin({ client }) {
+  return {
+    auth: {
+      provider: "anthropic",
+      async loader(getAuth, provider) {
+        // Zero out costs - Claude Code handles its own billing
+        for (const model of Object.values(provider.models)) {
+          model.cost = {
+            input: 0,
+            output: 0,
+            cache: {
+              read: 0,
+              write: 0,
+            },
+          };
+        }
+
+        return {
+          apiKey: "", // Not needed - Claude Code handles auth
+          /**
+           * Custom fetch that routes to Claude Code CLI
+           * @param {any} input - Fetch input
+           * @param {any} init - Fetch init options
+           */
+          async fetch(input, init) {
+            try {
+              return await handleClaudeCodeRequest(input, init);
+            } catch (error) {
+              console.error("[claude-code-wrapper] error:", error);
+              return createErrorResponse(error);
+            }
+          },
+        };
+      },
+      methods: [
+        {
+          label: "Claude Code CLI",
+          type: "api",
+          // Simple passthrough - Claude Code handles auth via its own config
+          // Users should run 'claude setup-token' or set ANTHROPIC_API_KEY
+        },
+      ],
+    },
+  };
+}
+
+// Default export for convenience
+export default ClaudeCodeWrapperPlugin;

package/lib/cli-runner.mjs

@@ -0,0 +1,174 @@
+import { spawn } from "child_process";
+
+/**
+ * Model name mapping from Anthropic API model IDs to Claude Code CLI model aliases
+ */
+const MODEL_MAP = {
+  "claude-sonnet-4-5-20250929": "sonnet",
+  "claude-opus-4-5-20251101": "opus",
+  "claude-3-5-sonnet-20241022": "sonnet",
+  "claude-3-5-haiku-20241022": "haiku",
+  "claude-3-opus-20240229": "opus",
+  "claude-3-sonnet-20240229": "sonnet",
+  "claude-3-haiku-20240307": "haiku",
+};
+
+/**
+ * Transform Anthropic API request body to Claude Code CLI arguments
+ * @param {object} requestBody - The API request body
+ * @returns {object} CLI arguments configuration
+ */
+export function transformRequestToCLIArgs(requestBody) {
+  const args = {
+    prompt: "",
+    model: null,
+    systemPrompt: null,
+  };
+
+  // Map model name
+  if (requestBody.model) {
+    args.model = MODEL_MAP[requestBody.model] || requestBody.model;
+  }
+
+  // Extract system prompt
+  if (requestBody.system) {
+    if (typeof requestBody.system === "string") {
+      args.systemPrompt = requestBody.system;
+    } else if (Array.isArray(requestBody.system)) {
+      args.systemPrompt = requestBody.system
+        .filter((s) => s.type === "text")
+        .map((s) => s.text)
+        .join("\n");
+    }
+  }
+
+  // Build prompt from messages
+  if (requestBody.messages && Array.isArray(requestBody.messages)) {
+    args.prompt = formatMessages(requestBody.messages);
+  }
+
+  return args;
+}
+
+/**
+ * Format messages array into a prompt string for Claude Code
+ * @param {Array} messages - Array of message objects
+ * @returns {string} Formatted prompt
+ */
+function formatMessages(messages) {
+  const parts = [];
+
+  for (const msg of messages) {
+    const role = msg.role === "user" ? "Human" : "Assistant";
+    let content = "";
+
+    if (typeof msg.content === "string") {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      const textParts = [];
+      const toolResults = [];
+
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_result") {
+          toolResults.push(
+            `[Tool Result for ${block.tool_use_id}]: ${typeof block.content === "string" ? block.content : JSON.stringify(block.content)}`
+          );
+        } else if (block.type === "tool_use") {
+          textParts.push(
+            `[Tool Call: ${block.name}]\nInput: ${JSON.stringify(block.input, null, 2)}`
+          );
+        }
+      }
+
+      if (toolResults.length > 0) {
+        content = toolResults.join("\n");
+      }
+      if (textParts.length > 0) {
+        content = (content ? content + "\n" : "") + textParts.join("\n");
+      }
+    }
+
+    if (content) {
+      parts.push(`${role}: ${content}`);
+    }
+  }
+
+  // Return only the last user message if it's a simple request,
+  // or the full conversation for context
+  if (parts.length === 1) {
+    return parts[0].replace(/^Human: /, "");
+  }
+
+  return parts.join("\n\n");
+}
+
+/**
+ * Spawn Claude Code CLI process
+ * @param {object} cliArgs - Arguments from transformRequestToCLIArgs
+ * @param {object} options - Additional options
+ * @param {boolean} options.streaming - Whether to enable streaming output
+ * @param {number} options.timeout - Timeout in milliseconds (default: 5 minutes)
+ * @returns {ChildProcess} Spawned child process
+ */
+export function spawnClaudeCode(cliArgs, options = {}) {
+  const { streaming = true, timeout = 300000 } = options;
+
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose", // Required for stream-json output
+    // Disable all MCP servers - Claude Code acts as pure API backend
+    "--strict-mcp-config",
+    "--mcp-config",
+    '{"mcpServers":{}}',
+  ];
+
+  if (cliArgs.model) {
+    args.push("--model", cliArgs.model);
+  }
+
+  if (cliArgs.systemPrompt) {
+    args.push("--system-prompt", cliArgs.systemPrompt);
+  }
+
+  // Add the prompt as the last argument
+  args.push(cliArgs.prompt);
+
+  const child = spawn("claude", args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env },
+  });
+
+  // Close stdin immediately - Claude Code waits for stdin to close in -p mode
+  child.stdin.end();
+
+  // Set up timeout
+  if (timeout > 0) {
+    const timeoutId = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 5000);
+    }, timeout);
+
+    child.on("close", () => clearTimeout(timeoutId));
+  }
+
+  return child;
+}
+
+/**
+ * Generate a random message ID
+ * @returns {string} Random ID
+ */
+export function generateId() {
+  return (
+    Math.random().toString(36).substring(2, 15) +
+    Math.random().toString(36).substring(2, 15)
+  );
+}

package/lib/transformer.mjs

@@ -0,0 +1,381 @@
+import { generateId } from "./cli-runner.mjs";
+
+/**
+ * Transforms Claude Code JSONL output to Anthropic SSE streaming format
+ */
+export class JSONLToSSETransformer {
+  constructor(requestBody) {
+    this.requestBody = requestBody;
+    this.messageId = `msg_${generateId()}`;
+    this.contentBlockIndex = 0;
+    this.hasStarted = false;
+    this.currentBlockStarted = false;
+    this.outputTokens = 0;
+    this.inputTokens = 0;
+  }
+
+  /**
+   * Create an SSE event string
+   * @param {string} eventType - The event type
+   * @param {object} data - The event data
+   * @returns {string} Formatted SSE event
+   */
+  createSSEEvent(eventType, data) {
+    return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+  }
+
+  /**
+   * Transform a single JSONL line to SSE events
+   * @param {string} line - JSONL line
+   * @returns {string} SSE events string
+   */
+  transformLine(line) {
+    if (!line.trim()) return "";
+
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (e) {
+      return "";
+    }
+
+    const events = [];
+
+    // Handle system init - emit message_start
+    if (parsed.type === "system" && parsed.subtype === "init") {
+      if (!this.hasStarted) {
+        events.push(this.createMessageStart());
+        this.hasStarted = true;
+      }
+      return events.join("");
+    }
+
+    // Handle assistant message events
+    if (parsed.type === "assistant") {
+      if (!this.hasStarted) {
+        events.push(this.createMessageStart());
+        this.hasStarted = true;
+      }
+
+      const msg = parsed.message;
+
+      if (msg && msg.content && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            // Start content block if needed
+            if (!this.currentBlockStarted) {
+              events.push(
+                this.createContentBlockStart(this.contentBlockIndex, "text")
+              );
+              this.currentBlockStarted = true;
+            }
+
+            // Send text delta
+            events.push(
+              this.createSSEEvent("content_block_delta", {
+                type: "content_block_delta",
+                index: this.contentBlockIndex,
+                delta: { type: "text_delta", text: block.text },
+              })
+            );
+
+            // Estimate tokens
+            this.outputTokens += Math.ceil(block.text.length / 4);
+          } else if (block.type === "tool_use") {
+            // Close current text block if open
+            if (this.currentBlockStarted) {
+              events.push(
+                this.createSSEEvent("content_block_stop", {
+                  type: "content_block_stop",
+                  index: this.contentBlockIndex,
+                })
+              );
+              this.contentBlockIndex++;
+              this.currentBlockStarted = false;
+            }
+
+            // Emit tool_use block
+            events.push(this.createToolUseBlock(block));
+          }
+        }
+      }
+
+      // Handle usage if present
+      if (msg && msg.usage) {
+        this.inputTokens = msg.usage.input_tokens || this.inputTokens;
+        this.outputTokens = msg.usage.output_tokens || this.outputTokens;
+      }
+
+      // Handle stop_reason
+      if (msg && msg.stop_reason) {
+        // Close any open content block
+        if (this.currentBlockStarted) {
+          events.push(
+            this.createSSEEvent("content_block_stop", {
+              type: "content_block_stop",
+              index: this.contentBlockIndex,
+            })
+          );
+          this.currentBlockStarted = false;
+        }
+
+        events.push(this.createMessageDelta(msg.stop_reason));
+        events.push(
+          this.createSSEEvent("message_stop", { type: "message_stop" })
+        );
+      }
+
+      return events.join("");
+    }
+
+    // Handle content streaming events
+    if (parsed.type === "content_block_delta") {
+      if (!this.hasStarted) {
+        events.push(this.createMessageStart());
+        this.hasStarted = true;
+      }
+
+      if (!this.currentBlockStarted) {
+        events.push(
+          this.createContentBlockStart(
+            parsed.index ?? this.contentBlockIndex,
+            "text"
+          )
+        );
+        this.currentBlockStarted = true;
+      }
+
+      events.push(this.createSSEEvent("content_block_delta", parsed));
+      return events.join("");
+    }
+
+    // Handle result events (end of response)
+    if (parsed.type === "result") {
+      if (!this.hasStarted) {
+        events.push(this.createMessageStart());
+        this.hasStarted = true;
+      }
+
+      // Close any open content block
+      if (this.currentBlockStarted) {
+        events.push(
+          this.createSSEEvent("content_block_stop", {
+            type: "content_block_stop",
+            index: this.contentBlockIndex,
+          })
+        );
+        this.currentBlockStarted = false;
+      }
+
+      // Update usage from result
+      if (parsed.usage) {
+        this.inputTokens = parsed.usage.input_tokens || this.inputTokens;
+        this.outputTokens = parsed.usage.output_tokens || this.outputTokens;
+      }
+
+      events.push(this.createMessageDelta(parsed.stop_reason || "end_turn"));
+      events.push(
+        this.createSSEEvent("message_stop", { type: "message_stop" })
+      );
+      return events.join("");
+    }
+
+    return "";
+  }
+
+  /**
+   * Create message_start SSE event
+   * @returns {string} SSE event string
+   */
+  createMessageStart() {
+    return this.createSSEEvent("message_start", {
+      type: "message_start",
+      message: {
+        id: this.messageId,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: this.requestBody.model || "claude-sonnet-4-5-20250929",
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+  }
+
+  /**
+   * Create content_block_start SSE event
+   * @param {number} index - Content block index
+   * @param {string} type - Block type (text or tool_use)
+   * @returns {string} SSE event string
+   */
+  createContentBlockStart(index, type) {
+    return this.createSSEEvent("content_block_start", {
+      type: "content_block_start",
+      index: index,
+      content_block: type === "text" ? { type: "text", text: "" } : { type },
+    });
+  }
+
+  /**
+   * Create tool_use content block events
+   * @param {object} toolBlock - Tool use block from Claude Code
+   * @returns {string} SSE events string
+   */
+  createToolUseBlock(toolBlock) {
+    const events = [];
+
+    // content_block_start for tool_use
+    events.push(
+      this.createSSEEvent("content_block_start", {
+        type: "content_block_start",
+        index: this.contentBlockIndex,
+        content_block: {
+          type: "tool_use",
+          id: toolBlock.id || `toolu_${generateId()}`,
+          name: toolBlock.name,
+          input: {},
+        },
+      })
+    );
+
+    // Stream the input as input_json_delta
+    const inputStr = JSON.stringify(toolBlock.input || {});
+    events.push(
+      this.createSSEEvent("content_block_delta", {
+        type: "content_block_delta",
+        index: this.contentBlockIndex,
+        delta: {
+          type: "input_json_delta",
+          partial_json: inputStr,
+        },
+      })
+    );
+
+    // content_block_stop
+    events.push(
+      this.createSSEEvent("content_block_stop", {
+        type: "content_block_stop",
+        index: this.contentBlockIndex,
+      })
+    );
+
+    this.contentBlockIndex++;
+    return events.join("");
+  }
+
+  /**
+   * Create message_delta SSE event
+   * @param {string} stopReason - Stop reason
+   * @returns {string} SSE event string
+   */
+  createMessageDelta(stopReason) {
+    return this.createSSEEvent("message_delta", {
+      type: "message_delta",
+      delta: {
+        stop_reason: stopReason || "end_turn",
+        stop_sequence: null,
+      },
+      usage: { output_tokens: this.outputTokens },
+    });
+  }
+
+  /**
+   * Finalize the stream with closing events
+   * @returns {string} Final SSE events string
+   */
+  finalize() {
+    const events = [];
+
+    // Ensure message started
+    if (!this.hasStarted) {
+      events.push(this.createMessageStart());
+    }
+
+    // Close any open content block
+    if (this.currentBlockStarted) {
+      events.push(
+        this.createSSEEvent("content_block_stop", {
+          type: "content_block_stop",
+          index: this.contentBlockIndex,
+        })
+      );
+    }
+
+    events.push(this.createMessageDelta("end_turn"));
+    events.push(this.createSSEEvent("message_stop", { type: "message_stop" }));
+
+    return events.join("");
+  }
+}
+
+/**
+ * Build a complete non-streaming response from JSONL output
+ * @param {string} jsonlOutput - Full JSONL output from Claude Code
+ * @param {object} requestBody - Original request body
+ * @returns {object} Anthropic Messages API response
+ */
+export function buildCompleteResponse(jsonlOutput, requestBody) {
+  const lines = jsonlOutput.split("\n").filter((l) => l.trim());
+  const content = [];
+  let usage = { input_tokens: 0, output_tokens: 0 };
+  let stopReason = "end_turn";
+
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+
+      if (parsed.type === "assistant" && parsed.message?.content) {
+        for (const block of parsed.message.content) {
+          if (block.type === "text") {
+            // Merge consecutive text blocks
+            const lastBlock = content[content.length - 1];
+            if (lastBlock && lastBlock.type === "text") {
+              lastBlock.text += block.text;
+            } else {
+              content.push({ type: "text", text: block.text });
+            }
+          } else if (block.type === "tool_use") {
+            content.push({
+              type: "tool_use",
+              id: block.id || `toolu_${generateId()}`,
+              name: block.name,
+              input: block.input || {},
+            });
+          }
+        }
+
+        if (parsed.message.usage) {
+          usage = parsed.message.usage;
+        }
+
+        if (parsed.message.stop_reason) {
+          stopReason = parsed.message.stop_reason;
+        }
+      }
+
+      // Handle result event
+      if (parsed.type === "result") {
+        if (parsed.usage) {
+          usage = parsed.usage;
+        }
+        if (parsed.stop_reason) {
+          stopReason = parsed.stop_reason;
+        }
+      }
+    } catch (e) {
+      // Skip malformed lines
+    }
+  }
+
+  return {
+    id: `msg_${generateId()}`,
+    type: "message",
+    role: "assistant",
+    content: content,
+    model: requestBody.model || "claude-sonnet-4-5-20250929",
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: usage,
+  };
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "opencode-claude-code-wrapper",
+  "version": "0.0.1",
+  "description": "OpenCode plugin that wraps Claude Code CLI for API-like access",
+  "main": "./index.mjs",
+  "type": "module",
+  "exports": {
+    ".": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "lib/"
+  ],
+  "keywords": [
+    "opencode",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "ai",
+    "plugin"
+  ],
+  "author": "Elad Ben Haim",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elad12390/opencode-claude-code-cli-wrapper"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^0.4.45"
+  }
+}