free-coding-models 0.3.11 → 0.3.12

package/src/log-reader.js

@@ -1,195 +0,0 @@
-/**
- * @file lib/log-reader.js
- * @description Pure functions to load recent request-log entries from
- *   ~/.free-coding-models/request-log.jsonl, newest-first, bounded by a
- *   configurable row limit.
- *
- * Design principles:
- *   - Bounded reads only — never slurp the entire log for every TUI repaint.
- *   - Tolerates malformed / partially-written JSONL lines by skipping them.
- *   - No shared mutable state (pure functions, injectable file path for tests).
- *   - No new npm dependencies — uses only Node.js built-ins.
- *
- * Default path:
- *   ~/.free-coding-models/request-log.jsonl
- *
- * Row object shape returned from loadRecentLogs():
- *   {
- *     time:     string   // ISO timestamp string  (from entry.timestamp)
- *     requestType: string // e.g. "chat.completions"
- *     model:    string   // e.g. "llama-3.3-70b-instruct"
- *     requestedModel: string // public proxy model originally requested by the client
- *     provider: string   // e.g. "nvidia"
- *     status:   string   // e.g. "200" | "429" | "error"
- *     tokens:   number   // promptTokens + completionTokens (0 if unknown)
- *     latency:  number   // ms (0 if unknown)
- *     switched: boolean  // true when the router retried on a fallback provider/model
- *     switchReason: string|null // short reason label shown in the log UI
- *   }
- *
- * @exports loadRecentLogs
- * @exports parseLogLine
- */
-
-import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-
-const DEFAULT_LOG_FILE = join(homedir(), '.free-coding-models', 'request-log.jsonl')
-
-/** Maximum bytes to read from the tail of the file to avoid OOM on large logs. */
-const MAX_READ_BYTES = 128 * 1024 // 128 KB
-
-function normalizeTimestamp(raw) {
-  if (typeof raw === 'number' && Number.isFinite(raw)) {
-    return new Date(raw).toISOString()
-  }
-  if (typeof raw === 'string') {
-    const numeric = Number(raw)
-    if (Number.isFinite(numeric)) return new Date(numeric).toISOString()
-    const parsed = new Date(raw)
-    if (!Number.isNaN(parsed.getTime())) return parsed.toISOString()
-  }
-  return null
-}
-
-function inferProvider(entry) {
-  if (entry.providerKey || entry.provider) {
-    return String(entry.providerKey ?? entry.provider)
-  }
-  if (typeof entry.accountId === 'string' && entry.accountId.includes('/')) {
-    return entry.accountId.split('/')[0] || 'unknown'
-  }
-  return 'unknown'
-}
-
-function inferStatus(entry) {
-  if (entry.statusCode !== undefined || entry.status !== undefined) {
-    return String(entry.statusCode ?? entry.status)
-  }
-  if (typeof entry.success === 'boolean') {
-    return entry.success ? '200' : 'error'
-  }
-  return 'unknown'
-}
-
-function inferRequestType(entry) {
-  if (entry.requestType !== undefined || entry.type !== undefined) {
-    return String(entry.requestType ?? entry.type)
-  }
-  if (typeof entry.url === 'string') {
-    if (entry.url.includes('/chat/completions')) return 'chat.completions'
-    if (entry.url.includes('/models')) return 'models'
-  }
-  return 'chat.completions'
-}
-
-/**
- * Parse a single JSONL line into a normalised log row object.
- *
- * Returns `null` for any line that is blank, not valid JSON, or missing
- * the required `timestamp` field.
- *
- * @param {string} line - A single text line from the JSONL file.
- * @returns {{ time: string, requestType: string, model: string, requestedModel: string, provider: string, status: string, tokens: number, latency: number, switched: boolean, switchReason: string|null, switchedFromProvider: string|null, switchedFromModel: string|null } | null}
- */
-export function parseLogLine(line) {
-  const trimmed = line.trim()
-  if (!trimmed) return null
-  let entry
-  try {
-    entry = JSON.parse(trimmed)
-  } catch {
-    return null
-  }
-  if (!entry || typeof entry !== 'object') return null
-  if (!entry.timestamp) return null
-
-  const normalizedTime = normalizeTimestamp(entry.timestamp)
-  if (!normalizedTime) return null
-
-  const model    = String(entry.modelId    ?? entry.model    ?? 'unknown')
-  const requestedModel = typeof entry.requestedModelId === 'string'
-    ? entry.requestedModelId
-    : (typeof entry.requestedModel === 'string' ? entry.requestedModel : '')
-  const provider = inferProvider(entry)
-  const status   = inferStatus(entry)
-  const requestType = inferRequestType(entry)
-  const tokens   = (Number(entry.usage?.prompt_tokens ?? entry.promptTokens ?? 0) +
-                    Number(entry.usage?.completion_tokens ?? entry.completionTokens ?? 0)) || 0
-  const latency  = Number(entry.latencyMs ?? entry.latency ?? 0) || 0
-  const switched = entry.switched === true
-  const switchReason = typeof entry.switchReason === 'string' && entry.switchReason.trim().length > 0
-    ? entry.switchReason.trim()
-    : null
-  const switchedFromProvider = typeof entry.switchedFromProviderKey === 'string' && entry.switchedFromProviderKey.trim().length > 0
-    ? entry.switchedFromProviderKey.trim()
-    : null
-  const switchedFromModel = typeof entry.switchedFromModelId === 'string' && entry.switchedFromModelId.trim().length > 0
-    ? entry.switchedFromModelId.trim()
-    : null
-
-  return {
-    time: normalizedTime,
-    requestType,
-    model,
-    requestedModel,
-    provider,
-    status,
-    tokens,
-    latency,
-    switched,
-    switchReason,
-    switchedFromProvider,
-    switchedFromModel,
-  }
-}
-
-/**
- * Load the N most-recent log entries from the JSONL file, newest-first.
- *
- * Only reads up to MAX_READ_BYTES from the end of the file to avoid
- * loading the entire log history.  Malformed lines are silently skipped.
- *
- * @param {object}  [opts]
- * @param {string}  [opts.logFile]  - Path to request-log.jsonl (injectable for tests)
- * @param {number}  [opts.limit]    - Maximum rows to return (default 200)
- * @returns {Array<{ time: string, requestType: string, model: string, requestedModel: string, provider: string, status: string, tokens: number, latency: number, switched: boolean, switchReason: string|null, switchedFromProvider: string|null, switchedFromModel: string|null }>}
- */
-export function loadRecentLogs({ logFile = DEFAULT_LOG_FILE, limit = 200 } = {}) {
-  try {
-    if (!existsSync(logFile)) return []
-
-    const fileSize = statSync(logFile).size
-    if (fileSize === 0) return []
-
-    // 📖 Read only the tail of the file (bounded by MAX_READ_BYTES) to avoid
-    // 📖 reading multi-megabyte logs on every TUI repaint.
-    const readBytes = Math.min(fileSize, MAX_READ_BYTES)
-    const fileOffset = fileSize - readBytes
-
-    const buf = Buffer.allocUnsafe(readBytes)
-    const fd = openSync(logFile, 'r')
-    try {
-      readSync(fd, buf, 0, readBytes, fileOffset)
-    } finally {
-      closeSync(fd)
-    }
-
-    const text = buf.toString('utf8')
-
-    // 📖 Split on newlines; if we started mid-line (fileOffset > 0), drop
-    // 📖 the first (potentially incomplete) line to avoid corrupt JSON.
-    const rawLines = text.split('\n')
-    const lines = fileOffset > 0 ? rawLines.slice(1) : rawLines
-
-    const rows = []
-    for (let i = lines.length - 1; i >= 0 && rows.length < limit; i--) {
-      const row = parseLogLine(lines[i])
-      if (row) rows.push(row)
-    }
-    return rows
-  } catch {
-    return []
-  }
-}

