@ai-ide-bridge/cli 1.0.4 → 1.1.0

package/src/commands/login.ts

@@ -0,0 +1,98 @@
+import { createInterface } from 'node:readline';
+import { createTokenStore, DeviceFlow, providers } from '../oauth/index.js';
+
+const SUPPORTED_PROVIDERS = ['copilot', 'cursor'] as const;
+type SupportedProvider = (typeof SUPPORTED_PROVIDERS)[number];
+
+export async function loginCommand(provider?: string): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q: string) => new Promise<string>((resolve) => rl.question(q, resolve));
+
+  let providerId: SupportedProvider;
+
+  if (provider && SUPPORTED_PROVIDERS.includes(provider as SupportedProvider)) {
+    providerId = provider as SupportedProvider;
+  } else {
+    const input = await ask(`Provider to login (${SUPPORTED_PROVIDERS.join(', ')}): `);
+    if (!SUPPORTED_PROVIDERS.includes(input as SupportedProvider)) {
+      console.error(`Unknown provider: ${input}`);
+      rl.close();
+      process.exit(1);
+    }
+    providerId = input as SupportedProvider;
+  }
+
+  const oauthProvider = providers[providerId];
+  if (!oauthProvider) {
+    console.error(`OAuth not configured for provider: ${providerId}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  const store = createTokenStore();
+
+  if (oauthProvider.deviceFlow) {
+    await loginWithDeviceFlow(rl, oauthProvider, store);
+  } else {
+    await loginWithPKCE(rl, oauthProvider, store);
+  }
+
+  rl.close();
+}
+
+async function loginWithDeviceFlow(
+  rl: ReturnType<typeof createInterface>,
+  provider: {
+    id: string;
+    name: string;
+    authUrl: string;
+    tokenUrl: string;
+    scopes: string[];
+    clientId: string;
+  },
+  store: ReturnType<typeof createTokenStore>,
+): Promise<void> {
+  const config = {
+    provider,
+    store,
+  };
+
+  const deviceFlow = new DeviceFlow(config);
+
+  console.log(`\nAuthenticating with ${provider.name}...`);
+  console.log('Requesting device code...');
+
+  try {
+    const deviceCode = await deviceFlow.start();
+
+    console.log(`\nOpen this URL in your browser: ${deviceCode.verificationUri}`);
+    console.log(`Enter this code: ${deviceCode.userCode}\n`);
+    console.log('Waiting for authorization...');
+
+    const token = await deviceFlow.poll();
+
+    const expiresIn = Math.round((token.expiresAt - Date.now()) / 1000);
+    console.log(`\nAuthentication successful!`);
+    console.log(`Token stored securely. Expires in ${expiresIn}s.`);
+  } catch (err: any) {
+    console.error(`\nAuthentication failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function loginWithPKCE(
+  rl: ReturnType<typeof createInterface>,
+  provider: {
+    id: string;
+    name: string;
+    authUrl: string;
+    tokenUrl: string;
+    scopes: string[];
+    clientId: string;
+  },
+  store: ReturnType<typeof createTokenStore>,
+): Promise<void> {
+  console.log(`\nOAuth with PKCE is not yet supported for ${provider.name}.`);
+  console.log('Use a personal access token instead: llm-bridge init');
+  process.exit(1);
+}

package/src/commands/logout.ts

@@ -0,0 +1,15 @@
+import { createTokenStore } from '../oauth/index.js';
+
+export async function logoutCommand(provider?: string): Promise<void> {
+  const store = createTokenStore();
+
+  if (provider) {
+    await store.delete(provider);
+    console.log(`Logged out from ${provider}.`);
+    return;
+  }
+
+  await store.delete('copilot');
+  await store.delete('cursor');
+  console.log('Logged out from all providers.');
+}

package/src/commands/start.ts

@@ -1,7 +1,7 @@
-import { BridgeServer, loadConfig } from '@ai-ide-bridge/core';
-import { CursorBridgePlugin } from '@ai-ide-bridge/cursor';
-import { CopilotBridgePlugin } from '@ai-ide-bridge/copilot';
-import { WindsurfBridgePlugin } from '@ai-ide-bridge/windsurf';
+import { BridgeServer, loadConfig } from '../core/index.js';
+import { CursorBridgePlugin } from '../plugins/cursor/index.js';
+import { CopilotBridgePlugin } from '../plugins/copilot/index.js';
+import { WindsurfBridgePlugin } from '../plugins/windsurf/index.js';
 
 async function getPlugin(name: string) {
   switch (name) {

package/src/core/config.ts

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { BridgeConfig, DefaultConfig } from './types.js';
+
+export function configPath(): string {
+  const home = os.homedir();
+  return path.join(home, '.config', 'llm-bridge', 'config.json');
+}
+
+export function loadConfig(): BridgeConfig {
+  const envPort = process.env.LLM_BRIDGE_PORT;
+  const envHost = process.env.LLM_BRIDGE_HOST;
+
+  try {
+    const filePath = process.env.LLM_BRIDGE_CONFIG ?? configPath();
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      const fileConfig = JSON.parse(raw) as Partial<BridgeConfig>;
+      const config = { ...DefaultConfig, ...fileConfig };
+
+      if (fileConfig.activePlugin && !fileConfig.defaultPlugin) {
+        config.defaultPlugin = fileConfig.activePlugin;
+      }
+
+      if (envPort) config.port = parseInt(envPort, 10);
+      if (envHost) config.host = envHost;
+      return config;
+    }
+  } catch (err) {
+    console.warn('[llm-bridge] failed to load config file, using defaults:', err);
+  }
+
+  const config = { ...DefaultConfig };
+  if (envPort) config.port = parseInt(envPort, 10);
+  if (envHost) config.host = envHost;
+  return config;
+}
+
+export function saveConfig(config: BridgeConfig): void {
+  const filePath = configPath();
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+}

package/src/core/daemon-session.ts

@@ -0,0 +1,199 @@
+import type { ChildProcess } from 'node:child_process';
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from './types.js';
+import type { DaemonManager } from './daemon.js';
+
+const MAX_BUFFER_SIZE = 1024 * 1024;
+
+export class DaemonBridgeSession implements BridgeSession {
+  private proc: ChildProcess | null = null;
+  private requestId = 0;
+  private busy = false;
+
+  constructor(
+    private daemon: DaemonManager,
+    private token: string,
+    private model: string,
+    private cwd: string,
+  ) {}
+
+  async *send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk> {
+    if (this.busy) {
+      yield {
+        type: 'error',
+        content: 'Session is busy — concurrent send() calls are not supported',
+        finishReason: 'error',
+      };
+      return;
+    }
+    this.busy = true;
+
+    if (!this.proc) {
+      const binaryPath = await this.daemon.locate();
+      if (!binaryPath) {
+        this.busy = false;
+        throw new Error(`Daemon binary '${this.daemon.binaryName}' not found`);
+      }
+      this.proc = this.daemon.spawn(binaryPath, []);
+    }
+
+    const id = ++this.requestId;
+    const request = {
+      jsonrpc: '2.0',
+      id,
+      method: 'chat/completions',
+      params: {
+        token: this.token,
+        model: this.model,
+        messages,
+        stream: true,
+        tools: tools?.map((t) => ({
+          type: 'function' as const,
+          function: {
+            name: t.function.name,
+            description: t.function.description,
+            parameters: t.function.parameters,
+          },
+        })),
+      },
+    };
+
+    this.proc.stdin!.write(JSON.stringify(request) + '\n');
+
+    let buffer = '';
+    let stderrBuffer = '';
+    let finished = false;
+    let capturedError: Error | null = null;
+    let onDataResolve: (() => void) | null = null;
+
+    const onStderr = (data: Buffer) => {
+      stderrBuffer += data.toString();
+    };
+    this.proc.stderr?.on('data', onStderr);
+
+    const onData = (data: Buffer) => {
+      if (buffer.length <= MAX_BUFFER_SIZE) {
+        buffer += data.toString();
+      }
+      if (buffer.length > MAX_BUFFER_SIZE && !capturedError) {
+        capturedError = new Error(`stdout buffer exceeded max size of ${MAX_BUFFER_SIZE} bytes`);
+        onDataResolve?.();
+      }
+      onDataResolve?.();
+    };
+
+    const onError = (err: Error) => {
+      if (!capturedError) {
+        capturedError = err;
+        onDataResolve?.();
+      }
+    };
+
+    const onExit = (code: number | null) => {
+      if (!finished && !capturedError) {
+        capturedError = new Error(`Process exited with code ${code ?? 'unknown'}`);
+        onDataResolve?.();
+      }
+    };
+
+    this.proc.stdout!.on('data', onData);
+    this.proc.on('error', onError);
+    this.proc.on('exit', onExit);
+
+    try {
+      while (!finished) {
+        if (capturedError) {
+          const stderrInfo = stderrBuffer.trim() ? ` (stderr: ${stderrBuffer.slice(0, 500)})` : '';
+          yield {
+            type: 'error',
+            content: `Process error: ${(capturedError as Error).message}${stderrInfo}`,
+            finishReason: 'error',
+          };
+          break;
+        }
+
+        const newlineIndex = buffer.indexOf('\n');
+        if (newlineIndex === -1) {
+          const waitForData = new Promise<void>((resolve) => {
+            onDataResolve = resolve;
+          });
+          await waitForData;
+          continue;
+        }
+
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+
+        if (!line.trim()) continue;
+
+        let parsed: any;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+
+        if (parsed.error) {
+          yield {
+            type: 'error',
+            content: `JSON-RPC error: ${parsed.error.message}`,
+            finishReason: 'error',
+          };
+          finished = true;
+          continue;
+        }
+
+        if (parsed.method === 'chat/chunk' && parsed.params) {
+          const delta = parsed.params.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.name ?? '',
+                  arguments: tc.arguments ?? '',
+                },
+              };
+            }
+          }
+        }
+
+        if (parsed.method === 'chat/done' && parsed.params) {
+          const reason = parsed.params.finishReason;
+          yield {
+            type: 'done',
+            finishReason:
+              reason === 'stop'
+                ? 'stop'
+                : reason === 'tool_calls'
+                  ? 'tool_calls'
+                  : reason === 'length'
+                    ? 'length'
+                    : 'error',
+          };
+          finished = true;
+        }
+
+        if (parsed.id === id && parsed.result) {
+          finished = true;
+        }
+      }
+    } finally {
+      this.proc?.stdout?.removeListener('data', onData);
+      this.proc?.removeListener('error', onError);
+      this.proc?.removeListener('exit', onExit);
+      this.proc?.stderr?.removeListener('data', onStderr);
+      this.busy = false;
+    }
+  }
+
+  async dispose(): Promise<void> {
+    if (this.proc) {
+      this.proc.kill();
+      this.proc = null;
+    }
+  }
+}

