@chrisromp/copilot-bridge 0.6.0-dev.2

package/scripts/lib/prerequisites.ts

@@ -0,0 +1,86 @@
+/**
+ * Prerequisite checks shared between init and check commands.
+ * Validates Node.js version, GitHub Copilot CLI, and auth status.
+ */
+
+import { execSync } from 'node:child_process';
+import type { CheckResult } from './output.js';
+
+export function checkNodeVersion(): CheckResult {
+  const version = process.version; // e.g., "v22.0.0"
+  const major = parseInt(version.slice(1).split('.')[0], 10);
+  if (major >= 20) {
+    return { status: 'pass', label: `Node.js ${version}` };
+  }
+  return { status: 'fail', label: `Node.js ${version}`, detail: 'requires v20 or higher' };
+}
+
+function tryCommand(cmd: string): string | null {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', timeout: 10_000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function checkCopilotCLI(): CheckResult {
+  // Try gh copilot first (GitHub CLI extension), then standalone copilot
+  const ghVersion = tryCommand('gh copilot --version 2>&1');
+  if (ghVersion) {
+    const ver = ghVersion.split('\n')[0];
+    return { status: 'pass', label: 'GitHub Copilot CLI', detail: ver };
+  }
+
+  const standaloneVersion = tryCommand('copilot --version 2>&1');
+  if (standaloneVersion) {
+    const ver = standaloneVersion.split('\n')[0];
+    return { status: 'pass', label: 'Copilot CLI (standalone)', detail: ver };
+  }
+
+  return {
+    status: 'fail',
+    label: 'GitHub Copilot CLI',
+    detail: 'not found — install via: gh extension install github/gh-copilot',
+  };
+}
+
+export function checkGitHubAuth(): CheckResult {
+  // Check for Copilot-specific env token first (highest priority)
+  if (process.env.COPILOT_GITHUB_TOKEN) {
+    return { status: 'pass', label: 'GitHub authenticated', detail: 'via COPILOT_GITHUB_TOKEN' };
+  }
+
+  // Check for general GitHub tokens
+  if (process.env.GH_TOKEN) {
+    return { status: 'pass', label: 'GitHub authenticated', detail: 'via GH_TOKEN' };
+  }
+  if (process.env.GITHUB_TOKEN) {
+    return { status: 'pass', label: 'GitHub authenticated', detail: 'via GITHUB_TOKEN' };
+  }
+
+  // Check if gh CLI is authenticated
+  const authStatus = tryCommand('gh auth status 2>&1');
+  if (authStatus && authStatus.includes('Logged in')) {
+    return { status: 'pass', label: 'GitHub authenticated', detail: 'via gh CLI' };
+  }
+
+  // Check if Copilot CLI has stored credentials
+  const copilotAuth = tryCommand('copilot auth status 2>&1');
+  if (copilotAuth && !copilotAuth.includes('not logged in')) {
+    return { status: 'pass', label: 'GitHub authenticated', detail: 'via Copilot CLI' };
+  }
+
+  return {
+    status: 'warn',
+    label: 'GitHub authentication',
+    detail: 'no token found — set COPILOT_GITHUB_TOKEN, run gh auth login, or run copilot auth login',
+  };
+}
+
+export function runAllPrereqs(): CheckResult[] {
+  return [
+    checkNodeVersion(),
+    checkCopilotCLI(),
+    checkGitHubAuth(),
+  ];
+}

package/scripts/lib/prompts.ts