package/src/opencode-sync.js

@@ -1,200 +0,0 @@
-import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-import { randomBytes } from 'node:crypto'
-
-const OC_CONFIG_DIR = join(homedir(), '.config', 'opencode')
-const OC_CONFIG_PATH = join(OC_CONFIG_DIR, 'opencode.json')
-const OC_BACKUP_PATH = join(OC_CONFIG_DIR, 'opencode.json.bak')
-const FCM_PROVIDER_ID = 'fcm-proxy'
-const DEFAULT_PROXY_BASE_URL = 'http://127.0.0.1:8045/v1'
-
-function generateProxyToken() {
-  return `fcm_${randomBytes(24).toString('hex')}`
-}
-
-function ensureV1BaseUrl(baseURL) {
-  if (typeof baseURL !== 'string' || baseURL.length === 0) {
-    return DEFAULT_PROXY_BASE_URL
-  }
-  const trimmed = baseURL.replace(/\/+$/, '')
-  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`
-}
-
-/**
- * Load existing OpenCode config, or return empty object.
- */
-export function loadOpenCodeConfig() {
-  try {
-    if (existsSync(OC_CONFIG_PATH)) {
-      return JSON.parse(readFileSync(OC_CONFIG_PATH, 'utf8'))
-    }
-  } catch {}
-  return {}
-}
-
-/**
- * Save OpenCode config with automatic backup.
- * Creates backup of current config before overwriting.
- */
-export function saveOpenCodeConfig(config) {
-  mkdirSync(OC_CONFIG_DIR, { recursive: true })
-  // Backup existing config before saving
-  if (existsSync(OC_CONFIG_PATH)) {
-    copyFileSync(OC_CONFIG_PATH, OC_BACKUP_PATH)
-  }
-  writeFileSync(OC_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
-}
-
-/**
- * Restore OpenCode config from backup.
- * @returns {boolean} true if restored, false if no backup exists
- */
-export function restoreOpenCodeBackup() {
-  if (!existsSync(OC_BACKUP_PATH)) return false
-  copyFileSync(OC_BACKUP_PATH, OC_CONFIG_PATH)
-  return true
-}
-
-/**
- * Pure merge: apply FCM provider entry into an existing OpenCode config object.
- *
- * This function contains the merge logic without any filesystem I/O so it can
- * be unit-tested in isolation. It is exported for tests and used internally by
- * syncToOpenCode.
- *
- * CRITICAL: This function ONLY adds/updates the fcm-proxy provider entry.
- * It PRESERVES all existing providers (antigravity-manager, openai, iflow, etc.)
- * and all other top-level keys ($schema, mcp, plugin, command, model).
- *
- * proxyInfo should only carry runtime port/token when the proxy is actively
- * running (running === true). Callers MUST NOT pass stale values from a stopped
- * proxy — use undefined/omit the fields instead so we fall back to the existing
- * persisted provider options cleanly.
- *
- * @param {Object} ocConfig - Existing OpenCode config object (will be mutated in-place)
- * @param {Array} mergedModels - Output of buildMergedModels()
- * @param {{ proxyPort?: number, proxyToken?: string, availableModelSlugs?: Set<string>|string[] }} proxyInfo
- *   availableModelSlugs: when provided, only models whose slug is in this set are written
- *   to the OpenCode catalog. Use this to prevent "ghost" entries for models with no API keys.
- * @returns {Object} The mutated ocConfig
- */
-export function mergeOcConfig(ocConfig, mergedModels, proxyInfo = {}) {
-  ocConfig.provider = ocConfig.provider || {}
-
-  const existingProvider = ocConfig.provider[FCM_PROVIDER_ID] || {}
-  const existingOptions = existingProvider.options || {}
-
-  // Only use the runtime proxyPort if it is a valid positive integer.
-  // A null/undefined/0 port means the proxy is not running — fall back to
-  // the existing persisted baseURL so we don't write a broken URL.
-  const hasValidPort = Number.isInteger(proxyInfo.proxyPort) && proxyInfo.proxyPort > 0
-  const baseURL = ensureV1BaseUrl(
-    hasValidPort
-      ? `http://127.0.0.1:${proxyInfo.proxyPort}`
-      : existingOptions.baseURL
-  )
-
-  // Keep token stable unless caller provides a runtime token.
-  // A non-string or empty proxyToken is treated as absent.
-  const hasValidToken = typeof proxyInfo.proxyToken === 'string' && proxyInfo.proxyToken.length > 0
-  const hasExistingToken =
-    typeof existingOptions.apiKey === 'string' &&
-    existingOptions.apiKey.length > 0 &&
-    existingOptions.apiKey !== 'fcm-proxy-token'
-  const apiKey = hasValidToken ? proxyInfo.proxyToken : (hasExistingToken ? existingOptions.apiKey : generateProxyToken())
-
-  const slugFilter = proxyInfo.availableModelSlugs
-    ? new Set(proxyInfo.availableModelSlugs)
-    : null
-
-  const models = {}
-  for (const m of mergedModels) {
-    if (slugFilter && !slugFilter.has(m.slug)) continue
-    models[m.slug] = { name: m.label }
-  }
-
-  ocConfig.provider[FCM_PROVIDER_ID] = {
-    npm: '@ai-sdk/openai-compatible',
-    name: 'FCM Rotation Proxy',
-    options: {
-      ...existingOptions,
-      baseURL,
-      apiKey,
-    },
-    models,
-  }
-
-  return ocConfig
-}
-
-/**
- * Pure cleanup: remove only the persisted FCM proxy provider and any default
- * model that still points at it. Other OpenCode providers stay untouched.
- *
- * @param {Object} ocConfig - Existing OpenCode config object (will be mutated in-place)
- * @returns {{ removedProvider: boolean, removedModel: boolean, config: Object }}
- */
-export function removeFcmProxyFromConfig(ocConfig) {
-  if (!ocConfig || typeof ocConfig !== 'object') {
-    return { removedProvider: false, removedModel: false, config: {} }
-  }
-
-  const hadProvider = Boolean(ocConfig.provider?.[FCM_PROVIDER_ID])
-  if (hadProvider) {
-    delete ocConfig.provider[FCM_PROVIDER_ID]
-    if (Object.keys(ocConfig.provider).length === 0) delete ocConfig.provider
-  }
-
-  const hadModel = typeof ocConfig.model === 'string' && ocConfig.model.startsWith(`${FCM_PROVIDER_ID}/`)
-  if (hadModel) delete ocConfig.model
-
-  return { removedProvider: hadProvider, removedModel: hadModel, config: ocConfig }
-}
-
-/**
- * MERGE the single FCM proxy provider into OpenCode config.
- *
- * CRITICAL: This function ONLY adds/updates the fcm-proxy provider entry.
- * It PRESERVES all existing providers (antigravity-manager, openai, iflow, etc.)
- * and all other top-level keys ($schema, mcp, plugin, command, model).
- *
- * proxyInfo should only carry runtime port/token when the proxy is actively
- * running (running === true). Callers MUST NOT pass stale values from a stopped
- * proxy — use undefined/omit the fields instead so we fall back to the existing
- * persisted provider options cleanly.
- *
- * @param {Object} fcmConfig - FCM config (from loadConfig())
- * @param {Object} _sources - PROVIDERS object from sources.js (unused, kept for signature compatibility)
- * @param {Array} mergedModels - Output of buildMergedModels()
- * @param {{ proxyPort?: number, proxyToken?: string, availableModelSlugs?: Set<string>|string[] }} proxyInfo
- *   availableModelSlugs: slugs of models that have real API key accounts. When provided,
- *   only those models appear in the OpenCode catalog, preventing ghost entries.
- */
-export function syncToOpenCode(fcmConfig, _sources, mergedModels, proxyInfo = {}) {
-  const oc = loadOpenCodeConfig()
-  const merged = mergeOcConfig(oc, mergedModels, proxyInfo)
-  saveOpenCodeConfig(merged)
-  return {
-    providerKey: FCM_PROVIDER_ID,
-    modelCount: Object.keys(merged.provider[FCM_PROVIDER_ID].models).length,
-    path: OC_CONFIG_PATH,
-  }
-}
-
-/**
- * Remove the persisted FCM proxy provider from OpenCode's config on disk.
- * This is the user-facing cleanup operation for "proxy uninstall".
- *
- * @returns {{ removedProvider: boolean, removedModel: boolean, path: string }}
- */
-export function cleanupOpenCodeProxyConfig() {
-  const oc = loadOpenCodeConfig()
-  const result = removeFcmProxyFromConfig(oc)
-  saveOpenCodeConfig(result.config)
-  return {
-    removedProvider: result.removedProvider,
-    removedModel: result.removedModel,
-    path: OC_CONFIG_PATH,
-  }
-}

