@orkastery/cli 0.5.6 → 0.6.0

package/dist/forja/gitlab/pedidos.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESTADOS_DO_MR = exports.projetoNaApi = void 0;
+exports.prDoMr = prDoMr;
+exports.caminhoDosMrsDaBranch = caminhoDosMrsDaBranch;
+exports.pedidosDaBranchGitlab = pedidosDaBranchGitlab;
+exports.abrirPedidoGitlab = abrirPedidoGitlab;
+exports.pedidoMescladoGitlab = pedidoMescladoGitlab;
+exports.branchPadraoGitlab = branchPadraoGitlab;
+exports.pontaDaBranchGitlab = pontaDaBranchGitlab;
+exports.compararGitlab = compararGitlab;
+const texto_1 = require("../texto");
+const SHA = /^[0-9a-f]{40}$/, BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
+/** O projeto na API: o caminho completo codificado (`projects/grupo%2Fsub%2Fprojeto`). */
+const projetoNaApi = (repo) => `projects/${encodeURIComponent(repo)}`;
+exports.projetoNaApi = projetoNaApi;
+/** O estado do MR, no REST e no GraphQL. `locked` e o merge em curso: o MR ainda nao entrou na base. */
+exports.ESTADOS_DO_MR = { opened: 'aberto', locked: 'aberto', merged: 'mesclado', closed: 'fechado' };
+/** O GitLab ainda calcula a mesclabilidade: o conflito nao e conhecido. */
+const EM_CALCULO = new Set(['unchecked', 'checking', 'preparing', 'approvals_syncing']);
+function instante(v) {
+    if (typeof v !== 'string')
+        return null;
+    const ms = Date.parse(v);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+/**
+ * Um MR da resposta, ou `null` quando nao e desta base nem deste projeto: de fork (outro projeto de origem), de outra
+ * base ou de branch que nao e nome de branch. Formato errado lanca: a leitura inteira vira "nao lida". Os checks ficam
+ * vazios: a lista nao traz o job do head.
+ */
+function prDoMr(bruto, base) {
+    if (!bruto || typeof bruto !== 'object')
+        throw new Error('MR fora do formato');
+    const m = bruto;
+    const estado = exports.ESTADOS_DO_MR[String(m.state)];
+    // As versoes antigas so tem `work_in_progress`.
+    const rascunho = typeof m.draft === 'boolean' ? m.draft : m.work_in_progress;
+    if (typeof m.iid !== 'number' || !Number.isSafeInteger(m.iid) || m.iid < 1 || typeof m.sha !== 'string' || !SHA.test(m.sha) || !estado ||
+        typeof rascunho !== 'boolean' || !Number.isSafeInteger(m.source_project_id) || !Number.isSafeInteger(m.target_project_id)) {
+        throw new Error('MR fora do formato');
+    }
+    if (m.source_project_id !== m.target_project_id || m.target_branch !== base || typeof m.source_branch !== 'string' ||
+        !BRANCH.test(m.source_branch))
+        return null;
+    const url = typeof m.web_url === 'string' && /^https?:\/\/\S+$/.test(m.web_url) ? m.web_url.slice(0, 300) : null;
+    const conflito = estado !== 'aberto' ? undefined : m.has_conflicts === true ? true
+        : m.has_conflicts === false && !EM_CALCULO.has(String(m.detailed_merge_status)) ? false : null;
+    return { numero: m.iid, branch: m.source_branch, head: m.sha, estado, rascunho, url, criadoEm: instante(m.created_at),
+        mescladoEm: instante(m.merged_at), checks: [], ...(conflito !== undefined ? { conflito } : {}) };
+}
+/** O caminho da lista de MRs de uma branch na API, como a leitura o pede. */
+function caminhoDosMrsDaBranch(repo, branch) {
+    const consulta = new URLSearchParams({ source_branch: branch, state: 'all', per_page: '100' });
+    return `${(0, exports.projetoNaApi)(repo)}/merge_requests?${consulta.toString()}`;
+}
+/** Os MRs de uma branch na base, do mais novo para o mais velho; `erro` com o codigo `forja.*` quando a leitura falha. */
+function pedidosDaBranchGitlab(e) {
+    if (!e.api)
+        return { prs: [], erro: 'forja.sem-capacidade: pedidosDaBranch sem a API do GitLab' };
+    const r = e.api({ metodo: 'GET', caminho: caminhoDosMrsDaBranch(e.repositorio, e.branch), prazoMs: e.prazoMs });
+    if (!r.ok)
+        return { prs: [], erro: (0, texto_1.deFora)(`${r.erro.codigo}: ${r.erro.detalhe}`) };
+    // Mais de 100 MRs da mesma branch: a lista nao foi lida inteira, e nunca vira a lista curta.
+    if (r.valor.cabecalhos['x-next-page'])
+        return { prs: [], erro: (0, texto_1.deFora)(`forja.incompleto: ${e.branch} > 100`) };
+    if (!Array.isArray(r.valor.corpo))
+        return { prs: [], erro: 'forja.resposta-invalida: a resposta nao e uma lista' };
+    try {
+        const prs = r.valor.corpo.map((x) => prDoMr(x, e.base)).filter((p) => !!p && p.branch === e.branch);
+        return { prs: prs.sort((a, b) => b.numero - a.numero), erro: null };
+    }
+    catch (err) {
+        return { prs: [], erro: (0, texto_1.deFora)(`forja.resposta-invalida: ${err.message}`) };
+    }
+}
+/**
+ * Abre o MR da branch na base. Escrita: nunca se repete sozinha (quem chamou rele a lista). O status e o stderr
+ * seguem o `gh pr create` (0, ou 1 com o codigo `forja.*` no stderr); o stdout e o JSON do MR criado.
+ */
+function abrirPedidoGitlab(e) {
+    if (!e.api)
+        return { status: 1, stdout: '', stderr: 'forja.sem-capacidade: abrirPedido sem a API do GitLab' };
+    const r = e.api({ metodo: 'POST', caminho: `${(0, exports.projetoNaApi)(e.repositorio)}/merge_requests`, prazoMs: e.prazoMs,
+        corpo: { source_branch: e.branch, target_branch: e.base, title: e.titulo, description: e.corpo } });
+    return r.ok ? { status: 0, stdout: JSON.stringify(r.valor.corpo), stderr: '' }
+        : { status: 1, stdout: '', stderr: (0, texto_1.deFora)(`${r.erro.codigo}: ${r.erro.detalhe}`, 300) };
+}
+/** O corpo de um GET que deu certo, quando e objeto; `null` sem a API, com erro ou fora do formato. */
+function lerObjeto(api, caminho) {
+    if (!api)
+        return null;
+    const r = api({ metodo: 'GET', caminho });
+    return r.ok && r.valor.corpo !== null && typeof r.valor.corpo === 'object' && !Array.isArray(r.valor.corpo) ? r.valor.corpo : null;
+}
+const sha = (v) => (typeof v === 'string' && SHA.test(v) ? v : null);
+/**
+ * O MR da entrega externa, pelo `iid`; `null` quando a consulta falha. O merge e o commit de merge (metodos `merge` e
+ * `rebase_merge`), o do squash (`ff` com squash) ou o proprio head (`ff` sem squash: o head entra na base sem commit
+ * novo, e o `ship(<thread>)` nunca chega a ela; e por isso que essa entrega vem por aqui).
+ */
+function pedidoMescladoGitlab(e) {
+    const mr = lerObjeto(e.api, `${(0, exports.projetoNaApi)(e.repo)}/merge_requests/${e.numero}`);
+    if (!mr)
+        return null;
+    const mesclado = mr.state === 'merged';
+    const headSha = sha(mr.sha);
+    return {
+        numero: e.numero, mesclado, headSha,
+        mergeSha: sha(mr.merge_commit_sha) ?? sha(mr.squash_commit_sha) ?? (mesclado ? headSha : null),
+        base: typeof mr.target_branch === 'string' && BRANCH.test(mr.target_branch) ? mr.target_branch : null,
+        branch: typeof mr.source_branch === 'string' ? mr.source_branch : null,
+        titulo: typeof mr.title === 'string' ? mr.title : null, corpo: typeof mr.description === 'string' ? mr.description : null,
+        url: typeof mr.web_url === 'string' && /^https?:\/\/\S+$/.test(mr.web_url) ? mr.web_url : null,
+    };
+}
+/** A branch padrao do projeto; `''` se a resposta nao a traz; `null` quando a consulta falha. */
+function branchPadraoGitlab(e) {
+    const p = lerObjeto(e.api, (0, exports.projetoNaApi)(e.repo));
+    return p ? (typeof p.default_branch === 'string' ? p.default_branch : '') : null;
+}
+/** O sha da ponta da branch (`commit.id` no GitLab); `null` quando a consulta falha ou nao ha sha valido. */
+function pontaDaBranchGitlab(e) {
+    const b = lerObjeto(e.api, `${(0, exports.projetoNaApi)(e.repo)}/repository/branches/${encodeURIComponent(e.branch)}`);
+    return sha(b?.commit?.id);
+}
+/**
+ * A ponta `ate` contem o merge `de`? Pela base de mesclagem (`straight=false`): os commits de `de` que a base de
+ * mesclagem com `ate` nao tem. Nenhum: `ahead`; algum: `diverged` (o GitLab nao separa `behind`). `null` sem leitura.
+ */
+function compararGitlab(e) {
+    if (!sha(e.de) || !sha(e.ate))
+        return null;
+    if (e.de === e.ate)
+        return 'identical';
+    const consulta = new URLSearchParams({ from: e.ate, to: e.de, straight: 'false' });
+    const r = lerObjeto(e.api, `${(0, exports.projetoNaApi)(e.repo)}/repository/compare?${consulta.toString()}`);
+    if (!r || r.compare_timeout === true || !Array.isArray(r.commits))
+        return null;
+    return r.commits.length === 0 ? 'ahead' : 'diverged';
+}

package/dist/forja/produtor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRODUTORES_PADRAO = void 0;
+exports.produtoresAceitos = produtoresAceitos;
+exports.produtorAceito = produtorAceito;
+exports.produtorDeSaida = produtorDeSaida;
+exports.PRODUTORES_PADRAO = {
+    github: ['github-actions'],
+    gitlab: ['gitlab-ci'],
+};
+/** Os produtores aceitos para uma forja do tipo: os do manifesto ou, sem eles, o padrao. */
+function produtoresAceitos(m, tipo) {
+    return m.ci.produtor ?? exports.PRODUTORES_PADRAO[tipo];
+}
+/** O check veio de um produtor da lista? Produtor desconhecido (`null`) nunca e aceito. */
+function produtorAceito(c, aceitos) {
+    if (!c.produtor)
+        return false;
+    if (c.fonte !== 'commit-status')
+        return aceitos.includes(c.produtor);
+    const app = /^(.+)\[bot\]$/.exec(c.produtor)?.[1];
+    return (app !== undefined && aceitos.includes(app)) || aceitos.includes(`status:${c.produtor}`);
+}
+/**
+ * O produtor como a pessoa o escreve em `ci.produtor` (e como o `ork ci status --json` o devolve): o slug para check-run
+ * e job da forja, o slug do app para a conta `<slug>[bot]` e `status:<login>` para qualquer outra conta de commit status.
+ */
+function produtorDeSaida(c) {
+    if (!c.produtor || c.fonte !== 'commit-status')
+        return c.produtor;
+    return /^(.+)\[bot\]$/.exec(c.produtor)?.[1] ?? `status:${c.produtor}`;
+}

package/dist/forja/registro.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptadorDaForja = void 0;
+exports.exigirCapacidade = exigirCapacidade;
+const metadados_1 = require("./github/metadados");
+const metadados_2 = require("./gitlab/metadados");
+const dono_da_rede_1 = require("./github/dono-da-rede");
+const ci_1 = require("./github/ci");
+const ci_2 = require("./gitlab/ci");
+const dono_da_rede_2 = require("./gitlab/dono-da-rede");
+const pedidos_1 = require("./gitlab/pedidos");
+const pedidos_abertos_1 = require("./gitlab/pedidos-abertos");
+const pedidos_2 = require("./github/pedidos");
+const ADAPTADORES = {
+    github: { tipo: 'github', checksNoCommit: ci_1.checksNoCommitGithub, estadoDeCi: ci_1.estadoDeCiGithub,
+        pedidoMesclado: pedidos_2.pedidoMescladoGithub, branchPadrao: pedidos_2.branchPadraoGithub, pontaDaBranch: pedidos_2.pontaDaBranchGithub, comparar: pedidos_2.compararGithub,
+        pedidosDaBranch: pedidos_2.pedidosDaBranchGithub, abrirPedido: pedidos_2.abrirPedidoGithub, metadados: metadados_1.metadadosGithub,
+        pedidosAbertos: pedidos_2.pedidosAbertosGithub, donoDaRede: dono_da_rede_1.donoDaRedeGithub },
+    // O GitLab le a CI so pelo `estadoDeCi`: o `checksNoCommit` e o caminho antigo do executor do `gh`, e o doctor nao o cobra.
+    gitlab: { tipo: 'gitlab', estadoDeCi: ci_2.estadoDeCiGitlab, metadados: metadados_2.metadadosGitlab, pedidosAbertos: pedidos_abertos_1.pedidosAbertosGitlab,
+        donoDaRede: dono_da_rede_2.donoDaRedeGitlab, pedidosDaBranch: pedidos_1.pedidosDaBranchGitlab, abrirPedido: pedidos_1.abrirPedidoGitlab,
+        pedidoMesclado: pedidos_1.pedidoMescladoGitlab, branchPadrao: pedidos_1.branchPadraoGitlab, pontaDaBranch: pedidos_1.pontaDaBranchGitlab, comparar: pedidos_1.compararGitlab },
+};
+const adaptadorDaForja = (tipo) => ADAPTADORES[tipo];
+exports.adaptadorDaForja = adaptadorDaForja;
+function exigirCapacidade(a, k) {
+    const f = a[k];
+    if (!f)
+        throw new Error(`forja.sem-capacidade: ${a.tipo} não tem ${k}`);
+    return f;
+}

package/dist/forja/resolver.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SONDAS_PADRAO = exports.hostConhecido = void 0;
+exports.sondasPadrao = sondasPadrao;
+exports.resolverForja = resolverForja;
+const api_1 = require("./api");
+const cache_1 = require("./cache");
+const cli_1 = require("./cli");
+const contrato_1 = require("./contrato");
+const executor_1 = require("./executor");
+const HOSTS_CONHECIDOS = {
+    'github.com': { tipo: 'github', host: 'github.com' },
+    'ssh.github.com': { tipo: 'github', host: 'github.com' },
+    'gitlab.com': { tipo: 'gitlab', host: 'gitlab.com' },
+    'altssh.gitlab.com': { tipo: 'gitlab', host: 'gitlab.com' },
+};
+/** O tipo e o host da web de um host conhecido (o SSH pela 443 tambem), ou `null`. */
+const hostConhecido = (host) => HOSTS_CONHECIDOS[host] ?? null;
+exports.hostConhecido = hostConhecido;
+const PRAZO_DA_SONDA_MS = 15_000;
+const objeto = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** As sondas pela CLI com login: o login e conferido antes; sem ele, a API nao e chamada. */
+function sondasPadrao(rodar = executor_1.rodarCli, logins) {
+    return {
+        github: (alvo) => {
+            // O GitHub nao e servido em subcaminho.
+            if (alvo.caminhoBase)
+                return 'nao-responde';
+            const f = { tipo: 'github', ...alvo };
+            if (!(0, api_1.temLogin)(f, rodar))
+                return 'sem-login';
+            const r = (0, api_1.chamarApi)(f, { metodo: 'GET', caminho: 'meta', prazoMs: PRAZO_DA_SONDA_MS }, { rodar, logins });
+            return r.ok && objeto(r.valor.corpo) && typeof r.valor.corpo.verifiable_password_authentication === 'boolean' ? 'responde' : 'nao-responde';
+        },
+        // O `chamarApi` confere o login do glab antes do pedido.
+        gitlab: (alvo) => {
+            const r = (0, api_1.chamarApi)({ tipo: 'gitlab', ...alvo }, { metodo: 'GET', caminho: 'metadata', prazoMs: PRAZO_DA_SONDA_MS }, { rodar, logins });
+            if (!r.ok)
+                return r.erro.codigo === 'forja.sem-login' ? 'sem-login' : 'nao-responde';
+            return objeto(r.valor.corpo) && typeof r.valor.corpo.version === 'string' ? 'responde' : 'nao-responde';
+        },
+    };
+}
+exports.SONDAS_PADRAO = sondasPadrao();
+const erro = (codigo, detalhe) => ({ ok: false, erro: { codigo, detalhe } });
+function resolverForja(e) {
+    const m = e.manifesto ?? {};
+    const r = e.endereco;
+    const web = r.protocolo === 'https' || r.protocolo === 'http';
+    const ssh = r.protocolo === 'ssh' || r.protocolo === 'scp' || r.protocolo === 'git';
+    const conhecidoDoRemoto = (0, exports.hostConhecido)(r.host);
+    const hostDoRemoto = conhecidoDoRemoto?.host ?? r.host;
+    const declarado = m.host ? ((0, exports.hostConhecido)(m.host)?.host ?? m.host) : null;
+    const portaPadrao = r.protocolo === 'http' ? 80 : 443;
+    const portaDoRemoto = web && !conhecidoDoRemoto && r.porta !== null && r.porta !== portaPadrao ? r.porta : null;
+    // O host da API sai do remoto: o manifesto so o confirma, nunca o troca. A unica troca e a do SSH declarado
+    // (`ssh_host`), em que o remoto nomeia o host do SSH e o manifesto, o da web.
+    // So `ssh` e `scp` dividem (nao o `git://`, sem autenticacao), e o host da web declarado nunca e um host conhecido:
+    // o gate dispensa o login no github.com, entao um manifesto nao pode apontar o SSH de um terceiro para ele.
+    const dividido = (r.protocolo === 'ssh' || r.protocolo === 'scp') && !conhecidoDoRemoto && !!m.ssh_host && r.host === m.ssh_host;
+    if (dividido && m.host && (0, exports.hostConhecido)(m.host))
+        return erro('forja.remoto-divergente', `${r.host} !~ ${m.host}`);
+    if (declarado && !dividido && declarado !== hostDoRemoto)
+        return erro('forja.remoto-divergente', `${r.host} != ${declarado}`);
+    const host = dividido ? (declarado ?? r.host) : hostDoRemoto;
+    if (m.porta !== undefined && !dividido) {
+        // A porta do remoto SSH e a do SSH, nao a da API: so um remoto web ou um host conhecido restringe a porta.
+        const exigida = conhecidoDoRemoto ? null : web ? portaDoRemoto : m.porta;
+        if (m.porta !== exigida)
+            return erro('forja.remoto-divergente', `${host}: porta ${m.porta} != ${exigida ?? 'padrao'}`);
+    }
+    const caminhoBase = m.caminho_base ?? '';
+    let repo = r.caminho;
+    if (caminhoBase && web) {
+        const prefixo = `${caminhoBase.slice(1)}/`;
+        if (!repo.startsWith(prefixo) || repo.slice(prefixo.length).split('/').length < 2) {
+            return erro('forja.remoto-divergente', `${r.caminho} !~ ${caminhoBase}`);
+        }
+        repo = repo.slice(prefixo.length);
+    }
+    const porta = m.porta ?? portaDoRemoto;
+    const valor = {
+        host, porta, caminhoBase,
+        sshHost: m.ssh_host ?? (ssh && r.host !== host ? r.host : null),
+        sshPorta: m.ssh_porta ?? (r.protocolo === 'ssh' ? r.porta : null),
+        ca: m.ca ?? null, repo,
+    };
+    const origem = {
+        host: (m.host ? 'manifesto' : 'remoto'),
+        porta: (m.porta !== undefined ? 'manifesto' : portaDoRemoto !== null ? 'remoto' : 'padrao'),
+        caminhoBase: (m.caminho_base !== undefined ? 'manifesto' : 'padrao'),
+    };
+    const conhecido = (0, exports.hostConhecido)(host);
+    if (m.tipo) {
+        if (conhecido && conhecido.tipo !== m.tipo)
+            return erro('forja.remoto-divergente', `${host}: ${conhecido.tipo} != ${m.tipo}`);
+        return { ok: true, valor: { tipo: m.tipo, ...valor, origem: { tipo: 'manifesto', ...origem } } };
+    }
+    if (conhecido)
+        return { ok: true, valor: { tipo: conhecido.tipo, ...valor, origem: { tipo: 'remoto', ...origem } } };
+    const sondas = e.sondas ?? exports.SONDAS_PADRAO;
+    const alvo = { host, porta, caminhoBase, ca: valor.ca };
+    // O tipo sondado vale 24 h: so a resposta unica e guardada; a duvida volta a sondar.
+    const agora = e.agoraMs ?? Date.now();
+    const chaveDoCache = `sondagem ${(0, cli_1.hostDaApi)(alvo)}${caminhoBase}`;
+    const guardado = (0, cache_1.lerDoCache)(e.cache ?? null, chaveDoCache, agora)?.tipo;
+    if (contrato_1.TIPOS_DE_FORJA.includes(guardado)) {
+        return { ok: true, valor: { tipo: guardado, ...valor, origem: { tipo: 'sondagem', ...origem } } };
+    }
+    const respostas = contrato_1.TIPOS_DE_FORJA.flatMap((tipo) => {
+        const sonda = sondas[tipo];
+        return sonda ? [{ tipo, resposta: sonda(alvo) }] : [];
+    });
+    const responderam = respostas.filter((x) => x.resposta === 'responde');
+    if (responderam.length === 1) {
+        (0, cache_1.gravarNoCache)(e.cache ?? null, chaveDoCache, { tipo: responderam[0].tipo }, agora);
+        return { ok: true, valor: { tipo: responderam[0].tipo, ...valor, origem: { tipo: 'sondagem', ...origem } } };
+    }
+    const resumo = respostas.map((x) => `${x.tipo} ${x.resposta}`).join(', ');
+    return erro(responderam.length > 1 ? 'forja.ambigua' : 'forja.desconhecida', `${(0, cli_1.hostDaApi)(alvo)}${caminhoBase} (${resumo})`);
+}

package/dist/forja/texto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.umaLinha = umaLinha;
+exports.deFora = deFora;
+const hitl_1 = require("../hitl");
+/** Texto curto: uma linha, sem controle, com teto. */
+function umaLinha(texto, teto = 200) {
+    return Array.from(texto.replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim()).slice(0, teto).join('') || '-';
+}
+/** Texto de fora (stderr do git ou do gh): sem segredo, numa linha e com teto, antes de ir ao `--json` e ao ledger. */
+function deFora(texto, teto = 200) {
+    return umaLinha((0, hitl_1.redigirSegredos)(texto), teto);
+}

package/dist/forja/versao.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAIXAS = exports.VALIDADE_DO_CACHE_MS = void 0;
+exports.faixaDaVersao = faixaDaVersao;
+exports.recusaAbaixoDoPiso = recusaAbaixoDoPiso;
+exports.lerMetadados = lerMetadados;
+/**
+ * A versao e a edicao do servidor da forja, e a faixa de compromisso dela: `testada` (as minors em que a bateria de
+ * contrato roda antes de cada release), `compativel` (do piso em diante; funciona, com degradacao explicita onde
+ * faltar recurso) e `abaixo-do-piso` (recusa clara, nunca comportamento parcial). A leitura fica 24 h no cache da forja
+ * (`forja/cache.ts`), por host.
+ */
+const api_1 = require("./api");
+const cache_1 = require("./cache");
+const cli_1 = require("./cli");
+const registro_1 = require("./registro");
+const texto_1 = require("./texto");
+var cache_2 = require("./cache");
+Object.defineProperty(exports, "VALIDADE_DO_CACHE_MS", { enumerable: true, get: function () { return cache_2.VALIDADE_DO_CACHE_MS; } });
+/**
+ * A janela testada e o piso de cada forja com faixas. A janela sao as tres minors mantidas pelo GitLab na data da
+ * release do ork: atualize a lista a cada release, depois de a bateria de contrato passar nelas.
+ */
+exports.FAIXAS = {
+    gitlab: { testadas: ['19.4', '19.3', '19.2'], piso: '17.0' },
+};
+const minor = (v) => {
+    const m = /^(\d+)\.(\d+)/.exec(v);
+    return m ? [Number(m[1]), Number(m[2])] : null;
+};
+const comparar = (a, b) => a[0] - b[0] || a[1] - b[1];
+function faixaDaVersao(tipo, versao) {
+    const f = exports.FAIXAS[tipo];
+    const v = versao ? minor(versao) : null;
+    if (!f || !v)
+        return 'sem-faixa';
+    if (comparar(v, minor(f.piso)) < 0)
+        return 'abaixo-do-piso';
+    return f.testadas.some((t) => comparar(v, minor(t)) === 0) ? 'testada' : 'compativel';
+}
+/**
+ * O erro de quem nao opera abaixo do piso; `null` na faixa. Na forja com faixas, a versao ilegivel (a do cache com
+ * `versao: null` ou fora de `N.N`) tambem recusa: sem saber a versao, o piso nao esta provado.
+ */
+function recusaAbaixoDoPiso(tipo, m) {
+    if (m.faixa === 'abaixo-do-piso')
+        return { codigo: 'forja.versao-abaixo-do-piso', detalhe: `${tipo} ${m.versao} < ${exports.FAIXAS[tipo]?.piso}` };
+    if (m.faixa === 'sem-faixa' && exports.FAIXAS[tipo]) {
+        return { codigo: 'forja.versao-abaixo-do-piso', detalhe: `${tipo}: versão ilegível (${m.versao === null ? 'nula' : (0, texto_1.deFora)(m.versao)})` };
+    }
+    return null;
+}
+/** A versao, a edicao e a faixa da forja; do cache quando ele tem menos de 24 h. */
+function lerMetadados(f, o) {
+    const agora = o.agoraMs ?? Date.now();
+    const chave = `metadados ${f.tipo} ${(0, cli_1.hostDaApi)(f)}${f.caminhoBase}`;
+    const g = (0, cache_1.lerDoCache)(o.cache, chave, agora);
+    if (g && (g.versao === null || typeof g.versao === 'string') && (g.edicao === null || g.edicao === 'ce' || g.edicao === 'ee')) {
+        const versao = g.versao;
+        return { ok: true, valor: { versao, edicao: g.edicao, lidoEm: String(g.lidoEm),
+                faixa: faixaDaVersao(f.tipo, versao), doCache: true } };
+    }
+    const capacidade = (0, registro_1.adaptadorDaForja)(f.tipo).metadados;
+    if (!capacidade)
+        return { ok: false, erro: { codigo: 'forja.sem-capacidade', detalhe: `${f.tipo} metadados` } };
+    const lido = capacidade({ api: o.api ?? (0, api_1.chamadorDaApi)(f, { rodar: o.rodar }) });
+    if (!lido.ok)
+        return lido;
+    (0, cache_1.gravarNoCache)(o.cache, chave, { ...lido.valor }, agora);
+    return { ok: true, valor: { ...lido.valor, lidoEm: new Date(agora).toISOString(), faixa: faixaDaVersao(f.tipo, lido.valor.versao), doCache: false } };
+}