@nectarcrm/ccx 0.1.1 → 0.2.0

package/README.md

@@ -17,6 +17,7 @@ ccx login                           # autoriza este computador (abre o navegador
 ccx                                 # mostra suas contas e troca a conta deste computador
 ccx claude-infra                    # troca direto
 ccx status                          # conta atual e uso de cada conta
+ccx sync                            # manda pro app o resumo das sessões (roda sozinho após o login e a cada 5 min)
 ccx sair                            # o claude volta ao seu login normal
 ccx logout                          # sai do app neste computador
 ```

package/bin/ccx.js

@@ -6,6 +6,7 @@
 //   ccx                      mostra suas contas e troca a conta deste computador
 //   ccx <conta>              troca direto (nome curto, ex.: claude-infra)
 //   ccx status               conta atual e uso das contas liberadas pra você
+//   ccx sync                 manda pro app o resumo das sessões do Claude (totais por projeto e dia; nunca o texto)
 //   ccx sair                 tira a conta deste computador (o claude volta ao login normal)
 //   ccx logout               sai do app: tira a conta, a autorização e o vigia
 //   ccx --version            versão instalada (atualizar: npm install -g @nectarcrm/ccx@latest)
@@ -14,12 +15,13 @@
 // (terminal, VS Code, JetBrains) usa essa conta. Claudes já abertos continuam na anterior.
 // O vigia roda sozinho a cada 5 min: avisa o app, atualiza o token se o admin trocou
 // e tira a conta se o acesso for removido. Os tokens gastos vão pro app pela telemetria.
+// O vigia também roda o sync, então o resumo dos projetos chega sozinho.
 
 import { execFileSync } from 'node:child_process'
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { createHash } from 'node:crypto'
 import { homedir, hostname } from 'node:os'
-import { dirname, join } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 const DIR = join(homedir(), '.config', 'ccx')
@@ -221,6 +223,8 @@ async function agentOnce() {
     writeJson(APP, removeAccount(app))
     return log('login vencido: conta tirada deste computador')
   }
+  try { await sync(app, key, true) }
+  catch (e) { log(`sync falhou: ${e.message}`) }
   const r = await api(app, key, 'POST', '/api/cli/heartbeat', { account_id: app.account?.id ?? null }, 20_000)
   if (r.status === 401) {
     writeJson(APP, removeAccount(app))
@@ -242,6 +246,162 @@ async function agentOnce() {
   }
 }
 
+// ---------- sync: resumo das sessões do Claude Code ----------
+// Lê ~/.claude/projects/**/*.jsonl, soma por sessão, projeto e dia (de Brasília) e manda só os
+// totais: pedidos, respostas, ferramentas e tokens. Nunca o texto da conversa.
+// Os arquivos só crescem: guardamos até onde lemos cada um e os totais, e mandamos só o que mudou.
+const PROJECTS = join(dirname(SETTINGS), 'projects')
+const SYNC_STATE = join(DIR, 'sync.json')
+const SYNC_LOCK = join(DIR, 'sync.lock')
+const SYNC_BATCH = 2000
+const SYNC_CHUNK = 1 << 20
+const SYNC_KEEP_DAYS = 40 // o Claude apaga as sessões com 30 dias
+const brtDay = ts => new Date(Date.parse(ts) - 3 * 3600_000).toISOString().slice(0, 10)
+
+function jsonlFiles(dir) {
+  const out = []
+  let list = []
+  try { list = readdirSync(dir, { withFileTypes: true }) }
+  catch { return out }
+  for (const e of list) {
+    const p = join(dir, e.name)
+    if (e.isDirectory()) out.push(...jsonlFiles(p))
+    else if (e.name.endsWith('.jsonl')) out.push(p)
+  }
+  return out
+}
+
+// Nome do projeto: o repositório do git (vale pra worktree também); sem git, o nome da pasta
+const projectNames = new Map()
+function projectOf(cwd) {
+  if (!projectNames.has(cwd)) {
+    let name = basename(cwd) || cwd
+    try {
+      const url = execFileSync('git', ['-C', cwd, 'remote', 'get-url', 'origin'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim()
+      name = basename(url.replace(/[/:]+$/, '')).replace(/\.git$/, '') || name
+    }
+    catch {}
+    projectNames.set(cwd, name)
+  }
+  return projectNames.get(cwd)
+}
+
+// Lê só as linhas completas a partir de `from`. Devolve as respostas e pedidos novos e até onde leu.
+function readNewLines(file, from) {
+  const events = new Map()
+  const fd = openSync(file, 'r')
+  const buf = Buffer.alloc(SYNC_CHUNK)
+  let pos = from, rest = Buffer.alloc(0)
+  try {
+    for (;;) {
+      const n = readSync(fd, buf, 0, SYNC_CHUNK, pos + rest.length)
+      if (!n) break
+      let data = Buffer.concat([rest, buf.subarray(0, n)])
+      let nl
+      while ((nl = data.indexOf(10)) !== -1) {
+        const lineBuf = data.subarray(0, nl)
+        data = data.subarray(nl + 1)
+        pos += nl + 1
+        // Filtro barato antes de ler o JSON (as linhas com resultado de ferramenta são enormes)
+        const assistant = lineBuf.includes('"type":"assistant"') && lineBuf.includes('"usage"')
+        const prompt = !assistant && lineBuf.includes('"type":"user"') && !lineBuf.includes('"tool_result"')
+        if (assistant || prompt) addLine(events, lineBuf.toString())
+      }
+      rest = Buffer.from(data)
+    }
+  }
+  finally { closeSync(fd) }
+  return { events: [...events.values()], offset: pos }
+}
+
+function addLine(events, text) {
+  let o
+  try { o = JSON.parse(text) }
+  catch { return }
+  if (!o.cwd || !o.sessionId || !o.timestamp || Number.isNaN(Date.parse(o.timestamp))) return
+  const base = { session_id: o.sessionId, project: projectOf(o.cwd), branch: o.gitBranch || null, at: o.timestamp }
+  if (o.type === 'assistant' && o.requestId && o.message?.usage) {
+    // Uma resposta vem em várias linhas (uma por bloco), com o mesmo requestId
+    const u = o.message.usage
+    const tools = (events.get(o.requestId)?.tools ?? 0) + (o.message.content ?? []).filter(b => b?.type === 'tool_use').length
+    events.set(o.requestId, {
+      ...base, kind: 'resposta', tools,
+      input_tokens: u.input_tokens ?? 0, output_tokens: u.output_tokens ?? 0,
+      cache_read_tokens: u.cache_read_input_tokens ?? 0, cache_creation_tokens: u.cache_creation_input_tokens ?? 0,
+    })
+    return
+  }
+  // Pedido digitado pela pessoa (não conta subagente, comando interno nem mensagem do sistema)
+  const content = o.message?.content
+  const typed = typeof content === 'string' ? content : Array.isArray(content) ? content.find(b => b?.type === 'text')?.text : null
+  if (o.type === 'user' && o.uuid && !o.isSidechain && !o.isMeta && typed && !typed.trimStart().startsWith('<')) {
+    events.set(`p:${o.uuid}`, { ...base, kind: 'pedido' })
+  }
+}
+
+// Soma um evento no total da sessão, projeto e dia
+function addToDay(days, e) {
+  const day = brtDay(e.at)
+  const key = `${e.session_id}\t${e.project}\t${day}`
+  const d = days[key] ??= { session_id: e.session_id, project: e.project, day, branch: null, last_at: e.at,
+    prompts: 0, responses: 0, tools: 0, input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_creation_tokens: 0 }
+  if (e.at >= d.last_at) { d.last_at = e.at; d.branch = e.branch ?? d.branch }
+  if (e.kind === 'pedido') d.prompts++
+  else {
+    d.responses++
+    for (const k of ['tools', 'input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_creation_tokens']) d[k] += e[k]
+  }
+  return key
+}
+
+// Só um sync por vez (o vigia pode rodar junto com o login). Trava velha (sync que caiu) é ignorada.
+function takeLock() {
+  mkdirSync(DIR, { recursive: true })
+  try { closeSync(openSync(SYNC_LOCK, 'wx')); return true }
+  catch {
+    try { if (Date.now() - statSync(SYNC_LOCK).mtimeMs < 30 * 60_000) return false } catch {}
+    rmSync(SYNC_LOCK, { force: true })
+    try { closeSync(openSync(SYNC_LOCK, 'wx')); return true } catch { return false }
+  }
+}
+
+async function sync(app, key, quiet = false) {
+  const say = msg => { if (!quiet) process.stderr.write(msg) }
+  if (!takeLock()) return say('Outro sync já está rodando. Tente de novo daqui a pouco.\n')
+  try {
+    const state = readJson(SYNC_STATE, {})
+    const offsets = state.files ?? {}, days = state.days ?? {}
+    const changed = new Set()
+    const files = jsonlFiles(PROJECTS)
+    say(`Lendo as sessões do Claude Code em ${PROJECTS}`)
+    for (const file of files) {
+      const size = statSync(file).size
+      const from = offsets[file] ?? 0
+      if (from >= size) continue // nada novo (ou arquivo trocado: não soma de novo)
+      const { events, offset } = readNewLines(file, from)
+      for (const e of events) changed.add(addToDay(days, e))
+      offsets[file] = offset
+    }
+    // Esquece arquivo apagado e dia antigo
+    const alive = new Set(files)
+    for (const f of Object.keys(offsets)) if (!alive.has(f)) delete offsets[f]
+    const oldest = brtDay(new Date(Date.now() - SYNC_KEEP_DAYS * 86_400_000).toISOString())
+    for (const [k, d] of Object.entries(days)) if (d.day < oldest) delete days[k]
+
+    const items = [...changed].map(k => days[k]).filter(Boolean)
+    for (let i = 0; i < items.length; i += SYNC_BATCH) {
+      say('.')
+      const r = await api(app, key, 'POST', '/api/cli/sync', { items: items.slice(i, i + SYNC_BATCH) })
+      if (r.status !== 200) throw new Error(r.data.message ?? `HTTP ${r.status}`)
+    }
+    // Só grava depois de enviar: se falhar, a próxima vez lê e manda de novo
+    writeJson(SYNC_STATE, { files: offsets, days })
+    say(`\n${c(32, '✓')} Enviado: ${items.length} ${items.length === 1 ? 'resumo' : 'resumos'} (sessão, projeto e dia).\n`)
+    return items.length
+  }
+  finally { rmSync(SYNC_LOCK, { force: true }) }
+}
+
 // ---------- saída ----------
 const isTTY = process.stderr.isTTY
 const c = (code, s) => (isTTY ? `\x1b[${code}m${s}\x1b[0m` : s)
@@ -346,7 +506,7 @@ async function useAccount(app, key, wanted) {
 const [cmd, ...rest] = process.argv.slice(2)
 
 if (cmd === 'help' || cmd === '-h' || cmd === '--help') {
-  console.log(readFileSync(SELF, 'utf8').split('\n').filter(l => l.startsWith('//')).slice(0, 15).map(l => l.slice(3)).join('\n'))
+  console.log(readFileSync(SELF, 'utf8').split('\n').filter(l => l.startsWith('//')).slice(0, 17).map(l => l.slice(3)).join('\n'))
   process.exit(0)
 }
 
@@ -381,6 +541,12 @@ if (cmd === 'sair') {
   process.exit(0)
 }
 
+if (cmd === 'sync') {
+  try { await sync(app, key) }
+  catch (e) { die(`\nO sync falhou: ${e.message}`) }
+  process.exit(0)
+}
+
 if (cmd === 'status') {
   const r = await api(app, key, 'GET', '/api/cli/status')
   if (r.status !== 200) die(r.data.message ?? `Falhou (HTTP ${r.status})`)
@@ -393,3 +559,10 @@ if (cmd === 'status') {
 
 // `ccx`, `ccx login ...` (depois de autorizar) ou `ccx <conta>`
 await useAccount(app, key, cmd && cmd !== 'login' ? cmd : await chooseAccount(app, key))
+
+// Logo depois do login, manda o resumo das sessões (as próximas vão pelo vigia)
+if (cmd === 'login') {
+  console.error('')
+  try { await sync(app, key) }
+  catch (e) { console.error(c(33, `\nO sync falhou (${e.message}). Tente: ccx sync`)) }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nectarcrm/ccx",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Escolhe qual conta Claude este computador usa, conectado ao app Contas Claude da Nectar.",
   "type": "module",
   "bin": { "ccx": "bin/ccx.js" },