@ai-ide-bridge/cli 1.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @ai-ide-bridge/cli@1.0.3 build /home/runner/work/llm-bridge/llm-bridge/cli
+> tsc
+

package/README.md

@@ -0,0 +1,63 @@
+# @ai-ide-bridge/cli
+
+The standalone command-line interface for **AI IDE Bridge**.
+
+AI IDE Bridge is a local HTTP server that translates OpenAI-compatible API requests into provider-specific calls (Cursor SDK, GitHub Copilot, Windsurf), enabling any OpenAI-format client to use any AI IDE's model catalog.
+
+## Installation
+
+```bash
+npm install -g @ai-ide-bridge/cli
+```
+
+## Quick Start
+
+### 1. Initialize
+
+```bash
+llm-bridge init
+```
+
+This interactive wizard will:
+
+- Ask which providers you want to enable (cursor, copilot, windsurf)
+- Collect your API tokens
+- Generate a config file at `~/.config/llm-bridge/config.json`
+
+### 2. Start the Bridge
+
+```bash
+llm-bridge start
+```
+
+The server starts on `http://127.0.0.1:3849` by default.
+
+### 3. Configure your Client
+
+```bash
+llm-bridge configure
+```
+
+This injects the llm-bridge provider into your `opencode.json`.
+
+## Commands
+
+| Command                       | Description                          |
+| ----------------------------- | ------------------------------------ |
+| `llm-bridge init`             | Interactive setup wizard             |
+| `llm-bridge start`            | Launch bridge server                 |
+| `llm-bridge configure`        | Inject provider config into OpenCode |
+| `llm-bridge doctor`           | Run diagnostics                      |
+| `llm-bridge install-daemon`   | Install macOS LaunchAgent            |
+| `llm-bridge uninstall-daemon` | Remove macOS LaunchAgent             |
+| `llm-bridge daemon status`    | Check Windsurf daemon status         |
+| `llm-bridge daemon download`  | Download Windsurf daemon             |
+| `llm-bridge daemon locate`    | Find Windsurf daemon path            |
+
+## Documentation
+
+For full documentation, architecture diagrams, and advanced configuration, please visit the main repository: [https://github.com/aeswibon/llm-bridge](https://github.com/aeswibon/llm-bridge).
+
+## License
+
+MIT

package/dist/commands/configure.d.ts

@@ -0,0 +1 @@
+export declare function configureOpencodeCommand(): Promise<void>;

package/dist/commands/configure.js

@@ -0,0 +1,21 @@
+import { findOpencodeConfig, injectProvider } from '../utils/opencode.js';
+import { readConfig } from '../utils/config.js';
+export async function configureOpencodeCommand() {
+    const configPath = findOpencodeConfig();
+    if (!configPath) {
+        console.error('No opencode.json found. Create one at ~/.config/opencode/opencode.json');
+        process.exit(1);
+    }
+    const bridgeConfig = readConfig();
+    const providerId = 'llm-bridge';
+    const plugin = bridgeConfig.defaultPlugin ?? 'cursor';
+    const modelId = plugin === 'copilot'
+        ? 'copilot/gpt-4o-copilot'
+        : plugin === 'windsurf'
+            ? 'windsurf/claude-4.5-sonnet'
+            : 'cursor/composer-2';
+    injectProvider(configPath, providerId, modelId, bridgeConfig.port);
+    console.log(`Injected provider into ${configPath}`);
+    console.log(`Provider: ${providerId}, Model: ${modelId}, Port: ${bridgeConfig.port}`);
+    console.log(`Plugin: ${plugin}`);
+}

package/dist/commands/daemon.d.ts

@@ -0,0 +1,5 @@
+export declare function installDaemonCommand(): Promise<void>;
+export declare function uninstallDaemonCommand(): Promise<void>;
+export declare function daemonStatusCommand(): Promise<void>;
+export declare function daemonDownloadCommand(): Promise<void>;
+export declare function daemonLocateCommand(): Promise<void>;

package/dist/commands/daemon.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const LABEL = 'com.llm-bridge.daemon';
+export async function installDaemonCommand() {
+    if (process.platform !== 'darwin') {
+        console.error('Daemon installation is only supported on macOS.');
+        process.exit(1);
+    }
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    const wrapperPath = path.join(__dirname, '..', '..', 'scripts', 'llm-bridge-daemon.sh');
+    const plist = `<?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>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${wrapperPath}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>StandardOutPath</key>
+  <string>${os.homedir()}/Library/Logs/llm-bridge.log</string>
+  <key>StandardErrorPath</key>
+  <string>${os.homedir()}/Library/Logs/llm-bridge.err.log</string>
+</dict>
+</plist>`;
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+    fs.writeFileSync(plistPath, plist);
+    try {
+        execSync(`launchctl bootstrap "gui/$(id -u)" "${plistPath}"`, { stdio: 'inherit' });
+        console.log(`Installed LaunchAgent: ${plistPath}`);
+        console.log(`Logs: ~/Library/Logs/llm-bridge.{log,err.log}`);
+    }
+    catch (e) {
+        console.error('Failed to bootstrap daemon:', e);
+        process.exit(1);
+    }
+}
+export async function uninstallDaemonCommand() {
+    if (process.platform !== 'darwin') {
+        console.error('Daemon uninstallation is only supported on macOS.');
+        process.exit(1);
+    }
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    try {
+        execSync(`launchctl bootout "gui/$(id -u)" "${plistPath}" 2>/dev/null || true`, {
+            stdio: 'inherit',
+        });
+    }
+    catch {
+        // Ignore errors during unbootstrap
+    }
+    if (fs.existsSync(plistPath)) {
+        fs.unlinkSync(plistPath);
+        console.log(`Removed LaunchAgent: ${plistPath}`);
+    }
+    else {
+        console.log('No LaunchAgent found.');
+    }
+}
+export async function daemonStatusCommand() {
+    const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
+    const daemon = createWindsurfDaemon();
+    const path = await daemon.locate();
+    if (path) {
+        console.log(`Windsurf language server found at: ${path}`);
+        const healthy = await daemon.healthCheck();
+        console.log(`Health: ${healthy ? 'OK' : 'Unhealthy'}`);
+    }
+    else {
+        console.log('Windsurf language server not found.');
+        console.log('Run: llm-bridge daemon download');
+    }
+}
+export async function daemonDownloadCommand() {
+    const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
+    const daemon = createWindsurfDaemon();
+    console.log('Downloading Windsurf language server...');
+    try {
+        const path = await daemon.download();
+        console.log(`Downloaded to: ${path}`);
+    }
+    catch (err) {
+        console.error(`Download failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+export async function daemonLocateCommand() {
+    const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
+    const daemon = createWindsurfDaemon();
+    const path = await daemon.locate();
+    if (path) {
+        console.log(path);
+    }
+    else {
+        console.log('Not found');
+        process.exit(1);
+    }
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctorCommand(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,66 @@
+import http from 'node:http';
+import { readConfig } from '../utils/config.js';
+import fs from 'node:fs';
+import { configPath } from '@ai-ide-bridge/core';
+export async function doctorCommand() {
+    const config = readConfig();
+    console.log('llm-bridge diagnostics\n');
+    console.log(`Config: ${configPath()}`);
+    console.log(`Active plugin: ${config.activePlugin ?? config.defaultPlugin}`);
+    console.log(`Port: ${config.port}`);
+    console.log(`Host: ${config.host}`);
+    console.log(`Tool mode: ${config.toolMode}`);
+    if (fs.existsSync(configPath())) {
+        console.log('✓ Config file exists');
+    }
+    else {
+        console.log('✗ Config file not found (using defaults)');
+    }
+    const activePlugin = config.activePlugin ?? config.defaultPlugin;
+    const pluginConfig = config.plugins[activePlugin];
+    if (pluginConfig && Object.keys(pluginConfig).length > 0) {
+        console.log(`✓ Plugin "${activePlugin}" has configuration`);
+    }
+    else {
+        console.log(`✗ Plugin "${activePlugin}" has no configuration`);
+    }
+    try {
+        const res = await new Promise((resolve, reject) => {
+            http
+                .get(`http://${config.host}:${config.port}/health`, (res) => {
+                resolve(res.statusCode ?? 0);
+            })
+                .on('error', reject);
+        });
+        if (res === 200) {
+            console.log('✓ Bridge server is running');
+        }
+        else {
+            console.log(`✗ Bridge server returned status ${res}`);
+        }
+    }
+    catch {
+        console.log('✗ Cannot reach bridge server (is it running?)');
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            const server = http.createServer();
+            server.listen(config.port, config.host, () => {
+                server.close();
+                resolve();
+            });
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    reject(new Error('Port in use'));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        console.log(`✓ Port ${config.port} is available`);
+    }
+    catch {
+        console.log(`✗ Port ${config.port} is already in use`);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,87 @@
+import { setPluginConfig, writeConfig, readConfig } from '../utils/config.js';
+import { CursorBridgePlugin } from '@ai-ide-bridge/cursor';
+import { CopilotBridgePlugin } from '@ai-ide-bridge/copilot';
+import { WindsurfBridgePlugin } from '@ai-ide-bridge/windsurf';
+import { createInterface } from 'node:readline';
+const PROVIDERS = ['cursor', 'copilot', 'windsurf'];
+async function getProviderPlugin(provider) {
+    switch (provider) {
+        case 'cursor':
+            return new CursorBridgePlugin();
+        case 'copilot':
+            return new CopilotBridgePlugin();
+        case 'windsurf':
+            return new WindsurfBridgePlugin();
+    }
+}
+function getCredentialPrompt(provider) {
+    switch (provider) {
+        case 'cursor':
+            return 'Enter your CURSOR_API_KEY: ';
+        case 'copilot':
+            return 'Enter your GITHUB_TOKEN: ';
+        case 'windsurf':
+            return 'Enter your WINDSURF_TOKEN: ';
+    }
+}
+function getEnvVar(provider) {
+    switch (provider) {
+        case 'cursor':
+            return 'CURSOR_API_KEY';
+        case 'copilot':
+            return 'GITHUB_TOKEN';
+        case 'windsurf':
+            return 'WINDSURF_TOKEN';
+    }
+}
+export async function initCommand() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log('llm-bridge setup wizard\n');
+    const existingConfig = readConfig();
+    const configuredProviders = Object.keys(existingConfig.plugins || {});
+    if (configuredProviders.length > 0) {
+        console.log(`Already configured: ${configuredProviders.join(', ')}\n`);
+    }
+    let firstProvider = null;
+    while (true) {
+        const available = PROVIDERS.filter((p) => !configuredProviders.includes(p));
+        if (available.length === 0) {
+            console.log('All providers already configured.');
+            break;
+        }
+        const input = await ask(`Provider to configure (${available.join(', ')}, or 'skip'): `);
+        if (input === 'skip' || !PROVIDERS.includes(input)) {
+            break;
+        }
+        const provider = input;
+        const envVar = getEnvVar(provider);
+        const credential = await ask(getCredentialPrompt(provider));
+        if (!credential) {
+            console.error('Credential is required.');
+            continue;
+        }
+        const plugin = await getProviderPlugin(provider);
+        const valid = await plugin.authenticate({ [envVar]: credential });
+        if (!valid) {
+            console.error('Authentication failed. Please check your credential and try again.');
+            continue;
+        }
+        console.log(`Authentication successful for ${provider}.`);
+        setPluginConfig(provider, { [envVar]: credential });
+        configuredProviders.push(provider);
+        if (!firstProvider) {
+            firstProvider = provider;
+        }
+        const more = await ask('Configure another provider? (y/n): ');
+        if (more.toLowerCase() !== 'y')
+            break;
+    }
+    const config = readConfig();
+    if (!config.defaultPlugin && firstProvider) {
+        config.defaultPlugin = firstProvider;
+        writeConfig(config);
+    }
+    console.log(`\nConfig saved. Run 'llm-bridge start' to launch.`);
+    rl.close();
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(): Promise<void>;

package/dist/commands/start.js

@@ -0,0 +1,60 @@
+import { BridgeServer, loadConfig } from '@ai-ide-bridge/core';
+import { CursorBridgePlugin } from '@ai-ide-bridge/cursor';
+import { CopilotBridgePlugin } from '@ai-ide-bridge/copilot';
+import { WindsurfBridgePlugin } from '@ai-ide-bridge/windsurf';
+async function getPlugin(name) {
+    switch (name) {
+        case 'cursor':
+            return new CursorBridgePlugin();
+        case 'copilot':
+            return new CopilotBridgePlugin();
+        case 'windsurf':
+            return new WindsurfBridgePlugin();
+        default:
+            return null;
+    }
+}
+export async function startCommand() {
+    const config = loadConfig();
+    const server = new BridgeServer(config);
+    // Register all configured plugins
+    const pluginNames = Object.keys(config.plugins);
+    if (pluginNames.length === 0) {
+        console.error('[llm-bridge] error: no plugins configured. Run: llm-bridge init');
+        process.exit(1);
+    }
+    for (const name of pluginNames) {
+        const plugin = await getPlugin(name);
+        if (plugin) {
+            server.registerPlugin(plugin);
+            console.error(`[llm-bridge] registered plugin: ${name}`);
+        }
+        else {
+            console.error(`[llm-bridge] warning: unknown plugin "${name}"`);
+        }
+    }
+    // Set default plugin for fallback routing
+    if (config.defaultPlugin) {
+        server.setDefaultPlugin(config.defaultPlugin);
+        console.error(`[llm-bridge] default plugin: ${config.defaultPlugin}`);
+    }
+    try {
+        await server.start();
+    }
+    catch (err) {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`[llm-bridge] error: port ${config.port} is already in use`);
+        }
+        else {
+            console.error(`[llm-bridge] error: ${err.message}`);
+        }
+        process.exit(1);
+    }
+    const shutdown = async () => {
+        console.error('\n[llm-bridge] shutting down...');
+        await server.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { configureOpencodeCommand } from './commands/configure.js';
+import { doctorCommand } from './commands/doctor.js';
+import { daemonStatusCommand, daemonDownloadCommand, daemonLocateCommand, } from './commands/daemon.js';
+import { installDaemonCommand, uninstallDaemonCommand } from './commands/daemon.js';
+const command = process.argv[2] ?? 'help';
+async function main() {
+    switch (command) {
+        case 'init':
+            await initCommand();
+            break;
+        case 'start':
+            await startCommand();
+            break;
+        case 'configure':
+            await configureOpencodeCommand();
+            break;
+        case 'doctor':
+            await doctorCommand();
+            break;
+        case 'install-daemon':
+            await installDaemonCommand();
+            break;
+        case 'uninstall-daemon':
+            await uninstallDaemonCommand();
+            break;
+        case 'daemon': {
+            const subcommand = process.argv[3] ?? 'status';
+            switch (subcommand) {
+                case 'status':
+                    await daemonStatusCommand();
+                    break;
+                case 'download':
+                    await daemonDownloadCommand();
+                    break;
+                case 'locate':
+                    await daemonLocateCommand();
+                    break;
+                default:
+                    console.log('Usage: llm-bridge daemon [status|download|locate]');
+            }
+            break;
+        }
+        case 'help':
+        default:
+            console.log(`llm-bridge v1.0.0
+
+Usage:
+  llm-bridge init              Interactive setup wizard (configure one or more providers)
+  llm-bridge start             Launch bridge server (all configured plugins registered)
+  llm-bridge configure         Inject OpenCode config for the default provider
+  llm-bridge doctor            Run diagnostics
+  llm-bridge install-daemon    Install macOS LaunchAgent
+  llm-bridge uninstall-daemon  Remove macOS LaunchAgent
+  llm-bridge daemon [status|download|locate]  Manage Windsurf daemon binary
+  llm-bridge help              Show this help`);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/utils/config.d.ts

@@ -0,0 +1,4 @@
+import { BridgeConfig } from '@ai-ide-bridge/core';
+export declare function readConfig(): BridgeConfig;
+export declare function writeConfig(config: BridgeConfig): void;
+export declare function setPluginConfig(pluginName: string, envVars: Record<string, string>): void;

package/dist/utils/config.js

@@ -0,0 +1,15 @@
+import { loadConfig, saveConfig } from '@ai-ide-bridge/core';
+export function readConfig() {
+    return loadConfig();
+}
+export function writeConfig(config) {
+    saveConfig(config);
+}
+export function setPluginConfig(pluginName, envVars) {
+    const config = readConfig();
+    config.plugins[pluginName] = { ...config.plugins[pluginName], ...envVars };
+    if (!config.defaultPlugin) {
+        config.defaultPlugin = pluginName;
+    }
+    writeConfig(config);
+}

package/dist/utils/opencode.d.ts

@@ -0,0 +1,2 @@
+export declare function findOpencodeConfig(): string | null;
+export declare function injectProvider(configPath: string, providerId: string, modelId: string, port: number): void;

package/dist/utils/opencode.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+export function findOpencodeConfig() {
+    const candidates = [
+        path.join(os.homedir(), '.config', 'opencode', 'opencode.json'),
+        path.join(os.homedir(), '.config', 'opencode', 'opencode.jsonc'),
+        path.join(process.cwd(), 'opencode.json'),
+        path.join(process.cwd(), 'opencode.jsonc'),
+    ];
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+export function injectProvider(configPath, providerId, modelId, port) {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse ${configPath}: ${e.message}`);
+    }
+    if (!config.provider)
+        config.provider = {};
+    config.provider[providerId] = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'LLM Bridge',
+        options: {
+            apiKey: 'bridge-local',
+            baseURL: `http://127.0.0.1:${port}/v1`,
+        },
+        models: { [modelId]: { name: modelId } },
+    };
+    config.model = `${providerId}/${modelId}`;
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@ai-ide-bridge/cli",
+  "version": "1.0.3",
+  "type": "module",
+  "bin": {
+    "llm-bridge": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@ai-ide-bridge/copilot": "workspace:*",
+    "@ai-ide-bridge/core": "workspace:*",
+    "@ai-ide-bridge/cursor": "workspace:*",
+    "@ai-ide-bridge/windsurf": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "vitest": "^2.0.0"
+  }
+}

package/scripts/llm-bridge-daemon.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BRIDGE_BIN="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/dist/index.js"
+
+if ! command -v node &>/dev/null; then
+  echo "llm-bridge: node is required." >&2
+  exit 1
+fi
+
+exec node "$BRIDGE_BIN" start

package/src/commands/configure.ts

@@ -0,0 +1,25 @@
+import { findOpencodeConfig, injectProvider } from '../utils/opencode.js';
+import { readConfig } from '../utils/config.js';
+
+export async function configureOpencodeCommand(): Promise<void> {
+  const configPath = findOpencodeConfig();
+  if (!configPath) {
+    console.error('No opencode.json found. Create one at ~/.config/opencode/opencode.json');
+    process.exit(1);
+  }
+
+  const bridgeConfig = readConfig();
+  const providerId = 'llm-bridge';
+  const plugin = bridgeConfig.defaultPlugin ?? 'cursor';
+  const modelId =
+    plugin === 'copilot'
+      ? 'copilot/gpt-4o-copilot'
+      : plugin === 'windsurf'
+        ? 'windsurf/claude-4.5-sonnet'
+        : 'cursor/composer-2';
+
+  injectProvider(configPath, providerId, modelId, bridgeConfig.port);
+  console.log(`Injected provider into ${configPath}`);
+  console.log(`Provider: ${providerId}, Model: ${modelId}, Port: ${bridgeConfig.port}`);
+  console.log(`Plugin: ${plugin}`);
+}

package/src/commands/daemon.ts

@@ -0,0 +1,120 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const LABEL = 'com.llm-bridge.daemon';
+
+export async function installDaemonCommand(): Promise<void> {
+  if (process.platform !== 'darwin') {
+    console.error('Daemon installation is only supported on macOS.');
+    process.exit(1);
+  }
+
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+  const wrapperPath = path.join(__dirname, '..', '..', 'scripts', 'llm-bridge-daemon.sh');
+
+  const plist = `<?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>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${wrapperPath}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>StandardOutPath</key>
+  <string>${os.homedir()}/Library/Logs/llm-bridge.log</string>
+  <key>StandardErrorPath</key>
+  <string>${os.homedir()}/Library/Logs/llm-bridge.err.log</string>
+</dict>
+</plist>`;
+
+  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+  fs.writeFileSync(plistPath, plist);
+
+  try {
+    execSync(`launchctl bootstrap "gui/$(id -u)" "${plistPath}"`, { stdio: 'inherit' });
+    console.log(`Installed LaunchAgent: ${plistPath}`);
+    console.log(`Logs: ~/Library/Logs/llm-bridge.{log,err.log}`);
+  } catch (e) {
+    console.error('Failed to bootstrap daemon:', e);
+    process.exit(1);
+  }
+}
+
+export async function uninstallDaemonCommand(): Promise<void> {
+  if (process.platform !== 'darwin') {
+    console.error('Daemon uninstallation is only supported on macOS.');
+    process.exit(1);
+  }
+
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+
+  try {
+    execSync(`launchctl bootout "gui/$(id -u)" "${plistPath}" 2>/dev/null || true`, {
+      stdio: 'inherit',
+    });
+  } catch {
+    // Ignore errors during unbootstrap
+  }
+
+  if (fs.existsSync(plistPath)) {
+    fs.unlinkSync(plistPath);
+    console.log(`Removed LaunchAgent: ${plistPath}`);
+  } else {
+    console.log('No LaunchAgent found.');
+  }
+}
+
+export async function daemonStatusCommand(): Promise<void> {
+  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
+  const daemon = createWindsurfDaemon();
+
+  const path = await daemon.locate();
+  if (path) {
+    console.log(`Windsurf language server found at: ${path}`);
+    const healthy = await daemon.healthCheck();
+    console.log(`Health: ${healthy ? 'OK' : 'Unhealthy'}`);
+  } else {
+    console.log('Windsurf language server not found.');
+    console.log('Run: llm-bridge daemon download');
+  }
+}
+
+export async function daemonDownloadCommand(): Promise<void> {
+  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
+  const daemon = createWindsurfDaemon();
+
+  console.log('Downloading Windsurf language server...');
+  try {
+    const path = await daemon.download();
+    console.log(`Downloaded to: ${path}`);
+  } catch (err: any) {
+    console.error(`Download failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+export async function daemonLocateCommand(): Promise<void> {
+  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
+  const daemon = createWindsurfDaemon();
+
+  const path = await daemon.locate();
+  if (path) {
+    console.log(path);
+  } else {
+    console.log('Not found');
+    process.exit(1);
+  }
+}

package/src/commands/doctor.ts

@@ -0,0 +1,65 @@
+import http from 'node:http';
+import { readConfig } from '../utils/config.js';
+import fs from 'node:fs';
+import { configPath } from '@ai-ide-bridge/core';
+
+export async function doctorCommand(): Promise<void> {
+  const config = readConfig();
+  console.log('llm-bridge diagnostics\n');
+  console.log(`Config: ${configPath()}`);
+  console.log(`Active plugin: ${config.activePlugin ?? config.defaultPlugin}`);
+  console.log(`Port: ${config.port}`);
+  console.log(`Host: ${config.host}`);
+  console.log(`Tool mode: ${config.toolMode}`);
+
+  if (fs.existsSync(configPath())) {
+    console.log('✓ Config file exists');
+  } else {
+    console.log('✗ Config file not found (using defaults)');
+  }
+
+  const activePlugin = config.activePlugin ?? config.defaultPlugin;
+  const pluginConfig = config.plugins[activePlugin];
+  if (pluginConfig && Object.keys(pluginConfig).length > 0) {
+    console.log(`✓ Plugin "${activePlugin}" has configuration`);
+  } else {
+    console.log(`✗ Plugin "${activePlugin}" has no configuration`);
+  }
+
+  try {
+    const res = await new Promise<number>((resolve, reject) => {
+      http
+        .get(`http://${config.host}:${config.port}/health`, (res) => {
+          resolve(res.statusCode ?? 0);
+        })
+        .on('error', reject);
+    });
+    if (res === 200) {
+      console.log('✓ Bridge server is running');
+    } else {
+      console.log(`✗ Bridge server returned status ${res}`);
+    }
+  } catch {
+    console.log('✗ Cannot reach bridge server (is it running?)');
+  }
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const server = http.createServer();
+      server.listen(config.port, config.host, () => {
+        server.close();
+        resolve();
+      });
+      server.on('error', (err: any) => {
+        if (err.code === 'EADDRINUSE') {
+          reject(new Error('Port in use'));
+        } else {
+          resolve();
+        }
+      });
+    });
+    console.log(`✓ Port ${config.port} is available`);
+  } catch {
+    console.log(`✗ Port ${config.port} is already in use`);
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,106 @@
+import { setPluginConfig, writeConfig, readConfig } from '../utils/config.js';
+import { CursorBridgePlugin } from '@ai-ide-bridge/cursor';
+import { CopilotBridgePlugin } from '@ai-ide-bridge/copilot';
+import { WindsurfBridgePlugin } from '@ai-ide-bridge/windsurf';
+import { createInterface } from 'node:readline';
+
+const PROVIDERS = ['cursor', 'copilot', 'windsurf'] as const;
+type Provider = (typeof PROVIDERS)[number];
+
+async function getProviderPlugin(provider: Provider) {
+  switch (provider) {
+    case 'cursor':
+      return new CursorBridgePlugin();
+    case 'copilot':
+      return new CopilotBridgePlugin();
+    case 'windsurf':
+      return new WindsurfBridgePlugin();
+  }
+}
+
+function getCredentialPrompt(provider: Provider): string {
+  switch (provider) {
+    case 'cursor':
+      return 'Enter your CURSOR_API_KEY: ';
+    case 'copilot':
+      return 'Enter your GITHUB_TOKEN: ';
+    case 'windsurf':
+      return 'Enter your WINDSURF_TOKEN: ';
+  }
+}
+
+function getEnvVar(provider: Provider): string {
+  switch (provider) {
+    case 'cursor':
+      return 'CURSOR_API_KEY';
+    case 'copilot':
+      return 'GITHUB_TOKEN';
+    case 'windsurf':
+      return 'WINDSURF_TOKEN';
+  }
+}
+
+export async function initCommand(): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q: string) => new Promise<string>((resolve) => rl.question(q, resolve));
+
+  console.log('llm-bridge setup wizard\n');
+
+  const existingConfig = readConfig();
+  const configuredProviders = Object.keys(existingConfig.plugins || {});
+  if (configuredProviders.length > 0) {
+    console.log(`Already configured: ${configuredProviders.join(', ')}\n`);
+  }
+
+  let firstProvider: Provider | null = null;
+
+  while (true) {
+    const available = PROVIDERS.filter((p) => !configuredProviders.includes(p));
+    if (available.length === 0) {
+      console.log('All providers already configured.');
+      break;
+    }
+
+    const input = await ask(`Provider to configure (${available.join(', ')}, or 'skip'): `);
+
+    if (input === 'skip' || !PROVIDERS.includes(input as Provider)) {
+      break;
+    }
+
+    const provider = input as Provider;
+
+    const envVar = getEnvVar(provider);
+    const credential = await ask(getCredentialPrompt(provider));
+    if (!credential) {
+      console.error('Credential is required.');
+      continue;
+    }
+
+    const plugin = await getProviderPlugin(provider);
+    const valid = await plugin.authenticate({ [envVar]: credential });
+    if (!valid) {
+      console.error('Authentication failed. Please check your credential and try again.');
+      continue;
+    }
+    console.log(`Authentication successful for ${provider}.`);
+
+    setPluginConfig(provider, { [envVar]: credential });
+    configuredProviders.push(provider);
+
+    if (!firstProvider) {
+      firstProvider = provider;
+    }
+
+    const more = await ask('Configure another provider? (y/n): ');
+    if (more.toLowerCase() !== 'y') break;
+  }
+
+  const config = readConfig();
+  if (!config.defaultPlugin && firstProvider) {
+    config.defaultPlugin = firstProvider;
+    writeConfig(config);
+  }
+
+  console.log(`\nConfig saved. Run 'llm-bridge start' to launch.`);
+  rl.close();
+}

