@orkastery/cli 0.5.6 → 0.6.0

package/dist/forja/api.js

@@ -0,0 +1,256 @@
+"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.chamadorDaApi = exports.limiteBaixo = exports.chaveDoLogin = exports.MAX_PAGINAS = exports.POR_PAGINA = exports.ESPERA_MAXIMA_DO_LIMITE_MS = exports.PRAZO_DA_API_MS = void 0;
+exports.temLogin = temLogin;
+exports.lerSaidaHttp = lerSaidaHttp;
+exports.chamarApi = chamarApi;
+exports.proximaPagina = proximaPagina;
+exports.paginarPelaApi = paginarPelaApi;
+exports.paginarApi = paginarApi;
+/**
+ * A chamada a API REST da forja pela CLI ja logada (`gh api`, `glab api`). O host vai sempre explicito (`CLI_DA_FORJA`),
+ * o corpo vai pelo stdin, a resposta vem com o status e os cabecalhos (`-i`), o ambiente e reduzido e o diretorio e
+ * neutro. O erro sai tipado pelo status HTTP. Um 429 em leitura espera o `tentarEm` uma vez, ate 60 s, e repete;
+ * escrita nunca se repete sozinha (quem chamou rele o estado antes de agir). No `glab`, que faz o pedido anonimo quando
+ * nao tem login no host, o login e conferido antes da primeira chamada de cada host do processo. A paginacao segue o
+ * `Link` (ou o `x-next-page` do GitLab) ate 10 paginas de 100; passou disso, `forja.incompleto`.
+ */
+const os = __importStar(require("node:os"));
+const forja_1 = require("../forja");
+const cli_1 = require("./cli");
+const executor_1 = require("./executor");
+exports.PRAZO_DA_API_MS = 30_000;
+exports.ESPERA_MAXIMA_DO_LIMITE_MS = 60_000;
+exports.POR_PAGINA = 100;
+exports.MAX_PAGINAS = 10;
+const TETO_DA_SAIDA = 32 * 1024 * 1024;
+const PRAZO_DO_LOGIN_MS = 15_000;
+const LOGINS = new Map();
+const falha = (codigo, detalhe) => ({ ok: false, erro: { codigo, detalhe } });
+const dormir = (ms) => { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); };
+/** A chave do login: o host como a CLI o guarda, `host` ou `host:porta`, nunca com o caminho base. */
+const chaveDoLogin = (f) => (0, cli_1.hostDaApi)(f);
+exports.chaveDoLogin = chaveDoLogin;
+/**
+ * A CLI do tipo tem login no host exato? O codigo de saida, e a saida quando a CLI nao filtra o host sozinha.
+ * `binario`: o caminho absoluto da CLI a rodar, sem busca no PATH.
+ */
+function temLogin(f, rodar = executor_1.rodarCli, binario) {
+    const cli = cli_1.CLI_DA_FORJA[f.tipo];
+    const s = rodar({ cmd: cli.cmd, args: cli.login(f), prazoMs: PRAZO_DO_LOGIN_MS, maxBuffer: 1024 * 1024, ...cli.ambiente(f),
+        cwd: os.tmpdir(), reduzido: true, ...(binario !== undefined ? { binario } : {}) });
+    return s.status === 0 && (cli.confirmaLogin?.(f, `${s.stdout}\n${s.stderr}`) ?? true);
+}
+/** A saida de `-i`: `HTTP/x NNN texto`, os cabecalhos ate a linha vazia (CRLF ou LF) e o corpo. */
+function lerSaidaHttp(stdout) {
+    const linha = /^HTTP\/\d(?:\.\d)? (\d{3})\b[^\n]*\n/.exec(stdout);
+    if (!linha)
+        return null;
+    const resto = stdout.slice(linha[0].length);
+    const cabecalhos = {};
+    let pos = 0;
+    for (;;) {
+        const fim = resto.indexOf('\n', pos);
+        if (fim < 0)
+            return null;
+        const l = resto.slice(pos, fim).replace(/\r$/, '');
+        pos = fim + 1;
+        if (l === '')
+            break;
+        const dois = l.indexOf(':');
+        if (dois > 0)
+            cabecalhos[l.slice(0, dois).trim().toLowerCase()] = l.slice(dois + 1).trim();
+    }
+    return { status: Number(linha[1]), cabecalhos, corpo: resto.slice(pos) };
+}
+const inteiro = (v) => (v !== undefined && /^\d+$/.test(v) ? Number(v) : null);
+function limiteDe(c) {
+    const reset = inteiro(c['ratelimit-reset'] ?? c['x-ratelimit-reset']);
+    return { restante: inteiro(c['ratelimit-remaining'] ?? c['x-ratelimit-remaining']), total: inteiro(c['ratelimit-limit'] ?? c['x-ratelimit-limit']),
+        reiniciaEm: reset === null ? null : new Date(reset * 1000).toISOString() };
+}
+/** A cota abaixo de 10 %: os consumidores de fundo (pulse, espera de CI) espacam as chamadas. */
+const limiteBaixo = (l) => l.restante !== null && l.total !== null && l.total > 0 && l.restante < l.total * 0.1;
+exports.limiteBaixo = limiteBaixo;
+/** Quando tentar de novo: o `Retry-After` (segundos ou data) ou o reset da cota (epoch em segundos). */
+function tentarEmDe(c, agora) {
+    const espera = c['retry-after'];
+    if (espera && /^\d+$/.test(espera))
+        return new Date(agora + Number(espera) * 1000).toISOString();
+    if (espera && Number.isFinite(Date.parse(espera)))
+        return new Date(Date.parse(espera)).toISOString();
+    const reset = inteiro(c['ratelimit-reset'] ?? c['x-ratelimit-reset']);
+    return reset === null ? null : new Date(reset * 1000).toISOString();
+}
+/** A mensagem do corpo de erro (`message` no GitHub e no GitLab, que as vezes a da como objeto). */
+function mensagemDoCorpo(texto) {
+    try {
+        const j = JSON.parse(texto);
+        const m = j && typeof j === 'object' ? j.message ?? j.error ?? j.error_description : undefined;
+        return typeof m === 'string' ? m : m === undefined ? '' : JSON.stringify(m);
+    }
+    catch {
+        return texto.trim().slice(0, 200);
+    }
+}
+function erroDoStatus(h, pedido, agora) {
+    const texto = mensagemDoCorpo(h.corpo);
+    const detalhe = (0, forja_1.detalheSeguro)(`HTTP ${h.status} ${pedido.metodo} ${pedido.caminho}${texto ? `: ${texto}` : ''}`);
+    // O GitHub responde 403, e nao 429, quando a cota primaria acaba (`x-ratelimit-remaining: 0`) e na secundaria.
+    // O limite secundario pode vir com a cota primaria sobrando e sem `Retry-After`: so a mensagem o diz, e a espera
+    // minima recomendada e de 60 s (o reset da cota primaria nao vale para ele).
+    const secundario = h.status === 403 && !('retry-after' in h.cabecalhos) && h.cabecalhos['x-ratelimit-remaining'] !== '0'
+        && /rate limit/i.test(texto);
+    const cota = h.status === 429 || (h.status === 403 && (h.cabecalhos['x-ratelimit-remaining'] === '0' || 'retry-after' in h.cabecalhos)) || secundario;
+    if (cota) {
+        const tentarEm = secundario ? new Date(agora + 60_000).toISOString() : tentarEmDe(h.cabecalhos, agora);
+        return { codigo: 'forja.limite', detalhe, ...(tentarEm ? { tentarEm } : {}) };
+    }
+    const codigo = h.status === 401 ? 'forja.sem-login' : h.status === 403 ? 'forja.sem-permissao'
+        : h.status === 404 ? 'forja.nao-achei' : h.status === 409 ? 'forja.conflito' : h.status >= 500 ? 'forja.indisponivel' : 'forja.pedido-recusado';
+    return { codigo, detalhe };
+}
+function umaChamada(f, pedido, rodar, agora) {
+    const cli = cli_1.CLI_DA_FORJA[f.tipo];
+    const prazoMs = pedido.prazoMs ?? exports.PRAZO_DA_API_MS;
+    const comCorpo = pedido.corpo !== undefined;
+    const s = rodar({ cmd: cli.cmd, args: cli.api(f, pedido.metodo, pedido.caminho, comCorpo), entrada: comCorpo ? JSON.stringify(pedido.corpo) : undefined,
+        prazoMs, maxBuffer: TETO_DA_SAIDA, ...cli.ambiente(f), cwd: os.tmpdir(), reduzido: true });
+    if (s.erro === 'ENOENT')
+        return falha('forja.ausente', `${cli.cmd}: ENOENT`);
+    // O estouro do teto tambem mata o processo com SIGTERM: vem antes do prazo.
+    if (s.erro === 'ENOBUFS')
+        return falha('forja.resposta-invalida', (0, forja_1.detalheSeguro)(`${pedido.metodo} ${pedido.caminho}: saida > ${TETO_DA_SAIDA} B`));
+    if (s.erro === 'ETIMEDOUT' || s.sinal === 'SIGTERM')
+        return falha('forja.indisponivel', `${cli.cmd}: ${Math.round(prazoMs / 1000)} s`);
+    const h = lerSaidaHttp(s.stdout);
+    if (!h) {
+        const texto = `${s.stderr}\n${s.stdout}`;
+        const semLogin = /auth login|not logged|not been authenticated|no token|GH_TOKEN|GITLAB_TOKEN/i.test(texto);
+        return falha(semLogin ? 'forja.sem-login' : 'forja.indisponivel', (0, forja_1.detalheSeguro)(s.stderr || s.stdout || `${cli.cmd}: ${s.status}`));
+    }
+    if (h.status < 200 || h.status >= 300)
+        return { ok: false, erro: erroDoStatus(h, pedido, agora) };
+    let corpo = null;
+    if (h.corpo.trim()) {
+        try {
+            corpo = JSON.parse(h.corpo);
+        }
+        catch {
+            return falha('forja.resposta-invalida', (0, forja_1.detalheSeguro)(`HTTP ${h.status} ${pedido.metodo} ${pedido.caminho}`));
+        }
+    }
+    return { ok: true, valor: { status: h.status, corpo, cabecalhos: h.cabecalhos, limite: limiteDe(h.cabecalhos) } };
+}
+function chamarApi(f, pedido, opcoes = {}) {
+    const rodar = opcoes.rodar ?? executor_1.rodarCli, agoraMs = opcoes.agoraMs ?? Date.now, esperar = opcoes.esperar ?? dormir;
+    const cli = cli_1.CLI_DA_FORJA[f.tipo];
+    // Um caminho com `-` na frente seria lido pela CLI como opcao.
+    if (pedido.caminho.startsWith('-'))
+        return falha('forja.pedido-recusado', (0, forja_1.detalheSeguro)(`${pedido.metodo} ${pedido.caminho}: caminho com - na frente`));
+    if (cli.loginAntes) {
+        const logins = opcoes.logins ?? LOGINS, chave = (0, exports.chaveDoLogin)(f);
+        let comLogin = logins.get(chave);
+        // So o login confirmado fica guardado: uma falha passageira nao marca o host como sem login pelo resto do processo.
+        if (comLogin === undefined) {
+            comLogin = temLogin(f, rodar);
+            if (comLogin)
+                logins.set(chave, true);
+        }
+        if (!comLogin)
+            return falha('forja.sem-login', `${cli.cmd} ${chave}`);
+    }
+    const r = umaChamada(f, pedido, rodar, agoraMs());
+    if (r.ok || r.erro.codigo !== 'forja.limite' || pedido.metodo !== 'GET' || !r.erro.tentarEm)
+        return r;
+    const espera = Date.parse(r.erro.tentarEm) - agoraMs();
+    if (espera > exports.ESPERA_MAXIMA_DO_LIMITE_MS)
+        return r;
+    esperar(Math.max(0, espera));
+    return umaChamada(f, pedido, rodar, agoraMs());
+}
+const chamadorDaApi = (f, opcoes = {}) => (p) => chamarApi(f, p, opcoes);
+exports.chamadorDaApi = chamadorDaApi;
+/** O numero da proxima pagina: do `Link` `rel="next"` ou do `x-next-page`. `sem-numero`: ha proxima sem `page=`. */
+function proximaPagina(cabecalhos) {
+    const link = cabecalhos.link;
+    // O header inteiro, sem cortar na virgula: a URL do next pode ter virgula (`labels=a,b`). Com `rel=next` e sem o
+    // numero lido, `sem-numero`, nunca o fim da lista.
+    if (link && /\brel="?next\b/.test(link)) {
+        const m = /<([^>]*)>\s*;\s*rel="?next\b/.exec(link);
+        const pagina = m ? /[?&]page=(\d+)/.exec(m[1]) : null;
+        return pagina ? Number(pagina[1]) : 'sem-numero';
+    }
+    return inteiro(cabecalhos['x-next-page'] || undefined);
+}
+function comPagina(caminho, pagina) {
+    const corte = caminho.indexOf('?');
+    const base = corte < 0 ? caminho : caminho.slice(0, corte);
+    const consulta = new URLSearchParams(corte < 0 ? '' : caminho.slice(corte + 1));
+    consulta.set('per_page', String(exports.POR_PAGINA));
+    consulta.set('page', String(pagina));
+    return `${base}?${consulta.toString()}`;
+}
+/**
+ * Le as paginas de uma lista (GET) por um chamador ja ligado a forja, pelo numero que a forja manda. `itens` extrai a
+ * lista do corpo (`null`: fora do formato); sem ele, o corpo tem de ser a lista. Mais de 10 paginas: `forja.incompleto`,
+ * nunca a lista curta.
+ */
+function paginarPelaApi(api, p) {
+    const extrair = p.itens ?? ((corpo) => (Array.isArray(corpo) ? corpo : null));
+    const itens = [];
+    let pagina = 1;
+    for (let lidas = 1; lidas <= exports.MAX_PAGINAS; lidas++) {
+        const r = api({ metodo: 'GET', caminho: comPagina(p.caminho, pagina), prazoMs: p.prazoMs });
+        if (!r.ok)
+            return r;
+        const lista = extrair(r.valor.corpo);
+        if (!lista)
+            return falha('forja.resposta-invalida', (0, forja_1.detalheSeguro)(p.caminho));
+        itens.push(...lista);
+        const proxima = proximaPagina(r.valor.cabecalhos);
+        if (proxima === null)
+            return { ok: true, valor: { itens, paginas: lidas } };
+        if (proxima === 'sem-numero' || proxima <= pagina)
+            return falha('forja.resposta-invalida', (0, forja_1.detalheSeguro)(`${p.caminho}: next`));
+        pagina = proxima;
+    }
+    return falha('forja.incompleto', (0, forja_1.detalheSeguro)(`${p.caminho} > ${exports.MAX_PAGINAS}x${exports.POR_PAGINA}`));
+}
+/** `paginarPelaApi` com o chamador da forja `f`. */
+function paginarApi(f, p, opcoes = {}) {
+    return paginarPelaApi((0, exports.chamadorDaApi)(f, opcoes), p);
+}

