@ai-ide-bridge/cli 1.0.5 → 1.1.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @ai-ide-bridge/cli@1.0.5 build /home/runner/work/llm-bridge/llm-bridge/cli
+> @ai-ide-bridge/cli@1.1.0 build /home/runner/work/llm-bridge/llm-bridge/cli
 > tsc
 

package/dist/commands/daemon.d.ts

@@ -3,3 +3,4 @@ export declare function uninstallDaemonCommand(): Promise<void>;
 export declare function daemonStatusCommand(): Promise<void>;
 export declare function daemonDownloadCommand(): Promise<void>;
 export declare function daemonLocateCommand(): Promise<void>;
+export declare function daemonReloadCommand(): Promise<void>;

package/dist/commands/daemon.js

@@ -2,17 +2,25 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { execSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { createWindsurfDaemon } from '../plugins/windsurf/daemon.js';
+import { getPlatform } from '../utils/platform.js';
 const LABEL = 'com.llm-bridge.daemon';
 export async function installDaemonCommand() {
-    if (process.platform !== 'darwin') {
-        console.error('Daemon installation is only supported on macOS.');
+    const platform = getPlatform();
+    if (platform === 'darwin') {
+        await installMacOSDaemon();
+    }
+    else if (platform === 'linux') {
+        await installLinuxDaemon();
+    }
+    else {
+        console.error('Daemon installation is only supported on macOS and Linux.');
         process.exit(1);
     }
+}
+async function installMacOSDaemon() {
     const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
-    const wrapperPath = path.join(__dirname, '..', '..', 'scripts', 'llm-bridge-daemon.sh');
+    const wrapperPath = path.join(path.dirname(process.execPath), '..', 'scripts', 'llm-bridge-daemon.sh');
     const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -35,8 +43,14 @@ export async function installDaemonCommand() {
   <string>${os.homedir()}/Library/Logs/llm-bridge.err.log</string>
 </dict>
 </plist>`;
-    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
-    fs.writeFileSync(plistPath, plist);
+    try {
+        fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+        fs.writeFileSync(plistPath, plist);
+    }
+    catch (e) {
+        console.error('Failed to write plist file:', e);
+        process.exit(1);
+    }
     try {
         execSync(`launchctl bootstrap "gui/$(id -u)" "${plistPath}"`, { stdio: 'inherit' });
         console.log(`Installed LaunchAgent: ${plistPath}`);
@@ -47,11 +61,56 @@ export async function installDaemonCommand() {
         process.exit(1);
     }
 }
+async function installLinuxDaemon() {
+    const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+    const servicePath = path.join(serviceDir, 'llm-bridge.service');
+    const binaryPath = process.execPath;
+    const unit = `[Unit]
+Description=llm-bridge daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${binaryPath} start
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+    try {
+        fs.mkdirSync(serviceDir, { recursive: true });
+        fs.writeFileSync(servicePath, unit);
+    }
+    catch (e) {
+        console.error('Failed to write service file:', e);
+        process.exit(1);
+    }
+    try {
+        execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+        execSync('systemctl --user enable --now llm-bridge', { stdio: 'inherit' });
+        console.log(`Installed systemd user service: ${servicePath}`);
+        console.log('Logs: journalctl --user -u llm-bridge -f');
+    }
+    catch (e) {
+        console.error('Failed to enable systemd service:', e);
+        process.exit(1);
+    }
+}
 export async function uninstallDaemonCommand() {
-    if (process.platform !== 'darwin') {
-        console.error('Daemon uninstallation is only supported on macOS.');
+    const platform = getPlatform();
+    if (platform === 'darwin') {
+        await uninstallMacOSDaemon();
+    }
+    else if (platform === 'linux') {
+        await uninstallLinuxDaemon();
+    }
+    else {
+        console.error('Daemon uninstallation is only supported on macOS and Linux.');
         process.exit(1);
     }
+}
+async function uninstallMacOSDaemon() {
     const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
     try {
         execSync(`launchctl bootout "gui/$(id -u)" "${plistPath}" 2>/dev/null || true`, {
@@ -69,8 +128,31 @@ export async function uninstallDaemonCommand() {
         console.log('No LaunchAgent found.');
     }
 }
+async function uninstallLinuxDaemon() {
+    const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', 'llm-bridge.service');
+    try {
+        execSync('systemctl --user disable --now llm-bridge 2>/dev/null || true', {
+            stdio: 'inherit',
+        });
+    }
+    catch {
+        // Ignore errors during disable
+    }
+    if (fs.existsSync(servicePath)) {
+        fs.unlinkSync(servicePath);
+        console.log(`Removed systemd service: ${servicePath}`);
+    }
+    else {
+        console.log('No systemd service found.');
+    }
+    try {
+        execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+    }
+    catch {
+        // Ignore errors during reload
+    }
+}
 export async function daemonStatusCommand() {
-    const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
     const daemon = createWindsurfDaemon();
     const path = await daemon.locate();
     if (path) {
@@ -84,7 +166,6 @@ export async function daemonStatusCommand() {
     }
 }
 export async function daemonDownloadCommand() {
-    const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
     const daemon = createWindsurfDaemon();
     console.log('Downloading Windsurf language server...');
     try {
@@ -97,7 +178,6 @@ export async function daemonDownloadCommand() {
     }
 }
 export async function daemonLocateCommand() {
-    const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
     const daemon = createWindsurfDaemon();
     const path = await daemon.locate();
     if (path) {
@@ -108,3 +188,17 @@ export async function daemonLocateCommand() {
         process.exit(1);
     }
 }
+export async function daemonReloadCommand() {
+    if (getPlatform() !== 'linux') {
+        console.error('Daemon reload is only supported on Linux.');
+        process.exit(1);
+    }
+    try {
+        execSync('systemctl --user reload-or-restart llm-bridge', { stdio: 'inherit' });
+        console.log('Daemon reloaded.');
+    }
+    catch (e) {
+        console.error('Failed to reload daemon:', e);
+        process.exit(1);
+    }
+}

package/dist/commands/doctor.js

@@ -1,7 +1,7 @@
 import http from 'node:http';
 import { readConfig } from '../utils/config.js';
 import fs from 'node:fs';
-import { configPath } from '@ai-ide-bridge/core';
+import { configPath } from '../core/index.js';
 export async function doctorCommand() {
     const config = readConfig();
     console.log('llm-bridge diagnostics\n');

package/dist/commands/init.js

@@ -1,8 +1,9 @@
 import { setPluginConfig, writeConfig, readConfig } from '../utils/config.js';
-import { CursorBridgePlugin } from '@ai-ide-bridge/cursor';
-import { CopilotBridgePlugin } from '@ai-ide-bridge/copilot';
-import { WindsurfBridgePlugin } from '@ai-ide-bridge/windsurf';
+import { CursorBridgePlugin } from '../plugins/cursor/index.js';
+import { CopilotBridgePlugin } from '../plugins/copilot/index.js';
+import { WindsurfBridgePlugin } from '../plugins/windsurf/index.js';
 import { createInterface } from 'node:readline';
+import { loginCommand } from './login.js';
 const PROVIDERS = ['cursor', 'copilot', 'windsurf'];
 async function getProviderPlugin(provider) {
     switch (provider) {
@@ -19,7 +20,7 @@ function getCredentialPrompt(provider) {
         case 'cursor':
             return 'Enter your CURSOR_API_KEY: ';
         case 'copilot':
-            return 'Enter your GITHUB_TOKEN: ';
+            return 'Enter your GITHUB_TOKEN (or leave empty for OAuth): ';
         case 'windsurf':
             return 'Enter your WINDSURF_TOKEN: ';
     }
@@ -34,6 +35,14 @@ function getEnvVar(provider) {
             return 'WINDSURF_TOKEN';
     }
 }
+async function authenticateWithOAuth(provider) {
+    if (provider === 'copilot') {
+        await loginCommand('copilot');
+        return true;
+    }
+    console.log(`OAuth not available for ${provider}. Use token authentication instead.`);
+    return false;
+}
 export async function initCommand() {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
@@ -55,6 +64,23 @@ export async function initCommand() {
             break;
         }
         const provider = input;
+        if (provider === 'copilot') {
+            const method = await ask('Auth method (token/oauth): ');
+            if (method.toLowerCase() === 'oauth') {
+                const ok = await authenticateWithOAuth(provider);
+                if (!ok)
+                    continue;
+                console.log(`Authentication successful for ${provider}.`);
+                setPluginConfig(provider, { COPILOT_OAUTH: 'true' });
+                configuredProviders.push(provider);
+                if (!firstProvider)
+                    firstProvider = provider;
+                const more = await ask('Configure another provider? (y/n): ');
+                if (more.toLowerCase() !== 'y')
+                    break;
+                continue;
+            }
+        }
         const envVar = getEnvVar(provider);
         const credential = await ask(getCredentialPrompt(provider));
         if (!credential) {

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(provider?: string): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,62 @@
+import { createInterface } from 'node:readline';
+import { createTokenStore, DeviceFlow, providers } from '../oauth/index.js';
+const SUPPORTED_PROVIDERS = ['copilot', 'cursor'];
+export async function loginCommand(provider) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    let providerId;
+    if (provider && SUPPORTED_PROVIDERS.includes(provider)) {
+        providerId = provider;
+    }
+    else {
+        const input = await ask(`Provider to login (${SUPPORTED_PROVIDERS.join(', ')}): `);
+        if (!SUPPORTED_PROVIDERS.includes(input)) {
+            console.error(`Unknown provider: ${input}`);
+            rl.close();
+            process.exit(1);
+        }
+        providerId = input;
+    }
+    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, provider, store) {
+    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) {
+        console.error(`\nAuthentication failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function loginWithPKCE(rl, provider, store) {
+    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/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logoutCommand(provider?: string): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,12 @@
+import { createTokenStore } from '../oauth/index.js';
+export async function logoutCommand(provider) {
+    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/dist/commands/start.js

@@ -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) {
     switch (name) {
         case 'cursor':

package/dist/core/config.d.ts

@@ -0,0 +1,4 @@
+import { BridgeConfig } from './types.js';
+export declare function configPath(): string;
+export declare function loadConfig(): BridgeConfig;
+export declare function saveConfig(config: BridgeConfig): void;

package/dist/core/config.js

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DefaultConfig } from './types.js';
+export function configPath() {
+    const home = os.homedir();
+    return path.join(home, '.config', 'llm-bridge', 'config.json');
+}
+export function loadConfig() {
+    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);
+            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) {
+    const filePath = configPath();
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
+}

package/dist/core/daemon-session.d.ts

@@ -0,0 +1,14 @@
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from './types.js';
+import type { DaemonManager } from './daemon.js';
+export declare class DaemonBridgeSession implements BridgeSession {
+    private daemon;
+    private token;
+    private model;
+    private cwd;
+    private proc;
+    private requestId;
+    private busy;
+    constructor(daemon: DaemonManager, token: string, model: string, cwd: string);
+    send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk>;
+    dispose(): Promise<void>;
+}

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;