opencode-with-claude 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ian White
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,280 @@
+# opencode-with-claude
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Use [OpenCode](https://opencode.ai) with your [Claude Max](https://claude.ai) subscription.
+
+## How It Works
+
+```
+┌─────────────┐       ┌────────────────────┐       ┌─────────────────┐
+│  OpenCode   │──────▶│  Claude Max Proxy  │──────▶│    Anthropic    │
+│  (TUI/Web)  │ :3456 │   (local server)   │  SDK  │    Claude Max   │
+│             │◀──────│                    │◀──────│                 │
+└─────────────┘       └────────────────────┘       └─────────────────┘
+```
+
+[OpenCode](https://opencode.ai) speaks the Anthropic REST API. Claude Max provides access via the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) (not the REST API). The [opencode-claude-max-proxy](https://github.com/rynfar/opencode-claude-max-proxy) bridges the gap — it accepts API requests from OpenCode and translates them into Agent SDK calls using your Claude Max session.
+
+## Quick Start
+
+There are three ways to get started: the **plugin** (recommended), the **standalone installer**, or **Docker**.
+
+### Option A: OpenCode Plugin (recommended)
+
+The plugin manages the proxy lifecycle automatically — it starts the proxy when OpenCode launches, health-checks it, and cleans up on exit.
+
+**1. Authenticate with Claude (one-time)**
+
+```bash
+npm install -g @anthropic-ai/claude-code
+claude login
+```
+
+**2. Add to your `opencode.json`**
+
+Global (`~/.config/opencode/opencode.json`) or project-level:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-with-claude"],
+  "provider": {
+    "anthropic": {
+      "options": {
+        "baseURL": "http://127.0.0.1:3456",
+        "apiKey": "dummy"
+      }
+    }
+  }
+}
+```
+
+**3. Run OpenCode**
+
+```bash
+opencode
+```
+
+That's it. The plugin handles everything.
+
+### Option B: Standalone Installer (`oc` launcher)
+
+A one-liner that installs all dependencies and gives you the `oc` command — no config files to edit.
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/ianjwhite99/opencode-with-claude/main/install.sh | bash
+```
+
+This installs:
+- [Claude Code CLI](https://www.npmjs.com/package/@anthropic-ai/claude-code) — authentication with Claude
+- [OpenCode](https://www.npmjs.com/package/opencode-ai) — the coding assistant
+- [opencode-claude-max-proxy](https://www.npmjs.com/package/opencode-claude-max-proxy) — bridges OpenCode to Claude Max
+- **`oc`** — launcher that ties it all together
+
+Then run:
+
+```bash
+cd your-project
+oc
+```
+
+The `oc` command starts the proxy in the background, waits for it to be ready, and launches OpenCode.
+
+### Option C: Docker
+
+Run everything in a container with the OpenCode web UI exposed on port 4096.
+
+```bash
+git clone https://github.com/ianjwhite99/opencode-with-claude.git
+cd opencode-with-claude
+
+# Build and start
+docker compose -f docker/docker-compose.yml up -d
+
+# Authenticate (first time only)
+docker exec -it -u opencode opencode-with-claude claude login
+
+# Open the web UI
+open http://localhost:4096
+```
+
+The container runs the proxy and OpenCode web UI together. Your `~/workspace` directory is mounted into the container, and Claude auth, OpenCode data, and config are persisted across restarts via Docker volumes.
+
+## Prerequisites
+
+- **Node.js >= 18** — [nodejs.org](https://nodejs.org) (or Bun/Deno) — not needed for Docker
+- **Claude Max subscription** — the $100/mo plan on [claude.ai](https://claude.ai)
+
+## `oc` Launcher Reference
+
+The `oc` launcher handles everything — starts the proxy, waits for health, launches OpenCode, and cleans up on exit:
+
+```bash
+oc              # Start OpenCode TUI in current directory
+oc web          # Start OpenCode web UI on port 4096
+oc update       # Update all components to latest versions
+oc --help       # Show help
+oc --version    # Show component versions
+```
+
+All arguments are passed through to `opencode`, so anything that works with `opencode` works with `oc`.
+
+### Installer Options
+
+```bash
+# Skip the Claude login prompt
+curl -fsSL ... | bash -s -- --no-auth
+
+# Don't modify shell PATH
+curl -fsSL ... | bash -s -- --no-modify-path
+
+# Show help
+curl -fsSL ... | bash -s -- --help
+```
+
+### Uninstalling
+
+Remove the `oc` launcher and clean up PATH entries:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/ianjwhite99/opencode-with-claude/main/install.sh | bash -s -- --uninstall
+```
+
+This removes the `oc` launcher from `~/.opencode/bin` and cleans up any PATH entries added to your shell config. To also remove the underlying tools:
+
+```bash
+npm uninstall -g @anthropic-ai/claude-code opencode-ai opencode-claude-max-proxy
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CLAUDE_PROXY_PORT` | `3456` (plugin/Docker) / random (`oc`) | Port for the proxy server |
+| `CLAUDE_PROXY_WORKDIR` | `$PWD` | Working directory for the proxy |
+| `OC_SKIP_AUTH_CHECK` | unset | Set to `1` to skip Claude auth check on `oc` launch |
+| `OC_AUTO_UPDATE` | unset | Set to `true` or `1` to auto-update components on Docker container start |
+
+## Troubleshooting
+
+### "Claude Code CLI not found"
+
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+### "Claude not authenticated"
+
+```bash
+claude login
+```
+
+This opens a browser for OAuth. Your Claude Max subscription credentials are needed.
+
+### "Proxy failed to start"
+
+1. Check Claude auth: `claude auth status`
+2. Check if the port is in use: `lsof -i :3456`
+3. Try a different port: set `CLAUDE_PROXY_PORT=4567` and update `baseURL` in `opencode.json` to match
+
+### "Proxy didn't become healthy within 10 seconds"
+
+The proxy takes a moment to initialize. If this persists:
+- Ensure `claude auth status` shows `loggedIn: true`
+- Check your internet connection
+
+### Updating components
+
+```bash
+# oc launcher
+oc update
+
+# Plugin / manual
+npm install -g @anthropic-ai/claude-code opencode-ai opencode-claude-max-proxy
+
+# Docker
+docker compose -f docker/docker-compose.yml build --no-cache && docker compose -f docker/docker-compose.yml up -d
+```
+
+## Development
+
+### Project Structure
+
+```
+opencode-with-claude/
+├── src/
+│   └── index.ts           # Plugin entry point
+├── bin/
+│   └── oc                 # Standalone launcher
+├── docker/
+│   ├── Dockerfile         # All-in-one Docker image
+│   ├── docker-compose.yml # Docker Compose config
+│   └── entrypoint.sh      # Docker entrypoint
+├── install.sh             # curl | bash installer
+├── test/
+│   ├── run.sh             # Test runner
+│   └── opencode.json      # Test config
+├── package.json
+└── tsconfig.json
+```
+
+### Build
+
+```bash
+npm install
+npm run build
+```
+
+### Test locally
+
+```bash
+./test/run.sh              # Build and launch OpenCode with the plugin
+./test/run.sh --clean      # Remove build artifacts
+```
+
+## FAQ
+
+**Do I need an Anthropic API key?**
+
+No. The proxy authenticates through your Claude Max subscription via `claude login`. The `ANTHROPIC_API_KEY=dummy` value is just a placeholder that OpenCode requires — it's never actually used.
+
+**What happens if my Claude Max subscription expires?**
+
+The proxy will fail to authenticate. Run `claude auth status` to check. You'll need an active Claude Max ($100/mo) or Claude Max with Team ($200/mo) subscription.
+
+**Plugin, `oc`, or Docker — which should I use?**
+
+The **plugin** is recommended if you already use OpenCode — it integrates with OpenCode's plugin system and requires no extra commands. Use the **`oc` launcher** if you want a one-command install from scratch or prefer not to edit config files. Use **Docker** if you want an isolated environment or want to run the web UI as a service.
+
+**Can I use this with multiple projects at the same time?**
+
+Yes. The `oc` launcher assigns a random port for each terminal session. The plugin uses a fixed port (`3456` by default), so configure `CLAUDE_PROXY_PORT` if running multiple instances.
+
+**Is this the same as using the Anthropic API?**
+
+Not exactly. The proxy translates between the Anthropic REST API format and the Claude Agent SDK. From OpenCode's perspective it looks like the API, but under the hood it uses your Claude Max session. Rate limits are determined by your Claude Max subscription, not API tier limits.
+
+**Why `claude login` instead of an API key?**
+
+Claude Max doesn't provide API access. Authentication goes through the Claude Code CLI's OAuth flow, which grants an Agent SDK session token tied to your subscription.
+
+## Disclaimer
+
+This project is an **unofficial wrapper** around Anthropic's publicly available Claude Agent SDK and OpenCode. It is not affiliated with, endorsed by, or supported by Anthropic or OpenCode.
+
+**Use at your own risk.** The authors make no claims regarding compliance with Anthropic's Terms of Service. It is your responsibility to review and comply with Anthropic's [Terms of Service](https://www.anthropic.com/terms) and [Authorized Usage Policy](https://www.anthropic.com/aup). Terms may change at any time.
+
+This project calls publicly available npm packages using your own authenticated account. No API keys are intercepted, no authentication is bypassed, and no proprietary systems are reverse-engineered.
+
+## Credits
+
+Built on top of [opencode-claude-max-proxy](https://github.com/rynfar/opencode-claude-max-proxy) by [@rynfar](https://github.com/rynfar), which provides the core proxy that bridges the Anthropic Agent SDK to the standard API.
+
+Powered by the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) by Anthropic and [OpenCode](https://opencode.ai).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode plugin that manages the Claude Max proxy lifecycle.
+ *
+ * On init:
+ *  1. Verifies the Claude CLI is installed and authenticated
+ *  2. Resolves the bundled claude-max-proxy binary
+ *  3. Spawns the proxy on a local port
+ *  4. Waits for the proxy to become healthy
+ *  5. Registers cleanup handlers to kill the proxy on exit
+ *
+ * Requires provider config in opencode.json to route API traffic through the proxy:
+ *   "provider": { "anthropic": { "options": { "baseURL": "http://127.0.0.1:3456", "apiKey": "dummy" } } }
+ */
+export declare const ClaudeMaxPlugin: Plugin;

package/dist/index.js

@@ -0,0 +1,137 @@
+import { spawn } from "child_process";
+import { createRequire } from "module";
+const DEFAULT_PORT = 3456;
+const HEALTH_TIMEOUT_MS = 10_000;
+const HEALTH_INTERVAL_MS = 100;
+/**
+ * Resolve the claude-max-proxy binary from this package's bundled dependency.
+ */
+function resolveProxyBin() {
+    const require = createRequire(import.meta.url);
+    const proxyPkgPath = require.resolve("opencode-claude-max-proxy/package.json");
+    const proxyDir = proxyPkgPath.replace(/\/package\.json$/, "");
+    const proxyPkg = require(proxyPkgPath);
+    const binEntries = proxyPkg.bin;
+    if (!binEntries || typeof binEntries !== "object") {
+        throw new Error("Could not find claude-max-proxy binary in opencode-claude-max-proxy package");
+    }
+    const binPath = Object.values(binEntries)[0];
+    if (!binPath) {
+        throw new Error("claude-max-proxy package has no bin entry");
+    }
+    return `${proxyDir}/${binPath}`;
+}
+/**
+ * Poll the proxy health endpoint until it responds OK or timeout.
+ */
+async function waitForHealth(port, timeoutMs, proxy) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        // Check if proxy process died
+        if (proxy.exitCode !== null) {
+            throw new Error("Claude Max proxy process exited unexpectedly. Is Claude authenticated? Run: claude login");
+        }
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/health`);
+            if (res.ok)
+                return;
+        }
+        catch {
+            // Not ready yet
+        }
+        await new Promise((r) => setTimeout(r, HEALTH_INTERVAL_MS));
+    }
+    throw new Error(`Claude Max proxy didn't become healthy within ${timeoutMs / 1000}s. Check: claude auth status`);
+}
+/**
+ * OpenCode plugin that manages the Claude Max proxy lifecycle.
+ *
+ * On init:
+ *  1. Verifies the Claude CLI is installed and authenticated
+ *  2. Resolves the bundled claude-max-proxy binary
+ *  3. Spawns the proxy on a local port
+ *  4. Waits for the proxy to become healthy
+ *  5. Registers cleanup handlers to kill the proxy on exit
+ *
+ * Requires provider config in opencode.json to route API traffic through the proxy:
+ *   "provider": { "anthropic": { "options": { "baseURL": "http://127.0.0.1:3456", "apiKey": "dummy" } } }
+ */
+export const ClaudeMaxPlugin = async ({ client, $, directory }) => {
+    const log = (level, message) => client.app.log({
+        body: { service: "opencode-with-claude", level, message },
+    });
+    // 1. Check claude CLI exists
+    try {
+        await $ `which claude`;
+    }
+    catch {
+        throw new Error("Claude Code CLI not found. Install it with: npm install -g @anthropic-ai/claude-code");
+    }
+    // 2. Check authentication
+    let authOutput;
+    try {
+        authOutput = await $ `claude auth status`.text();
+    }
+    catch {
+        throw new Error("Failed to check Claude auth status. Run: claude login");
+    }
+    if (!authOutput.includes('"loggedIn": true')) {
+        throw new Error("Claude not authenticated. Run: claude login");
+    }
+    await log("info", "Claude authentication verified");
+    // 3. Resolve proxy binary (bundled dependency)
+    let proxyBin;
+    try {
+        proxyBin = resolveProxyBin();
+    }
+    catch (err) {
+        throw new Error(`Failed to resolve claude-max-proxy binary: ${err instanceof Error ? err.message : err}`);
+    }
+    // 4. Pick port
+    const port = parseInt(process.env.CLAUDE_PROXY_PORT || "", 10) || DEFAULT_PORT;
+    // 5. Spawn proxy
+    await log("info", `Starting Claude Max proxy on port ${port}...`);
+    const proxy = spawn(proxyBin, [], {
+        env: {
+            ...process.env,
+            CLAUDE_PROXY_PORT: String(port),
+            CLAUDE_PROXY_PASSTHROUGH: "1",
+            CLAUDE_PROXY_WORKDIR: directory,
+        },
+        stdio: "ignore",
+        detached: false,
+    });
+    proxy.on("error", (err) => {
+        log("error", `Proxy process error: ${err.message}`);
+    });
+    // 6. Wait for health
+    try {
+        await waitForHealth(port, HEALTH_TIMEOUT_MS, proxy);
+    }
+    catch (err) {
+        // Kill the proxy if health check fails
+        try {
+            proxy.kill();
+        }
+        catch { }
+        throw err;
+    }
+    await log("info", `Claude Max proxy ready on port ${port}`);
+    // 7. Cleanup on exit
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        try {
+            proxy.kill();
+        }
+        catch { }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    // No hooks needed -- proxy runs as a sidecar process.
+    // Provider config in opencode.json routes API traffic through the proxy.
+    return {};
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "opencode-with-claude",
+  "version": "1.0.0",
+  "description": "OpenCode plugin to use your Claude Max subscription via local proxy",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "./test/run.sh",
+    "test:clean": "./test/run.sh --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "opencode-claude-max-proxy": "latest"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/node": "^25.5.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "claude",
+    "claude-max",
+    "proxy"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ianjwhite99/opencode-with-claude.git"
+  }
+}