coc-bridge 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to coc-bridge are documented here.
+
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).  
+Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+---
+
+## [1.0.0] — 2026-10-14
+
+### Added
+- Initial public release 🎉
+- Zero-dependency HTTP proxy serving the Anthropic `/v1/messages` and `/v1/models` API
+- Streaming SSE support (`message_start → content_block_delta → message_stop`)
+- Non-streaming JSON response support
+- Model discovery endpoint (`GET /v1/models`) for Claude Code's `/model` picker
+- 9 OpenCode free models available out of the box
+- Model alias table: short names (`cat-jam`, `nemotron`, `muse-spark`, etc.) and Claude tier names (`opus`, `sonnet`, `haiku`, `fable`) all resolve correctly
+- Auto-detection of `opencode` binary from `$PATH`, NVM locations, and common paths
+- `coc-bridge setup` — wraps the `claude` binary to auto-start the bridge and inject all env vars
+- `coc-bridge doctor` — checks Node.js version, opencode presence, claude wrapper status, bridge health, and log directory
+- `coc-bridge help` — full CLI help with all env vars and model list
+- 5-minute request timeout with `BRIDGE_TIMEOUT_MS` override
+- 50MB payload cap with `413` response
+- Client disconnect detection — kills orphan opencode child processes immediately
+- `tool_use` block support in `buildPrompt()` — preserves full agent tool-call history across turns
+- CORS headers for VS Code extension compatibility
+- `npm test` four-test suite: health, model discovery, non-streaming, streaming SSE
+
+[1.0.0]: https://github.com/allannuwamanya/coc-bridge/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Allan Nuwamanya
+
+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

