@ai-ide-bridge/cli 1.0.5 → 1.1.1

package/dist/plugins/cursor/plugin.js

@@ -0,0 +1,36 @@
+import { Cursor } from '@cursor/sdk';
+import { CursorBridgeSession } from './session.js';
+export class CursorBridgePlugin {
+    name = 'cursor';
+    version = '2.0.0';
+    async authenticate(config) {
+        const apiKey = config.CURSOR_API_KEY;
+        if (!apiKey)
+            return false;
+        try {
+            await Cursor.me({ apiKey });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async listModels(config) {
+        const apiKey = config.CURSOR_API_KEY;
+        if (!apiKey)
+            throw new Error('Missing CURSOR_API_KEY');
+        const models = await Cursor.models.list({ apiKey });
+        return models.map((m) => ({
+            id: m.id,
+            name: m.id,
+            capabilities: { streaming: true, tools: true },
+        }));
+    }
+    async createSession(config, model) {
+        const apiKey = config.CURSOR_API_KEY;
+        if (!apiKey)
+            throw new Error('Missing CURSOR_API_KEY');
+        const cwd = config.CURSOR_OPENCODE_BRIDGE_CWD ?? process.cwd();
+        return new CursorBridgeSession(apiKey, model, cwd);
+    }
+}

package/dist/plugins/cursor/session.d.ts

@@ -0,0 +1,11 @@
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '../../core/index.js';
+export declare class CursorBridgeSession implements BridgeSession {
+    private agent;
+    private apiKey;
+    private modelId;
+    private cwd;
+    constructor(apiKey: string, modelId: string, cwd?: string);
+    send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk>;
+    dispose(): Promise<void>;
+    private buildPrompt;
+}

package/dist/plugins/cursor/session.js

@@ -0,0 +1,69 @@
+import { Agent } from '@cursor/sdk';
+import { translateTools } from './tools.js';
+export class CursorBridgeSession {
+    agent = null;
+    apiKey;
+    modelId;
+    cwd;
+    constructor(apiKey, modelId, cwd = process.cwd()) {
+        this.apiKey = apiKey;
+        this.modelId = modelId;
+        this.cwd = cwd;
+    }
+    async *send(messages, tools) {
+        const prompt = this.buildPrompt(messages);
+        const cursorTools = tools ? translateTools(tools) : undefined;
+        try {
+            this.agent = await Agent.create({
+                apiKey: this.apiKey,
+                model: { id: this.modelId },
+                local: { cwd: this.cwd, settingSources: [] },
+            });
+            const sendOptions = {
+                model: { id: this.modelId },
+                onDelta: ({ update }) => {
+                    if (update.type === 'text-delta' && 'text' in update && update.text) {
+                        // onDelta is synchronous callback, we buffer and yield in the loop
+                    }
+                },
+            };
+            const run = await this.agent.send(prompt, sendOptions);
+            const result = await run.wait();
+            if (result.status === 'error' || result.status === 'cancelled') {
+                yield {
+                    type: 'error',
+                    content: `Agent run ${result.status}: ${result.result ?? 'no details'}`,
+                    finishReason: 'error',
+                };
+                return;
+            }
+            yield { type: 'text', content: result.result ?? '', finishReason: 'stop' };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            yield { type: 'error', content: msg, finishReason: 'error' };
+        }
+    }
+    async dispose() {
+        if (this.agent) {
+            try {
+                await this.agent[Symbol.asyncDispose]();
+            }
+            catch {
+                // Ignore dispose errors
+            }
+            this.agent = null;
+        }
+    }
+    buildPrompt(messages) {
+        const blocks = [];
+        for (const m of messages) {
+            const text = typeof m.content === 'string' ? m.content : '';
+            if (!text)
+                continue;
+            const label = m.role === 'tool' ? `tool (${m.tool_call_id ?? m.name ?? 'result'})` : m.role;
+            blocks.push(`[${label}]\n${text}`);
+        }
+        return `\nFollow this conversation transcript and reply as the assistant.\n\n${blocks.join('\n\n---\n\n')}\n`;
+    }
+}

package/dist/plugins/cursor/tools.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from '../../core/index.js';
+export interface CursorTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function translateTools(tools: ToolDefinition[]): CursorTool[];
+export declare function translateToolResult(toolCallId: string, result: string): string;

package/dist/plugins/cursor/tools.js

@@ -0,0 +1,13 @@
+export function translateTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+        },
+    }));
+}
+export function translateToolResult(toolCallId, result) {
+    return `[tool result for ${toolCallId}]\n${result}`;
+}

