opencode-with-claude 1.0.0 → 1.1.1

package/README.md

@@ -7,11 +7,11 @@ Use [OpenCode](https://opencode.ai) with your [Claude Max](https://claude.ai) su
 ## How It Works
 
 ```
-┌─────────────┐       ┌────────────────────┐       ┌─────────────────┐
-│  OpenCode   │──────▶│  Claude Max Proxy  │──────▶│    Anthropic    │
-│  (TUI/Web)  │ :3456 │   (local server)   │  SDK  │    Claude Max   │
-│             │◀──────│                    │◀──────│                 │
-└─────────────┘       └────────────────────┘       └─────────────────┘
+┌─────────────┐              ┌────────────────────┐       ┌─────────────────┐
+│  OpenCode   │─────────────▶│  Claude Max Proxy  │──────▶│    Anthropic    │
+│  (TUI/Web)  │ :3456 / auto │   (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.
@@ -22,7 +22,7 @@ There are three ways to get started: the **plugin** (recommended), the **standal
 
 ### 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.
+The plugin manages the proxy lifecycle automatically — it starts the proxy when OpenCode launches, configures the Anthropic provider, and cleans up on exit. Each OpenCode instance gets its own proxy on an OS-assigned port, so multiple instances can run simultaneously without conflicts.
 
 **1. Authenticate with Claude (one-time)**
 
@@ -50,14 +50,14 @@ Global (`~/.config/opencode/opencode.json`) or project-level:
 }
 ```
 
+The `apiKey` is a dummy value — authentication goes through your Claude Max session, not an API key. The `baseURL` points to the default proxy port (3456). If that port is already in use (e.g. another opencode instance), the plugin automatically starts the proxy on a different port and overrides the `baseURL` at runtime.
+
 **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.
@@ -153,7 +153,7 @@ npm uninstall -g @anthropic-ai/claude-code opencode-ai opencode-claude-max-proxy
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `CLAUDE_PROXY_PORT` | `3456` (plugin/Docker) / random (`oc`) | Port for the proxy server |
+| `CLAUDE_PROXY_PORT` | `3456` | Preferred port for the proxy (falls back to a random port if in use) |
 | `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 |
@@ -177,14 +177,8 @@ This opens a browser for OAuth. Your Claude Max subscription credentials are nee
 ### "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
+2. Ensure your internet connection is working
+3. If using a manual port override, check if it's in use: `lsof -i :$CLAUDE_PROXY_PORT`
 
 ### Updating components
 
@@ -206,7 +200,9 @@ docker compose -f docker/docker-compose.yml build --no-cache && docker compose -
 ```
 opencode-with-claude/
 ├── src/
-│   └── index.ts           # Plugin entry point
+│   ├── index.ts           # Plugin entry point
+│   ├── proxy.ts           # Proxy lifecycle management
+│   └── logger.ts          # Plugin logger
 ├── bin/
 │   └── oc                 # Standalone launcher
 ├── docker/
@@ -239,7 +235,7 @@ npm run build
 
 **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.
+No. The proxy authenticates through your Claude Max subscription via `claude login`. The plugin automatically sets a dummy API key — it's never actually used for authentication.
 
 **What happens if my Claude Max subscription expires?**
 
@@ -251,7 +247,7 @@ The **plugin** is recommended if you already use OpenCode — it integrates with
 
 **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.
+Yes. The first instance uses port 3456 by default. Additional instances automatically fall back to a random OS-assigned port, so they all work simultaneously without any extra configuration.
 
 **Is this the same as using the Anthropic API?**
 

package/dist/index.d.ts

@@ -4,12 +4,9 @@ import type { Plugin } from "@opencode-ai/plugin";
  *
  * 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" } } }
+ *  2. Starts the proxy (port 3456, or falls back to a random port if in use)
+ *  3. Registers cleanup handlers to stop the proxy on exit
+ *  4. Returns a `config` hook that injects the proxy's baseURL into
+ *     the Anthropic provider so each opencode instance gets its own proxy.
  */
 export declare const ClaudeMaxPlugin: Plugin;

package/dist/index.js

@@ -1,73 +1,25 @@
-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`);
-}
+import { createLogger } from "./logger.js";
+import { registerCleanup, startProxy } from "./proxy.js";
 /**
  * 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" } } }
+ *  2. Starts the proxy (port 3456, or falls back to a random port if in use)
+ *  3. Registers cleanup handlers to stop the proxy on exit
+ *  4. Returns a `config` hook that injects the proxy's baseURL into
+ *     the Anthropic provider so each opencode instance gets its own proxy.
  */
 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
+    const log = createLogger(client);
+    // 1. Verify Claude CLI is installed
     try {
-        await $ `which claude`;
+        await $ `claude --version`;
     }
     catch {
         throw new Error("Claude Code CLI not found. Install it with: npm install -g @anthropic-ai/claude-code");
     }
-    // 2. Check authentication
+    // 2. Verify authentication
     let authOutput;
     try {
         authOutput = await $ `claude auth status`.text();
@@ -79,59 +31,22 @@ export const ClaudeMaxPlugin = async ({ client, $, directory }) => {
         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,
+    // 3. Start the proxy
+    const port = parseInt(process.env.CLAUDE_PROXY_PORT || "", 10) || undefined;
+    await log("info", "Starting Claude Max proxy...");
+    const proxy = await startProxy({ port, log });
+    const baseURL = `http://127.0.0.1:${proxy.port}`;
+    await log("info", `Claude Max proxy ready at ${baseURL}`);
+    // 4. Register cleanup handlers
+    registerCleanup(proxy);
+    // 5. Configure the Anthropic provider to route through the proxy
+    return {
+        async config(input) {
+            input.provider ??= {};
+            input.provider.anthropic ??= {};
+            input.provider.anthropic.options ??= {};
+            input.provider.anthropic.options.baseURL = baseURL;
+            input.provider.anthropic.options.apiKey = "claude-max-proxy";
         },
-        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/dist/logger.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogFn = (level: LogLevel, message: string) => Promise<unknown>;
+/**
+ * Create a logger bound to the plugin's client.
+ */
+export declare function createLogger(client: Parameters<Plugin>[0]["client"]): LogFn;

package/dist/logger.js

@@ -0,0 +1,8 @@
+/**
+ * Create a logger bound to the plugin's client.
+ */
+export function createLogger(client) {
+    return (level, message) => client.app.log({
+        body: { service: "opencode-with-claude", level, message },
+    });
+}

package/dist/proxy.d.ts

@@ -0,0 +1,29 @@
+import type { LogFn } from "./logger.js";
+export interface StartProxyOptions {
+    port?: number;
+    log: LogFn;
+}
+export interface ProxyHandle {
+    port: number;
+    close(): Promise<void>;
+}
+/**
+ * Start the Claude Max proxy using the programmatic API.
+ *
+ * Tries the preferred port first (default 3456). If that port is already
+ * in use, falls back to port 0 so the OS assigns a free port. This keeps
+ * the port predictable for single-instance users while allowing multiple
+ * opencode instances to coexist without conflicts.
+ *
+ * The upstream proxy unconditionally writes `[PROXY]` lines to
+ * console.error, so we patch it for the duration of the call and
+ * redirect those messages through the plugin logger instead.
+ */
+export declare function startProxy(opts: StartProxyOptions): Promise<ProxyHandle>;
+/**
+ * Register cross-platform cleanup handlers that stop the proxy on exit.
+ *
+ * - `exit` and `SIGINT` work on all platforms.
+ * - `SIGTERM` is only available on POSIX systems.
+ */
+export declare function registerCleanup(proxy: ProxyHandle): void;

package/dist/proxy.js

@@ -0,0 +1,91 @@
+import { startProxyServer } from "opencode-claude-max-proxy";
+const IS_WINDOWS = process.platform === "win32";
+const DEFAULT_PORT = 3456;
+/**
+ * Start the Claude Max proxy using the programmatic API.
+ *
+ * Tries the preferred port first (default 3456). If that port is already
+ * in use, falls back to port 0 so the OS assigns a free port. This keeps
+ * the port predictable for single-instance users while allowing multiple
+ * opencode instances to coexist without conflicts.
+ *
+ * The upstream proxy unconditionally writes `[PROXY]` lines to
+ * console.error, so we patch it for the duration of the call and
+ * redirect those messages through the plugin logger instead.
+ */
+export async function startProxy(opts) {
+    const { port = DEFAULT_PORT, log } = opts;
+    const origError = console.error;
+    console.error = (...args) => {
+        const msg = args.map(String).join(" ");
+        if (msg.startsWith("[PROXY]")) {
+            void log("debug", msg);
+            return;
+        }
+        origError.apply(console, args);
+    };
+    const attempt = async (p) => {
+        try {
+            return await startProxyServer({
+                port: p,
+                host: "127.0.0.1",
+                silent: true,
+            });
+        }
+        catch (err) {
+            if (p !== 0 &&
+                err instanceof Error &&
+                "code" in err &&
+                err.code === "EADDRINUSE") {
+                await log("info", `Port ${p} in use, starting on a random port instead...`);
+                return startProxyServer({
+                    port: 0,
+                    host: "127.0.0.1",
+                    silent: true,
+                });
+            }
+            throw err;
+        }
+    };
+    let proxy;
+    try {
+        proxy = await attempt(port);
+    }
+    catch (err) {
+        console.error = origError;
+        throw err;
+    }
+    const addr = proxy.server.address();
+    const actualPort = addr.port;
+    await log("info", `Claude Max proxy running on port ${actualPort}`);
+    return {
+        port: actualPort,
+        close: async () => {
+            console.error = origError;
+            await proxy.close();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Process cleanup
+// ---------------------------------------------------------------------------
+/**
+ * Register cross-platform cleanup handlers that stop the proxy on exit.
+ *
+ * - `exit` and `SIGINT` work on all platforms.
+ * - `SIGTERM` is only available on POSIX systems.
+ */
+export function registerCleanup(proxy) {
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        void proxy.close();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", cleanup);
+    if (!IS_WINDOWS) {
+        process.on("SIGTERM", cleanup);
+    }
+}

package/package.json

@@ -1,27 +1,20 @@
 {
   "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"
+  "version": "1.1.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ianjwhite99/opencode-with-claude.git"
   },
+  "main": "dist/index.js",
   "devDependencies": {
-    "@opencode-ai/plugin": "latest",
+    "@opencode-ai/plugin": "^1.3.0",
     "@types/node": "^25.5.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.9.3"
   },
+  "description": "OpenCode plugin to use your Claude Max subscription via local proxy",
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "opencode",
     "opencode-plugin",
@@ -30,8 +23,15 @@
     "proxy"
   ],
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ianjwhite99/opencode-with-claude.git"
+  "scripts": {
+    "build": "tsc",
+    "test": "./test/run.sh",
+    "test:clean": "./test/run.sh --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "opencode-claude-max-proxy": "^1.15.0"
   }
 }