robot-resources 1.9.6 → 1.10.2

package/lib/service.js

@@ -1,740 +0,0 @@
-import { execSync, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { readProviderKeys } from '@robot-resources/cli-core/config.mjs';
-
-const LABEL = 'ai.robotresources.router';
-const SERVICE_NAME = 'robot-resources-router.service';
-const TASK_NAME = 'RobotResourcesRouter';
-const ROUTER_PORT = 3838;
-
-// Maps config.json provider_keys names to environment variable names
-const CONFIG_TO_ENV = {
-  openai: 'OPENAI_API_KEY',
-  anthropic: 'ANTHROPIC_API_KEY',
-  google: 'GOOGLE_API_KEY',
-};
-
-// ─── Environment detection ──────────────────────────────────────────────────
-
-function isDocker() {
-  return existsSync('/.dockerenv') ||
-    (existsSync('/proc/1/cgroup') &&
-      readFileSync('/proc/1/cgroup', 'utf-8').includes('docker'));
-}
-
-function isWSL() {
-  try {
-    const version = readFileSync('/proc/version', 'utf-8');
-    return /microsoft|wsl/i.test(version);
-  } catch {
-    return false;
-  }
-}
-
-function hasSystemd() {
-  // systemd is PID 1 — check if /run/systemd/system exists (standard detection)
-  return existsSync('/run/systemd/system');
-}
-
-function isRoot() {
-  return process.getuid?.() === 0;
-}
-
-// ─── Shared helpers ─────────────────────────────────────────────────────────
-
-function resolveProviderEnv() {
-  const configKeys = readProviderKeys();
-  const keyNames = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
-  const resolvedKeys = {};
-  for (const key of keyNames) {
-    if (process.env[key]) {
-      resolvedKeys[key] = process.env[key];
-    }
-  }
-  for (const [configName, envName] of Object.entries(CONFIG_TO_ENV)) {
-    if (!resolvedKeys[envName] && configKeys[configName]) {
-      resolvedKeys[envName] = configKeys[configName];
-    }
-  }
-  // Windows inherits PATH from the user profile when schtasks fires the task;
-  // overwriting it to a Unix path would break every `python.exe` resolution.
-  if (process.platform !== 'win32') {
-    resolvedKeys['PATH'] = '/usr/local/bin:/usr/bin:/bin';
-  }
-  return resolvedKeys;
-}
-
-function writeEnvFile(resolvedKeys) {
-  const envDir = join(homedir(), '.robot-resources');
-  const envPath = join(envDir, 'router.env');
-  mkdirSync(envDir, { recursive: true });
-  const lines = Object.entries(resolvedKeys)
-    .map(([key, value]) => `${key}=${value}`)
-    .join('\n');
-  writeFileSync(envPath, lines + '\n', { mode: 0o600 });
-  return envPath;
-}
-
-// ─── macOS (launchd) ────────────────────────────────────────────────────────
-
-function getPlistPath() {
-  return join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
-}
-
-function buildPlist(venvPythonPath) {
-  const home = homedir();
-  const logsDir = join(home, '.robot-resources', 'logs');
-
-  // Snapshot provider API keys: env vars take priority, then config.json
-  const envVars = {};
-  const configKeys = readProviderKeys();
-  const keyNames = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
-  for (const key of keyNames) {
-    const value = process.env[key];
-    if (value) {
-      envVars[key] = value;
-    }
-  }
-  // Fill in from config.json for any keys not found in environment
-  for (const [configName, envName] of Object.entries(CONFIG_TO_ENV)) {
-    if (!envVars[envName] && configKeys[configName]) {
-      envVars[envName] = configKeys[configName];
-    }
-  }
-  // Ensure PATH includes common binary locations
-  envVars.PATH = '/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin';
-
-  const envEntries = Object.entries(envVars)
-    .map(([k, v]) => `      <key>${k}</key>\n      <string>${v}</string>`)
-    .join('\n');
-
-  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>${LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${venvPythonPath}</string>
-    <string>-m</string>
-    <string>robot_resources.cli.main</string>
-    <string>start</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${logsDir}/router.stdout.log</string>
-  <key>StandardErrorPath</key>
-  <string>${logsDir}/router.stderr.log</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-${envEntries}
-  </dict>
-  <key>WorkingDirectory</key>
-  <string>${home}/.robot-resources</string>
-</dict>
-</plist>
-`;
-}
-
-function installLaunchd(venvPythonPath) {
-  const plistPath = getPlistPath();
-  const logsDir = join(homedir(), '.robot-resources', 'logs');
-  const launchAgentsDir = join(homedir(), 'Library', 'LaunchAgents');
-
-  mkdirSync(logsDir, { recursive: true });
-  mkdirSync(launchAgentsDir, { recursive: true });
-
-  // Unload existing service if present
-  if (existsSync(plistPath)) {
-    try {
-      execSync(`launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null`, { stdio: 'pipe' });
-    } catch {
-      // Not loaded — fine
-    }
-  }
-
-  writeFileSync(plistPath, buildPlist(venvPythonPath));
-  chmodSync(plistPath, 0o600);
-  execSync(`launchctl bootstrap gui/$(id -u) "${plistPath}"`, { stdio: 'pipe' });
-}
-
-function uninstallLaunchd() {
-  const plistPath = getPlistPath();
-  if (!existsSync(plistPath)) return;
-
-  try {
-    execSync(`launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null`, { stdio: 'pipe' });
-  } catch {
-    // Already unloaded
-  }
-  unlinkSync(plistPath);
-}
-
-function isLaunchdRunning() {
-  try {
-    const output = execSync(`launchctl print gui/$(id -u)/${LABEL} 2>&1`, { encoding: 'utf-8' });
-    return output.includes('state = running');
-  } catch {
-    return false;
-  }
-}
-
-// ─── Linux: systemd user service ────────────────────────────────────────────
-
-function getUserUnitPath() {
-  return join(homedir(), '.config', 'systemd', 'user', SERVICE_NAME);
-}
-
-function buildUserUnit(venvPythonPath, envFilePath) {
-  const home = homedir();
-  const logsDir = join(home, '.robot-resources', 'logs');
-
-  return `[Unit]
-Description=Robot Resources Router — LLM cost optimization proxy
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${venvPythonPath} -m robot_resources.cli.main start
-Restart=on-failure
-RestartSec=5
-EnvironmentFile=${envFilePath}
-WorkingDirectory=${home}/.robot-resources
-StandardOutput=append:${logsDir}/router.stdout.log
-StandardError=append:${logsDir}/router.stderr.log
-
-[Install]
-WantedBy=default.target
-`;
-}
-
-/**
- * Check whether linger is enabled for the current user.
- *
- * Without linger, systemd-user services are torn down when the user logs
- * out (SSH disconnect, login manager logout). On the Finland signup
- * (2026-04-23) this was the root cause: 3 heartbeats, then session ended,
- * then the router died with the session.
- */
-function isLingerEnabled() {
-  try {
-    const user = process.env.USER || process.env.LOGNAME;
-    if (!user) return false;
-    const res = spawnSync('loginctl', ['show-user', user, '--property=Linger'], {
-      stdio: 'pipe', encoding: 'utf-8',
-    });
-    if (res.status !== 0) return false;
-    return /^Linger=yes\s*$/m.test(res.stdout || '');
-  } catch {
-    return false;
-  }
-}
-
-function installSystemdUser(venvPythonPath) {
-  const unitPath = getUserUnitPath();
-  const logsDir = join(homedir(), '.robot-resources', 'logs');
-  const unitDir = dirname(unitPath);
-
-  mkdirSync(logsDir, { recursive: true });
-  mkdirSync(unitDir, { recursive: true });
-
-  const resolvedKeys = resolveProviderEnv();
-  const envFilePath = writeEnvFile(resolvedKeys);
-  writeFileSync(unitPath, buildUserUnit(venvPythonPath, envFilePath));
-  chmodSync(unitPath, 0o600);
-  execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
-  execSync('systemctl --user enable robot-resources-router.service', { stdio: 'pipe' });
-  execSync('systemctl --user start robot-resources-router.service', { stdio: 'pipe' });
-
-  // Enable linger so the service survives SSH disconnects (critical for VMs).
-  // On many distros this needs polkit auth and silently no-ops from a
-  // non-interactive shell — we attempt it then VERIFY the result.
-  let lingerEnabled = false;
-  try {
-    execSync('loginctl enable-linger', { stdio: 'pipe' });
-  } catch {
-    // fall through to verification
-  }
-  lingerEnabled = isLingerEnabled();
-  return { lingerEnabled };
-}
-
-function uninstallSystemdUser() {
-  const unitPath = getUserUnitPath();
-  if (!existsSync(unitPath)) return;
-
-  try {
-    execSync('systemctl --user stop robot-resources-router.service', { stdio: 'pipe' });
-    execSync('systemctl --user disable robot-resources-router.service', { stdio: 'pipe' });
-  } catch {
-    // Already stopped
-  }
-  unlinkSync(unitPath);
-  execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
-}
-
-// ─── Linux: systemd system service (root / VMs / servers) ───────────────────
-
-const SYSTEM_UNIT_PATH = `/etc/systemd/system/${SERVICE_NAME}`;
-
-function buildSystemUnit(venvPythonPath, envFilePath) {
-  const home = homedir();
-  const logsDir = join(home, '.robot-resources', 'logs');
-
-  return `[Unit]
-Description=Robot Resources Router — LLM cost optimization proxy
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=root
-ExecStart=${venvPythonPath} -m robot_resources.cli.main start
-Restart=on-failure
-RestartSec=5
-EnvironmentFile=${envFilePath}
-WorkingDirectory=${home}/.robot-resources
-StandardOutput=append:${logsDir}/router.stdout.log
-StandardError=append:${logsDir}/router.stderr.log
-
-[Install]
-WantedBy=multi-user.target
-`;
-}
-
-function installSystemdSystem(venvPythonPath) {
-  const logsDir = join(homedir(), '.robot-resources', 'logs');
-  mkdirSync(logsDir, { recursive: true });
-
-  const resolvedKeys = resolveProviderEnv();
-  const envFilePath = writeEnvFile(resolvedKeys);
-  writeFileSync(SYSTEM_UNIT_PATH, buildSystemUnit(venvPythonPath, envFilePath));
-  chmodSync(SYSTEM_UNIT_PATH, 0o644);
-  execSync('systemctl daemon-reload', { stdio: 'pipe' });
-  execSync(`systemctl enable ${SERVICE_NAME}`, { stdio: 'pipe' });
-  execSync(`systemctl start ${SERVICE_NAME}`, { stdio: 'pipe' });
-}
-
-function uninstallSystemdSystem() {
-  if (!existsSync(SYSTEM_UNIT_PATH)) return;
-
-  try {
-    execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'pipe' });
-    execSync(`systemctl disable ${SERVICE_NAME}`, { stdio: 'pipe' });
-  } catch {
-    // Already stopped
-  }
-  unlinkSync(SYSTEM_UNIT_PATH);
-  execSync('systemctl daemon-reload', { stdio: 'pipe' });
-}
-
-// ─── Linux routing logic ────────────────────────────────────────────────────
-
-function getLinuxMode() {
-  if (isDocker()) return 'docker';
-  if (isWSL() && !hasSystemd()) return 'wsl-no-systemd';
-  if (isRoot()) return 'system';
-  return 'user';
-}
-
-function getLinuxUnitPath() {
-  return isRoot() ? SYSTEM_UNIT_PATH : getUserUnitPath();
-}
-
-// ─── Crontab @reboot fallback (Docker / WSL-no-systemd / rootless) ──────────
-//
-// When systemd isn't available, we fall back to a cron @reboot entry plus an
-// immediate detached spawn. This gives the router:
-//   1. Persistence across reboot — @reboot fires when cron starts at boot.
-//   2. Immediate availability — the detached process starts right now.
-//
-// The crontab command invokes a wrapper script (same idea as the Windows .cmd
-// wrapper) so env vars from router.env are sourced before launch. Cron runs
-// commands with a minimal env so sourcing is required.
-
-const CRONTAB_MARKER = '# robot-resources-router';
-const CRONTAB_MARKER_FILE = '.crontab-installed';
-
-function hasCrontab() {
-  const res = spawnSync('crontab', ['-l'], { stdio: 'pipe', encoding: 'utf-8' });
-  // Exit 0 = crontab exists; exit 1 with "no crontab" message = cron available
-  // but empty; exit 127 / ENOENT = no crontab command at all.
-  return res.error?.code !== 'ENOENT' && res.status !== 127;
-}
-
-function getCronWrapperPath() {
-  return join(homedir(), '.robot-resources', 'rr-router-run.sh');
-}
-
-function getCrontabMarkerPath() {
-  return join(homedir(), '.robot-resources', CRONTAB_MARKER_FILE);
-}
-
-function buildCronWrapper(venvPythonPath, envFilePath, logsDir) {
-  // POSIX /bin/sh so it runs under any cron implementation (cron, cronie,
-  // busybox). `set -a` auto-exports every var we source. nohup detaches from
-  // cron's controlling terminal so the router stays alive after cron exits.
-  return [
-    '#!/bin/sh',
-    'set -a',
-    `. "${envFilePath}"`,
-    'set +a',
-    `exec nohup "${venvPythonPath}" -m robot_resources.cli.main start \\`,
-    `  >> "${join(logsDir, 'router.stdout.log')}" \\`,
-    `  2>> "${join(logsDir, 'router.stderr.log')}"`,
-    '',
-  ].join('\n');
-}
-
-function readCurrentCrontab() {
-  const res = spawnSync('crontab', ['-l'], { stdio: 'pipe', encoding: 'utf-8' });
-  // Exit 1 with no stdout usually means "no crontab for user" — treat as empty.
-  if (res.status !== 0) return '';
-  return res.stdout || '';
-}
-
-function writeCrontab(contents) {
-  const res = spawnSync('crontab', ['-'], {
-    input: contents,
-    stdio: ['pipe', 'pipe', 'pipe'],
-    encoding: 'utf-8',
-  });
-  if (res.status !== 0) {
-    const stderr = (res.stderr || '').toString().trim();
-    throw new Error(`crontab write failed (status ${res.status}): ${stderr || 'unknown error'}`);
-  }
-}
-
-function spawnDetachedRouter(wrapperPath) {
-  // Immediate start so wizard's health check can verify :3838 right away.
-  // Best-effort: if cron or sh is unavailable, at least log it; the @reboot
-  // entry will still fire next boot.
-  const child = spawnSync('sh', ['-c', `nohup "${wrapperPath}" > /dev/null 2>&1 &`], {
-    stdio: 'ignore',
-    detached: true,
-  });
-  return child.status === 0;
-}
-
-function installCrontab(venvPythonPath) {
-  if (!hasCrontab()) {
-    throw new Error(
-      'crontab command not available — cannot install @reboot fallback.\n' +
-      `  Run the router manually: ${venvPythonPath} -m robot_resources.cli.main start`,
-    );
-  }
-
-  const logsDir = join(homedir(), '.robot-resources', 'logs');
-  mkdirSync(logsDir, { recursive: true });
-
-  // Snapshot provider env + PATH so the router has the keys it needs when
-  // cron fires at boot. Cron runs with a minimal env by default.
-  const resolvedKeys = resolveProviderEnv();
-  const envFilePath = writeEnvFile(resolvedKeys);
-
-  // Write wrapper script (0o700 — contains nothing secret itself, but only
-  // the owner should be able to execute it).
-  const wrapperPath = getCronWrapperPath();
-  writeFileSync(wrapperPath, buildCronWrapper(venvPythonPath, envFilePath, logsDir));
-  chmodSync(wrapperPath, 0o700);
-
-  // Add or replace our @reboot entry. Idempotent: strip any existing
-  // robot-resources lines first, then append a fresh one.
-  const current = readCurrentCrontab();
-  const filtered = current
-    .split('\n')
-    .filter((line) => !line.includes(CRONTAB_MARKER) && !line.includes('robot_resources.cli.main'))
-    .join('\n');
-  const trimmed = filtered.trimEnd();
-  const entry = `@reboot "${wrapperPath}" ${CRONTAB_MARKER}`;
-  const next = (trimmed ? trimmed + '\n' : '') + entry + '\n';
-  writeCrontab(next);
-
-  // Marker file lets uninstallService() know we used this fallback without
-  // having to re-parse the crontab.
-  writeFileSync(getCrontabMarkerPath(), new Date().toISOString() + '\n', { mode: 0o600 });
-
-  // Start now so :3838 is live before the wizard's health check runs.
-  spawnDetachedRouter(wrapperPath);
-}
-
-function uninstallCrontab() {
-  if (!existsSync(getCrontabMarkerPath())) return;
-
-  // Remove our line(s) from the user crontab; leave other entries alone.
-  if (hasCrontab()) {
-    try {
-      const current = readCurrentCrontab();
-      const filtered = current
-        .split('\n')
-        .filter((line) => !line.includes(CRONTAB_MARKER) && !line.includes('robot_resources.cli.main'))
-        .join('\n')
-        .trimEnd();
-      writeCrontab(filtered ? filtered + '\n' : '');
-    } catch {
-      // Best-effort — don't block uninstall if crontab write fails.
-    }
-  }
-
-  // Best-effort: kill the running router process.
-  spawnSync('pkill', ['-f', 'robot_resources.cli.main start'], { stdio: 'ignore' });
-
-  // Clean up marker + wrapper.
-  try { unlinkSync(getCrontabMarkerPath()); } catch { /* already gone */ }
-  try { unlinkSync(getCronWrapperPath()); } catch { /* already gone */ }
-}
-
-function isCrontabInstalled() {
-  return existsSync(getCrontabMarkerPath());
-}
-
-function isCrontabRouterRunning() {
-  // Cheapest check: is anything listening on :3838?
-  // We can't rely on `systemctl is-active` since we aren't using systemd.
-  const res = spawnSync('sh', ['-c', `lsof -i :${ROUTER_PORT} -t 2>/dev/null`], {
-    stdio: 'pipe',
-    encoding: 'utf-8',
-  });
-  return res.status === 0 && (res.stdout || '').trim().length > 0;
-}
-
-// ─── Windows (Task Scheduler) ───────────────────────────────────────────────
-
-function getWrapperCmdPath() {
-  return join(homedir(), '.robot-resources', 'rr-router-run.cmd');
-}
-
-function buildWrapperCmd(venvPythonPath, envFilePath, logsDir) {
-  // The wrapper sources router.env line-by-line into `set` (so quoting is
-  // handled by cmd.exe), then launches the router. stdout/stderr append to
-  // log files so the scheduled task — which has no attached console — leaves
-  // a trail the user can read.
-  return [
-    '@echo off',
-    'setlocal enabledelayedexpansion',
-    `for /f "usebackq tokens=* delims=" %%a in ("${envFilePath}") do set "%%a"`,
-    `"${venvPythonPath}" -m robot_resources.cli.main start >> "${join(logsDir, 'router.stdout.log')}" 2>> "${join(logsDir, 'router.stderr.log')}"`,
-    '',
-  ].join('\r\n');
-}
-
-function runSchtasks(args, { ignoreStatus = false } = {}) {
-  // spawnSync (not execSync) because paths like `C:\Users\Some Person\...`
-  // have spaces and shell re-tokenization via execSync is a quoting footgun.
-  // spawnSync with an arg array passes each arg verbatim to schtasks.exe.
-  const res = spawnSync('schtasks.exe', args, { stdio: 'pipe', encoding: 'utf-8' });
-  if (!ignoreStatus && res.status !== 0) {
-    const stderr = (res.stderr || '').toString().trim();
-    const stdout = (res.stdout || '').toString().trim();
-    throw new Error(`schtasks ${args[0]} failed (status ${res.status}): ${stderr || stdout || 'unknown error'}`);
-  }
-  return res;
-}
-
-function installTaskScheduler(venvPythonPath) {
-  const logsDir = join(homedir(), '.robot-resources', 'logs');
-  mkdirSync(logsDir, { recursive: true });
-
-  const resolvedKeys = resolveProviderEnv();
-  const envFilePath = writeEnvFile(resolvedKeys);
-  const wrapperPath = getWrapperCmdPath();
-  writeFileSync(wrapperPath, buildWrapperCmd(venvPythonPath, envFilePath, logsDir));
-
-  // /rl LIMITED is the default — explicit here for readability. /f overwrites
-  // an existing task of the same name so the install is idempotent.
-  runSchtasks([
-    '/create', '/sc', 'onlogon',
-    '/tn', TASK_NAME,
-    '/tr', `"${wrapperPath}"`,
-    '/rl', 'LIMITED',
-    '/f',
-  ]);
-
-  // Launch now so the wizard's post-install health check can hit port 3838.
-  // Best-effort — if the immediate run fails, the task is still registered
-  // and will fire at next logon.
-  runSchtasks(['/run', '/tn', TASK_NAME], { ignoreStatus: true });
-}
-
-function uninstallTaskScheduler() {
-  runSchtasks(['/end', '/tn', TASK_NAME], { ignoreStatus: true });
-  runSchtasks(['/delete', '/tn', TASK_NAME, '/f'], { ignoreStatus: true });
-  if (existsSync(getWrapperCmdPath())) unlinkSync(getWrapperCmdPath());
-}
-
-function isTaskSchedulerRunning() {
-  const res = spawnSync(
-    'schtasks.exe',
-    ['/query', '/tn', TASK_NAME, '/fo', 'LIST', '/v'],
-    { stdio: 'pipe', encoding: 'utf-8' },
-  );
-  if (res.status !== 0) return false;
-  // 0x41301 is TASK_RUNNING (HRESULT). Locale-independent — the localized
-  // "Running" / "In corso" / "実行中" string is unreliable across Windows SKUs.
-  return (res.stdout || '').includes('0x41301');
-}
-
-function isTaskSchedulerInstalled() {
-  const res = spawnSync(
-    'schtasks.exe',
-    ['/query', '/tn', TASK_NAME],
-    { stdio: 'pipe' },
-  );
-  return res.status === 0;
-}
-
-// ─── Public API ─────────────────────────────────────────────────────────────
-
-/**
- * Register the router as a system service and start it.
- */
-export function installService(venvPythonPath) {
-  if (process.platform === 'darwin') {
-    installLaunchd(venvPythonPath);
-    return { type: 'launchd', path: getPlistPath() };
-  }
-
-  if (process.platform === 'linux') {
-    const mode = getLinuxMode();
-
-    // Docker and WSL-no-systemd fall through to the crontab fallback.
-    // Previously these returned { type: 'skipped' } and the router was never
-    // registered — users ended up with install_complete service=false and
-    // silent failure. crontab @reboot + immediate detached spawn gives us
-    // persistence across reboot without requiring systemd.
-    if (mode === 'docker' || mode === 'wsl-no-systemd') {
-      try {
-        installCrontab(venvPythonPath);
-        return { type: 'crontab', path: getCronWrapperPath() };
-      } catch (err) {
-        // Last-resort message if even cron is unavailable.
-        return {
-          type: 'skipped',
-          reason: `${mode === 'docker' ? 'Running inside Docker' : 'WSL without systemd'} and crontab fallback failed: ${err.message}\n` +
-            `  Run the router manually: ${venvPythonPath} -m robot_resources.cli.main start`,
-        };
-      }
-    }
-
-    if (mode === 'system') {
-      installSystemdSystem(venvPythonPath);
-      return { type: 'systemd-system', path: SYSTEM_UNIT_PATH };
-    }
-
-    // mode === 'user'
-    const { lingerEnabled } = installSystemdUser(venvPythonPath);
-
-    // Belt-and-suspenders: ALSO install crontab @reboot so the router comes
-    // back on reboot even if linger isn't taking effect (polkit denied,
-    // container restrictions, etc.). Idempotent — removes any existing
-    // RR crontab entry before adding the fresh one. Safe to call even
-    // when crontab is absent (we skip silently).
-    let crontabFallback = false;
-    if (hasCrontab()) {
-      try {
-        installCrontab(venvPythonPath);
-        crontabFallback = true;
-      } catch {
-        // Non-fatal — systemd-user still works while user is logged in.
-      }
-    }
-
-    return {
-      type: 'systemd-user',
-      path: getUserUnitPath(),
-      lingerEnabled,
-      crontabFallback,
-    };
-  }
-
-  if (process.platform === 'win32') {
-    installTaskScheduler(venvPythonPath);
-    return { type: 'schtasks', path: getWrapperCmdPath() };
-  }
-
-  throw new Error(
-    `Service registration not supported on ${process.platform}.\n` +
-    `  Run the router manually: rr-router start`
-  );
-}
-
-/**
- * Stop and remove the router service.
- */
-export function uninstallService() {
-  if (process.platform === 'darwin') return uninstallLaunchd();
-  if (process.platform === 'linux') {
-    // Clean up whatever variants are installed. systemd-user users may
-    // also have a crontab belt installed alongside — remove both.
-    if (existsSync(SYSTEM_UNIT_PATH)) uninstallSystemdSystem();
-    if (existsSync(getUserUnitPath())) uninstallSystemdUser();
-    if (isCrontabInstalled()) uninstallCrontab();
-    return;
-  }
-  if (process.platform === 'win32') return uninstallTaskScheduler();
-}
-
-/**
- * Check if the router service is currently running.
- */
-export function isServiceRunning() {
-  if (process.platform === 'darwin') return isLaunchdRunning();
-  if (process.platform === 'linux') {
-    // Check system-level first, then user-level
-    if (existsSync(SYSTEM_UNIT_PATH)) {
-      try {
-        execSync(`systemctl is-active ${SERVICE_NAME}`, { stdio: 'pipe' });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    if (existsSync(getUserUnitPath())) {
-      try {
-        execSync(`systemctl --user is-active ${SERVICE_NAME}`, { stdio: 'pipe' });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    // Crontab fallback — check if anything is listening on :3838.
-    if (isCrontabInstalled()) return isCrontabRouterRunning();
-    return false;
-  }
-  if (process.platform === 'win32') return isTaskSchedulerRunning();
-  return false;
-}
-
-/**
- * Check if a service config file exists.
- */
-export function isServiceInstalled() {
-  if (process.platform === 'darwin') return existsSync(getPlistPath());
-  if (process.platform === 'linux') {
-    return existsSync(SYSTEM_UNIT_PATH) || existsSync(getUserUnitPath()) || isCrontabInstalled();
-  }
-  if (process.platform === 'win32') return isTaskSchedulerInstalled();
-  return false;
-}
-
-/**
- * Get missing provider API keys (not in environment or config.json).
- */
-export function getMissingProviderKeys() {
-  const keys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
-  const configKeys = readProviderKeys();
-  return keys.filter((k) => {
-    if (process.env[k]) return false;
-    // Check config.json using the provider name mapping
-    const configName = Object.entries(CONFIG_TO_ENV).find(([, env]) => env === k)?.[0];
-    return !configName || !configKeys[configName];
-  });
-}