@ai-ide-bridge/cli 1.0.5 → 1.1.1

package/dist/core/daemon-session.js

@@ -0,0 +1,179 @@
+const MAX_BUFFER_SIZE = 1024 * 1024;
+export class DaemonBridgeSession {
+    daemon;
+    token;
+    model;
+    cwd;
+    proc = null;
+    requestId = 0;
+    busy = false;
+    constructor(daemon, token, model, cwd) {
+        this.daemon = daemon;
+        this.token = token;
+        this.model = model;
+        this.cwd = cwd;
+    }
+    async *send(messages, tools) {
+        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',
+                    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 = null;
+        let onDataResolve = null;
+        const onStderr = (data) => {
+            stderrBuffer += data.toString();
+        };
+        this.proc.stderr?.on('data', onStderr);
+        const onData = (data) => {
+            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) => {
+            if (!capturedError) {
+                capturedError = err;
+                onDataResolve?.();
+            }
+        };
+        const onExit = (code) => {
+            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.message}${stderrInfo}`,
+                        finishReason: 'error',
+                    };
+                    break;
+                }
+                const newlineIndex = buffer.indexOf('\n');
+                if (newlineIndex === -1) {
+                    const waitForData = new Promise((resolve) => {
+                        onDataResolve = resolve;
+                    });
+                    await waitForData;
+                    continue;
+                }
+                const line = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line.trim())
+                    continue;
+                let parsed;
+                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() {
+        if (this.proc) {
+            this.proc.kill();
+            this.proc = null;
+        }
+    }
+}

package/dist/core/daemon.d.ts

@@ -0,0 +1,16 @@
+import { type ChildProcess } from 'node:child_process';
+export interface DaemonManager {
+    binaryName: string;
+    locate(): Promise<string | null>;
+    download(): Promise<string>;
+    spawn(binaryPath: string, args: string[]): ChildProcess;
+    healthCheck(port?: number): Promise<boolean>;
+}
+export declare function createDaemonManager(config: {
+    binaryName: string;
+    downloadUrl: string;
+    checksum: string;
+    knownPaths: string[];
+    envVar?: string;
+    daemonsDir?: string;
+}): DaemonManager;

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