@orkastery/cli 0.5.3 → 0.6.0

package/dist/pulse-delivery.js

@@ -33,11 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RETEM_PARADO_MS = exports.adquirirLockMonitor = void 0;
+exports.FIM_DO_EPISODIO_OCIOSO_MS = exports.RETEM_PARADO_MS = exports.adquirirLockMonitor = void 0;
 exports.assinaturaPulse = assinaturaPulse;
 exports.assinaturaDoResumo = assinaturaDoResumo;
 exports.mensagemPulse = mensagemPulse;
+exports.idsDaEntrega = idsDaEntrega;
+exports.entregarPeloTransporte = entregarPeloTransporte;
 exports.varrerPulse = varrerPulse;
+exports.agirDepoisDaEntrega = agirDepoisDaEntrega;
 exports.varrerEDepoisPublicarNaRede = varrerEDepoisPublicarNaRede;
 exports.enviarPayloadHost = enviarPayloadHost;
 const manifest_1 = require("./manifest");
@@ -50,6 +53,7 @@ const node_crypto_1 = require("node:crypto");
 const node_child_process_1 = require("node:child_process");
 const pulse_1 = require("./pulse");
 const estado_thread_1 = require("./estado-thread");
+const procedencia_1 = require("./procedencia");
 const hitl_1 = require("./hitl");
 const horario_1 = require("./horario");
 const hitl_resumo_1 = require("./hitl-resumo");
@@ -63,11 +67,20 @@ const maquina_1 = require("./maquina");
 const rede_1 = require("./rede");
 const rede_adesao_1 = require("./rede-adesao");
 const pulse_cadencia_1 = require("./pulse-cadencia");
+const conducao_batida_1 = require("./conducao-batida");
+const doctor_pulse_cron_1 = require("./doctor-pulse-cron");
+const transporte_do_canal_1 = require("./transporte-do-canal");
+const ledger_1 = require("./ledger");
 // O lock dos monitores mudou de modulo (I-41, GO-FIX 1); quem o importava daqui continua importando.
 var monitor_lock_2 = require("./monitor-lock");
 Object.defineProperty(exports, "adquirirLockMonitor", { enumerable: true, get: function () { return monitor_lock_2.adquirirLockMonitor; } });
 /** RM-037 (fatia 4): por quanto tempo a parada ja informada continua sabida depois de sumir de uma batida. */
 exports.RETEM_PARADO_MS = 6 * 60 * 60 * 1000;