package/dist/plugins/windsurf/auth.d.ts

@@ -0,0 +1,3 @@
+import type { WindsurfConfig } from './types.js';
+export declare function getToken(config: WindsurfConfig): string | null;
+export declare function validateToken(token: string): Promise<boolean>;

package/dist/plugins/windsurf/auth.js

@@ -0,0 +1,20 @@
+const WINDSURF_API_BASE = 'https://server.codeium.com';
+export function getToken(config) {
+    return config.WINDSURF_TOKEN ?? config.WINDSURF_OAUTH_TOKEN ?? null;
+}
+export async function validateToken(token) {
+    try {
+        const response = await fetch(`${WINDSURF_API_BASE}/api/v1/validate_token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ token }),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plugins/windsurf/daemon.d.ts

@@ -0,0 +1,6 @@
+import { type DaemonManager } from '../../core/index.js';
+interface WindsurfDaemonOptions {
+    knownPaths?: string[];
+}
+export declare function createWindsurfDaemon(options?: WindsurfDaemonOptions): DaemonManager;
+export {};

package/dist/plugins/windsurf/daemon.js

@@ -0,0 +1,16 @@
+import { createDaemonManager } from '../../core/index.js';
+import { join } from 'node:path';
+const DEFAULT_KNOWN_PATHS = [
+    join('/Applications', 'Windsurf.app', 'Contents', 'Resources', 'language_server'),
+    join('/usr', 'local', 'bin', 'language_server'),
+];
+export function createWindsurfDaemon(options = {}) {
+    const knownPaths = options.knownPaths ?? DEFAULT_KNOWN_PATHS;
+    return createDaemonManager({
+        binaryName: 'language_server',
+        downloadUrl: `https://server.codeium.com/language_server/latest/{platform}/{arch}`,
+        checksum: 'PLACEHOLDER_SHA256',
+        knownPaths,
+        envVar: 'WINDSURF_LANGUAGE_SERVER_PATH',
+    });
+}

package/dist/plugins/windsurf/index.d.ts

@@ -0,0 +1,5 @@
+export { WindsurfBridgePlugin } from './plugin.js';
+export { WINDSURF_MODELS } from './models.js';
+export { createWindsurfDaemon } from './daemon.js';
+export { WindsurfBridgeSession } from './session.js';
+export type { WindsurfModel, WindsurfConfig } from './types.js';

package/dist/plugins/windsurf/index.js

@@ -0,0 +1,4 @@
+export { WindsurfBridgePlugin } from './plugin.js';
+export { WINDSURF_MODELS } from './models.js';
+export { createWindsurfDaemon } from './daemon.js';
+export { WindsurfBridgeSession } from './session.js';

package/dist/plugins/windsurf/models.d.ts

@@ -0,0 +1,2 @@
+import type { WindsurfModel } from './types.js';
+export declare const WINDSURF_MODELS: WindsurfModel[];

package/dist/plugins/windsurf/models.js

@@ -0,0 +1,42 @@
+export const WINDSURF_MODELS = [
+    {
+        id: 'claude-4.5-sonnet',
+        name: 'Claude 4.5 Sonnet (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'claude-4.5-opus',
+        name: 'Claude 4.5 Opus (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gpt-5.2',
+        name: 'GPT-5.2 (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gpt-5.2-codex',
+        name: 'GPT-5.2 Codex (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gpt-4o',
+        name: 'GPT-4o (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gemini-3.0-pro',
+        name: 'Gemini 3.0 Pro (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'gemini-3.0-flash',
+        name: 'Gemini 3.0 Flash (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+    {
+        id: 'swe-1.5',
+        name: 'SWE-1.5 (Windsurf)',
+        capabilities: { streaming: true, tools: true },
+    },
+];

package/dist/plugins/windsurf/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { BridgePlugin, BridgeSession, ModelInfo } from '../../core/index.js';
+export declare class WindsurfBridgePlugin implements BridgePlugin {
+    name: string;
+    version: string;
+    authenticate(config: Record<string, string>): Promise<boolean>;
+    listModels(config: Record<string, string>): Promise<ModelInfo[]>;
+    createSession(config: Record<string, string>, model: string): Promise<BridgeSession>;
+}

package/dist/plugins/windsurf/plugin.js