package/src/commands/start.ts

@@ -0,0 +1,65 @@
+import { BridgeServer, loadConfig } from '@ai-ide-bridge/core';
+import { CursorBridgePlugin } from '@ai-ide-bridge/cursor';
+import { CopilotBridgePlugin } from '@ai-ide-bridge/copilot';
+import { WindsurfBridgePlugin } from '@ai-ide-bridge/windsurf';
+
+async function getPlugin(name: string) {
+  switch (name) {
+    case 'cursor':
+      return new CursorBridgePlugin();
+    case 'copilot':
+      return new CopilotBridgePlugin();
+    case 'windsurf':
+      return new WindsurfBridgePlugin();
+    default:
+      return null;
+  }
+}
+
+export async function startCommand(): Promise<void> {
+  const config = loadConfig();
+  const server = new BridgeServer(config);
+
+  // Register all configured plugins
+  const pluginNames = Object.keys(config.plugins);
+  if (pluginNames.length === 0) {
+    console.error('[llm-bridge] error: no plugins configured. Run: llm-bridge init');
+    process.exit(1);
+  }
+
+  for (const name of pluginNames) {
+    const plugin = await getPlugin(name);
+    if (plugin) {
+      server.registerPlugin(plugin);
+      console.error(`[llm-bridge] registered plugin: ${name}`);
+    } else {
+      console.error(`[llm-bridge] warning: unknown plugin "${name}"`);
+    }
+  }
+
+  // Set default plugin for fallback routing
+  if (config.defaultPlugin) {
+    server.setDefaultPlugin(config.defaultPlugin);
+    console.error(`[llm-bridge] default plugin: ${config.defaultPlugin}`);
+  }
+
+  try {
+    await server.start();
+  } catch (err: any) {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`[llm-bridge] error: port ${config.port} is already in use`);
+    } else {
+      console.error(`[llm-bridge] error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+
+  const shutdown = async () => {
+    console.error('\n[llm-bridge] shutting down...');
+    await server.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/src/index.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { configureOpencodeCommand } from './commands/configure.js';
+import { doctorCommand } from './commands/doctor.js';
+import {
+  daemonStatusCommand,
+  daemonDownloadCommand,
+  daemonLocateCommand,
+} from './commands/daemon.js';
+import { installDaemonCommand, uninstallDaemonCommand } from './commands/daemon.js';
+
+const command = process.argv[2] ?? 'help';
+
+async function main(): Promise<void> {
+  switch (command) {
+    case 'init':
+      await initCommand();
+      break;
+    case 'start':
+      await startCommand();
+      break;
+    case 'configure':
+      await configureOpencodeCommand();
+      break;
+    case 'doctor':
+      await doctorCommand();
+      break;
+    case 'install-daemon':
+      await installDaemonCommand();
+      break;
+    case 'uninstall-daemon':
+      await uninstallDaemonCommand();
+      break;
+    case 'daemon': {
+      const subcommand = process.argv[3] ?? 'status';
+      switch (subcommand) {
+        case 'status':
+          await daemonStatusCommand();
+          break;
+        case 'download':
+          await daemonDownloadCommand();
+          break;
+        case 'locate':
+          await daemonLocateCommand();
+          break;
+        default:
+          console.log('Usage: llm-bridge daemon [status|download|locate]');
+      }
+      break;
+    }
+    case 'help':
+    default:
+      console.log(`llm-bridge v1.0.0
+
+Usage:
+  llm-bridge init              Interactive setup wizard (configure one or more providers)
+  llm-bridge start             Launch bridge server (all configured plugins registered)
+  llm-bridge configure         Inject OpenCode config for the default provider
+  llm-bridge doctor            Run diagnostics
+  llm-bridge install-daemon    Install macOS LaunchAgent
+  llm-bridge uninstall-daemon  Remove macOS LaunchAgent
+  llm-bridge daemon [status|download|locate]  Manage Windsurf daemon binary
+  llm-bridge help              Show this help`);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/utils/config.ts

@@ -0,0 +1,18 @@
+import { loadConfig, saveConfig, BridgeConfig } from '@ai-ide-bridge/core';
+
+export function readConfig(): BridgeConfig {
+  return loadConfig();
+}
+
+export function writeConfig(config: BridgeConfig): void {
+  saveConfig(config);
+}
+
+export function setPluginConfig(pluginName: string, envVars: Record<string, string>): void {
+  const config = readConfig();
+  config.plugins[pluginName] = { ...config.plugins[pluginName], ...envVars };
+  if (!config.defaultPlugin) {
+    config.defaultPlugin = pluginName;
+  }
+  writeConfig(config);
+}

package/src/utils/opencode.ts

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function findOpencodeConfig(): string | null {
+  const candidates = [
+    path.join(os.homedir(), '.config', 'opencode', 'opencode.json'),
+    path.join(os.homedir(), '.config', 'opencode', 'opencode.jsonc'),
+    path.join(process.cwd(), 'opencode.json'),
+    path.join(process.cwd(), 'opencode.jsonc'),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+export function injectProvider(
+  configPath: string,
+  providerId: string,
+  modelId: string,
+  port: number,
+): void {
+  const raw = fs.readFileSync(configPath, 'utf8');
+  let config: any;
+  try {
+    config = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Failed to parse ${configPath}: ${(e as Error).message}`);
+  }
+  if (!config.provider) config.provider = {};
+  config.provider[providerId] = {
+    npm: '@ai-sdk/openai-compatible',
+    name: 'LLM Bridge',
+    options: {
+      apiKey: 'bridge-local',
+      baseURL: `http://127.0.0.1:${port}/v1`,
+    },
+    models: { [modelId]: { name: modelId } },
+  };
+  config.model = `${providerId}/${modelId}`;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}