package/src/core/daemon.ts

@@ -0,0 +1,206 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir, platform, arch } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { IncomingMessage, get as httpGet, request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { URL } from 'node:url';
+
+export interface DaemonManager {
+  binaryName: string;
+  locate(): Promise<string | null>;
+  download(): Promise<string>;
+  spawn(binaryPath: string, args: string[]): ChildProcess;
+  healthCheck(port?: number): Promise<boolean>;
+}
+
+export function createDaemonManager(config: {
+  binaryName: string;
+  downloadUrl: string;
+  checksum: string;
+  knownPaths: string[];
+  envVar?: string;
+  daemonsDir?: string;
+}): DaemonManager {
+  const defaultDaemonsDir = () => join(homedir(), '.llm-bridge', 'daemons');
+  const getDaemonsDir = () => config.daemonsDir ?? defaultDaemonsDir();
+
+  return {
+    binaryName: config.binaryName,
+
+    async locate(): Promise<string | null> {
+      if (config.envVar && process.env[config.envVar]) {
+        const envPath = process.env[config.envVar]!;
+        if (existsSync(envPath)) {
+          try {
+            accessSync(envPath, constants.X_OK);
+            return envPath;
+          } catch {
+            // Not executable, skip
+          }
+        }
+      }
+
+      for (const p of config.knownPaths) {
+        if (existsSync(p)) {
+          try {
+            accessSync(p, constants.X_OK);
+            return p;
+          } catch {
+            // Not executable, skip
+          }
+        }
+      }
+
+      const daemonsDir = getDaemonsDir();
+      const managedPath = join(daemonsDir, config.binaryName);
+      if (existsSync(managedPath)) {
+        try {
+          accessSync(managedPath, constants.X_OK);
+          return managedPath;
+        } catch {
+          // Not executable, skip
+        }
+      }
+
+      return null;
+    },
+
+    async download(): Promise<string> {
+      const daemonsDir = getDaemonsDir();
+      mkdirSync(daemonsDir, { recursive: true });
+      const destPath = join(daemonsDir, config.binaryName);
+
+      const url = config.downloadUrl.replace('{platform}', platform()).replace('{arch}', arch());
+
+      const MAX_REDIRECTS = 5;
+      const MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
+      let currentReq: ReturnType<typeof httpRequest> | null = null;
+
+      const followRedirect = (currentUrl: string, redirectCount: number): Promise<Buffer> =>
+        new Promise((resolve, reject) => {
+          const parsed = new URL(currentUrl);
+          const requestFn = parsed.protocol === 'https:' ? httpsRequest : httpRequest;
+
+          currentReq = requestFn(currentUrl, (res: IncomingMessage) => {
+            if (
+              res.statusCode === 301 ||
+              res.statusCode === 302 ||
+              res.statusCode === 307 ||
+              res.statusCode === 308
+            ) {
+              if (redirectCount >= MAX_REDIRECTS) {
+                reject(new Error('Too many redirects'));
+                return;
+              }
+              const location = res.headers.location;
+              if (location) {
+                const redirectUrl = new URL(location, currentUrl);
+                if (redirectUrl.protocol !== 'http:' && redirectUrl.protocol !== 'https:') {
+                  reject(new Error(`Redirect to unsupported protocol: ${redirectUrl.protocol}`));
+                  res.resume();
+                  return;
+                }
+                res.resume();
+                followRedirect(redirectUrl.href, redirectCount + 1)
+                  .then(resolve)
+                  .catch(reject);
+              } else {
+                reject(new Error('Redirect with no location'));
+              }
+              return;
+            }
+
+            if (res.statusCode !== 200) {
+              reject(new Error(`Download failed: ${res.statusCode}`));
+              return;
+            }
+
+            const chunks: Buffer[] = [];
+            let totalSize = 0;
+            res.on('data', (chunk: Buffer) => {
+              totalSize += chunk.length;
+              if (totalSize > MAX_DOWNLOAD_SIZE) {
+                reject(new Error(`Download exceeds maximum size (${MAX_DOWNLOAD_SIZE} bytes)`));
+                res.destroy();
+                return;
+              }
+              chunks.push(chunk);
+            });
+            res.on('end', () => {
+              resolve(Buffer.concat(chunks));
+            });
+          });
+
+          currentReq.on('error', reject);
+          currentReq.end();
+        });
+
+      const downloadPromise = followRedirect(url, 0);
+
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          currentReq?.destroy();
+          reject(new Error('Download timeout (30s)'));
+        }, 30000);
+      });
+
+      return Promise.race([downloadPromise, timeoutPromise]).then((data) => {
+        try {
+          writeFileSync(destPath, data);
+          const hash = createHash('sha256').update(data).digest('hex');
+          if (hash !== config.checksum) {
+            throw new Error(`Checksum mismatch: expected ${config.checksum}, got ${hash}`);
+          }
+          chmodSync(destPath, 0o755);
+          return destPath;
+        } catch (err) {
+          try {
+            unlinkSync(destPath);
+          } catch {}
+          throw err;
+        }
+      });
+    },
+
+    spawn(binaryPath: string, args: string[]): ChildProcess {
+      return spawn(binaryPath, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    },
+
+    async healthCheck(port?: number): Promise<boolean> {
+      const path = await this.locate();
+      if (!path) return false;
+      if (!existsSync(path)) return false;
+
+      if (port) {
+        try {
+          return new Promise((resolve) => {
+            const req = httpGet(`http://127.0.0.1:${port}/health`, (res) => {
+              resolve(res.statusCode === 200);
+            });
+            req.on('error', () => resolve(false));
+            req.setTimeout(5000, () => {
+              req.destroy();
+              resolve(false);
+            });
+          });
+        } catch {
+          return false;
+        }
+      }
+
+      return true;
+    },
+  };
+}

