terminal-smart-cli 0.32.0

package/lib/router.js

@@ -0,0 +1,82 @@
+// Roteador de intenção — o coração do "conversa 100% natural": o usuário digita
+// qualquer coisa e o sistema decide o destino. Em CAMADAS pra custar quase nada:
+//   1) heurística determinística (zero tokens, resolve ~85-90%)
+//   2) classificador flash-lite SÓ na dúvida (centavos — mesmo padrão do web-intent)
+// Errar é barato de propósito: agente tem gate de destrutivo, orquestração tem
+// aprovação de plano com custo — o roteador nunca dispara gasto grande sozinho.
+const { api } = require('./api');
+
+// Pergunta/conversa: forma interrogativa ou pedido de explicação
+const Q_RE = /^(como|por ?qu[eê]|o ?que|qual|quais|quando|onde|quem|ser[aá] que|devo|posso|vale a pena|existe|tem como|é melhor|what|how|why|which|when|where|explique|me explica|explica|o que significa|diferen[çc]a entre)\b|\?\s*$/i;
+
+// Verbos de AÇÃO (imperativo) — quem pede ação quer execução, não aula
+const ACT_RE = /\b(cri[ae]|criar|instal[ae]|execut[ae]|rod[ae]|verifi(que|car)|cheque|confira|liber[ae]|limp[ae]|corrij[ae]|consert[ae]|configur[ae]|atualiz[ae]|apag[ue]|remov[ae]|delet[ae]|mov[ae]|renomei[ae]|salv[ae]|baix[ae]|ger[ae]|fa[çc]a|mont[ae]|compil[ae]|test[ae]|reinici[ae]|par[ae] o|sub[ae]|otimiz[ae]|organiz[ae]|analis[ae]|list[ae]|mostr[ae]|abr[ae]|zip[ae]|compact[ae]|extrai[ae]|clon[ae]|comit[ae]|create|install|run|check|fix|clean|delete|remove|generate|make|build|list|show)\b/i;
+
+// Alvos LOCAIS/de sistema — sinal de "faça NESTA máquina"
+const LOCAL_RE = /\b(disco|espa[çc]o|pasta|diret[óo]rio|arquivo|servi[çc]o|processo|porta|mem[óo]ria|cpu|logs?|docker|container|nginx|apache|git|npm|pip|python|node|backup|temp|downloads?|desktop|aqui|nesta m[áa]quina|meu (pc|computador|servidor|not(e|ebook))|vps|sistema|firewall|cron|zip|script|\.txt|\.js|\.py|\.json|\.env|\.log|c:\\|\/var\/|\/etc\/|\/opt\/|\/home\/)\b/i;
+
+// Construção GRANDE multi-entregável (mesma família do _looksBigTask do app)
+const BUILD_RE = /\b(cri[ae]|mont[ae]|desenvolv[ae]|constru[aá]|fa[çc]a (um|uma)|ger[ae]|implement[ae]|prepar[ae]|escrev[ae])\b/i;
+const BIG_RE = /\b(completo|sistema|site|aplicativo|app|kit|painel|plataforma|loja|portal|api|dashboard|landing|portf[óo]lio|apresenta[çc][ãa]o|plano de neg[óo]cio|campanha|e-?book)\b/i;
+
+function heuristic(msg) {
+  const t = String(msg || '').trim();
+  if (!t) return 'chat';
+  const multi = t.length > 150 || (t.match(/,/g) || []).length >= 2 || (t.match(/\d\)/g) || []).length >= 2;
+  const isBigBuild = BUILD_RE.test(t) && BIG_RE.test(t) && multi;
+  // construção grande COM alvo local (pasta/servidor/arquivo) → agente faz AQUI;
+  // sem alvo local → orquestração na nuvem (plano + custo + aprovação)
+  if (isBigBuild) return LOCAL_RE.test(t) ? 'agente' : 'run';
+  // pergunta clara SEM imperativo no começo → conversa
+  if (Q_RE.test(t) && !/^(cri[ae]|instal[ae]|execut[ae]|rod[ae]|fa[çc]a|ger[ae]|mont[ae]|apag[ue]|remov[ae]|corrij[ae]|limp[ae]|liber[ae])\b/i.test(t)) return 'chat';
+  // ação + alvo local → agente
+  if (ACT_RE.test(t) && LOCAL_RE.test(t)) return 'agente';
+  // imperativo logo no começo → agente mesmo sem alvo explícito
+  if (/^(cri[ae]|criar|instal[ae]|execut[ae]|rod[ae]|roda|fa[çc]a|ger[ae]|mont[ae]|salv[ae]|baix[ae]|list[ae]|verifi(que|car)|cheque|limp[ae]|corrij[ae]|configur[ae]|atualiz[ae]|test[ae]|analis[ae]|otimiz[ae]|organiz[ae]|mostr[ae]|abr[ae])\b/i.test(t)) return 'agente';
+  return null; // ambíguo → classificador decide
+}
+
+let _keyCache = null;
+async function _aiKey(token) {
+  if (_keyCache) return _keyCache;
+  _keyCache = await api('/api/ai/key', { token, timeoutMs: 15000 });
+  return _keyCache;
+}
+
+// Classificador flash-lite (só na dúvida). Falhou/estranho → 'chat' (comportamento de hoje).
+async function classify(msg, token) {
+  try {
+    const k = await _aiKey(token);
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 12000);
+    const res = await fetch(String(k.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+      method: 'POST', signal: ctrl.signal,
+      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + k.key },
+      body: JSON.stringify({
+        model: 'gemini-2.5-flash-lite', stream: false, max_completion_tokens: 5,
+        messages: [
+          { role: 'system', content: 'Classifique a intenção da mensagem de um usuário de um CLI DevOps. Responda APENAS uma palavra: "chat" (pergunta, conversa, pedido de explicação), "agente" (quer que algo seja FEITO nesta máquina: comandos, arquivos, diagnóstico, instalação) ou "orquestrar" (objetivo GRANDE com vários entregáveis para uma equipe de agentes).' },
+          { role: 'user', content: String(msg).slice(0, 500) },
+        ],
+      }),
+    });
+    clearTimeout(timer);
+    const j = await res.json().catch(() => null);
+    const word = String(j?.choices?.[0]?.message?.content || '').toLowerCase();
+    // cobra a classificação (mesmo padrão do web-intent) — best-effort
+    const u = j?.usage || {};
+    if (u.prompt_tokens) api('/api/credit/charge', { method: 'POST', token, body: { model: 'gemini-2.5-flash-lite', inTok: u.prompt_tokens || 0, outTok: u.completion_tokens || 0 } }).catch(() => {});
+    if (word.includes('agente')) return 'agente';
+    if (word.includes('orquestrar')) return 'run';
+    return 'chat';
+  } catch (_) { return 'chat'; }
+}
+
+// API principal: destino + por qual camada decidiu (pra linha de transparência)
+async function route(msg, token) {
+  const h = heuristic(msg);
+  if (h) return { dest: h, via: 'heuristica' };
+  return { dest: await classify(msg, token), via: 'ia' };
+}
+
+module.exports = { route, heuristic };

