@ai-ide-bridge/cli 1.0.5 → 1.1.1

package/src/plugins/copilot/session.ts

@@ -0,0 +1,130 @@
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '../../core/index.js';
+import { translateTools } from './tools.js';
+
+const COPILOT_API_BASE = 'https://api.github.com';
+
+export class CopilotBridgeSession implements BridgeSession {
+  private token: string;
+  private modelId: string;
+
+  constructor(token: string, modelId: string) {
+    this.token = token;
+    this.modelId = modelId;
+  }
+
+  async *send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk> {
+    const body = {
+      model: this.modelId,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content ?? '',
+        ...(m.tool_calls && { tool_calls: m.tool_calls }),
+        ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+      })),
+      ...(tools && { tools: translateTools(tools) }),
+      stream: true,
+    };
+
+    try {
+      const response = await fetch(`${COPILOT_API_BASE}/copilot_internal/chat/completions`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          'Content-Type': 'application/json',
+          Accept: 'text/event-stream',
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        yield {
+          type: 'error',
+          content: `Copilot API error: ${response.status} ${errorText}`,
+          finishReason: 'error',
+        };
+        return;
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        yield { type: 'error', content: 'No response body', finishReason: 'error' };
+        return;
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let finished = false;
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data:')) continue;
+
+          const data = trimmed.slice(5).trim();
+          if (data === '[DONE]') {
+            if (!finished) {
+              yield { type: 'done', finishReason: 'stop' };
+            }
+            return;
+          }
+
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta;
+
+            if (delta?.content) {
+              yield { type: 'text', content: delta.content };
+            }
+
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                yield {
+                  type: 'tool_call',
+                  toolCall: {
+                    id: tc.id ?? '',
+                    name: tc.function?.name ?? '',
+                    arguments: tc.function?.arguments ?? '',
+                  },
+                };
+              }
+            }
+
+            if (parsed.choices?.[0]?.finish_reason && !finished) {
+              const reason = parsed.choices[0].finish_reason;
+              const finishReason =
+                reason === 'stop'
+                  ? 'stop'
+                  : reason === 'tool_calls'
+                    ? 'tool_calls'
+                    : reason === 'length'
+                      ? 'length'
+                      : 'error';
+              yield {
+                type: 'done',
+                finishReason,
+              };
+              finished = true;
+            }
+          } catch {
+            // Skip malformed SSE data
+          }
+        }
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      yield { type: 'error', content: msg, finishReason: 'error' };
+    }
+  }
+
+  async dispose(): Promise<void> {
+    // No persistent connections to dispose
+  }
+}

package/src/plugins/copilot/tools.ts

@@ -0,0 +1,21 @@
+import type { ToolDefinition } from '../../core/index.js';
+
+export interface CopilotTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export function translateTools(tools: ToolDefinition[]): CopilotTool[] {
+  return tools.map((tool) => ({
+    type: 'function' as const,
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+    },
+  }));
+}

package/src/plugins/copilot/types.ts

@@ -0,0 +1,43 @@
+export interface CopilotModel {
+  id: string;
+  name: string;
+  capabilities: {
+    streaming: boolean;
+    tools: boolean;
+    vision?: boolean;
+  };
+}
+
+export const COPILOT_MODELS: CopilotModel[] = [
+  {
+    id: 'gpt-4-copilot',
+    name: 'GPT-4 (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'gpt-4o-copilot',
+    name: 'GPT-4o (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'claude-3.5-sonnet-copilot',
+    name: 'Claude 3.5 Sonnet (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'o1-copilot',
+    name: 'o1 (Copilot)',
+    capabilities: { streaming: true, tools: true },
+  },
+  {
+    id: 'o1-mini-copilot',
+    name: 'o1-mini (Copilot)',
+    capabilities: { streaming: true, tools: false },
+  },
+];
+
+export interface CopilotConfig {
+  COPILOT_TOKEN?: string;
+  COPILOT_OAUTH_TOKEN?: string;
+  COPILOT_OAUTH_REFRESH_TOKEN?: string;
+}

package/src/plugins/cursor/index.ts