package/src/core/formatter.ts

@@ -0,0 +1,56 @@
+import type { StreamChunk } from './types.js';
+
+export function formatStreamChunk(chunk: StreamChunk, model: string, completionId: string): string {
+  const delta: Record<string, unknown> = {};
+  let finishReason: string | null = null;
+
+  if (chunk.type === 'text' && chunk.content) {
+    delta.content = chunk.content;
+  }
+
+  if (chunk.type === 'tool_call' && chunk.toolCall) {
+    delta.tool_calls = [
+      {
+        index: 0,
+        id: chunk.toolCall.id,
+        type: 'function',
+        function: { name: chunk.toolCall.name, arguments: chunk.toolCall.arguments },
+      },
+    ];
+  }
+
+  if (chunk.finishReason) {
+    finishReason = chunk.finishReason;
+  }
+
+  const payload = {
+    id: completionId,
+    object: 'chat.completion.chunk',
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  };
+
+  return `data: ${JSON.stringify(payload)}\n\n`;
+}
+
+export function formatCompletion(
+  content: string,
+  model: string,
+  completionId: string,
+): Record<string, unknown> {
+  return {
+    id: completionId,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant', content },
+        finish_reason: 'stop',
+      },
+    ],
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+}

package/src/core/index.ts

@@ -0,0 +1,9 @@
+export * from './types.js';
+export { BridgeServer } from './server.js';
+export { SessionStore } from './session.js';
+export { parseChatRequest, parseModelsRequest } from './parser.js';
+export { formatStreamChunk, formatCompletion } from './formatter.js';
+export { PluginRegistry } from './registry.js';
+export { loadConfig, saveConfig, configPath } from './config.js';
+export { createDaemonManager, type DaemonManager } from './daemon.js';
+export { DaemonBridgeSession } from './daemon-session.js';

