terminal-smart-cli 0.98.0 → 0.99.0

package/hub/estado.js

@@ -0,0 +1,274 @@
+'use strict';
+// Estado em disco do `ts hub`: diretório privado, chave do nó, lista de aparelhos e auditoria.
+//
+//   <TS_HUB_DIR>/                 0700
+//     no-chave.json               0600  chave do nó (Windows: PKCS#8 cifrado com DPAPI)
+//     aparelhos.json              0600  aparelhos autorizados + versão da lista publicada
+//     lista-versao.json           0600  cópia da maior versão publicada (fora do aparelhos.json)
+//     revogados.jsonl             0600  revogações (só acrescenta): ID + instante
+//     auditoria.jsonl             0600  comando, aparelho, resultado (nunca chave nem tela)
+//     controle.json               0600  endereço do controle local + ficha (só o mesmo usuário)
+//     controle.sock               0600  (Linux) socket do controle local
+//
+// No Windows o modo 0600/0700 não vale nada: a proteção é a ACL herdada do perfil do usuário
+// e, para a chave, o DPAPI.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const P = require('./proto/ts-proto.js');
+
+const POSIX = process.platform !== 'win32';
+const AUDITORIA_MAX = 5 * 1024 * 1024;
+
+function dirPadrao() {
+  return process.env.TS_HUB_DIR || path.join(os.homedir(), '.ts', 'hub');
+}
+
+/** Cria o diretório com 0700 e corrige o modo se alguém o abriu. */
+function garantirDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (POSIX) {
+    const st = fs.statSync(dir);
+    if ((st.mode & 0o077) !== 0) fs.chmodSync(dir, 0o700);
+  }
+}
+
+function nomeTemporario(arq) {
+  return arq + '.' + crypto.randomBytes(6).toString('hex') + '.tmp';
+}
+
+/** Grava com 0600 de forma atômica (temporário + rename). */
+function gravarPrivado(arq, conteudo) {
+  const tmp = nomeTemporario(arq);
+  try {
+    fs.writeFileSync(tmp, conteudo, { mode: 0o600, flag: 'wx' });
+    if (POSIX) fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, arq);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+}
+
+/** Grava só se o arquivo ainda não existe (devolve false se outro processo chegou antes). */
+function criarPrivadoExclusivo(arq, conteudo) {
+  const tmp = nomeTemporario(arq);
+  fs.writeFileSync(tmp, conteudo, { mode: 0o600, flag: 'wx' });
+  try {
+    if (POSIX) fs.chmodSync(tmp, 0o600);
+    fs.linkSync(tmp, arq);
+    return true;
+  } catch (e) {
+    if (e.code === 'EEXIST') return false;
+    throw e;
+  } finally {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+  }
+}
+
+/** Avisa e corrige arquivo privado que ficou legível por outros (só POSIX). */
+function corrigirModo(arq, avisar) {
+  if (!POSIX) return;
+  const st = fs.statSync(arq);
+  if ((st.mode & 0o077) !== 0) {
+    fs.chmodSync(arq, 0o600);
+    if (avisar) avisar('permissão de ' + path.basename(arq) + ' estava aberta; corrigida para 0600');
+  }
+}
+
+function lerJson(arq) {
+  return JSON.parse(fs.readFileSync(arq, 'utf8'));
+}
+
+// ─── Chave do nó ────────────────────────────────────────────────────────────────────────────
+
+function protetorPadrao() {
+  return process.platform === 'win32' ? require('./dpapi').dpapi : null;
+}
+
+/**
+ * Carrega a identidade do nó ou gera na primeira vez.
+ * `protetor`: { nome, proteger(bytes), abrir(bytes) } (DPAPI no Windows) ou null (arquivo 0600).
+ */
+async function carregarOuCriarIdentidade(dir, opcoes) {
+  const o = opcoes || {};
+  const protetor = o.protetor === undefined ? protetorPadrao() : o.protetor;
+  const arq = path.join(dir, 'no-chave.json');
+
+  const carregar = async () => {
+    corrigirModo(arq, o.avisar);
+    const j = lerJson(arq);
+    if (!j || j.v !== 1 || typeof j.spki !== 'string') throw new Error('arquivo da chave do nó inválido');
+    let dados;
+    if (j.protecao === 'arquivo') {
+      dados = { pkcs8: j.pkcs8, spki: j.spki };
+    } else if (typeof j.protecao === 'string' && typeof j.dados === 'string') {
+      if (!protetor || protetor.nome !== j.protecao) throw new Error('a chave do nó está protegida com "' + j.protecao + '", indisponível aqui');
+      const claro = await protetor.abrir(Buffer.from(String(j.dados), 'base64'));
+      try { dados = JSON.parse(claro.toString('utf8')); } finally { claro.fill(0); }
+    }
+    if (!dados) {
+      throw new Error('proteção da chave do nó desconhecida');
+    }
+    const ident = await P.importarIdentidadeNo(dados);
+    if (ident.spkiB64 !== j.spki) throw new Error('chave do nó não confere com a pública gravada');
+    return ident;
+  };
+
+  if (fs.existsSync(arq)) return { identidade: await carregar(), criada: false };
+
+  const ident = await P.gerarIdentidade({ tipo: 'no' });
+  const exp = await P.exportarIdentidadeNo(ident);
+  let registro;
+  if (protetor) {
+    const claro = Buffer.from(JSON.stringify(exp), 'utf8');
+    try {
+      const blob = await protetor.proteger(claro);
+      registro = { v: 1, protecao: protetor.nome, spki: exp.spki, dados: Buffer.from(blob).toString('base64') };
+    } finally { claro.fill(0); }
+  } else {
+    registro = { v: 1, protecao: 'arquivo', spki: exp.spki, pkcs8: exp.pkcs8 };
+  }
+  if (!criarPrivadoExclusivo(arq, JSON.stringify(registro) + '\n')) {
+    // Outro processo gerou ao mesmo tempo: vale a dele.
+    return { identidade: await carregar(), criada: false };
+  }
+  return { identidade: ident, criada: true };
+}
+
+// ─── Aparelhos autorizados ──────────────────────────────────────────────────────────────────
+
+const RX_ID = /^[A-Za-z0-9_-]{22}$/;
+
+/**
+ * Aparelhos autorizados. Restaurar um backup antigo de aparelhos.json traria de volta um
+ * aparelho já revogado; por isso a revogação também fica em revogados.jsonl (só acrescenta) e
+ * a maior versão da lista em lista-versao.json, os dois FORA do aparelhos.json. Ao carregar:
+ * aparelho revogado depois do próprio pareamento continua fora, e uma lista mais velha que a
+ * última publicada é sinalizada (`restauradoDeBackup`). Quem restaura o diretório inteiro
+ * desfaz isso também: é proteção contra restauração parcial/acidental, não contra quem
+ * controla o disco (PROTOCOLO §12).
+ */
+class Aparelhos {
+  constructor(dir) {
+    this.dir = dir;
+    this.arq = path.join(dir, 'aparelhos.json');
+    this.arqVersao = path.join(dir, 'lista-versao.json');
+    this.arqRevogados = path.join(dir, 'revogados.jsonl');
+    this.versaoLista = 0;
+    this.restauradoDeBackup = false;
+    this.mantidosRevogados = [];
+    this._mapa = new Map();
+  }
+
+  /** Revogações gravadas: Map(id → instante ms da revogação mais recente). */
+  _lerRevogados() {
+    const m = new Map();
+    let texto = '';
+    try { texto = fs.readFileSync(this.arqRevogados, 'utf8'); } catch (_) { return m; }
+    for (const linha of texto.split('\n')) {
+      if (!linha.trim()) continue;
+      let r;
+      try { r = JSON.parse(linha); } catch (_) { continue; }
+      if (r && RX_ID.test(r.id) && Number.isSafeInteger(r.em)) m.set(r.id, Math.max(m.get(r.id) || 0, r.em));
+    }
+    return m;
+  }
+
+  registrarRevogacao(id, em) {
+    fs.appendFileSync(this.arqRevogados, JSON.stringify({ id, em: em || Date.now() }) + '\n', { mode: 0o600 });
+  }
+
+  async carregar(avisar) {
+    let externa = 0;
+    try {
+      const v = lerJson(this.arqVersao);
+      if (v && Number.isSafeInteger(v.versao)) externa = v.versao;
+    } catch (_) { /* sem cópia externa ainda */ }
+    if (!fs.existsSync(this.arq)) {
+      if (externa > 0) { this.restauradoDeBackup = true; this.versaoLista = externa; if (avisar) avisar('aparelhos.json sumiu, mas já houve lista publicada (versão ' + externa + ')'); }
+      return this;
+    }
+    corrigirModo(this.arq, avisar);
+    const j = lerJson(this.arq);
+    if (!j || j.v !== 1 || !Array.isArray(j.aparelhos) || !Number.isSafeInteger(j.versaoLista)) {
+      throw new Error('aparelhos.json inválido');
+    }
+    this.versaoLista = j.versaoLista;
+    for (const a of j.aparelhos) {
+      if (!a || !RX_ID.test(a.id) || typeof a.spki !== 'string') throw new Error('aparelhos.json inválido');
+      if ((await P.idDeSpki(P.deB64u(a.spki))) !== a.id) throw new Error('aparelhos.json inválido');
+      this._mapa.set(a.id, {
+        id: a.id, spki: a.spki, nome: String(a.nome || ''), impressao: String(a.impressao || ''),
+        pareadoEm: String(a.pareadoEm || ''),
+      });
+    }
+    // Revogado depois do próprio pareamento continua revogado (backup antigo não o traz de volta).
+    const revogados = this._lerRevogados();
+    for (const [id, em] of revogados) {
+      const a = this._mapa.get(id);
+      if (!a) continue;
+      const pareado = Date.parse(a.pareadoEm);
+      if (!Number.isFinite(pareado) || pareado <= em) { this._mapa.delete(id); this.mantidosRevogados.push(id); }
+    }
+    if (externa > this.versaoLista) {
+      this.restauradoDeBackup = true;
+      this.versaoLista = externa;   // a versão publicada nunca anda para trás
+    }
+    if ((this.restauradoDeBackup || this.mantidosRevogados.length) && avisar) {
+      avisar('aparelhos.json mais velho que o estado gravado (backup restaurado?): ' + this.mantidosRevogados.length + ' aparelho(s) revogado(s) continuam revogados');
+    }
+    if (this.mantidosRevogados.length) this.salvar();
+    return this;
+  }
+
+  salvar() {
+    const aparelhos = Array.from(this._mapa.values()).sort((x, y) => (x.id < y.id ? -1 : x.id > y.id ? 1 : 0));
+    gravarPrivado(this.arq, JSON.stringify({ v: 1, versaoLista: this.versaoLista, aparelhos }, null, 2) + '\n');
+    gravarPrivado(this.arqVersao, JSON.stringify({ v: 1, versao: this.versaoLista }) + '\n');
+  }
+
+  get tamanho() { return this._mapa.size; }
+  tem(id) { return typeof id === 'string' && this._mapa.has(id); }
+  spki(id) { const a = typeof id === 'string' ? this._mapa.get(id) : undefined; return a ? a.spki : undefined; }
+  obter(id) { return this._mapa.get(id); }
+  lista() { return Array.from(this._mapa.values()).sort((x, y) => (x.id < y.id ? -1 : x.id > y.id ? 1 : 0)); }
+  adicionar(a) { this._mapa.set(a.id, Object.assign({}, a)); }
+  remover(id) { return this._mapa.delete(id); }
+}
+
+// ─── Auditoria ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Uma linha JSON por evento. Campos permitidos: tipo, metodo, aparelho, resultado.
+ * Nunca chaves, URL de convite, parâmetros livres nem conteúdo de tela.
+ */
+function criarAuditoria(dir) {
+  const arq = path.join(dir, 'auditoria.jsonl');
+  return function auditar(ev) {
+    const linha = { em: new Date().toISOString(), tipo: String(ev.tipo || '') };
+    if (ev.metodo !== undefined) linha.metodo = ev.metodo === null ? null : String(ev.metodo).slice(0, 64);
+    if (ev.aparelho !== undefined) linha.aparelho = RX_ID.test(String(ev.aparelho)) ? ev.aparelho : null;
+    if (ev.resultado !== undefined) linha.resultado = String(ev.resultado).slice(0, 48);
+    try {
+      try {
+        if (fs.statSync(arq).size > AUDITORIA_MAX) fs.renameSync(arq, path.join(dir, 'auditoria.1.jsonl'));
+      } catch (_) {}
+      fs.appendFileSync(arq, JSON.stringify(linha) + '\n', { mode: 0o600 });
+    } catch (_) { /* auditoria nunca derruba o hub */ }
+  };
+}
+
+module.exports = {
+  POSIX,
+  dirPadrao,
+  garantirDir,
+  gravarPrivado,
+  corrigirModo,
+  lerJson,
+  carregarOuCriarIdentidade,
+  Aparelhos,
+  criarAuditoria,
+};

