token-trace-manager 0.7.0

package/lib/config.mjs

@@ -0,0 +1,135 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { dataDir } from './db.mjs'
+
+// Porta padrão deliberadamente fora das "manjadas" (8080/3000/8000/9090).
+// 25519 é memorável (aceno à curva ed25519) e não registrada na IANA.
+export const DEFAULT_PORT = 25519
+
+// Protocolos de wire reconhecidos pelos extratores em adapters.mjs.
+// Qualquer outro valor no target.protocol é marcado como _invalid em readConfig
+// e recusado em runtime (400 no proxyRequest) — sem cair silenciosamente no
+// extrator OpenAI default (que produziria 0 tokens sem erro visível).
+export const KNOWN_PROTOCOLS = ['anthropic', 'openai', 'openai-responses', 'gemini']
+
+// Targets padrão: o primeiro segmento do path escolhe o upstream.
+// targetUrl = URL base real do provedor que o TUI chamaria sem o proxy.
+const DEFAULT_TARGETS = {
+  anthropic: { targetUrl: 'https://api.anthropic.com', protocol: 'anthropic' },
+  openai: { targetUrl: 'https://api.openai.com', protocol: 'openai' },
+  gemini: { targetUrl: 'https://generativelanguage.googleapis.com', protocol: 'gemini' },
+  openrouter: { targetUrl: 'https://openrouter.ai/api', protocol: 'openai' },
+}
+
+function configPath() {
+  return path.join(dataDir(), 'config.json')
+}
+
+function readUserRaw() {
+  try {
+    return JSON.parse(fs.readFileSync(configPath(), 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeUserRaw(user) {
+  // Escrita atômica (tmp+rename): evita config corrompida se o processo for
+  // morto no meio da escrita (ex: shutdown entre link/unlink). No Windows,
+  // rename sobre arquivo existente pode falhar (EPERM) — aí fallback.
+  const tmp = configPath() + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(user, null, 2))
+  try {
+    fs.renameSync(tmp, configPath())
+  } catch {
+    try { fs.unlinkSync(configPath()) } catch {}
+    fs.renameSync(tmp, configPath())
+  }
+}
+
+export function readConfig() {
+  const user = readUserRaw()
+  const port = user.port ?? DEFAULT_PORT
+  const mergedTargets = { ...DEFAULT_TARGETS, ...(user.targets ?? {}) }
+  const targets = {}
+  for (const [name, t] of Object.entries(mergedTargets)) {
+    targets[name] = { ...t, _invalid: !KNOWN_PROTOCOLS.includes(t.protocol) }
+  }
+  return {
+    port,
+    proxyUrl: user.proxyUrl ?? `http://127.0.0.1:${port}`,
+    injectUsage: user.injectUsage ?? true,
+    retentionHours: user.retentionHours ?? 24,
+    storePayloads: user.storePayloads ?? true,
+    otel: user.otel ?? null,
+    targets,
+    links: user.links ?? {},
+  }
+}
+
+export function writeConfig(patch) {
+  const user = readUserRaw()
+  const next = { ...user, ...patch }
+  writeUserRaw(next)
+  return readConfig()
+}
+
+// Patch de UM único target sem clobberar os demais (writeConfig faz merge raso
+// no nível top-level, então passar {targets: {...}} substituiria o mapa todo).
+export function setTarget(name, spec) {
+  const user = readUserRaw()
+  user.targets = user.targets ?? {}
+  user.targets[name] = spec
+  writeUserRaw(user)
+  return readConfig()
+}
+
+export function removeTarget(name) {
+  const user = readUserRaw()
+  if (user.targets && user.targets[name]) {
+    delete user.targets[name]
+    writeUserRaw(user)
+  }
+  return readConfig()
+}
+
+export function setLink(tui, info) {
+  const user = readUserRaw()
+  user.links = user.links ?? {}
+  if (info === null) delete user.links[tui]
+  else user.links[tui] = info
+  writeUserRaw(user)
+  return readConfig()
+}
+
+// Validação de config para warnings em boot/CLI (NUNCA chamada por-request:
+// readConfig já marca _invalid nos targets; isso só produz mensagens).
+export function validateConfig(cfg) {
+  const warnings = []
+  const invalidTargets = []
+  for (const [name, t] of Object.entries(cfg.targets)) {
+    if (t._invalid) {
+      invalidTargets.push(name)
+      warnings.push(
+        `target "${name}" tem protocolo desconhecido "${t.protocol}" (válidos: ${KNOWN_PROTOCOLS.join(', ')}) — será recusado em runtime`,
+      )
+    }
+    if (t.targetUrl) {
+      try {
+        const u = new URL(t.targetUrl)
+        if (/\/v1$/.test(u.pathname) || /\/v1\//.test(u.pathname)) {
+          warnings.push(
+            `target "${name}" targetUrl "${t.targetUrl}" inclui sufixo de rota (/v1...) — pode dobrar o path no upstream (o ttm já encadeia o caminho do TUI)`,
+          )
+        }
+      } catch {
+        warnings.push(`target "${name}" targetUrl inválida: "${t.targetUrl}"`)
+      }
+    }
+  }
+  return { warnings, invalidTargets }
+}
+
+export function pidFilePath() {
+  return path.join(dataDir(), 'daemon.pid')
+}

package/lib/daemon-client.mjs

@@ -0,0 +1,139 @@
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { readConfig, pidFilePath } from './config.mjs'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const LOCAL_VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version
+
+export async function fetchDaemon(pathname, { method = 'GET', body = null, timeoutMs = 3000 } = {}) {
+  const cfg = readConfig()
+  const res = await fetch(`http://127.0.0.1:${cfg.port}${pathname}`, {
+    method,
+    body: body ? JSON.stringify(body) : undefined,
+    headers: body ? { 'content-type': 'application/json' } : undefined,
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const json = await res.json()
+  if (!res.ok) throw new Error(json.error || `HTTP ${res.status}`)
+  return json
+}
+
+export async function daemonHealth() {
+  try {
+    return await fetchDaemon('/healthz', { timeoutMs: 1500 })
+  } catch {
+    return null
+  }
+}
+
+async function spawnDaemon() {
+  const child = spawn(process.execPath, [path.join(__dirname, 'daemon.mjs')], {
+    detached: true,
+    stdio: 'ignore',
+  })
+  child.unref()
+
+  for (let i = 0; i < 20; i++) {
+    await new Promise(r => setTimeout(r, 150))
+    const h = await daemonHealth()
+    if (h) return h
+  }
+  throw new Error('daemon não respondeu ao /healthz após o start — verifique a porta com `ttm status`')
+}
+
+export async function ensureDaemon() {
+  const health = await daemonHealth()
+  if (health && health.version === LOCAL_VERSION) return { started: false, health }
+
+  // Daemon de uma versão antiga ainda de pé após upgrade: template/dados
+  // ficariam inconsistentes — reinicia com o código novo automaticamente.
+  if (health) {
+    await stopDaemon()
+    const h = await spawnDaemon()
+    return { started: true, restartedFrom: health.version, health: h }
+  }
+
+  return { started: true, health: await spawnDaemon() }
+}
+
+// O pid do /healthz é a fonte de verdade (o próprio daemon responde). O pid
+// file é só dica: pode ficar obsoleto após crash/SIGKILL e, com reuso de PID
+// pelo SO, apontar para um processo alheio — por isso, antes de matar por pid
+// file, confirmamos via /proc que o processo é mesmo o nosso daemon.
+function pidLooksLikeDaemon(pid) {
+  try {
+    const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8')
+    return cmdline.includes('daemon.mjs')
+  } catch {
+    return null // sem /proc (macOS etc.) — não dá pra confirmar
+  }
+}
+
+export async function stopDaemon() {
+  const pidFile = pidFilePath()
+  const clearPidFile = () => {
+    try {
+      fs.unlinkSync(pidFile)
+    } catch {
+      /* já removido */
+    }
+  }
+
+  // O daemon encerra graciosamente (espera streams em voo, até 15s) —
+  // aguardamos o processo sair de fato para liberar a porta antes de retornar.
+  const waitExit = async pid => {
+    for (let i = 0; i < 170; i++) {
+      try {
+        process.kill(pid, 0)
+      } catch {
+        return true // processo saiu
+      }
+      await new Promise(r => setTimeout(r, 100))
+    }
+    return false
+  }
+
+  const h = await daemonHealth()
+  if (h?.pid) {
+    try {
+      process.kill(h.pid, 'SIGTERM')
+    } catch (err) {
+      return { stopped: false, reason: `não consegui matar pid ${h.pid}: ${err.message}` }
+    }
+    clearPidFile()
+    const exited = await waitExit(h.pid)
+    return { stopped: true, pid: h.pid, graceful: exited }
+  }
+
+  // Sem healthz: daemon travado ou morto. Só matamos por pid file se
+  // conseguirmos confirmar que o processo é o daemon.
+  let pid = null
+  try {
+    pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10)
+  } catch {
+    /* sem pid file */
+  }
+  if (!pid) return { stopped: false, reason: 'daemon não está rodando' }
+
+  const confirmed = pidLooksLikeDaemon(pid)
+  if (confirmed === false) {
+    clearPidFile() // pid file obsoleto apontando pra outro processo
+    return { stopped: false, reason: `pid file obsoleto (pid ${pid} não é o daemon) — removido` }
+  }
+  if (confirmed === null) {
+    return {
+      stopped: false,
+      reason: `daemon não responde e não consigo confirmar o pid ${pid} nesta plataforma — mate manualmente se necessário`,
+    }
+  }
+  try {
+    process.kill(pid, 'SIGTERM')
+  } catch (err) {
+    clearPidFile()
+    return { stopped: false, reason: `não consegui matar pid ${pid}: ${err.message}` }
+  }
+  clearPidFile()
+  return { stopped: true, pid }
+}