package/src/core/parser.ts

@@ -0,0 +1,47 @@
+import http from 'node:http';
+import { z } from 'zod';
+import { MessageSchema, ToolDefinitionSchema } from './types.js';
+
+const ChatRequestSchema = z.object({
+  model: z.string().min(1, 'model is required'),
+  messages: z.array(MessageSchema).min(1, 'messages must have at least one message'),
+  stream: z.boolean().optional().default(false),
+  tools: z.array(ToolDefinitionSchema).optional(),
+  tool_choice: z.unknown().optional(),
+});
+
+export type ParsedChatRequest = z.infer<typeof ChatRequestSchema>;
+
+export async function parseChatRequest(
+  req: http.IncomingMessage,
+): Promise<{ success: true; data: ParsedChatRequest } | { success: false; error: string }> {
+  try {
+    const body = await readBody(req);
+    const json = JSON.parse(body);
+    const result = ChatRequestSchema.safeParse(json);
+    if (!result.success) {
+      return { success: false, error: result.error.errors[0].message };
+    }
+    return { success: true, data: result.data };
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      return { success: false, error: 'Invalid JSON body' };
+    }
+    return { success: false, error: e instanceof Error ? e.message : 'Unknown error' };
+  }
+}
+
+export function parseModelsRequest(
+  _req: http.IncomingMessage,
+): { success: true } | { success: false; error: string } {
+  return { success: true };
+}
+
+function readBody(req: http.IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (c) => chunks.push(c as Buffer));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+  });
+}