@orkastery/cli 0.5.3 → 0.6.0

package/dist/forja/github/dono-da-rede.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.donoDaRedeGithub = donoDaRedeGithub;
+function donoDaRedeGithub(e) {
+    if (!e.dono.trim())
+        return { ok: false, erro: { codigo: 'forja.nao-achei', detalhe: 'dono vazio' } };
+    const eu = e.api({ metodo: 'GET', caminho: 'user' });
+    if (!eu.ok)
+        return eu;
+    const c = eu.valor.corpo;
+    const p = c && typeof c === 'object' && !Array.isArray(c) ? c : null;
+    if (!p || typeof p.login !== 'string' || !Number.isSafeInteger(p.id) || p.id <= 0) {
+        return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: 'user' } };
+    }
+    if (p.login !== e.dono)
+        return { ok: false, erro: { codigo: 'forja.nao-achei', detalhe: `${e.dono}: nao e o login ${p.login}` } };
+    return { ok: true, valor: { tipo: 'usuario', caminho: p.login, namespaceId: p.id, nivel: null } };
+}

package/dist/forja/github/metadados.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadadosGithub = metadadosGithub;
+const zod_1 = require("zod");
+const META = zod_1.z.object({ verifiable_password_authentication: zod_1.z.boolean(), installed_version: zod_1.z.string().optional() });
+/** `GET /meta`: o GitHub Enterprise Server diz a versao (`installed_version`); o github.com, nenhuma. */
+function metadadosGithub(e) {
+    const r = e.api({ metodo: 'GET', caminho: 'meta' });
+    if (!r.ok)
+        return r;
+    const lido = META.safeParse(r.valor.corpo);
+    if (!lido.success)
+        return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: 'meta: verifiable_password_authentication' } };
+    return { ok: true, valor: { versao: lido.data.installed_version ?? null, edicao: null } };
+}

package/dist/forja/github/pedidos.js