package/src/proxy-foreground.js

@@ -1,234 +0,0 @@
-/**
- * @file src/proxy-foreground.js
- * @description Foreground proxy mode — starts the FCM Proxy V2 in the current terminal
- * with a live dashboard showing status, accounts, and incoming requests.
- *
- * 📖 This is the `--proxy` flag handler. Unlike the daemon, it runs in the foreground
- *    with a live-updating terminal UI that shows proxy health and request activity.
- *    Perfect for debugging, dev testing (no .git check), and monitoring.
- *
- * @functions
- *   → startForegroundProxy(config, chalk) — main entry point, starts proxy + dashboard
- *
- * @exports startForegroundProxy
- *
- * @see src/proxy-server.js — ProxyServer implementation
- * @see src/proxy-topology.js — topology builder
- * @see bin/fcm-proxy-daemon.js — headless daemon equivalent
- */
-
-import { loadConfig, getProxySettings } from './config.js'
-import { ProxyServer } from './proxy-server.js'
-import { buildProxyTopologyFromConfig, buildMergedModelsForDaemon } from './proxy-topology.js'
-import { sources } from '../sources.js'
-import { syncProxyToTool, resolveProxySyncToolMode } from './proxy-sync.js'
-import { buildMergedModels } from './model-merger.js'
-import { createHash, randomBytes } from 'node:crypto'
-
-// 📖 Default foreground proxy port — same as daemon
-const DEFAULT_PORT = 18045
-
-/**
- * 📖 Start the proxy in foreground mode with a live terminal dashboard.
- * 📖 No .git check, no daemon install — just starts the proxy and shows activity.
- *
- * @param {object} config — loaded FCM config
- * @param {object} chalk — chalk instance for terminal colors
- */
-export async function startForegroundProxy(config, chalk) {
-  const proxySettings = getProxySettings(config)
-  const port = proxySettings.preferredPort || DEFAULT_PORT
-
-  // 📖 Ensure a stable token exists — generate one if missing (dev-friendly)
-  let token = proxySettings.stableToken
-  if (!token) {
-    token = 'fcm_' + randomBytes(16).toString('hex')
-    console.log(chalk.yellow('  ⚠ No stableToken in config — generated a temporary one for this session'))
-  }
-
-  console.log()
-  console.log(chalk.bold('  📡 FCM Proxy V2 — Foreground Mode'))
-  console.log(chalk.dim('  ─────────────────────────────────────────────'))
-  console.log()
-
-  // 📖 Build topology
-  console.log(chalk.dim('  Building merged model catalog...'))
-  let mergedModels
-  try {
-    mergedModels = await buildMergedModelsForDaemon()
-  } catch (err) {
-    console.error(chalk.red(`  ✗ Failed to build model catalog: ${err.message}`))
-    process.exit(1)
-  }
-
-  const topology = buildProxyTopologyFromConfig(config, mergedModels, sources)
-  const { accounts, proxyModels, anthropicRouting } = topology
-
-  if (accounts.length === 0) {
-    console.error(chalk.red('  ✗ No API keys configured — no accounts to serve.'))
-    console.error(chalk.dim('  Add keys via the TUI first (run free-coding-models without --proxy)'))
-    process.exit(1)
-  }
-
-  // 📖 Start proxy server
-  const proxy = new ProxyServer({
-    port,
-    accounts,
-    proxyApiKey: token,
-    anthropicRouting,
-  })
-
-  let listeningPort
-  try {
-    const result = await proxy.start()
-    listeningPort = result.port
-  } catch (err) {
-    if (err.code === 'EADDRINUSE') {
-      console.error(chalk.red(`  ✗ Port ${port} already in use.`))
-      console.error(chalk.dim('  Another FCM proxy or process may be running on that port.'))
-      process.exit(2)
-    }
-    console.error(chalk.red(`  ✗ Failed to start proxy: ${err.message}`))
-    process.exit(1)
-  }
-
-  const modelCount = Object.keys(proxyModels).length
-
-  // 📖 Sync env file for claude-code if it's a syncable tool
-  try {
-    const baseUrl = `http://127.0.0.1:${listeningPort}/v1`
-    const proxyInfo = { baseUrl, token }
-    syncProxyToTool('claude-code', proxyInfo, mergedModels)
-  } catch { /* best effort */ }
-
-  // 📖 Dashboard header
-  console.log(chalk.green('  ✓ Proxy running'))
-  console.log()
-  console.log(chalk.bold('  Status'))
-  console.log(chalk.dim('  ─────────────────────────────────────────────'))
-  console.log(`  ${chalk.cyan('Endpoint')}     http://127.0.0.1:${listeningPort}`)
-  console.log(`  ${chalk.cyan('Token')}        ${token.slice(0, 12)}...${token.slice(-4)}`)
-  console.log(`  ${chalk.cyan('Accounts')}     ${accounts.length}`)
-  console.log(`  ${chalk.cyan('Models')}       ${modelCount}`)
-  console.log()
-
-  // 📖 Show provider breakdown
-  const byProvider = {}
-  for (const acct of accounts) {
-    byProvider[acct.providerKey] = (byProvider[acct.providerKey] || 0) + 1
-  }
-  console.log(chalk.bold('  Providers'))
-  console.log(chalk.dim('  ─────────────────────────────────────────────'))
-  for (const [provider, count] of Object.entries(byProvider).sort((a, b) => b[1] - a[1])) {
-    console.log(`  ${chalk.cyan(provider.padEnd(20))} ${count} account${count > 1 ? 's' : ''}`)
-  }
-  console.log()
-
-  // 📖 Claude Code quick-start hint
-  console.log(chalk.bold('  Quick Start'))
-  console.log(chalk.dim('  ─────────────────────────────────────────────'))
-  console.log(chalk.dim('  Claude Code:'))
-  console.log(`    ${chalk.cyan(`ANTHROPIC_BASE_URL=http://127.0.0.1:${listeningPort} ANTHROPIC_API_KEY=${token} claude`)}`)
-  console.log()
-  console.log(chalk.dim('  curl test:'))
-  console.log(`    ${chalk.cyan(`curl -s -H "x-api-key: ${token}" http://127.0.0.1:${listeningPort}/v1/models | head`)}`)
-  console.log()
-
-  console.log(chalk.bold('  Live Requests'))
-  console.log(chalk.dim('  ─────────────────────────────────────────────'))
-  console.log(chalk.dim('  Waiting for incoming requests... (Ctrl+C to stop)'))
-  console.log()
-
-  // 📖 Monkey-patch tokenStats.record to intercept and display live requests
-  const originalRecord = proxy._tokenStats.record.bind(proxy._tokenStats)
-  let requestCount = 0
-  proxy._tokenStats.record = (entry) => {
-    originalRecord(entry)
-    requestCount++
-
-    const now = new Date().toLocaleTimeString()
-    const status = entry.success ? chalk.green(`${entry.statusCode}`) : chalk.red(`${entry.statusCode}`)
-    const latency = entry.latencyMs ? chalk.dim(`${entry.latencyMs}ms`) : ''
-    const tokens = (entry.promptTokens + entry.completionTokens) > 0
-      ? chalk.dim(`${entry.promptTokens}+${entry.completionTokens}tok`)
-      : ''
-    const reqType = entry.requestType || 'unknown'
-    const model = entry.requestedModelId || entry.modelId || '?'
-    const provider = entry.providerKey || '?'
-    const switched = entry.switched ? chalk.yellow(' ↻') : ''
-
-    console.log(
-      `  ${chalk.dim(now)}  ${status}  ${chalk.cyan(reqType.padEnd(20))}  ` +
-      `${chalk.white(model)}  →  ${chalk.dim(provider)}${switched}  ${latency}  ${tokens}`
-    )
-  }
-
-  // 📖 Also intercept errors on the _handleRequest level to show auth failures etc.
-  const originalHandleRequest = proxy._handleRequest.bind(proxy)
-  proxy._handleRequest = (req, res) => {
-    const origEnd = res.end.bind(res)
-    const method = req.method
-    const url = req.url
-    let logged = false
-
-    res.end = function (...args) {
-      if (!logged && res.statusCode >= 400) {
-        logged = true
-        const now = new Date().toLocaleTimeString()
-        const status = chalk.red(`${res.statusCode}`)
-        const ua = req.headers['user-agent'] || ''
-        // 📖 Try to detect the client tool from user-agent
-        const tool = detectClientTool(ua, req.headers)
-        const toolLabel = tool ? chalk.magenta(` [${tool}]`) : ''
-        console.log(
-          `  ${chalk.dim(now)}  ${status}  ${chalk.cyan(`${method} ${url}`.padEnd(20))}  ` +
-          `${chalk.dim('rejected')}${toolLabel}`
-        )
-        // 📖 Debug: show auth headers on 401 to help diagnose auth issues
-        if (res.statusCode === 401) {
-          const authHeader = req.headers.authorization ? `Bearer ${req.headers.authorization.slice(0, 20)}...` : 'none'
-          const xApiKeyHeader = req.headers['x-api-key'] ? `${req.headers['x-api-key'].slice(0, 20)}...` : 'none'
-          console.log(chalk.dim(`         auth: ${authHeader}  |  x-api-key: ${xApiKeyHeader}`))
-        }
-      }
-      return origEnd(...args)
-    }
-
-    return originalHandleRequest(req, res)
-  }
-
-  // 📖 Graceful shutdown
-  const shutdown = async (signal) => {
-    console.log()
-    console.log(chalk.dim(`  Received ${signal} — shutting down...`))
-    try { await proxy.stop() } catch { /* best effort */ }
-    console.log(chalk.green(`  ✓ Proxy stopped. ${requestCount} request${requestCount !== 1 ? 's' : ''} served this session.`))
-    console.log()
-    process.exit(0)
-  }
-
-  process.on('SIGINT', () => shutdown('SIGINT'))
-  process.on('SIGTERM', () => shutdown('SIGTERM'))
-}
-
-/**
- * 📖 Detect which client tool sent the request based on User-Agent or custom headers.
- * 📖 Claude Code, Codex, OpenCode etc. each have distinctive UA patterns.
- */
-function detectClientTool(ua, headers) {
-  if (!ua && !headers) return null
-  const uaLower = (ua || '').toLowerCase()
-
-  if (uaLower.includes('claude') || uaLower.includes('anthropic')) return 'Claude Code'
-  if (headers?.['anthropic-version'] || headers?.['x-api-key']) return 'Anthropic SDK'
-  if (uaLower.includes('codex')) return 'Codex'
-  if (uaLower.includes('opencode')) return 'OpenCode'
-  if (uaLower.includes('cursor')) return 'Cursor'
-  if (uaLower.includes('aider')) return 'Aider'
-  if (uaLower.includes('goose')) return 'Goose'
-  if (uaLower.includes('openclaw')) return 'OpenClaw'
-  if (uaLower.includes('node-fetch') || uaLower.includes('undici')) return 'Node.js'
-  if (uaLower.includes('python')) return 'Python'
-  if (uaLower.includes('curl')) return 'curl'
-  return null
-}