@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-rede.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRATO_REDE_DO_ARCO = void 0;
+exports.lerRede = lerRede;
+exports.coordenacaoDaFila = coordenacaoDaFila;
+const maquina_1 = require("./maquina");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_coordenacao_1 = require("./noctum-coordenacao");
+const noctum_envelope_1 = require("./noctum-envelope");
+exports.CONTRATO_REDE_DO_ARCO = 'ork.noctum-rede/v1';
+const consumoVazio = () => ({ arco: 0, porConta: {}, porRuntime: {} });
+function vazia(arco, maquina, multimaquina, envelopeSha256, lidaEm, lacuna) {
+    return { contrato: exports.CONTRATO_REDE_DO_ARCO, arco, multimaquina, maquina, envelopeSha256, lidaEm, autoridade: null, revogada: null,
+        maquinas: [], trabalhos: [], consumo: consumoVazio(), obrigacoes: { ordens: [], vagas: [], vezes: [] }, lacuna };
+}
+function ordemProjetada(o) {
+    return { ordem: o.ordem, numero: o.n, maquina: o.maquina, estado: o.estado, emitidaEm: o.emitidaEm };
+}
+function projetar(estado, maquina, quando) {
+    const conteudo = estado.vigente.conteudo;
+    if (!(0, noctum_envelope_1.envelopeMultimaquina)(conteudo))
+        return vazia(estado.arco, maquina, false, estado.vigente.envelopeSha256, estado.lidoEm, null);
+    const vezes = [...estado.vezes.values()].flat();
+    const maquinas = conteudo.maquinas.map(({ nome }) => ({
+        nome,
+        ultimoSinal: estado.sinais.get(nome) ?? null,
+        sinalRecente: (0, noctum_coordenacao_1.batidaRecente)(estado, nome, maquina, quando),
+        ordensVivas: [...estado.ordens.values()].filter(o => o.maquina === nome && (0, noctum_coordenacao_1.ordemViva)(o)).map(o => o.ordem).sort(),
+        vagasAtivas: estado.vagas.filter(v => v.maquina === nome && !v.solta).map(v => v.vaga).sort(),
+        vezesAtivas: vezes.filter(v => v.maquina === nome && !v.fim).map(v => `${v.chave}/${v.n}`).sort(),
+        consumo: estado.vagas.filter(v => v.maquina === nome && (!v.solta || v.solta.consumiu)).length,
+    }));
+    const trabalhos = conteudo.trabalhos.map(t => {
+        const situacao = estado.trabalhos.get(t.id);
+        const ordem = situacao.ordem ? ordemProjetada(situacao.ordem) : null;
+        const registro = estado.entregas.get(t.id);
+        const entrega = registro ? { em: registro.em, maquina: registro.por, merge: String(registro.merge) } : null;
+        return { id: t.id, estado: situacao.estado, maquina: ordem?.maquina ?? null, ordem, maquinaPresa: t.maquina ?? null, entrega };
+    });
+    return {
+        contrato: exports.CONTRATO_REDE_DO_ARCO,
+        arco: estado.arco,
+        multimaquina: true,
+        maquina,
+        envelopeSha256: estado.vigente.envelopeSha256,
+        lidaEm: estado.lidoEm,
+        autoridade: estado.autoridade ? { maquina: estado.autoridade.maquina, geracao: estado.autoridade.geracao, desde: estado.autoridade.desde } : null,
+        revogada: estado.revogada,
+        maquinas,
+        trabalhos,
+        consumo: estado.consumo,
+        obrigacoes: {
+            ordens: [...estado.ordens.values()].filter(o => o.maquina === maquina && (0, noctum_coordenacao_1.ordemViva)(o)).map(o => o.ordem).sort(),
+            vagas: estado.vagas.filter(v => v.maquina === maquina && !v.solta).map(v => v.vaga).sort(),
+            vezes: vezes.filter(v => v.maquina === maquina && !v.fim).map(v => `${v.chave}/${v.n}`).sort(),
+        },
+        lacuna: null,
+    };
+}
+/** Lê a rede de um v3. Em v1/v2 não toca o remoto; recusa tipada vira lacuna, sem inventar estado. */
+function lerRede(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const maquina = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    const local = (0, noctum_arco_1.lerArco)(carregado.raiz, arco, quando);
+    if (!local?.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(local.conteudo)) {
+        return vazia(arco, maquina, false, local?.envelopeSha256 ?? null, quando, null);
+    }
+    try {
+        return projetar((0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando }), maquina, quando);
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+        return vazia(arco, maquina, true, local.envelopeSha256, quando, { motivo: e.motivo, detalhe: e.message });
+    }
+}
+/** Adapta a projeção íntegra para a fila. Rede local ou ilegível não vira coordenação vazia. */
+function coordenacaoDaFila(rede) {
+    if (!rede.multimaquina || rede.lacuna)
+        return null;
+    const trabalhos = new Set();
+    const entregues = new Map();
+    const encerrados = new Set();
+    const emOutraMaquina = new Set();
+    const ordens = new Map();
+    for (const t of rede.trabalhos) {
+        if (t.entrega)
+            entregues.set(t.id, t.entrega.em);
+        else if (t.estado === 'entregue')
+            entregues.set(t.id, t.ordem?.emitidaEm ?? rede.lidaEm);
+        if (t.estado === 'encerrado')
+            encerrados.add(t.id);
+        if (t.ordem?.maquina === rede.maquina && t.ordem.estado === 'aceita') {
+            trabalhos.add(t.id);
+            ordens.set(t.id, { ordem: t.ordem.ordem, numero: t.ordem.numero });
+        }
+        else if (t.ordem && ['emitida', 'aceita', 'isolada'].includes(t.ordem.estado) && t.ordem.maquina !== rede.maquina) {
+            emOutraMaquina.add(t.id);
+        }
+    }
+    return { trabalhos, entregues, encerrados, emOutraMaquina, ordens };
+}

