opencode-claude-max-proxy 1.0.0

package/README.md

@@ -0,0 +1,205 @@
+# opencode-claude-max-proxy
+
+[![npm version](https://img.shields.io/npm/v/opencode-claude-max-proxy.svg)](https://www.npmjs.com/package/opencode-claude-max-proxy)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub stars](https://img.shields.io/github/stars/rynfar/opencode-claude-max-proxy.svg)](https://github.com/rynfar/opencode-claude-max-proxy/stargazers)
+
+Use your **Claude Max subscription** with OpenCode.
+
+## The Problem
+
+Anthropic doesn't allow Claude Max subscribers to use their subscription with third-party tools like OpenCode. If you want to use Claude in OpenCode, you have to pay for API access separately - even though you're already paying for "unlimited" Claude.
+
+Your options are:
+1. Use Claude's official apps only (limited to their UI)
+2. Pay again for API access on top of your Max subscription
+3. **Use this proxy**
+
+## The Solution
+
+This proxy bridges the gap using Anthropic's own tools:
+
+```
+OpenCode → Proxy (localhost:3456) → Claude Agent SDK → Your Claude Max Subscription
+```
+
+The [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) is Anthropic's **official npm package** that lets developers build with Claude using their Max subscription. This proxy simply translates OpenCode's API requests into SDK calls.
+
+**Your Max subscription. Anthropic's official SDK. Zero additional cost.**
+
+## Is This Allowed?
+
+**Yes.** Here's why:
+
+| Concern | Reality |
+|---------|---------|
+| "Bypassing restrictions" | No. We use Anthropic's public SDK exactly as documented |
+| "Violating TOS" | No. The SDK is designed for programmatic Claude access |
+| "Unauthorized access" | No. You authenticate with `claude login` using your own account |
+| "Reverse engineering" | No. We call `query()` from their npm package, that's it |
+
+The Claude Agent SDK exists specifically to let Max subscribers use Claude programmatically. We're just translating the request format so OpenCode can use it.
+
+**~200 lines of TypeScript. No hacks. No magic. Just format translation.**
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Zero API costs** | Uses your Claude Max subscription, not per-token billing |
+| **Full compatibility** | Works with any Anthropic model in OpenCode |
+| **Streaming support** | Real-time SSE streaming just like the real API |
+| **Auto-start** | Optional launchd service for macOS |
+| **Simple setup** | Two commands to get running |
+
+## Prerequisites
+
+1. **Claude Max subscription** - [Subscribe here](https://claude.ai/settings/subscription)
+
+2. **Claude CLI** installed and authenticated:
+   ```bash
+   npm install -g @anthropic-ai/claude-code
+   claude login
+   ```
+
+3. **Bun** runtime:
+   ```bash
+   curl -fsSL https://bun.sh/install | bash
+   ```
+
+## Installation
+
+```bash
+git clone https://github.com/rynfar/opencode-claude-max-proxy
+cd opencode-claude-max-proxy
+bun install
+```
+
+## Usage
+
+### Start the Proxy
+
+```bash
+bun run proxy
+```
+
+### Run OpenCode
+
+```bash
+ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode
+```
+
+Select any `anthropic/claude-*` model (opus, sonnet, haiku).
+
+### One-liner
+
+```bash
+bun run proxy & ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode
+```
+
+## Auto-start on macOS
+
+Set up the proxy to run automatically on login:
+
+```bash
+cat > ~/Library/LaunchAgents/com.claude-max-proxy.plist << EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.claude-max-proxy</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>$(which bun)</string>
+        <string>run</string>
+        <string>proxy</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>$(pwd)</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+</dict>
+</plist>
+EOF
+
+launchctl load ~/Library/LaunchAgents/com.claude-max-proxy.plist
+```
+
+Then add an alias to `~/.zshrc`:
+
+```bash
+echo "alias oc='ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode'" >> ~/.zshrc
+source ~/.zshrc
+```
+
+Now just run `oc` to start OpenCode with Claude Max.
+
+## Model Mapping
+
+| OpenCode Model | Claude SDK |
+|----------------|------------|
+| `anthropic/claude-opus-*` | opus |
+| `anthropic/claude-sonnet-*` | sonnet |
+| `anthropic/claude-haiku-*` | haiku |
+
+## Configuration
+
+| Environment Variable | Default | Description |
+|---------------------|---------|-------------|
+| `CLAUDE_PROXY_PORT` | 3456 | Proxy server port |
+| `CLAUDE_PROXY_HOST` | 127.0.0.1 | Proxy server host |
+
+## How It Works
+
+1. **OpenCode** sends a request to `http://127.0.0.1:3456/messages` (thinking it's the Anthropic API)
+2. **Proxy** receives the request and extracts the messages
+3. **Proxy** calls `query()` from the Claude Agent SDK with your prompt
+4. **Claude Agent SDK** authenticates using your Claude CLI login (tied to your Max subscription)
+5. **Claude** processes the request using your subscription
+6. **Proxy** streams the response back in Anthropic SSE format
+7. **OpenCode** receives the response as if it came from the real API
+
+The proxy is ~200 lines of TypeScript. No magic, no hacks.
+
+## FAQ
+
+### Why do I need `ANTHROPIC_API_KEY=dummy`?
+
+OpenCode requires an API key to be set, but we never actually use it. The Claude Agent SDK handles authentication through your Claude CLI login. Any non-empty string works.
+
+### Does this work with other tools besides OpenCode?
+
+Yes! Any tool that uses the Anthropic API format can use this proxy. Just point `ANTHROPIC_BASE_URL` to `http://127.0.0.1:3456`.
+
+### What about rate limits?
+
+Your Claude Max subscription has its own usage limits. This proxy doesn't add any additional limits.
+
+### Is my data sent anywhere else?
+
+No. The proxy runs locally on your machine. Your requests go directly to Claude through the official SDK.
+
+## Troubleshooting
+
+### "Authentication failed"
+
+Run `claude login` to authenticate with the Claude CLI.
+
+### "Connection refused"
+
+Make sure the proxy is running: `bun run proxy`
+
+### Proxy keeps dying
+
+Use the launchd service (see Auto-start section) which automatically restarts the proxy.
+
+## License
+
+MIT
+
+## Credits
+
+Built with the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) by Anthropic.

package/bin/claude-proxy.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+
+import { startProxyServer } from "../src/proxy/server"
+
+const port = parseInt(process.env.CLAUDE_PROXY_PORT || "3456", 10)
+const host = process.env.CLAUDE_PROXY_HOST || "127.0.0.1"
+
+await startProxyServer({ port, host })

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "opencode-claude-max-proxy",
+  "version": "1.0.0",
+  "description": "Use your Claude Max subscription with OpenCode via proxy server",
+  "type": "module",
+  "main": "./src/proxy/server.ts",
+  "bin": {
+    "claude-max-proxy": "./bin/claude-proxy.ts"
+  },
+  "exports": {
+    ".": "./src/proxy/server.ts"
+  },
+  "scripts": {
+    "start": "bun run ./bin/claude-proxy.ts",
+    "proxy": "bun run ./bin/claude-proxy.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.0",
+    "hono": "^4.11.4"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.21",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.2"
+  },
+  "files": [
+    "bin/",
+    "src/proxy/",
+    "src/logger.ts",
+    "README.md"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-ai",
+    "opencode-plugin",
+    "claude",
+    "claude-max",
+    "claude-code",
+    "anthropic",
+    "ai-coding",
+    "ai-assistant",
+    "proxy",
+    "claude-agent-sdk",
+    "llm",
+    "coding-assistant"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rynfar/opencode-claude-max-proxy.git"
+  },
+  "homepage": "https://github.com/rynfar/opencode-claude-max-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/rynfar/opencode-claude-max-proxy/issues"
+  },
+  "author": "rynfar",
+  "license": "MIT",
+  "private": false
+}

package/src/logger.ts

@@ -0,0 +1,10 @@
+const shouldLog = () => process.env["OPENCODE_CLAUDE_PROVIDER_DEBUG"]
+
+export const claudeLog = (message: string, extra?: Record<string, unknown>) => {
+  if (!shouldLog()) return
+  const parts = ["[opencode-claude-code-provider]", message]
+  if (extra && Object.keys(extra).length > 0) {
+    parts.push(JSON.stringify(extra))
+  }
+  console.debug(parts.join(" "))
+}

package/src/proxy/server.ts

@@ -0,0 +1,193 @@
+import { Hono } from "hono"
+import { cors } from "hono/cors"
+import { query } from "@anthropic-ai/claude-agent-sdk"
+import type { Context } from "hono"
+import type { ProxyConfig } from "./types"
+import { DEFAULT_PROXY_CONFIG } from "./types"
+import { claudeLog } from "../logger"
+
+function mapModelToClaudeModel(model: string): "sonnet" | "opus" | "haiku" {
+  if (model.includes("opus")) return "opus"
+  if (model.includes("haiku")) return "haiku"
+  return "sonnet"
+}
+
+export function createProxyServer(config: Partial<ProxyConfig> = {}) {
+  const finalConfig = { ...DEFAULT_PROXY_CONFIG, ...config }
+  const app = new Hono()
+
+  app.use("*", cors())
+
+  app.get("/", (c) => {
+    return c.json({
+      status: "ok",
+      service: "claude-max-proxy",
+      version: "1.0.0",
+      format: "anthropic",
+      endpoints: ["/v1/messages", "/messages"]
+    })
+  })
+
+  const handleMessages = async (c: Context) => {
+    try {
+      const body = await c.req.json()
+      const model = mapModelToClaudeModel(body.model || "sonnet")
+      const stream = body.stream ?? true
+
+      claudeLog("proxy.anthropic.request", { model, stream, messageCount: body.messages?.length })
+
+      const prompt = body.messages
+        ?.map((m: { role: string; content: string | Array<{ type: string; text?: string }> }) => {
+          const role = m.role === "assistant" ? "Assistant" : "Human"
+          let content: string
+          if (typeof m.content === "string") {
+            content = m.content
+          } else if (Array.isArray(m.content)) {
+            content = m.content
+              .filter((block) => block.type === "text" && block.text)
+              .map((block) => block.text)
+              .join("")
+          } else {
+            content = String(m.content)
+          }
+          return `${role}: ${content}`
+        })
+        .join("\n\n") || ""
+
+      if (!stream) {
+        let fullContent = ""
+        const response = query({
+          prompt,
+          options: { maxTurns: 1, model }
+        })
+
+        for await (const message of response) {
+          if (message.type === "assistant") {
+            for (const block of message.message.content) {
+              if (block.type === "text") {
+                fullContent += block.text
+              }
+            }
+          }
+        }
+
+        return c.json({
+          id: `msg_${Date.now()}`,
+          type: "message",
+          role: "assistant",
+          content: [{ type: "text", text: fullContent }],
+          model: body.model,
+          stop_reason: "end_turn",
+          usage: { input_tokens: 0, output_tokens: 0 }
+        })
+      }
+
+      const encoder = new TextEncoder()
+      const readable = new ReadableStream({
+        async start(controller) {
+          try {
+            controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify({
+              type: "message_start",
+              message: {
+                id: `msg_${Date.now()}`,
+                type: "message",
+                role: "assistant",
+                content: [],
+                model: body.model,
+                stop_reason: null,
+                usage: { input_tokens: 0, output_tokens: 0 }
+              }
+            })}\n\n`))
+
+            controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify({
+              type: "content_block_start",
+              index: 0,
+              content_block: { type: "text", text: "" }
+            })}\n\n`))
+
+            const response = query({
+              prompt,
+              options: { maxTurns: 1, model }
+            })
+
+            for await (const message of response) {
+              if (message.type === "assistant") {
+                for (const block of message.message.content) {
+                  if (block.type === "text") {
+                    controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify({
+                      type: "content_block_delta",
+                      index: 0,
+                      delta: { type: "text_delta", text: block.text }
+                    })}\n\n`))
+                  }
+                }
+              }
+            }
+
+            controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify({
+              type: "content_block_stop",
+              index: 0
+            })}\n\n`))
+
+            controller.enqueue(encoder.encode(`event: message_delta\ndata: ${JSON.stringify({
+              type: "message_delta",
+              delta: { stop_reason: "end_turn" },
+              usage: { output_tokens: 0 }
+            })}\n\n`))
+
+            controller.enqueue(encoder.encode(`event: message_stop\ndata: ${JSON.stringify({
+              type: "message_stop"
+            })}\n\n`))
+
+            controller.close()
+          } catch (error) {
+            claudeLog("proxy.anthropic.error", { error: error instanceof Error ? error.message : String(error) })
+            controller.enqueue(encoder.encode(`event: error\ndata: ${JSON.stringify({
+              type: "error",
+              error: { type: "api_error", message: error instanceof Error ? error.message : "Unknown error" }
+            })}\n\n`))
+            controller.close()
+          }
+        }
+      })
+
+      return new Response(readable, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      })
+    } catch (error) {
+      claudeLog("proxy.error", { error: error instanceof Error ? error.message : String(error) })
+      return c.json({
+        type: "error",
+        error: {
+          type: "api_error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }
+      }, 500)
+    }
+  }
+
+  app.post("/v1/messages", handleMessages)
+  app.post("/messages", handleMessages)
+
+  return { app, config: finalConfig }
+}
+
+export async function startProxyServer(config: Partial<ProxyConfig> = {}) {
+  const { app, config: finalConfig } = createProxyServer(config)
+
+  const server = Bun.serve({
+    port: finalConfig.port,
+    hostname: finalConfig.host,
+    fetch: app.fetch
+  })
+
+  console.log(`Claude Max Proxy (Anthropic API) running at http://${finalConfig.host}:${finalConfig.port}`)
+  console.log(`\nTo use with OpenCode, run:`)
+  console.log(`  ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://${finalConfig.host}:${finalConfig.port} opencode`)
+
+  return server
+}

package/src/proxy/types.ts

@@ -0,0 +1,11 @@
+export interface ProxyConfig {
+  port: number
+  host: string
+  debug: boolean
+}
+
+export const DEFAULT_PROXY_CONFIG: ProxyConfig = {
+  port: 3456,
+  host: "127.0.0.1",
+  debug: process.env.CLAUDE_PROXY_DEBUG === "1"
+}