@ai-ide-bridge/cli 1.0.4 → 1.1.0

package/src/core/registry.ts

@@ -0,0 +1,62 @@
+import type { BridgePlugin, PluginHealth } from './types.js';
+
+export class PluginRegistry {
+  private plugins: Map<string, BridgePlugin> = new Map();
+  private activePluginName: string | null = null;
+  private defaultPluginName: string | null = null;
+  private health: Map<string, PluginHealth> = new Map();
+
+  register(plugin: BridgePlugin): void {
+    this.plugins.set(plugin.name, plugin);
+    this.health.set(plugin.name, {
+      name: plugin.name,
+      healthy: true,
+      lastChecked: new Date(),
+    });
+  }
+
+  getPlugin(name: string): BridgePlugin | undefined {
+    return this.plugins.get(name);
+  }
+
+  setActive(name: string): void {
+    if (!this.plugins.has(name)) {
+      throw new Error(`Plugin "${name}" is not registered`);
+    }
+    this.activePluginName = name;
+  }
+
+  setDefault(name: string): void {
+    if (!this.plugins.has(name)) {
+      throw new Error(`Plugin "${name}" is not registered`);
+    }
+    this.defaultPluginName = name;
+  }
+
+  getActivePlugin(): BridgePlugin | null {
+    if (!this.activePluginName) return null;
+    return this.plugins.get(this.activePluginName) ?? null;
+  }
+
+  getDefaultPlugin(): BridgePlugin | null {
+    if (!this.defaultPluginName) return null;
+    return this.plugins.get(this.defaultPluginName) ?? null;
+  }
+
+  listPlugins(): BridgePlugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  markUnhealthy(name: string, error: string): void {
+    this.health.set(name, {
+      name,
+      healthy: false,
+      lastChecked: new Date(),
+      error,
+    });
+  }
+
+  getHealth(name: string): PluginHealth | undefined {
+    return this.health.get(name);
+  }
+}

package/src/core/server.ts

