@orkastery/cli 0.5.1 → 0.5.6

package/dist/rede-status.js

@@ -0,0 +1,337 @@
+"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.NAO_CONSULTADO = exports.SEM_BATIDA_MS = exports.CONTRATO_DO_STATUS = void 0;
+exports.lerRede = lerRede;
+exports.duracao = duracao;
+exports.textoDaRede = textoDaRede;
+exports.jsonDaRede = jsonDaRede;
+/**
+ * RM-053: a leitura da Orkastery Network, `ork network status` (contrato `ork.rede-status/v1`).
+ *
+ * Responde "quais maquinas desta pessoa existem e o que cada uma tem" de QUALQUER diretorio, e diz
+ * sempre de onde leu, quando, e o que NAO leu. Lacuna e o que faltou ler, e ela nunca vira lista
+ * vazia: no incidente de 29/09 o agente disse "nenhuma maquina publicou" quando so nao tinha olhado.
+ *
+ * D10: a branch `ork/fabrica-estado` dos projetos conhecidos continua lida. Maquina que so aparece
+ * la entra com `origem: fabrica-estado` e `adesao: null` (vista, sem supor adesao), ate publicar na
+ * rede; quando esta nos dois, o retrato da rede vence.
+ * D15: maquina sem batida ha mais de 3 h vira a lacuna `maquina.sem-batida`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const fabrica_estado_1 = require("./fabrica-estado");
+const horario_1 = require("./horario");
+const locale_1 = require("./locale");
+const manifest_1 = require("./manifest");
+const maquina_1 = require("./maquina");
+const rede_1 = require("./rede");
+const rede_adesao_1 = require("./rede-adesao");
+const rede_forja_1 = require("./rede-forja");
+const rede_projetos_1 = require("./rede-projetos");
+const saida_segura_1 = require("./saida-segura");
+exports.CONTRATO_DO_STATUS = 'ork.rede-status/v1';
+/** D15: tres batidas perdidas. */
+exports.SEM_BATIDA_MS = 3 * 60 * 60 * 1000;
+/** O que esta leitura nunca olha: quem conclui sobre isso a partir daqui erra. */
+exports.NAO_CONSULTADO = ['roadmap', 'reservas', 'threads'];
+const mensagem = (e) => e.message.replace(/^[a-z.-]+: /, '');
+/** Sem rede, a casa vem da adesao gravada ou da ultima publicacao desta maquina. */
+function casaSemRede() {
+    const cfg = (0, rede_adesao_1.adesaoDaRede)().config;
+    if (cfg?.forja && cfg.host && cfg.dono && cfg.repositorio) {
+        return { forja: cfg.forja, host: cfg.host, dono: cfg.dono, repositorio: cfg.repositorio, origem: 'rede.json' };
+    }
+    const marca = (0, rede_1.lerMarcaDaRede)();
+    const partes = marca?.casa?.split('/') ?? [];
+    if (marca && (0, rede_forja_1.ehNomeDeForja)(marca.forja) && partes.length === 3) {
+        return { forja: marca.forja, host: partes[0], dono: partes[1], repositorio: partes[2], origem: 'marca' };
+    }
+    return null;
+}
+function membroDoRetrato(r, agoraMs) {
+    return { maquina: r.maquina, origem: 'rede', publicadoEm: r.publicadoEm, idadeMs: Math.max(0, agoraMs - Date.parse(r.publicadoEm)),
+        hostname: r.hostname ?? null, adesao: r.adesao ?? null, pessoa: null, forjas: r.forjas, runtimes: r.runtimes, hosts: r.hosts,
+        projetos: r.projetos.map((p) => ({ nome: p.nome, remoto: p.remoto, caminho: p.caminho })), versaoOrk: r.versaoOrk ?? null };
+}
+/** `ork network status`: a rede inteira, de qualquer diretorio, com fontes e lacunas. */
+function lerRede(o = {}) {
+    const consultadoEm = o.agora ?? new Date().toISOString();
+    const agoraMs = Date.parse(consultadoEm);
+    const eu = (0, rede_1.nomeSeguro)((0, maquina_1.nomeDaMaquina)(o.maquina));
+    const adesao = (0, rede_adesao_1.adesaoDaRede)();
+    const lacunas = [], fontes = [];
+    const membros = new Map();
+    // 1. A casa: resolvida pela forja (com rede) ou pela adesao e pela marca (sem rede).
+    let casa = null;
+    let ler = true;
+    let semHttps = false;
+    if (o.semRemoto) {
+        casa = casaSemRede();
+        if (!casa)
+            lacunas.push({ tipo: 'rede.sem-leitura', detalhe: 'sem rede e sem casa conhecida nesta maquina: rode sem --sem-remoto' });
+    }
+    else {
+        const r = (0, rede_1.resolverCasa)({ amb: o.amb });
+        casa = r.casa;
+        if (r.motivo)
+            lacunas.push({ tipo: r.motivo.tipo, detalhe: r.motivo.detalhe });
+        if (r.casa && r.forja) {
+            try {
+                const repo = r.forja.repositorio(r.casa.dono, r.casa.repositorio);
+                if (!repo.existe) {
+                    ler = false;
+                    lacunas.push({ tipo: 'rede.sem-repositorio', detalhe: `${(0, rede_1.refDaCasa)(r.casa)} ainda nao existe: nenhuma maquina rodou ork network entrar` });
+                }
+                else {
+                    if (repo.privado !== true)
+                        lacunas.push({ tipo: 'rede.repositorio-publico', detalhe: `${(0, rede_1.refDaCasa)(r.casa)} nao e privado: nenhuma maquina publica nele` });
+                    if (repo.url && (0, rede_1.urlDaCasaAceita)(repo.url))
+                        (0, rede_1.prepararCache)(r.casa, repo.url, r.forja.helperDeCredencial(), eu);
+                    else if (repo.url) {
+                        // W10 da revisao 5: sem https nao ha leitura nova; o cache fica com a URL antiga e so a copia local vale.
+                        semHttps = true;
+                        lacunas.push({ tipo: 'rede.sem-leitura', detalhe: `${(0, rede_1.refDaCasa)(r.casa)}: a forja devolveu uma URL sem https; a rede so fala por https (vale a ultima copia local, quando ha)` });
+                    }
+                }
+            }
+            catch (e) {
+                lacunas.push({ tipo: 'rede.sem-leitura', detalhe: `${(0, rede_1.refDaCasa)(r.casa)}: ${mensagem(e)}` });
+            }
+        }
+    }
+    // 2. Os retratos da casa.
+    let retratos = [];
+    let lida = null;
+    if (casa && ler) {
+        const cache = (0, rede_1.dirDoCache)(casa);
+        if ((0, rede_1.cachePronto)(cache) && (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.git)(cache, ['config', 'remote.origin.url']).ok)) {
+            const soLocal = o.semRemoto || semHttps;
+            const { ponta, atualizado } = (0, rede_forja_1.comGitIsolado)(() => soLocal
+                ? { ponta: (0, branch_de_estado_1.pontaLocal)(cache, 'origin', rede_1.BRANCH_DA_REDE), atualizado: false }
+                : (0, branch_de_estado_1.buscarBranch)(cache, 'origin', rede_1.BRANCH_DA_REDE, 'rede', o.timeoutMs ?? 30000));
+            fontes.push({ fonte: 'rede', ref: `${(0, rede_1.refDaCasa)(casa)}#${rede_1.BRANCH_DA_REDE}`, ponta, atualizado });
+            if (!atualizado && !soLocal) {
+                lacunas.push({ tipo: 'rede.sem-leitura', detalhe: `${(0, rede_1.refDaCasa)(casa)} sem leitura nova: ${ponta ? 'mostrando a ultima copia local' : 'nenhuma copia local'}` });
+            }
+            const lidos = (0, rede_1.retratosDaPonta)(cache, ponta);
+            lida = { cache, ponta };
+            retratos = lidos.retratos;
+            for (const inv of lidos.invalidos)
+                lacunas.push({ tipo: 'retrato.invalido', detalhe: `${inv.arquivo}: ${inv.motivo}` });
+        }
+        else if (!lacunas.some((l) => l.tipo === 'rede.sem-leitura')) {
+            lacunas.push({ tipo: 'rede.sem-leitura', detalhe: `${(0, rede_1.refDaCasa)(casa)} nunca foi lida nesta maquina` });
+        }
+    }
+    for (const r of retratos)
+        membros.set(r.maquina, membroDoRetrato(r, agoraMs));
+    // 3. A fabrica legada dos projetos conhecidos (D10).
+    const marca = (0, rede_1.lerMarcaDaRede)();
+    const anteriores = retratos.find((r) => r.maquina === eu)?.projetos ?? (marca?.maquina === eu ? marca.projetos : undefined);
+    const conhecidos = (0, rede_projetos_1.projetosConhecidos)({ arquivo: o.arquivoDeProjetos, diretorio: o.diretorio, anteriores }).projetos;
+    const raizDe = (c) => { try {
+        return fs.realpathSync(c);
+    }
+    catch {
+        return path.resolve(c);
+    } };
+    const projetos = o.soRaiz === undefined ? conhecidos : conhecidos.filter((p) => raizDe(p.caminho) === raizDe(o.soRaiz));
+    for (const p of projetos) {
+        if (!p.presente) {
+            lacunas.push({ tipo: 'projeto.sem-clone', projeto: p.nome, detalhe: `${p.nome}: ${p.caminho} nao tem mais o projeto nesta maquina` });
+            continue;
+        }
+        let remoto = 'origin';
+        try {
+            remoto = (0, manifest_1.carregarManifesto)(p.caminho)?.manifesto.fabrica.remoto ?? 'origin';
+        }
+        catch { /* manifesto ruim: origin */ }
+        // RM-047: o `fabrica.remoto` vem do manifesto versionado; so nome de remoto vai ao git (depois do `--`),
+        // e o valor recusado sai redigido, sem a credencial de uma URL, no texto e no JSON.
+        if (!(0, branch_de_estado_1.remotoValido)(remoto)) {
+            lacunas.push({ tipo: 'fabrica.sem-leitura', projeto: p.nome,
+                detalhe: `${p.nome}: fabrica.remoto ${(0, branch_de_estado_1.remotoRedigido)(remoto)} nao e nome de remoto do git; nada foi lido pelo git` });
+            continue;
+        }
+        if (!(0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.git)(p.caminho, ['remote', 'get-url', '--', remoto]).ok)) {
+            lacunas.push({ tipo: 'fabrica.sem-leitura', projeto: p.nome, detalhe: `${p.nome}: sem o remoto ${remoto}, nao ha fabrica compartilhada para ler` });
+            continue;
+        }
+        try {
+            // M5: sem prompt de senha; um remoto que pediria senha vira lacuna, nao trava o status. S4: o
+            // `core.sshCommand` do projeto (chave propria, proxy) continua valendo.
+            const sshProprio = (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.git)(p.caminho, ['config', '--get', 'core.sshCommand']).stdout.trim() !== '');
+            const painel = (0, rede_forja_1.comGitIsolado)(() => (0, fabrica_estado_1.lerFabrica)(p.caminho, { remoto, semRemoto: o.semRemoto, timeoutMs: o.timeoutMs ?? 10000 }), undefined, { ssh: sshProprio ? 'herdado' : 'lote' });
+            fontes.push({ fonte: 'fabrica-estado', projeto: p.nome, ref: fabrica_estado_1.BRANCH_DA_FABRICA, ponta: painel.ponta, atualizado: painel.atualizado });
+            if (!painel.atualizado && !o.semRemoto) {
+                lacunas.push({ tipo: 'fabrica.sem-leitura', projeto: p.nome, detalhe: `${p.nome}: ${fabrica_estado_1.BRANCH_DA_FABRICA} sem leitura nova; usei a ultima copia local` });
+            }
+            for (const bruto of painel.maquinas) {
+                // U4 da revisao 3: a fabrica guarda o nome cru, a rede o saneado; casam pelo saneado.
+                const m = { ...bruto, maquina: (0, rede_1.nomeSeguro)(bruto.maquina) };
+                const atual = membros.get(m.maquina);
+                if (atual?.origem === 'rede')
+                    continue;
+                const idadeMs = Math.max(0, agoraMs - Date.parse(m.publicadoEm));
+                if (atual) {
+                    if (!atual.projetos.some((x) => x.nome === m.projeto))
+                        atual.projetos.push({ nome: m.projeto, remoto: null, caminho: null });
+                    // Y1 da revisao 7: a batida ilegivel (NaN) guardada antes perde para qualquer batida legivel.
+                    if (Number.isFinite(idadeMs) && !(atual.idadeMs <= idadeMs))
+                        Object.assign(atual, { publicadoEm: m.publicadoEm, idadeMs, versaoOrk: m.versaoOrk ?? null });
+                    continue;
+                }
+                // B11 do CHECK 1: quem so aparece na fabrica nao e dado como membro. Pode ser um `ork` antigo, uma
+                // maquina que saiu da rede ou uma sem forja: a leitura diz o que viu, nao o que supoe.
+                membros.set(m.maquina, { maquina: m.maquina, origem: 'fabrica-estado', publicadoEm: m.publicadoEm, idadeMs, hostname: null,
+                    adesao: null, pessoa: m.por ?? null, forjas: [], runtimes: [], hosts: [],
+                    projetos: [{ nome: m.projeto, remoto: null, caminho: null }], versaoOrk: m.versaoOrk ?? null });
+            }
+        }
+        catch (e) {
+            lacunas.push({ tipo: 'fabrica.sem-leitura', projeto: p.nome, detalhe: `${p.nome}: ${mensagem(e)}` });
+        }
+    }
+    // S7 da revisao 2: o retrato com o nome desta maquina pode ser de outra instalacao (tomou o nome).
+    const meuId = (0, rede_adesao_1.lerIdDaMaquina)();
+    const comMeuNome = retratos.find((r) => r.maquina === eu);
+    // V7 da revisao 4: o arquivo com este nome num contrato mais novo, com outro `id`, tambem e de outra instalacao.
+    let idDeOutraVersao = null;
+    if (!comMeuNome && lida) {
+        try {
+            idDeOutraVersao = (0, rede_1.idNoArquivo)(lida.cache, lida.ponta, (0, rede_1.arquivoDoRetrato)(eu));
+        }
+        catch { /* nome impossivel */ }
+    }
+    const idNaCasa = comMeuNome?.id ?? idDeOutraVersao;
+    // Revisao de 03/10: sem id local (nunca publicou, ou ~/.orkastery apagada), a proxima publicacao cria um id novo
+    // e o `publicarRede` recusa com `rede.nome-em-uso`; o status diz o mesmo, em vez de chamar de "esta maquina".
+    const nomeEmUso = !!idNaCasa && idNaCasa !== meuId;
+    if (nomeEmUso) {
+        lacunas.push({ tipo: 'maquina.nome-em-uso', maquina: eu, detalhe: `o retrato "${eu}" na casa e de outra instalacao: esta maquina nao ` +
+                'publica ate trocar de nome (ork network entrar --maquina NOME) ou retomar este (ork network entrar --forcar)' });
+    }
+    // 4. O frescor de cada maquina (D15).
+    const lista = [...membros.values()].sort((a, b) => a.maquina.localeCompare(b.maquina));
+    for (const m of lista) {
+        // X5 da revisao 6: batida ilegivel (a fabrica legada aceita qualquer texto) nao passa por fresca.
+        if (!Number.isFinite(m.idadeMs))
+            lacunas.push({ tipo: 'maquina.sem-batida', maquina: m.maquina, detalhe: `${m.maquina}: batida ilegivel` });
+        else if (m.idadeMs > exports.SEM_BATIDA_MS)
+            lacunas.push({ tipo: 'maquina.sem-batida', maquina: m.maquina, detalhe: `${m.maquina}: sem batida ha ${duracao(m.idadeMs)}` });
+    }
+    return {
+        contrato: exports.CONTRATO_DO_STATUS, consultadoEm, casa: casa ? { ...casa } : null,
+        estaMaquina: { maquina: eu, membro: adesao.membro, adesao: adesao.adesao, publicada: !!comMeuNome && !nomeEmUso, nomeEmUso },
+        fontes, membros: lista, lacunas, naoConsultado: [...exports.NAO_CONSULTADO],
+    };
+}
+function duracao(ms) {
+    if (!Number.isFinite(ms))
+        return (0, locale_1.msg)().horario.duracaoDesconhecida;
+    const min = Math.round(ms / 60000);
+    if (min < 1)
+        return (0, locale_1.msg)().horario.menosDeUmMin;
+    if (min < 120)
+        return `${min} min`;
+    const h = Math.round(ms / 3600000);
+    return h < 48 ? `${h} h` : `${Math.round(ms / 86400000)} d`;
+}
+/** O texto de `ork network status`: fonte e o que nao foi lido primeiro, lacunas sempre no fim. */
+function textoDaRede(status) {
+    // V2 da revisao 4 e W4 da revisao 5: a fabrica legada vem do remoto de um projeto, onde outras pessoas
+    // escrevem. Cada VALOR vai numa linha so e sem nada que o terminal execute ou que ninguem ve, antes de
+    // entrar no texto: um `\n` num valor nao abre uma linha que parece do `ork`.
+    // X5 da revisao 6: um mapa que so troca texto (a ida e volta em JSON trocava `NaN` por `null`).
+    const s = (0, saida_segura_1.valoresEmUmaLinha)(status);
+    const linhas = [];
+    const rede = s.fontes.find((f) => f.fonte === 'rede');
+    const estadoDaCasa = rede ? (rede.atualizado ? 'lida agora' : 'última cópia local') : 'não lida';
+    linhas.push(s.casa
+        ? `Orkastery Network de ${s.casa.dono} · ${s.casa.forja}: ${(0, rede_1.refDaCasa)(s.casa)} · ${estadoDaCasa}`
+        : 'Orkastery Network · sem casa: nenhuma forja com login nesta máquina');
+    const consultado = [
+        ...(rede ? [`repositório da rede (${rede.ponta ? rede.ponta.slice(0, 7) : 'vazio'})`] : []),
+        ...s.fontes.filter((f) => f.fonte === 'fabrica-estado')
+            .map((f) => `fábrica de ${f.projeto} (${f.ref}, ${f.atualizado ? 'lida agora' : 'última cópia'})`),
+    ];
+    linhas.push(`Consultado: ${consultado.length ? consultado.join('; ') : 'nada (veja as lacunas)'}.`);
+    linhas.push(`Não consultado: ${s.naoConsultado.join(', ')}. O roadmap de um projeto sai do ork roadmap status nele.`);
+    linhas.push('');
+    if (s.membros.length === 0)
+        linhas.push('Nenhuma máquina lida. Isso não quer dizer que não há máquinas: veja as lacunas.');
+    for (const m of s.membros) {
+        const esta = m.maquina !== s.estaMaquina.maquina ? ''
+            : m.origem === 'rede' && s.estaMaquina.nomeEmUso ? ' (outra instalação com o nome desta máquina)' : ' (esta máquina)';
+        const origem = m.origem === 'rede' ? `rede${m.adesao === 'fabrica' ? ', adesão herdada da fábrica' : ''}`
+            : `vista só na fábrica de ${m.projetos.map((p) => p.nome).join(', ')}; sem retrato na rede`;
+        linhas.push(`${m.maquina}${esta} · ${origem} · batida ${(0, horario_1.formatarDataHora)(m.publicadoEm)} (há ${duracao(m.idadeMs)})`);
+        const ficha = [m.hostname ? `hostname ${m.hostname}` : null, m.versaoOrk ? `ork ${m.versaoOrk}` : null,
+            ...m.forjas.map((f) => `${f.forja}: ${f.usuario ?? 'sem login'}`), m.pessoa ? `pessoa ${m.pessoa}` : null].filter(Boolean);
+        if (ficha.length)
+            linhas.push(`  ${ficha.join(' · ')}`);
+        if (m.runtimes.length)
+            linhas.push(`  runtimes: ${m.runtimes.map((r) => `${r.runtime} ${r.versao ?? '?'}`).join(', ')}`);
+        if (m.hosts.length) {
+            linhas.push(`  hosts: ${m.hosts.map((h) => `${h.host} ${h.versao ?? '?'}${h.adaptador ? ` (adaptador ${h.adaptador})` : ''}`).join(', ')}`);
+        }
+        if (m.projetos.length) {
+            linhas.push(`  projetos: ${m.projetos.map((p) => `${p.nome}${p.remoto ? ` (${p.remoto})` : ''}${p.caminho ? ` em ${p.caminho}` : ''}`).join('; ')}`);
+        }
+    }
+    linhas.push('');
+    const aqui = s.estaMaquina;
+    linhas.push(aqui.membro
+        ? `Esta máquina (${aqui.maquina}) é membro${aqui.adesao === 'fabrica' ? ', herdado da fábrica' : ''}${aqui.publicada ? '.' : '; o retrato dela ainda não está na casa.'}`
+        : `Esta máquina (${aqui.maquina}) não está na rede: ork network entrar.`);
+    if (s.lacunas.length === 0)
+        linhas.push('Lacunas: nenhuma.');
+    else {
+        linhas.push(`Lacunas (${s.lacunas.length}), o que faltou ler:`);
+        for (const l of s.lacunas)
+            linhas.push(`  • ${l.tipo}: ${l.detalhe}`);
+    }
+    linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}
+/**
+ * `ork network status --json`: o mesmo JSON, com os caracteres invisiveis escritos como `\uXXXX`
+ * (o valor lido e o mesmo; so o terminal deixa de executa-los). A quebra de linha da indentacao fica.
+ */
+function jsonDaRede(s) {
+    return (0, saida_segura_1.jsonSemInvisivel)(s);
+}