@@ -0,0 +1,200 @@
+"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.pedidoMescladoGithub = pedidoMescladoGithub;
+exports.branchPadraoGithub = branchPadraoGithub;
+exports.pontaDaBranchGithub = pontaDaBranchGithub;
+exports.compararGithub = compararGithub;
+exports.pedidosDaBranchGithub = pedidosDaBranchGithub;
+exports.abrirPedidoGithub = abrirPedidoGithub;
+exports.pedidosAbertosGithub = pedidosAbertosGithub;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const texto_1 = require("../texto");
+const SHA = /^[0-9a-f]{40}$/, BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
+function lerJson(r) {
+    if (!r.ok)
+        return null;
+    try {
+        return JSON.parse(r.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+function pedidoMescladoGithub(e) {
+    const pr = lerJson(e.executor(`repos/${e.repo}/pulls/${e.numero}`));
+    if (!pr)
+        return null;
+    return {
+        numero: e.numero, mesclado: pr.merged === true,
+        mergeSha: typeof pr.merge_commit_sha === 'string' && SHA.test(pr.merge_commit_sha) ? pr.merge_commit_sha : null,
+        headSha: typeof pr.head?.sha === 'string' && SHA.test(pr.head.sha) ? pr.head.sha : null,
+        base: typeof pr.base?.ref === 'string' && BRANCH.test(pr.base.ref) ? pr.base.ref : null,
+        branch: typeof pr.head?.ref === 'string' ? pr.head.ref : null,
+        titulo: typeof pr.title === 'string' ? pr.title : null, corpo: typeof pr.body === 'string' ? pr.body : null,
+        url: typeof pr.html_url === 'string' ? pr.html_url : null,
+    };
+}
+function branchPadraoGithub(e) {
+    const r = lerJson(e.executor(`repos/${e.repo}`));
+    return r ? (r.default_branch ?? '') : null;
+}
+function pontaDaBranchGithub(e) {
+    const r = lerJson(e.executor(`repos/${e.repo}/branches/${encodeURIComponent(e.branch)}`));
+    return typeof r?.commit?.sha === 'string' && SHA.test(r.commit.sha) ? r.commit.sha : null;
+}
+function compararGithub(e) {
+    const r = lerJson(e.executor(`repos/${e.repo}/compare/${e.de}...${e.ate}`));
+    return r ? String(r.status) : null;
+}
+/** Os campos do `gh pr list` de uma branch: os do `prDaForja`, com o estado de merge do PR aberto. */
+const CAMPOS_DA_BRANCH = 'number,state,headRefName,headRefOid,baseRefName,isDraft,isCrossRepository,url,createdAt,mergedAt,mergeable';
+/** Os PRs de uma branch, da base do projeto, do mais novo para o mais velho. */
+function pedidosDaBranchGithub(e) {
+    const r = e.executor(['pr', 'list', `--repo=${e.host}/${e.repositorio}`, `--head=${e.branch}`, '--state=all', '--limit=10',
+        `--json=${CAMPOS_DA_BRANCH}`], e.prazoMs);
+    if (r.status !== 0)
+        return { prs: [], erro: (0, texto_1.deFora)(r.stderr || r.stdout || `codigo ${r.status ?? '-'}`) };
+    try {
+        const lista = JSON.parse(r.stdout);
+        if (!Array.isArray(lista))
+            throw new Error('a resposta nao e uma lista');
+        // Carga tardia: o parado-no-condutor chega a este módulo pelo entrega-pr; importar no topo fecharia um ciclo de carga.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { prDaForja } = require('../../parado-no-condutor');
+        const prs = lista.map((p) => prDaForja(p, 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)(err.message) };
+    }
+}
+/** Abre o PR da branch na base. */
+function abrirPedidoGithub(e) {
+    // O corpo vai por arquivo 600 num diretorio proprio: texto que parece flag (`--repo=outro/repo`) ou de 64 KiB nao toca o argv.
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-pr-'));
+    try {
+        const arquivo = path.join(dir, 'corpo.md');
+        fs.writeFileSync(arquivo, e.corpo, { mode: 0o600 });
+        return e.executor(['pr', 'create', `--repo=${e.host}/${e.repositorio}`, `--base=${e.base}`, `--head=${e.branch}`, `--title=${e.titulo}`,
+            '--body-file', arquivo], e.prazoMs);
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Os campos dos recentes e os dos abertos, com o rollup e o estado de merge (RM-059, F7). */
+const CAMPOS_DOS_RECENTES = 'number,state,headRefName,headRefOid,baseRefName,isDraft,isCrossRepository,url,createdAt,mergedAt';
+const CAMPOS_DOS_ABERTOS = `${CAMPOS_DOS_RECENTES},statusCheckRollup,mergeable`;
+/** O texto de fora numa linha, sem segredo e com teto (`deFora`); vazio vira "sem detalhe". */
+const detalheDeFora = (v, teto) => (v.replace(/\p{Cc}/gu, ' ').trim() ? (0, texto_1.deFora)(v, teto) : 'sem detalhe');
+/**
+ * Os PRs da base para o pulse, pelo `gh pr list`: os abertos com o rollup (ate o teto; lista cheia e `parcial`), os
+ * recentes de qualquer estado, e cada candidata que nao apareceu, conferida pelo `--head` enquanto houver tempo
+ * (acima do teto ou sem tempo, ela fica em `semConferir`, que e "PR nao lido", nunca "sem PR"). O `gh` usa a
+ * autenticacao dele; nenhum token passa por aqui.
+ */
+function pedidosAbertosGithub(e) {
+    // Carga tardia: o parado-no-condutor chega a este modulo pelo registro; importar no topo fecharia um ciclo de carga.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { prDaForja } = require('../../parado-no-condutor');
+    const l = e.limites, repo = `--repo=${e.forja.host}/${e.forja.repo}`;
+    const falha = (detalhe, codigo = 'forja.indisponivel') => ({ ok: false, erro: { codigo, detalhe } });
+    const pedir = (args) => {
+        if (e.resta() <= 0)
+            return `gh pr list: orçamento de ${Math.round(e.orcamentoMs / 1000)} s da leitura esgotado`;
+        const r = e.executor(['pr', 'list', repo, `--base=${e.base}`, ...args], Math.min(l.prazoMs, e.resta()));
+        if (r.status !== 0) {
+            const detalhe = detalheDeFora(r.stderr || r.stdout || '', 160);
+            return `gh pr list falhou (${r.status === null ? 'sem código de saída' : `código ${r.status}`}): ${detalhe}`;
+        }
+        try {
+            const lista = JSON.parse(r.stdout);
+            if (!Array.isArray(lista))
+                throw new Error('a resposta não é uma lista');
+            return lista;
+        }
+        catch (err) {
+            return `resposta do gh pr list fora do formato: ${detalheDeFora(err.message, 120)}`;
+        }
+    };
+    try {
+        const porNumero = new Map();
+        const juntar = (lista, comChecks) => {
+            for (const bruto of lista) {
+                const pr = prDaForja(bruto, e.base);
+                if (!pr || porNumero.has(pr.numero))
+                    continue;
+                // A leitura sem rollup nunca diz que o aberto nao tem checks.
+                if (!comChecks && pr.estado === 'aberto')
+                    pr.checks = [{ nome: 'checks não lidos', situacao: 'pendente', concluidoEm: null }];
+                porNumero.set(pr.numero, pr);
+            }
+        };
+        const abertos = pedir(['--state=open', `--limit=${l.abertos}`, `--json=${CAMPOS_DOS_ABERTOS}`]);
+        if (typeof abertos === 'string')
+            return falha(abertos);
+        juntar(abertos, true);
+        const recentes = pedir(['--state=all', `--limit=${l.recentes}`, `--json=${CAMPOS_DOS_RECENTES}`]);
+        if (typeof recentes === 'string')
+            return falha(recentes);
+        juntar(recentes, false);
+        // Antes de dizer "sem PR", a candidata e conferida sozinha (o mesclado velho fica fora dos recentes).
+        const achadas = new Set([...porNumero.values()].map((p) => p.branch));
+        const faltam = [...new Set(e.candidatas)].filter((b) => BRANCH.test(b) && !achadas.has(b));
+        const semConferir = [];
+        for (const [i, branch] of faltam.entries()) {
+            if (i >= l.candidatas || e.resta() < l.minimoDaConferenciaMs) {
+                semConferir.push(branch);
+                continue;
+            }
+            const daBranch = pedir(['--state=all', `--head=${branch}`, '--limit=5', `--json=${CAMPOS_DOS_RECENTES}`]);
+            try {
+                if (typeof daBranch === 'string')
+                    throw new Error(daBranch);
+                juntar(daBranch, false);
+            }
+            catch {
+                semConferir.push(branch);
+            }
+        }
+        return { ok: true, valor: { prs: [...porNumero.values()], parcial: abertos.length >= l.abertos, semConferir } };
+    }
+    catch (err) {
+        return falha(`resposta do gh pr list fora do formato: ${detalheDeFora(err.message, 120)}`, 'forja.resposta-invalida');
+    }
+}

package/dist/forja/gitlab/ci.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PIPELINES = void 0;
+exports.estadoDeCiGitlab = estadoDeCiGitlab;
+/**
+ * A CI de um commit no GitLab. O check exigido e lido dos commit statuses do commit, filtrados pelo nome e com as
+ * reexecucoes (`all=true`). So um job real de pipeline do projeto e `pipeline-job` (produtor `gitlab-ci`): o status
+ * traz o `pipeline_id`, e um job com o mesmo id e o mesmo nome esta na lista de jobs dessa pipeline (status e job sao
+ * a mesma linha no GitLab). O `pipeline_id` sozinho nao prova nada: um `POST /statuses` com nome novo entra na
+ * pipeline real (pelo `pipeline_id` ou pelo `ref` do MR) e um com `ref` de branch cria uma pipeline `external`; nos
+ * dois casos o status e um job `external`, que a lista de jobs nao traz. Ele fica `commit-status`, com o usuario que o
+ * criou como produtor.
+ *
+ * Resultado mesclado e merge train (EE) testam um commit temporario, nao o head. Sem job do check no head, numa
+ * instancia que pode te-los (edicao EE ou desconhecida, com a opcao ligada no projeto), a leitura procura a pipeline do
+ * pedido cujo commit tem o head como pai (o `CI_MERGE_REQUEST_SOURCE_BRANCH_SHA` que o job recebe); o vinculo e lido
+ * do proprio commit, pela API. Pipeline candidata sem esse pai marca `mescladoSemVinculo`.
+ *
+ * Qualquer erro de leitura, pagina a mais ou item fora do esquema sai como erro, nunca como lista curta.
+ */
+const zod_1 = require("zod");
+const api_1 = require("../api");
+const estado_1 = require("../estado");
+const pedidos_1 = require("./pedidos");
+const INSTANTES = { created_at: zod_1.z.string().nullish(), started_at: zod_1.z.string().nullish(), finished_at: zod_1.z.string().nullish() };
+const STATUS = zod_1.z.object({ id: zod_1.z.number().int(), name: zod_1.z.string(), status: zod_1.z.string(), target_url: zod_1.z.string().nullish(),
+    pipeline_id: zod_1.z.number().int().nullish(), author: zod_1.z.object({ username: zod_1.z.string() }).passthrough().nullish(), ...INSTANTES }).passthrough();
+const JOB = zod_1.z.object({ id: zod_1.z.number().int(), name: zod_1.z.string(), status: zod_1.z.string(), web_url: zod_1.z.string().nullish(),
+    pipeline: zod_1.z.object({ id: zod_1.z.number().int(), project_id: zod_1.z.number().int().nullish() }).passthrough(), ...INSTANTES }).passthrough();
+const PROJETO = zod_1.z.object({ id: zod_1.z.number().int(), merge_pipelines_enabled: zod_1.z.boolean().nullish(), merge_trains_enabled: zod_1.z.boolean().nullish() })
+    .passthrough();
+const PEDIDO = zod_1.z.object({ iid: zod_1.z.number().int(), sha: zod_1.z.string().nullish() }).passthrough();
+/** O sha completo: o que entra no caminho da API, de fora ou da resposta, tem esta forma. */
+const SHA = /^[0-9a-f]{40}$/;
+const PIPELINE = zod_1.z.object({ id: zod_1.z.number().int(), project_id: zod_1.z.number().int().nullish(), sha: zod_1.z.string().regex(SHA), ref: zod_1.z.string() }).passthrough();
+const COMMIT = zod_1.z.object({ id: zod_1.z.string(), parent_ids: zod_1.z.array(zod_1.z.string()) }).passthrough();
+/** As pipelines distintas que a leitura confere por commit (e por pedido, no resultado mesclado). */
+exports.MAX_PIPELINES = 10;
+const falha = (codigo, detalhe) => ({ ok: false, erro: { codigo, detalhe } });
+/** Uma lista paginada, cada item no esquema; item fora dele e `forja.resposta-invalida`. */
+function lista(api, caminho, esquema) {
+    const lido = (0, api_1.paginarPelaApi)(api, { caminho });
+    if (!lido.ok)
+        return lido;
+    const itens = zod_1.z.array(esquema).safeParse(lido.valor.itens);
+    return itens.success ? { ok: true, valor: itens.data } : falha('forja.resposta-invalida', caminho.split('?')[0]);
+}
+/** Um objeto, no esquema. */
+function um(api, caminho, esquema) {
+    const r = api({ metodo: 'GET', caminho });
+    if (!r.ok)
+        return r;
+    const lido = esquema.safeParse(r.valor.corpo);
+    return lido.success ? { ok: true, valor: lido.data } : falha('forja.resposta-invalida', caminho);
+}
+/** A data que escolhe o mais novo de um produtor: `null` enquanto pendente; sem data nenhuma, `''` (a mais velha). */
+function concluidoEm(fonte, s) {
+    if ((0, estado_1.estadoDoCheck)(fonte, s.status, null) === 'pendente')
+        return null;
+    return s.finished_at ?? s.started_at ?? s.created_at ?? '';
+}
+const doJob = (j) => ({ nome: j.name, fonte: 'pipeline-job', produtor: 'gitlab-ci', status: j.status, conclusao: null,
+    url: j.web_url ?? null, concluidoEm: concluidoEm('pipeline-job', j), ordem: j.id });
+const jobsDaPipeline = (api, projeto, pipeline) => lista(api, `${projeto}/pipelines/${pipeline}/jobs?include_retried=true`, JOB);
+function estadoDeCiGitlab(e) {
+    if (!SHA.test(e.sha))
+        return falha('forja.pedido-recusado', 'o sha do commit não tem 40 caracteres hexadecimais minúsculos');
+    const projeto = (0, pedidos_1.projetoNaApi)(e.repo);
+    const lidos = lista(e.api, `${projeto}/repository/commits/${e.sha}/statuses?name=${encodeURIComponent(e.context)}&all=true`, STATUS);
+    if (!lidos.ok)
+        return lidos;
+    const doNome = lidos.valor.filter((s) => s.name === e.context);
+    const pipelines = [...new Set(doNome.flatMap((s) => (typeof s.pipeline_id === 'number' ? [s.pipeline_id] : [])))].sort((a, b) => a - b);
+    if (pipelines.length > exports.MAX_PIPELINES)
+        return falha('forja.incompleto', `${e.context}: ${pipelines.length} pipelines > ${exports.MAX_PIPELINES}`);
+    // O job real de cada status: mesma pipeline, mesmo id e mesmo nome. A lista e a do projeto pedido; pipeline de outro
+    // projeto nao esta nela (404, que sai como erro).
+    const reais = new Map();
+    for (const pipeline of pipelines) {
+        const jobs = jobsDaPipeline(e.api, projeto, pipeline);
+        if (!jobs.ok)
+            return jobs;
+        for (const j of jobs.valor)
+            if (j.name === e.context && j.pipeline.id === pipeline)
+                reais.set(`${pipeline}:${j.id}`, j);
+    }
+    const checks = doNome.map((s) => {
+        const job = typeof s.pipeline_id === 'number' ? reais.get(`${s.pipeline_id}:${s.id}`) : undefined;
+        if (job)
+            return doJob(job);
+        return { nome: s.name, fonte: 'commit-status', produtor: s.author?.username ?? null, status: s.status, conclusao: null,
+            url: s.target_url ?? null, concluidoEm: concluidoEm('commit-status', s), ordem: s.id };
+    });
+    if (checks.some((c) => c.fonte === 'pipeline-job'))
+        return { ok: true, valor: { checks, mescladoSemVinculo: false } };
+    const mesclado = doResultadoMesclado(e, projeto);
+    if (!mesclado.ok)
+        return mesclado;
+    return { ok: true, valor: { checks: [...checks, ...mesclado.valor.checks], mescladoSemVinculo: mesclado.valor.mescladoSemVinculo } };
+}
+/** Os jobs do check na pipeline de resultado mesclado do pedido ligada ao head pelo pai do commit dela. */
+function doResultadoMesclado(e, projeto) {
+    const nada = { ok: true, valor: { checks: [], mescladoSemVinculo: false } };
+    if (e.edicao === 'ce')
+        return nada;
+    const opcoes = um(e.api, projeto, PROJETO);
+    if (!opcoes.ok)
+        return opcoes;
+    if (opcoes.valor.merge_pipelines_enabled !== true && opcoes.valor.merge_trains_enabled !== true)
+        return nada;
+    const id = opcoes.valor.id;
+    const pedidos = lista(e.api, `${projeto}/repository/commits/${e.sha}/merge_requests`, PEDIDO);
+    if (!pedidos.ok)
+        return pedidos;
+    let semVinculo = false;
+    for (const pedido of pedidos.valor.filter((p) => p.sha === e.sha)) {
+        const doPedido = lista(e.api, `${projeto}/merge_requests/${pedido.iid}/pipelines`, PIPELINE);
+        if (!doPedido.ok)
+            return doPedido;
+        const ref = new RegExp(`^refs/merge-requests/${pedido.iid}/(?:merge|train)$`);
+        // So a pipeline do proprio projeto: a de um fork roda o codigo e a CI de outro projeto.
+        const candidatas = doPedido.valor.filter((p) => p.project_id === id && p.sha !== e.sha && ref.test(p.ref))
+            .sort((a, b) => b.id - a.id).slice(0, exports.MAX_PIPELINES);
+        for (const p of candidatas) {
+            const commit = um(e.api, `${projeto}/repository/commits/${p.sha}`, COMMIT);
+            if (!commit.ok)
+                return commit;
+            if (!commit.valor.parent_ids.includes(e.sha)) {
+                semVinculo = true;
+                continue;
+            }
+            const jobs = jobsDaPipeline(e.api, projeto, p.id);
+            if (!jobs.ok)
+                return jobs;
+            const doCheck = jobs.valor.filter((j) => j.name === e.context && j.pipeline.id === p.id && j.pipeline.project_id === id);
+            if (doCheck.length)
+                return { ok: true, valor: { checks: doCheck.map(doJob), mescladoSemVinculo: false } };
+        }
+    }
+    return { ok: true, valor: { checks: [], mescladoSemVinculo: semVinculo } };
+}

package/dist/forja/gitlab/consultas.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * As consultas GraphQL do adaptador GitLab, num lugar so: o codigo e o roteiro que grava as respostas reais
+ * (`scripts/forja-contrato.cjs`, que as le do `dist`) usam o mesmo texto. So consulta, sem mutation; o que vem do
+ * pedido vai em variaveis, nunca interpolado.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSULTA_ARVORES_GITLAB = exports.CONSULTA_RAIZ_GITLAB = exports.CONSULTA_DOS_ABERTOS_SEGUINTES = exports.CONSULTA_DOS_PEDIDOS = void 0;
+exports.consultaDeBlobsDoGitlab = consultaDeBlobsDoGitlab;
+/** Os campos de um MR que o pulse le, nas tres listas. */
+const CAMPOS_DO_PEDIDO = 'iid sourceBranch targetBranch diffHeadSha draft state webUrl createdAt mergedAt sourceProjectId targetProjectId';
+/** Os do MR aberto: os de todos, o conflito, a pipeline do head e o job do check da CI (`$check`) dela, com o estagio. */
+const CAMPOS_DO_ABERTO = `${CAMPOS_DO_PEDIDO} conflicts headPipeline { sha status finishedAt ` +
+    'job(name: $check) { status startedAt finishedAt stage { name } } }';
+/**
+ * Os MRs da base numa consulta so: os abertos (100 por pagina), os recentes de qualquer estado (100) e os das
+ * branches candidatas (ate 50). Medido no CE 17.0 e 19.4: complexidade 140 de 250. Lista vazia de candidatas nao devolve
+ * MR nenhum (`null` devolveria todos, por isso a variavel e obrigatoria).
+ */
+exports.CONSULTA_DOS_PEDIDOS = `query($path: ID!, $base: String!, $candidatas: [String!]!, $check: String!) {
+  queryComplexity { score limit }
+  project(fullPath: $path) {
+    id
+    abertos: mergeRequests(state: opened, targetBranches: [$base], sort: CREATED_DESC, first: 100) {
+      pageInfo { hasNextPage endCursor } nodes { ${CAMPOS_DO_ABERTO} } }
+    recentes: mergeRequests(state: all, targetBranches: [$base], sort: CREATED_DESC, first: 100) { nodes { ${CAMPOS_DO_PEDIDO} } }
+    daBranch: mergeRequests(state: all, targetBranches: [$base], sourceBranches: $candidatas, sort: CREATED_DESC, first: 50) {
+      pageInfo { hasNextPage } nodes { ${CAMPOS_DO_PEDIDO} } }
+  }
+}`;
+/** A pagina seguinte dos abertos, pelo cursor da anterior. */
+exports.CONSULTA_DOS_ABERTOS_SEGUINTES = `query($path: ID!, $base: String!, $depois: String!, $check: String!) {
+  queryComplexity { score limit }
+  project(fullPath: $path) {
+    id
+    abertos: mergeRequests(state: opened, targetBranches: [$base], sort: CREATED_DESC, first: 100, after: $depois) {
+      pageInfo { hasNextPage endCursor } nodes { ${CAMPOS_DO_ABERTO} } }
+  }
+}`;
+exports.CONSULTA_RAIZ_GITLAB = 'query($path: ID!) { project(fullPath: $path) { repository { rootRef } } }';
+exports.CONSULTA_ARVORES_GITLAB = `query($path: ID!, $base: String!, $dirRoadmap: String!, $refReservas: String!, $dirReservas: String!,
+  $refFabrica: String!, $dirFabrica: String!) {
+  project(fullPath: $path) { repository {
+    baseTopo: tree(ref: $base) { lastCommit { sha committedDate } }
+    baseDir: tree(ref: $base, path: $dirRoadmap) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
+    reservasTopo: tree(ref: $refReservas) { lastCommit { sha committedDate } }
+    reservasDir: tree(ref: $refReservas, path: $dirReservas) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
+    fabricaTopo: tree(ref: $refFabrica) { lastCommit { sha committedDate } }
+    fabricaDir: tree(ref: $refFabrica, path: $dirFabrica) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
+  } }
+}`;
+/** Os blobs de cada ponta que existe; so as partes pedidas entram na consulta (texto fixo, sem interpolar o pedido). */
+function consultaDeBlobsDoGitlab(partes) {
+    const sufixo = { base: 'Base', reservas: 'Reservas', fabrica: 'Fabrica' };
+    const declaracoes = ['$path: ID!', ...partes.flatMap((p) => [`$ref${sufixo[p]}: String!`, `$paths${sufixo[p]}: [String!]!`])];
+    const campos = partes.map((p) => `${p}: blobs(ref: $ref${sufixo[p]}, paths: $paths${sufixo[p]}, first: 100) ` +
+        '{ pageInfo { hasNextPage } nodes { path rawTextBlob } }');
+    return `query(${declaracoes.join(', ')}) { project(fullPath: $path) { repository { ${campos.join(' ')} } } }`;
+}

package/dist/forja/gitlab/dono-da-rede.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.donoDaRedeGitlab = donoDaRedeGitlab;
+const obj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const id = (v) => Number.isSafeInteger(v) && v > 0;
+const invalida = (detalhe) => ({ ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe } });
+const naoAchei = (detalhe) => ({ ok: false, erro: { codigo: 'forja.nao-achei', detalhe } });
+function donoDaRedeGitlab(e) {
+    if (!e.dono.trim())
+        return naoAchei('dono vazio');
+    const ns = e.api({ metodo: 'GET', caminho: `namespaces/${encodeURIComponent(e.dono)}` });
+    if (!ns.ok)
+        return ns;
+    const n = ns.valor.corpo;
+    if (!obj(n) || !id(n.id) || (n.kind !== 'user' && n.kind !== 'group') || typeof n.full_path !== 'string')
+        return invalida(`namespaces/${e.dono}`);
+    // O GitLab acha o namespace sem diferenciar maiusculas; outro caminho na resposta e outra coisa.
+    if (n.full_path.toLowerCase() !== e.dono.toLowerCase())
+        return invalida(`namespaces/${e.dono}: ${n.full_path}`);
+    const eu = e.api({ metodo: 'GET', caminho: 'user' });
+    if (!eu.ok)
+        return eu;
+    const pessoa = eu.valor.corpo;
+    if (!obj(pessoa) || !id(pessoa.id))
+        return invalida('user');
+    if (n.kind === 'user') {
+        // Um token de admin le o namespace de qualquer usuario com 200; so o da propria pessoa serve de casa.
+        const propria = (typeof pessoa.username === 'string' && pessoa.username.toLowerCase() === n.full_path.toLowerCase()) || pessoa.namespace_id === n.id;
+        if (!propria)
+            return naoAchei(`namespaces/${e.dono}: nao e da pessoa logada`);
+        return { ok: true, valor: { tipo: 'usuario', caminho: n.full_path, namespaceId: n.id, nivel: null } };
+    }
+    const membro = e.api({ metodo: 'GET', caminho: `groups/${n.id}/members/all/${pessoa.id}` });
+    // Fora do grupo, nem herdado: 404, nivel 0.
+    if (!membro.ok && membro.erro.codigo === 'forja.nao-achei')
+        return { ok: true, valor: { tipo: 'grupo', caminho: n.full_path, namespaceId: n.id, nivel: 0 } };
+    if (!membro.ok)
+        return membro;
+    const m = membro.valor.corpo;
+    if (!obj(m) || !Number.isSafeInteger(m.access_level))
+        return invalida(`groups/${n.id}/members/all`);
+    return { ok: true, valor: { tipo: 'grupo', caminho: n.full_path, namespaceId: n.id, nivel: m.access_level } };
+}

package/dist/forja/gitlab/metadados.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadadosGitlab = metadadosGitlab;
+const zod_1 = require("zod");
+const METADATA = zod_1.z.object({ version: zod_1.z.string().regex(/^\d+\.\d+/), enterprise: zod_1.z.boolean() });
+/** `GET /metadata`: a versao e a edicao da instancia. Responde tambem abaixo do piso (16.11 gravada), e a recusa e de quem le. */
+function metadadosGitlab(e) {
+    const r = e.api({ metodo: 'GET', caminho: 'metadata' });
+    if (!r.ok)
+        return r;
+    const lido = METADATA.safeParse(r.valor.corpo);
+    if (!lido.success)
+        return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: 'metadata: version, enterprise' } };
+    return { ok: true, valor: { versao: lido.data.version, edicao: lido.data.enterprise ? 'ee' : 'ce' } };
+}

package/dist/forja/gitlab/pedidos-abertos.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pedidosAbertosGitlab = pedidosAbertosGitlab;
+/**
+ * Os MRs da base para o pulse, numa consulta GraphQL (todos os tiers; o REST pediria uma chamada por MR): os abertos
+ * com a pipeline do head e o job do check da CI (`ci.context`), os recentes de qualquer estado e os das branches
+ * candidatas. Os abertos paginam de 100 em 100 ate o teto; com a cota abaixo de 10 % a paginacao para, e o que faltou
+ * e `parcial`, nunca "sem MR". MR de fork (`sourceProjectId` de outro projeto) e de outra base ficam de fora, como o
+ * `isCrossRepository` do GitHub. O estado de cada job e da pipeline sai da regra unica (`estadoDoCheck`); como no
+ * GitHub, o pulse conta o pulado de proposito (`manual`, `skipped`) como verde. O status externo (`POST /statuses`)
+ * entra na pipeline com o estagio `external`: nunca e o check da CI, e a pipeline sem o job nao fica verde no pulse.
+ */
+const api_1 = require("../api");
+const estado_1 = require("../estado");
+const texto_1 = require("../texto");
+const consultas_1 = require("./consultas");
+const pedidos_1 = require("./pedidos");
+const obj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const SHA = /^[0-9a-f]{40}$/, BRANCH = /^[A-Za-z0-9._/-]{1,200}$/, IID = /^[1-9]\d{0,9}$/;
+class ForaDoFormato extends Error {
+}
+/** Instante ISO de fora; ano antes de 2000 nao vale. */
+function instante(v) {
+    if (typeof v !== 'string')
+        return null;
+    const ms = Date.parse(v);
+    return Number.isFinite(ms) && new Date(ms).getUTCFullYear() >= 2000 ? new Date(ms).toISOString() : null;
+}
+function situacao(status) {
+    if (typeof status !== 'string')
+        return 'pendente';
+    const estado = (0, estado_1.estadoDoCheck)('pipeline-job', status, null);
+    return estado === 'bloqueado' ? 'verde' : estado;
+}
+/** Os checks do MR aberto: a pipeline do head e o job do check da CI dela, com o nome do manifesto. */
+function checksDoAberto(no, head, check) {
+    const p = no.headPipeline;
+    if (p === null || p === undefined)
+        return [];
+    if (!obj(p))
+        throw new ForaDoFormato('headPipeline');
+    // A pipeline de outro head (o MR ganhou commit e a nova ainda nao nasceu) nao diz nada do head de agora.
+    if (p.sha !== head)
+        return [{ nome: 'pipeline', situacao: 'pendente', concluidoEm: null }];
+    const daPipeline = situacao(p.status);
+    const checks = [{ nome: 'pipeline', situacao: daPipeline, concluidoEm: daPipeline === 'pendente' ? null : instante(p.finishedAt) }];
+    // Sem o job, o verde da pipeline pode ser so de status externos (qualquer nome fecha a pipeline): o check da CI
+    // fica pendente, nunca some.
+    if (p.job === null || p.job === undefined)
+        return [...checks, { nome: check, situacao: 'pendente', concluidoEm: null }];
+    if (!obj(p.job))
+        throw new ForaDoFormato('job');
+    const externo = !obj(p.job.stage) || p.job.stage.name === 'external';
+    const doJob = externo ? 'pendente' : situacao(p.job.status);
+    checks.push({ nome: check, situacao: doJob,
+        concluidoEm: doJob === 'pendente' ? null : instante(p.job.finishedAt) ?? instante(p.job.startedAt) });
+    return checks;
+}
+/** Um MR da resposta, ou `null` quando nao e desta base nem deste projeto (fork). Formato errado lanca. */
+function pedidoDoGitlab(bruto, base, projeto, comChecks, check) {
+    if (!obj(bruto))
+        throw new ForaDoFormato('MR');
+    const estado = pedidos_1.ESTADOS_DO_MR[String(bruto.state)];
+    if (typeof bruto.iid !== 'string' || !IID.test(bruto.iid) || !estado || typeof bruto.draft !== 'boolean' ||
+        typeof bruto.sourceProjectId !== 'number')
+        throw new ForaDoFormato('MR');
+    if (bruto.sourceProjectId !== projeto || bruto.targetBranch !== base || typeof bruto.sourceBranch !== 'string' ||
+        !BRANCH.test(bruto.sourceBranch))
+        return null;
+    const head = bruto.diffHeadSha, aberto = estado === 'aberto';
+    if (typeof head !== 'string' || !SHA.test(head)) {
+        if (aberto)
+            throw new ForaDoFormato('diffHeadSha');
+        return null;
+    }
+    const url = typeof bruto.webUrl === 'string' && /^https:\/\/[^\s]+$/.test(bruto.webUrl) ? bruto.webUrl.slice(0, 300) : null;
+    // A leitura sem a pipeline (recentes, candidatas) nunca diz que o aberto nao tem checks.
+    const checks = !aberto ? [] : comChecks ? checksDoAberto(bruto, head, check) : [{ nome: 'checks não lidos', situacao: 'pendente', concluidoEm: null }];
+    return { numero: Number(bruto.iid), branch: bruto.sourceBranch, head, estado, rascunho: bruto.draft, url,
+        criadoEm: instante(bruto.createdAt), mescladoEm: instante(bruto.mergedAt), checks,
+        ...(aberto && comChecks && typeof bruto.conflicts === 'boolean' ? { conflito: bruto.conflicts } : {}) };
+}
+function pagina(conexao, comCursor) {
+    const info = conexao.pageInfo;
+    if (!obj(info) || typeof info.hasNextPage !== 'boolean')
+        throw new ForaDoFormato('pageInfo');
+    if (info.hasNextPage && comCursor && typeof info.endCursor !== 'string')
+        throw new ForaDoFormato('endCursor');
+    return { temMais: info.hasNextPage, cursor: typeof info.endCursor === 'string' ? info.endCursor : null };
+}
+function pedidosAbertosGitlab(e) {
+    const falha = (codigo, detalhe) => ({ ok: false, erro: { codigo, detalhe } });
+    const pedir = (query, variables) => {
+        if (e.resta() <= 0)
+            return falha('forja.indisponivel', `graphql: orçamento de ${Math.round(e.orcamentoMs / 1000)} s da leitura esgotado`);
+        const r = e.api({ metodo: 'POST', caminho: 'graphql', corpo: { query, variables }, prazoMs: Math.min(e.limites.prazoMs, e.resta()) });
+        if (!r.ok)
+            return r;
+        const corpo = r.valor.corpo;
+        if (obj(corpo) && Array.isArray(corpo.errors) && corpo.errors.length) {
+            const mensagens = corpo.errors.map((x) => (obj(x) && typeof x.message === 'string' ? x.message : '?')).join('; ');
+            return falha('forja.resposta-invalida', (0, texto_1.deFora)(`graphql: ${mensagens}`));
+        }
+        const dados = obj(corpo) ? corpo.data : undefined;
+        if (!obj(dados) || !('project' in dados))
+            return falha('forja.resposta-invalida', 'graphql: sem data.project');
+        // Projeto que nao existe e projeto privado sem acesso respondem igual: `project: null`.
+        if (dados.project === null)
+            return falha('forja.nao-achei', `graphql: projeto ${e.forja.repo}`);
+        if (!obj(dados.project))
+            return falha('forja.resposta-invalida', 'graphql: project');
+        return { ok: true, valor: { projeto: dados.project, baixo: (0, api_1.limiteBaixo)(r.valor.limite) } };
+    };
+    const candidatas = [...new Set(e.candidatas)].filter((b) => BRANCH.test(b));
+    const primeira = pedir(consultas_1.CONSULTA_DOS_PEDIDOS, { path: e.forja.repo, base: e.base, candidatas: candidatas.slice(0, e.limites.candidatas),
+        check: e.contexto });
+    if (!primeira.ok)
+        return primeira;
+    try {
+        const projeto = primeira.valor.projeto;
+        const id = /^gid:\/\/gitlab\/Project\/(\d+)$/.exec(String(projeto.id))?.[1];
+        if (!id)
+            throw new ForaDoFormato('project.id');
+        const porNumero = new Map();
+        const juntar = (conexao, comChecks, onde) => {
+            if (!obj(conexao) || !Array.isArray(conexao.nodes))
+                throw new ForaDoFormato(onde);
+            for (const bruto of conexao.nodes) {
+                const pr = pedidoDoGitlab(bruto, e.base, Number(id), comChecks, e.contexto);
+                if (pr && !porNumero.has(pr.numero))
+                    porNumero.set(pr.numero, pr);
+            }
+            return conexao;
+        };
+        let abertos = juntar(projeto.abertos, true, 'abertos');
+        let lidos = abertos.nodes.length, baixo = primeira.valor.baixo, seguinte = pagina(abertos, true);
+        while (seguinte.temMais && lidos < e.limites.abertos && !baixo) {
+            const r = pedir(consultas_1.CONSULTA_DOS_ABERTOS_SEGUINTES, { path: e.forja.repo, base: e.base, depois: seguinte.cursor, check: e.contexto });
+            if (!r.ok)
+                return r;
+            abertos = juntar(r.valor.projeto.abertos, true, 'abertos');
+            lidos += abertos.nodes.length;
+            baixo = r.valor.baixo;
+            seguinte = pagina(abertos, true);
+        }
+        juntar(projeto.recentes, false, 'recentes');
+        const daBranch = juntar(projeto.daBranch, false, 'daBranch');
+        const cortada = pagina(daBranch, false).temMais;
+        const achadas = new Set([...porNumero.values()].map((p) => p.branch));
+        const semConferir = candidatas.filter((b, i) => !achadas.has(b) && (i >= e.limites.candidatas || cortada));
+        return { ok: true, valor: { prs: [...porNumero.values()], parcial: seguinte.temMais, semConferir } };
+    }
+    catch (err) {
+        if (err instanceof ForaDoFormato)
+            return falha('forja.resposta-invalida', `graphql: ${err.message} fora do formato`);
+        throw err;
+    }
+}