package/test/configure.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { injectProvider } from '../src/utils/opencode.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+describe('opencode utils', () => {
+  let tmpFile: string;
+
+  beforeEach(() => {
+    tmpFile = path.join(os.tmpdir(), `opencode-test-${Date.now()}.json`);
+    fs.writeFileSync(tmpFile, '{}');
+  });
+
+  it('injects provider into empty config', () => {
+    injectProvider(tmpFile, 'test-provider', 'test-model', 3849);
+    const config = JSON.parse(fs.readFileSync(tmpFile, 'utf8'));
+    expect(config.provider['test-provider']).toBeDefined();
+    expect(config.provider['test-provider'].options.baseURL).toBe('http://127.0.0.1:3849/v1');
+    expect(config.model).toBe('test-provider/test-model');
+  });
+
+  it('preserves existing config fields', () => {
+    fs.writeFileSync(tmpFile, JSON.stringify({ existing: 'value' }));
+    injectProvider(tmpFile, 'test-provider', 'test-model', 3849);
+    const config = JSON.parse(fs.readFileSync(tmpFile, 'utf8'));
+    expect(config.existing).toBe('value');
+    expect(config.provider['test-provider']).toBeDefined();
+  });
+});

package/test/init.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+describe('initCommand', () => {
+  let tmpDir: string;
+  let configDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'llm-bridge-init-test-'));
+    configDir = path.join(tmpDir, '.config', 'llm-bridge');
+    fs.mkdirSync(configDir, { recursive: true });
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('writes config with single provider', async () => {
+    const config = {
+      defaultPlugin: 'cursor',
+      port: 3849,
+      host: '127.0.0.1',
+      plugins: { cursor: { CURSOR_API_KEY: 'test-api-key' } },
+      sessionTTL: 1800,
+      toolMode: 'lenient',
+    };
+
+    const configPath = path.join(configDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    const loaded = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+    expect(loaded.defaultPlugin).toBe('cursor');
+    expect(loaded.plugins.cursor.CURSOR_API_KEY).toBe('test-api-key');
+  });
+
+  it('writes config with multiple providers', async () => {
+    const config = {
+      defaultPlugin: 'cursor',
+      port: 3849,
+      host: '127.0.0.1',
+      plugins: {
+        cursor: { CURSOR_API_KEY: 'test-api-key' },
+        windsurf: { WINDSURF_TOKEN: 'test-windsurf-token' },
+      },
+      sessionTTL: 1800,
+      toolMode: 'lenient',
+    };
+
+    const configPath = path.join(configDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    const loaded = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+    expect(loaded.defaultPlugin).toBe('cursor');
+    expect(loaded.plugins.cursor.CURSOR_API_KEY).toBe('test-api-key');
+    expect(loaded.plugins.windsurf.WINDSURF_TOKEN).toBe('test-windsurf-token');
+  });
+});

package/test/start.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+
+describe('startCommand', () => {
+  it('registers all configured plugins', async () => {
+    // This is an integration test — verify config loading works
+    const { readConfig } = await import('../src/utils/config.js');
+    const config = readConfig();
+
+    // Config should have defaultPlugin field
+    expect(config.defaultPlugin).toBeDefined();
+    expect(typeof config.defaultPlugin).toBe('string');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}