@@ -0,0 +1,65 @@
+/**
+ * Readline-based interactive prompts. No external dependencies.
+ */
+
+import * as readline from 'node:readline';
+
+let rl: readline.Interface | null = null;
+
+function getRL(): readline.Interface {
+  if (!rl) {
+    rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+  }
+  return rl;
+}
+
+export function closePrompts(): void {
+  rl?.close();
+  rl = null;
+}
+
+export async function ask(question: string, defaultValue?: string): Promise<string> {
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  return new Promise((resolve) => {
+    getRL().question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+export async function askRequired(question: string): Promise<string> {
+  let answer = '';
+  while (!answer) {
+    answer = await ask(question);
+    if (!answer) console.log('  This field is required.');
+  }
+  return answer;
+}
+
+export async function confirm(question: string, defaultYes = true): Promise<boolean> {
+  const hint = defaultYes ? 'Y/n' : 'y/N';
+  const answer = await ask(`${question} (${hint})`);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase().startsWith('y');
+}
+
+export async function choose(question: string, options: string[], defaultIndex = 0): Promise<number> {
+  console.log(`\n${question}`);
+  for (let i = 0; i < options.length; i++) {
+    const marker = i === defaultIndex ? '>' : ' ';
+    console.log(`  ${marker} ${i + 1}. ${options[i]}`);
+  }
+  const answer = await ask('Choose', String(defaultIndex + 1));
+  const idx = parseInt(answer, 10) - 1;
+  if (idx >= 0 && idx < options.length) return idx;
+  return defaultIndex;
+}
+
+export async function askSecret(question: string): Promise<string> {
+  // For tokens — we don't mask input because readline doesn't support it
+  // without raw mode, but we label it clearly
+  return askRequired(question);
+}

package/scripts/lib/service.ts

@@ -0,0 +1,191 @@
+/**
+ * OS-specific service file generation and installation.
+ * Supports macOS (launchd) and Linux (systemd system-level units).
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+
+export type Platform = 'macos' | 'linux' | 'unsupported';
+
+export function detectPlatform(): Platform {
+  switch (process.platform) {
+    case 'darwin': return 'macos';
+    case 'linux': return 'linux';
+    default: return 'unsupported';
+  }
+}
+
+export function getNodePath(): string {
+  try {
+    return execSync('which node', { encoding: 'utf-8' }).trim();
+  } catch {
+    return '/usr/local/bin/node';
+  }
+}
+
+export function getSystemPath(): string {
+  // Include the directory containing the current node binary (e.g., nvm paths)
+  const nodeBinDir = path.dirname(getNodePath());
+  const platform = detectPlatform();
+  const basePath = platform === 'macos'
+    ? '/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin'
+    : '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin';
+  // Prepend node's bin dir if not already in the base path
+  if (basePath.split(':').includes(nodeBinDir)) return basePath;
+  return `${nodeBinDir}:${basePath}`;
+}
+
+// --- launchd (macOS) ---
+
+export interface LaunchdConfig {
+  label: string;
+  bridgePath: string;
+  homePath: string;
+}
+
+export function generateLaunchdPlist(config: LaunchdConfig): string {
+  const nodePath = getNodePath();
+  const tsxPath = path.join(config.bridgePath, 'node_modules', '.bin', 'tsx');
+  return `<?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">
+<dict>
+    <key>Label</key>
+    <string>${config.label}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${tsxPath}</string>
+        <string>dist/index.js</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>${config.bridgePath}</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${getSystemPath()}</string>
+        <key>HOME</key>
+        <string>${config.homePath}</string>
+    </dict>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+
+    <key>StandardOutPath</key>
+    <string>/tmp/copilot-bridge.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>/tmp/copilot-bridge.log</string>
+</dict>
+</plist>`;
+}
+
+export function getLaunchdInstallPath(): string {
+  return path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.copilot-bridge.plist');
+}
+
+export function installLaunchd(plistContent: string): { installed: boolean; path: string; error?: string } {
+  const installPath = getLaunchdInstallPath();
+  try {
+    const dir = path.dirname(installPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    // Unload existing service before overwriting (ignore errors if not loaded)
+    try { execSync(`launchctl bootout gui/$(id -u) "${installPath}" 2>/dev/null`, { encoding: 'utf-8' }); } catch { /* not loaded */ }
+    fs.writeFileSync(installPath, plistContent, 'utf-8');
+    execSync(`launchctl load "${installPath}"`, { encoding: 'utf-8' });
+    return { installed: true, path: installPath };
+  } catch (err) {
+    return { installed: false, path: installPath, error: String(err) };
+  }
+}
+
+// --- systemd (Linux) ---
+
+export interface SystemdConfig {
+  bridgePath: string;
+  homePath: string;
+  user: string;
+}
+
+export function generateSystemdUnit(config: SystemdConfig): string {
+  const nodePath = getNodePath();
+  const tsxPath = path.join(config.bridgePath, 'node_modules', '.bin', 'tsx');
+  return `[Unit]
+Description=Copilot Bridge
+After=network.target
+
+[Service]
+Type=simple
+User=${config.user}
+ExecStart=${nodePath} ${tsxPath} ${config.bridgePath}/dist/index.js
+WorkingDirectory=${config.bridgePath}
+Environment=HOME=${config.homePath}
+Environment=PATH=${getSystemPath()}
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target`;
+}
+
+export function getSystemdInstallPath(): string {
+  return '/etc/systemd/system/copilot-bridge.service';
+}
+
+// --- Service status ---
+
+export function getServiceStatus(): { running: boolean; pid?: number; detail: string } {
+  const platform = detectPlatform();
+
+  if (platform === 'macos') {
+    try {
+      const output = execSync('launchctl list com.copilot-bridge 2>/dev/null', { encoding: 'utf-8' });
+      const pidMatch = output.match(/"PID"\s*=\s*(\d+)/);
+      if (pidMatch) {
+        return { running: true, pid: parseInt(pidMatch[1], 10), detail: `launchd, PID ${pidMatch[1]}` };
+      }
+      // launchctl list succeeded but no PID — service loaded but not running
+      return { running: false, detail: 'launchd: loaded but not running' };
+    } catch {
+      return { running: false, detail: 'launchd: not loaded' };
+    }
+  }
+
+  if (platform === 'linux') {
+    try {
+      // systemctl is-active exits non-zero for inactive/unknown services
+      const output = execSync('systemctl is-active copilot-bridge 2>/dev/null', { encoding: 'utf-8' }).trim();
+      if (output === 'active') {
+        try {
+          const pid = execSync('systemctl show copilot-bridge --property=MainPID --value 2>/dev/null', { encoding: 'utf-8' }).trim();
+          return { running: true, pid: parseInt(pid, 10), detail: `systemd, PID ${pid}` };
+        } catch {
+          return { running: true, detail: 'systemd: active' };
+        }
+      }
+      return { running: false, detail: `systemd: ${output}` };
+    } catch (err) {
+      // Exit code 3 = inactive/dead (unit exists but not running)
+      // Exit code 4 = no such unit file
+      const stdout = err instanceof Error && 'stdout' in err ? String((err as { stdout: unknown }).stdout).trim() : '';
+      if (stdout === 'inactive' || stdout === 'failed' || stdout === 'activating' || stdout === 'deactivating') {
+        return { running: false, detail: `systemd: ${stdout}` };
+      }
+      return { running: false, detail: 'systemd: not installed' };
+    }
+  }
+
+  return { running: false, detail: 'unsupported platform' };
+}

