@orkastery/cli 0.5.6 → 0.6.0

package/dist/transporte-do-canal.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESTINO_DO_CANAL = exports.HOSTS_DO_CANAL = void 0;
+exports.canalValido = canalValido;
+exports.transporteValido = transporteValido;
+exports.hostDoTransporte = hostDoTransporte;
+exports.transporteDoCanal = transporteDoCanal;
+exports.caminhoDoPulseHost = caminhoDoPulseHost;
+exports.gravarTransporteDoCanal = gravarTransporteDoCanal;
+/**
+ * RM-063 (fatia 3, H3 e H4): o transporte do pulse pronto de cada host, gravado pelo onboarding junto com o canal do dono.
+ *
+ * Incidente de 03 a 12/10/2026 (P1 da pagina da RM-063): sem `pulse-host.json`, o `ork doctor` calava e a maquina ficou
+ * nove dias sem batida e sem aviso. O transporte era um JSON que o dono escrevia a mao, com o executavel e os argumentos
+ * de cada host, e so o do OpenClaw estava pronto num guia. Agora a etapa `maestro` do onboarding aceita o canal do dono
+ * (`canal: { host, destino }`) e grava o `.orkastery/monitor/pulse-host.json` desta maquina com o modelo pronto do host:
+ *
+ *  - `openclaw`: `openclaw message send --channel telegram --target <chat> --message {{mensagem}} --json`;
+ *  - `hermes`: o Python do venv do Hermes com o `ork-pulse-enviar.py` do adaptador e `--target telegram:<chat>[:<topico>]`.
+ *
+ * O canal de um host novo vira o principal, e o do outro host que ja estava fica como alternativo (H4): a entrega tenta o
+ * outro quando o primeiro falha. O arquivo e desta maquina e nunca vai ao git (RM-047).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const procedencia_1 = require("./procedencia");
+const util_1 = require("./util");
+exports.HOSTS_DO_CANAL = ['openclaw', 'hermes'];
+exports.DESTINO_DO_CANAL = /^telegram:(-?\d{1,20})(?::(\d{1,12}))?$/;
+const MARCA = '{' + '{mensagem}}';
+const CHAVES_DO_CANAL = ['host', 'destino', 'executavel', 'script'];
+const caminhoAceito = (v) => typeof v === 'string' && v.length <= 4096 && path.isAbsolute(v) && !/\p{Cc}/u.test(v);
+/** A forma do canal, sem tocar o disco: host conhecido, destino Telegram explicito e caminhos absolutos. */
+function canalValido(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const c = v;
+    if (Object.keys(c).some((k) => !CHAVES_DO_CANAL.includes(k)))
+        return false;
+    if (!exports.HOSTS_DO_CANAL.includes(c.host))
+        return false;
+    if (typeof c.destino !== 'string' || !exports.DESTINO_DO_CANAL.test(c.destino))
+        return false;
+    if (c.executavel !== undefined && !caminhoAceito(c.executavel))
+        return false;
+    if (c.script !== undefined && (c.host !== 'hermes' || !caminhoAceito(c.script)))
+        return false;
+    // O `message send` do OpenClaw recebe o chat; o topico e do transporte do Hermes.
+    if (c.host === 'openclaw' && exports.DESTINO_DO_CANAL.exec(c.destino)?.[2] !== undefined)
+        return false;
+    return true;
+}
+/** Um transporte valido: executavel e argumentos de texto, com `{{mensagem}}` em algum. */
+function transporteValido(t) {
+    const c = t;
+    return !!c && typeof c.executavel === 'string' && !!c.executavel && Array.isArray(c.argumentos) &&
+        c.argumentos.every((a) => typeof a === 'string') && c.argumentos.some((a) => a.includes(MARCA));
+}
+/** O nome do host de um transporte: o declarado, ou o que o executavel e os argumentos dizem. */
+function hostDoTransporte(t) {
+    if (typeof t.host === 'string' && /^[a-z0-9][a-z0-9._-]{0,39}$/i.test(t.host))
+        return t.host;
+    const nomes = [t.executavel, ...t.argumentos].map((a) => path.basename(a)).join(' ');
+    return /openclaw/i.test(nomes) ? 'openclaw' : /hermes|ork-pulse-enviar/i.test(nomes) ? 'hermes' : path.basename(t.executavel).slice(0, 40);
+}
+const executavel = (arquivo) => {
+    try {
+        fs.accessSync(arquivo, fs.constants.X_OK);
+        return fs.statSync(arquivo).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * O transporte pronto do host do canal, com os caminhos desta maquina. Lanca `onboarding.canal.transporte` com a
+ * correcao quando o executavel do host nao esta aqui: o onboarding nao grava um transporte que nunca entrega.
+ */
+function transporteDoCanal(raiz, canal, env = process.env) {
+    const falta = (detalhe) => { throw new Error(`onboarding.canal.transporte: ${detalhe}`); };
+    if (canal.host === 'openclaw') {
+        const bin = canal.executavel ?? (0, util_1.noPath)('openclaw', env);
+        if (!bin || !path.isAbsolute(bin) || !executavel(bin)) {
+            return falta('o openclaw não está no PATH desta máquina; informe canal.executavel com o caminho absoluto dele');
+        }
+        if ((0, procedencia_1.rastreadoPeloGit)(raiz, bin))
+            return falta(`${bin} está versionado no git: o transporte só vale de um arquivo local desta máquina`);
+        const chat = exports.DESTINO_DO_CANAL.exec(canal.destino)[1];
+        return { host: 'openclaw', destino: canal.destino, executavel: bin,
+            argumentos: ['message', 'send', '--channel', 'telegram', '--target', chat, '--message', MARCA, '--json'] };
+    }
+    const casa = (env.HERMES_HOME ?? '').trim() || path.join(os.homedir(), '.hermes');
+    const agente = (env.HERMES_AGENT_DIR ?? '').trim() || path.join(casa, 'hermes-agent');
+    const python = canal.executavel ?? path.join(agente, 'venv', 'bin', 'python3');
+    if (!executavel(python))
+        return falta(`o Python do venv do Hermes não está em ${python}; informe canal.executavel`);
+    const script = canal.script ?? [path.join(casa, 'bin', 'ork-pulse-enviar.py'), path.join((0, estado_thread_1.raizDoEstado)(raiz), '.hermes', 'bin', 'ork-pulse-enviar.py')]
+        .find((s) => fs.existsSync(s));
+    if (!script || !fs.existsSync(script)) {
+        return falta('o ork-pulse-enviar.py do adaptador Hermes não foi achado (ork adapter install hermes); informe canal.script');
+    }
+    // RM-047: o que a entrega executa so vale do arquivo local desta maquina; versionado no git, veio com o repositorio.
+    for (const arquivo of [python, script]) {
+        if ((0, procedencia_1.rastreadoPeloGit)(raiz, arquivo))
+            return falta(`${arquivo} está versionado no git: o transporte só vale de um arquivo local desta máquina`);
+    }
+    return { host: 'hermes', destino: canal.destino, executavel: python, argumentos: [script, '--target', canal.destino, '--message', MARCA] };
+}
+function caminhoDoPulseHost(raiz) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor', 'pulse-host.json');
+}
+/**
+ * Grava o transporte do canal como o principal do `pulse-host.json` desta maquina. O principal de outro host que ja
+ * estava vira alternativo, na frente dos outros; o do mesmo host e trocado. Devolve o arquivo e os hosts alternativos.
+ */
+function gravarTransporteDoCanal(raiz, novo) {
+    const arquivo = caminhoDoPulseHost(raiz);
+    (0, procedencia_1.exigirHostLocal)(raiz, arquivo);
+    let atual = null;
+    try {
+        const lido = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        if (transporteValido(lido))
+            atual = lido;
+    }
+    catch {
+        atual = null;
+    }
+    const host = hostDoTransporte(novo);
+    const alternativos = [];
+    const somar = (t) => {
+        const h = hostDoTransporte(t);
+        if (h !== host && !alternativos.some((a) => hostDoTransporte(a) === h)) {
+            alternativos.push({ ...(t.host ? { host: t.host } : { host: h }), ...(t.destino ? { destino: t.destino } : {}),
+                executavel: t.executavel, argumentos: t.argumentos });
+        }
+    };
+    if (atual) {
+        somar(atual);
+        for (const a of Array.isArray(atual.alternativos) ? atual.alternativos.filter(transporteValido) : [])
+            somar(a);
+    }
+    const conteudo = { ...novo, ...(alternativos.length ? { alternativos } : {}) };
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const temporario = `${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)().slice(0, 8)}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(conteudo, null, 2) + '\n', { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+    return { arquivo, alternativos: alternativos.map(hostDoTransporte) };
+}

package/dist/types.js

@@ -6,7 +6,8 @@
  * Nada aqui depende de LLM; tudo e deterministico e testavel.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIGITO_DA_FASE = exports.FASES = void 0;
+exports.ESTADOS_DE_TRABALHO = exports.DIGITO_DA_FASE = exports.FASES = void 0;
+exports.estadoDeTrabalho = estadoDeTrabalho;
 /** Ordem canonica das fases. */
 exports.FASES = ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER'];
 /** Alias numerico herdado do Devmaster (F1..F6), usado na parte 3 do slug. */
@@ -18,3 +19,13 @@ exports.DIGITO_DA_FASE = {
     SHIP: '5',
     MASTER: '6',
 };
+/**
+ * RM-063 (fatia 3, achado a): os estados crus do runtime que sao trabalho em curso. O `claude agents --json` diz
+ * `working` para a sessao de fundo, e `busy` ou `running` para a interativa que executa um turno: nenhum dos tres e
+ * parada, com ou sem thread.
+ */
+exports.ESTADOS_DE_TRABALHO = ['working', 'busy', 'running'];
+/** O estado cru e trabalho em curso? */
+function estadoDeTrabalho(estado) {
+    return typeof estado === 'string' && exports.ESTADOS_DE_TRABALHO.includes(estado.trim().toLowerCase());
+}

package/dist/util.js

@@ -53,6 +53,8 @@ exports.tabela = tabela;
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+/** Saidas de build e teste podem passar do teto padrao de 1 MiB do `spawnSync`. */
+const MAX_BUFFER_EXEC = 64 * 1024 * 1024;
 /** Executa um comando capturando saida, sem shell (argumentos vao como array). */
 function exec(cmd, args, cwd, timeoutMs = 120000, env = process.env) {
     const r = (0, node_child_process_1.spawnSync)(cmd, args, {
@@ -60,6 +62,7 @@ function exec(cmd, args, cwd, timeoutMs = 120000, env = process.env) {
         encoding: 'utf8',
         timeout: timeoutMs,
         env,
+        maxBuffer: MAX_BUFFER_EXEC,
     });
     return {
         ok: r.status === 0,
@@ -119,7 +122,7 @@ exports.GITIGNORE_DA_MAQUINA = '# Criado pelo ork: esta pasta é da máquina, n
  * nao cria quando o repositorio ja rastreia algo nela: o projeto que versiona o proprio estado segue
  * versionando. Devolve se criou.
  */
-function ignorarPastaNoGit(dir, raizDoRepo) {
+function ignorarPastaNoGit(dir, raizDoRepo, conteudo = exports.GITIGNORE_DA_MAQUINA) {
     const relativo = path.relative(raizDoRepo, dir);
     if (!relativo || relativo.startsWith('..') || path.isAbsolute(relativo))
         return false;
@@ -131,7 +134,7 @@ function ignorarPastaNoGit(dir, raizDoRepo) {
         return false;
     fs.mkdirSync(dir, { recursive: true });
     try {
-        fs.writeFileSync(arquivo, exports.GITIGNORE_DA_MAQUINA, { flag: 'wx' });
+        fs.writeFileSync(arquivo, conteudo, { flag: 'wx' });
     }
     catch {
         return false;