terminal-smart-cli 0.98.0 → 0.99.0

package/hub/mascara.js

@@ -0,0 +1,67 @@
+'use strict';
+// Máscara de segredos nas telas de terminal, antes de saírem da máquina (exportar-telas) e de
+// novo no hub (defesa em profundidade). É uma rede de segurança, não uma garantia: segredo
+// em formato desconhecido passa. Por isso a lista de janelas exportadas é fechada.
+//
+// Mascara: chaves sk-… / sk-ant-…, tokens do GitHub (ghp_/gho_/ghu_/ghs_/ghr_/github_pat_),
+// chaves da AWS (AKIA…/ASIA…), tokens do Slack (xox…), JWT (eyJ….….…), blocos
+// "-----BEGIN … PRIVATE KEY-----" e senha em URL (usuario:senha@).
+//
+// A tela vem com escapes de cor (SGR) que podem cortar um segredo ao meio. Cada linha é
+// conferida também sem as cores; se o segredo só aparece sem as cores, a linha sai sem cor.
+
+const RX_SGR = /\x1b\[[0-9;:]*m/g;
+const MARCA = '[mascarado]';
+
+const PADROES = [
+  [/sk-ant-[A-Za-z0-9_-]{8,}/g, 'sk-ant-' + MARCA],
+  [/\bsk-[A-Za-z0-9_-]{16,}/g, 'sk-' + MARCA],
+  [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, 'github_pat_' + MARCA],
+  [/\b(gh[pousr]_)[A-Za-z0-9]{20,}/g, '$1' + MARCA],
+  [/\b(AKIA|ASIA)[0-9A-Z]{16}\b/g, '$1' + MARCA],
+  [/\b(xox[abposr]-)[A-Za-z0-9-]{10,}/g, '$1' + MARCA],
+  [/\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}/g, 'jwt-' + MARCA],
+  // esquema://usuario:senha@host → esquema://usuario:[mascarado]@host
+  [/\b([a-z][a-z0-9+.-]{0,30}:\/\/[^\s/:@]{1,256}):[^\s/@]{1,256}@/gi, '$1:' + MARCA + '@'],
+];
+const RX_INICIO_CHAVE = /-----BEGIN [A-Z0-9 ]{0,40}PRIVATE KEY-----/;
+const RX_FIM_CHAVE = /-----END [A-Z0-9 ]{0,40}PRIVATE KEY-----/;
+
+function semCor(s) { return s.replace(RX_SGR, ''); }
+
+function mascararLinha(linha) {
+  let s = linha;
+  for (const [rx, troca] of PADROES) s = s.replace(rx, troca);
+  return s;
+}
+function temSegredo(linha) {
+  return PADROES.some(([rx]) => { rx.lastIndex = 0; const r = rx.test(linha); rx.lastIndex = 0; return r; });
+}
+
+/** Devolve a tela com os segredos conhecidos trocados por "[mascarado]". */
+function mascararSegredos(texto) {
+  const linhas = String(texto).split('\n');
+  let dentroDeChave = false;
+  for (let i = 0; i < linhas.length; i++) {
+    const original = linhas[i];
+    const plana = semCor(original);
+    if (dentroDeChave) {
+      if (RX_FIM_CHAVE.test(plana)) dentroDeChave = false;
+      linhas[i] = RX_FIM_CHAVE.test(plana) ? '-----END PRIVATE KEY-----' : MARCA;
+      continue;
+    }
+    if (RX_INICIO_CHAVE.test(plana)) {
+      // O bloco inteiro some, até o END (ou até o fim da tela, se o END não estiver nela).
+      linhas[i] = plana.slice(0, plana.search(RX_INICIO_CHAVE)) + '-----BEGIN PRIVATE KEY----- ' + MARCA;
+      dentroDeChave = !RX_FIM_CHAVE.test(plana.slice(plana.search(RX_INICIO_CHAVE) + 10));
+      continue;
+    }
+    let m = mascararLinha(original);
+    // Segredo partido por escapes de cor: só aparece no texto sem cor. Sai a linha sem cor.
+    if (temSegredo(semCor(m))) m = mascararLinha(plana);
+    linhas[i] = m;
+  }
+  return linhas.join('\n');
+}
+
+module.exports = { mascararSegredos, MARCA };

package/hub/parar.js

