@ai-ide-bridge/cli 1.0.5 → 1.1.1

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);
+  });
+}

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;
+  }
+}