@@ -0,0 +1,31 @@
+import { WindsurfBridgeSession } from './session.js';
+import { WINDSURF_MODELS } from './models.js';
+import { getToken, validateToken } from './auth.js';
+import { createWindsurfDaemon } from './daemon.js';
+export class WindsurfBridgePlugin {
+    name = 'windsurf';
+    version = '2.0.0';
+    async authenticate(config) {
+        const token = getToken(config);
+        if (!token)
+            return false;
+        return validateToken(token);
+    }
+    async listModels(config) {
+        const token = getToken(config);
+        if (!token)
+            throw new Error('Missing WINDSURF_TOKEN');
+        return WINDSURF_MODELS.map((m) => ({
+            id: m.id,
+            name: m.name,
+            capabilities: m.capabilities,
+        }));
+    }
+    async createSession(config, model) {
+        const token = getToken(config);
+        if (!token)
+            throw new Error('Missing WINDSURF_TOKEN');
+        const daemon = createWindsurfDaemon();
+        return new WindsurfBridgeSession(daemon, token, model);
+    }
+}

package/dist/plugins/windsurf/session.d.ts

@@ -0,0 +1,5 @@
+import { DaemonBridgeSession } from '../../core/index.js';
+import type { DaemonManager } from '../../core/index.js';
+export declare class WindsurfBridgeSession extends DaemonBridgeSession {
+    constructor(daemon: DaemonManager, token: string, model: string, cwd?: string);
+}

package/dist/plugins/windsurf/session.js

@@ -0,0 +1,6 @@
+import { DaemonBridgeSession } from '../../core/index.js';
+export class WindsurfBridgeSession extends DaemonBridgeSession {
+    constructor(daemon, token, model, cwd = process.cwd()) {
+        super(daemon, token, model, cwd);
+    }
+}

package/dist/plugins/windsurf/tools.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from '../../core/index.js';
+import type { WindsurfTool } from './types.js';
+export declare function translateTools(tools: ToolDefinition[]): WindsurfTool[];

package/dist/plugins/windsurf/tools.js

@@ -0,0 +1,10 @@
+export function translateTools(tools) {
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+        },
+    }));
+}

package/dist/plugins/windsurf/types.d.ts

@@ -0,0 +1,22 @@
+export interface WindsurfModel {
+    id: string;
+    name: string;
+    capabilities: {
+        streaming: boolean;
+        tools: boolean;
+        vision?: boolean;
+    };
+}
+export interface WindsurfConfig {
+    WINDSURF_TOKEN?: string;
+    WINDSURF_OAUTH_TOKEN?: string;
+    WINDSURF_LANGUAGE_SERVER_PATH?: string;
+}
+export interface WindsurfTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}

package/dist/plugins/windsurf/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/config.d.ts

@@ -1,4 +1,4 @@
-import { BridgeConfig } from '@ai-ide-bridge/core';
+import { BridgeConfig } from '../core/index.js';
 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

@@ -1,4 +1,4 @@
-import { loadConfig, saveConfig } from '@ai-ide-bridge/core';
+import { loadConfig, saveConfig } from '../core/index.js';
 export function readConfig() {
     return loadConfig();
 }

package/dist/utils/opencode.d.ts

@@ -1,2 +1,4 @@
 export declare function findOpencodeConfig(): string | null;
-export declare function injectProvider(configPath: string, providerId: string, modelId: string, port: number): void;
+export declare function injectProvider(configPath: string, providerId: string, models: Record<string, {
+    name: string;
+}>, port: number, defaultModelId: string): void;

package/dist/utils/opencode.js

@@ -14,7 +14,7 @@ export function findOpencodeConfig() {
     }
     return null;
 }
