token-trace-manager 0.7.0

package/lib/mcp-server.mjs

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+// Servidor MCP (stdio) do token-trace-manager — sem dependências externas.
+// Transporte: JSON-RPC 2.0, uma mensagem JSON por linha (spec MCP stdio).
+// Funciona em qualquer cliente MCP: Claude Code (plugin.json mcpServers),
+// OpenCode (opencode.json "mcp"), etc. Garante o daemon do proxy de pé.
+
+import { execFileSync } from 'node:child_process'
+import path from 'node:path'
+import readline from 'node:readline'
+import { readConfig } from './config.mjs'
+import { ensureDaemon, daemonHealth, fetchDaemon } from './daemon-client.mjs'
+
+// O servidor MCP roda DENTRO do ambiente do TUI (cwd = projeto do usuário) —
+// é daqui que repo/branch são detectados e viram tags nos traces.
+function detectContext() {
+  const git = args => {
+    try {
+      return execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()
+    } catch {
+      return null
+    }
+  }
+  const top = git(['rev-parse', '--show-toplevel'])
+  return {
+    repo: top ? path.basename(top) : null,
+    branch: git(['branch', '--show-current']) || null,
+  }
+}
+
+const TICKET_RE = /[A-Z][A-Z0-9]+-\d+/i
+
+const SERVER_INFO = { name: 'token-trace-manager', version: '0.6.0' }
+// Negociação (spec): se a versão pedida está na lista, ecoa; senão responde
+// com a nossa mais recente (não é erro — o client decide se desconecta).
+const SUPPORTED_PROTOCOL_VERSIONS = ['2025-11-25', '2025-06-18', '2024-11-05']
+
+const TOOLS = [
+  {
+    name: 'ttm_status',
+    description:
+      'Estado do proxy de rastreio de tokens: daemon rodando ou não, porta, label padrão atual e URL do dashboard.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'ttm_activate',
+    description:
+      'Ativa o rastreio de tokens numa tarefa A PARTIR DE AGORA (pode trocar a qualquer momento da sessão). Sem label, detecta o ticket pelo nome da branch git do ambiente atual. Também detecta repo/branch e os carimba como tags em cada trace. Com retroactive_minutes, mensagens recentes SEM tarefa — de QUALQUER TUI/cliente que use o proxy — entram na tarefa nova (caso o card tenha sido criado depois do trabalho começar).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        label: {
+          type: ['string', 'null'],
+          description: 'Ticket (ex: PROJ-123). Omitido/null = detectar da branch git.',
+        },
+        retroactive_minutes: {
+          type: 'number',
+          description: 'Atribui também as mensagens sem tarefa dos últimos N minutos (máx 1440).',
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'ttm_set_label',
+    description:
+      'Define/troca o label padrão (ticket Jira, ex: PROJ-123) do tráfego do proxy — vale para o que vier DEPOIS da troca. Passe null para limpar. Prefira ttm_activate, que também detecta repo/branch.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        label: {
+          type: ['string', 'null'],
+          description: 'Chave do ticket (ex: PROJ-123) ou null para limpar',
+        },
+      },
+      required: ['label'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'ttm_usage_summary',
+    description:
+      'Resumo de uso de tokens e custo registrado pelo proxy: total e quebras por label/ticket, provedor, modelo, cliente e dia.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        since: {
+          type: 'string',
+          description: "Janela: '7d', '24h', '30d' (padrão) ou 'all'",
+        },
+        label: { type: 'string', description: 'Filtrar por um label/ticket específico' },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'ttm_dashboard_url',
+    description: 'Garante que o daemon está de pé e retorna a URL do dashboard local ao vivo.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+]
+
+async function callTool(name, args) {
+  const cfg = readConfig()
+  switch (name) {
+    case 'ttm_status': {
+      const h = await daemonHealth()
+      const label = h ? (await fetchDaemon('/api/label')).defaultLabel : null
+      return {
+        daemon: h ? 'rodando' : 'parado',
+        proxyUrl: `http://127.0.0.1:${cfg.port}`,
+        pid: h?.pid ?? null,
+        uptime_s: h?.uptime_s ?? null,
+        defaultLabel: label,
+        dashboard: `http://127.0.0.1:${cfg.port}/dashboard`,
+        targets: Object.fromEntries(Object.entries(cfg.targets).map(([k, t]) => [k, t.targetUrl])),
+      }
+    }
+    case 'ttm_activate': {
+      await ensureDaemon()
+      const context = detectContext()
+      let label = args.label ?? null
+      let labelSource = label ? 'informado' : null
+      if (!label && context.branch) {
+        const m = TICKET_RE.exec(context.branch)
+        if (m) {
+          label = m[0].toUpperCase()
+          labelSource = `detectado da branch "${context.branch}"`
+        }
+      }
+      if (!label) {
+        return {
+          ativado: false,
+          motivo: `nenhum label informado e a branch atual (${context.branch ?? 'sem git'}) não contém um ticket tipo PROJ-123 — pergunte ao usuário qual tarefa usar e chame de novo com label`,
+          context,
+        }
+      }
+      const r = await fetchDaemon('/api/label', {
+        method: 'POST',
+        body: {
+          label,
+          context,
+          retroactiveMinutes: args.retroactive_minutes ?? 0,
+        },
+      })
+      return {
+        ativado: true,
+        tarefa: r.defaultLabel,
+        origem: labelSource,
+        tags: r.context,
+        mensagensRetroativas: r.relabeled,
+        nota: 'todo tráfego novo do proxy (sem label na URL) cai nesta tarefa até trocar — use ttm_activate de novo para mudar',
+      }
+    }
+    case 'ttm_set_label': {
+      await ensureDaemon()
+      const r = await fetchDaemon('/api/label', { method: 'POST', body: { label: args.label ?? null } })
+      return { defaultLabel: r.defaultLabel }
+    }
+    case 'ttm_usage_summary': {
+      await ensureDaemon()
+      const params = new URLSearchParams()
+      if (args.since) params.set('since', args.since)
+      if (args.label) params.set('label', args.label)
+      return await fetchDaemon(`/api/summary?${params}`)
+    }
+    case 'ttm_dashboard_url': {
+      await ensureDaemon()
+      return { url: `http://127.0.0.1:${cfg.port}/dashboard` }
+    }
+    default:
+      throw new Error(`tool desconhecida: ${name}`)
+  }
+}
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
+}
+
+function reply(id, result) {
+  send({ jsonrpc: '2.0', id, result })
+}
+
+function replyError(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } })
+}
+
+async function handle(msg) {
+  const { id, method, params } = msg
+
+  // Notifications (sem id) — só reconhecemos, nada a responder.
+  // (id: 0 é válido em JSON-RPC e passa por aqui corretamente.)
+  if (id === undefined || id === null) return
+
+  if (typeof method !== 'string' || !method) {
+    return replyError(id, -32600, 'Invalid Request: método ausente')
+  }
+
+  switch (method) {
+    case 'initialize': {
+      const requested = params?.protocolVersion
+      const version = SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+        ? requested
+        : SUPPORTED_PROTOCOL_VERSIONS[0]
+      reply(id, {
+        protocolVersion: version,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO,
+      })
+      // Sobe o daemon em background — sem bloquear o handshake
+      ensureDaemon().catch(() => {})
+      return
+    }
+    case 'ping':
+      return reply(id, {})
+    case 'tools/list':
+      return reply(id, { tools: TOOLS })
+    case 'tools/call': {
+      if (typeof params?.name !== 'string' || !params.name) {
+        return replyError(id, -32602, 'Invalid params: "name" é obrigatório em tools/call')
+      }
+      try {
+        const result = await callTool(params.name, params.arguments ?? {})
+        return reply(id, {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        })
+      } catch (err) {
+        return reply(id, {
+          content: [{ type: 'text', text: `erro: ${err.message}` }],
+          isError: true,
+        })
+      }
+    }
+    case 'resources/list':
+      return reply(id, { resources: [] })
+    case 'prompts/list':
+      return reply(id, { prompts: [] })
+    default:
+      return replyError(id, -32601, `método não suportado: ${method}`)
+  }
+}
+
+// stdin fechar NÃO pode matar handlers assíncronos em voo (ex: ttm_activate
+// esperando o daemon subir) — sai só quando o último terminar.
+let pending = 0
+let stdinClosed = false
+function maybeExit() {
+  if (stdinClosed && pending === 0) process.exit(0)
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity })
+rl.on('line', line => {
+  if (!line.trim()) return
+  let msg
+  try {
+    msg = JSON.parse(line)
+  } catch {
+    return // linha inválida — ignora, nunca derruba o servidor
+  }
+  // "null", números e strings são JSON válidos mas não são mensagens JSON-RPC —
+  // desestruturar null derrubaria o processo (unhandled rejection)
+  if (typeof msg !== 'object' || msg === null || Array.isArray(msg)) return
+  pending++
+  handle(msg)
+    .catch(err => {
+      if (msg.id !== undefined && msg.id !== null) replyError(msg.id, -32603, err.message)
+    })
+    .finally(() => {
+      pending--
+      maybeExit()
+    })
+})
+rl.on('close', () => {
+  stdinClosed = true
+  maybeExit()
+})

