@orkastery/cli 0.5.1 → 0.5.3

package/dist/rede-adesao.js

@@ -0,0 +1,399 @@
+"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.ehIdDeMaquina = exports.pastaDaRede = exports.TETO_DE_TENTATIVA_MS = exports.REPOSITORIO_PADRAO = exports.CONTRATO_DA_ADESAO = void 0;
+exports.lerConfigDaRede = lerConfigDaRede;
+exports.gravarConfigDaRede = gravarConfigDaRede;
+exports.adesaoDaRede = adesaoDaRede;
+exports.lerIdDaMaquina = lerIdDaMaquina;
+exports.idDaMaquina = idDaMaquina;
+exports.idDerivado = idDerivado;
+exports.publicacaoDesligada = publicacaoDesligada;
+exports.tomarVezDePublicar = tomarVezDePublicar;
+exports.publicarRedeEmSegundoPlano = publicarRedeEmSegundoPlano;
+exports.registrarNaRede = registrarNaRede;
+/**
+ * RM-053 (D2, D9): a adesao desta maquina a rede da pessoa, e o disparo em segundo plano.
+ *
+ * Modulo leve de proposito, como a `fabrica-publicar`: quem publica em segundo plano (thread nova,
+ * despacho de fase, entrega) chega aqui por ela e nao pode arrastar o retrato nem a forja.
+ *
+ * A adesao e da MAQUINA, em `~/.orkastery/rede.json` (contrato `ork.rede/v1`), gravado por
+ * `ork network entrar` e `ork network sair`. Sem esse arquivo, a maquina que ja fez
+ * `ork fabrica entrar` (`fabricaCompartilhada: true` em `maquina.json`) e membro HERDADO: entra na
+ * rede sem refazer nada. `ork network sair` grava `membro: false`, que vence a heranca. O manifesto
+ * do projeto nao conta: um time nao inscreve a maquina de ninguem na rede pessoal.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const maquina_1 = require("./maquina");
+const monitor_lock_1 = require("./monitor-lock");
+const util_1 = require("./util");
+exports.CONTRATO_DA_ADESAO = 'ork.rede/v1';
+exports.REPOSITORIO_PADRAO = 'orkastery-network';
+/**
+ * D9: no maximo uma tentativa de publicacao em segundo plano (evento ou batida) a cada 14 minutos.
+ * Um minuto de folga sob o cron de 15: com o teto igual ao periodo, a oscilacao do horario de cada
+ * batida pulava metade delas (B4 do CHECK 1).
+ */
+exports.TETO_DE_TENTATIVA_MS = 14 * 60 * 1000;
+/** `~/.orkastery/rede`: o cache bare da casa, as marcas e o log da rede. */
+const pastaDaRede = () => path.join((0, maquina_1.pastaDoUsuario)(), 'rede');
+exports.pastaDaRede = pastaDaRede;
+const arquivoDaConfig = () => path.join((0, maquina_1.pastaDoUsuario)(), 'rede.json');
+const arquivoDaTentativa = () => path.join((0, exports.pastaDaRede)(), 'tentativa.json');
+const IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+const HOST = /^[A-Za-z0-9.-]+(?::\d+)?$/;
+const texto = (v, padrao) => typeof v === 'string' && padrao.test(v) ? v : null;
+function lerConfigDaRede() {
+    try {
+        const bruto = JSON.parse(fs.readFileSync(arquivoDaConfig(), 'utf8'));
+        if (!bruto || bruto.contrato !== exports.CONTRATO_DA_ADESAO || typeof bruto.membro !== 'boolean')
+            return null;
+        return {
+            contrato: exports.CONTRATO_DA_ADESAO, membro: bruto.membro,
+            forja: bruto.forja === 'github' || bruto.forja === 'gitlab' ? bruto.forja : null,
+            host: texto(bruto.host, HOST), dono: texto(bruto.dono, IDENTIFICADOR), repositorio: texto(bruto.repositorio, IDENTIFICADOR),
+            atualizadoEm: typeof bruto.atualizadoEm === 'string' ? bruto.atualizadoEm : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Grava a adesao (troca atomica). Campo ausente na mudanca fica como estava. */
+function gravarConfigDaRede(mudanca) {
+    const atual = lerConfigDaRede();
+    const config = {
+        contrato: exports.CONTRATO_DA_ADESAO,
+        membro: mudanca.membro ?? atual?.membro ?? false,
+        forja: mudanca.forja !== undefined ? mudanca.forja : atual?.forja ?? null,
+        host: mudanca.host !== undefined ? mudanca.host : atual?.host ?? null,
+        dono: mudanca.dono !== undefined ? mudanca.dono : atual?.dono ?? null,
+        repositorio: mudanca.repositorio !== undefined ? mudanca.repositorio : atual?.repositorio ?? null,
+        atualizadoEm: new Date().toISOString(),
+    };
+    if (config.host !== null && !HOST.test(config.host))
+        throw new Error(`rede.config: host invalido ("${config.host}")`);
+    for (const [campo, valor] of [['dono', config.dono], ['repositorio', config.repositorio]]) {
+        if (valor !== null && !IDENTIFICADOR.test(valor))
+            throw new Error(`rede.config: ${campo} invalido ("${valor}")`);
+    }
+    const dir = (0, maquina_1.pastaDoUsuario)();
+    fs.mkdirSync(dir, { recursive: true });
+    const temp = path.join(dir, `.rede.json.${process.pid}.tmp`);
+    fs.writeFileSync(temp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(temp, arquivoDaConfig());
+    return config;
+}
+/** Esta maquina esta na rede? Explicita pelo `rede.json`, senao herdada da fabrica. */
+function adesaoDaRede() {
+    const config = lerConfigDaRede();
+    if (config)
+        return { membro: config.membro, adesao: config.membro ? 'rede' : null, config };
+    const herdada = (0, maquina_1.lerConfigDaMaquina)()?.fabricaCompartilhada === true;
+    return { membro: herdada, adesao: herdada ? 'fabrica' : null, config: null };
+}
+const ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const arquivoDoId = () => path.join((0, maquina_1.pastaDoUsuario)(), 'maquina-id');
+function lerId(arquivo) {
+    try {
+        const id = fs.readFileSync(arquivo, 'utf8').trim();
+        return ID.test(id) ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** O id desta instalacao, sem criar: `null` quando ela nunca publicou (a leitura nao cria estado). */
+function lerIdDaMaquina() {
+    return lerId(arquivoDoId());
+}
+/**
+ * B7 do CHECK 1: um identificador aleatorio desta instalacao, criado na primeira publicacao. Vai no
+ * retrato para duas maquinas com o mesmo nome (hostname `ubuntu`, o corte em 64 caracteres) nao
+ * regravarem o arquivo uma da outra. Nao identifica pessoa.
+ *
+ * S3 da revisao 2: mora em `~/.orkastery/maquina-id`, ao lado do `maquina.json`, e NAO na pasta de
+ * cache `~/.orkastery/rede/`: apagar o cache nao pode fazer a maquina virar outra de si mesma.
+ * U6 da revisao 3: sem arquivo, `link` de um temporario cria so se nao existe (atomico).
+ * V5 da revisao 4: arquivo ruim e trocado por um id DERIVADO dele, o mesmo para todo processo que o
+ * viu. W7 e W8 da revisao 5: nenhum caminho expoe arquivo vazio, e link pendurado tambem e trocado.
+ * X6 do CHECK 6: sem hard link, e na troca do arquivo ruim, o id vem de uma reserva (`idReservado`),
+ * igual para todo host que divide a pasta; o derivado so fica para quando a reserva falha.
+ * Todo caminho devolve o que ficou gravado, nunca o que tentou gravar.
+ */
+function idDaMaquina() {
+    const arquivo = arquivoDoId();
+    for (let tentativa = 0; tentativa < 3; tentativa++) {
+        const lido = lerId(arquivo);
+        if (lido)
+            return lido;
+        fs.mkdirSync((0, maquina_1.pastaDoUsuario)(), { recursive: true });
+        let st = null;
+        try {
+            st = fs.lstatSync(arquivo, { bigint: true });
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+        }
+        if (st)
+            trocarIdInvalido(arquivo, st);
+        else
+            criarId(arquivo);
+    }
+    const persistido = lerId(arquivo);
+    if (!persistido)
+        throw new Error(`rede.id: nao consegui gravar nem ler ${arquivo}`);
+    return persistido;
+}
+function gravarTemporario(conteudo) {
+    const temporario = path.join((0, maquina_1.pastaDoUsuario)(), `.maquina-id.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    fs.writeFileSync(temporario, conteudo, { mode: 0o600 });
+    return temporario;
+}
+/** Troca o que estiver no caminho (arquivo ou link) por um arquivo inteiro com o id: `rename` e atomico. */
+function trocarPor(arquivo, id) {
+    const temporario = gravarTemporario(id);
+    try {
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+}
+const SEM_HARD_LINK = new Set(['EPERM', 'ENOTSUP', 'EOPNOTSUPP', 'ENOSYS']);
+/** Cria o id so se o arquivo nao existe; perdeu a corrida, fica o do outro. */
+function criarId(arquivo) {
+    const temporario = gravarTemporario((0, node_crypto_1.randomUUID)());
+    try {
+        fs.linkSync(temporario, arquivo);
+        return;
+    }
+    catch (e) {
+        const codigo = e.code ?? '';
+        if (codigo === 'EEXIST')
+            return;
+        if (!SEM_HARD_LINK.has(codigo))
+            throw e;
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+    // W7 da revisao 5: sistema de arquivos sem hard link (vboxsf, alguns FUSE e SMB). Nada de arquivo
+    // vazio nem de espera por relogio. X6 do CHECK 6: o id sai da reserva, o mesmo para todo processo
+    // de todo host que divide a pasta; so se a reserva falhar, o id DERIVADO da pasta e do boot.
+    const reservado = idReservado('maquina-id.reserva');
+    if (reservado)
+        return trocarPor(arquivo, reservado);
+    const pasta = fs.statSync((0, maquina_1.pastaDoUsuario)(), { bigint: true });
+    trocarPor(arquivo, idDerivado(['novo', pasta.dev, pasta.ino]));
+}
+/**
+ * X6 do CHECK 6: cria-se-ausente sem hard link, sem relogio e sem arquivo vazio. A pasta temporaria
+ * ganha o id inteiro antes do `rename`; `rename` de pasta sobre pasta NAO vazia falha (ENOTEMPTY ou
+ * EEXIST no POSIX, EPERM no Windows), entao so a primeira entra, e todo processo, de qualquer host ou
+ * conteiner que divida `~/.orkastery`, le dela o mesmo id. A reserva fica: e ela que responde ao lento.
+ * Clones de uma imagem (W6) tem disco proprio e criam cada um a sua. Qualquer falha devolve `null`, e
+ * quem chamou usa o id derivado de antes.
+ */
+function idReservado(nome) {
+    const reserva = path.join((0, maquina_1.pastaDoUsuario)(), nome);
+    const jaReservado = lerId(path.join(reserva, 'id'));
+    if (jaReservado)
+        return jaReservado;
+    const temporaria = path.join((0, maquina_1.pastaDoUsuario)(), `.${nome}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    try {
+        fs.mkdirSync(temporaria, { mode: 0o700 });
+        fs.writeFileSync(path.join(temporaria, 'id'), (0, node_crypto_1.randomUUID)(), { mode: 0o600 });
+        fs.renameSync(temporaria, reserva);
+    }
+    catch { /* outro entrou antes (ou a pasta recusa): vale o que estiver na reserva */ }
+    finally {
+        fs.rmSync(temporaria, { recursive: true, force: true });
+    }
+    return lerId(path.join(reserva, 'id'));
+}
+/** O arquivo ruim (vazio, corrompido, link pendurado) vira o id derivado dele; o que mudou no meio, quem chamou rele. */
+function trocarIdInvalido(arquivo, st) {
+    let conteudo;
+    if (st.isSymbolicLink()) {
+        // W8 da revisao 5: o link pendurado (ou para arquivo ruim) sai; o alvo fica como esta. X2 da revisao
+        // 6: se outro processo ja o trocou (ou tirou) depois do `lstat`, quem chamou rele.
+        let alvo;
+        try {
+            alvo = fs.readlinkSync(arquivo);
+        }
+        catch (e) {
+            if (['ENOENT', 'EINVAL'].includes(e.code ?? ''))
+                return;
+            throw e;
+        }
+        conteudo = Buffer.from(`link:${alvo}`);
+    }
+    else if (st.isFile()) {
+        let fd;
+        try {
+            fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        }
+        catch (e) {
+            if (['ENOENT', 'ELOOP'].includes(e.code ?? ''))
+                return;
+            throw e;
+        }
+        try {
+            // Conteudo e metadados do MESMO inode: o `fstat` do descritor aberto, nao do caminho.
+            st = fs.fstatSync(fd, { bigint: true });
+            const buffer = Buffer.alloc(4096);
+            conteudo = buffer.subarray(0, fs.readSync(fd, buffer, 0, buffer.length, 0));
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        if (ID.test(conteudo.toString('utf8').trim()))
+            return;
+    }
+    else {
+        throw new Error(`rede.id: ${arquivo} nao e um arquivo; apague-o e rode de novo`);
+    }
+    // X6 do CHECK 6: a reserva da troca e chaveada pelo que todo host ve igual do arquivo ruim (conteudo,
+    // tamanho e hora); `dev` e local a cada host e fica so no id derivado, o caminho de quando a reserva falha.
+    const sha = (0, node_crypto_1.createHash)('sha256').update(conteudo).digest('hex');
+    const chave = (0, node_crypto_1.createHash)('sha256').update([sha, st.size, st.mtimeNs].join('\0')).digest('hex').slice(0, 32);
+    trocarPor(arquivo, idReservado(`maquina-id.troca-${chave}`) ?? idDerivado([sha, st.dev, st.ino, st.mtimeNs, st.size]));
+}
+/**
+ * O id que todo processo desta maquina deriva do mesmo estado, agora. W6 da revisao 5: alem das
+ * partes (o arquivo ruim, ou a pasta), o hostname e o boot (`boot_id` e `machine-id`): VMs clonadas
+ * da mesma imagem, com o mesmo arquivo, inode e hostname, tem boot proprio e ganham ids diferentes.
+ * Formato de UUID v4.
+ */
+function idDerivado(partes, fontes = fontesDaMaquina()) {
+    const h = (0, node_crypto_1.createHash)('sha256').update([...partes.map(String), ...fontes].join('\0')).digest('hex');
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${'89ab'[parseInt(h[16], 16) & 3]}${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+function fontesDaMaquina() {
+    const ler = (arquivo) => { try {
+        return fs.readFileSync(arquivo, 'utf8').trim();
+    }
+    catch {
+        return '';
+    } };
+    return [os.hostname(), ler('/proc/sys/kernel/random/boot_id'), ler('/etc/machine-id')];
+}
+const ehIdDeMaquina = (v) => typeof v === 'string' && ID.test(v);
+exports.ehIdDeMaquina = ehIdDeMaquina;
+/** Publicacao automatica desligada pelo ambiente (testes, `ork eval`, demo). */
+function publicacaoDesligada(env = process.env) {
+    return env.ORK_REDE_PUBLICAR === '0' || env.ORK_FABRICA_PUBLICAR === '0';
+}
+/**
+ * D9: toma a vez de tentar publicar, no maximo uma a cada 14 minutos por maquina. Devolve `false`
+ * quando a ultima tentativa (evento ou batida) foi ha menos que isso; a marca e gravada antes da
+ * tentativa, para duas batidas simultaneas nao dispararem juntas. Revisao de 03/10: a leitura e a
+ * gravacao da marca correm sob uma trava (quem nao a pega perde a vez) e a marca troca por rename;
+ * sem isso, varios processos na mesma batida liam a marca velha e todos tomavam a vez.
+ */
+function tomarVezDePublicar(agoraPedido) {
+    try {
+        fs.mkdirSync((0, exports.pastaDaRede)(), { recursive: true });
+    }
+    catch {
+        return false;
+    }
+    const trava = (0, monitor_lock_1.adquirirLockMonitor)(path.join((0, exports.pastaDaRede)(), 'tentativa.lock'));
+    if (!trava.ok)
+        return false;
+    // A hora e lida DENTRO da trava: lida antes, o processo que perdia a CPU entre a leitura e a trava
+    // via a marca do vencedor "no futuro", a tomava por relogio que voltou e tomava a vez tambem.
+    const agora = agoraPedido ?? Date.now();
+    try {
+        try {
+            const ultima = Date.parse(JSON.parse(fs.readFileSync(arquivoDaTentativa(), 'utf8')).em ?? '');
+            if (Number.isFinite(ultima) && agora - ultima < exports.TETO_DE_TENTATIVA_MS && agora >= ultima)
+                return false;
+        }
+        catch { /* primeira vez, ou marca ilegivel: tenta */ }
+        try {
+            // Dado de maquina: o JSON vai inteiro, sem concatenar o ISO em texto (lint de horario, RM-035).
+            const temporario = `${arquivoDaTentativa()}.${process.pid}.tmp`;
+            fs.writeFileSync(temporario, JSON.stringify({ em: new Date(agora).toISOString() }), { mode: 0o600 });
+            fs.renameSync(temporario, arquivoDaTentativa());
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+    finally {
+        try {
+            trava.liberar();
+        }
+        catch { /* a trava de outro dono nao e desfeita aqui */ }
+    }
+}
+/**
+ * Evento de thread (criada, fase despachada, entregue, fechada): dispara `ork network publicar
+ * --silencioso` sem segurar quem chamou. So para membro, so fora do teto, nunca com a publicacao
+ * desligada pelo ambiente.
+ */
+function publicarRedeEmSegundoPlano(opcoes = {}) {
+    const env = opcoes.env ?? process.env;
+    if (publicacaoDesligada(env) || !adesaoDaRede().membro)
+        return false;
+    const cli = opcoes.cli ?? path.join(__dirname, 'index.js');
+    if (!fs.existsSync(cli) || !tomarVezDePublicar(opcoes.agora))
+        return false;
+    try {
+        const filho = (0, node_child_process_1.spawn)(process.execPath, [cli, 'network', 'publicar', '--silencioso'], { cwd: opcoes.diretorio ?? process.cwd(), detached: true, stdio: 'ignore', env });
+        filho.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Uma linha JSON por publicacao em segundo plano, em `~/.orkastery/rede/rede.log`: quem publica sozinho deixa rastro. */
+function registrarNaRede(registro) {
+    try {
+        fs.mkdirSync((0, exports.pastaDaRede)(), { recursive: true });
+        fs.appendFileSync(path.join((0, exports.pastaDaRede)(), 'rede.log'), JSON.stringify({ ts: (0, util_1.agora)(), ...registro }) + '\n', { mode: 0o600 });
+    }
+    catch { /* o log e informativo */ }
+}