@nectarcrm/ccx 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,34 @@
-# Temporary Holding Version
+# ccx
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Escolhe qual conta Claude este computador usa. Funciona junto com o app **Contas Claude** da Nectar.
+
+## Instalar
+
+Precisa de Node 18.17 ou mais novo. Funciona no macOS, Windows e Linux.
+
+```
+npm install -g @nectarcrm/ccx
+```
+
+## Usar
+
+```
+ccx login                           # autoriza este computador (abre o navegador) e escolhe a conta
+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 sair                            # o claude volta ao seu login normal
+ccx logout                          # sai do app neste computador
+```
+
+Depois de escolher, **qualquer `claude`** (terminal, VS Code, JetBrains) usa a conta escolhida.
+Claudes que já estavam abertos continuam na conta anterior até serem fechados.
+
+## O que o ccx faz no seu computador
+
+- Grava o token da conta e a telemetria (tokens gastos vão pro app) no `env` do `~/.claude/settings.json`.
+  Ele só mexe nas chaves que ele mesmo escreveu.
+- Guarda a chave do computador no Keychain (macOS), protegida pelo Windows (DPAPI) ou, no Linux,
+  no cofre do sistema (`secret-tool`) — sem ele, num arquivo que só o seu usuário lê.
+- Liga um vigia que roda a cada 5 minutos (launchd no macOS, Agendador de Tarefas no Windows, timer do systemd ou crontab no Linux):
+  avisa o app, atualiza o token se o admin trocou e tira a conta se o acesso for removido.