package/lib/otel-export.mjs

@@ -0,0 +1,122 @@
+// Exportador OTLP/HTTP (JSON) opcional — desligado por padrão.
+//
+// Um span por chamada LLM, com atributos GenAI semconv + os detalhes que o
+// Langfuse ingere (usage_details/cost_details). Funciona com o endpoint OTel
+// do Langfuse (cloud ou self-hosted) e com qualquer collector OTel genérico.
+//
+// Config (config.json no diretório de dados):
+//   "otel": {
+//     "endpoint": "https://cloud.langfuse.com/api/public/otel",   // sem /v1/traces
+//     "headers": { "Authorization": "Basic <base64(pk-lf-...:sk-lf-...)>" }
+//   }
+//
+// Sem "otel" na config => nenhum byte sai da máquina (padrão local-first).
+
+import crypto from 'node:crypto'
+import { readConfig } from './config.mjs'
+
+const BATCH_MAX = 20
+const FLUSH_MS = 5000
+
+let queue = []
+let timer = null
+
+function attr(key, value) {
+  if (value === null || value === undefined) return null
+  if (typeof value === 'number' && Number.isInteger(value)) return { key, value: { intValue: String(value) } }
+  if (typeof value === 'number') return { key, value: { doubleValue: value } }
+  return { key, value: { stringValue: String(value) } }
+}
+
+function eventToSpan(ev) {
+  const endMs = ev.ts ? Date.parse(ev.ts) : NaN
+  const end = Number.isNaN(endMs) ? 0 : endMs
+  const start = end - (ev.durationMs ?? 0)
+  const usageDetails = {
+    input: ev.inputTokens,
+    output: ev.outputTokens,
+    cache_read_input_tokens: ev.cacheReadTokens,
+    cache_creation_input_tokens: ev.cacheCreateTokens,
+    total: ev.inputTokens + ev.cacheCreateTokens + ev.cacheReadTokens + ev.outputTokens,
+  }
+  return {
+    traceId: crypto.randomBytes(16).toString('hex'),
+    spanId: crypto.randomBytes(8).toString('hex'),
+    name: ev.label ? `llm ${ev.label}` : 'llm',
+    kind: 3, // CLIENT
+    startTimeUnixNano: String(start) + '000000',
+    endTimeUnixNano: String(end) + '000000',
+    attributes: [
+      attr('gen_ai.system', ev.target),
+      attr('gen_ai.response.model', ev.model),
+      attr('gen_ai.response.id', ev.providerId),
+      attr('gen_ai.usage.input_tokens', ev.inputTokens + ev.cacheCreateTokens + ev.cacheReadTokens),
+      attr('gen_ai.usage.output_tokens', ev.outputTokens),
+      attr('langfuse.observation.type', 'generation'),
+      attr('langfuse.observation.usage_details', JSON.stringify(usageDetails)),
+      ev.costUsd !== null && ev.costUsd !== undefined
+        ? attr('langfuse.observation.cost_details', JSON.stringify({ total: ev.costUsd }))
+        : null,
+      attr('langfuse.trace.name', ev.label ?? 'sem-label'),
+      attr('langfuse.session.id', ev.label ?? undefined),
+      attr('ttm.client', ev.client),
+      attr('ttm.label', ev.label ?? undefined),
+    ].filter(Boolean),
+    status: { code: ev.status && ev.status >= 400 ? 2 : 1 },
+  }
+}
+
+async function flush() {
+  // relê a config NA HORA do flush: trocar/desligar o endpoint vale também
+  // para spans já enfileirados (desligou => fila descartada, nada sai)
+  const otelCfg = readConfig().otel
+  const spans = queue
+  queue = []
+  if (!spans.length || !otelCfg?.endpoint) return
+  const body = JSON.stringify({
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [attr('service.name', 'token-trace-manager'), attr('service.version', otelCfg.serviceVersion ?? '0.4.0')],
+        },
+        scopeSpans: [{ scope: { name: 'ttm-proxy' }, spans }],
+      },
+    ],
+  })
+  try {
+    const res = await fetch(otelCfg.endpoint.replace(/\/$/, '') + '/v1/traces', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...(otelCfg.headers || {}) },
+      body,
+      signal: AbortSignal.timeout(10_000),
+    })
+    if (!res.ok) {
+      process.stderr.write(`ttm: export OTel falhou (HTTP ${res.status}) — eventos locais intactos\n`)
+    }
+  } catch (err) {
+    process.stderr.write(`ttm: export OTel falhou (${err.message}) — eventos locais intactos\n`)
+  }
+}
+
+// Fire-and-forget: exportar NUNCA pode atrasar nem derrubar o proxy.
+export function exportUsageEvent(ev, otelCfg) {
+  if (!otelCfg?.endpoint) return
+  try {
+    queue.push(eventToSpan(ev))
+  } catch {
+    return
+  }
+  if (queue.length >= BATCH_MAX) {
+    if (timer) clearTimeout(timer)
+    timer = null
+    void flush()
+    return
+  }
+  if (!timer) {
+    timer = setTimeout(() => {
+      timer = null
+      void flush()
+    }, otelCfg.flushMs ?? FLUSH_MS)
+    timer.unref?.()
+  }
+}