@@ -0,0 +1,151 @@
+'use strict';
+// "Parar tudo" com confirmação real (entrega 1, revisão de segurança).
+//
+// O hub não para nada sozinho: ele grava um PEDIDO num diretório fixo e espera um consumidor
+// externo (na VPS: unidade systemd de root, exemplos em cli/hub/vps/) gravar a CONFIRMAÇÃO.
+// Só com a confirmação o hub responde { parado:true } ao celular; sem ela, no prazo,
+// E_PARAR_SEM_CONFIRMACAO. hub.status/hub.estado refletem a confirmação, nunca o pedido.
+//
+//   <TS_HUB_PARAR_DIR>/
+//     pedidos/        dono = usuário do hub, sem escrita para grupo/outros. O hub cria aqui
+//                     parar-<carimbo ms>-<16 hex>.pedido com O_EXCL (+ O_NOFOLLOW).
+//     confirmacoes/   dono = o consumidor (root, uid 0 por padrão), sem escrita para
+//                     grupo/outros. O consumidor grava parar-<...>.ok (ou .falhou).
+//
+// O consumidor não lê o conteúdo do pedido (só o nome, validado) e o renomeia para fora de
+// pedidos/, então o .path do systemd não dispara em laço. "Religar" = o root apagar os .ok.
+// Nó sem TS_HUB_PARAR_DIR (ex.: o PC na entrega 1) anuncia pararDisponivel:false.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const PEDIDOS = 'pedidos';
+const CONFIRMACOES = 'confirmacoes';
+const RX_BASE = /^parar-\d{13}-[0-9a-f]{16}$/;
+const RX_OK = /^parar-\d{13}-[0-9a-f]{16}\.ok$/;
+const PRAZO_PADRAO_MS = 10000;
+const CONFIRMACOES_MAX_LIDAS = 200;
+
+function erro(codigo) { return Object.assign(new Error(codigo), { codigo }); }
+const dormir = ms => new Promise(r => setTimeout(r, ms));
+
+class Parada {
+  /**
+   * opcoes: { dir (TS_HUB_PARAR_DIR ou null), prazoMs (10 s), sondaMs (100 ms),
+   *           donoUid (dono exigido de confirmacoes/: 0 = root), plataforma, agora }
+   */
+  constructor(opcoes) {
+    const o = opcoes || {};
+    this.dir = o.dir ? path.resolve(String(o.dir)) : null;
+    this.prazoMs = o.prazoMs || PRAZO_PADRAO_MS;
+    this.sondaMs = o.sondaMs || 100;
+    this.plataforma = o.plataforma || process.platform;
+    this.posix = this.plataforma !== 'win32';
+    this.donoUid = Number.isSafeInteger(o.donoUid) ? o.donoUid : 0;
+    this.meuUid = this.posix && typeof process.getuid === 'function' ? process.getuid() : null;
+    this.agora = o.agora || Date.now;
+    this._emCurso = null;
+  }
+
+  get configurado() { return !!this.dir; }
+  get dirPedidos() { return this.dir && path.join(this.dir, PEDIDOS); }
+  get dirConfirmacoes() { return this.dir && path.join(this.dir, CONFIRMACOES); }
+
+  /** Diretório real (sem link), sem escrita para grupo/outros e com o dono esperado. */
+  _dirSeguro(dir, dono) {
+    let st;
+    try { st = fs.lstatSync(dir); } catch (_) { return false; }
+    if (st.isSymbolicLink() || !st.isDirectory()) return false;
+    if (this.posix) {
+      if ((st.mode & 0o022) !== 0) return false;
+      if (dono !== null && st.uid !== dono) return false;
+    }
+    return true;
+  }
+
+  /** Há consumidor configurado e os diretórios estão no lugar, com dono e modo certos. */
+  disponivel() {
+    if (!this.dir) return false;
+    return this._dirSeguro(this.dir, null)
+      && this._dirSeguro(this.dirPedidos, this.meuUid)
+      && this._dirSeguro(this.dirConfirmacoes, this.posix ? this.donoUid : null);
+  }
+
+  /** Arquivo de confirmação válido: regular, não link, dono = consumidor. */
+  _confirmacaoValida(arq) {
+    let st;
+    try { st = fs.lstatSync(arq); } catch (_) { return false; }
+    if (st.isSymbolicLink() || !st.isFile()) return false;
+    if (this.posix && st.uid !== this.donoUid) return false;
+    return true;
+  }
+
+  /** O nó está parado = existe confirmação válida (não basta o pedido). */
+  parado() {
+    if (!this.dir || !this._dirSeguro(this.dirConfirmacoes, this.posix ? this.donoUid : null)) return false;
+    let nomes;
+    try { nomes = fs.readdirSync(this.dirConfirmacoes); } catch (_) { return false; }
+    let lidas = 0;
+    for (const n of nomes) {
+      if (!RX_OK.test(n)) continue;
+      if (++lidas > CONFIRMACOES_MAX_LIDAS) break;
+      if (this._confirmacaoValida(path.join(this.dirConfirmacoes, n))) return true;
+    }
+    return false;
+  }
+
+  /** Grava o pedido sem seguir link e sem sobrescrever nada. Devolve o nome-base. */
+  _gravarPedido() {
+    const base = 'parar-' + String(this.agora()).padStart(13, '0').slice(-13) + '-' + crypto.randomBytes(8).toString('hex');
+    if (!RX_BASE.test(base)) throw erro('E_INTERNO');
+    const c = fs.constants;
+    const arq = path.join(this.dirPedidos, base + '.pedido');
+    // O nome tem 64 bits aleatórios (ninguém planta um link nele de antemão). Ainda assim:
+    // nada pode existir com esse nome (nem link quebrado) — no Windows não há O_NOFOLLOW e o
+    // CREATE_NEW seguiria um link plantado.
+    let existe = true;
+    try { fs.lstatSync(arq); } catch (e) { existe = !(e && e.code === 'ENOENT'); }
+    if (existe) throw erro('E_PARAR_INDISPONIVEL');
+    const flags = c.O_WRONLY | c.O_CREAT | c.O_EXCL | (c.O_NOFOLLOW || 0);
+    const fd = fs.openSync(arq, flags, 0o600);
+    try {
+      // O consumidor não lê isto; serve só para quem olhar o diretório à mão.
+      fs.writeSync(fd, JSON.stringify({ v: 1, por: 'ts hub', origem: 'celular', em: new Date(this.agora()).toISOString() }) + '\n');
+    } finally { fs.closeSync(fd); }
+    return base;
+  }
+
+  /**
+   * Pede a parada e espera a confirmação. Resolve { pedido } com .ok; rejeita com
+   * E_PARAR_INDISPONIVEL (sem consumidor) ou E_PARAR_SEM_CONFIRMACAO (prazo ou .falhou).
+   * Pedidos simultâneos (dois celulares) compartilham a mesma espera.
+   */
+  pedir() {
+    if (this._emCurso) return this._emCurso;
+    const p = this._pedir();
+    this._emCurso = p;
+    const limpar = () => { if (this._emCurso === p) this._emCurso = null; };
+    p.then(limpar, limpar);
+    return p;
+  }
+
+  async _pedir() {
+    if (!this.disponivel()) throw erro('E_PARAR_INDISPONIVEL');
+    let base;
+    try { base = this._gravarPedido(); } catch (e) {
+      throw erro(e && e.codigo ? e.codigo : 'E_PARAR_INDISPONIVEL');
+    }
+    const ok = path.join(this.dirConfirmacoes, base + '.ok');
+    const falhou = path.join(this.dirConfirmacoes, base + '.falhou');
+    const limite = Date.now() + this.prazoMs;
+    for (;;) {
+      if (this._confirmacaoValida(ok)) return { pedido: base };
+      if (this._confirmacaoValida(falhou)) throw erro('E_PARAR_SEM_CONFIRMACAO');
+      if (Date.now() >= limite) throw erro('E_PARAR_SEM_CONFIRMACAO');
+      await dormir(Math.min(this.sondaMs, Math.max(1, limite - Date.now())));
+    }
+  }
+}
+
+module.exports = { Parada, PEDIDOS, CONFIRMACOES, RX_BASE, PRAZO_PADRAO_MS };

package/hub/principal.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+'use strict';
+// Ponto de entrada só do hub (instalação mínima na VPS, sem o resto do cli):
+//   node /opt/ts-hub/hub/principal.js <subcomando>   ==   ts hub <subcomando>
+require('./cli').main(process.argv.slice(2));