package/bin/ccx.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+// ccx — escolhe qual conta Claude este computador usa. Conectado ao app Contas Claude.
+//
+//   ccx login                autoriza este computador (abre o navegador) e escolhe a conta
+//                            (outro app: ccx login https://endereco)
+//   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 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)
+//
+// A conta escolhida vai pro settings.json do Claude Code, então qualquer `claude` aberto
+// (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.
+
+import { execFileSync } from 'node:child_process'
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { homedir, hostname } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const DIR = join(homedir(), '.config', 'ccx')
+const APP = join(DIR, 'app.json')
+const LOG = join(DIR, 'vigia.log')
+const SETTINGS = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'settings.json')
+const WIN = process.platform === 'win32'
+const MAC = process.platform === 'darwin'
+const DEFAULT_URL = 'https://ccx.nectarcrm.com.br'
+const SERVICE = 'ccx-app' // Keychain: guarda a chave do computador
+const AGENT_MINUTES = 5
+const AGENT_ID = 'br.com.nectarcrm.ccx' // launchd (Mac) / nome da tarefa (Windows)
+const SELF = fileURLToPath(import.meta.url)
+
+const readJson = (p, fallback) => (existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : fallback)
+const writeJson = (p, v) => { mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, JSON.stringify(v, null, 2) + '\n') }
+const fingerprint = t => createHash('sha256').update(t).digest('hex').slice(0, 16)
+
+// ---------- segredo (chave do computador) ----------
+// macOS: Keychain. Windows: DPAPI (só o usuário do Windows abre). Linux: cofre do sistema
+// (secret-tool/libsecret) ou, sem ele (servidor, WSL), arquivo que só o usuário lê.
+// O segredo sempre passa por stdin, nunca pela linha de comando.
+const ps = (script, input) => execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], { input, stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim()
+const KEY_FILE = join(DIR, 'chave') // Windows (DPAPI) e Linux sem cofre
+const SECRET_TOOL = ['service', SERVICE, 'account', 'chave']
+
+function secretGet() {
+  try {
+    if (WIN) return ps('$s = [Console]::In.ReadToEnd().Trim() | ConvertTo-SecureString; [Runtime.InteropServices.Marshal]::PtrToStringBSTR([Runtime.InteropServices.Marshal]::SecureStringToBSTR($s))', readFileSync(KEY_FILE, 'utf8'))
+    if (MAC) return execFileSync('security', ['find-generic-password', '-s', SERVICE, '-a', 'chave', '-w'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim()
+    if (existsSync(KEY_FILE)) return readFileSync(KEY_FILE, 'utf8').trim()
+    return execFileSync('secret-tool', ['lookup', ...SECRET_TOOL], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null
+  }
+  catch { return null }
+}
+function secretSet(value) {
+  if (WIN) {
+    mkdirSync(DIR, { recursive: true })
+    writeFileSync(KEY_FILE, ps('[Console]::In.ReadToEnd().Trim() | ConvertTo-SecureString -AsPlainText -Force | ConvertFrom-SecureString', value))
+    return
+  }
+  if (MAC) {
+    // Via `security -i` (stdin) para o segredo não aparecer na lista de processos
+    execFileSync('security', ['-i'], { input: `add-generic-password -U -s ${SERVICE} -a chave -w ${value}\n`, stdio: ['pipe', 'ignore', 'inherit'] })
+    return
+  }
+  try {
+    execFileSync('secret-tool', ['store', '--label=ccx', ...SECRET_TOOL], { input: value, stdio: ['pipe', 'ignore', 'ignore'] })
+    rmSync(KEY_FILE, { force: true })
+  }
+  catch {
+    mkdirSync(DIR, { recursive: true })
+    writeFileSync(KEY_FILE, value, { mode: 0o600 })
+    chmodSync(KEY_FILE, 0o600)
+  }
+}
+function secretDelete() {
+  if (WIN) return rmSync(KEY_FILE, { force: true })
+  if (MAC) {
+    try { execFileSync('security', ['delete-generic-password', '-s', SERVICE, '-a', 'chave'], { stdio: 'ignore' }) }
+    catch {}
+    return
+  }
+  rmSync(KEY_FILE, { force: true })
+  try { execFileSync('secret-tool', ['clear', ...SECRET_TOOL], { stdio: 'ignore' }) }
+  catch {}
+}
+
+// ---------- settings.json do Claude Code ----------
+// O ccx só mexe nas chaves de `env` que ele mesmo escreveu (lista guardada em app.json).
+function readSettings() {
+  try { return readJson(SETTINGS, {}) }
+  catch { die(`Não consegui ler ${SETTINGS} (JSON inválido). Corrija o arquivo e rode o ccx de novo.`) }
+}
+function writeSettings(s) {
+  writeJson(SETTINGS, s)
+  if (!WIN) chmodSync(SETTINGS, 0o600) // agora guarda um token
+}
+function applyAccount(app, key, account, token) {
+  const s = readSettings()
+  const env = { ...s.env }
+  const vars = {
+    CLAUDE_CODE_OAUTH_TOKEN: token,
+    // Telemetria: cada resposta de qualquer claude manda os tokens pro app, marcada com a conta
+    CLAUDE_CODE_ENABLE_TELEMETRY: '1',
+    OTEL_LOGS_EXPORTER: 'otlp',
+    OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: 'http/json',
+    OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: `${app.url}/api/cli/otel/v1/logs`,
+    OTEL_EXPORTER_OTLP_LOGS_HEADERS: `Authorization=Bearer ${key}`,
+    OTEL_RESOURCE_ATTRIBUTES: `ccx.account_id=${account.id}`,
+  }
+  // Métricas não são usadas; desliga só se a pessoa não configurou as dela
+  if (!('OTEL_METRICS_EXPORTER' in env) || app.owned?.includes('OTEL_METRICS_EXPORTER')) vars.OTEL_METRICS_EXPORTER = 'none'
+  writeSettings({ ...s, env: { ...env, ...vars } })
+  return { ...app, account: { id: account.id, slug: account.slug, label: account.label }, token_fp: fingerprint(token), owned: Object.keys(vars) }
+}
+function removeAccount(app) {
+  if (app?.owned?.length && existsSync(SETTINGS)) {
+    const s = readSettings()
+    const env = { ...s.env }
+    for (const k of app.owned) delete env[k]
+    if (Object.keys(env).length) s.env = env
+    else delete s.env
+    writeSettings(s)
+  }
+  return { ...app, account: null, token_fp: null, owned: [] }
+}
+
+// ---------- vigia em segundo plano ----------
+// macOS: launchd. Windows: Agendador de Tarefas. Linux: timer do systemd do usuário ou, sem ele, crontab.
+const PLIST = join(homedir(), 'Library', 'LaunchAgents', `${AGENT_ID}.plist`)
+const UNIT_DIR = join(homedir(), '.config', 'systemd', 'user')
+const CRON_TAG = '# ccx-vigia'
+const run = (cmd, args, input) => execFileSync(cmd, args, { input, stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'ignore'] }).toString()
+const crontabWithout = () => { try { return run('crontab', ['-l']).split('\n').filter(l => l && !l.includes(CRON_TAG)) } catch { return [] } }
+
+function installLinuxAgent() {
+  const cmdLine = `"${process.execPath}" "${SELF}" vigia`
+  try {
+    run('systemctl', ['--user', 'show-environment']) // tem systemd do usuário?
+    mkdirSync(UNIT_DIR, { recursive: true })
+    writeFileSync(join(UNIT_DIR, 'ccx-vigia.service'), `[Unit]\nDescription=ccx: vigia da conta Claude\n\n[Service]\nType=oneshot\nExecStart=${cmdLine}\n`)
+    writeFileSync(join(UNIT_DIR, 'ccx-vigia.timer'), `[Unit]\nDescription=ccx: vigia a cada ${AGENT_MINUTES} min\n\n[Timer]\nOnBootSec=1min\nOnUnitActiveSec=${AGENT_MINUTES}min\n\n[Install]\nWantedBy=timers.target\n`)
+    run('systemctl', ['--user', 'daemon-reload'])
+    run('systemctl', ['--user', 'enable', '--now', 'ccx-vigia.timer'])
+    return true
+  }
+  catch {}
+  // Sem systemd do usuário: crontab
+  run('crontab', ['-'], [...crontabWithout(), `*/${AGENT_MINUTES} * * * * ${cmdLine} 2>>"${LOG}" ${CRON_TAG}`, ''].join('\n'))
+  return true
+}
+function uninstallLinuxAgent() {
+  try {
+    run('systemctl', ['--user', 'disable', '--now', 'ccx-vigia.timer'])
+  }
+  catch {}
+  rmSync(join(UNIT_DIR, 'ccx-vigia.service'), { force: true })
+  rmSync(join(UNIT_DIR, 'ccx-vigia.timer'), { force: true })
+  try { run('systemctl', ['--user', 'daemon-reload']) }
+  catch {}
+  try {
+    const lines = crontabWithout()
+    if (lines.length) run('crontab', ['-'], [...lines, ''].join('\n'))
+    else run('crontab', ['-r'])
+  }
+  catch {}
+}
+function installAgent() {
+  try {
+    if (MAC) {
+      mkdirSync(dirname(PLIST), { recursive: true })
+      writeFileSync(PLIST, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${AGENT_ID}</string>
+  <key>ProgramArguments</key><array><string>${process.execPath}</string><string>${SELF}</string><string>vigia</string></array>
+  <key>StartInterval</key><integer>${AGENT_MINUTES * 60}</integer>
+  <key>RunAtLoad</key><true/>
+  <key>StandardErrorPath</key><string>${LOG}</string>
+</dict></plist>
+`)
+      const domain = `gui/${process.getuid()}`
+      try { execFileSync('launchctl', ['bootout', domain, PLIST], { stdio: 'ignore' }) }
+      catch {}
+      execFileSync('launchctl', ['bootstrap', domain, PLIST], { stdio: 'ignore' })
+      return true
+    }
+    if (WIN) {
+      execFileSync('schtasks', ['/Create', '/F', '/SC', 'MINUTE', '/MO', String(AGENT_MINUTES), '/TN', AGENT_ID,
+        '/TR', `"${process.execPath}" "${SELF}" vigia`], { stdio: 'ignore' })
+      return true
+    }
+    return installLinuxAgent()
+  }
+  catch (e) { console.error(c(33, `Não consegui ligar o vigia automático (${e.message}).`)) }
+  return false
+}
+function uninstallAgent() {
+  try {
+    if (MAC) {
+      try { execFileSync('launchctl', ['bootout', `gui/${process.getuid()}`, PLIST], { stdio: 'ignore' }) }
+      catch {}
+      rmSync(PLIST, { force: true })
+    }
+    else if (WIN) execFileSync('schtasks', ['/Delete', '/F', '/TN', AGENT_ID], { stdio: 'ignore' })
+    else uninstallLinuxAgent()
+  }
+  catch {}
+}
+
+// Uma passada do vigia: avisa o app, atualiza o token ou tira a conta
+async function agentOnce() {
+  const app = readJson(APP, null)
+  const key = app && secretGet()
+  if (!app || !key) return
+  const log = msg => appendFileSync(LOG, `${new Date().toISOString()} ${msg}\n`)
+  if (new Date(app.expires_at) < new Date()) {
+    writeJson(APP, removeAccount(app))
+    return log('login vencido: conta tirada deste computador')
+  }
+  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))
+    secretDelete()
+    uninstallAgent()
+    return log(`acesso removido (${r.data.message ?? '401'}): conta e autorização tiradas deste computador`)
+  }
+  if (r.status !== 200 || !app.account) return
+  if (!r.data.allowed) {
+    writeJson(APP, removeAccount(app))
+    return log(`conta ${app.account.label} não está mais liberada: tirada deste computador`)
+  }
+  if (r.data.token_fp !== app.token_fp) {
+    const s = await api(app, key, 'POST', '/api/cli/session', { account: app.account.slug }, 30_000)
+    if (s.status === 200) {
+      writeJson(APP, applyAccount(app, key, s.data.account, s.data.token))
+      log(`token da conta ${app.account.label} atualizado`)
+    }
+  }
+}
+
+// ---------- saída ----------
+const isTTY = process.stderr.isTTY
+const c = (code, s) => (isTTY ? `\x1b[${code}m${s}\x1b[0m` : s)
+const colorPct = p => (p >= 95 ? c(31, `${p}%`) : p >= 80 ? c(33, `${p}%`) : c(32, `${p}%`))
+function when(d) {
+  if (!d) return ''
+  const mins = Math.round((d - Date.now()) / 60_000)
+  if (mins <= 0) return 'agora'
+  const dd = Math.floor(mins / 1440), hh = Math.floor((mins % 1440) / 60), mm = mins % 60
+  return dd ? `${dd}d ${hh}h` : hh ? `${hh}h${String(mm).padStart(2, '0')}` : `${mm}min`
+}
+function line(a) {
+  const name = a.slug.padEnd(14)
+  if (a.five_hour_pct === null && a.weekly_pct === null) return `${name} ${c(90, a.status === 'ok' ? 'sem leitura ainda' : 'desconectada — avise um admin')}`
+  const at = s => s && new Date(s)
+  return `${name} 5h ${colorPct(a.five_hour_pct ?? 0).padEnd(isTTY ? 13 : 4)} (reinicia em ${when(at(a.five_hour_resets_at))})   semana ${colorPct(a.weekly_pct ?? 0).padEnd(isTTY ? 13 : 4)} (reinicia em ${when(at(a.weekly_resets_at))})`
+}
+
+// ---------- app ----------
+function die(msg) { console.error(msg); process.exit(1) }
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+async function api(app, key, method, path, body, timeoutMs = 60_000) {
+  let res
+  try {
+    res = await fetch(app.url + path, {
+      method,
+      headers: { 'content-type': 'application/json', ...(key ? { authorization: `Bearer ${key}` } : {}) },
+      body: body && JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+  }
+  catch (e) { return { status: 0, data: { message: `sem conexão com ${app.url} (${e.message})` } } }
+  const data = await res.json().catch(() => ({}))
+  return { status: res.status, data }
+}
+
+function openBrowser(url) {
+  const [cmd, args] = WIN ? ['cmd', ['/c', 'start', '""', url]] : MAC ? ['open', [url]] : ['xdg-open', [url]]
+  try { execFileSync(cmd, args, { stdio: 'ignore' }) }
+  catch {}
+}
+
+async function login(url) {
+  const target = { url: url.replace(/\/+$/, '') }
+  if (!/^https?:\/\//.test(target.url)) die('Uso: ccx login https://endereco-do-app')
+  const start = await api(target, null, 'POST', '/api/cli/device', { hostname: hostname(), platform: process.platform })
+  if (start.status !== 200) die(`Não consegui falar com o app: ${start.data.message ?? `HTTP ${start.status}`}`)
+  const { device_code, user_code, verify_url, expires_in, interval } = start.data
+  console.error(`\nNo navegador, digite este código:\n\n   ${c(1, user_code)}\n\n   ${verify_url}\n`)
+  openBrowser(verify_url)
+  process.stderr.write('Esperando a aprovação')
+  const deadline = Date.now() + expires_in * 1000
+  while (Date.now() < deadline) {
+    await sleep(interval * 1000)
+    const r = await api(target, null, 'POST', '/api/cli/device/token', { device_code })
+    if (r.status === 202 || r.status === 0) { process.stderr.write('.'); continue }
+    if (r.status !== 200) die(`\n${r.data.message ?? `Falhou (HTTP ${r.status})`}`)
+    try { secretSet(r.data.key) }
+    catch { die('\nNão consegui guardar a chave no cofre do sistema. Rode ccx login de novo e permita o acesso.') }
+    // Login de novo: tira a conta anterior (a telemetria dela usava a chave antiga)
+    writeJson(APP, { ...removeAccount(readJson(APP, null)), url: target.url, email: r.data.email, expires_at: r.data.expires_at })
+    console.error(`\n\nPronto! Este computador está autorizado para ${r.data.email} até ${new Date(r.data.expires_at).toLocaleDateString('pt-BR')}.\n`)
+    return
+  }
+  die('\nO código venceu. Rode ccx login de novo.')
+}
+
+// Mostra as contas e devolve o nome curto escolhido (Enter = recomendada)
+async function chooseAccount(app, key) {
+  const r = await api(app, key, 'GET', '/api/cli/status?fresh=1')
+  if (r.status !== 200) die(r.data.message ?? `Falhou (HTTP ${r.status})`)
+  const { accounts: list, recommended } = r.data
+  if (!list.length) die('Nenhuma conta liberada pra você. Peça a um admin.')
+  if (list.length === 1) return list[0].slug
+  if (!process.stdin.isTTY) return recommended ?? die('Nenhuma conta disponível agora.')
+  console.error('Qual conta este computador deve usar?\n')
+  list.forEach((a, i) => console.error(`  ${c(1, String(i + 1))}  ${line(a)}${a.slug === recommended ? c(36, '  ← recomendada') : ''}${a.id === app.account?.id ? c(90, '  (atual)') : ''}`))
+  const { createInterface } = await import('node:readline/promises')
+  const rl = createInterface({ input: process.stdin, output: process.stderr })
+  for (;;) {
+    const ans = (await rl.question(`\nNúmero${recommended ? ' (Enter = recomendada)' : ''}: `).catch(() => die('\nCancelado.'))).trim()
+    if (!ans && recommended) { rl.close(); return recommended }
+    const n = Number(ans)
+    if (Number.isInteger(n) && n >= 1 && n <= list.length) { rl.close(); return list[n - 1].slug }
+    console.error('Digite um dos números da lista.')
+  }
+}
+
+async function useAccount(app, key, wanted) {
+  const s = await api(app, key, 'POST', '/api/cli/session', { account: wanted })
+  if (s.status !== 200) die(s.data.message ?? `Falhou (HTTP ${s.status})`)
+  writeJson(APP, applyAccount(app, key, s.data.account, s.data.token))
+  const agent = installAgent()
+  if (process.env.ANTHROPIC_API_KEY) console.error(c(33, 'Aviso: ANTHROPIC_API_KEY está definida e tem prioridade sobre a conta escolhida.'))
+  console.error(`\n${c(32, '✓')} Este computador agora usa a conta ${c(1, s.data.account.label)}.`)
+  console.error('  Todo claude aberto a partir de agora usa essa conta. Os que já estão abertos continuam na anterior.')
+  if (!agent) console.error(c(33, '  Vigia automático indisponível neste sistema: rode "ccx vigia" de vez em quando.'))
+}
+
+// ---------- comandos ----------
+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'))
+  process.exit(0)
+}
+
+if (cmd === '--version' || cmd === '-v' || cmd === 'version') {
+  console.log(readJson(join(dirname(SELF), '..', 'package.json'), {}).version ?? '?')
+  process.exit(0)
+}
+
+if (cmd === 'vigia') {
+  await agentOnce()
+  process.exit(0)
+}
+
+if (cmd === 'login') await login(rest[0] ?? readJson(APP, null)?.url ?? DEFAULT_URL)
+
+const app = readJson(APP, null)
+const key = app && secretGet()
+if (!app || !key) die('Este computador ainda não está conectado. Rode: ccx login')
+
+if (cmd === 'logout') {
+  removeAccount(app)
+  secretDelete()
+  rmSync(APP, { force: true })
+  uninstallAgent()
+  console.error('Pronto: este computador saiu do app. O claude volta ao seu login normal.')
+  process.exit(0)
+}
+
+if (cmd === 'sair') {
+  writeJson(APP, removeAccount(app))
+  console.error('Pronto: este computador não usa mais conta do app. O claude volta ao seu login normal. Pra escolher de novo: ccx')
+  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})`)
+  console.error(c(90, `${r.data.email} · login vale até ${new Date(r.data.expires_at).toLocaleDateString('pt-BR')} · ${app.url}`))
+  console.error(`Conta deste computador: ${app.account ? c(1, app.account.label) : c(33, 'nenhuma (rode ccx)')}\n`)
+  for (const a of r.data.accounts) console.log(`${a.id === app.account?.id ? c(36, '●') : ' '} ${line(a)}`)
+  if (!r.data.accounts.length) console.log('(nenhuma conta liberada pra você — peça a um admin)')
+  process.exit(0)
+}
+
+// `ccx`, `ccx login ...` (depois de autorizar) ou `ccx <conta>`
+await useAccount(app, key, cmd && cmd !== 'login' ? cmd : await chooseAccount(app, key))

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "@nectarcrm/ccx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Escolhe qual conta Claude este computador usa, conectado ao app Contas Claude da Nectar.",
+  "type": "module",
+  "bin": { "ccx": "bin/ccx.js" },
+  "files": ["bin"],
+  "engines": { "node": ">=18.17" },
+  "os": ["darwin", "win32", "linux"],
+  "keywords": ["claude", "claude-code", "nectar"],
+  "license": "UNLICENSED",
+  "publishConfig": { "access": "public" }
+}