@ai-ide-bridge/cli 1.0.4 → 1.1.0

package/dist/core/daemon.js

@@ -0,0 +1,168 @@
+import { spawn } 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 { get as httpGet, request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { URL } from 'node:url';
+export function createDaemonManager(config) {
+    const defaultDaemonsDir = () => join(homedir(), '.llm-bridge', 'daemons');
+    const getDaemonsDir = () => config.daemonsDir ?? defaultDaemonsDir();
+    return {
+        binaryName: config.binaryName,
+        async locate() {
+            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() {
+            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 = null;
+            const followRedirect = (currentUrl, redirectCount) => new Promise((resolve, reject) => {
+                const parsed = new URL(currentUrl);
+                const requestFn = parsed.protocol === 'https:' ? httpsRequest : httpRequest;
+                currentReq = requestFn(currentUrl, (res) => {
+                    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 = [];
+                    let totalSize = 0;
+                    res.on('data', (chunk) => {
+                        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((_, 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, args) {
+            return spawn(binaryPath, args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        },
+        async healthCheck(port) {
+            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/dist/core/formatter.d.ts

@@ -0,0 +1,3 @@
+import type { StreamChunk } from './types.js';
+export declare function formatStreamChunk(chunk: StreamChunk, model: string, completionId: string): string;
+export declare function formatCompletion(content: string, model: string, completionId: string): Record<string, unknown>;

package/dist/core/formatter.js

@@ -0,0 +1,44 @@
+export function formatStreamChunk(chunk, model, completionId) {
+    const delta = {};
+    let finishReason = 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, model, completionId) {
+    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/dist/core/index.d.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/dist/core/index.js

@@ -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 } from './daemon.js';
+export { DaemonBridgeSession } from './daemon-session.js';

package/dist/core/parser.d.ts

@@ -0,0 +1,164 @@
+import http from 'node:http';
+import { z } from 'zod';
+declare const ChatRequestSchema: z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant", "tool", "function"]>;
+        content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodString>;
+        tool_call_id: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string;
+            }, {
+                name: string;
+                arguments: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role: "function" | "system" | "user" | "assistant" | "tool";
+        content?: string | null | undefined;
+        name?: string | undefined;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }, {
+        role: "function" | "system" | "user" | "assistant" | "tool";
+        content?: string | null | undefined;
+        name?: string | undefined;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }>, "many">;
+    stream: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        }, {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }, {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }>, "many">>;
+    tool_choice: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    messages: {
+        role: "function" | "system" | "user" | "assistant" | "tool";
+        content?: string | null | undefined;
+        name?: string | undefined;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }[];
+    stream: boolean;
+    tools?: {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }[] | undefined;
+    tool_choice?: unknown;
+}, {
+    model: string;
+    messages: {
+        role: "function" | "system" | "user" | "assistant" | "tool";
+        content?: string | null | undefined;
+        name?: string | undefined;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }[];
+    tools?: {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }[] | undefined;
+    stream?: boolean | undefined;
+    tool_choice?: unknown;
+}>;
+export type ParsedChatRequest = z.infer<typeof ChatRequestSchema>;
+export declare function parseChatRequest(req: http.IncomingMessage): Promise<{
+    success: true;
+    data: ParsedChatRequest;
+} | {
+    success: false;
+    error: string;
+}>;
+export declare function parseModelsRequest(_req: http.IncomingMessage): {
+    success: true;
+} | {
+    success: false;
+    error: string;
+};
+export {};

package/dist/core/parser.js

@@ -0,0 +1,37 @@
+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 async function parseChatRequest(req) {
+    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) {
+    return { success: true };
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}

package/dist/core/registry.d.ts

@@ -0,0 +1,16 @@
+import type { BridgePlugin, PluginHealth } from './types.js';
+export declare class PluginRegistry {
+    private plugins;
+    private activePluginName;
+    private defaultPluginName;
+    private health;
+    register(plugin: BridgePlugin): void;
+    getPlugin(name: string): BridgePlugin | undefined;
+    setActive(name: string): void;
+    setDefault(name: string): void;
+    getActivePlugin(): BridgePlugin | null;
+    getDefaultPlugin(): BridgePlugin | null;
+    listPlugins(): BridgePlugin[];
+    markUnhealthy(name: string, error: string): void;
+    getHealth(name: string): PluginHealth | undefined;
+}

package/dist/core/registry.js

@@ -0,0 +1,53 @@
+export class PluginRegistry {
+    plugins = new Map();
+    activePluginName = null;
+    defaultPluginName = null;
+    health = new Map();
+    register(plugin) {
+        this.plugins.set(plugin.name, plugin);
+        this.health.set(plugin.name, {
+            name: plugin.name,
+            healthy: true,
+            lastChecked: new Date(),
+        });
+    }
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+    setActive(name) {
+        if (!this.plugins.has(name)) {
+            throw new Error(`Plugin "${name}" is not registered`);
+        }
+        this.activePluginName = name;
+    }
+    setDefault(name) {
+        if (!this.plugins.has(name)) {
+            throw new Error(`Plugin "${name}" is not registered`);
+        }
+        this.defaultPluginName = name;
+    }
+    getActivePlugin() {
+        if (!this.activePluginName)
+            return null;
+        return this.plugins.get(this.activePluginName) ?? null;
+    }
+    getDefaultPlugin() {
+        if (!this.defaultPluginName)
+            return null;
+        return this.plugins.get(this.defaultPluginName) ?? null;
+    }
+    listPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    markUnhealthy(name, error) {
+        this.health.set(name, {
+            name,
+            healthy: false,
+            lastChecked: new Date(),
+            error,
+        });
+    }
+    getHealth(name) {
+        return this.health.get(name);
+    }
+}

package/dist/core/server.d.ts

@@ -0,0 +1,19 @@
+import { BridgeConfig, BridgePlugin } from './types.js';
+export declare class BridgeServer {
+    private server;
+    private registry;
+    private sessions;
+    private config;
+    constructor(config?: Partial<BridgeConfig>);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    address(): import('net').AddressInfo | string | null;
+    private handleRequest;
+    private handleModels;
+    private resolvePlugin;
+    private handleChatCompletions;
+    private jsonResponse;
+    registerPlugin(plugin: BridgePlugin): void;
+    setActivePlugin(name: string): void;
+    setDefaultPlugin(name: string): void;
+}