@ai-ide-bridge/cli 1.0.5 → 1.1.1

package/src/commands/daemon.ts

@@ -2,20 +2,31 @@ 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';
+import { createWindsurfDaemon } from '../plugins/windsurf/daemon.js';
+import { getPlatform } from '../utils/platform.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 const LABEL = 'com.llm-bridge.daemon';
 
 export async function installDaemonCommand(): Promise<void> {
-  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(): Promise<void> {
   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">
@@ -40,8 +51,13 @@ export async function installDaemonCommand(): Promise<void> {
 </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' });
@@ -53,12 +69,58 @@ export async function installDaemonCommand(): Promise<void> {
   }
 }
 
+async function installLinuxDaemon(): Promise<void> {
+  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(): Promise<void> {
-  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(): Promise<void> {
   const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
 
   try {
@@ -77,8 +139,32 @@ export async function uninstallDaemonCommand(): Promise<void> {
   }
 }
 
+async function uninstallLinuxDaemon(): Promise<void> {
+  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(): Promise<void> {
-  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
   const daemon = createWindsurfDaemon();
 
   const path = await daemon.locate();
@@ -93,7 +179,6 @@ export async function daemonStatusCommand(): Promise<void> {
 }
 
 export async function daemonDownloadCommand(): Promise<void> {
-  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
   const daemon = createWindsurfDaemon();
 
   console.log('Downloading Windsurf language server...');
@@ -107,7 +192,6 @@ export async function daemonDownloadCommand(): Promise<void> {
 }
 
 export async function daemonLocateCommand(): Promise<void> {
-  const { createWindsurfDaemon } = await import('@ai-ide-bridge/windsurf/daemon.js');
   const daemon = createWindsurfDaemon();
 
   const path = await daemon.locate();
@@ -118,3 +202,18 @@ export async function daemonLocateCommand(): Promise<void> {
     process.exit(1);
   }
 }
+
+export async function daemonReloadCommand(): Promise<void> {
+  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/src/commands/doctor.ts

@@ -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(): Promise<void> {
   const config = readConfig();

package/src/commands/init.ts

@@ -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'] as const;
 type Provider = (typeof PROVIDERS)[number];
@@ -23,7 +25,7 @@ function getCredentialPrompt(provider: Provider): string {
     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: ';
   }
@@ -40,6 +42,56 @@ function getEnvVar(provider: Provider): string {
   }
 }
 
+async function authenticateWithOAuth(provider: Provider): Promise<boolean> {
+  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: string): Promise<string> {
+  return new Promise<string>((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: Buffer) => {
+      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(): Promise<void> {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const ask = (q: string) => new Promise<string>((resolve) => rl.question(q, resolve));
@@ -69,8 +121,23 @@ export async function initCommand(): Promise<void> {
 
     const provider = input as Provider;
 
+    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/src/commands/login.ts

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

@@ -0,0 +1,15 @@
+import { createTokenStore } from '../oauth/index.js';
+
+export async function logoutCommand(provider?: string): Promise<void> {
+  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/src/commands/start.ts

@@ -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: string) {
   switch (name) {

package/src/core/config.ts

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

package/src/core/daemon-session.ts

@@ -0,0 +1,199 @@
+import type { ChildProcess } from 'node:child_process';
+import type { BridgeSession, Message, ToolDefinition, StreamChunk } from './types.js';
+import type { DaemonManager } from './daemon.js';
+
+const MAX_BUFFER_SIZE = 1024 * 1024;
+
+export class DaemonBridgeSession implements BridgeSession {
+  private proc: ChildProcess | null = null;
+  private requestId = 0;
+  private busy = false;
+
+  constructor(
+    private daemon: DaemonManager,
+    private token: string,
+    private model: string,
+    private cwd: string,
+  ) {}
+
+  async *send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk> {
+    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' as const,
+          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: Error | null = null;
+    let onDataResolve: (() => void) | null = null;
+
+    const onStderr = (data: Buffer) => {
+      stderrBuffer += data.toString();
+    };
+    this.proc.stderr?.on('data', onStderr);
+
+    const onData = (data: Buffer) => {
+      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: Error) => {
+      if (!capturedError) {
+        capturedError = err;
+        onDataResolve?.();
+      }
+    };
+
+    const onExit = (code: number | null) => {
+      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 as Error).message}${stderrInfo}`,
+            finishReason: 'error',
+          };
+          break;
+        }
+
+        const newlineIndex = buffer.indexOf('\n');
+        if (newlineIndex === -1) {
+          const waitForData = new Promise<void>((resolve) => {
+            onDataResolve = resolve;
+          });
+          await waitForData;
+          continue;
+        }
+
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+
+        if (!line.trim()) continue;
+
+        let parsed: any;
+        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(): Promise<void> {
+    if (this.proc) {
+      this.proc.kill();
+      this.proc = null;
+    }
+  }
+}