token-trace-manager 0.7.0

package/lib/db.mjs

@@ -0,0 +1,444 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+export function payloadsDir() {
+  const dir = path.join(dataDir(), 'payloads')
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+export function payloadPath(id) {
+  return path.join(payloadsDir(), `${id}.json`)
+}
+
+function unlinkPayloads(ids) {
+  for (const id of ids) {
+    try {
+      fs.unlinkSync(payloadPath(id))
+    } catch {
+      /* sem payload */
+    }
+  }
+}
+
+export function dataDir() {
+  const dir =
+    process.env.TTM_DATA_DIR ||
+    path.join(os.homedir(), '.claude', 'plugins', 'data', 'token-trace-manager')
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS usage_events (
+  id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts                  TEXT NOT NULL,
+  label               TEXT,
+  target              TEXT NOT NULL,
+  protocol            TEXT NOT NULL,
+  model               TEXT,
+  input_tokens        INTEGER DEFAULT 0,
+  cache_create_tokens INTEGER DEFAULT 0,
+  cache_create_1h_tokens INTEGER DEFAULT 0,
+  cache_read_tokens   INTEGER DEFAULT 0,
+  output_tokens       INTEGER DEFAULT 0,
+  reasoning_tokens    INTEGER DEFAULT 0,
+  cost_usd            REAL,
+  rates               TEXT,
+  provider_id         TEXT,
+  repo                TEXT,
+  branch              TEXT,
+  status              INTEGER,
+  duration_ms         INTEGER,
+  client              TEXT,
+  payload             INTEGER DEFAULT 0,
+  usage_fields        TEXT,
+  usage_unknown       INTEGER DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_usage_events_ts ON usage_events(ts);
+CREATE INDEX IF NOT EXISTS idx_usage_events_label ON usage_events(label);
+
+CREATE TABLE IF NOT EXISTS kv (
+  key   TEXT PRIMARY KEY,
+  value TEXT
+);
+
+-- Histórico permanente por tarefa: quando um trace expira (retenção), ele é
+-- somado aqui ANTES de ser apagado — o detalhe morre, a soma sobrevive.
+CREATE TABLE IF NOT EXISTS daily_rollups (
+  day                 TEXT NOT NULL,
+  label               TEXT NOT NULL DEFAULT '',
+  target              TEXT NOT NULL,
+  model               TEXT NOT NULL DEFAULT '',
+  client              TEXT NOT NULL DEFAULT '',
+  input_tokens        INTEGER DEFAULT 0,
+  cache_create_tokens INTEGER DEFAULT 0,
+  cache_create_1h_tokens INTEGER DEFAULT 0,
+  cache_read_tokens   INTEGER DEFAULT 0,
+  output_tokens       INTEGER DEFAULT 0,
+  reasoning_tokens    INTEGER DEFAULT 0,
+  cost_usd            REAL DEFAULT 0,
+  cost_known          INTEGER DEFAULT 1,
+  events              INTEGER DEFAULT 0,
+  PRIMARY KEY (day, label, target, model, client)
+);
+`
+
+// Migração aditiva: bases criadas por versões antigas ganham as colunas novas.
+// (CREATE TABLE IF NOT EXISTS não altera tabela existente.) O índice de
+// provider_id vive AQUI, nunca no SCHEMA: num banco antigo ele só pode ser
+// criado depois do ALTER TABLE adicionar a coluna.
+const MIGRATION_COLUMNS = [
+  ['cache_create_1h_tokens', 'INTEGER DEFAULT 0'],
+  ['rates', 'TEXT'],
+  ['provider_id', 'TEXT'],
+  ['repo', 'TEXT'],
+  ['branch', 'TEXT'],
+  ['payload', 'INTEGER DEFAULT 0'],
+  ['usage_fields', 'TEXT'],
+  ['usage_unknown', 'INTEGER DEFAULT 0'],
+]
+
+function migrate(db) {
+  const existing = new Set(db.prepare('PRAGMA table_info(usage_events)').all().map(c => c.name))
+  for (const [col, type] of MIGRATION_COLUMNS) {
+    if (!existing.has(col)) db.exec(`ALTER TABLE usage_events ADD COLUMN ${col} ${type}`)
+  }
+  db.exec('CREATE INDEX IF NOT EXISTS idx_usage_events_provider_id ON usage_events(provider_id)')
+}
+
+let backend = null // { kind: 'sqlite', db } | { kind: 'json', file }
+
+async function getBackend() {
+  if (backend) return backend
+  try {
+    const { DatabaseSync } = await import('node:sqlite')
+    const db = new DatabaseSync(path.join(dataDir(), 'ttm.sqlite'))
+    db.exec(SCHEMA)
+    migrate(db)
+    backend = { kind: 'sqlite', db }
+  } catch (err) {
+    // Fallback JSON existe para Node < 22.5 (sem node:sqlite). Qualquer outro
+    // erro (schema/migração) precisa aparecer — nunca trocar de backend mudo.
+    if (err?.code !== 'ERR_UNKNOWN_BUILTIN_MODULE' && !/node:sqlite/.test(err?.message || '')) {
+      process.stderr.write(`ttm: sqlite indisponível (${err.message}) — usando fallback JSON\n`)
+    }
+    const file = path.join(dataDir(), 'ttm-events.json')
+    if (!fs.existsSync(file)) {
+      fs.writeFileSync(file, JSON.stringify({ nextId: 1, events: [], kv: {} }, null, 2))
+    }
+    backend = { kind: 'json', file }
+  }
+  return backend
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch {
+    return { nextId: 1, events: [], kv: {} }
+  }
+}
+
+function writeJson(file, data) {
+  fs.writeFileSync(file, JSON.stringify(data))
+}
+
+export async function insertUsageEvent(ev) {
+  const b = await getBackend()
+  const row = {
+    ts: ev.ts ?? new Date().toISOString(),
+    label: ev.label ?? null,
+    target: ev.target,
+    protocol: ev.protocol,
+    model: ev.model ?? null,
+    input_tokens: ev.inputTokens | 0,
+    cache_create_tokens: ev.cacheCreateTokens | 0,
+    cache_create_1h_tokens: ev.cacheCreate1hTokens | 0,
+    cache_read_tokens: ev.cacheReadTokens | 0,
+    output_tokens: ev.outputTokens | 0,
+    reasoning_tokens: ev.reasoningTokens | 0,
+    cost_usd: ev.costUsd ?? null,
+    rates: ev.rates ? JSON.stringify(ev.rates) : null,
+    provider_id: ev.providerId ?? null,
+    repo: ev.repo ?? null,
+    branch: ev.branch ?? null,
+    status: ev.status ?? null,
+    duration_ms: ev.durationMs ?? null,
+    client: ev.client ?? null,
+    payload: ev.payload ? 1 : 0,
+    usage_fields: ev.usageFields && ev.usageFields.length ? JSON.stringify(ev.usageFields) : null,
+    usage_unknown: ev.usageUnknown ? 1 : 0,
+  }
+  if (b.kind === 'sqlite') {
+    const r = b.db
+      .prepare(
+        `INSERT INTO usage_events (ts, label, target, protocol, model, input_tokens, cache_create_tokens,
+           cache_create_1h_tokens, cache_read_tokens, output_tokens, reasoning_tokens, cost_usd, rates,
+           provider_id, repo, branch, status, duration_ms, client, payload, usage_fields, usage_unknown)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        row.ts,
+        row.label,
+        row.target,
+        row.protocol,
+        row.model,
+        row.input_tokens,
+        row.cache_create_tokens,
+        row.cache_create_1h_tokens,
+        row.cache_read_tokens,
+        row.output_tokens,
+        row.reasoning_tokens,
+        row.cost_usd,
+        row.rates,
+        row.provider_id,
+        row.repo,
+        row.branch,
+        row.status,
+        row.duration_ms,
+        row.client,
+        row.payload,
+        row.usage_fields,
+        row.usage_unknown,
+      )
+    return Number(r.lastInsertRowid)
+  }
+  const data = readJson(b.file)
+  const id = data.nextId++
+  data.events.push({ id, ...row })
+  writeJson(b.file, data)
+  return id
+}
+
+export async function listUsageEvents({ since, label, target, limit } = {}) {
+  const b = await getBackend()
+  let rows
+  if (b.kind === 'sqlite') {
+    const where = []
+    const params = []
+    if (since) {
+      where.push('ts >= ?')
+      params.push(since)
+    }
+    if (label) {
+      where.push('label = ?')
+      params.push(label)
+    }
+    if (target) {
+      where.push('target = ?')
+      params.push(target)
+    }
+    const sql =
+      'SELECT * FROM usage_events' +
+      (where.length ? ' WHERE ' + where.join(' AND ') : '') +
+      ' ORDER BY ts DESC' +
+      (limit ? ` LIMIT ${limit | 0}` : '')
+    rows = b.db.prepare(sql).all(...params)
+  } else {
+    rows = readJson(b.file).events.slice().reverse()
+    if (since) rows = rows.filter(r => r.ts >= since)
+    if (label) rows = rows.filter(r => r.label === label)
+    if (target) rows = rows.filter(r => r.target === target)
+    if (limit) rows = rows.slice(0, limit)
+  }
+  return rows
+}
+
+const clientShort = c => (c || '').split('/')[0].split(' ')[0]
+
+// Expira traces mais antigos que cutoffIso: agrega em daily_rollups e apaga.
+export async function purgeExpired(cutoffIso) {
+  const b = await getBackend()
+  const groups = new Map()
+  const keyOf = r =>
+    `${(r.ts || '').slice(0, 10)}|${r.label ?? ''}|${r.target}|${r.model ?? ''}|${clientShort(r.client)}`
+  const addTo = r => {
+    const k = keyOf(r)
+    let g = groups.get(k)
+    if (!g) {
+      g = {
+        day: (r.ts || '').slice(0, 10),
+        label: r.label ?? '',
+        target: r.target,
+        model: r.model ?? '',
+        client: clientShort(r.client),
+        input_tokens: 0,
+        cache_create_tokens: 0,
+        cache_create_1h_tokens: 0,
+        cache_read_tokens: 0,
+        output_tokens: 0,
+        reasoning_tokens: 0,
+        cost_usd: 0,
+        cost_known: 1,
+        events: 0,
+      }
+      groups.set(k, g)
+    }
+    g.input_tokens += r.input_tokens || 0
+    g.cache_create_tokens += r.cache_create_tokens || 0
+    g.cache_create_1h_tokens += r.cache_create_1h_tokens || 0
+    g.cache_read_tokens += r.cache_read_tokens || 0
+    g.output_tokens += r.output_tokens || 0
+    g.reasoning_tokens += r.reasoning_tokens || 0
+    g.cost_usd += r.cost_usd || 0
+    if (r.cost_usd === null || r.cost_usd === undefined) g.cost_known = 0
+    g.events += 1
+  }
+
+  if (b.kind === 'sqlite') {
+    const expiring = b.db.prepare('SELECT * FROM usage_events WHERE ts < ?').all(cutoffIso)
+    if (!expiring.length) return { purged: 0 }
+    for (const r of expiring) addTo(r)
+    unlinkPayloads(expiring.map(r => r.id))
+    // TRANSAÇÃO: agregar + apagar precisam ser tudo-ou-nada — um crash entre
+    // os dois deixaria os eventos contados DUAS vezes no próximo purge.
+    b.db.exec('BEGIN IMMEDIATE')
+    const upsert = b.db.prepare(
+      `INSERT INTO daily_rollups (day, label, target, model, client, input_tokens, cache_create_tokens,
+         cache_create_1h_tokens, cache_read_tokens, output_tokens, reasoning_tokens, cost_usd, cost_known, events)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(day, label, target, model, client) DO UPDATE SET
+         input_tokens = input_tokens + excluded.input_tokens,
+         cache_create_tokens = cache_create_tokens + excluded.cache_create_tokens,
+         cache_create_1h_tokens = cache_create_1h_tokens + excluded.cache_create_1h_tokens,
+         cache_read_tokens = cache_read_tokens + excluded.cache_read_tokens,
+         output_tokens = output_tokens + excluded.output_tokens,
+         reasoning_tokens = reasoning_tokens + excluded.reasoning_tokens,
+         cost_usd = cost_usd + excluded.cost_usd,
+         cost_known = MIN(cost_known, excluded.cost_known),
+         events = events + excluded.events`,
+    )
+    try {
+      for (const g of groups.values()) {
+        upsert.run(
+          g.day, g.label, g.target, g.model, g.client,
+          g.input_tokens, g.cache_create_tokens, g.cache_create_1h_tokens, g.cache_read_tokens,
+          g.output_tokens, g.reasoning_tokens, g.cost_usd, g.cost_known, g.events,
+        )
+      }
+      b.db.prepare('DELETE FROM usage_events WHERE ts < ?').run(cutoffIso)
+      b.db.exec('COMMIT')
+    } catch (err) {
+      try {
+        b.db.exec('ROLLBACK')
+      } catch {
+        /* rollback já implícito */
+      }
+      throw err
+    }
+    return { purged: expiring.length }
+  }
+
+  const data = readJson(b.file)
+  const expiring = data.events.filter(e => e.ts < cutoffIso)
+  if (!expiring.length) return { purged: 0 }
+  for (const r of expiring) addTo(r)
+  unlinkPayloads(expiring.map(r => r.id))
+  data.rollups = data.rollups || {}
+  for (const [k, g] of groups) {
+    const prev = data.rollups[k]
+    if (!prev) data.rollups[k] = g
+    else {
+      for (const f of ['input_tokens','cache_create_tokens','cache_create_1h_tokens','cache_read_tokens','output_tokens','reasoning_tokens','cost_usd','events']) prev[f] += g[f]
+      prev.cost_known = Math.min(prev.cost_known, g.cost_known)
+    }
+  }
+  data.events = data.events.filter(e => e.ts >= cutoffIso)
+  writeJson(b.file, data)
+  return { purged: expiring.length }
+}
+
+export async function listRollups({ sinceDay, label } = {}) {
+  const b = await getBackend()
+  let rows
+  if (b.kind === 'sqlite') {
+    rows = b.db.prepare('SELECT * FROM daily_rollups').all()
+  } else {
+    rows = Object.values(readJson(b.file).rollups || {})
+  }
+  if (sinceDay) rows = rows.filter(r => r.day >= sinceDay)
+  if (label) rows = rows.filter(r => (r.label || '') === label) // '' interno = sem label; filtro '' não chega aqui (guard truthy)
+  return rows
+}
+
+// "Poder de deletar": traces, ou tudo (traces + histórico agregado).
+export async function deleteData({ mode = 'events', label = null } = {}) {
+  const b = await getBackend()
+  if (b.kind === 'sqlite') {
+    let deleted = 0
+    if (label) {
+      unlinkPayloads(b.db.prepare('SELECT id FROM usage_events WHERE label = ?').all(label).map(r => r.id))
+      deleted = b.db.prepare('DELETE FROM usage_events WHERE label = ?').run(label).changes
+      if (mode === 'everything') {
+        deleted += b.db.prepare('DELETE FROM daily_rollups WHERE label = ?').run(label).changes
+      }
+    } else {
+      unlinkPayloads(b.db.prepare('SELECT id FROM usage_events').all().map(r => r.id))
+      deleted = b.db.prepare('DELETE FROM usage_events').run().changes
+      if (mode === 'everything') deleted += b.db.prepare('DELETE FROM daily_rollups').run().changes
+    }
+    return { deleted }
+  }
+  const data = readJson(b.file)
+  const before = data.events.length + Object.keys(data.rollups || {}).length
+  unlinkPayloads((label ? data.events.filter(e => e.label === label) : data.events).map(e => e.id))
+  data.events = label ? data.events.filter(e => e.label !== label) : []
+  if (mode === 'everything') {
+    if (label) {
+      for (const k of Object.keys(data.rollups || {})) if ((data.rollups[k].label || '') === label) delete data.rollups[k]
+    } else data.rollups = {}
+  }
+  writeJson(b.file, data)
+  return { deleted: before - (data.events.length + Object.keys(data.rollups || {}).length) }
+}
+
+// Relabel retroativo: o usuário começou a trabalhar antes de criar o card e
+// ativou o ttm depois — as mensagens SEM label da janela recebem a tarefa.
+export async function relabelUnlabeled({ label, sinceIso }) {
+  const b = await getBackend()
+  if (b.kind === 'sqlite') {
+    const r = b.db
+      .prepare('UPDATE usage_events SET label = ? WHERE label IS NULL AND ts >= ?')
+      .run(label, sinceIso)
+    return { relabeled: r.changes }
+  }
+  const data = readJson(b.file)
+  let n = 0
+  for (const e of data.events) {
+    if (e.label === null && e.ts >= sinceIso) {
+      e.label = label
+      n++
+    }
+  }
+  writeJson(b.file, data)
+  return { relabeled: n }
+}
+
+export async function getKv(key) {
+  const b = await getBackend()
+  if (b.kind === 'sqlite') {
+    const row = b.db.prepare('SELECT value FROM kv WHERE key = ?').get(key)
+    return row ? row.value : null
+  }
+  return readJson(b.file).kv[key] ?? null
+}
+
+export async function setKv(key, value) {
+  const b = await getBackend()
+  if (b.kind === 'sqlite') {
+    if (value === null) {
+      b.db.prepare('DELETE FROM kv WHERE key = ?').run(key)
+    } else {
+      b.db
+        .prepare('INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value')
+        .run(key, value)
+    }
+  } else {
+    const data = readJson(b.file)
+    if (value === null) delete data.kv[key]
+    else data.kv[key] = value
+    writeJson(b.file, data)
+  }
+}

