terminal-smart-cli 0.48.0 → 0.50.0

package/bin/ts.js

@@ -1333,6 +1333,60 @@ async function metaCmd() {
 }
 
 // ── Uso / conta / idioma ─────────────────────────────────────────────────────
+// ── ts diagnosticar — MODO INVESTIGAÇÃO (hipótese→sonda→veredito→causa raiz) ──
+async function diagnosticarCmd(args) {
+  const token = needToken();
+  const en = (cfg.lang === 'en');
+  const _val = (names) => { const i = rawArgs.findIndex(a => names.includes(a)); return i >= 0 ? rawArgs[i + 1] : null; };
+  const target = _val(['--remoto', '--remote', '--ssh']) || '';       // ex: "ssh -i key user@host"
+  const model = _val(['--modelo', '--model']) || null;
+  const rounds = Number(_val(['--rodadas', '--rounds'])) || 12;
+  // sintoma = positionais, exceto os valores consumidos por flags (--remoto/--modelo/--rodadas)
+  const consumed = new Set([target, model, String(rounds)].filter(Boolean));
+  const sym = args.filter(a => !a.startsWith('-') && !consumed.has(a)).join(' ').trim();
+  if (!sym) { console.log(ui.errLine(en ? 'usage: ts diagnosticar "<symptom/error>" [--remoto "ssh user@host"]' : 'uso: ts diagnosticar "<sintoma/erro>" [--remoto "ssh user@host"]')); return; }
+
+  console.log('\n' + ui.box([
+    C.bold(en ? 'Diagnosis mode' : 'Modo diagnóstico') + C.dim(en ? ' — hypothesis → probe → verdict' : ' — hipótese → sonda → veredito'),
+    C.dim(en ? 'symptom: ' : 'sintoma: ') + sym.slice(0, 60) + (sym.length > 60 ? '…' : ''),
+    target ? C.dim(en ? 'target: ' : 'alvo: ') + target : C.dim(en ? 'target: this machine' : 'alvo: esta máquina'),
+  ], { title: 'ts' }) + '\n');
+
+  const diag = require('../lib/diagnose');
+  const catIcon = { environment: '🌐', config: '⚙', permission: '🔒', resource: '📦', network: '🔌', data: '🗄', version: '🔀', logic: '🧩', unknown: '·' };
+  const r = await diag.diagnose(sym, {
+    token, lang: cfg.lang || 'pt', model, target, maxRounds: rounds,
+    onEvent: (e) => {
+      if (e.type === 'think') console.log('  ' + C.dim('R' + e.round) + ' ' + (catIcon[e.category] || '·') + ' ' + C.bold(e.hypothesis || '—') + (e.confidence ? C.dim('  ' + e.confidence + '%') : ''));
+      else if (e.type === 'probe') console.log('    ' + C.dim('$ ') + e.probe.slice(0, 90));
+      else if (e.type === 'blocked') console.log('    ' + C.err(en ? 'probe blocked (not read-only)' : 'sonda bloqueada (não é só-leitura)'));
+      else if (e.type === 'skip') console.log('    ' + C.dim(en ? 'repeated probe skipped' : 'sonda repetida pulada'));
+      else if (e.type === 'stuck') console.log('  ' + C.dim(en ? 'exhausted hypotheses' : 'hipóteses esgotadas'));
+    },
+  });
+
+  console.log('');
+  if (r.status === 'no_credits') { console.log(ui.errLine(T.no_credits)); return; }
+  if (r.status === 'solved') {
+    console.log(ui.box([
+      C.ok(en ? 'ROOT CAUSE FOUND' : 'CAUSA RAIZ ENCONTRADA') + C.dim('  (' + r.category + ', ' + r.rounds + (en ? ' rounds' : ' rodadas') + ', ' + r.credits + ' cr)'),
+      '',
+      C.bold(en ? 'Cause: ' : 'Causa: ') + r.rootCause,
+      '',
+      C.bold(en ? 'Fix:' : 'Conserto:'),
+      ...String(r.fix || '—').split('\n').map(l => C.dim('  ' + l)),
+    ], { title: 'ts diagnóstico' }));
+    console.log('\n' + C.dim(en ? 'Apply it with: ' : 'Aplique com: ') + 'ts agente "' + (en ? 'apply this fix: ' : 'aplique este conserto: ') + String(r.rootCause).slice(0, 40) + '…"');
+  } else {
+    console.log(ui.box([
+      C.err(en ? 'NO ROOT CAUSE (honest)' : 'SEM CAUSA RAIZ (honesto)') + C.dim('  (' + r.rounds + (en ? ' rounds' : ' rodadas') + ', ' + r.credits + ' cr)'),
+      '',
+      C.dim(en ? 'Best guess: ' : 'Melhor palpite: ') + (r.rootCause || r.reason || (en ? 'unclear' : 'inconclusivo')),
+      C.dim(en ? 'Ruled out: ' : 'Descartado: ') + r.evidence.map(e => e.hypothesis).filter((v, i, a) => v && a.indexOf(v) === i).slice(0, 5).join('; ').slice(0, 120),
+    ], { title: 'ts diagnóstico' }));
+  }
+}
+
 // ── ts cloud — caixa de dev na nuvem (Fase 1) ────────────────────────────────
 async function cloudCmd(args) {
   const token = needToken();
@@ -1373,6 +1427,13 @@ async function cloudCmd(args) {
   if (sub === 'exec' || sub === 'sh' || sub === 'run') {
     const cmd = rest.join(' ').trim();
     if (!cmd) { console.log(ui.errLine(en ? 'usage: ts cloud exec "<command>"' : 'uso: ts cloud exec "<comando>"')); return; }
+    // Saída AO VIVO via SSE quando é terminal interativo; fallback pro modo bloqueante.
+    if (process.stdout.isTTY) {
+      try {
+        await sse('/api/cloud/exec-stream', { token, body: { cmd, timeoutMs: 300000 }, timeoutMs: 310000, onEvent: (e) => { if (e.chunk) process.stdout.write(e.chunk); } });
+        return;
+      } catch (e) { if (e.code === 'auth') { console.log(ui.errLine(T.need_login)); return; } }
+    }
     const r = await call('exec', { method: 'POST', body: { cmd }, timeoutMs: 300000 });
     if (r.out) process.stdout.write(r.out);
     if (!r.ok && r.error) console.log(ui.errLine(r.error));
@@ -1386,8 +1447,19 @@ async function cloudCmd(args) {
     if (!st.exists) { console.log(C.dim(en ? 'creating box…' : 'criando caixa…')); const up = await call('up', { method: 'POST', body: {}, timeoutMs: 120000 }); if (!up.ok) { console.log(ui.errLine(up.error || 'falha')); if (up.code === 'plan_required') console.log(C.dim('terminalsmart.com.br/planos')); return; } }
     console.log(C.dim(en ? 'running ts meta inside the cloud box (may take a while)…' : 'rodando ts meta dentro da caixa (pode demorar)…'));
     const safe = goal.replace(/(["\\$`])/g, '\\$1');
-    const r = await call('exec', { method: 'POST', body: { cmd: 'cd /workspace && ts meta "' + safe + '" --yes 2>&1 | tail -50' }, timeoutMs: 1800000 });
-    if (r.out) process.stdout.write(r.out);
+    const cmdMeta = 'cd /workspace && ts meta "' + safe + '" --yes 2>&1';
+    // Build AO VIVO via SSE quando é terminal interativo; fallback bloqueante com tail.
+    let streamed = false;
+    if (process.stdout.isTTY) {
+      try {
+        await sse('/api/cloud/exec-stream', { token, body: { cmd: cmdMeta, timeoutMs: 1800000 }, timeoutMs: 1860000, onEvent: (e) => { if (e.chunk) process.stdout.write(e.chunk); } });
+        streamed = true;
+      } catch (e) { if (e.code === 'auth') { console.log(ui.errLine(T.need_login)); return; } }
+    }
+    if (!streamed) {
+      const r = await call('exec', { method: 'POST', body: { cmd: cmdMeta + ' | tail -50' }, timeoutMs: 1800000 });
+      if (r.out) process.stdout.write(r.out);
+    }
     // EXPÕE o app na porta 3000 de forma PERSISTENTE (o startCmd fica salvo e é
     // re-executado no resume, então sobrevive ao idle-suspend). npm start senão estático.
     const startCmd = 'if [ -f package.json ] && grep -q \'"start"\' package.json; then PORT=3000 npm start; elif [ -f index.html ] || ls *.html >/dev/null 2>&1; then python3 -m http.server 3000; fi';
@@ -1525,6 +1597,7 @@ function recallCmd(args) {
     case 'recall': case 'lembrei': case 'sessoes': case 'sessões': return recallCmd(POS.slice(1));
     case 'vps': case 'servidor': return vpsCmd(POS.slice(1));
     case 'cloud': case 'nuvem': return cloudCmd(POS.slice(1));
+    case 'diagnosticar': case 'diagnose': case 'investigar': case 'debug': return diagnosticarCmd(POS.slice(1));
     case 'meta': case 'missao': case 'mission': return metaCmd();
     case 'runs':   return runsCmd();
     case 'status': return statusCmd(POS[1]);

package/lib/diagnose.js

@@ -0,0 +1,97 @@
+// lib/diagnose.js — MODO DIAGNÓSTICO do TS: um loop de INVESTIGAÇÃO (não de build).
+// Dado um SINTOMA (erro/comando que falha), o agente forma HIPÓTESES rankeadas, testa
+// cada uma com uma SONDA somente-leitura, lê o resultado, dá um VEREDITO (confirma/refuta)
+// e itera até achar a CAUSA RAIZ — distinguindo ambiente/config de dado/lógica interna.
+// É o que faltava pro TS encarar legado obscuro (ex: instalar um servidor de MMO) em vez de
+// só construir do zero: hipótese → teste → descarte → nova hipótese.
+const { api, ApiError } = require('./api');
+const agent = require('./agent');
+const tools = require('./tools');
+
+// SONDA = comando de INVESTIGAÇÃO (só leitura). Bloqueia qualquer verbo que MUTE o sistema —
+// o diagnóstico observa, não conserta (o fix vem depois, com aprovação, no `ts agente`).
+const MUTATE = /(^|[\s;|&(])(rm|rmdir|mv|cp|dd|mkfs\S*|chmod|chown|ln|truncate|tee|shred|install|apt|apt-get|yum|dnf|snap|pip|pip3|npm|yarn|pnpm|gem|cargo|make|gcc|g\+\+|systemctl|service|kill|pkill|killall|reboot|shutdown|halt|poweroff|mount|umount|iptables|ufw|crontab|useradd|userdel|passwd|dpkg|growpart|resize2fs|mkswap|fdisk|parted)([\s;|&)]|$)|(\bmysql\b[^|]*\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|GRANT|TRUNCATE|REPLACE)\b)|(^|[^>])>[^>|&]|>>|\bsed\b[^|]*-i|\bgit\b\s+(commit|push|reset|checkout|clean|rm|merge|rebase|pull)/i;
+function isProbe(cmd) { return !MUTATE.test(String(cmd || '')); }
+
+function sysPrompt(lang, target) {
+  const where = target ? (lang === 'en' ? `The system under investigation is REMOTE: probes run via "${target}".` : `O sistema investigado é REMOTO: as sondas rodam via "${target}".`) : (lang === 'en' ? 'The system under investigation is THIS machine.' : 'O sistema investigado é ESTA máquina.');
+  return lang === 'en'
+    ? `You are a SENIOR DIAGNOSTICIAN. Given a symptom, find the ROOT CAUSE by investigation — never guess a fix blindly.
+${where}
+METHOD each round: pick your single strongest HYPOTHESIS and ONE cheap READ-ONLY probe that would CONFIRM or REFUTE it. Read the probe output next round, then keep or discard the hypothesis and move on. Rank likely causes first (recent changes, environment, config, permissions, resources, data/version, then logic).
+HARD RULES: (1) probe must be READ-ONLY (ldd, strace -f, cat, head, tail, ls, stat, file, readelf, md5sum, ss, ps, grep, find, ldconfig -p, dpkg -l, journalctl, "mysql ... SELECT/SHOW"). NEVER install/rm/mv/chmod/restart/write. (2) Don't repeat a probe already run. (3) A missing library that "exists" often means its OWN dependency is missing — probe the lib itself. (4) Distinguish ENVIRONMENT (missing lib, perm, port, config) from DATA/INTERNAL (version mismatch, corrupt/incompatible file, logic). (5) When the evidence proves the cause, STOP and report it with a concrete fix.
+Reply ONLY with a JSON object, no prose:
+{"thought":"1-2 sentences reasoning from the latest evidence","status":"investigating|solved|stuck","hypothesis":"current leading hypothesis (short)","category":"environment|config|permission|resource|network|data|version|logic|unknown","probe":"ONE read-only shell command (empty if solved/stuck)","expect_if_true":"what in the output confirms it","root_cause":"(only if solved) the confirmed root cause","fix":"(only if solved) the concrete fix — commands/steps","confidence":0}`
+    : `Você é um DIAGNOSTICADOR SÊNIOR. Dado um sintoma, ache a CAUSA RAIZ investigando — nunca chute o conserto às cegas.
+${where}
+MÉTODO por rodada: escolha sua HIPÓTESE mais forte e UMA sonda barata SÓ-LEITURA que a CONFIRME ou REFUTE. Leia a saída na rodada seguinte, mantenha ou descarte a hipótese e siga. Rankeie causas prováveis primeiro (mudanças recentes, ambiente, config, permissões, recursos, dado/versão, e por fim lógica).
+REGRAS DURAS: (1) a sonda tem que ser SÓ-LEITURA (ldd, strace -f, cat, head, tail, ls, stat, file, readelf, md5sum, ss, ps, grep, find, ldconfig -p, dpkg -l, journalctl, "mysql ... SELECT/SHOW"). NUNCA install/rm/mv/chmod/restart/escrever. (2) Não repita uma sonda já feita. (3) Biblioteca "não encontrada" que EXISTE quase sempre é DEPENDÊNCIA-DA-DEPENDÊNCIA faltando — sonde a própria lib. (4) Distinga AMBIENTE (lib faltando, permissão, porta, config) de DADO/INTERNO (mismatch de versão, arquivo corrompido/incompatível, lógica). (5) Quando a evidência provar a causa, PARE e reporte com um conserto concreto.
+Responda SÓ com um objeto JSON, sem prosa:
+{"thought":"raciocínio de 1-2 frases a partir da última evidência","status":"investigating|solved|stuck","hypothesis":"hipótese atual (curta)","category":"environment|config|permission|resource|network|data|version|logic|unknown","probe":"UM comando shell só-leitura (vazio se solved/stuck)","expect_if_true":"o que na saída confirma","root_cause":"(só se solved) a causa raiz confirmada","fix":"(só se solved) o conserto concreto — comandos/passos","confidence":0}`;
+}
+
+function extractJson(s) {
+  const t = String(s || '');
+  const a = t.indexOf('{'); const b = t.lastIndexOf('}');
+  if (a < 0 || b <= a) return null;
+  try { return JSON.parse(t.slice(a, b + 1)); } catch (_) {
+    // tenta reparar aspas/vírgulas comuns
+    try { return JSON.parse(t.slice(a, b + 1).replace(/,\s*}/g, '}').replace(/,\s*]/g, ']')); } catch (_) { return null; }
+  }
+}
+
+async function diagnose(symptom, opts = {}) {
+  const { token, lang = 'pt', model = null, cwd = process.cwd(), target = '', maxRounds = 12, onEvent = () => {} } = opts;
+  const k = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  if (!k || !k.key) throw new ApiError('ai_key', {});
+  const wrap = (probe) => target ? `${target} ${JSON.stringify(probe)}` : probe; // remoto = prefixo ssh + sonda quotada
+
+  const evidence = [];   // { round, hypothesis, probe, output }
+  const seenProbes = new Set();
+  let inTok = 0, outTok = 0;
+  let result = { status: 'stuck', rootCause: '', fix: '', category: 'unknown', evidence, rounds: 0 };
+
+  for (let round = 1; round <= maxRounds; round++) {
+    const evLog = evidence.map(e => `--- Rodada ${e.round} · hipótese: ${e.hypothesis}\n$ ${e.probe}\n${String(e.output).slice(0, 1600)}`).join('\n\n') || '(nenhuma sonda ainda)';
+    const userMsg = (lang === 'en' ? 'SYMPTOM:\n' : 'SINTOMA:\n') + symptom + '\n\n' + (lang === 'en' ? 'EVIDENCE SO FAR:\n' : 'EVIDÊNCIAS ATÉ AGORA:\n') + evLog + '\n\n' + (lang === 'en' ? `Round ${round}/${maxRounds}. Next step as JSON.` : `Rodada ${round}/${maxRounds}. Próximo passo em JSON.`);
+    let r;
+    try {
+      r = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model, noTools: true, signalMs: 90000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: userMsg }] });
+    } catch (e) { if (e.code === 'no_credits') { result.status = 'no_credits'; break; } throw e; }
+    inTok += (r.usage.prompt_tokens || 0); outTok += (r.usage.completion_tokens || 0);
+    const j = extractJson(r.msg.content) || { status: 'stuck', thought: 'resposta não-JSON', probe: '' };
+    result.rounds = round;
+
+    onEvent({ type: 'think', round, hypothesis: j.hypothesis || '', category: j.category || '', thought: j.thought || '', confidence: j.confidence || 0 });
+
+    if (j.status === 'solved' && (j.root_cause || j.fix)) {
+      result = { status: 'solved', rootCause: j.root_cause || j.hypothesis || '', fix: j.fix || '', category: j.category || 'unknown', confidence: j.confidence || 0, evidence, rounds: round };
+      onEvent({ type: 'solved', rootCause: result.rootCause, fix: result.fix, category: result.category });
+      break;
+    }
+    if (j.status === 'stuck' || !j.probe) {
+      result = { status: 'stuck', rootCause: j.root_cause || '', fix: j.fix || '', category: j.category || 'unknown', reason: j.thought || '', evidence, rounds: round };
+      onEvent({ type: 'stuck', reason: j.thought || '' });
+      break;
+    }
+
+    const probe = String(j.probe).trim();
+    if (seenProbes.has(probe)) { onEvent({ type: 'skip', reason: 'sonda repetida', probe }); evidence.push({ round, hypothesis: j.hypothesis || '', probe, output: '(sonda repetida — ignorada; mude de abordagem)' }); continue; }
+    seenProbes.add(probe);
+    if (!isProbe(probe)) { onEvent({ type: 'blocked', probe }); evidence.push({ round, hypothesis: j.hypothesis || '', probe, output: '(BLOQUEADA: sonda não é só-leitura. Investigue sem alterar o sistema.)' }); continue; }
+
+    onEvent({ type: 'probe', round, hypothesis: j.hypothesis || '', probe, expect: j.expect_if_true || '' });
+    let out;
+    try {
+      const ex = await tools.execute('executar_comando', { comando: wrap(probe) }, { baseDir: cwd, token });
+      out = ex.erro ? ('ERRO: ' + ex.erro) : ([ex.stdout, ex.stderr].filter(Boolean).join('\n') || ('(sem saída, exit ' + (ex.codigo ?? '?') + ')'));
+    } catch (e) { out = 'FALHA ao rodar sonda: ' + (e.message || e); }
+    evidence.push({ round, hypothesis: j.hypothesis || '', probe, output: out });
+    onEvent({ type: 'evidence', round, output: String(out).slice(0, 500) });
+  }
+
+  const credits = Math.max(1, Math.round((inTok * 0.15 + outTok * 0.6) / 1000));
+  return { ...result, tokens: { inTok, outTok }, credits };
+}
+
+module.exports = { diagnose, isProbe, _extractJson: extractJson };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.48.0",
+  "version": "0.50.0",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"