package/dist/noctum-registro.js

@@ -0,0 +1,215 @@
+"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.RecusaDoRegistro = exports.MOTIVOS_DO_REGISTRO = exports.contratoDoRegistro = exports.DOMINIOS_DO_REGISTRO = void 0;
+exports.pastaDoArco = pastaDoArco;
+exports.lerRegistro = lerRegistro;
+exports.comRegistro = comRegistro;
+/**
+ * RM-058, fatia N6 (D7 da ork-rm058n6): o registro da N6 ao lado do log do arco.
+ *
+ * O fechamento e o relatório da manhã guardam o que fizeram em logs de acréscimo próprios, um por domínio, na pasta do
+ * arco (`.orkastery/noctum/arcos/<arco>/fechamento.jsonl` e `relatorio.jsonl`). Cada linha leva o sha256 da anterior e
+ * o MAC de uma subchave da chave local do núcleo derivada pelo domínio: a do log do arco não vale aqui, e a de um domínio
+ * não vale no outro. O log do arco ganha só o `encerrado` (D2): nada aqui autoriza, renova ou emenda o envelope.
+ *
+ * A trava de cada domínio é a do kernel num arquivo próprio (`<domínio>.lock`), nunca a do arco: o envio do relatório
+ * espera o transporte do canal, e a revogação do dono não pode esperar por ele. A trava solta quando o processo morre.
+ *
+ * Limites, os mesmos do log do arco: a chave local é legível por qualquer processo do mesmo usuário do sistema, que pode
+ * escrever uma linha nova ou truncar o log; o MAC acusa a linha trocada e a cadeia, a linha apagada do meio.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const fila_pesada_1 = require("./fila-pesada");
+const hitl_local_receipt_1 = require("./hitl-local-receipt");
+const noctum_envelope_1 = require("./noctum-envelope");
+exports.DOMINIOS_DO_REGISTRO = ['fechamento', 'relatorio'];
+/** O contrato de cada domínio, que também separa a subchave do MAC. */
+const contratoDoRegistro = (dominio) => `ork.noctum-${dominio}/v1`;
+exports.contratoDoRegistro = contratoDoRegistro;
+/** Tipo fechado próprio, como o da supervisão da N4: o registro não abre gate nem recusa efeito do arco. */
+exports.MOTIVOS_DO_REGISTRO = ['noctum.registro.adulterado', 'noctum.registro.ocupado', 'noctum.registro.sem-trava'];
+class RecusaDoRegistro extends Error {
+    motivo;
+    constructor(motivo, detalhe) {
+        super(`${motivo}: ${detalhe}`);
+        this.motivo = motivo;
+        this.name = 'RecusaDoRegistro';
+    }
+}
+exports.RecusaDoRegistro = RecusaDoRegistro;
+const ZERO = '0'.repeat(64);
+const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+const adulterado = (dominio, detalhe) => new RecusaDoRegistro('noctum.registro.adulterado', `${dominio}: ${detalhe}; o registro do arco exige inspeção`);
+const objeto = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** A pasta do arco na raiz do estado, sem link no caminho. */
+function pastaDoArco(raiz, arco) {
+    if (typeof arco !== 'string' || !noctum_envelope_1.ID_DO_ARCO.test(arco))
+        throw new RecusaDoRegistro('noctum.registro.adulterado', 'identificador de arco inválido');
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum', 'arcos', arco]);
+    return path.join(principal, '.orkastery', 'noctum', 'arcos', arco);
+}
+function subchave(raiz, dominio, criar) {
+    return (0, node_crypto_1.createHmac)('sha256', (0, hitl_local_receipt_1.chaveLocal)(raiz, criar)).update((0, exports.contratoDoRegistro)(dominio)).digest();
+}
+/** Lê e confere o log inteiro. Linha sem quebra no fim está sendo gravada: fica de fora e não conta. */
+function lerCompleto(raiz, arco, dominio) {
+    const file = path.join(pastaDoArco(raiz, arco), `${dominio}.jsonl`);
+    let bruto;
+    try {
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const st = fs.fstatSync(fd);
+            if (!st.isFile() || st.nlink !== 1 || st.uid !== process.getuid?.() || (st.mode & 0o077) !== 0) {
+                throw adulterado(dominio, 'o log não é arquivo privado do núcleo');
+            }
+            bruto = fs.readFileSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return { linhas: [], ultima: null, bytesCompletos: 0, bytesLidos: 0 };
+        if (e instanceof RecusaDoRegistro)
+            throw e;
+        throw adulterado(dominio, 'log ilegível');
+    }
+    // Em bytes: uma cauda que corta um caractere de vários bytes não desalinha os tamanhos.
+    const fim = bruto.lastIndexOf(0x0a) + 1;
+    const textos = bruto.subarray(0, fim).toString('utf8').split('\n').slice(0, -1);
+    if (!textos.length)
+        return { linhas: [], ultima: null, bytesCompletos: fim, bytesLidos: bruto.length };
+    let chave;
+    try {
+        chave = subchave(raiz, dominio, false);
+    }
+    catch {
+        throw adulterado(dominio, 'chave do núcleo ausente para conferir o log');
+    }
+    let anterior = ZERO;
+    const contrato = (0, exports.contratoDoRegistro)(dominio);
+    const linhas = textos.map((texto, i) => {
+        let l;
+        try {
+            l = JSON.parse(texto);
+        }
+        catch {
+            throw adulterado(dominio, `linha ${i + 1} não é JSON`);
+        }
+        if (!objeto(l) || Object.keys(l).sort().join(',') !== 'dados,mac' || typeof l.mac !== 'string' || !/^[a-f0-9]{64}$/.test(l.mac)) {
+            throw adulterado(dominio, `linha ${i + 1} fora do formato`);
+        }
+        const esperado = (0, node_crypto_1.createHmac)('sha256', chave).update(JSON.stringify(l.dados)).digest();
+        if (!(0, node_crypto_1.timingSafeEqual)(Buffer.from(l.mac, 'hex'), esperado))
+            throw adulterado(dominio, `linha ${i + 1} com MAC que não confere`);
+        const d = l.dados;
+        if (!objeto(d) || d.contrato !== contrato || d.arco !== arco || d.seq !== i + 1 || d.anterior !== anterior) {
+            throw adulterado(dominio, `linha ${i + 1} fora da cadeia`);
+        }
+        anterior = sha(texto);
+        return d;
+    });
+    return { linhas, ultima: textos.at(-1), bytesCompletos: fim, bytesLidos: bruto.length };
+}
+/** As linhas conferidas do registro, sem trava (o log é lido inteiro e conferido). Vazio quando ele ainda não existe. */
+function lerRegistro(raiz, arco, dominio) {
+    return lerCompleto(raiz, arco, dominio).linhas;
+}
+const pausa = new Int32Array(new SharedArrayBuffer(4));
+/**
+ * Executa sob a trava do domínio, com as linhas lidas sob ela e um `anexar` que grava em cima delas. `esperarMs` é quanto
+ * a trava ocupada por outro processo é esperada antes da recusa `noctum.registro.ocupado`; sem ele, a recusa é imediata.
+ */
+function comRegistro(raiz, arco, dominio, executar, opcoes = {}) {
+    if (!(0, fila_pesada_1.kernelDisponivel)())
+        throw new RecusaDoRegistro('noctum.registro.sem-trava', 'o registro do arco só grava com /usr/bin/flock');
+    const pasta = pastaDoArco(raiz, arco);
+    fs.mkdirSync(pasta, { recursive: true, mode: 0o700 });
+    const prazo = Date.now() + Math.max(0, opcoes.esperarMs ?? 0);
+    let fd;
+    for (;;) {
+        fd = (0, fila_pesada_1.tentarTravaExclusiva)(path.join(pasta, `${dominio}.lock`));
+        if (fd !== null || Date.now() >= prazo)
+            break;
+        Atomics.wait(pausa, 0, 0, Math.min(100, Math.max(1, prazo - Date.now())));
+    }
+    if (fd === null)
+        throw new RecusaDoRegistro('noctum.registro.ocupado', `outro processo grava o ${dominio} do arco ${arco}`);
+    try {
+        let lido = lerCompleto(raiz, arco, dominio);
+        const anexar = (evento, quando) => {
+            const dados = { contrato: (0, exports.contratoDoRegistro)(dominio), arco, seq: lido.linhas.length + 1,
+                anterior: lido.ultima === null ? ZERO : sha(lido.ultima), em: quando, evento };
+            const texto = JSON.stringify({ dados, mac: (0, node_crypto_1.createHmac)('sha256', subchave(raiz, dominio, true)).update(JSON.stringify(dados)).digest('hex') });
+            const linha = Buffer.from(texto + '\n', 'utf8');
+            const file = path.join(pasta, `${dominio}.jsonl`);
+            const out = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o600);
+            try {
+                const st = fs.fstatSync(out);
+                if (!st.isFile() || st.nlink !== 1 || st.uid !== process.getuid?.() || (st.mode & 0o077) !== 0) {
+                    throw adulterado(dominio, 'o log não é arquivo privado do núcleo');
+                }
+                if (st.size !== lido.bytesLidos)
+                    throw adulterado(dominio, 'o log mudou entre a leitura e a escrita sob a trava');
+                // A cauda sem quebra é escrita abortada (queda, disco cheio): nunca contou, e sai antes da linha nova.
+                if (lido.bytesLidos !== lido.bytesCompletos)
+                    fs.ftruncateSync(out, lido.bytesCompletos);
+                const escritos = fs.writeSync(out, linha);
+                if (escritos !== linha.length) {
+                    fs.ftruncateSync(out, lido.bytesCompletos);
+                    fs.fsyncSync(out);
+                    throw adulterado(dominio, `escrita curta (${escritos} de ${linha.length} bytes); nada foi gravado`);
+                }
+                fs.fsyncSync(out);
+            }
+            finally {
+                fs.closeSync(out);
+            }
+            const total = lido.bytesCompletos + linha.length;
+            lido = { linhas: [...lido.linhas, dados], ultima: texto, bytesCompletos: total, bytesLidos: total };
+            return dados;
+        };
+        return executar(lido.linhas, anexar);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}