opencode-claude-max-proxy 1.0.2 → 1.8.0

package/README.md

@@ -4,199 +4,358 @@
 [![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](https://github.com/opencode-ai/opencode). Built to work with [Oh-My-OpenCode](https://github.com/code-yeongyu/oh-my-opencode) and its full agent orchestration system.
+A transparent proxy that lets you use your **Claude Max subscription** with [OpenCode](https://opencode.ai) — with full multi-model agent delegation.
 
-![OpenCode with Claude Max](screenshot.png)
+## The Idea
 
-## The Problem
+OpenCode speaks the Anthropic API. Claude Max gives you unlimited Claude through the [Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). This proxy bridges the two — but the interesting part isn't the bridging, it's **how tool execution and agent delegation work**.
 
-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.
+Most proxy approaches try to handle everything internally: the SDK runs tools, manages subagents, and streams back a finished result. The problem? The SDK only knows about Claude models. If you're using [oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode) with agents routed to GPT-5.4, Gemini, or other providers, the SDK can't reach them. Your carefully configured multi-model agent setup gets flattened to "everything runs on 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**
+This proxy takes a different approach: **passthrough delegation**. Instead of handling tools internally, the proxy intercepts every tool call *before the SDK executes it*, stops the turn, and forwards the raw `tool_use` back to OpenCode. OpenCode handles execution — including routing `Task` calls through its own agent system with full model routing. The result comes back as a standard `tool_result`, the proxy resumes the SDK session, and Claude continues.
 
-## The Solution
-
-This proxy bridges the gap using Anthropic's own tools:
+The effect: Claude thinks it's calling tools normally. OpenCode thinks it's talking to the Anthropic API. But behind the scenes, your oracle agent runs on GPT-5.4, your explore agent runs on Gemini, and the main session runs on Claude Max — exactly as configured.
 
 ```
-OpenCode → Proxy (localhost:3456) → Claude Agent SDK → Your Claude Max Subscription
+┌──────────┐                ┌───────────────┐              ┌──────────────┐
+│          │  1. Request    │               │   SDK Auth   │              │
+│ OpenCode │ ─────────────► │    Proxy      │ ───────────► │  Claude Max  │
+│          │                │  (localhost)  │              │              │
+│          │  4. tool_use   │               │  2. Generate │              │
+│          │ ◄───────────── │  PreToolUse   │ ◄─────────── │  Response    │
+│          │                │  hook blocks  │              │              │
+│          │  5. Execute    │               │              └──────────────┘
+│          │  ─── Task ───► │               │
+│          │  (routes to    │               │              ┌──────────────┐
+│          │   GPT-5.4,     │  6. Resume    │              │  oh-my-      │
+│          │   Gemini,etc)  │ ◄──────────── │              │  opencode    │
+│          │                │  tool_result  │              │  agents      │
+│          │  7. Final      │               │              │              │
+│          │ ◄───────────── │               │              │  oracle:     │
+│          │  response      │               │              │   GPT-5.4    │
+└──────────┘                └───────────────┘              │  explore:    │
+                                                          │   Gemini     │
+                                                          │  librarian:  │
+                                                          │   Sonnet     │
+                                                          └──────────────┘
 ```
 
-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:
+## How Passthrough Works
 
-| 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 key insight is the Claude Agent SDK's `PreToolUse` hook — an officially supported callback that fires before any tool executes. Combined with `maxTurns: 1`, it gives us precise control over the execution boundary:
 
-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.
+1. **Claude generates a response** with `tool_use` blocks (Read a file, delegate to an agent, run a command)
+2. **The PreToolUse hook fires** for each tool call — we capture the tool name, input, and ID, then return `decision: "block"` to prevent SDK-internal execution
+3. **The SDK stops** (blocked tool + maxTurns:1 = turn complete) and we have the full tool_use payload
+4. **The proxy returns it to OpenCode** as a standard Anthropic API response with `stop_reason: "tool_use"`
+5. **OpenCode handles everything** — file reads, shell commands, and crucially, `Task` delegation through its own agent system with full model routing
+6. **OpenCode sends `tool_result` back**, the proxy resumes the SDK session, and Claude continues
 
-**~200 lines of TypeScript. No hacks. No magic. Just format translation.**
+No monkey-patching. No forked SDKs. No fragile stream rewriting. Just a hook and a turn limit.
 
-## Features
+## Quick Start
 
-| 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
 
-## Prerequisites
+1. **Claude Max subscription** — [Subscribe here](https://claude.ai/settings/subscription)
+2. **Claude CLI** authenticated: `npm install -g @anthropic-ai/claude-code && claude login`
 
-1. **Claude Max subscription** - [Subscribe here](https://claude.ai/settings/subscription)
+### Option A: npm Install
 
-2. **Claude CLI** installed and authenticated:
-   ```bash
-   npm install -g @anthropic-ai/claude-code
-   claude login
-   ```
+```bash
+npm install -g opencode-claude-max-proxy
 
-3. **Bun** runtime:
-   ```bash
-   curl -fsSL https://bun.sh/install | bash
-   ```
+# Start in passthrough mode (recommended)
+CLAUDE_PROXY_PASSTHROUGH=1 claude-max-proxy
+```
 
-## Installation
+### Option B: From Source
 
 ```bash
 git clone https://github.com/rynfar/opencode-claude-max-proxy
 cd opencode-claude-max-proxy
 bun install
+
+# Start in passthrough mode (recommended)
+CLAUDE_PROXY_PASSTHROUGH=1 bun run proxy
 ```
 
-## Usage
+> **Note:** Running from source requires [Bun](https://bun.sh): `curl -fsSL https://bun.sh/install | bash`
 
-### Start the Proxy
+### Option C: Docker
 
 ```bash
-bun run proxy
+git clone https://github.com/rynfar/opencode-claude-max-proxy
+cd opencode-claude-max-proxy
+
+# Start the container
+docker compose up -d
+
+# Login to Claude inside the container (one-time)
+docker compose exec proxy claude login
+
+# Verify
+curl http://127.0.0.1:3456/health
 ```
 
-### Run OpenCode
+> **Note:** On macOS, `claude login` must be run inside the container (keychain credentials can't be mounted). On Linux, volume-mounting `~/.claude` may work without re-login.
+
+### Connect OpenCode
 
 ```bash
 ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode
 ```
 
-Select any `anthropic/claude-*` model (opus, sonnet, haiku).
+The `ANTHROPIC_API_KEY` can be any non-empty string — the proxy doesn't use it. Authentication is handled by your `claude login` session.
 
-### One-liner
+### Shell Alias
 
 ```bash
-bun run proxy & ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode
+# Add to ~/.zshrc or ~/.bashrc
+alias oc='ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode'
 ```
 
-## Auto-start on macOS
+## Modes
 
-Set up the proxy to run automatically on login:
+### Passthrough Mode (recommended)
 
 ```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
+CLAUDE_PROXY_PASSTHROUGH=1 bun run proxy
+```
 
-launchctl load ~/Library/LaunchAgents/com.claude-max-proxy.plist
+All tool execution is forwarded to OpenCode. This enables:
+
+- **Multi-model agent delegation** — oh-my-opencode routes each agent to its configured model
+- **Full agent system prompts** — not abbreviated descriptions, the real prompts
+- **OpenCode manages everything** — tools, agents, permissions, lifecycle
+
+### Internal Mode (default)
+
+```bash
+bun run proxy
 ```
 
-Then add an alias to `~/.zshrc`:
+Tools execute inside the proxy via MCP. Subagents run on Claude via the SDK's native agent system. Simpler setup, but all agents use Claude regardless of oh-my-opencode config.
+
+| | Passthrough | Internal |
+|---|---|---|
+| Tool execution | OpenCode | Proxy (MCP) |
+| Agent delegation | OpenCode → multi-model | SDK → Claude only |
+| oh-my-opencode models | ✅ Respected | ❌ All Claude |
+| Agent system prompts | ✅ Full | ⚠️ Description only |
+| Setup complexity | Same | Same |
+
+## Works With Any Agent Framework
+
+The proxy extracts agent definitions from the `Task` tool description that OpenCode sends in each request. This means it works automatically with:
+
+- **Native OpenCode** — `build` and `plan` agents
+- **oh-my-opencode** — `oracle`, `explore`, `librarian`, `sisyphus-junior`, `metis`, `momus`, etc.
+- **Custom agents** — anything you define in `opencode.json`
+
+In internal mode, a `PreToolUse` hook fuzzy-matches agent names as a safety net (e.g., `general-purpose` → `general`, `Explore` → `explore`, `code-reviewer` → `oracle`). In passthrough mode, OpenCode handles agent names directly.
+
+## Session Resume
+
+The proxy tracks SDK session IDs and resumes conversations on follow-up requests:
+
+- **Faster responses** — no re-processing of conversation history
+- **Better context** — the SDK remembers tool results from previous turns
+
+Session tracking works two ways:
+
+1. **Header-based** (recommended) — Add the included OpenCode plugin:
+   ```json
+   { "plugin": ["./path/to/opencode-claude-max-proxy/src/plugin/claude-max-headers.ts"] }
+   ```
+
+2. **Fingerprint-based** (automatic fallback) — hashes the first user message to identify returning conversations
+
+Sessions are cached for 24 hours.
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CLAUDE_PROXY_PASSTHROUGH` | (unset) | Enable passthrough mode — forward all tools to OpenCode |
+| `CLAUDE_PROXY_PORT` | 3456 | Proxy server port |
+| `CLAUDE_PROXY_HOST` | 127.0.0.1 | Proxy server host |
+| `CLAUDE_PROXY_WORKDIR` | (cwd) | Working directory for Claude and tools |
+| `CLAUDE_PROXY_MAX_CONCURRENT` | 1 | Max concurrent SDK sessions (increase with caution) |
+| `CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS` | 120 | Connection idle timeout |
+
+## Concurrency
+
+The proxy supports multiple simultaneous OpenCode instances. Each request spawns its own independent SDK subprocess — run as many terminals as you want. All concurrent responses are delivered correctly.
+
+**Use the auto-restart supervisor** (recommended):
 
 ```bash
-echo "alias oc='ANTHROPIC_API_KEY=dummy ANTHROPIC_BASE_URL=http://127.0.0.1:3456 opencode'" >> ~/.zshrc
-source ~/.zshrc
+CLAUDE_PROXY_PASSTHROUGH=1 bun run proxy
+# or directly:
+CLAUDE_PROXY_PASSTHROUGH=1 ./bin/claude-proxy-supervisor.sh
 ```
 
-Now just run `oc` to start OpenCode with Claude Max.
+> **⚠️ Known Issue: Bun SSE Crash ([oven-sh/bun#17947](https://github.com/oven-sh/bun/issues/17947))**
+>
+> The Claude Agent SDK's `cli.js` subprocess is compiled with Bun, which has a known segfault in `structuredCloneForStream` during cleanup of concurrent streaming responses. This affects all runtimes (Bun, Node.js via tsx) because the crash originates in the SDK's child process, not in the proxy itself.
+>
+> **What this means in practice:**
+> - **Sequential requests (1 terminal):** No impact. Never crashes.
+> - **Concurrent requests (2+ terminals):** All responses are delivered correctly. The crash occurs *after* responses complete, during stream cleanup. No work is lost.
+> - **After a crash:** The supervisor restarts the proxy in ~1-3 seconds. If a new request arrives during this window, OpenCode shows "Unable to connect" — just retry.
+>
+> We are monitoring the upstream Bun issue for a fix. Once patched, the supervisor becomes optional.
 
 ## Model Mapping
 
 | OpenCode Model | Claude SDK |
 |----------------|------------|
 | `anthropic/claude-opus-*` | opus |
-| `anthropic/claude-sonnet-*` | sonnet |
+| `anthropic/claude-sonnet-*` | sonnet (default) |
 | `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 |
+## Disclaimer
 
-## How It Works
+This project is an **unofficial wrapper** around Anthropic's publicly available [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). It is not affiliated with, endorsed by, or supported by Anthropic.
 
-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
+**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 any applicable usage policies. Terms may change at any time.
 
-The proxy is ~200 lines of TypeScript. No magic, no hacks.
+This project calls `query()` from Anthropic's public npm package using your own authenticated account. No API keys are intercepted, no authentication is bypassed, and no proprietary systems are reverse-engineered.
 
 ## FAQ
 
-### Why do I need `ANTHROPIC_API_KEY=dummy`?
+<details>
+<summary><strong>Why passthrough mode instead of handling tools internally?</strong></summary>
+
+Internal tool execution means the SDK handles everything — but the SDK only speaks Claude. If your agents are configured for GPT-5.4 or Gemini via oh-my-opencode, that routing gets lost. Passthrough mode preserves the full OpenCode agent pipeline, including multi-model routing, full system prompts, and agent lifecycle management.
+</details>
+
+<details>
+<summary><strong>Does this work without oh-my-opencode?</strong></summary>
+
+Yes. Both modes work with native OpenCode (build + plan agents) and with any custom agents defined in your `opencode.json`. oh-my-opencode just adds more agents and model routing — the proxy handles whatever OpenCode sends.
+</details>
 
-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.
+<details>
+<summary><strong>Why do I need ANTHROPIC_API_KEY=dummy?</strong></summary>
 
-### Does this work with other tools besides OpenCode?
+OpenCode requires an API key to be set, but the proxy never uses it. Authentication is handled by your `claude login` session through the Agent SDK.
+</details>
 
-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`.
+<details>
+<summary><strong>What about rate limits?</strong></summary>
 
-### What about rate limits?
+Your Claude Max subscription has its own usage limits. The proxy doesn't add any additional limits. Concurrent requests are supported.
+</details>
 
-Your Claude Max subscription has its own usage limits. This proxy doesn't add any additional limits.
+<details>
+<summary><strong>Is my data sent anywhere else?</strong></summary>
 
-### Is my data sent anywhere else?
+No. The proxy runs locally. Requests go directly to Claude through the official SDK. In passthrough mode, tool execution happens in OpenCode on your machine.
+</details>
 
-No. The proxy runs locally on your machine. Your requests go directly to Claude through the official SDK.
+<details>
+<summary><strong>Why does internal mode use MCP tools?</strong></summary>
+
+The Claude Agent SDK uses different parameter names for tools than OpenCode (e.g., `file_path` vs `filePath`). Internal mode provides its own MCP tools with SDK-compatible parameter names. Passthrough mode doesn't need this since OpenCode handles tool execution directly.
+</details>
 
 ## Troubleshooting
 
-### "Authentication failed"
+| Problem | Solution |
+|---------|----------|
+| "Authentication failed" | Run `claude login` to authenticate |
+| "Connection refused" | Make sure the proxy is running: `bun run proxy` |
+| "Port 3456 is already in use" | `kill $(lsof -ti :3456)` or use `CLAUDE_PROXY_PORT=4567` |
+| Title generation fails | Set `"small_model": "anthropic/claude-haiku-4-5"` in your OpenCode config |
+
+## Auto-start (macOS)
+
+```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>$(pwd)/bin/claude-proxy-supervisor.sh</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>$(pwd)</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>CLAUDE_PROXY_PASSTHROUGH</key>
+        <string>1</string>
+    </dict>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+</dict>
+</plist>
+EOF
+
+launchctl load ~/Library/LaunchAgents/com.claude-max-proxy.plist
+```
 
-Run `claude login` to authenticate with the Claude CLI.
+## Testing
 
-### "Connection refused"
+```bash
+bun test
+```
 
-Make sure the proxy is running: `bun run proxy`
+106 tests across 13 files covering:
+- Passthrough tool forwarding and tool_result acceptance
+- PreToolUse hook interception and agent name fuzzy matching
+- SDK agent definition extraction (native OpenCode + oh-my-opencode)
+- MCP tool filtering (internal mode)
+- Session resume (header-based and fingerprint-based)
+- Streaming message deduplication
+- Working directory propagation
+- Concurrent request handling
+- Error classification (auth, rate limit, billing, timeout)
 
-### Proxy keeps dying
+### Health Endpoint
 
-Use the launchd service (see Auto-start section) which automatically restarts the proxy.
+```bash
+curl http://127.0.0.1:3456/health
+```
+
+Returns auth status, subscription type, and proxy mode. Use this to verify the proxy is running and authenticated before connecting OpenCode.
+
+## Architecture
+
+```
+src/
+├── proxy/
+│   ├── server.ts      # HTTP server, passthrough/internal modes, SSE streaming, session resume
+│   ├── agentDefs.ts   # Extract SDK agent definitions from OpenCode's Task tool
+│   ├── agentMatch.ts  # Fuzzy matching for agent names (6-level priority)
+│   └── types.ts       # ProxyConfig types and defaults
+├── mcpTools.ts        # MCP tool definitions for internal mode (read, write, edit, bash, glob, grep)
+├── logger.ts          # Structured logging with AsyncLocalStorage context
+├── plugin/
+│   └── claude-max-headers.ts  # OpenCode plugin for session header injection
+└── __tests__/         # 106 tests across 13 files
+    ├── helpers.ts
+    ├── integration.test.ts
+    ├── proxy-agent-definitions.test.ts
+    ├── proxy-agent-fuzzy-match.test.ts
+    ├── proxy-error-handling.test.ts
+    ├── proxy-mcp-filtering.test.ts
+    ├── proxy-passthrough-concept.test.ts
+    ├── proxy-pretooluse-hook.test.ts
+    ├── proxy-session-resume.test.ts
+    ├── proxy-streaming-message.test.ts
+    ├── proxy-subagent-support.test.ts
+    ├── proxy-tool-forwarding.test.ts
+    ├── proxy-transparent-tools.test.ts
+    └── proxy-working-directory.test.ts
+```
 
 ## License
 

package/bin/claude-proxy-supervisor.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+# Auto-restart supervisor for claude-max-proxy
+#
+# The Claude Agent SDK's cli.js subprocess (compiled with Bun) can crash
+# during cleanup of concurrent streaming responses — a known Bun bug
+# (oven-sh/bun#17947). All responses are delivered correctly; the crash
+# only occurs after response completion.
+#
+# This supervisor runs the proxy in a subshell with signal isolation,
+# detects crashes, and restarts in ~1 second.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/.."
+
+# Ignore signals that the child's crash might propagate
+trap '' SIGPIPE
+
+RESTART_COUNT=0
+MAX_RAPID_RESTARTS=50
+RAPID_WINDOW=60
+LAST_START=0
+
+while true; do
+  NOW=$(date +%s)
+  
+  if [ $((NOW - LAST_START)) -gt $RAPID_WINDOW ]; then
+    RESTART_COUNT=0
+  fi
+  
+  if [ $RESTART_COUNT -ge $MAX_RAPID_RESTARTS ]; then
+    echo "[supervisor] Too many restarts ($RESTART_COUNT in ${RAPID_WINDOW}s). Stopping."
+    exit 1
+  fi
+  
+  LAST_START=$NOW
+  RESTART_COUNT=$((RESTART_COUNT + 1))
+  
+  if [ $RESTART_COUNT -gt 1 ]; then
+    echo "[supervisor] Restarting proxy (restart #$RESTART_COUNT)..."
+  else
+    echo "[supervisor] Starting proxy..."
+  fi
+  
+  # Run in subshell so crashes don't kill the supervisor
+  (exec bun run ./bin/claude-proxy.ts)
+  EXIT_CODE=$?
+  
+  if [ $EXIT_CODE -eq 0 ]; then
+    echo "[supervisor] Proxy exited cleanly."
+    break
+  fi
+  
+  # Signal-based exits (128+signal)
+  if [ $EXIT_CODE -gt 128 ]; then
+    SIG=$((EXIT_CODE - 128))
+    echo "[supervisor] Proxy killed by signal $SIG. Restarting in 1s..."
+  else
+    echo "[supervisor] Proxy exited (code $EXIT_CODE). Restarting in 1s..."
+  fi
+  
+  sleep 1
+done

package/bin/claude-proxy.ts

@@ -1,8 +1,33 @@
 #!/usr/bin/env bun
 
 import { startProxyServer } from "../src/proxy/server"
+import { execSync } from "child_process"
+
+// Prevent SDK subprocess crashes from killing the proxy
+process.on("uncaughtException", (err) => {
+  console.error(`[PROXY] Uncaught exception (recovered): ${err.message}`)
+})
+process.on("unhandledRejection", (reason) => {
+  console.error(`[PROXY] Unhandled rejection (recovered): ${reason instanceof Error ? reason.message : reason}`)
+})
 
 const port = parseInt(process.env.CLAUDE_PROXY_PORT || "3456", 10)
 const host = process.env.CLAUDE_PROXY_HOST || "127.0.0.1"
+const idleTimeoutSeconds = parseInt(process.env.CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS || "120", 10)
+
+// Pre-flight auth check
+try {
+  const authJson = execSync("claude auth status", { encoding: "utf-8", timeout: 5000 })
+  const auth = JSON.parse(authJson)
+  if (!auth.loggedIn) {
+    console.error("\x1b[31m✗ Not logged in to Claude.\x1b[0m Run: claude login")
+    process.exit(1)
+  }
+  if (auth.subscriptionType !== "max") {
+    console.error(`\x1b[33m⚠ Claude subscription: ${auth.subscriptionType || "unknown"} (Max recommended)\x1b[0m`)
+  }
+} catch {
+  console.error("\x1b[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1b[0m")
+}
 
-await startProxyServer({ port, host })
+await startProxyServer({ port, host, idleTimeoutSeconds })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-max-proxy",
-  "version": "1.0.2",
+  "version": "1.8.0",
   "description": "Use your Claude Max subscription with OpenCode via proxy server",
   "type": "module",
   "main": "./src/proxy/server.ts",
@@ -11,14 +11,17 @@
     ".": "./src/proxy/server.ts"
   },
   "scripts": {
-    "start": "bun run ./bin/claude-proxy.ts",
-    "proxy": "bun run ./bin/claude-proxy.ts",
+    "start": "./bin/claude-proxy-supervisor.sh",
+    "proxy": "./bin/claude-proxy-supervisor.sh",
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "proxy:direct": "bun run ./bin/claude-proxy.ts"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.0",
-    "hono": "^4.11.4"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.80",
+    "glob": "^13.0.0",
+    "hono": "^4.11.4",
+    "p-queue": "^8.0.1"
   },
   "devDependencies": {
     "@types/bun": "^1.2.21",