@@ -0,0 +1,211 @@
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import crypto from 'node:crypto';
+import { BridgeConfig, DefaultConfig, BridgePlugin } from './types.js';
+import { parseChatRequest } from './parser.js';
+import { PluginRegistry } from './registry.js';
+import { SessionStore } from './session.js';
+import { formatStreamChunk, formatCompletion } from './formatter.js';
+
+export class BridgeServer {
+  private server: http.Server | null = null;
+  private registry: PluginRegistry;
+  private sessions: SessionStore;
+  private config: BridgeConfig;
+
+  constructor(config: Partial<BridgeConfig> = {}) {
+    this.config = { ...DefaultConfig, ...config };
+    this.registry = new PluginRegistry();
+    this.sessions = new SessionStore(this.config.sessionTTL);
+  }
+
+  async start(): Promise<void> {
+    this.server = http.createServer((req, res) => {
+      this.handleRequest(req, res).catch((err) => {
+        console.error('[llm-bridge] unhandled error:', err);
+        if (!res.headersSent) {
+          this.jsonResponse(res, 500, { error: { message: 'internal error', type: 'internal' } });
+        }
+      });
+    });
+
+    return new Promise((resolve) => {
+      this.server!.listen(this.config.port, this.config.host, () => {
+        const address = this.server!.address();
+        const port = typeof address === 'object' ? address?.port : this.config.port;
+        console.error(`[llm-bridge] listening on http://${this.config.host}:${port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    await this.sessions.disposeAll();
+    return new Promise((resolve) => {
+      this.server?.close(() => resolve());
+    });
+  }
+
+  address(): import('net').AddressInfo | string | null {
+    return this.server?.address() ?? null;
+  }
+
+  private async handleRequest(req: IncomingMessage, res: http.ServerResponse): Promise<void> {
+    const url = new URL(req.url ?? '/', `http://${this.config.host}`);
+    const path = url.pathname.replace(/\/+$/, '') || '/';
+
+    if (req.method === 'GET' && path === '/health') {
+      this.jsonResponse(res, 200, { ok: true, service: 'llm-bridge' });
+      return;
+    }
+
+    if (req.method === 'GET' && path === '/v1/models') {
+      await this.handleModels(req, res);
+      return;
+    }
+
+    if (req.method === 'POST' && path === '/v1/chat/completions') {
+      await this.handleChatCompletions(req, res);
+      return;
+    }
+
+    this.jsonResponse(res, 404, { error: { message: `Not found: ${path}`, type: 'not_found' } });
+  }
+
+  private async handleModels(_req: IncomingMessage, res: http.ServerResponse): Promise<void> {
+    const allPlugins = this.registry.listPlugins();
+    if (allPlugins.length === 0) {
+      this.jsonResponse(res, 503, {
+        error: { message: 'No plugins configured', type: 'configuration_error' },
+      });
+      return;
+    }
+
+    try {
+      const models: { id: string; object: string; created: number; owned_by: string }[] = [];
+      const now = Math.floor(Date.now() / 1000);
+      for (const plugin of allPlugins) {
+        const config = this.config.plugins[plugin.name] ?? {};
+        const pluginModels = await plugin.listModels(config);
+        for (const m of pluginModels) {
+          models.push({
+            id: `${plugin.name}/${m.id}`,
+            object: 'model',
+            created: now,
+            owned_by: plugin.name,
+          });
+        }
+      }
+      this.jsonResponse(res, 200, {
+        object: 'list',
+        data: models,
+      });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.jsonResponse(res, 502, { error: { message: msg, type: 'provider_error' } });
+    }
+  }
+
+  private resolvePlugin(model: string): { plugin: BridgePlugin | null; error: string | null } {
+    const slashIndex = model.indexOf('/');
+    if (slashIndex !== -1) {
+      const prefix = model.slice(0, slashIndex);
+      const plugin = this.registry.getPlugin(prefix);
+      if (plugin) return { plugin, error: null };
+      return { plugin: null, error: `Unknown plugin: "${prefix}"` };
+    }
+    return { plugin: this.registry.getDefaultPlugin(), error: null };
+  }
+
+  private async handleChatCompletions(
+    req: IncomingMessage,
+    res: http.ServerResponse,
+  ): Promise<void> {
+    const parsed = await parseChatRequest(req);
+    if (!parsed.success) {
+      this.jsonResponse(res, 400, {
+        error: { message: parsed.error, type: 'invalid_request_error' },
+      });
+      return;
+    }
+
+    const { messages, model, stream, tools } = parsed.data;
+    const { plugin, error } = this.resolvePlugin(model);
+
+    if (error) {
+      this.jsonResponse(res, 400, {
+        error: { message: error, type: 'invalid_request_error' },
+      });
+      return;
+    }
+
+    if (!plugin) {
+      this.jsonResponse(res, 503, {
+        error: { message: 'No default plugin configured', type: 'configuration_error' },
+      });
+      return;
+    }
+
+    try {
+      const config = this.config.plugins[plugin.name] ?? {};
+      const modelId = model.includes('/') ? model.slice(model.indexOf('/') + 1) : model;
+      const session = await plugin.createSession(config, modelId);
+      const sessionId = req.headers['x-session-id'] as string | undefined;
+      this.sessions.set(sessionId ?? crypto.randomUUID(), session);
+
+      res.writeHead(200, {
+        'Content-Type': stream ? 'text/event-stream; charset=utf-8' : 'application/json',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+
+      const chunks: string[] = [];
+      for await (const chunk of session.send(messages, tools)) {
+        if (stream) {
+          res.write(formatStreamChunk(chunk, model, `chatcmpl-${crypto.randomUUID()}`));
+        } else {
+          if (chunk.type === 'text' && chunk.content) {
+            chunks.push(chunk.content);
+          }
+        }
+      }
+
+      if (!stream) {
+        const completionId = `chatcmpl-${crypto.randomUUID()}`;
+        const completion = formatCompletion(chunks.join(''), model, completionId);
+        res.end(JSON.stringify(completion));
+      } else {
+        res.write(`data: [DONE]\n\n`);
+        res.end();
+      }
+
+      await session.dispose();
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (stream && !res.writableEnded) {
+        res.write(
+          `data: ${JSON.stringify({ error: { message: msg, type: 'provider_error' } })}\n\n`,
+        );
+        res.end();
+      } else if (!res.headersSent) {
+        this.jsonResponse(res, 502, { error: { message: msg, type: 'provider_error' } });
+      }
+    }
+  }
+
+  private jsonResponse(res: http.ServerResponse, status: number, body: unknown): void {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+  }
+
+  registerPlugin(plugin: BridgePlugin): void {
+    this.registry.register(plugin);
+  }
+
+  setActivePlugin(name: string): void {
+    this.registry.setActive(name);
+  }
+
+  setDefaultPlugin(name: string): void {
+    this.registry.setDefault(name);
+  }
+}

package/src/core/session.ts

@@ -0,0 +1,54 @@
+import type { BridgeSession } from './types.js';
+
+interface SessionEntry {
+  session: BridgeSession;
+  lastActive: number;
+}
+
+export class SessionStore {
+  private sessions: Map<string, SessionEntry> = new Map();
+  private ttlMs: number;
+
+  constructor(ttlSeconds: number = 1800) {
+    this.ttlMs = ttlSeconds * 1000;
+  }
+
+  set(id: string, session: BridgeSession): void {
+    this.sessions.set(id, { session, lastActive: Date.now() });
+  }
+
+  get(id: string): BridgeSession | undefined {
+    const entry = this.sessions.get(id);
+    if (entry) {
+      entry.lastActive = Date.now();
+      return entry.session;
+    }
+    return undefined;
+  }
+
+  cleanup(): void {
+    const now = Date.now();
+    for (const [id, entry] of this.sessions.entries()) {
+      if (now - entry.lastActive > this.ttlMs) {
+        this.sessions.delete(id);
+        entry.session.dispose().catch((err) => {
+          console.error(`[session] dispose error for ${id}:`, err);
+        });
+      }
+    }
+  }
+
+  async disposeAll(): Promise<void> {
+    const disposals = Array.from(this.sessions.values()).map((entry) =>
+      entry.session.dispose().catch((err) => {
+        console.error('[session] disposeAll error:', err);
+      }),
+    );
+    this.sessions.clear();
+    await Promise.all(disposals);
+  }
+
+  get size(): number {
+    return this.sessions.size;
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+export const MessageSchema = z.object({
+  role: z.enum(['system', 'user', 'assistant', 'tool', 'function']),
+  content: z.string().nullable().optional(),
+  name: z.string().optional(),
+  tool_call_id: z.string().optional(),
+  tool_calls: z
+    .array(
+      z.object({
+        id: z.string(),
+        type: z.literal('function'),
+        function: z.object({
+          name: z.string(),
+          arguments: z.string(),
+        }),
+      }),
+    )
+    .optional(),
+});
+
+export type Message = z.infer<typeof MessageSchema>;
+
+export const ToolDefinitionSchema = z.object({
+  type: z.literal('function'),
+  function: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.record(z.unknown()),
+  }),
+});
+
+export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+
+export const ModelInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  capabilities: z
+    .object({
+      streaming: z.boolean().optional(),
+      tools: z.boolean().optional(),
+      vision: z.boolean().optional(),
+    })
+    .optional(),
+});
+
+export type ModelInfo = z.infer<typeof ModelInfoSchema>;
+
+export type StreamChunkType = 'text' | 'tool_call' | 'tool_result' | 'error' | 'done';
+export type FinishReason = 'stop' | 'tool_calls' | 'error' | 'length';
+
+export interface StreamChunk {
+  type: StreamChunkType;
+  content?: string;
+  toolCall?: {
+    id: string;
+    name: string;
+    arguments: string;
+  };
+  finishReason?: FinishReason;
+}
+
+export interface 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>;
+}
+
+export interface BridgeSession {
+  send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk>;
+  dispose(): Promise<void>;
+}
+
+export interface PluginHealth {
+  name: string;
+  healthy: boolean;
+  lastChecked: Date;
+  error?: string;
+}
+
+export interface BridgeConfig {
+  activePlugin?: string;
+  defaultPlugin: string;
+  port: number;
+  host: string;
+  plugins: Record<string, Record<string, string>>;
+  sessionTTL: number;
+  toolMode: 'strict' | 'lenient';
+}
+
+export const DefaultConfig: BridgeConfig = {
+  defaultPlugin: 'cursor',
+  port: 3849,
+  host: '127.0.0.1',
+  plugins: {},
+  sessionTTL: 1800,
+  toolMode: 'lenient',
+};

package/src/index.ts

@@ -7,8 +7,11 @@ import {
   daemonStatusCommand,
   daemonDownloadCommand,
   daemonLocateCommand,
+  daemonReloadCommand,
 } from './commands/daemon.js';
 import { installDaemonCommand, uninstallDaemonCommand } from './commands/daemon.js';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
 
 const command = process.argv[2] ?? 'help';
 
@@ -44,11 +47,24 @@ async function main(): Promise<void> {
         case 'locate':
           await daemonLocateCommand();
           break;
+        case 'reload':
+          await daemonReloadCommand();
+          break;
         default:
-          console.log('Usage: llm-bridge daemon [status|download|locate]');
+          console.log('Usage: llm-bridge daemon [status|download|locate|reload]');
       }
       break;
     }
+    case 'login': {
+      const provider = process.argv[3];
+      await loginCommand(provider);
+      break;
+    }
+    case 'logout': {
+      const provider = process.argv[3];
+      await logoutCommand(provider);
+      break;
+    }
     case 'help':
     default:
       console.log(`llm-bridge v1.0.0
@@ -56,11 +72,13 @@ async function main(): Promise<void> {
 Usage:
   llm-bridge init              Interactive setup wizard (configure one or more providers)
   llm-bridge start             Launch bridge server (all configured plugins registered)
+  llm-bridge login [provider]  OAuth login (copilot, cursor)
+  llm-bridge logout [provider] Remove stored OAuth token
   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 install-daemon    Install platform daemon (LaunchAgent or systemd)
+  llm-bridge uninstall-daemon  Remove platform daemon
+  llm-bridge daemon [status|download|locate|reload]  Manage Windsurf daemon binary
   llm-bridge help              Show this help`);
   }
 }

package/src/oauth/device-flow.ts

@@ -0,0 +1,111 @@
+import type { OAuthConfig, StoredToken, DeviceCodeResponse } from './types.js';
+
+const SLOW_DOWN_BACKOFF_MS = 5000;
+const DEFAULT_POLL_INTERVAL_S = 5;
+const DEFAULT_TOKEN_EXPIRY_S = 3600;
+
+export class DeviceFlow {
+  private deviceCode = '';
+  private interval = DEFAULT_POLL_INTERVAL_S * 1000;
+  private expiresAt = 0;
+  private firstPoll = true;
+
+  constructor(private config: OAuthConfig) {}
+
+  async start(): Promise<DeviceCodeResponse> {
+    const params = new URLSearchParams({
+      client_id: this.config.provider.clientId,
+      scope: this.config.provider.scopes.join(' '),
+    });
+
+    const response = await fetch(this.config.provider.authUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' },
+      body: params.toString(),
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Device code request failed: ${response.status} ${body}`);
+    }
+
+    const data = (await response.json()) as Record<string, unknown>;
+
+    if (!data.device_code || !data.user_code || !data.verification_uri || !data.expires_in) {
+      throw new Error('Invalid device code response: missing required fields');
+    }
+
+    this.deviceCode = data.device_code as string;
+    this.interval = ((data.interval as number) ?? DEFAULT_POLL_INTERVAL_S) * 1000;
+    this.expiresAt = Date.now() + (data.expires_in as number) * 1000;
+    this.firstPoll = true;
+
+    return {
+      deviceCode: this.deviceCode,
+      userCode: data.user_code as string,
+      verificationUri: data.verification_uri as string,
+      expiresIn: data.expires_in as number,
+      interval: (data.interval as number) ?? DEFAULT_POLL_INTERVAL_S,
+    };
+  }
+
+  async poll(): Promise<StoredToken> {
+    if (!this.deviceCode) {
+      throw new Error('No device code. Call start() first.');
+    }
+
+    while (Date.now() < this.expiresAt) {
+      if (!this.firstPoll) {
+        await this.sleep(this.interval);
+      }
+      this.firstPoll = false;
+
+      const params = new URLSearchParams({
+        client_id: this.config.provider.clientId,
+        device_code: this.deviceCode,
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      });
+
+      const response = await fetch(this.config.provider.tokenUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          Accept: 'application/json',
+        },
+        body: params.toString(),
+      });
+
+      const data = (await response.json()) as Record<string, unknown>;
+
+      if (response.ok) {
+        if (!data.access_token) {
+          throw new Error('Invalid token response: missing access_token');
+        }
+
+        const token: StoredToken = {
+          version: 1,
+          accessToken: data.access_token as string,
+          refreshToken: data.refresh_token as string | undefined,
+          expiresAt: Date.now() + ((data.expires_in as number) ?? DEFAULT_TOKEN_EXPIRY_S) * 1000,
+          scopes: (data.scope as string)?.split(' ') ?? this.config.provider.scopes,
+        };
+
+        await this.config.store.set(this.config.provider.id, token);
+        return token;
+      }
+
+      const error = data.error as string;
+      if (error === 'slow_down') {
+        this.interval += ((data.interval as number) ?? 0) * 1000 + SLOW_DOWN_BACKOFF_MS;
+      } else if (error !== 'authorization_pending') {
+        throw new Error(`Device flow error: ${error}`);
+      }
+    }
+
+    throw new Error('Device flow expired');
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/oauth/flow.ts

@@ -0,0 +1,94 @@
+import { randomBytes, createHash } from 'node:crypto';
+import type { OAuthConfig, StoredToken, TokenStore, PKCEState } from './types.js';
+
+const DEFAULT_TOKEN_EXPIRY_MS = 3600000;
+
+export class OAuthFlow {
+  private pkceState: PKCEState | null = null;
+
+  constructor(
+    private config: OAuthConfig,
+    private store: TokenStore,
+  ) {}
+
+  async start(): Promise<string> {
+    const codeVerifier = this.generateCodeVerifier();
+    const codeChallenge = this.generateCodeChallenge(codeVerifier);
+    const state = randomBytes(16).toString('hex');
+
+    this.pkceState = { codeVerifier, codeChallenge, state };
+
+    const params = new URLSearchParams({
+      response_type: 'code',
+      client_id: this.config.provider.clientId,
+      scope: this.config.provider.scopes.join(' '),
+      code_challenge: codeChallenge,
+      code_challenge_method: 'S256',
+      state,
+    });
+
+    if (this.config.redirectUri) {
+      params.set('redirect_uri', this.config.redirectUri);
+    }
+
+    return `${this.config.provider.authUrl}?${params.toString()}`;
+  }
+
+  async callback(code: string, state: string): Promise<StoredToken> {
+    if (!this.pkceState) {
+      throw new Error('No pending PKCE state');
+    }
+
+    if (state !== this.pkceState.state) {
+      throw new Error('State mismatch');
+    }
+
+    const { codeVerifier } = this.pkceState;
+    this.pkceState = null;
+
+    const params = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      code_verifier: codeVerifier,
+      client_id: this.config.provider.clientId,
+    });
+
+    if (this.config.redirectUri) {
+      params.set('redirect_uri', this.config.redirectUri);
+    }
+
+    const response = await fetch(this.config.provider.tokenUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: params.toString(),
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Token exchange failed: ${response.status} ${body}`);
+    }
+
+    const data = (await response.json()) as Record<string, unknown>;
+
+    const newToken: StoredToken = {
+      version: 1,
+      accessToken: data.access_token as string,
+      refreshToken: data.refresh_token as string | undefined,
+      expiresAt: data.expires_in
+        ? Date.now() + (data.expires_in as number) * 1000
+        : Date.now() + DEFAULT_TOKEN_EXPIRY_MS,
+      scopes: this.config.provider.scopes,
+    };
+
+    await this.store.set(this.config.provider.id, newToken);
+    return newToken;
+  }
+
+  private generateCodeVerifier(): string {
+    return randomBytes(32).toString('base64url');
+  }
+
+  private generateCodeChallenge(verifier: string): string {
+    return createHash('sha256').update(verifier).digest('base64url');
+  }
+}

package/src/oauth/index.ts

@@ -0,0 +1,6 @@
+export type { OAuthProvider, TokenStore, StoredToken, OAuthConfig } from './types.js';
+export { createTokenStore } from './storage.js';
+export { OAuthFlow } from './flow.js';
+export { DeviceFlow } from './device-flow.js';
+export { TokenLifecycle, type TokenLifecycleOptions } from './lifecycle.js';
+export { providers } from './providers.js';