package/lib/pricing.mjs

@@ -0,0 +1,137 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { dataDir } from './db.mjs'
+
+// USD por 1M de tokens. Anthropic confirmado via skill claude-api (2026-06-24).
+// OpenAI/Gemini preenchidos pela varredura de pesquisa — marcar a data ao atualizar.
+// Modelos desconhecidos => custo null (tokens continuam registrados).
+export const PRICING_LAST_UPDATED = '2026-07-06'
+
+// { input, output, cacheRead?, cacheWrite? } — cacheRead default = 0.1x input
+// e cacheWrite default = 1.25x input (regra Anthropic); OpenAI/Gemini têm
+// cacheRead explícito e cacheWrite 0 (não cobram escrita de cache à parte).
+// Fontes: platform.claude.com/docs pricing, developers.openai.com/api/docs/pricing,
+// help.openai.com codex rate card, ai.google.dev/gemini-api/docs/pricing.
+const BASE_TABLE = {
+  // Anthropic
+  'claude-fable-5': { input: 10.0, output: 50.0 },
+  'claude-mythos-5': { input: 10.0, output: 50.0 },
+  'claude-opus-4-8': { input: 5.0, output: 25.0 },
+  'claude-opus-4-7': { input: 5.0, output: 25.0 },
+  'claude-opus-4-6': { input: 5.0, output: 25.0 },
+  'claude-opus-4-5': { input: 5.0, output: 25.0 },
+  // Sonnet 5: preço introdutório ($2/$10) vigente até 2026-08-31; a partir
+  // de 2026-09-01 vira $3/$15 — atualizar aqui ou via pricing.override.json.
+  'claude-sonnet-5': { input: 2.0, output: 10.0 },
+  'claude-sonnet-4-6': { input: 3.0, output: 15.0 },
+  'claude-sonnet-4-5': { input: 3.0, output: 15.0 },
+  'claude-haiku-4-5': { input: 1.0, output: 5.0 },
+
+  // OpenAI (sem cobrança de cache write; cacheRead explícito)
+  'gpt-5.5': { input: 5.0, output: 30.0, cacheRead: 0.5, cacheWrite: 0 },
+  'gpt-5.5-pro': { input: 30.0, output: 180.0, cacheRead: 30.0, cacheWrite: 0 },
+  'gpt-5.5-codex': { input: 5.0, output: 30.0, cacheRead: 0.5, cacheWrite: 0 },
+  'gpt-5.4': { input: 2.5, output: 15.0, cacheRead: 0.25, cacheWrite: 0 },
+  'gpt-5.4-mini': { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
+  'gpt-5.4-nano': { input: 0.2, output: 1.25, cacheRead: 0.02, cacheWrite: 0 },
+  'gpt-5.4-pro': { input: 30.0, output: 180.0, cacheRead: 30.0, cacheWrite: 0 },
+  'gpt-5.4-codex': { input: 2.5, output: 15.0, cacheRead: 0.25, cacheWrite: 0 },
+  'gpt-5.3-codex': { input: 1.75, output: 14.0, cacheRead: 0.175, cacheWrite: 0 },
+  'gpt-5.2-codex': { input: 1.75, output: 14.0, cacheRead: 0.175, cacheWrite: 0 },
+  'o3-deep-research': { input: 5.0, output: 20.0, cacheRead: 5.0, cacheWrite: 0 },
+  'o4-mini-deep-research': { input: 1.0, output: 4.0, cacheRead: 1.0, cacheWrite: 0 },
+
+  // Google Gemini (preço da faixa <=200K de contexto quando em camadas)
+  'gemini-3.5-flash': { input: 1.5, output: 9.0, cacheRead: 0.15, cacheWrite: 0 },
+  'gemini-3.1-pro-preview': { input: 2.0, output: 12.0, cacheRead: 0.2, cacheWrite: 0 },
+  'gemini-3.1-flash-lite': { input: 0.25, output: 1.5, cacheRead: 0.025, cacheWrite: 0 },
+  'gemini-3-flash-preview': { input: 0.5, output: 3.0, cacheRead: 0.05, cacheWrite: 0 },
+  'gemini-2.5-pro': { input: 1.25, output: 10.0, cacheRead: 0.125, cacheWrite: 0 },
+  'gemini-2.5-flash': { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 },
+  'gemini-2.5-flash-lite': { input: 0.1, output: 0.4, cacheRead: 0.01, cacheWrite: 0 },
+}
+
+function baseAlias(model) {
+  // Alguns modelos aparecem com sufixo de snapshot datado (ex:
+  // claude-haiku-4-5-20251001, gpt-5.2-2026-01-15); normaliza pro alias.
+  return model.replace(/[-@]\d{4}-?\d{2}-?\d{2}$/, '').replace(/-\d{8}$/, '')
+}
+
+let overrideTable = null
+
+function overridePath() {
+  return path.join(dataDir(), 'pricing.override.json')
+}
+
+function loadOverrides() {
+  if (overrideTable) return overrideTable
+  try {
+    overrideTable = JSON.parse(fs.readFileSync(overridePath(), 'utf8'))
+  } catch {
+    overrideTable = {}
+  }
+  return overrideTable
+}
+
+function rateFor(model) {
+  if (!model) return null
+  const overrides = loadOverrides()
+  const entry =
+    overrides[model] ??
+    BASE_TABLE[model] ??
+    overrides[baseAlias(model)] ??
+    BASE_TABLE[baseAlias(model)] ??
+    null
+  if (!entry) return null
+  return {
+    input: entry.input,
+    output: entry.output,
+    cacheRead: entry.cacheRead ?? entry.input * 0.1,
+    cacheWrite: entry.cacheWrite ?? entry.input * 1.25, // Anthropic: TTL 5m = 1.25x
+    cacheWrite1h: entry.cacheWrite1h ?? (entry.cacheWrite === 0 ? 0 : entry.input * 2), // TTL 1h = 2x
+  }
+}
+
+export function knownModel(model) {
+  return rateFor(model) !== null
+}
+
+// O "recibo" auditável do cálculo: custo total + as taxas aplicadas ($/1M) +
+// cada parcela. Guardado por evento (coluna rates) para o custo ser sempre
+// re-verificável mesmo se a tabela de preços mudar depois.
+// usage normalizado (ver adapters.mjs): input já exclui cache; output já
+// inclui reasoning; cacheCreate1h é subconjunto de cacheCreate.
+export function costBreakdown(model, u) {
+  const r = rateFor(model)
+  if (!r) return { cost: null, rates: null }
+  const create1h = Math.min(u.cacheCreate1hTokens || 0, u.cacheCreateTokens || 0)
+  const create5m = (u.cacheCreateTokens || 0) - create1h
+  const cost =
+    (u.inputTokens / 1e6) * r.input +
+    (u.cacheReadTokens / 1e6) * r.cacheRead +
+    (create5m / 1e6) * r.cacheWrite +
+    (create1h / 1e6) * r.cacheWrite1h +
+    (u.outputTokens / 1e6) * r.output
+  return {
+    cost,
+    rates: {
+      input: r.input,
+      output: r.output,
+      cacheRead: r.cacheRead,
+      cacheWrite5m: r.cacheWrite,
+      cacheWrite1h: r.cacheWrite1h,
+      pricingDate: PRICING_LAST_UPDATED,
+    },
+  }
+}
+
+export function costForUsage(model, u) {
+  return costBreakdown(model, u).cost
+}
+
+export function registerPricing(entries) {
+  const current = loadOverrides()
+  const next = { ...current, ...entries }
+  fs.writeFileSync(overridePath(), JSON.stringify(next, null, 2))
+  overrideTable = next
+}