@ai-ide-bridge/cli 1.0.5 → 1.1.1

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

package/dist/core/server.js

@@ -0,0 +1,185 @@
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { DefaultConfig } 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 {
+    server = null;
+    registry;
+    sessions;
+    config;
+    constructor(config = {}) {
+        this.config = { ...DefaultConfig, ...config };
+        this.registry = new PluginRegistry();
+        this.sessions = new SessionStore(this.config.sessionTTL);
+    }
+    async start() {
+        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() {
+        await this.sessions.disposeAll();
+        return new Promise((resolve) => {
+            this.server?.close(() => resolve());
+        });
+    }
+    address() {
+        return this.server?.address() ?? null;
+    }
+    async handleRequest(req, res) {
+        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' } });
+    }
+    async handleModels(_req, res) {
+        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 = [];
+            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' } });
+        }
+    }
+    resolvePlugin(model) {
+        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 };
+    }
+    async handleChatCompletions(req, res) {
+        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'];
+            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 = [];
+            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' } });
+            }
+        }
+    }
+    jsonResponse(res, status, body) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(body));
+    }
+    registerPlugin(plugin) {
+        this.registry.register(plugin);
+    }
+    setActivePlugin(name) {
+        this.registry.setActive(name);
+    }
+    setDefaultPlugin(name) {
+        this.registry.setDefault(name);
+    }
+}

package/dist/core/session.d.ts

@@ -0,0 +1,11 @@
+import type { BridgeSession } from './types.js';
+export declare class SessionStore {
+    private sessions;
+    private ttlMs;
+    constructor(ttlSeconds?: number);
+    set(id: string, session: BridgeSession): void;
+    get(id: string): BridgeSession | undefined;
+    cleanup(): void;
+    disposeAll(): Promise<void>;
+    get size(): number;
+}

package/dist/core/session.js

@@ -0,0 +1,39 @@
+export class SessionStore {
+    sessions = new Map();
+    ttlMs;
+    constructor(ttlSeconds = 1800) {
+        this.ttlMs = ttlSeconds * 1000;
+    }
+    set(id, session) {
+        this.sessions.set(id, { session, lastActive: Date.now() });
+    }
+    get(id) {
+        const entry = this.sessions.get(id);
+        if (entry) {
+            entry.lastActive = Date.now();
+            return entry.session;
+        }
+        return undefined;
+    }
+    cleanup() {
+        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() {
+        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() {
+        return this.sessions.size;
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+export declare const MessageSchema: 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;
+}>;
+export type Message = z.infer<typeof MessageSchema>;
+export declare const ToolDefinitionSchema: 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";
+}>;
+export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+export declare const ModelInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodBoolean>;
+        tools: z.ZodOptional<z.ZodBoolean>;
+        vision: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        streaming?: boolean | undefined;
+        tools?: boolean | undefined;
+        vision?: boolean | undefined;
+    }, {
+        streaming?: boolean | undefined;
+        tools?: boolean | undefined;
+        vision?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    capabilities?: {
+        streaming?: boolean | undefined;
+        tools?: boolean | undefined;
+        vision?: boolean | undefined;
+    } | undefined;
+}, {
+    name: string;
+    id: string;
+    capabilities?: {
+        streaming?: boolean | undefined;
+        tools?: boolean | undefined;
+        vision?: boolean | undefined;
+    } | undefined;
+}>;
+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 declare const DefaultConfig: BridgeConfig;

package/dist/core/types.js

@@ -0,0 +1,44 @@
+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 const ToolDefinitionSchema = z.object({
+    type: z.literal('function'),
+    function: z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        parameters: z.record(z.unknown()),
+    }),
+});
+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 const DefaultConfig = {
+    defaultPlugin: 'cursor',
+    port: 3849,
+    host: '127.0.0.1',
+    plugins: {},
+    sessionTTL: 1800,
+    toolMode: 'lenient',
+};

package/dist/index.js

@@ -3,8 +3,10 @@ import { initCommand } from './commands/init.js';
 import { startCommand } from './commands/start.js';
 import { configureOpencodeCommand } from './commands/configure.js';
 import { doctorCommand } from './commands/doctor.js';
-import { daemonStatusCommand, daemonDownloadCommand, daemonLocateCommand, } from './commands/daemon.js';
+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';
 async function main() {
     switch (command) {
@@ -38,11 +40,24 @@ async function main() {
                 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
@@ -50,11 +65,13 @@ async function main() {
 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/dist/oauth/device-flow.d.ts

@@ -0,0 +1,12 @@
+import type { OAuthConfig, StoredToken, DeviceCodeResponse } from './types.js';
+export declare class DeviceFlow {
+    private config;
+    private deviceCode;
+    private interval;
+    private expiresAt;
+    private firstPoll;
+    constructor(config: OAuthConfig);
+    start(): Promise<DeviceCodeResponse>;
+    poll(): Promise<StoredToken>;
+    private sleep;
+}

package/dist/oauth/device-flow.js

@@ -0,0 +1,93 @@
+const SLOW_DOWN_BACKOFF_MS = 5000;
+const DEFAULT_POLL_INTERVAL_S = 5;
+const DEFAULT_TOKEN_EXPIRY_S = 3600;
+export class DeviceFlow {
+    config;
+    deviceCode = '';
+    interval = DEFAULT_POLL_INTERVAL_S * 1000;
+    expiresAt = 0;
+    firstPoll = true;
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        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());
+        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;
+        this.interval = (data.interval ?? DEFAULT_POLL_INTERVAL_S) * 1000;
+        this.expiresAt = Date.now() + data.expires_in * 1000;
+        this.firstPoll = true;
+        return {
+            deviceCode: this.deviceCode,
+            userCode: data.user_code,
+            verificationUri: data.verification_uri,
+            expiresIn: data.expires_in,
+            interval: data.interval ?? DEFAULT_POLL_INTERVAL_S,
+        };
+    }
+    async poll() {
+        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());
+            if (response.ok) {
+                if (!data.access_token) {
+                    throw new Error('Invalid token response: missing access_token');
+                }
+                const token = {
+                    version: 1,
+                    accessToken: data.access_token,
+                    refreshToken: data.refresh_token,
+                    expiresAt: Date.now() + (data.expires_in ?? DEFAULT_TOKEN_EXPIRY_S) * 1000,
+                    scopes: data.scope?.split(' ') ?? this.config.provider.scopes,
+                };
+                await this.config.store.set(this.config.provider.id, token);
+                return token;
+            }
+            const error = data.error;
+            if (error === 'slow_down') {
+                this.interval += (data.interval ?? 0) * 1000 + SLOW_DOWN_BACKOFF_MS;
+            }
+            else if (error !== 'authorization_pending') {
+                throw new Error(`Device flow error: ${error}`);
+            }
+        }
+        throw new Error('Device flow expired');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}