-export function injectProvider(configPath, providerId, modelId, port) {
+export function injectProvider(configPath, providerId, models, port, defaultModelId) {
     const raw = fs.readFileSync(configPath, 'utf8');
     let config;
     try {
@@ -32,8 +32,8 @@ export function injectProvider(configPath, providerId, modelId, port) {
             apiKey: 'bridge-local',
             baseURL: `http://127.0.0.1:${port}/v1`,
         },
-        models: { [modelId]: { name: modelId } },
+        models,
     };
-    config.model = `${providerId}/${modelId}`;
+    config.model = `${providerId}/${defaultModelId}`;
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }

package/dist/utils/platform.d.ts

@@ -0,0 +1 @@
+export declare function getPlatform(): NodeJS.Platform;

package/dist/utils/platform.js

@@ -0,0 +1,3 @@
+export function getPlatform() {
+    return process.platform;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ide-bridge/cli",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "type": "module",
   "bin": {
     "llm-bridge": "./dist/index.js"
@@ -14,10 +14,8 @@
     "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:*"
+    "@cursor/sdk": "^1.0.13",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",

package/src/commands/configure.ts

@@ -1,5 +1,21 @@
 import { findOpencodeConfig, injectProvider } from '../utils/opencode.js';
 import { readConfig } from '../utils/config.js';
+import { createInterface } from 'node:readline';
+import { CursorBridgePlugin } from '../plugins/cursor/index.js';
+import { CopilotBridgePlugin } from '../plugins/copilot/index.js';
+import { WindsurfBridgePlugin } from '../plugins/windsurf/index.js';
+
+const PROVIDER_PLUGINS: Record<
+  string,
+  new () => {
+    name: string;
+    listModels(config: Record<string, string>): Promise<{ id: string; name: string }[]>;
+  }
+> = {
+  cursor: CursorBridgePlugin,
+  copilot: CopilotBridgePlugin,
+  windsurf: WindsurfBridgePlugin,
+};
 
 export async function configureOpencodeCommand(): Promise<void> {
   const configPath = findOpencodeConfig();
@@ -9,17 +25,96 @@ export async function configureOpencodeCommand(): Promise<void> {
   }
 
   const bridgeConfig = readConfig();
+  const configuredPlugins = Object.keys(bridgeConfig.plugins || {});
+
+  if (configuredPlugins.length === 0) {
+    console.error('No plugins configured. Run `llm-bridge init` first.');
+    process.exit(1);
+  }
+
+  const allSelectedModels: Record<string, { name: string }> = {};
+  let firstSelectedModelId: string | null = null;
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q: string) => new Promise<string>((resolve) => rl.question(q, resolve));
+
+  for (const pluginName of configuredPlugins) {
+    const PluginClass = PROVIDER_PLUGINS[pluginName];
+    if (!PluginClass) {
+      console.warn(`Skipping unknown provider: ${pluginName}`);
+      continue;
+    }
+
+    const plugin = new PluginClass();
+    const pluginConfig = bridgeConfig.plugins[pluginName];
+
+    let models: { id: string; name: string }[];
+    try {
+      models = await plugin.listModels(pluginConfig);
+    } catch (e) {
+      console.warn(
+        `Failed to list models for ${pluginName}: ${e instanceof Error ? e.message : String(e)}`,
+      );
+      continue;
+    }
+
+    if (models.length === 0) {
+      console.warn(`No models available for ${pluginName}.`);
+      continue;
+    }
+
+    console.log(`\nModels available for ${pluginName}:`);
+    models.forEach((m, i) => {
+      console.log(`  ${i + 1}) ${pluginName}/${m.id}`);
+    });
+
+    const input = await ask(`Select models (comma-separated numbers, 'all', or 'skip'): `);
+
+    let selectedIndices: number[] = [];
+
+    if (input.toLowerCase() === 'all') {
+      selectedIndices = models.map((_, i) => i);
+    } else if (input.toLowerCase() === 'skip') {
+      continue;
+    } else {
+      selectedIndices = input
+        .split(',')
+        .map((s) => parseInt(s.trim(), 10) - 1)
+        .filter((i) => i >= 0 && i < models.length);
+    }
+
+    if (selectedIndices.length === 0) {
+      console.log(`No models selected for ${pluginName}. Skipping.`);
+      continue;
+    }
+
+    for (const idx of selectedIndices) {
+      const model = models[idx];
+      const qualifiedId = `${pluginName}/${model.id}`;
+      allSelectedModels[qualifiedId] = { name: qualifiedId };
+      if (!firstSelectedModelId) {
+        firstSelectedModelId = qualifiedId;
+      }
+    }
+  }
+
+  rl.close();
+
+  if (Object.keys(allSelectedModels).length === 0) {
+    console.error('No models selected. Run `llm-bridge configure` again to try again.');
+    process.exit(1);
+  }
+
   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}`);
+  injectProvider(
+    configPath,
+    providerId,
+    allSelectedModels,
+    bridgeConfig.port,
+    firstSelectedModelId!,
+  );
+
+  const modelCount = Object.keys(allSelectedModels).length;
+  console.log(`\nInjected provider into ${configPath}`);
+  console.log(`Provider: ${providerId}, Models: ${modelCount}, Default: ${firstSelectedModelId}`);
 }