@ai-ide-bridge/cli 1.0.5 → 1.1.1

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.1 build /home/runner/work/llm-bridge/llm-bridge/cli
 > tsc
 

package/dist/commands/configure.js

@@ -1,5 +1,14 @@
 import { findOpencodeConfig, injectProvider } from '../utils/opencode.js';
 import { readConfig } from '../utils/config.js';
+import { createInterface } from 'node:readline';
+import { CursorBridgePlugin } from '../plugins/cursor/index.js';
+import { CopilotBridgePlugin } from '../plugins/copilot/index.js';
+import { WindsurfBridgePlugin } from '../plugins/windsurf/index.js';
+const PROVIDER_PLUGINS = {
+    cursor: CursorBridgePlugin,
+    copilot: CopilotBridgePlugin,
+    windsurf: WindsurfBridgePlugin,
+};
 export async function configureOpencodeCommand() {
     const configPath = findOpencodeConfig();
     if (!configPath) {
@@ -7,15 +16,74 @@ export async function configureOpencodeCommand() {
         process.exit(1);
     }
     const bridgeConfig = readConfig();
+    const configuredPlugins = Object.keys(bridgeConfig.plugins || {});
+    if (configuredPlugins.length === 0) {
+        console.error('No plugins configured. Run `llm-bridge init` first.');
+        process.exit(1);
+    }
+    const allSelectedModels = {};
+    let firstSelectedModelId = null;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    for (const pluginName of configuredPlugins) {
+        const PluginClass = PROVIDER_PLUGINS[pluginName];
+        if (!PluginClass) {
+            console.warn(`Skipping unknown provider: ${pluginName}`);
+            continue;
+        }
+        const plugin = new PluginClass();
+        const pluginConfig = bridgeConfig.plugins[pluginName];
+        let models;
+        try {
+            models = await plugin.listModels(pluginConfig);
+        }
+        catch (e) {
+            console.warn(`Failed to list models for ${pluginName}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
+        if (models.length === 0) {
+            console.warn(`No models available for ${pluginName}.`);
+            continue;
+        }
+        console.log(`\nModels available for ${pluginName}:`);
+        models.forEach((m, i) => {
+            console.log(`  ${i + 1}) ${pluginName}/${m.id}`);
+        });
+        const input = await ask(`Select models (comma-separated numbers, 'all', or 'skip'): `);
+        let selectedIndices = [];
+        if (input.toLowerCase() === 'all') {
+            selectedIndices = models.map((_, i) => i);
+        }
+        else if (input.toLowerCase() === 'skip') {
+            continue;
+        }
+        else {
+            selectedIndices = input
+                .split(',')
+                .map((s) => parseInt(s.trim(), 10) - 1)
+                .filter((i) => i >= 0 && i < models.length);
+        }
+        if (selectedIndices.length === 0) {
+            console.log(`No models selected for ${pluginName}. Skipping.`);
+            continue;
+        }
+        for (const idx of selectedIndices) {
+            const model = models[idx];
+            const qualifiedId = `${pluginName}/${model.id}`;
+            allSelectedModels[qualifiedId] = { name: qualifiedId };
+            if (!firstSelectedModelId) {
+                firstSelectedModelId = qualifiedId;
+            }
+        }
+    }
+    rl.close();
+    if (Object.keys(allSelectedModels).length === 0) {
+        console.error('No models selected. Run `llm-bridge configure` again to try again.');
+        process.exit(1);
+    }
     const providerId = 'llm-bridge';
-    const plugin = bridgeConfig.defaultPlugin ?? 'cursor';
-    const modelId = plugin === 'copilot'
-        ? 'copilot/gpt-4o-copilot'
-        : plugin === 'windsurf'
-            ? 'windsurf/claude-4.5-sonnet'
-            : 'cursor/composer-2';
-    injectProvider(configPath, providerId, modelId, bridgeConfig.port);
-    console.log(`Injected provider into ${configPath}`);
-    console.log(`Provider: ${providerId}, Model: ${modelId}, Port: ${bridgeConfig.port}`);
-    console.log(`Plugin: ${plugin}`);
+    injectProvider(configPath, providerId, allSelectedModels, bridgeConfig.port, firstSelectedModelId);
+    const modelCount = Object.keys(allSelectedModels).length;
+    console.log(`\nInjected provider into ${configPath}`);
+    console.log(`Provider: ${providerId}, Models: ${modelCount}, Default: ${firstSelectedModelId}`);
 }

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,10 @@
 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 { stdin as processStdin, stdout as processStdout } from 'node:process';
+import { loginCommand } from './login.js';
 const PROVIDERS = ['cursor', 'copilot', 'windsurf'];
 async function getProviderPlugin(provider) {
     switch (provider) {
@@ -19,7 +21,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 +36,52 @@ 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;
+}
+async function askHidden(prompt) {
+    return new Promise((resolve, reject) => {
+        const stdin = processStdin;
+        const stdout = processStdout;
+        stdout.write(prompt);
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        let input = '';
+        const onData = (data) => {
+            const char = data.toString();
+            if (char === '\r' || char === '\n') {
+                stdin.setRawMode(wasRaw);
+                stdin.pause();
+                stdin.removeListener('data', onData);
+                stdout.write('\n');
+                resolve(input);
+            }
+            else if (char === '\x7f' || char === '\b') {
+                if (input.length > 0) {
+                    input = input.slice(0, -1);
+                    stdout.write('\b \b');
+                }
+            }
+            else if (char === '\x03') {
+                stdin.setRawMode(wasRaw);
+                stdin.pause();
+                stdin.removeListener('data', onData);
+                process.exit(1);
+            }
+            else {
+                input += char;
+                stdout.write('*');
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
 export async function initCommand() {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
@@ -55,8 +103,25 @@ 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));
+        const credential = await askHidden(getCredentialPrompt(provider));
         if (!credential) {
             console.error('Credential is required.');
             continue;

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