@simonyea/holysheep-cli 1.7.53 → 1.7.55

package/src/webui/server.js

@@ -0,0 +1,621 @@
+/**
+ * HolySheep WebUI — HTTP 服务器 + REST API
+ * 仅绑定 127.0.0.1，零新依赖
+ */
+'use strict'
+
+const http = require('http')
+const fs = require('fs')
+const path = require('path')
+const { execSync, spawn } = require('child_process')
+const { loadConfig, saveConfig, getApiKey, BASE_URL_ANTHROPIC, BASE_URL_OPENAI, BASE_URL_CLAUDE_RELAY, SHOP_URL, CONFIG_FILE } = require('../utils/config')
+const { removeEnvFromShell, writeEnvToShell, getShellRcFiles } = require('../utils/shell')
+const { commandExists } = require('../utils/which')
+const TOOLS = require('../tools')
+const pkg = require('../../package.json')
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function maskKey(key) {
+  if (!key || key.length < 8) return '****'
+  return key.slice(0, 6) + '...' + key.slice(-4)
+}
+
+async function validateApiKey(apiKey) {
+  const fetch = require('node-fetch')
+  const res = await fetch(`${BASE_URL_OPENAI}/models`, {
+    method: 'GET',
+    headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+    timeout: 10000,
+  })
+  return res.status === 200
+}
+
+function getVersion(tool) {
+  if (typeof tool.getVersion === 'function') return tool.getVersion()
+  const cmds = {
+    'claude-code': 'claude --version',
+    'codex': 'codex --version',
+    'droid': 'droid --version',
+    'gemini-cli': 'gemini --version',
+    'opencode': 'opencode --version',
+    'openclaw': 'openclaw --version',
+    'aider': 'aider --version',
+  }
+  const cmd = cmds[tool.id]
+  if (!cmd) return null
+  try {
+    return execSync(cmd, { stdio: 'pipe', timeout: 10000 }).toString().trim().split('\n')[0].slice(0, 30)
+  } catch { return null }
+}
+
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = ''
+    req.on('data', chunk => { body += chunk })
+    req.on('end', () => {
+      try { resolve(body ? JSON.parse(body) : {}) }
+      catch { reject(new Error('Invalid JSON')) }
+    })
+    req.on('error', reject)
+  })
+}
+
+function json(res, data, status = 200) {
+  res.writeHead(status, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify(data))
+}
+
+function sseStart(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+  })
+}
+
+function sseEmit(res, data) {
+  res.write(`data: ${JSON.stringify(data)}\n\n`)
+}
+
+// ── AUTO_INSTALL map (from setup.js) ─────────────────────────────────────────
+
+const AUTO_INSTALL = {
+  'claude-code': {
+    cmd: process.platform === 'win32'
+      ? 'powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "irm https://claude.ai/install.ps1 | iex"'
+      : 'curl -fsSL https://claude.ai/install.sh | bash',
+  },
+  'codex':       { cmd: 'npm install -g @openai/codex' },
+  'gemini-cli':  { cmd: 'npm install -g @google/gemini-cli' },
+  'opencode':    { cmd: 'npm install -g opencode-ai' },
+  'openclaw':    { cmd: 'npm install -g openclaw@latest --ignore-scripts' },
+  'aider':       { cmd: 'pip install aider-chat' },
+}
+
+// ── UPGRADABLE_TOOLS (from upgrade.js) ───────────────────────────────────────
+
+const UPGRADABLE_TOOLS = [
+  {
+    name: 'Claude Code', id: 'claude-code', command: 'claude',
+    versionCmd: 'claude --version', npmPkg: null,
+    installCmd: process.platform === 'win32'
+      ? 'powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://claude.ai/install.ps1 | iex"'
+      : 'curl -fsSL https://claude.ai/install.sh | bash',
+  },
+  { name: 'Codex CLI', id: 'codex', command: 'codex', versionCmd: 'codex --version', npmPkg: '@openai/codex', installCmd: 'npm install -g @openai/codex@latest' },
+  { name: 'Gemini CLI', id: 'gemini-cli', command: 'gemini', versionCmd: 'gemini --version', npmPkg: '@google/gemini-cli', installCmd: 'npm install -g @google/gemini-cli@latest' },
+]
+
+// ── API Handlers ─────────────────────────────────────────────────────────────
+
+async function handleStatus(_req, res) {
+  const apiKey = getApiKey()
+  const config = loadConfig()
+  json(res, {
+    loggedIn: !!apiKey,
+    apiKey: apiKey ? maskKey(apiKey) : null,
+    savedAt: config.savedAt || null,
+    version: pkg.version,
+  })
+}
+
+async function handleLogin(req, res) {
+  const body = await parseBody(req)
+  const apiKey = (body.apiKey || '').trim()
+  if (!apiKey || !apiKey.startsWith('cr_')) {
+    return json(res, { success: false, message: 'API Key 必须以 cr_ 开头' }, 400)
+  }
+  try {
+    const valid = await validateApiKey(apiKey)
+    if (!valid) return json(res, { success: false, message: 'API Key 无效' }, 401)
+    saveConfig({ apiKey, savedAt: new Date().toISOString() })
+    json(res, { success: true, apiKey: maskKey(apiKey) })
+  } catch (e) {
+    json(res, { success: false, message: `验证失败: ${e.message}` }, 500)
+  }
+}
+
+async function handleLogout(_req, res) {
+  const config = loadConfig()
+  delete config.apiKey
+  delete config.savedAt
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+  json(res, { success: true })
+}
+
+async function handleWhoami(_req, res) {
+  const apiKey = getApiKey()
+  const config = loadConfig()
+  if (!apiKey) return json(res, { loggedIn: false })
+  let valid = null
+  try { valid = await validateApiKey(apiKey) } catch {}
+  json(res, { loggedIn: true, apiKey: maskKey(apiKey), savedAt: config.savedAt || null, valid })
+}
+
+async function handleBalance(_req, res) {
+  const apiKey = getApiKey()
+  if (!apiKey) return json(res, { error: '未登录' }, 401)
+  try {
+    const fetch = require('node-fetch')
+    const r = await fetch(`${SHOP_URL}/api/stats/overview`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      timeout: 8000,
+    })
+    if (r.status === 401) return json(res, { error: 'API Key 无效或已过期' }, 401)
+    if (!r.ok) return json(res, { error: `HTTP ${r.status}` }, r.status)
+    const data = await r.json()
+    json(res, {
+      balance: Number(data.balance || 0),
+      todayCost: Number(data.todayCost || 0),
+      monthCost: Number(data.monthCost || 0),
+      totalCalls: Number(data.totalCalls || 0),
+    })
+  } catch (e) {
+    json(res, { error: e.message }, 500)
+  }
+}
+
+async function handleDoctor(_req, res) {
+  const apiKey = getApiKey()
+  const nodeMajor = parseInt(process.version.slice(1), 10)
+
+  // Tools
+  const tools = TOOLS.map(t => {
+    const installed = t.checkInstalled()
+    return {
+      id: t.id,
+      name: t.name,
+      installed,
+      configured: installed ? (t.isConfigured?.() || false) : false,
+      version: installed ? getVersion(t) : null,
+      installCmd: t.installCmd,
+      hint: t.hint || null,
+      launchCmd: t.launchCmd || null,
+    }
+  })
+
+  // Connectivity
+  let connectivity = { ok: false, modelCount: 0 }
+  if (apiKey) {
+    try {
+      const fetch = require('node-fetch')
+      const r = await fetch(`${BASE_URL_ANTHROPIC}/v1/models`, {
+        headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
+        timeout: 8000,
+      })
+      if (r.ok) {
+        const data = await r.json()
+        connectivity = { ok: true, modelCount: data.data?.length || 0 }
+      }
+    } catch {}
+  }
+
+  json(res, {
+    node: { version: process.version, ok: nodeMajor >= 16 },
+    apiKey: { set: !!apiKey, masked: apiKey ? maskKey(apiKey) : null },
+    envVars: {
+      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || null,
+      ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN || null,
+      ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || null,
+      OPENAI_API_KEY: process.env.OPENAI_API_KEY || null,
+      OPENAI_BASE_URL: process.env.OPENAI_BASE_URL || null,
+    },
+    tools,
+    connectivity,
+  })
+}
+
+async function handleTools(_req, res) {
+  const tools = TOOLS.map(t => {
+    const installed = t.checkInstalled()
+    return {
+      id: t.id,
+      name: t.name,
+      installed,
+      configured: installed ? (t.isConfigured?.() || false) : false,
+      version: installed ? getVersion(t) : null,
+      installCmd: t.installCmd,
+      hint: t.hint || null,
+      launchCmd: t.launchCmd || null,
+      canAutoInstall: !!AUTO_INSTALL[t.id],
+    }
+  })
+  json(res, tools)
+}
+
+async function handleSetup(req, res) {
+  const body = await parseBody(req)
+  const { apiKey, models, toolIds, autoInstall } = body
+
+  sseStart(res)
+
+  // Step 1: Validate API Key — support using saved key
+  let effectiveKey = apiKey
+  if (apiKey === '__use_saved__') {
+    effectiveKey = getApiKey()
+    if (!effectiveKey) {
+      sseEmit(res, { type: 'error', message: '未找到已保存的 API Key' })
+      return res.end()
+    }
+  }
+  if (!effectiveKey || !effectiveKey.startsWith('cr_')) {
+    sseEmit(res, { type: 'error', message: 'API Key 必须以 cr_ 开头' })
+    return res.end()
+  }
+
+  sseEmit(res, { type: 'progress', step: 'validate', message: '验证 API Key...' })
+  try {
+    const valid = await validateApiKey(effectiveKey)
+    if (!valid) {
+      sseEmit(res, { type: 'error', message: 'API Key 无效' })
+      return res.end()
+    }
+    sseEmit(res, { type: 'progress', step: 'validate', status: 'ok', message: 'API Key 验证成功' })
+  } catch (e) {
+    sseEmit(res, { type: 'error', message: `验证失败: ${e.message}` })
+    return res.end()
+  }
+
+  // Step 2: Save API Key
+  saveConfig({ apiKey: effectiveKey, savedAt: new Date().toISOString() })
+  sseEmit(res, { type: 'progress', step: 'save-key', status: 'ok', message: 'API Key 已保存' })
+
+  // Step 3: Determine models
+  const selectedModels = models && models.length > 0 ? models : ['claude-sonnet-4-6']
+  const primaryModel = selectedModels.find(m => m.startsWith('claude-')) || selectedModels[0] || 'claude-sonnet-4-6'
+
+  // Step 4: Process each tool
+  const selectedToolIds = toolIds || []
+  const selectedTools = TOOLS.filter(t => selectedToolIds.includes(t.id))
+  const results = []
+
+  for (const tool of selectedTools) {
+    const installed = tool.checkInstalled()
+
+    // Auto-install if needed
+    if (!installed && autoInstall && AUTO_INSTALL[tool.id]) {
+      sseEmit(res, { type: 'progress', step: 'install', tool: tool.name, message: `正在安装 ${tool.name}...` })
+      const installOk = await new Promise(resolve => {
+        const child = spawn(AUTO_INSTALL[tool.id].cmd, [], { shell: true })
+        let output = ''
+        child.stdout?.on('data', chunk => {
+          output += chunk.toString()
+          sseEmit(res, { type: 'output', tool: tool.name, text: chunk.toString() })
+        })
+        child.stderr?.on('data', chunk => {
+          output += chunk.toString()
+          sseEmit(res, { type: 'output', tool: tool.name, text: chunk.toString() })
+        })
+        child.on('close', code => resolve(code === 0))
+        child.on('error', () => resolve(false))
+      })
+      if (!installOk) {
+        sseEmit(res, { type: 'progress', step: 'install', tool: tool.name, status: 'error', message: `${tool.name} 安装失败` })
+        results.push({ tool: tool.name, status: 'error', error: '安装失败' })
+        continue
+      }
+      sseEmit(res, { type: 'progress', step: 'install', tool: tool.name, status: 'ok', message: `${tool.name} 安装成功` })
+    } else if (!installed) {
+      sseEmit(res, { type: 'progress', step: 'skip', tool: tool.name, status: 'skip', message: `${tool.name} 未安装，跳过` })
+      results.push({ tool: tool.name, status: 'skip' })
+      continue
+    }
+
+    // Configure
+    sseEmit(res, { type: 'progress', step: 'configure', tool: tool.name, message: `配置 ${tool.name}...` })
+    try {
+      const result = tool.configure(effectiveKey, BASE_URL_ANTHROPIC, BASE_URL_OPENAI, primaryModel, selectedModels)
+      if (result.manual) {
+        sseEmit(res, { type: 'progress', step: 'configure', tool: tool.name, status: 'manual', message: `${tool.name} 需要手动配置`, steps: result.steps })
+        results.push({ tool: tool.name, status: 'manual', steps: result.steps })
+      } else if (result.warning) {
+        sseEmit(res, { type: 'progress', step: 'configure', tool: tool.name, status: 'warning', message: result.warning, file: result.file })
+        results.push({ tool: tool.name, status: 'warning', warning: result.warning, file: result.file })
+      } else {
+        sseEmit(res, { type: 'progress', step: 'configure', tool: tool.name, status: 'ok', message: `${tool.name} 配置成功`, file: result.file, hot: result.hot })
+        results.push({ tool: tool.name, status: 'ok', file: result.file, hot: result.hot })
+      }
+    } catch (e) {
+      sseEmit(res, { type: 'progress', step: 'configure', tool: tool.name, status: 'error', message: e.message })
+      results.push({ tool: tool.name, status: 'error', error: e.message })
+    }
+  }
+
+  // Step 5: Clean env vars
+  try {
+    const cleaned = removeEnvFromShell(['ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'OPENAI_API_KEY', 'OPENAI_BASE_URL'])
+    if (cleaned.length) {
+      sseEmit(res, { type: 'progress', step: 'clean-env', status: 'ok', message: `已清理环境变量: ${cleaned.join(', ')}` })
+    }
+  } catch {}
+
+  // Done
+  const ok = results.filter(r => r.status === 'ok').length
+  const errors = results.filter(r => r.status === 'error').length
+  sseEmit(res, { type: 'done', summary: { ok, errors, total: results.length, results } })
+  res.end()
+}
+
+async function handleReset(req, res) {
+  const body = await parseBody(req)
+  if (!body.confirm) return json(res, { error: '需要确认' }, 400)
+
+  const results = []
+  for (const tool of TOOLS) {
+    if (!tool.checkInstalled() && !tool.isConfigured?.()) continue
+    try {
+      tool.reset()
+      results.push({ tool: tool.name, status: 'ok' })
+    } catch (e) {
+      results.push({ tool: tool.name, status: 'error', error: e.message })
+    }
+  }
+
+  try { removeEnvFromShell() } catch {}
+  saveConfig({ apiKey: '' })
+
+  json(res, { success: true, results })
+}
+
+async function handleUpgrade(_req, res) {
+  sseStart(res)
+
+  for (const tool of UPGRADABLE_TOOLS) {
+    const installed = commandExists(tool.command)
+    if (!installed) {
+      sseEmit(res, { type: 'tool', name: tool.name, status: 'not-installed' })
+      continue
+    }
+
+    let localVer = null
+    try {
+      const out = execSync(tool.versionCmd, { stdio: 'pipe', timeout: 10000 }).toString().trim()
+      const m = out.match(/(\d+\.\d+\.\d+[\w.-]*)/)
+      localVer = m ? m[1] : out.split('\n')[0].slice(0, 30)
+    } catch {}
+
+    sseEmit(res, { type: 'tool', name: tool.name, status: 'upgrading', localVer })
+
+    const ok = await new Promise(resolve => {
+      const child = spawn(tool.installCmd, [], { shell: true })
+      child.stdout?.on('data', chunk => sseEmit(res, { type: 'output', name: tool.name, text: chunk.toString() }))
+      child.stderr?.on('data', chunk => sseEmit(res, { type: 'output', name: tool.name, text: chunk.toString() }))
+      child.on('close', code => resolve(code === 0))
+      child.on('error', () => resolve(false))
+    })
+
+    let newVer = null
+    try {
+      const out = execSync(tool.versionCmd, { stdio: 'pipe', timeout: 10000 }).toString().trim()
+      const m = out.match(/(\d+\.\d+\.\d+[\w.-]*)/)
+      newVer = m ? m[1] : null
+    } catch {}
+
+    sseEmit(res, { type: 'tool', name: tool.name, status: ok ? 'ok' : 'error', localVer, newVer })
+  }
+
+  sseEmit(res, { type: 'done' })
+  res.end()
+}
+
+async function handleToolInstall(req, res) {
+  const body = await parseBody(req)
+  const { toolId } = body
+  if (!toolId || !AUTO_INSTALL[toolId]) {
+    return json(res, { error: '不支持自动安装此工具' }, 400)
+  }
+
+  sseStart(res)
+  sseEmit(res, { type: 'progress', message: `正在安装 ${toolId}...` })
+
+  const ok = await new Promise(resolve => {
+    const child = spawn(AUTO_INSTALL[toolId].cmd, [], { shell: true })
+    child.stdout?.on('data', chunk => sseEmit(res, { type: 'output', text: chunk.toString() }))
+    child.stderr?.on('data', chunk => sseEmit(res, { type: 'output', text: chunk.toString() }))
+    child.on('close', code => resolve(code === 0))
+    child.on('error', () => resolve(false))
+  })
+
+  sseEmit(res, { type: 'done', success: ok })
+  res.end()
+}
+
+// ── Single-tool configure (SSE) ──────────────────────────────────────────────
+
+async function handleToolConfigure(req, res) {
+  const body = await parseBody(req)
+  const { toolId } = body
+  const apiKey = getApiKey()
+  if (!apiKey) return json(res, { error: '未登录' }, 401)
+
+  const tool = TOOLS.find(t => t.id === toolId)
+  if (!tool) return json(res, { error: '未知工具' }, 400)
+
+  sseStart(res)
+
+  if (!tool.checkInstalled()) {
+    sseEmit(res, { type: 'error', message: `${tool.name} 未安装` })
+    sseEmit(res, { type: 'done', success: false })
+    return res.end()
+  }
+
+  const allModelIds = ['gpt-5.4', 'gpt-5.3-codex-spark', 'claude-sonnet-4-6', 'claude-opus-4-6', 'MiniMax-M2.7-highspeed', 'claude-haiku-4-5']
+  const primaryModel = 'claude-sonnet-4-6'
+
+  sseEmit(res, { type: 'progress', message: `正在配置 ${tool.name}...` })
+
+  try {
+    const result = tool.configure(apiKey, BASE_URL_ANTHROPIC, BASE_URL_OPENAI, primaryModel, allModelIds)
+
+    if (result.envVars && Object.keys(result.envVars).length > 0) {
+      writeEnvToShell(result.envVars)
+      sseEmit(res, { type: 'progress', message: '已写入环境变量到 shell 配置' })
+    }
+
+    try { removeEnvFromShell(['ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'OPENAI_API_KEY', 'OPENAI_BASE_URL']) } catch {}
+
+    if (result.manual) {
+      sseEmit(res, { type: 'result', status: 'manual', message: `${tool.name} 需要手动完成配置`, steps: result.steps })
+    } else if (result.warning) {
+      sseEmit(res, { type: 'result', status: 'warning', message: result.warning, file: result.file })
+    } else {
+      sseEmit(res, { type: 'result', status: 'ok', message: `${tool.name} 配置成功`, file: result.file, hot: result.hot })
+    }
+
+    sseEmit(res, { type: 'done', success: true, file: result.file, hot: result.hot })
+  } catch (e) {
+    sseEmit(res, { type: 'error', message: e.message })
+    sseEmit(res, { type: 'done', success: false })
+  }
+  res.end()
+}
+
+// ── Single-tool reset ────────────────────────────────────────────────────────
+
+async function handleToolReset(req, res) {
+  const body = await parseBody(req)
+  const { toolId } = body
+  const tool = TOOLS.find(t => t.id === toolId)
+  if (!tool) return json(res, { error: '未知工具' }, 400)
+  try {
+    tool.reset()
+    json(res, { success: true })
+  } catch (e) {
+    json(res, { success: false, error: e.message }, 500)
+  }
+}
+
+// ── Environment variables ────────────────────────────────────────────────────
+
+const HS_ENV_KEYS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'OPENAI_API_KEY', 'OPENAI_BASE_URL']
+const MARKER_START = '# >>> holysheep-cli managed >>>'
+
+function handleEnv(_req, res) {
+  const vars = {}
+  for (const k of HS_ENV_KEYS) {
+    const v = process.env[k]
+    vars[k] = v ? (k.includes('KEY') || k.includes('TOKEN') ? maskKey(v) : v) : null
+  }
+
+  const rcFiles = []
+  try {
+    for (const f of getShellRcFiles()) {
+      let has = false
+      try { has = fs.readFileSync(f, 'utf8').includes(MARKER_START) } catch {}
+      rcFiles.push({ path: f.replace(require('os').homedir(), '~'), hasManagedBlock: has })
+    }
+  } catch {}
+
+  json(res, { vars, rcFiles })
+}
+
+function handleEnvClean(_req, res) {
+  try {
+    const cleaned = removeEnvFromShell()
+    json(res, { success: true, cleaned })
+  } catch (e) {
+    json(res, { success: false, error: e.message }, 500)
+  }
+}
+
+// ── Models list ──────────────────────────────────────────────────────────────
+
+function handleModels(_req, res) {
+  json(res, [
+    { id: 'gpt-5.4',                label: 'GPT 5.4',              desc: '通用编码' },
+    { id: 'gpt-5.3-codex-spark',    label: 'GPT 5.3 Codex Spark',  desc: '编码' },
+    { id: 'claude-sonnet-4-6',      label: 'Sonnet 4.6',           desc: '均衡推荐' },
+    { id: 'claude-opus-4-6',        label: 'Opus 4.6',             desc: '强力旗舰' },
+    { id: 'MiniMax-M2.7-highspeed', label: 'MiniMax M2.7',         desc: '高速经济版' },
+    { id: 'claude-haiku-4-5',       label: 'Haiku 4.5',            desc: '轻快便宜' },
+  ])
+}
+
+// ── Router ───────────────────────────────────────────────────────────────────
+
+async function handleRequest(req, res) {
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
+
+  if (req.method === 'OPTIONS') { res.writeHead(204); return res.end() }
+
+  const url = new URL(req.url, `http://${req.headers.host}`)
+  const route = url.pathname
+
+  try {
+    // Static
+    if (route === '/' || route === '/index.html') {
+      const html = fs.readFileSync(path.join(__dirname, 'index.html'), 'utf8')
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+      return res.end(html)
+    }
+
+    // API
+    if (route === '/api/status'  && req.method === 'GET')  return await handleStatus(req, res)
+    if (route === '/api/login'   && req.method === 'POST') return await handleLogin(req, res)
+    if (route === '/api/logout'  && req.method === 'POST') return await handleLogout(req, res)
+    if (route === '/api/balance' && req.method === 'GET')  return await handleBalance(req, res)
+    if (route === '/api/doctor'  && req.method === 'GET')  return await handleDoctor(req, res)
+    if (route === '/api/tools'   && req.method === 'GET')  return await handleTools(req, res)
+    if (route === '/api/models'  && req.method === 'GET')  return await handleModels(req, res)
+    if (route === '/api/upgrade' && req.method === 'POST') return await handleUpgrade(req, res)
+    if (route === '/api/tool/install'   && req.method === 'POST') return await handleToolInstall(req, res)
+    if (route === '/api/tool/configure' && req.method === 'POST') return await handleToolConfigure(req, res)
+    if (route === '/api/tool/reset'     && req.method === 'POST') return await handleToolReset(req, res)
+    if (route === '/api/env'       && req.method === 'GET')  return handleEnv(req, res)
+    if (route === '/api/env/clean' && req.method === 'POST') return handleEnvClean(req, res)
+
+    res.writeHead(404)
+    res.end('Not Found')
+  } catch (e) {
+    if (!res.headersSent) {
+      json(res, { error: e.message }, 500)
+    }
+  }
+}
+
+function startServer(port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(handleRequest)
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        // Try to kill stale process and retry once
+        try {
+          execSync(`lsof -ti:${port} | xargs kill -9`, { stdio: 'ignore' })
+        } catch {}
+        setTimeout(() => {
+          const retry = http.createServer(handleRequest)
+          retry.on('error', (err2) => reject(err2))
+          retry.listen(port, '127.0.0.1', () => resolve(retry))
+        }, 500)
+      } else {
+        reject(err)
+      }
+    })
+    server.listen(port, '127.0.0.1', () => resolve(server))
+  })
+}
+
+module.exports = { startServer }