opencode-claude-code-wrapper 0.0.1 → 0.0.2

package/index.mjs

@@ -1,18 +1,80 @@
+import { generatePKCE } from "@openauthjs/openauth/pkce";
 import {
   transformRequestToCLIArgs,
   spawnClaudeCode,
-  generateId,
 } from "./lib/cli-runner.mjs";
 import {
   JSONLToSSETransformer,
   buildCompleteResponse,
 } from "./lib/transformer.mjs";
 
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+/**
+ * @param {"max" | "console"} mode
+ */
+async function authorize(mode) {
+  const pkce = await generatePKCE();
+
+  const url = new URL(
+    `https://${mode === "console" ? "console.anthropic.com" : "claude.ai"}/oauth/authorize`,
+    import.meta.url
+  );
+  url.searchParams.set("code", "true");
+  url.searchParams.set("client_id", CLIENT_ID);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set(
+    "redirect_uri",
+    "https://console.anthropic.com/oauth/code/callback"
+  );
+  url.searchParams.set(
+    "scope",
+    "org:create_api_key user:profile user:inference"
+  );
+  url.searchParams.set("code_challenge", pkce.challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", pkce.verifier);
+  return {
+    url: url.toString(),
+    verifier: pkce.verifier,
+  };
+}
+
+/**
+ * @param {string} code
+ * @param {string} verifier
+ */
+async function exchange(code, verifier) {
+  const splits = code.split("#");
+  const result = await fetch("https://console.anthropic.com/v1/oauth/token", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      code: splits[0],
+      state: splits[1],
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      redirect_uri: "https://console.anthropic.com/oauth/code/callback",
+      code_verifier: verifier,
+    }),
+  });
+  if (!result.ok)
+    return {
+      type: "failed",
+    };
+  const json = await result.json();
+  return {
+    type: "success",
+    refresh: json.refresh_token,
+    access: json.access_token,
+    expires: Date.now() + json.expires_in * 1000,
+  };
+}
+
 /**
  * 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(
@@ -32,9 +94,6 @@ function createErrorResponse(error, statusCode = 500) {
 
 /**
  * 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);
@@ -59,12 +118,10 @@ function createStreamingResponse(child, requestBody) {
       });
 
       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) {
@@ -72,7 +129,6 @@ function createStreamingResponse(child, requestBody) {
           }
         }
 
-        // Send final events if not already sent
         if (!finalized) {
           finalized = true;
           const finalEvents = transformer.finalize();
@@ -105,12 +161,9 @@ function createStreamingResponse(child, requestBody) {
 
 /**
  * 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) => {
+  return new Promise((resolve) => {
     let stdout = "";
     let stderr = "";
 
@@ -158,13 +211,9 @@ async function createNonStreamingResponse(child, requestBody) {
 }
 
 /**
- * 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
+ * Handle request via Claude Code CLI
  */
 async function handleClaudeCodeRequest(input, init) {
-  // Parse the incoming request URL
   let requestUrl;
   try {
     if (typeof input === "string" || input instanceof URL) {
@@ -176,12 +225,10 @@ async function handleClaudeCodeRequest(input, init) {
     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 = "";
@@ -198,13 +245,8 @@ async function handleClaudeCodeRequest(input, init) {
     });
   }
 
-  // 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) {
@@ -215,7 +257,7 @@ async function handleClaudeCodeRequest(input, init) {
 }
 
 /**
- * OpenCode plugin that wraps Claude Code CLI
+ * OpenCode plugin that wraps Claude Code CLI with full auth options
  * @type {import('@opencode-ai/plugin').Plugin}
  */
 export async function ClaudeCodeWrapperPlugin({ client }) {
@@ -223,46 +265,272 @@ export async function ClaudeCodeWrapperPlugin({ client }) {
     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,
+        const auth = await getAuth();
+
+        // Claude Code CLI auth - zero cost, use CLI
+        if (auth.type === "claude-code") {
+          for (const model of Object.values(provider.models)) {
+            model.cost = {
+              input: 0,
+              output: 0,
+              cache: { read: 0, write: 0 },
+            };
+          }
+
+          return {
+            apiKey: "",
+            async fetch(input, init) {
+              try {
+                return await handleClaudeCodeRequest(input, init);
+              } catch (error) {
+                console.error("[claude-code-wrapper] error:", error);
+                return createErrorResponse(error);
+              }
             },
           };
         }
 
-        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);
-            }
-          },
-        };
+        // OAuth auth (Claude Pro/Max)
+        if (auth.type === "oauth") {
+          for (const model of Object.values(provider.models)) {
+            model.cost = {
+              input: 0,
+              output: 0,
+              cache: { read: 0, write: 0 },
+            };
+          }
+
+          return {
+            apiKey: "",
+            async fetch(input, init) {
+              const auth = await getAuth();
+              if (auth.type !== "oauth") return fetch(input, init);
+
+              // Refresh token if expired
+              if (!auth.access || auth.expires < Date.now()) {
+                const response = await fetch(
+                  "https://console.anthropic.com/v1/oauth/token",
+                  {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                      grant_type: "refresh_token",
+                      refresh_token: auth.refresh,
+                      client_id: CLIENT_ID,
+                    }),
+                  }
+                );
+                if (!response.ok) {
+                  throw new Error(`Token refresh failed: ${response.status}`);
+                }
+                const json = await response.json();
+                await client.auth.set({
+                  path: { id: "anthropic" },
+                  body: {
+                    type: "oauth",
+                    refresh: json.refresh_token,
+                    access: json.access_token,
+                    expires: Date.now() + json.expires_in * 1000,
+                  },
+                });
+                auth.access = json.access_token;
+              }
+
+              const requestInit = init ?? {};
+              const requestHeaders = new Headers();
+
+              if (input instanceof Request) {
+                input.headers.forEach((value, key) => {
+                  requestHeaders.set(key, value);
+                });
+              }
+              if (requestInit.headers) {
+                if (requestInit.headers instanceof Headers) {
+                  requestInit.headers.forEach((value, key) => {
+                    requestHeaders.set(key, value);
+                  });
+                } else if (Array.isArray(requestInit.headers)) {
+                  for (const [key, value] of requestInit.headers) {
+                    if (typeof value !== "undefined") {
+                      requestHeaders.set(key, String(value));
+                    }
+                  }
+                } else {
+                  for (const [key, value] of Object.entries(
+                    requestInit.headers
+                  )) {
+                    if (typeof value !== "undefined") {
+                      requestHeaders.set(key, String(value));
+                    }
+                  }
+                }
+              }
+
+              const incomingBeta = requestHeaders.get("anthropic-beta") || "";
+              const incomingBetasList = incomingBeta
+                .split(",")
+                .map((b) => b.trim())
+                .filter(Boolean);
+
+              const includeClaudeCode = incomingBetasList.includes(
+                "claude-code-20250219"
+              );
+
+              const mergedBetas = [
+                "oauth-2025-04-20",
+                "interleaved-thinking-2025-05-14",
+                ...(includeClaudeCode ? ["claude-code-20250219"] : []),
+              ].join(",");
+
+              requestHeaders.set("authorization", `Bearer ${auth.access}`);
+              requestHeaders.set("anthropic-beta", mergedBetas);
+              requestHeaders.set(
+                "user-agent",
+                "claude-cli/2.1.2 (external, cli)"
+              );
+              requestHeaders.delete("x-api-key");
+
+              const TOOL_PREFIX = "oc_";
+              let body = requestInit.body;
+              if (body && typeof body === "string") {
+                try {
+                  const parsed = JSON.parse(body);
+                  if (parsed.tools && Array.isArray(parsed.tools)) {
+                    parsed.tools = parsed.tools.map((tool) => ({
+                      ...tool,
+                      name: tool.name ? `${TOOL_PREFIX}${tool.name}` : tool.name,
+                    }));
+                    body = JSON.stringify(parsed);
+                  }
+                } catch (e) {
+                  // ignore parse errors
+                }
+              }
+
+              let requestInput = input;
+              let requestUrl = null;
+              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;
+              }
+
+              if (
+                requestUrl &&
+                requestUrl.pathname === "/v1/messages" &&
+                !requestUrl.searchParams.has("beta")
+              ) {
+                requestUrl.searchParams.set("beta", "true");
+                requestInput =
+                  input instanceof Request
+                    ? new Request(requestUrl.toString(), input)
+                    : requestUrl;
+              }
+
+              const response = await fetch(requestInput, {
+                ...requestInit,
+                body,
+                headers: requestHeaders,
+              });
+
+              // Transform streaming response to rename tools back
+              if (response.body) {
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                const encoder = new TextEncoder();
+
+                const stream = new ReadableStream({
+                  async pull(controller) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                      controller.close();
+                      return;
+                    }
+
+                    let text = decoder.decode(value, { stream: true });
+                    text = text.replace(
+                      /"name"\s*:\s*"oc_([^"]+)"/g,
+                      '"name": "$1"'
+                    );
+                    controller.enqueue(encoder.encode(text));
+                  },
+                });
+
+                return new Response(stream, {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                });
+              }
+
+              return response;
+            },
+          };
+        }
+
+        // Default - no special handling
+        return {};
       },
       methods: [
         {
           label: "Claude Code CLI",
+          type: "claude-code",
+        },
+        {
+          label: "Claude Pro/Max",
+          type: "oauth",
+          authorize: async () => {
+            const { url, verifier } = await authorize("max");
+            return {
+              url: url,
+              instructions: "Paste the authorization code here: ",
+              method: "code",
+              callback: async (code) => {
+                const credentials = await exchange(code, verifier);
+                return credentials;
+              },
+            };
+          },
+        },
+        {
+          label: "Create an API Key",
+          type: "oauth",
+          authorize: async () => {
+            const { url, verifier } = await authorize("console");
+            return {
+              url: url,
+              instructions: "Paste the authorization code here: ",
+              method: "code",
+              callback: async (code) => {
+                const credentials = await exchange(code, verifier);
+                if (credentials.type === "failed") return credentials;
+                const result = await fetch(
+                  `https://api.anthropic.com/api/oauth/claude_cli/create_api_key`,
+                  {
+                    method: "POST",
+                    headers: {
+                      "Content-Type": "application/json",
+                      authorization: `Bearer ${credentials.access}`,
+                    },
+                  }
+                ).then((r) => r.json());
+                return { type: "success", key: result.raw_key };
+              },
+            };
+          },
+        },
+        {
+          provider: "anthropic",
+          label: "Manually enter API Key",
           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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-code-wrapper",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "OpenCode plugin that wraps Claude Code CLI for API-like access",
   "main": "./index.mjs",
   "type": "module",
@@ -25,6 +25,9 @@
     "type": "git",
     "url": "https://github.com/elad12390/opencode-claude-code-cli-wrapper"
   },
+  "dependencies": {
+    "@openauthjs/openauth": "^0.4.3"
+  },
   "devDependencies": {
     "@opencode-ai/plugin": "^0.4.45"
   }