package/dist/forja/cache.js

@@ -0,0 +1,89 @@
+"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.VALIDADE_DO_CACHE_MS = void 0;
+exports.dirDoCacheDaForja = dirDoCacheDaForja;
+exports.lerDoCache = lerDoCache;
+exports.gravarNoCache = gravarNoCache;
+/**
+ * O cache da forja: um arquivo JSON por raiz do estado (`.orkastery/cache/forja.json`) com o que vale 24 h, a versao do
+ * servidor e o tipo sondado de um host. Arquivo ilegivel e entrada vencida (ou datada no futuro alem da folga do
+ * relogio) sao ignorados; escrita que falha tambem: o cache e conveniencia, e sem ele a leitura consulta de novo.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("../estado-thread");
+const manifest_1 = require("../manifest");
+exports.VALIDADE_DO_CACHE_MS = 24 * 60 * 60 * 1000;
+const ARQUIVO = 'forja.json';
+const FOLGA_DO_RELOGIO_MS = 5 * 60 * 1000;
+/** O diretorio do cache da raiz (a da arvore principal, tambem numa worktree); `null` sem estado legivel. */
+function dirDoCacheDaForja(raiz) {
+    try {
+        return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'cache');
+    }
+    catch {
+        return null;
+    }
+}
+function todos(dir) {
+    try {
+        const j = JSON.parse(fs.readFileSync(path.join(dir, ARQUIVO), 'utf8'));
+        return j && typeof j === 'object' && !Array.isArray(j) ? j : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** A entrada da chave gravada ha menos de 24 h, ou `null`. */
+function lerDoCache(dir, chave, agoraMs) {
+    if (!dir)
+        return null;
+    const e = todos(dir)[chave];
+    if (!e || typeof e !== 'object' || Array.isArray(e))
+        return null;
+    const t = Date.parse(String(e.lidoEm));
+    return Number.isFinite(t) && t <= agoraMs + FOLGA_DO_RELOGIO_MS && agoraMs - t < exports.VALIDADE_DO_CACHE_MS ? e : null;
+}
+/** Grava a entrada com `lidoEm`; pasta 700 e arquivo 600, os modos do estado do projeto. */
+function gravarNoCache(dir, chave, valor, agoraMs) {
+    if (!dir)
+        return;
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(path.join(dir, ARQUIVO), `${JSON.stringify({ ...todos(dir), [chave]: { ...valor, lidoEm: new Date(agoraMs).toISOString() } }, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch { /* sem escrita, a proxima leitura consulta de novo */ }
+}

package/dist/forja/cli.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_DA_FORJA = exports.hostDaApi = void 0;
+exports.versaoAbaixo = versaoAbaixo;
+/** `host` ou `host:porta`, sem a porta padrao do HTTPS e sem o caminho base: e tambem a chave do login da CLI. */
+const hostDaApi = (f) => (f.porta !== null && f.porta !== 443 ? `${f.host}:${f.porta}` : f.host);
+exports.hostDaApi = hostDaApi;
+const SEM_PROMPT = { GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GLAB_CHECK_UPDATE: 'false', GLAB_SEND_TELEMETRY: 'false', NO_COLOR: '1' };
+/** O host com porta: o `gh` recusa `--hostname host:porta` (medido no 2.102.0) e o recebe por `GH_HOST`. */
+const comPorta = (f) => (0, exports.hostDaApi)(f) !== f.host;
+const hostnameDoGh = (f) => (comPorta(f) ? [] : ['--hostname', f.host]);
+exports.CLI_DA_FORJA = {
+    github: {
+        cmd: 'gh',
+        // 2.18.0, medida: `pr list --json` com `headRefOid`, `api -i`, `auth status --hostname`, `auth git-credential`, `--body-file`.
+        minima: '2.18.0',
+        loginAntes: false,
+        // O gh nao tem opcao de CA; o Go le SSL_CERT_FILE no Linux. O GH_HOST herdado sai, salvo quando e o nosso (host:porta).
+        ambiente: (f) => ({
+            acrescentar: { ...SEM_PROMPT, ...(comPorta(f) ? { GH_HOST: (0, exports.hostDaApi)(f) } : {}), ...(f.ca ? { SSL_CERT_FILE: f.ca } : {}) },
+            apagar: [...(comPorta(f) ? [] : ['GH_HOST']), 'GH_REPO', 'GH_FORCE_TTY'],
+        }),
+        api: (f, metodo, caminho, comCorpo) => ['api', ...hostnameDoGh(f), '-i', '--method', metodo,
+            '-H', 'Accept: application/vnd.github+json', caminho, ...(comCorpo ? ['--input', '-'] : [])],
+        login: (f) => ['auth', 'status', ...hostnameDoGh(f)],
+        // Com porta, o `auth status` roda sem `--hostname` e sai 0 se QUALQUER host tem login: so vale a linha de login
+        // do host:porta exato, nos dois formatos do gh (`Logged in to H as U` e `Logged in to H account U`).
+        confirmaLogin: (f, saida) => !comPorta(f)
+            || new RegExp(`Logged in to ${(0, exports.hostDaApi)(f).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')} (?:as|account) `).test(saida),
+        entrar: (f) => (comPorta(f) ? [`GH_HOST=${(0, exports.hostDaApi)(f)}`, 'gh', 'auth', 'login'] : ['gh', 'auth', 'login', '--hostname', f.host]),
+        lerVersao: (s) => /^gh version (\d+\.\d+\.\d+)/m.exec(s)?.[1] ?? null,
+    },
+    gitlab: {
+        cmd: 'glab',
+        // 1.121.0, medida: GITLAB_HOST com porta, login com subcaminho, `auth git-credential`, GLAB_CA_CERT, `api -i`.
+        minima: '1.121.0',
+        loginAntes: true,
+        ambiente: (f) => ({
+            acrescentar: { ...SEM_PROMPT, GITLAB_HOST: (0, exports.hostDaApi)(f), ...(f.ca ? { GLAB_CA_CERT: f.ca } : {}) },
+            // Estas mudariam o host ou a CA por fora do GITLAB_HOST.
+            apagar: ['GITLAB_URI', 'GL_HOST', 'GITLAB_API_HOST', 'CA_CERT'],
+        }),
+        // Sem Content-Type, o GitLab ignora o corpo do `--input -` (medido).
+        api: (_f, metodo, caminho, comCorpo) => ['api', '-i', '--method', metodo, caminho,
+            ...(comCorpo ? ['-H', 'Content-Type: application/json', '--input', '-'] : [])],
+        login: (f) => ['auth', 'status', '--hostname', (0, exports.hostDaApi)(f)],
+        entrar: (f, http) => ['glab', 'auth', 'login', '--hostname', `${(0, exports.hostDaApi)(f)}${f.caminhoBase}`, ...(http ? ['--api-protocol', 'http'] : []), '--stdin'],
+        lerVersao: (s) => /^glab (?:version )?(\d+\.\d+\.\d+)/m.exec(s)?.[1] ?? null,
+    },
+};
+/** `versao` (x.y.z) abaixo de `minima`? */
+function versaoAbaixo(versao, minima) {
+    const a = versao.split('.').map(Number), b = minima.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const x = a[i] ?? 0, y = b[i] ?? 0;
+        if (x !== y)
+            return x < y;
+    }
+    return false;
+}

package/dist/forja/contrato.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * O contrato neutro da forja. Os tipos abaixo moram aqui e `forja.ts` os
+ * reexporta com o mesmo nome; nenhum depende de `gh` ou `glab`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIPOS_DE_FORJA = void 0;
+/** Os tipos de forja que o registro conhece, na ordem em que a sondagem os tenta. Sem import: o manifesto o le. */
+exports.TIPOS_DE_FORJA = ['github', 'gitlab'];

package/dist/forja/endereco.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostComPorta = exports.HOST_DO_REMOTO = void 0;
+exports.lerHostDoRemoto = lerHostDoRemoto;
+exports.lerEnderecoDoRemoto = lerEnderecoDoRemoto;
+/** Um parser só para as três formas de URL, com porta e subgrupos. */
+/** O host que o parser aceita: minusculas, rotulos sem hifen na ponta (nunca comeca por `-`). */
+exports.HOST_DO_REMOTO = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*$/;
+const HOST = exports.HOST_DO_REMOTO;
+const SEGMENTO = /^[A-Za-z0-9_.-]+$/;
+function caminhoValido(bruto) {
+    const c = bruto.replace(/^\/+/, '').replace(/\/+$/, '').replace(/\.git$/, '');
+    const partes = c.split('/');
+    return partes.length >= 2 && partes.every((p) => SEGMENTO.test(p) && p !== '.' && p !== '..') ? partes.join('/') : null;
+}
+/** Protocolo, host e porta de uma URL de remoto (https, http, ssh, git ou scp), com o caminho sem validar. */
+function lerHostDoRemoto(url) {
+    const t = url.trim();
+    const esquema = /^(https?|ssh|git|git\+ssh|ssh\+git):\/\/(?:[^@/]*@)?([^/:?#@]+)(?::(\d+))?\/([^?#\s]+)$/i.exec(t);
+    if (esquema) {
+        const host = esquema[2].toLowerCase();
+        if (!HOST.test(host))
+            return null;
+        const p = esquema[1].toLowerCase();
+        const protocolo = p === 'https' ? 'https' : p === 'http' ? 'http' : p === 'git' ? 'git' : 'ssh';
+        return { protocolo, host, porta: esquema[3] ? Number(esquema[3]) : null, caminhoBruto: esquema[4].replace(/^\/+/, '') };
+    }
+    const scp = /^(?:[^@\s/:]+@)?([^:\s/@]+):(?!\/\/)([^\s]+)$/.exec(t);
+    if (!scp)
+        return null;
+    const host = scp[1].toLowerCase();
+    return HOST.test(host) ? { protocolo: 'scp', host, porta: null, caminhoBruto: scp[2].replace(/^\/+/, '') } : null;
+}
+function lerEnderecoDoRemoto(url) {
+    const lido = lerHostDoRemoto(url);
+    const caminho = lido ? caminhoValido(lido.caminhoBruto) : null;
+    if (!lido || !caminho || (lido.porta !== null && (lido.porta < 1 || lido.porta > 65535)))
+        return null;
+    return { protocolo: lido.protocolo, host: lido.host, porta: lido.porta, caminho };
+}
+/** `host` ou `host:porta`, a forma que `--hostname` do `gh` e do `glab` aceita. */
+const hostComPorta = (e) => (e.porta ? `${e.host}:${e.porta}` : e.host);
+exports.hostComPorta = hostComPorta;

package/dist/forja/estado.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estadoDoCheck = estadoDoCheck;
+/** Os estados de commit status (GitHub e GitLab) e de job (GitLab) que reprovam: falha, erro e cancelamento. */
+const VERMELHOS = new Set(['failure', 'error', 'failed', 'canceled', 'cancelled', 'canceling']);
+/** O job que espera uma pessoa (`manual`) ou que a pipeline pulou (`skipped`): nao e verde para o gate. */
+const BLOQUEADOS = new Set(['manual', 'skipped']);
+/**
+ * O estado de um check, igual para o gate e para o pulse. O que cada um exige e dele. O check-run (GitHub) decide pela
+ * conclusao; o commit status (GitHub e GitLab) e o job de pipeline (GitLab) decidem pelo estado: `success` e verde,
+ * falha, erro e cancelamento sao vermelhos, `manual` e `skipped` sao bloqueados, e o resto (em fila, rodando,
+ * pendente, criado, aguardando recurso, preparando, agendado) e pendente.
+ */
+function estadoDoCheck(fonte, status, conclusao) {
+    const s = status.toLowerCase();
+    if (fonte !== 'check-run')
+        return s === 'success' ? 'verde' : VERMELHOS.has(s) ? 'vermelho' : BLOQUEADOS.has(s) ? 'bloqueado' : 'pendente';
+    if (s !== 'completed')
+        return 'pendente';
+    const c = (conclusao ?? '').toLowerCase();
+    return c === 'success' ? 'verde' : c === 'neutral' || c === 'skipped' ? 'bloqueado' : 'vermelho';
+}

package/dist/forja/executor.js

@@ -0,0 +1,73 @@
+"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.ambienteReduzido = ambienteReduzido;
+exports.rodarCli = rodarCli;
+/**
+ * O unico ponto que roda a CLI da forja. Sem shell e sem token: a CLI usa a autenticacao que ja tem. Cada consumidor
+ * diz o prazo, o teto de saida e o ambiente; a CI e a entrega externa usam 32 MiB, como a leitura da forja, e o gh
+ * e achado pelo `acharBinario` salvo nos consumidores que pedem `procurarBinario: false`.
+ */
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const rede_forja_1 = require("../rede-forja");
+/** O que a CLI da forja le do ambiente: o resto (chaves de outros servicos, `NODE_OPTIONS`) nao chega a ela. */
+const VARIAVEIS_DA_CLI = new Set(['PATH', 'HOME', 'USER', 'LOGNAME', 'LANG', 'LC_ALL', 'LC_MESSAGES', 'TMPDIR', 'XDG_CONFIG_HOME',
+    'XDG_DATA_HOME', 'XDG_STATE_HOME', 'XDG_CACHE_HOME', 'XDG_RUNTIME_DIR', 'DBUS_SESSION_BUS_ADDRESS', 'SSL_CERT_FILE', 'SSL_CERT_DIR',
+    'HTTPS_PROXY', 'HTTP_PROXY', 'NO_PROXY', 'https_proxy', 'http_proxy', 'no_proxy', 'ORK_BINARIOS_EXTRA', 'NO_COLOR']);
+const PREFIXOS_DA_CLI = ['GH_', 'GLAB_', 'GITLAB_', 'GITHUB_'];
+/** O ambiente reduzido: os tokens que a CLI le do ambiente passam sem o `ork` le-los. */
+function ambienteReduzido(env) {
+    const saida = {};
+    for (const [nome, valor] of Object.entries(env)) {
+        if (valor !== undefined && (VARIAVEIS_DA_CLI.has(nome) || PREFIXOS_DA_CLI.some((p) => nome.startsWith(p))))
+            saida[nome] = valor;
+    }
+    return saida;
+}
+function rodarCli(c) {
+    const env = { ...(c.base ?? (c.reduzido ? ambienteReduzido(process.env) : process.env)), ...(c.acrescentar ?? {}) };
+    for (const nome of c.apagar ?? [])
+        delete env[nome];
+    if (c.binario !== undefined && !path.isAbsolute(c.binario)) {
+        return { status: null, stdout: '', stderr: '', sinal: null, erro: 'EINVAL', mensagemDoErro: 'binario sem caminho absoluto' };
+    }
+    const exe = c.binario ?? (c.procurarBinario === false ? null : (0, rede_forja_1.acharBinario)(c.cmd, { env })) ?? c.cmd;
+    const r = (0, node_child_process_1.spawnSync)(exe, [...c.args], {
+        cwd: c.cwd, input: c.entrada, encoding: 'utf8', timeout: c.prazoMs, maxBuffer: c.maxBuffer, env,
+    });
+    return { status: r.status, stdout: (r.stdout ?? '').toString(), stderr: (r.stderr ?? '').toString(), sinal: r.signal ?? null,
+        ...(r.error ? { erro: r.error.code ?? r.error.message, mensagemDoErro: r.error.message } : {}) };
+}

package/dist/forja/github/ci.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checksNoCommitGithub = checksNoCommitGithub;
+exports.estadoDeCiGithub = estadoDeCiGithub;
+/** Uma pagina tem no maximo 100 itens; 10 paginas (1000 check-runs) e o teto da leitura. */
+const POR_PAGINA = 100;
+const MAX_PAGINAS = 10;
+function chamar(e, caminho) {
+    const r = e.executor({ repository: e.repository, sha: e.sha, context: e.context, host: e.host, caminho });
+    // Sem trim aqui: quem formata o detalhe (ci.ts) apara e corta, como sempre fez.
+    if (!r.ok)
+        return { ok: false, erro: { codigo: 'forja.indisponivel', detalhe: r.stderr || r.stdout } };
+    try {
+        return { ok: true, valor: JSON.parse(r.stdout) };
+    }
+    catch {
+        return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: '' } };
+    }
+}
+const invalida = (detalhe = '') => ({ ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe } });
+/**
+ * Le as paginas 1..10 ate uma pagina curta. `itens` extrai a lista da resposta (`null`: fora do formato). Passou do
+ * teto sem pagina curta: `forja.resposta-invalida` com detalhe `incompleto`.
+ */
+function paginar(e, caminho, itens) {
+    const todos = [];
+    for (let pagina = 1; pagina <= MAX_PAGINAS; pagina++) {
+        const lido = chamar(e, caminho(pagina));
+        if (!lido.ok)
+            return lido;
+        const lista = itens(lido.valor);
+        if (!lista)
+            return invalida();
+        todos.push(...lista);
+        if (lista.length < POR_PAGINA)
+            return { ok: true, valor: todos };
+    }
+    return invalida('incompleto');
+}
+/**
+ * Os check-runs (paginados, filtrados por nome no servidor e de novo aqui) e os commit statuses (paginados, os mais
+ * novos primeiro) com o nome `context` no commit. Resposta fora do formato, de qualquer das duas chamadas, e
+ * `forja.resposta-invalida`; lista que passa do teto de paginas tambem, com detalhe `incompleto`: nunca vira ausente.
+ */
+function checksNoCommitGithub(e) {
+    const base = `repos/${e.repository}/commits/${e.sha}`;
+    // A lista so termina numa pagina curta. O `total_count` nao encerra a leitura (um valor baixo cortaria a lista
+    // cedo); ele so confere: lista que acabou antes do total declarado esta incompleta. Mais itens que o total nao e
+    // erro (um run novo entre duas paginas).
+    let total = null;
+    const lidosRuns = paginar(e, (pagina) => `${base}/check-runs?check_name=${encodeURIComponent(e.context)}&filter=all&per_page=${POR_PAGINA}&page=${pagina}`, (valor) => {
+        const payload = valor;
+        if (!payload || typeof payload !== 'object' || !Array.isArray(payload.check_runs))
+            return null;
+        if (typeof payload.total_count === 'number')
+            total = Math.max(total ?? 0, payload.total_count);
+        return payload.check_runs;
+    });
+    if (!lidosRuns.ok)
+        return lidosRuns;
+    if (total !== null && lidosRuns.valor.length < total)
+        return invalida('incompleto');
+    const runs = lidosRuns.valor;
+    // O GitHub lista toda transicao de todo contexto: um vermelho do `ork-verify` pode estar alem da primeira pagina.
+    const lidosStatuses = paginar(e, (pagina) => `${base}/statuses?per_page=${POR_PAGINA}&page=${pagina}`, (valor) => (Array.isArray(valor) ? valor : null));
+    if (!lidosStatuses.ok)
+        return lidosStatuses;
+    const statuses = lidosStatuses.valor;
+    const valor = [
+        ...runs.filter((c) => c && c.name === e.context).map((c, i) => ({
+            nome: c.name, fonte: 'check-run', produtor: c.app?.slug ?? null, status: c.status ?? 'unknown',
+            conclusao: c.conclusion ?? null, url: c.html_url ?? null, concluidoEm: c.completed_at ?? null,
+            ordem: Number.isSafeInteger(c.id) ? c.id : i,
+        })),
+        // Os statuses vem do mais novo para o mais velho: sem id, a ordem de reserva decresce com a posicao.
+        ...statuses.filter((s) => s && s.context === e.context).map((s, i) => ({
+            nome: s.context, fonte: 'commit-status', produtor: s.creator?.login ?? null, status: s.state ?? 'unknown',
+            conclusao: null, url: s.target_url ?? null, concluidoEm: s.updated_at ?? null,
+            ordem: Number.isSafeInteger(s.id) ? s.id : -i,
+        })),
+    ];
+    return { ok: true, valor };
+}
+/**
+ * A mesma leitura pela API da forja ja resolvida: os check-runs e os statuses do commit, pelo chamador em vez do
+ * `ExecutorCi`. O GitHub nao testa commit temporario fora do lido: `mescladoSemVinculo` e sempre falso.
+ */
+function estadoDeCiGithub(e) {
+    const executor = (input) => {
+        const r = e.api({ metodo: 'GET', caminho: input.caminho ?? `repos/${input.repository}/commits/${input.sha}/check-runs` });
+        return r.ok ? { ok: true, code: 0, stdout: JSON.stringify(r.valor.corpo), stderr: '' } : { ok: false, code: 1, stdout: '', stderr: r.erro.detalhe };
+    };
+    const lido = checksNoCommitGithub({ repository: e.repo, sha: e.sha, context: e.context, executor });
+    return lido.ok ? { ok: true, valor: { checks: lido.valor, mescladoSemVinculo: false } } : lido;
+}