package/lib/skills.js

@@ -0,0 +1,81 @@
+// Galeria de SKILLS da comunidade (MVP): publicar/descobrir/instalar skills via o backend
+// do ts (terminalsmart.com.br /api/skills). Uma skill = pasta com SKILL.md (frontmatter
+// name/description/category + corpo = instruções) + opcional script.(sh|js) + references/.
+// Instalada em ~/.ts/skills/<slug>/. Transparência: o `add` mostra o conteúdo ANTES de gravar.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { api } = require('./api');
+
+const SKILLS_DIR = path.join(os.homedir(), '.ts', 'skills');
+
+async function list(token, q) {
+  const qs = q ? ('?q=' + encodeURIComponent(q)) : '';
+  const r = await api('/api/skills' + qs, { token, timeoutMs: 20000 });
+  return (r && r.skills) || [];
+}
+async function get(token, slug) {
+  const r = await api('/api/skills/' + encodeURIComponent(slug), { token, timeoutMs: 20000 });
+  return r && r.skill;
+}
+async function publish(token, body) {
+  return api('/api/skills', { method: 'POST', token, body, timeoutMs: 30000 });
+}
+function markInstalled(token, slug) {
+  return api('/api/skills/' + encodeURIComponent(slug) + '/install', { method: 'POST', token, timeoutMs: 15000 }).catch(() => {});
+}
+
+// Lê uma skill LOCAL (pasta com SKILL.md OU um .md solto) → { name, description, category, content }.
+// content = { instructions, script:{nome,conteudo}|null, references:[{nome,conteudo}] }
+function readLocal(dir) {
+  let mdPath = dir, base = dir;
+  const st = fs.statSync(dir);
+  if (st.isDirectory()) { mdPath = path.join(dir, 'SKILL.md'); base = dir; }
+  else { base = path.dirname(dir); }
+  if (!fs.existsSync(mdPath)) throw new Error('SKILL.md não encontrado em ' + dir);
+  const raw = fs.readFileSync(mdPath, 'utf8');
+  // frontmatter YAML simples entre --- ... ---
+  const meta = { name: '', description: '', category: 'geral' };
+  let bodyStr = raw;
+  const fm = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (fm) {
+    bodyStr = fm[2];
+    for (const line of fm[1].split('\n')) {
+      const m = line.match(/^(name|description|category|título|titulo)\s*:\s*(.+)$/i);
+      if (m) { const k = m[1].toLowerCase(); meta[k === 'título' || k === 'titulo' ? 'name' : k] = m[2].trim().replace(/^["']|["']$/g, ''); }
+    }
+  }
+  if (!meta.name) meta.name = path.basename(base);
+  // script opcional
+  let script = null;
+  for (const s of ['script.js', 'script.sh', 'run.js', 'run.sh']) {
+    const p = path.join(fs.statSync(dir).isDirectory() ? dir : base, s);
+    if (fs.existsSync(p)) { script = { nome: s, conteudo: fs.readFileSync(p, 'utf8').slice(0, 40000) }; break; }
+  }
+  // references/ opcional
+  const references = [];
+  const refDir = path.join(fs.statSync(dir).isDirectory() ? dir : base, 'references');
+  if (fs.existsSync(refDir)) {
+    for (const f of fs.readdirSync(refDir).slice(0, 20)) {
+      try { const fp = path.join(refDir, f); if (fs.statSync(fp).isFile()) references.push({ nome: f, conteudo: fs.readFileSync(fp, 'utf8').slice(0, 40000) }); } catch (_) {}
+    }
+  }
+  return { name: meta.name, description: meta.description, category: meta.category, content: { instructions: bodyStr.trim().slice(0, 40000), script, references } };
+}
+
+// Grava uma skill baixada em ~/.ts/skills/<slug>/ (SKILL.md + script + references).
+function writeLocal(skill) {
+  const dir = path.join(SKILLS_DIR, skill.slug);
+  fs.mkdirSync(dir, { recursive: true });
+  const c = skill.content || {};
+  const fm = `---\nname: ${skill.name}\ndescription: ${skill.description || ''}\ncategory: ${skill.category || 'geral'}\nautor: ${skill.author || ''}\n---\n\n`;
+  fs.writeFileSync(path.join(dir, 'SKILL.md'), fm + (c.instructions || ''), 'utf8');
+  if (c.script && c.script.nome) fs.writeFileSync(path.join(dir, c.script.nome), c.script.conteudo || '', 'utf8');
+  if (Array.isArray(c.references) && c.references.length) {
+    const rd = path.join(dir, 'references'); fs.mkdirSync(rd, { recursive: true });
+    for (const r of c.references) { if (r && r.nome) fs.writeFileSync(path.join(rd, path.basename(r.nome)), r.conteudo || '', 'utf8'); }
+  }
+  return dir;
+}
+
+module.exports = { list, get, publish, markInstalled, readLocal, writeLocal, SKILLS_DIR };

package/lib/ssh.js

@@ -0,0 +1,93 @@
+// Conexão SSH do ts — permite o agente (e o comando `ts vps`) LOGAR num servidor
+// remoto e rodar comandos lá, da máquina local. Usa ssh2 (senha OU chave privada).
+// Mantém UMA conexão viva por processo (stateful) pra o agente reusar entre passos.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let _conn = null;       // cliente ssh2 conectado
+let _info = null;       // { host, port, user }
+let Client = null;
+try { Client = require('ssh2').Client; } catch (_) { /* ssh2 ausente → erro amigável no connect */ }
+
+// Perfil salvo em ~/.ts/config.json { vps: { host, port, user, pass, keyPath } }
+function _cfgFile() { return path.join(os.homedir(), '.ts', 'config.json'); }
+function loadProfile() {
+  try { const c = JSON.parse(fs.readFileSync(_cfgFile(), 'utf8')); return c.vps || null; } catch (_) { return null; }
+}
+function saveProfile(vps) {
+  const f = _cfgFile();
+  let c = {}; try { c = JSON.parse(fs.readFileSync(f, 'utf8')); } catch (_) {}
+  c.vps = vps;
+  try { fs.mkdirSync(path.dirname(f), { recursive: true }); } catch (_) {}
+  fs.writeFileSync(f, JSON.stringify(c, null, 2));
+}
+
+// Lê um arquivo de login (formato flexível): 1 linha = só senha; 2 linhas = usuário + senha;
+// ou linhas "user:", "senha:", "host:" rotuladas. Retorna {user, pass, host}.
+function parseLoginFile(p) {
+  const t = fs.readFileSync(p, 'utf8');
+  const lines = t.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+  const out = {};
+  for (const l of lines) {
+    const m = l.match(/^(usu[aá]rio|user|login|senha|password|pass|host|ip|servidor)\s*[:=]\s*(.+)$/i);
+    if (m) {
+      const k = m[1].toLowerCase();
+      if (/usu|user|login/.test(k)) out.user = m[2].trim();
+      else if (/senha|pass/.test(k)) out.pass = m[2].trim();
+      else out.host = m[2].trim();
+    }
+  }
+  if (!out.user && !out.pass) {
+    if (lines.length === 1) out.pass = lines[0];
+    else if (lines.length >= 2) { out.user = lines[0]; out.pass = lines[1]; }
+  }
+  return out;
+}
+
+function isConnected() { return !!_conn; }
+function info() { return _info; }
+
+function connect(opts = {}) {
+  return new Promise((resolve, reject) => {
+    if (!Client) return reject(new Error('Biblioteca ssh2 não instalada no CLI.'));
+    const prof = loadProfile() || {};
+    const host = opts.host || prof.host;
+    const port = opts.port || prof.port || 22;
+    const user = opts.user || prof.user || 'root';
+    let password = opts.pass || prof.pass;
+    let privateKey;
+    const keyPath = opts.keyPath || prof.keyPath;
+    if (keyPath) { try { privateKey = fs.readFileSync(keyPath); } catch (_) {} }
+    if (!host) return reject(new Error('Sem host — configure com "ts vps set" ou passe --host.'));
+    if (!password && !privateKey) return reject(new Error('Sem senha nem chave — configure a credencial.'));
+
+    if (_conn) { try { _conn.end(); } catch (_) {} _conn = null; }
+    const c = new Client();
+    const cfg = { host, port, username: user, readyTimeout: 20000, keepaliveInterval: 15000 };
+    if (privateKey) cfg.privateKey = privateKey; else cfg.password = password;
+    c.on('ready', () => { _conn = c; _info = { host, port, user }; resolve({ host, port, user }); });
+    c.on('error', (e) => { _conn = null; reject(new Error('Falha ao conectar: ' + (e && e.message || e))); });
+    c.on('close', () => { if (_conn === c) { _conn = null; _info = null; } });
+    try { c.connect(cfg); } catch (e) { reject(e); }
+  });
+}
+
+// Roda um comando no servidor conectado. Retorna {code, stdout, stderr}.
+function exec(cmd, { timeoutMs = 120000 } = {}) {
+  return new Promise((resolve, reject) => {
+    if (!_conn) return reject(new Error('Não conectado. Rode "ts vps" ou conectar_vps primeiro.'));
+    _conn.exec(cmd, (err, stream) => {
+      if (err) return reject(err);
+      let stdout = '', stderr = '', done = false;
+      const to = setTimeout(() => { if (!done) { done = true; try { stream.close(); } catch (_) {} resolve({ code: 124, stdout, stderr: stderr + '\n[timeout]' }); } }, timeoutMs);
+      stream.on('close', (code) => { if (done) return; done = true; clearTimeout(to); resolve({ code: code == null ? 0 : code, stdout, stderr }); });
+      stream.on('data', (d) => { stdout += d.toString(); if (stdout.length > 200000) stdout = stdout.slice(-120000); });
+      stream.stderr.on('data', (d) => { stderr += d.toString(); if (stderr.length > 60000) stderr = stderr.slice(-40000); });
+    });
+  });
+}
+
+function disconnect() { if (_conn) { try { _conn.end(); } catch (_) {} _conn = null; _info = null; return true; } return false; }
+
+module.exports = { connect, exec, disconnect, isConnected, info, loadProfile, saveProfile, parseLoginFile };