@orkastery/cli 0.5.3 → 0.6.0

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);
+    }
+}