package/hub/exportar-telas.js

@@ -0,0 +1,149 @@
+'use strict';
+// `ts hub exportar-telas`: lê o tmux dos agentes e grava instantâneos para o hub ler.
+//
+// Roda como o USUÁRIO DOS AGENTES (quem já enxerga o tmux), nunca como o hub. Assim o hub não
+// tem acesso ao tmux: só lê arquivos prontos (hub/telas-arquivo.js).
+//
+//   - tmux por execFile, sem shell, sempre no servidor dedicado `-L ts`;
+//   - só janelas da lista permitida (TS_HUB_TELAS_PERMITIDAS: "sessao:janela" ou "sessao:*",
+//     separados por vírgula; sem lista, nada é exportado);
+//   - histórico de no máximo 200 linhas (TS_HUB_TELAS_HISTORICO, padrão 200);
+//   - só SGR sobrevive (sanitizarTela) e os segredos conhecidos são mascarados;
+//   - gravação atômica (temporário + rename), índice por último, telas velhas apagadas.
+//
+// Variáveis: TS_HUB_TELAS_DIR (obrigatória), TS_HUB_TELAS_PERMITIDAS (obrigatória),
+// TS_HUB_TELAS_HISTORICO (0–200), TS_HUB_TELAS_INTERVALO_MS (padrão 1000, mínimo 250).
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const P = require('./proto/ts-proto.js');
+const T = require('./tmux');
+const { mascararSegredos } = require('./mascara');
+const { INDICE, arquivoTela, RX_ID, TELA_ARQUIVO_MAX } = require('./telas-arquivo');
+
+const RX_ENTRADA = /^[^:,\s][^:,]{0,79}:(\*|[^,]{1,80})$/;
+const TELA_BYTES_MAX = Math.min(256 * 1024, TELA_ARQUIVO_MAX - 4096);
+
+function erroConfig(msg) { return Object.assign(new Error(msg), { codigo: 'E_CONFIG' }); }
+
+/** "agentes:claude, agentes:*" → [{ sessao, janela|null }]. Lança em entrada malformada. */
+function lerPermitidas(texto) {
+  if (typeof texto !== 'string' || !texto.trim()) return [];
+  const out = [];
+  for (const parte of texto.split(',')) {
+    const e = parte.trim();
+    if (!e) continue;
+    if (!RX_ENTRADA.test(e)) throw erroConfig('TS_HUB_TELAS_PERMITIDAS: entrada inválida (use sessao:janela ou sessao:*)');
+    const i = e.indexOf(':');
+    const janela = e.slice(i + 1);
+    out.push({ sessao: e.slice(0, i), janela: janela === '*' ? null : janela });
+  }
+  return out;
+}
+
+function permitida(lista, t) {
+  return lista.some(p => p.sessao === t.sessao && (p.janela === null || p.janela === t.janela));
+}
+
+function lerConfig(env) {
+  const e = env || process.env;
+  const dir = (e.TS_HUB_TELAS_DIR || '').trim();
+  if (!dir) throw erroConfig('defina TS_HUB_TELAS_DIR (diretório dos instantâneos que o hub lê)');
+  const permitidas = lerPermitidas(e.TS_HUB_TELAS_PERMITIDAS);
+  if (!permitidas.length) throw erroConfig('defina TS_HUB_TELAS_PERMITIDAS (ex.: agentes:claude,agentes:codex); sem lista nada é exportado');
+  let historico = P.LIMITES.HISTORICO_MAX;
+  if (e.TS_HUB_TELAS_HISTORICO !== undefined && e.TS_HUB_TELAS_HISTORICO !== '') {
+    historico = Number(e.TS_HUB_TELAS_HISTORICO);
+    if (!Number.isSafeInteger(historico) || historico < 0 || historico > P.LIMITES.HISTORICO_MAX) {
+      throw erroConfig('TS_HUB_TELAS_HISTORICO deve ser um inteiro de 0 a ' + P.LIMITES.HISTORICO_MAX);
+    }
+  }
+  let intervaloMs = 1000;
+  if (e.TS_HUB_TELAS_INTERVALO_MS) {
+    intervaloMs = Number(e.TS_HUB_TELAS_INTERVALO_MS);
+    if (!Number.isSafeInteger(intervaloMs) || intervaloMs < 250 || intervaloMs > 60000) throw erroConfig('TS_HUB_TELAS_INTERVALO_MS deve ser de 250 a 60000');
+  }
+  return { dir: path.resolve(dir), permitidas, historico, intervaloMs };
+}
+
+function garantirDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o750 });
+  const st = fs.lstatSync(dir);
+  if (st.isSymbolicLink() || !st.isDirectory()) throw erroConfig('TS_HUB_TELAS_DIR não pode ser link simbólico');
+}
+
+/** Grava atômico: temporário exclusivo no mesmo diretório + rename (nunca segue link). */
+function gravarAtomico(dir, nome, conteudo) {
+  const tmp = path.join(dir, '.tmp-' + crypto.randomBytes(8).toString('hex'));
+  try {
+    fs.writeFileSync(tmp, conteudo, { mode: 0o640, flag: 'wx' });
+    fs.renameSync(tmp, path.join(dir, nome));
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+}
+
+/** Tela pronta para sair da máquina: só SGR, segredos mascarados, tamanho limitado. */
+function prepararTela(bruta) {
+  const limpa = mascararSegredos(T.sanitizarTela(bruta));
+  return T.cortarTela(limpa, t => Buffer.byteLength(t, 'utf8') <= TELA_BYTES_MAX);
+}
+
+/**
+ * Uma passada. opcoes: { dir, permitidas, historico, executar?, agora? }.
+ * Devolve { exportados: [terminalId], removidos: n }.
+ */
+async function exportarUmaVez(opcoes) {
+  const o = opcoes;
+  const executar = o.executar || T.executorPadrao;
+  const agora = o.agora || Date.now;
+  const historico = Math.max(0, Math.min(P.LIMITES.HISTORICO_MAX, o.historico === undefined ? P.LIMITES.HISTORICO_MAX : o.historico));
+  const tmux = args => executar('tmux', ['-u', '-L', T.SOCKET_TMUX].concat(args));
+  garantirDir(o.dir);
+
+  let lista = [];
+  try { lista = T.analisarLista(await tmux(['list-panes', '-a', '-F', T.FORMATO])); } catch (_) { lista = []; }
+  const escolhidos = lista.filter(t => RX_ID.test(t.terminalId) && T.RX_TERMINAL_TMUX.test(t.terminalId) && permitida(o.permitidas, t)).slice(0, 100);
+
+  const indice = [];
+  for (const t of escolhidos) {
+    let bruta;
+    try {
+      bruta = await tmux(['capture-pane', '-p', '-e', '-J', '-t', '%' + t.terminalId.slice(1), '-S', '-' + historico]);
+    } catch (_) { continue; }
+    const registro = {
+      v: 1, terminalId: t.terminalId, colunas: t.colunas, linhas: t.linhas, historico, geradoEm: agora(), tela: prepararTela(bruta),
+    };
+    gravarAtomico(o.dir, arquivoTela(t.terminalId), JSON.stringify(registro) + '\n');
+    indice.push({ terminalId: t.terminalId, titulo: t.titulo, ativo: t.ativo, colunas: t.colunas, linhas: t.linhas });
+  }
+  gravarAtomico(o.dir, INDICE, JSON.stringify({ v: 1, geradoEm: agora(), terminais: indice }) + '\n');
+
+  // Telas de terminais que sumiram (ou saíram da lista permitida) não ficam para trás.
+  const atuais = new Set(indice.map(t => arquivoTela(t.terminalId)));
+  let removidos = 0;
+  for (const n of fs.readdirSync(o.dir)) {
+    if (/^tela-[A-Za-z0-9_-]{1,64}\.json$/.test(n) && !atuais.has(n)) {
+      try { fs.unlinkSync(path.join(o.dir, n)); removidos++; } catch (_) {}
+    } else if (/^\.tmp-[0-9a-f]{16}$/.test(n)) {
+      try { if (agora() - fs.lstatSync(path.join(o.dir, n)).mtimeMs > 60000) fs.unlinkSync(path.join(o.dir, n)); } catch (_) {}
+    }
+  }
+  return { exportados: indice.map(t => t.terminalId), removidos };
+}
+
+/** Laço contínuo até `sinal.parar` (ou SIGINT/SIGTERM no processo de verdade). */
+async function exportarTelas(opcoes) {
+  const o = opcoes;
+  const sinal = o.sinal || { parar: false };
+  for (;;) {
+    try { await exportarUmaVez(o); } catch (e) { if (o.log) o.log('falha ao exportar (' + (e.codigo || e.code || 'erro') + ')'); }
+    if (sinal.parar) return;
+    await new Promise(r => setTimeout(r, o.intervaloMs || 1000));
+    if (sinal.parar) return;
+  }
+}
+
+module.exports = { exportarUmaVez, exportarTelas, lerConfig, lerPermitidas, prepararTela };