+/**
+ * RM-063 (F6): o fim de um episodio de maquina ociosa. A marca do alerta fica enquanto ela continua ociosa e por mais
+ * duas batidas depois: a maquina que volta a ficar ociosa depois disso e outro episodio, e o dono e avisado de novo.
+ */
+exports.FIM_DO_EPISODIO_OCIOSO_MS = 30 * 60 * 1000;
 /**
  * I-41 (D9): a assinatura de deduplicacao NAO inclui `apresentacao`.
  *
@@ -113,6 +126,64 @@ function gravarCache(file, vistas) {
     fs.writeFileSync(tmp, JSON.stringify({ versao: 1, vistas }) + '\n', { mode: 0o600 });
     fs.renameSync(tmp, file);
 }
+/** Os ids de mensagem que o transporte imprimiu ao entregar: só inteiros positivos do Telegram, no máximo dez. */
+function idsDaEntrega(saida) {
+    const texto = String(saida ?? '').trim();
+    let j = null;
+    for (const candidato of [texto, texto.split('\n').filter(Boolean).at(-1) ?? '']) {
+        try {
+            j = JSON.parse(candidato);
+            break;
+        }
+        catch {
+            j = null;
+        }
+    }
+    if (!j || typeof j !== 'object' || Array.isArray(j))
+        return [];
+    const o = j;
+    const brutos = [...(Array.isArray(o.message_ids) ? o.message_ids : []), o.message_id, o.messageId];
+    const ids = brutos.map(v => (typeof v === 'number' && Number.isSafeInteger(v) && v > 0) ? String(v)
+        : typeof v === 'string' && /^[1-9][0-9]{0,19}$/.test(v) ? v : null).filter((v) => v !== null);
+    return [...new Set(ids)].slice(0, 10);
+}
+/**
+ * RM-063 (fatia 3, H4): entrega a mensagem pelo transporte do pulse e, quando ele falha, pelos outros hosts configurados
+ * (`alternativos`), na ordem. Cada entrega vai ao `transporte.log` (`transporte_entrega`, com cada tentativa), que o
+ * `ork doctor` le: a falha do principal aparece la mesmo quando o outro host entregou. A mensagem entra como texto:
+ * `$&` e `$'` nela nao sao padrao de substituicao (CHECK da RM-037, fatia 4).
+ */
+function entregarPeloTransporte(raiz, mensagem, opcoes) {
+    const dir = opcoes.dir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+    // RM-047 (P2): o executavel do transporte so sai do arquivo local, nunca de um versionado no git.
+    if (!opcoes.config)
+        (0, procedencia_1.exigirHostLocal)(raiz, path.join(dir, 'pulse-host.json'));
+    const config = opcoes.config ?? JSON.parse(fs.readFileSync(path.join(dir, 'pulse-host.json'), 'utf8'));
+    if (!(0, transporte_do_canal_1.transporteValido)(config))
+        throw new Error('transporte requer executavel e argumentos com {{mensagem}}');
+    const todos = [config, ...(Array.isArray(config.alternativos) ? config.alternativos.filter(transporte_do_canal_1.transporteValido) : [])];
+    const tentativas = [];
+    let entregue = null, mensagens = [];
+    for (const t of todos) {
+        const host = (0, transporte_do_canal_1.hostDoTransporte)(t);
+        const r = (0, node_child_process_1.spawnSync)(t.executavel, t.argumentos.map((a) => a.replaceAll('{{mensagem}}', () => mensagem)), { cwd: raiz, encoding: 'utf8', input: mensagem, timeout: 30000, maxBuffer: 1024 * 1024 });
+        const ok = r.status === 0;
+        tentativas.push({ host, ok, codigo: r.status, detalhe: ok ? '' : (0, hitl_1.redigirSegredos)(`${r.error ? r.error.message : ''} ${r.stderr ?? ''}`)
+                .replace(/\s+/g, ' ').trim().slice(0, 200) });
+        if (ok) {
+            entregue = host;
+            mensagens = idsDaEntrega(r.stdout ?? '');
+            break;
+        }
+    }
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(path.join(dir, doctor_pulse_cron_1.ARQUIVO_DO_TRANSPORTE), JSON.stringify({ ts: opcoes.quando ?? new Date().toISOString(),
+            tipo: 'transporte_entrega', oQue: opcoes.oQue, ok: entregue !== null, host: entregue, tentativas }) + '\n', { mode: 0o600 });
+    }
+    catch { /* o log e do doctor; a entrega vale sem ele */ }
+    return { ok: entregue !== null, host: entregue, tentativas, mensagens };
+}
 /**
  * I-41 (escopo do dono, 20/09 16:5x): a varredura entrega UMA mensagem, nunca uma por item.
  *
@@ -194,41 +265,51 @@ function varrerPulse(opcoes) {
         const chaveDoParado = (p) => `parado:${p.thread}:${p.caso}`;
         for (const p of parados)
             presentes.add(chaveDoParado(p));
+        // RM-063 (F5): o que a varredura fez sozinha, pela autorizacao do dono, e noticia uma vez, como a decisao informada.
+        const feitas = pulse.varredura?.feitas ?? [];
+        const chaveDaFeita = (id) => `varredura:${id}`;
+        for (const f of feitas)
+            presentes.add(chaveDaFeita(f.eventId));
         // A parada que some por uma batida (gh que falhou, um `ork verify` do condutor) e volta nao e noticia
         // nova: a marca fica guardada por `RETEM_PARADO_MS` depois da ultima vez que a parada apareceu.
-        const guardada = (id, valor) => id.startsWith('parado:') &&
-            Date.parse(quando) - Number(valor.split('|')[1]) < exports.RETEM_PARADO_MS;
+        // RM-063 (F6): a maquina ociosa e alerta uma vez por episodio; a marca guarda a ultima vez que ela apareceu ociosa.
+        const ociosa = pulse.maquinaOciosa ?? null;
+        const chaveDaOciosa = ociosa ? `ociosa:${ociosa.maquina}` : null;
+        if (chaveDaOciosa)
+            presentes.add(chaveDaOciosa);
+        const guardada = (id, valor) => (id.startsWith('parado:') &&
+            Date.parse(quando) - Number(valor.split('|')[1]) < exports.RETEM_PARADO_MS) ||
+            (id.startsWith('ociosa:') && Date.parse(quando) - Number(valor.split('|')[1]) < exports.FIM_DO_EPISODIO_OCIOSO_MS);
         vistas = Object.fromEntries(Object.entries(vistas).filter(([id, valor]) => presentes.has(id) || guardada(id, valor)));
         const esperaNovaFora = esperasFora.some(k => vistas[k] === undefined);
         const decisoesNovas = decisoes.filter(d => vistas[chaveDaDecisao(d.id)] === undefined);
+        const feitasNovas = feitas.filter(f => vistas[chaveDaFeita(f.eventId)] === undefined);
         const paradosNovos = parados.filter(p => vistas[chaveDoParado(p)] === undefined);
         // A marca guarda o instante em milissegundos: e dado de maquina, nao texto para o dono.
         for (const p of parados)
             if (vistas[chaveDoParado(p)] !== undefined)
                 vistas[chaveDoParado(p)] = `informada|${Date.parse(quando)}`;
+        const ociosaNova = !!chaveDaOciosa && vistas[chaveDaOciosa] === undefined;
+        if (chaveDaOciosa && !ociosaNova)
+            vistas[chaveDaOciosa] = `informada|${Date.parse(quando)}`;
         // I-41 (GO-FIX 1): a thread que ja recebeu a pergunta e ainda nao respondeu nao e noticia. A
         // mudanca no item dela (o pedido que o sim do dono abriu) e obra nossa, e avisar sobre ela seria
         // mandar ao dono um resumo sobre a pergunta que ele acabou de receber.
         const servidas = (0, pulse_resposta_1.threadsComPerguntaViva)(raiz, quando, dir);
         const jaServida = (i) => !!i.thread && servidas.has(i.thread);
         novas = itens.filter(i => vistas[i.id] !== assinaturaPulse(i) && !jaServida(i)).length;
+        // RM-055 (continuacao, D3): o impedimento que so o dono destrava vai no resumo com o comando de cada um,
+        // e o que ele ainda nao viu sai na hora, como pergunta nova: esperar a janela da cadencia deixava a
+        // fase parada sem ele saber. O ja avisado nao volta a tocar sozinho.
+        const impedimentos = itens.filter(i => i.impedimento && i.thread).map(i => ({ thread: i.thread, fase: i.fase,
+            comando: i.impedimento.comando, retry: i.impedimento.retry }));
+        const impedimentoNovo = itens.some(i => i.impedimento && vistas[i.id] !== assinaturaPulse(i) && !jaServida(i));
         for (const i of itens)
             if (jaServida(i))
                 vistas[i.id] = assinaturaPulse(i);
         const entregar = (mensagem, oQue) => {
-            let entregue;
-            if (opcoes.enviar)
-                entregue = opcoes.enviar(mensagem);
-            else {
-                const config = opcoes.transporte ?? JSON.parse(fs.readFileSync(path.join(dir, 'pulse-host.json'), 'utf8'));
-                if (typeof config.executavel !== 'string' || !config.executavel || !Array.isArray(config.argumentos) ||
-                    !config.argumentos.every(a => typeof a === 'string') || !config.argumentos.some(a => a.includes('{{mensagem}}'))) {
-                    throw new Error('transporte requer executavel e argumentos com {{mensagem}}');
-                }
-                // A mensagem entra como texto: `$&` e `$'` nela nao sao padrao de substituicao (CHECK da RM-037, fatia 4).
-                const r = (0, node_child_process_1.spawnSync)(config.executavel, config.argumentos.map(a => a.replaceAll('{{mensagem}}', () => mensagem)), { cwd: raiz, encoding: 'utf8', input: mensagem, timeout: 30000, maxBuffer: 1024 * 1024 });
-                entregue = r.status === 0;
-            }
+            const entregue = opcoes.enviar ? opcoes.enviar(mensagem)
+                : entregarPeloTransporte(raiz, mensagem, { dir, oQue, quando, ...(opcoes.transporte ? { config: opcoes.transporte } : {}) }).ok;
             if (!entregue)
                 throw new Error(`transporte não confirmou ${oQue}; novidade preservada`);
             enviadas++;
@@ -250,13 +331,22 @@ function varrerPulse(opcoes) {
         // I-50: pergunta nova sai na hora; o resto (status, decisoes informadas) espera a janela da
         // cadencia do dono, e a novidade que esperou continua nao vista ate sair.
         const noPrazo = !opcoes.comCadencia || (0, pulse_cadencia_1.janelaAberta)(cadencia, (0, pulse_cadencia_1.lerUltimoResumo)(opcoes.raiz, dir), quando);
-        const informacaoNova = novas > 0 || decisoesNovas.length > 0 || paradosNovos.length > 0;
-        const adiada = !conjuntoNovo && !esperaNovaFora && informacaoNova && !noPrazo;
-        if (conjuntoNovo || esperaNovaFora || (noPrazo && informacaoNova)) {
+        const informacaoNova = novas > 0 || decisoesNovas.length > 0 || paradosNovos.length > 0 || feitasNovas.length > 0;
+        // RM-063 (F6): a maquina ociosa sai na hora, como a pergunta nova: esperar a janela da cadencia (ate 8 h no
+        // #OrkPulseOff) e exatamente a maquina parada sem o dono saber.
+        const adiada = !conjuntoNovo && !esperaNovaFora && !impedimentoNovo && !ociosaNova && informacaoNova && !noPrazo;
+        if (conjuntoNovo || esperaNovaFora || impedimentoNovo || ociosaNova || (noPrazo && informacaoNova)) {
             const guardadas = anterior ? fila.candidatos.filter(c => anterior.candidatos.some(a => a.thread === c.thread)).length : 0;
             const resumo = (0, hitl_resumo_1.resumirHitl)(itens, { quando, janelaMin, prontas: fila.candidatos.length, acumuladas: guardadas,
                 consertos: fila.consertos, atoDoItem: i => fila.atos.get(`${i.thread}|${i.fase}`),
                 decisoes: decisoesNovas, acimaDoLimiar: pulse.acimaDoLimiar ?? [], outrasMaquinas: outras, paradosNoCondutor: parados,
+                impedimentosDoDono: impedimentos,
+                // RM-063 (F5): o que espera o dono na varredura, com o comando, e o que ela fez sozinha desde o ultimo resumo.
+                acoesDaVarredura: (pulse.varredura?.pendentes ?? []).filter(a => a.quemFaz === 'dono')
+                    .map(a => ({ thread: a.thread, acao: a.acao, texto: (0, pulse_1.textoDaAcaoDaVarredura)(a), comando: (0, pulse_1.comandoDaAcaoDaVarredura)(a) })),
+                feitasPelaVarredura: feitasNovas.map(f => ({ thread: f.thread, acao: f.acao, texto: `${f.acao}: ${f.detalhe}`, comando: null })),
+                maquinaOciosa: ociosa ? { maquina: ociosa.maquina, livres: ociosa.livres, limite: ociosa.limite, reservados: ociosa.reservados,
+                    sugeridas: ociosa.sugeridas.map(x => ({ item: x.item, thread: x.thread, passo: x.passo, comando: x.comando })) } : null,
                 // RM-057 (fatia 3): a linha so acompanha o resumo que ja sai; nao e novidade nem fura a cadencia.
                 ...(pulse.hitlDeConducao ? { hitlDeConducao: pulse.hitlDeConducao } : {}) });
             // Pedir licenca para mandar zero perguntas era o defeito: sem pergunta, nao ha codigo.
@@ -278,6 +368,19 @@ function varrerPulse(opcoes) {
                 vistas[k] = 'informada';
             for (const p of parados)
                 vistas[chaveDoParado(p)] = `informada|${Date.parse(quando)}`;
+            for (const f of feitas)
+                vistas[chaveDaFeita(f.eventId)] = 'informada';
+            if (chaveDaOciosa)
+                vistas[chaveDaOciosa] = `informada|${Date.parse(quando)}`;
+            // RM-063 (F6): o aviso de maquina ociosa vai ao ledger do projeto, uma linha por episodio: e a metrica do item.
+            if (ociosa && ociosaNova) {
+                try {
+                    (0, ledger_1.registrar)(path.join(raiz, '.orkastery'), 'projeto', ledger_1.TIPOS_DE_EVENTO.maquinaOciosaAvisada, { maquina: ociosa.maquina,
+                        livres: ociosa.livres, limite: ociosa.limite, reservados: ociosa.reservados, sugeridas: ociosa.sugeridas.map(x => x.item),
+                        fonte: ociosa.fonte });
+                }
+                catch { /* o aviso ja saiu; o ledger e a metrica */ }
+            }
             (0, pulse_cadencia_1.gravarUltimoResumo)(opcoes.raiz, quando, dir);
         }
         gravarCache(cache, vistas);
