@ai-ide-bridge/cli 1.0.4 → 1.1.0

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/platform.ts

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

package/test/daemon.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+vi.mock('node:fs', () => ({
+  default: {
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    existsSync: vi.fn(),
+    unlinkSync: vi.fn(),
+  },
+}));
+
+vi.mock('../src/utils/platform.js', () => ({
+  getPlatform: vi.fn(() => process.platform),
+}));
+
+const { execSync } = await import('node:child_process');
+const mockedExecSync = vi.mocked(execSync);
+const { getPlatform } = await import('../src/utils/platform.js');
+const mockedGetPlatform = vi.mocked(getPlatform);
+
+describe('installDaemonCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockedGetPlatform.mockReturnValue(process.platform);
+  });
+
+  it('generates systemd unit file on Linux', async () => {
+    mockedGetPlatform.mockReturnValue('linux');
+
+    const { installDaemonCommand } = await import('../src/commands/daemon.js');
+
+    await installDaemonCommand();
+
+    const fs = await import('node:fs');
+    const mockedFs = vi.mocked(fs.default);
+
+    expect(mockedFs.mkdirSync).toHaveBeenCalled();
+    const writeCall = mockedFs.writeFileSync.mock.calls[0];
+    const unitPath = writeCall[0] as string;
+    expect(unitPath).toContain('.config/systemd/user/llm-bridge.service');
+
+    const unitContent = writeCall[1] as string;
+    expect(unitContent).toContain('[Unit]');
+    expect(unitContent).toContain('Description=llm-bridge daemon');
+    expect(unitContent).toContain('After=network.target');
+    expect(unitContent).toContain('[Service]');
+    expect(unitContent).toContain('Type=simple');
+    expect(unitContent).toContain('Restart=on-failure');
+    expect(unitContent).toContain('RestartSec=5');
+    expect(unitContent).toContain('[Install]');
+    expect(unitContent).toContain('WantedBy=default.target');
+
+    expect(mockedExecSync).toHaveBeenCalledWith('systemctl --user daemon-reload', {
+      stdio: 'inherit',
+    });
+    expect(mockedExecSync).toHaveBeenCalledWith('systemctl --user enable --now llm-bridge', {
+      stdio: 'inherit',
+    });
+  });
+
+  it('routes to installMacOSDaemon on darwin', async () => {
+    mockedGetPlatform.mockReturnValue('darwin');
+
+    const { installDaemonCommand } = await import('../src/commands/daemon.js');
+    const fs = await import('node:fs');
+    const mockedFs = vi.mocked(fs.default);
+
+    await installDaemonCommand();
+
+    expect(mockedFs.writeFileSync).toHaveBeenCalled();
+    const writeCall = mockedFs.writeFileSync.mock.calls[0];
+    const plistPath = writeCall[0] as string;
+    expect(plistPath).toContain('Library/LaunchAgents/com.llm-bridge.daemon.plist');
+
+    expect(mockedExecSync).toHaveBeenCalledWith(expect.stringContaining('launchctl bootstrap'), {
+      stdio: 'inherit',
+    });
+  });
+
+  it('exits with error on unsupported platforms', async () => {
+    mockedGetPlatform.mockReturnValue('win32');
+
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const { installDaemonCommand } = await import('../src/commands/daemon.js');
+
+    await installDaemonCommand();
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      'Daemon installation is only supported on macOS and Linux.',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    exitSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+});
+
+describe('uninstallDaemonCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockedGetPlatform.mockReturnValue(process.platform);
+  });
+
+  it('removes systemd unit file on Linux', async () => {
+    mockedGetPlatform.mockReturnValue('linux');
+
+    const { uninstallDaemonCommand } = await import('../src/commands/daemon.js');
+    const fs = await import('node:fs');
+    const mockedFs = vi.mocked(fs.default);
+
+    mockedFs.existsSync.mockReturnValue(true);
+
+    await uninstallDaemonCommand();
+
+    expect(mockedExecSync).toHaveBeenCalledWith(
+      'systemctl --user disable --now llm-bridge 2>/dev/null || true',
+      { stdio: 'inherit' },
+    );
+
+    const unlinkCall = mockedFs.unlinkSync.mock.calls[0];
+    expect(unlinkCall[0]).toContain('.config/systemd/user/llm-bridge.service');
+
+    expect(mockedExecSync).toHaveBeenCalledWith('systemctl --user daemon-reload', {
+      stdio: 'inherit',
+    });
+  });
+
+  it('routes to uninstallMacOSDaemon on darwin', async () => {
+    mockedGetPlatform.mockReturnValue('darwin');
+
+    const { uninstallDaemonCommand } = await import('../src/commands/daemon.js');
+    const fs = await import('node:fs');
+    const mockedFs = vi.mocked(fs.default);
+
+    mockedFs.existsSync.mockReturnValue(true);
+
+    await uninstallDaemonCommand();
+
+    const unlinkCall = mockedFs.unlinkSync.mock.calls[0];
+    expect(unlinkCall[0]).toContain('Library/LaunchAgents/com.llm-bridge.daemon.plist');
+
+    expect(mockedExecSync).toHaveBeenCalledWith(expect.stringContaining('launchctl bootout'), {
+      stdio: 'inherit',
+    });
+  });
+
+  it('errors on unsupported platforms', async () => {
+    mockedGetPlatform.mockReturnValue('win32');
+
+    const { uninstallDaemonCommand } = await import('../src/commands/daemon.js');
+
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await uninstallDaemonCommand();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Daemon uninstallation is only supported on macOS and Linux.',
+    );
+
+    exitSpy.mockRestore();
+    consoleSpy.mockRestore();
+  });
+
+  it('handles missing service file gracefully on Linux', async () => {
+    mockedGetPlatform.mockReturnValue('linux');
+
+    const { uninstallDaemonCommand } = await import('../src/commands/daemon.js');
+    const fs = await import('node:fs');
+    const mockedFs = vi.mocked(fs.default);
+
+    mockedFs.existsSync.mockReturnValue(false);
+
+    await uninstallDaemonCommand();
+
+    expect(mockedFs.unlinkSync).not.toHaveBeenCalled();
+    expect(mockedExecSync).toHaveBeenCalledWith('systemctl --user daemon-reload', {
+      stdio: 'inherit',
+    });
+  });
+});
+
+describe('daemonReloadCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockedGetPlatform.mockReturnValue(process.platform);
+  });
+
+  it('runs systemctl daemon-reload on Linux', async () => {
+    mockedGetPlatform.mockReturnValue('linux');
+
+    const { daemonReloadCommand } = await import('../src/commands/daemon.js');
+
+    await daemonReloadCommand();
+
+    expect(mockedExecSync).toHaveBeenCalledWith('systemctl --user reload-or-restart llm-bridge', {
+      stdio: 'inherit',
+    });
+  });
+
+  it('errors on unsupported platforms', async () => {
+    mockedGetPlatform.mockReturnValue('win32');
+
+    const { daemonReloadCommand } = await import('../src/commands/daemon.js');
+
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await daemonReloadCommand();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(consoleSpy).toHaveBeenCalledWith('Daemon reload is only supported on Linux.');
+
+    exitSpy.mockRestore();
+    consoleSpy.mockRestore();
+  });
+});