package/lib/link.mjs

@@ -0,0 +1,152 @@
+// Orquestração do `ttm link <tui>` / `ttm unlink <tui>`.
+//
+// Fluxo do link:
+//   1. descobre a base URL efetiva do TUI (env var ou arquivo de config)
+//   2. registra um target no ttm apontando pra esse upstream (preserva o
+//      original em links.<tui> p/ unlink + detecção de loop)
+//   3. reescreve a config do TUI pra apontar pro ttm
+//   4. (garante daemon rodando; seta label default se --label)
+//
+// Idempotente: se o TUI já aponta pro ttm, não re-descobre (evita loop).
+// Re-link pós troca de upstream exige --force (detecção via links.<tui>).
+
+import { readConfig, setTarget, removeTarget, setLink } from './config.mjs'
+import { discoverTui, writeTuiBaseUrl, restoreTuiBaseUrl, AUTOLINKABLE_TUIS } from './tui-config.mjs'
+import { ensureDaemon, fetchDaemon } from './daemon-client.mjs'
+
+export async function linkTui(tui, { label, repo, force, cwd } = {}) {
+  if (!AUTOLINKABLE_TUIS.includes(tui)) {
+    return { supported: false, tui }
+  }
+
+  const cfg = readConfig()
+  const existing = cfg.links?.[tui]
+  const discover = discoverTui(tui, { cwd: cwd ?? process.cwd() })
+  const proxyUrl = cfg.proxyUrl
+  const expectedProxyBase = `${proxyUrl}/${tui}`
+
+  // já linkado?
+  if (existing) {
+    const pointingAtTtm = discover.baseUrl && discover.baseUrl.startsWith(proxyUrl)
+    if (pointingAtTtm) {
+      // idempotente — só garante label/daemon
+      if (label) {
+        await ensureDaemon()
+        await fetchDaemon('/api/label', { method: 'POST', body: { label } })
+      }
+      return { alreadyLinked: true, tui, upstream: existing.upstream, proxyBaseUrl: expectedProxyBase, label }
+    }
+    // usuário mudou o upstream manualmente desde o último link
+    if (!force) {
+      return {
+        needsForce: true,
+        tui,
+        currentBaseUrl: discover.baseUrl,
+        existingUpstream: existing.upstream,
+        hint: `você já está linkado (upstream registrado: ${existing.upstream}). Se mudou o upstream, rode com --force p/ relinkar a partir de ${discover.baseUrl}`,
+      }
+    }
+    // --force: re-linka usando o baseUrl atual como novo upstream
+  }
+
+  // determina o upstream
+  let upstream = discover.baseUrl
+  // loop guard: se o baseUrl atual já aponta pro ttm (ex: link re-rodado sem
+  // ter mudado nada mas o discovery via settings retornou o proxy), usa o
+  // original guardado ou o default do TUI
+  if (!upstream || upstream.startsWith(proxyUrl)) {
+    upstream = existing?.upstream ?? discover.defaultUpstream
+  }
+  if (!upstream) {
+    return { error: `não consegui determinar o upstream para ${tui} (sem redirect prévio e sem default)` }
+  }
+
+  // registra o target no ttm
+  const spec = { targetUrl: upstream, protocol: discover.protocol }
+  if (discover.envVar && discover.source === 'env') {
+    // env-following: segue a env var em runtime (se o usuário trocar de
+    // redirect só mudando a env, o ttm acompanha)
+    spec.targetUrlEnv = discover.envVar
+    spec.targetUrl = upstream
+  }
+  setTarget(tui, spec)
+
+  // garante daemon de pé (link não funciona sem proxy ouvindo)
+  await ensureDaemon()
+
+  // seta label default se pedido
+  if (label) {
+    await fetchDaemon('/api/label', { method: 'POST', body: { label } })
+  }
+
+  // reescreve a config do TUI
+  let rewrite
+  if (discover.canWriteBack) {
+    const writeTarget = repo && discover.repoWriteTarget ? discover.repoWriteTarget : discover.writeTarget
+    writeTuiBaseUrl(tui, expectedProxyBase, { writeTarget, cwd })
+    rewrite = { done: true, writeTarget, source: discover.source }
+  } else {
+    // TUI só-env (gemini-cli, ou claude-code quando redirect via env):
+    // ttm não consegue persistir — instrui o usuário a fazer o export
+    rewrite = {
+      done: false,
+      envVar: discover.envVar,
+      exportLine: `export ${discover.envVar}=${expectedProxyBase}`,
+      note: `o ${tui} lê a base URL de uma env var que o ttm não pode alterar — rode o export acima no seu shell e reinicie o TUI`,
+    }
+  }
+
+  // guarda o estado do link p/ unlink + detecção de loop/idempotência
+  setLink(tui, {
+    originalBaseUrl: discover.baseUrl,
+    source: discover.source,
+    writeTarget: discover.writeTarget,
+    repoWriteTarget: discover.repoWriteTarget ?? null,
+    envVar: discover.envVar ?? null,
+    upstream,
+    protocol: discover.protocol,
+    targetUrlEnv: spec.targetUrlEnv ?? null,
+    linkedAt: new Date().toISOString(),
+  })
+
+  return {
+    linked: true,
+    tui,
+    upstream,
+    protocol: discover.protocol,
+    proxyBaseUrl: expectedProxyBase,
+    rewrite,
+    label,
+  }
+}
+
+export async function unlinkTui(tui, { cwd } = {}) {
+  const cfg = readConfig()
+  const info = cfg.links?.[tui]
+  if (!info) return { notLinked: true, tui }
+
+  let restore
+  if (info.source === 'env' || !info.writeTarget) {
+    // fonte só-env: só dá pra instruir o usuário
+    const target = info.originalBaseUrl
+      ? `export ${info.envVar}=${info.originalBaseUrl}`
+      : `unset ${info.envVar}`
+    restore = { done: false, envVar: info.envVar, exportLine: target, note: 'fonte só-env — rode o export/unset no seu shell' }
+  } else {
+    try {
+      restoreTuiBaseUrl(tui, {
+        original: info.originalBaseUrl,
+        source: info.source,
+        writeTarget: info.writeTarget,
+        cwd,
+      })
+      restore = { done: true, writeTarget: info.writeTarget }
+    } catch (err) {
+      restore = { done: false, error: err.message }
+    }
+  }
+
+  removeTarget(tui)
+  setLink(tui, null)
+  return { unlinked: true, tui, restore }
+}