@@ -292,6 +395,21 @@ function varrerPulse(opcoes) {
         trava.liberar();
     }
 }
+/**
+ * RM-063 (F5 e F7): a parte que age da batida, depois da entrega ao dono (a busca da base, o merge e o registro do PR nao
+ * atrasam o resumo): a batida da conducao (`ork conducao batida`), com o merge dos PRs prontos, a varredura da F5 e o
+ * despacho da fase seguinte, cada rodada no `hitl.log` (`varredura_acoes`). Uma batida por vez (`varredura-acoes.lock`):
+ * a que chega com outra agindo so registra a vez perdida. Nunca lanca.
+ */
+function agirDepoisDaEntrega(carregado, opcoes = {}) {
+    try {
+        const r = (0, conducao_batida_1.baterConducao)(carregado, opcoes);
+        return r.ocupada ? null : r;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * RM-053: a entrega ao dono vem primeiro, e a rede depois, mesmo quando a varredura falha. M4 do
  * CHECK 1: antes da entrega, uma forja lenta atrasava o HITL em minutos. S13 da revisao 2: sem o
@@ -341,13 +459,22 @@ if (require.main === module) {
         // RM-053 (D9): depois da entrega ao dono, a mesma batida publica o retrato desta maquina na rede da
         // pessoa (so membro, uma tentativa a cada 14 min, retrato igual so de hora em hora).
         const r = varrerEDepoisPublicarNaRede(() => varrerPulse({ raiz, escopo, comCadencia: true, outrasMaquinas }), () => {
+            // RM-063 (F5 e F7): a batida da conducao vem depois da entrega ao dono e antes da rede: com a autorizacao duravel
+            // do dono, mescla o PR pronto, limpa as sessoes fantasmas, registra a entrega do PR ja mesclado, fecha pelo MASTER
+            // por omissao e despacha a fase seguinte; o resumo seguinte diz o que ela fez, e o que ficou sem autorizacao ja
+            // esta na fila do dono. Ela nunca lanca.
             try {
-                const rede = (0, rede_1.publicarRedeNaBatida)({ diretorio: carregado.raiz });
-                if (rede)
-                    (0, rede_adesao_1.registrarNaRede)({ ...rede, origem: 'pulse' });
+                agirDepoisDaEntrega(carregado);
             }
-            catch (e) {
-                (0, rede_adesao_1.registrarNaRede)({ acao: 'falhou', origem: 'pulse', erro: e.message });
+            finally {
+                try {
+                    const rede = (0, rede_1.publicarRedeNaBatida)({ diretorio: carregado.raiz });
+                    if (rede)
+                        (0, rede_adesao_1.registrarNaRede)({ ...rede, origem: 'pulse' });
+                }
+                catch (e) {
+                    (0, rede_adesao_1.registrarNaRede)({ acao: 'falhou', origem: 'pulse', erro: e.message });
+                }
             }
         });
         console.log(JSON.stringify(r));