package/scripts/uninstall-service.ts

@@ -0,0 +1,90 @@
+#!/usr/bin/env npx tsx
+/**
+ * copilot-bridge uninstall-service — Remove the bridge system service.
+ *
+ * macOS: unloads and removes the launchd plist
+ * Linux: stops, disables, and removes the systemd unit (requires sudo)
+ *
+ * Usage: npm run uninstall-service
+ *        npx tsx scripts/uninstall-service.ts
+ */
+
+import * as fs from 'node:fs';
+import { heading, success, fail, info, dim, blank } from './lib/output.js';
+import { detectPlatform, getLaunchdInstallPath, getSystemdInstallPath } from './lib/service.js';
+import { execSync } from 'node:child_process';
+
+function main() {
+  const osPlatform = detectPlatform();
+
+  heading('🗑️  copilot-bridge service uninstaller');
+  blank();
+
+  if (osPlatform === 'macos') {
+    const plistPath = getLaunchdInstallPath();
+
+    if (!fs.existsSync(plistPath)) {
+      info('No launchd service found — nothing to uninstall.');
+      return;
+    }
+
+    info(`Unloading and removing ${plistPath}`);
+
+    try {
+      // bootout is the modern replacement for unload
+      execSync(`launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null || launchctl unload "${plistPath}" 2>/dev/null`, {
+        stdio: 'inherit',
+      });
+    } catch {
+      // Service may not be loaded — that's fine
+    }
+
+    try {
+      fs.unlinkSync(plistPath);
+      blank();
+      success('Service uninstalled.');
+    } catch (err) {
+      fail(`Failed to remove plist: ${err}`);
+      process.exit(1);
+    }
+
+  } else if (osPlatform === 'linux') {
+    const unitPath = getSystemdInstallPath();
+
+    if (!fs.existsSync(unitPath)) {
+      info('No systemd service found — nothing to uninstall.');
+      return;
+    }
+
+    const isRoot = process.getuid?.() === 0;
+    if (!isRoot) {
+      info('This requires sudo to remove from /etc/systemd/system/.');
+      blank();
+    }
+
+    try {
+      execSync('sudo systemctl stop copilot-bridge 2>/dev/null || true', { stdio: 'inherit' });
+      execSync('sudo systemctl disable copilot-bridge 2>/dev/null || true', { stdio: 'inherit' });
+      execSync(`sudo rm "${unitPath}"`, { stdio: 'inherit' });
+      execSync('sudo systemctl daemon-reload', { stdio: 'inherit' });
+      blank();
+      success('Service uninstalled.');
+    } catch {
+      blank();
+      fail('Automatic uninstall failed (sudo may have been denied).');
+      blank();
+      info('To uninstall manually:');
+      dim('  sudo systemctl stop copilot-bridge');
+      dim('  sudo systemctl disable copilot-bridge');
+      dim(`  sudo rm ${unitPath}`);
+      dim('  sudo systemctl daemon-reload');
+      process.exit(1);
+    }
+
+  } else {
+    fail('Unsupported platform — no service to uninstall.');
+    process.exit(1);
+  }
+}
+
+main();