@@ -0,0 +1,2 @@
+export { CursorBridgePlugin } from './plugin.js';
+export { CursorBridgeSession } from './session.js';

package/src/plugins/cursor/plugin.ts

@@ -0,0 +1,37 @@
+import { Cursor } from '@cursor/sdk';
+import type { BridgePlugin, BridgeSession, ModelInfo } from '../../core/index.js';
+import { CursorBridgeSession } from './session.js';
+
+export class CursorBridgePlugin implements BridgePlugin {
+  name = 'cursor';
+  version = '2.0.0';
+
+  async authenticate(config: Record<string, string>): Promise<boolean> {
+    const apiKey = config.CURSOR_API_KEY;
+    if (!apiKey) return false;
+    try {
+      await Cursor.me({ apiKey });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async listModels(config: Record<string, string>): Promise<ModelInfo[]> {
+    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: Record<string, string>, model: string): Promise<BridgeSession> {
+    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/src/plugins/cursor/session.ts

@@ -0,0 +1,78 @@
+import { Agent } from '@cursor/sdk';
+import type { SDKAgent, SendOptions } from '@cursor/sdk';
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '../../core/index.js';
+import { translateTools } from './tools.js';
+
+export class CursorBridgeSession implements BridgeSession {
+  private agent: SDKAgent | null = null;
+  private apiKey: string;
+  private modelId: string;
+  private cwd: string;
+
+  constructor(apiKey: string, modelId: string, cwd: string = process.cwd()) {
+    this.apiKey = apiKey;
+    this.modelId = modelId;
+    this.cwd = cwd;
+  }
+
+  async *send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk> {
+    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: 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(): Promise<void> {
+    if (this.agent) {
+      try {
+        await this.agent[Symbol.asyncDispose]();
+      } catch {
+        // Ignore dispose errors
+      }
+      this.agent = null;
+    }
+  }
+
+  private buildPrompt(messages: Message[]): string {
+    const blocks: string[] = [];
+    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/src/plugins/cursor/tools.ts

@@ -0,0 +1,25 @@
+import type { ToolDefinition } from '../../core/index.js';
+
+export interface CursorTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export function translateTools(tools: ToolDefinition[]): CursorTool[] {
+  return tools.map((tool) => ({
+    type: 'function' as const,
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+    },
+  }));
+}
+
+export function translateToolResult(toolCallId: string, result: string): string {
+  return `[tool result for ${toolCallId}]\n${result}`;
+}

package/src/plugins/windsurf/auth.ts

@@ -0,0 +1,23 @@
+import type { WindsurfConfig } from './types.js';
+
+const WINDSURF_API_BASE = 'https://server.codeium.com';
+
+export function getToken(config: WindsurfConfig): string | null {
+  return config.WINDSURF_TOKEN ?? config.WINDSURF_OAUTH_TOKEN ?? null;
+}
+
+export async function validateToken(token: string): Promise<boolean> {
+  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/src/plugins/windsurf/daemon.ts

@@ -0,0 +1,24 @@
+import { createDaemonManager, type DaemonManager } from '../../core/index.js';
+import { homedir, platform, arch } from 'node:os';
+import { join } from 'node:path';
+
+const DEFAULT_KNOWN_PATHS: string[] = [
+  join('/Applications', 'Windsurf.app', 'Contents', 'Resources', 'language_server'),
+  join('/usr', 'local', 'bin', 'language_server'),
+];
+
+interface WindsurfDaemonOptions {
+  knownPaths?: string[];
+}
+
+export function createWindsurfDaemon(options: WindsurfDaemonOptions = {}): DaemonManager {
+  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/src/plugins/windsurf/index.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/src/plugins/windsurf/models.ts

@@ -0,0 +1,44 @@
+import type { WindsurfModel } from './types.js';
+
+export const WINDSURF_MODELS: WindsurfModel[] = [
+  {
+    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/src/plugins/windsurf/plugin.ts

@@ -0,0 +1,34 @@
+import type { BridgePlugin, BridgeSession, ModelInfo } from '../../core/index.js';
+import { WindsurfBridgeSession } from './session.js';
+import { WINDSURF_MODELS } from './models.js';
+import type { WindsurfConfig } from './types.js';
+import { getToken, validateToken } from './auth.js';
+import { createWindsurfDaemon } from './daemon.js';
+
+export class WindsurfBridgePlugin implements BridgePlugin {
+  name = 'windsurf';
+  version = '2.0.0';
+
+  async authenticate(config: Record<string, string>): Promise<boolean> {
+    const token = getToken(config as WindsurfConfig);
+    if (!token) return false;
+    return validateToken(token);
+  }
+
+  async listModels(config: Record<string, string>): Promise<ModelInfo[]> {
+    const token = getToken(config as WindsurfConfig);
+    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: Record<string, string>, model: string): Promise<BridgeSession> {
+    const token = getToken(config as WindsurfConfig);
+    if (!token) throw new Error('Missing WINDSURF_TOKEN');
+    const daemon = createWindsurfDaemon();
+    return new WindsurfBridgeSession(daemon, token, model);
+  }
+}

package/src/plugins/windsurf/session.ts

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

package/src/plugins/windsurf/tools.ts

@@ -0,0 +1,13 @@
+import type { ToolDefinition } from '../../core/index.js';
+import type { WindsurfTool } from './types.js';
+
+export function translateTools(tools: ToolDefinition[]): WindsurfTool[] {
+  return tools.map((tool) => ({
+    type: 'function' as const,
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+    },
+  }));
+}

package/src/plugins/windsurf/types.ts

@@ -0,0 +1,24 @@
+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/src/utils/config.ts

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

package/src/utils/opencode.ts

@@ -18,8 +18,9 @@ export function findOpencodeConfig(): string | null {
 export function injectProvider(
   configPath: string,
   providerId: string,
-  modelId: string,
+  models: Record<string, { name: string }>,
   port: number,
+  defaultModelId: string,
 ): void {
   const raw = fs.readFileSync(configPath, 'utf8');
   let config: any;
@@ -36,8 +37,8 @@ export function injectProvider(
       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/src/utils/platform.ts

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

package/test/configure.test.ts

@@ -12,17 +12,32 @@ describe('opencode utils', () => {
     fs.writeFileSync(tmpFile, '{}');
   });
 
-  it('injects provider into empty config', () => {
-    injectProvider(tmpFile, 'test-provider', 'test-model', 3849);
+  it('injects provider with single model into empty config', () => {
+    const models = { 'cursor/composer-2': { name: 'cursor/composer-2' } };
+    injectProvider(tmpFile, 'test-provider', models, 3849, 'cursor/composer-2');
     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');
+    expect(config.provider['test-provider'].models['cursor/composer-2']).toBeDefined();
+    expect(config.model).toBe('test-provider/cursor/composer-2');
+  });
+
+  it('injects provider with multiple models', () => {
+    const models = {
+      'cursor/composer-2': { name: 'cursor/composer-2' },
+      'cursor/gpt-4o': { name: 'cursor/gpt-4o' },
+    };
+    injectProvider(tmpFile, 'test-provider', models, 3849, 'cursor/gpt-4o');
+    const config = JSON.parse(fs.readFileSync(tmpFile, 'utf8'));
+    expect(config.provider['test-provider'].models['cursor/composer-2']).toBeDefined();
+    expect(config.provider['test-provider'].models['cursor/gpt-4o']).toBeDefined();
+    expect(config.model).toBe('test-provider/cursor/gpt-4o');
   });
 
   it('preserves existing config fields', () => {
     fs.writeFileSync(tmpFile, JSON.stringify({ existing: 'value' }));
-    injectProvider(tmpFile, 'test-provider', 'test-model', 3849);
+    const models = { 'cursor/composer-2': { name: 'cursor/composer-2' } };
+    injectProvider(tmpFile, 'test-provider', models, 3849, 'cursor/composer-2');
     const config = JSON.parse(fs.readFileSync(tmpFile, 'utf8'));
     expect(config.existing).toBe('value');
     expect(config.provider['test-provider']).toBeDefined();