@@ -1,3 +1,178 @@
-# Temporary Holding Version
+# coc-bridge 🔌
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> **Claude Code ↔ OpenCode. Zero API keys. All free.**
+
+[![npm](https://img.shields.io/npm/v/coc-bridge.svg)](https://www.npmjs.com/package/coc-bridge)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node ≥18](https://img.shields.io/badge/Node-%3E%3D18-brightgreen.svg)](https://nodejs.org)
+
+`coc-bridge` is a tiny local proxy that lets **Claude Code** use **OpenCode's free hosted models** — no Anthropic API key, no billing, no friction.
+
+```
+Claude Code ──( Anthropic format )──► coc-bridge ──► opencode run -m <model>
+Claude Code ◄──( SSE stream      )─── coc-bridge ◄── model output
+```
+
+---
+
+## ✨ Features
+
+- **Zero dependencies** — pure Node.js, nothing to `npm install`
+- **Drop-in replacement** — Claude Code doesn't know the difference
+- **9 free models** out of the box (Space Bunny, Cat Jam, Nemotron Ultra, Muse Spark, and more)
+- **Full streaming** — Anthropic SSE events, same as the real API
+- **VS Code model picker** — custom model names show up in the sidebar dropdown
+- **Auto-start** — the bridge starts itself when you run `claude`, so you never have to think about it
+- **`coc-bridge doctor`** — one command checks everything is working
+
+---
+
+## 🚀 Quick start (3 steps)
+
+### Step 1 — Install opencode
+
+```bash
+npm install -g opencode
+```
+
+> opencode is the only runtime requirement. coc-bridge itself has zero dependencies.
+
+### Step 2 — Install coc-bridge
+
+```bash
+npm install -g coc-bridge
+```
+
+### Step 3 — Run setup
+
+```bash
+coc-bridge setup
+```
+
+That's it. From now on, running `claude` will automatically start the bridge and use free OpenCode models. 🎉
+
+---
+
+## 🧪 Verify it's working
+
+```bash
+coc-bridge doctor
+```
+
+```
+coc-bridge doctor 🩺
+
+  ✔  Node.js                         v24.21.0
+  ✔  opencode                        0.3.x
+  ✔  claude wrapper                  /usr/local/bin/claude (patched ✓)
+  ✔  Bridge server                   http://127.0.0.1:4045 ✓
+  ✔  Default model                   opencode/space-bunny-free
+  ✔  Available models                9 models
+  ✔  Log directory                   /home/you/.coc-bridge
+
+Everything looks great! 🎉
+```
+
+Or run the full test suite:
+
+```bash
+npm test
+```
+
+---
+
+## 🎛️ Available models
+
+| Short name       | Full OpenCode ID                                  | Best for                        |
+| :--------------- | :------------------------------------------------ | :------------------------------ |
+| `space-bunny`    | `opencode/space-bunny-free`                       | General coding (default)        |
+| `cat-jam`        | `opencode/cat-jam-free`                           | Fast edits & quick answers      |
+| `muse-spark`     | `opencode/muse-spark-1.3-contributor-free`        | Reasoning & architecture        |
+| `nemotron`       | `opencode/nemotron-3-ultra-free`                  | Deep reasoning (NVIDIA 500B)    |
+| `nemotron-lightning` | `opencode/nemotron-3.5-lightning-free`        | Fast NVIDIA model               |
+| `ling-flash`     | `opencode/ling-3.1-flash-free`                    | High-throughput tasks           |
+| `longcat`        | `opencode/longcat-2.5-preview-free`               | Long-context tasks              |
+| `mimo`           | `opencode/mimo-v2.6-flash-free`                   | Multimodal flash                |
+| `big-pickle`     | `opencode/big-pickle`                             | 🥒                              |
+
+**VS Code dropdown** maps to:
+| Claude Code menu | Resolves to                                          |
+| :--------------- | :--------------------------------------------------- |
+| Opus             | `opencode/nemotron-3-ultra-free` (Nemotron 3 Ultra)  |
+| Sonnet           | `opencode/muse-spark-1.3-contributor-free` (Muse Spark 1.3) |
+| Haiku            | `opencode/cat-jam-free` (Cat Jam)                    |
+| Fable            | `opencode/ling-3.1-flash-free` (Ling 3.1 Flash)     |
+| Custom           | `opencode/space-bunny-free` (Space Bunny)            |
+
+---
+
+## ⚙️ Configuration
+
+All configuration is via environment variables — no config files.
+
+| Variable             | Default                        | Description                                  |
+| :------------------- | :----------------------------- | :------------------------------------------- |
+| `BRIDGE_PORT`        | `4045`                         | Port the bridge listens on                   |
+| `OPENCODE_MODEL`     | `opencode/space-bunny-free`    | Default model when none is requested         |
+| `OPENCODE_BIN`       | auto-detected                  | Path to the `opencode` binary                |
+| `BRIDGE_TIMEOUT_MS`  | `300000` (5 min)               | Max time per request before killing the child process |
+
+### Use a custom port
+
+```bash
+BRIDGE_PORT=5000 coc-bridge
+```
+
+### Use a specific model as default
+
+```bash
+OPENCODE_MODEL=opencode/nemotron-3-ultra-free coc-bridge
+```
+
+---
+
+## 🛠️ Manual setup (without `coc-bridge setup`)
+
+If you prefer not to let the installer touch your `claude` binary:
+
+```bash
+# Terminal 1 — start the bridge
+coc-bridge
+
+# Terminal 2 — set env vars and launch Claude Code
+export ANTHROPIC_BASE_URL="http://127.0.0.1:4045"
+export ANTHROPIC_AUTH_TOKEN="coc-local"
+claude
+```
+
+---
+
+## 🗂️ Project structure
+
+```
+coc-bridge/
+├── bin/
+│   └── coc-bridge.js        # CLI entry point
+├── src/
+│   └── server.js            # Bridge proxy server
+├── scripts/
+│   ├── setup-claude.js      # Wraps the claude binary
+│   └── doctor.js            # Health check utility
+├── test/
+│   └── test-client.js       # Test suite
+├── CHANGELOG.md
+├── CONTRIBUTING.md
+└── LICENSE
+```
+
+---
+
+## 🤝 Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). PRs welcome — especially new model aliases and better error messages.
+
+---
+
+## 📄 License
+
+[MIT](LICENSE) © Allan Nuwamanya

package/bin/coc-bridge.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+/**
+ * coc-bridge CLI entry point
+ *
+ * Default behaviour: daemonize the server in the background, confirm it's
+ * connected, then return the terminal prompt immediately.
+ *
+ * Commands:
+ *   (none / start)   Start daemon in background and confirm connection
+ *   stop             Stop the running daemon
+ *   status           Show whether the daemon is running
+ *   restart          Stop then start
+ *   logs             Tail the live log file
+ *   server           Run the server IN the foreground (for debugging)
+ *   setup            Wire Claude Code to auto-start the bridge
+ *   doctor           Health-check the full installation
+ *   help / --help    Show this help
+ *   --version / -v   Show version
+ */
+'use strict';
+
+const path   = require('path');
+const fs     = require('fs');
+const http   = require('http');
+const os     = require('os');
+const { spawn, execSync } = require('child_process');
+
+// ─── paths ────────────────────────────────────────────────────────────────────
+const PORT        = parseInt(process.env.BRIDGE_PORT || '4045', 10);
+const LOG_DIR     = path.join(os.homedir(), '.coc-bridge');
+const LOG_FILE    = path.join(LOG_DIR, 'bridge.log');
+const PID_FILE    = path.join(LOG_DIR, 'bridge.pid');
+const CONFIG_FILE = path.join(LOG_DIR, 'config.json');
+const SERVER_JS   = path.join(__dirname, '..', 'src', 'server.js');
+
+function readConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch (_) { return {}; }
+}
+
+// ─── colours ──────────────────────────────────────────────────────────────────
+const G = '\x1b[32m', Y = '\x1b[33m', R = '\x1b[31m', B = '\x1b[34m';
+const BOLD = '\x1b[1m', DIM = '\x1b[2m', RESET = '\x1b[0m';
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+function ensureLogDir() {
+  if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+function readPid() {
+  try { return parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10); } catch (_) { return null; }
+}
+
+function writePid(pid) {
+  ensureLogDir();
+  fs.writeFileSync(PID_FILE, String(pid));
+}
+
+function clearPid() {
+  try { fs.unlinkSync(PID_FILE); } catch (_) {}
+}
+
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch (_) { return false; }
+}
+
+function healthCheck() {
+  return new Promise(resolve => {
+    const req = http.get(`http://127.0.0.1:${PORT}/health`, { timeout: 2000 }, res => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => {
+        try { resolve(JSON.parse(body)); } catch (_) { resolve(null); }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+async function waitForBridge(timeoutMs = 8000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const health = await healthCheck();
+    if (health && health.status === 'ok') return health;
+    await new Promise(r => setTimeout(r, 150));
+  }
+  return null;
+}
+
+// ─── commands ─────────────────────────────────────────────────────────────────
+
+async function cmdStart() {
+  // Already running?
+  const existingPid = readPid();
+  if (isProcessAlive(existingPid)) {
+    const health = await healthCheck();
+    if (health) {
+      console.log(`\n${G}${BOLD}✔  coc-bridge already running${RESET}  ${DIM}(pid ${existingPid}, port ${PORT})${RESET}`);
+      console.log(`   ${DIM}Default model: ${health.defaultModel}${RESET}`);
+      console.log(`   ${DIM}${health.availableModels.length} models available${RESET}\n`);
+      return;
+    }
+    // PID alive but bridge not responding — stale, clean up
+    clearPid();
+  }
+
+  // Spawn the daemon — stdout/stderr both go to the log file
+  ensureLogDir();
+  const logFd = fs.openSync(LOG_FILE, 'a');
+  const child = spawn(process.execPath, [SERVER_JS], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env, COC_BRIDGE_DAEMON: '1' },
+  });
+  fs.closeSync(logFd);
+  child.unref();
+
+  writePid(child.pid);
+
+  process.stdout.write(`\n   Starting coc-bridge`);
+  const health = await waitForBridge(10000);
+
+  if (!health) {
+    process.stdout.write(`\n${R}${BOLD}✖  Bridge failed to start${RESET}\n`);
+    console.log(`   Check logs: ${LOG_FILE}\n`);
+    clearPid();
+    process.exit(1);
+  }
+
+  console.log(`\r${G}${BOLD}✔  coc-bridge connected${RESET}  ${DIM}http://127.0.0.1:${PORT}  (pid ${child.pid})${RESET}`);
+  console.log(`   ${DIM}Default model : ${health.defaultModel}${RESET}`);
+  console.log(`   ${DIM}Models        : ${health.availableModels.length} available${RESET}`);
+  console.log(`   ${DIM}Logs          : ${LOG_FILE}${RESET}`);
+  console.log(`\n   ${DIM}Run ${RESET}${BOLD}coc-bridge stop${RESET}${DIM} to shut it down.${RESET}\n`);
+}
+
+async function cmdStop() {
+  const pid = readPid();
+  if (!pid || !isProcessAlive(pid)) {
+    console.log(`\n${Y}  coc-bridge is not running.${RESET}\n`);
+    clearPid();
+    return;
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+    // Wait up to 3s for process to die
+    for (let i = 0; i < 30; i++) {
+      await new Promise(r => setTimeout(r, 100));
+      if (!isProcessAlive(pid)) break;
+    }
+    clearPid();
+    console.log(`\n${G}  ✔  coc-bridge stopped.${RESET}\n`);
+  } catch (e) {
+    console.log(`\n${R}  ✖  Could not stop process ${pid}: ${e.message}${RESET}\n`);
+  }
+}
+
+async function cmdStatus() {
+  const pid = readPid();
+  const alive = isProcessAlive(pid);
+  const health = await healthCheck();
+
+  console.log('');
+  if (alive && health) {
+    console.log(`${G}${BOLD}  ● coc-bridge is running${RESET}`);
+    console.log(`    pid     : ${pid}`);
+    console.log(`    port    : ${PORT}`);
+    console.log(`    model   : ${health.defaultModel}`);
+    console.log(`    models  : ${health.availableModels.length} available`);
+    console.log(`    log     : ${LOG_FILE}`);
+  } else if (alive && !health) {
+    console.log(`${Y}${BOLD}  ⚠  Process alive (pid ${pid}) but not responding on port ${PORT}${RESET}`);
+  } else {
+    console.log(`${R}${BOLD}  ○  coc-bridge is not running${RESET}`);
+    console.log(`    Run ${BOLD}coc-bridge${RESET} to start it.`);
+  }
+  console.log('');
+}
+
+async function cmdRestart() {
+  await cmdStop();
+  await new Promise(r => setTimeout(r, 500));
+  await cmdStart();
+}
+
+function cmdLogs() {
+  ensureLogDir();
+  if (!fs.existsSync(LOG_FILE)) {
+    console.log(`\n${Y}  No log file yet. Start the bridge first: coc-bridge${RESET}\n`);
+    return;
+  }
+  console.log(`\n${DIM}  Tailing ${LOG_FILE} (Ctrl+C to exit)${RESET}\n`);
+  // Print last 20 lines then follow
+  try {
+    const lines = fs.readFileSync(LOG_FILE, 'utf8').split('\n').slice(-20).join('\n');
+    if (lines.trim()) console.log(lines);
+  } catch (_) {}
+  const tail = spawn('tail', ['-f', LOG_FILE], { stdio: 'inherit' });
+  tail.on('exit', () => process.exit(0));
+  process.on('SIGINT', () => { tail.kill(); process.exit(0); });
+}
+
+function cmdServer() {
+  // Foreground mode — just run the server directly, no daemonizing
+  console.log(`\n${B}${BOLD}  coc-bridge — foreground mode${RESET}  ${DIM}(Ctrl+C to stop)${RESET}\n`);
+  require(SERVER_JS);
+}
+
+// ── coc-bridge models ──────────────────────────────────────────────────────────
+function cmdModels() {
+  const { spawnSync } = require('child_process');
+  const NODE = process.execPath;
+
+  // Ask the bridge's own health endpoint first (if running)
+  http.get(`http://127.0.0.1:${PORT}/v1/models`, { timeout: 2000 }, res => {
+    let body = '';
+    res.on('data', d => body += d);
+    res.on('end', () => {
+      try {
+        const data = JSON.parse(body);
+        printModelList(data.data, '(from running bridge)');
+      } catch (_) {
+        fetchAndPrint();
+      }
+    });
+  }).on('error', () => fetchAndPrint());
+
+  function fetchAndPrint() {
+    // Bridge not running — call opencode models directly
+    let opencodebin;
+    try {
+      const { execSync } = require('child_process');
+      opencodebin = execSync('which opencode', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    } catch (_) {
+      const candidates = [
+        path.join(os.homedir(), '.nvm', 'versions', 'node', 'v24.21.0', 'bin', 'opencode'),
+        path.join(os.homedir(), '.local', 'bin', 'opencode'),
+        '/usr/local/bin/opencode',
+      ];
+      opencodebin = candidates.find(c => { try { fs.accessSync(c, fs.constants.X_OK); return true; } catch (_) { return false; } });
+    }
+    if (!opencodebin) {
+      console.log(`\n${R}  Cannot find opencode. Install it: npm install -g opencode${RESET}\n`);
+      return;
+    }
+    const r = spawnSync(opencodebin, ['models'], { encoding: 'utf8', timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'] });
+    if (r.status !== 0 || !r.stdout) {
+      console.log(`\n${R}  opencode models failed.${RESET}\n`);
+      return;
+    }
+    const models = r.stdout.trim().split('\n').filter(Boolean).map(id => ({ id, display_name: id }));
+    printModelList(models, '(from opencode)');
+  }
+
+  function printModelList(models, source) {
+    const cfg = readConfig();
+    const current = cfg.defaultModel || 'opencode/space-bunny-free';
+    console.log(`\n${BOLD}  Available OpenCode models ${DIM}${source}${RESET}\n`);
+    for (const m of models) {
+      const isDefault = m.id === current;
+      const tag = isDefault ? ` ${G}← current default${RESET}` : '';
+      console.log(`  ${isDefault ? G + BOLD : DIM}${m.id}${RESET}${tag}`);
+    }
+    console.log(`\n  ${DIM}Set default: ${RESET}${BOLD}coc-bridge use <model-id>${RESET}\n`);
+  }
+}
+
+// ── coc-bridge use <model> ─────────────────────────────────────────────────────
+function cmdUse(modelId) {
+  if (!modelId) {
+    console.log(`\n${R}  Usage: coc-bridge use <model-id>${RESET}`);
+    console.log(`  Example: coc-bridge use opencode/cat-jam-free\n`);
+    console.log(`  Run ${BOLD}coc-bridge models${RESET} to see what's available.\n`);
+    return;
+  }
+  ensureLogDir();
+  const cfg = readConfig();
+  const previous = cfg.defaultModel || 'opencode/space-bunny-free';
+  cfg.defaultModel = modelId;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+  console.log(`\n${G}${BOLD}  ✔  Default model updated${RESET}`);
+  console.log(`     ${DIM}Was:${RESET} ${previous}`);
+  console.log(`     ${DIM}Now:${RESET} ${G}${modelId}${RESET}`);
+  console.log(`\n  ${DIM}Restart the bridge to apply: ${RESET}${BOLD}coc-bridge restart${RESET}\n`);
+}
+
+function showHelp() {
+  const pkg = require('../package.json');
+  console.log(`
+${BOLD}╔══════════════════════════════════════════════════════╗
+║         coc-bridge 🔌  v${pkg.version}  —  Claude ↔ OpenCode    ║
+╚══════════════════════════════════════════════════════╝${RESET}
+
+${BOLD}USAGE${RESET}
+  coc-bridge [command]
+
+${BOLD}COMMANDS${RESET}
+  ${G}(default)${RESET}    Start the bridge in the background, return your prompt
+  ${G}stop${RESET}         Stop the running background bridge
+  ${G}restart${RESET}      Stop then start again
+  ${G}status${RESET}       Show whether the bridge is running
+  ${G}logs${RESET}         Tail the live log file
+  ${G}models${RESET}       List all available OpenCode models
+  ${G}use <id>${RESET}     Set the default model (saved to ~/.coc-bridge/config.json)
+  ${G}server${RESET}       Run in the foreground (useful for debugging)
+  ${G}setup${RESET}        Wire Claude Code to auto-start the bridge on login
+  ${G}doctor${RESET}       Check that Node, opencode, and claude are all wired up
+
+${BOLD}ENVIRONMENT VARIABLES${RESET}
+  BRIDGE_PORT        Port to listen on          (default: 4045)
+  OPENCODE_MODEL     Default model              (overrides config.json)
+  OPENCODE_BIN       Path to opencode binary    (auto-detected)
+  BRIDGE_TIMEOUT_MS  Max ms per request         (default: 300000)
+
+${BOLD}EXAMPLES${RESET}
+  coc-bridge                             # Start daemon, get prompt back
+  coc-bridge models                      # See all models you can use
+  coc-bridge use opencode/cat-jam-free   # Switch default model
+  coc-bridge restart                     # Apply model change
+  coc-bridge stop                        # Shut it down
+  coc-bridge status                      # Is it running?
+  coc-bridge logs                        # Watch live logs
+  coc-bridge setup                       # One-time Claude Code wiring
+  BRIDGE_PORT=5000 coc-bridge            # Custom port
+`);
+}
+
+// ─── router ───────────────────────────────────────────────────────────────────
+const cmd = process.argv[2] || 'start';
+
+(async () => {
+  switch (cmd) {
+    case 'start':     await cmdStart();              break;
+    case 'stop':      await cmdStop();               break;
+    case 'status':    await cmdStatus();             break;
+    case 'restart':   await cmdRestart();            break;
+    case 'logs':      cmdLogs();                     break;
+    case 'server':    cmdServer();                   break;
+    case 'models':    cmdModels();                   break;
+    case 'use':       cmdUse(process.argv[3]);       break;
+    case 'setup':     require(path.join(__dirname, '..', 'scripts', 'setup-claude.js')); break;
+    case 'doctor':    require(path.join(__dirname, '..', 'scripts', 'doctor.js'));       break;
+    case '--version':
+    case '-v': {
+      const pkg = require('../package.json');
+      console.log(`coc-bridge v${pkg.version}`);
+      break;
+    }
+    case 'help':
+    case '--help':
+    case '-h':
+      showHelp();
+      break;
+    default:
+      console.log(`\n${R}  Unknown command: ${cmd}${RESET}\n  Run ${BOLD}coc-bridge help${RESET} for available commands.\n`);
+      process.exit(1);
+  }
+})();
+

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "coc-bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "A zero-dependency local bridge that connects Claude Code to OpenCode's free hosted models — no API keys required.",
+  "main": "src/server.js",
+  "bin": {
+    "coc-bridge": "./bin/coc-bridge.js",
+    "coc-bridge-start": "./bin/coc-bridge.js"
+  },
+  "scripts": {
+    "start": "node src/server.js",
+    "dev": "BRIDGE_LOG_LEVEL=debug node src/server.js",
+    "test": "node test/test-client.js",
+    "install-claude": "node scripts/setup-claude.js",
+    "doctor": "node scripts/doctor.js"
+  },
+  "keywords": [
+    "claude-code",
+    "opencode",
+    "anthropic",
+    "proxy",
+    "bridge",
+    "ai",
+    "llm",
+    "free",
+    "claude",
+    "opencode-bridge"
+  ],
+  "author": {
+    "name": "Allan Nuwamanya",
+    "email": "allan.info.comp@gmail.com",
+    "url": "https://github.com/allannuwamanya"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/allannuwamanya/coc-bridge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/allannuwamanya/coc-bridge/issues"
+  },
+  "homepage": "https://github.com/allannuwamanya/coc-bridge#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/",
+    "test/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "preferGlobal": true
+}