@ai-ide-bridge/cli 1.0.4 → 1.1.0

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/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.4",
+  "version": "1.1.0",
   "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/daemon.ts

@@ -2,20 +2,31 @@ 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';
+import { createWindsurfDaemon } from '../plugins/windsurf/daemon.js';
+import { getPlatform } from '../utils/platform.js';
 
-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.');
+  const platform = getPlatform();
+  if (platform === 'darwin') {
+    await installMacOSDaemon();
+  } else if (platform === 'linux') {
+    await installLinuxDaemon();
+  } else {
+    console.error('Daemon installation is only supported on macOS and Linux.');
     process.exit(1);
   }
+}
 
+async function installMacOSDaemon(): Promise<void> {
   const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
-  const wrapperPath = path.join(__dirname, '..', '..', 'scripts', 'llm-bridge-daemon.sh');
+  const wrapperPath = path.join(
+    path.dirname(process.execPath),
+    '..',
+    '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">
@@ -40,8 +51,13 @@ export async function installDaemonCommand(): Promise<void> {
 </dict>
 </plist>`;
 
-  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
-  fs.writeFileSync(plistPath, plist);
+  try {
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+    fs.writeFileSync(plistPath, plist);
+  } catch (e) {
+    console.error('Failed to write plist file:', e);
+    process.exit(1);
+  }
 
   try {
     execSync(`launchctl bootstrap "gui/$(id -u)" "${plistPath}"`, { stdio: 'inherit' });
@@ -53,12 +69,58 @@ export async function installDaemonCommand(): Promise<void> {
   }
 }
 
+async function installLinuxDaemon(): Promise<void> {
+  const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+  const servicePath = path.join(serviceDir, 'llm-bridge.service');
+
+  const binaryPath = process.execPath;
+
+  const unit = `[Unit]
+Description=llm-bridge daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${binaryPath} start
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+
+  try {
+    fs.mkdirSync(serviceDir, { recursive: true });
+    fs.writeFileSync(servicePath, unit);
+  } catch (e) {
+    console.error('Failed to write service file:', e);
+    process.exit(1);
+  }
+
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+    execSync('systemctl --user enable --now llm-bridge', { stdio: 'inherit' });
+    console.log(`Installed systemd user service: ${servicePath}`);
+    console.log('Logs: journalctl --user -u llm-bridge -f');
+  } catch (e) {
+    console.error('Failed to enable systemd service:', e);
+    process.exit(1);
+  }
+}
+
 export async function uninstallDaemonCommand(): Promise<void> {
-  if (process.platform !== 'darwin') {
-    console.error('Daemon uninstallation is only supported on macOS.');
+  const platform = getPlatform();
+  if (platform === 'darwin') {
+    await uninstallMacOSDaemon();
+  } else if (platform === 'linux') {
+    await uninstallLinuxDaemon();
+  } else {
+    console.error('Daemon uninstallation is only supported on macOS and Linux.');
     process.exit(1);
   }
+}
 
+async function uninstallMacOSDaemon(): Promise<void> {
   const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
 
   try {
@@ -77,8 +139,32 @@ export async function uninstallDaemonCommand(): Promise<void> {
   }
 }
 
+async function uninstallLinuxDaemon(): Promise<void> {
+  const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', 'llm-bridge.service');
+
+  try {
+    execSync('systemctl --user disable --now llm-bridge 2>/dev/null || true', {
+      stdio: 'inherit',
+    });
+  } catch {
+    // Ignore errors during disable
+  }
+
+  if (fs.existsSync(servicePath)) {
+    fs.unlinkSync(servicePath);
+    console.log(`Removed systemd service: ${servicePath}`);
+  } else {
+    console.log('No systemd service found.');
+  }
+
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+  } catch {
+    // Ignore errors during reload
+  }
+}
+
 export async function daemonStatusCommand(): Promise<void> {
-  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
   const daemon = createWindsurfDaemon();
 
   const path = await daemon.locate();
@@ -93,7 +179,6 @@ export async function daemonStatusCommand(): Promise<void> {
 }
 
 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...');
@@ -107,7 +192,6 @@ export async function daemonDownloadCommand(): Promise<void> {
 }
 
 export async function daemonLocateCommand(): Promise<void> {
-  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
   const daemon = createWindsurfDaemon();
 
   const path = await daemon.locate();
@@ -118,3 +202,18 @@ export async function daemonLocateCommand(): Promise<void> {
     process.exit(1);
   }
 }
+
+export async function daemonReloadCommand(): Promise<void> {
+  if (getPlatform() !== 'linux') {
+    console.error('Daemon reload is only supported on Linux.');
+    process.exit(1);
+  }
+
+  try {
+    execSync('systemctl --user reload-or-restart llm-bridge', { stdio: 'inherit' });
+    console.log('Daemon reloaded.');
+  } catch (e) {
+    console.error('Failed to reload daemon:', e);
+    process.exit(1);
+  }
+}

package/src/commands/doctor.ts

@@ -1,7 +1,7 @@
 import http from 'node:http';
 import { readConfig } from '../utils/config.js';
 import fs from 'node:fs';
-import { configPath } from '@ai-ide-bridge/core';
+import { configPath } from '../core/index.js';
 
 export async function doctorCommand(): Promise<void> {
   const config = readConfig();

package/src/commands/init.ts

@@ -1,8 +1,9 @@
 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 { CursorBridgePlugin } from '../plugins/cursor/index.js';
+import { CopilotBridgePlugin } from '../plugins/copilot/index.js';
+import { WindsurfBridgePlugin } from '../plugins/windsurf/index.js';
 import { createInterface } from 'node:readline';
+import { loginCommand } from './login.js';
 
 const PROVIDERS = ['cursor', 'copilot', 'windsurf'] as const;
 type Provider = (typeof PROVIDERS)[number];
@@ -23,7 +24,7 @@ function getCredentialPrompt(provider: Provider): string {
     case 'cursor':
       return 'Enter your CURSOR_API_KEY: ';
     case 'copilot':
-      return 'Enter your GITHUB_TOKEN: ';
+      return 'Enter your GITHUB_TOKEN (or leave empty for OAuth): ';
     case 'windsurf':
       return 'Enter your WINDSURF_TOKEN: ';
   }
@@ -40,6 +41,15 @@ function getEnvVar(provider: Provider): string {
   }
 }
 
+async function authenticateWithOAuth(provider: Provider): Promise<boolean> {
+  if (provider === 'copilot') {
+    await loginCommand('copilot');
+    return true;
+  }
+  console.log(`OAuth not available for ${provider}. Use token authentication instead.`);
+  return false;
+}
+
 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));
@@ -69,6 +79,21 @@ export async function initCommand(): Promise<void> {
 
     const provider = input as Provider;
 
+    if (provider === 'copilot') {
+      const method = await ask('Auth method (token/oauth): ');
+      if (method.toLowerCase() === 'oauth') {
+        const ok = await authenticateWithOAuth(provider);
+        if (!ok) continue;
+        console.log(`Authentication successful for ${provider}.`);
+        setPluginConfig(provider, { COPILOT_OAUTH: 'true' });
+        configuredProviders.push(provider);
+        if (!firstProvider) firstProvider = provider;
+        const more = await ask('Configure another provider? (y/n): ');
+        if (more.toLowerCase() !== 'y') break;
+        continue;
+      }
+    }
+
     const envVar = getEnvVar(provider);
     const credential = await ask(getCredentialPrompt(provider));
     if (!credential) {