@orkastery/cli 0.5.6 → 0.6.0

package/dist/mcp-ship-transporte.js

@@ -0,0 +1,977 @@
+"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.ESQUEMA_DA_FIXACAO = exports.linhasDoKnownHosts = exports.nomeNoKnownHosts = exports.impressaoDaChave = exports.RECUSAS_DO_TRANSPORTE = exports.URL_GITHUB_SSH = void 0;
+exports.recusar = recusar;
+exports.originUnicoMcp = originUnicoMcp;
+exports.enderecoDoOrigin = enderecoDoOrigin;
+exports.lerKeyscan = lerKeyscan;
+exports.lerKnownHosts = lerKnownHosts;
+exports.comandoSsh = comandoSsh;
+exports.alvoDaCredencial = alvoDaCredencial;
+exports.configDeRede = configDeRede;
+exports.protocoloDaConfigDeRede = protocoloDaConfigDeRede;
+exports.urlDaConfigDeRede = urlDaConfigDeRede;
+exports.criarGitdirDoPush = criarGitdirDoPush;
+exports.chaveRecusadaDaConfigDeRede = chaveRecusadaDaConfigDeRede;
+exports.configDaCliDoAmbiente = configDaCliDoAmbiente;
+exports.ambienteDaCliDoTransporte = ambienteDaCliDoTransporte;
+exports.conferirConfigDaCli = conferirConfigDaCli;
+exports.ambienteDoTransporte = ambienteDoTransporte;
+exports.ambienteDoWorkerShip = ambienteDoWorkerShip;
+exports.ambienteDoWorkerDoTransporte = ambienteDoWorkerDoTransporte;
+exports.dirDaFixacao = dirDaFixacao;
+exports.lerCaDoTransporte = lerCa;
+exports.binarioRealDoTransporte = binarioReal;
+exports.gravarFixacao = gravarFixacao;
+exports.conferirFixacao = conferirFixacao;
+exports.lerFixacao = lerFixacao;
+exports.textoDaFixacao = textoDaFixacao;
+exports.fixacaoInstalada = fixacaoInstalada;
+exports.proporTransporte = proporTransporte;
+exports.sondasPadraoDoTransporte = sondasPadraoDoTransporte;
+exports.prepararFixacao = prepararFixacao;
+/**
+ * Os transportes do `ork_ship` que a instalacao fixa. `forja-ssh`: a chave do servidor confirmada pela pessoa vai
+ * para um known_hosts proprio, e o ssh roda sem config do usuario nem do sistema, com `StrictHostKeyChecking=yes`.
+ * `forja-https`: o git zera os helpers de credencial da config e recebe um so, o da CLI da forja com login no host,
+ * fixado pela origem; a CA do manifesto entra conferida pelo hash. A fixacao mora fora do projeto, numa pasta 700
+ * do usuario por raiz; o servidor MCP a le no startup e o worker do SHIP a confere antes de cada passo. O token
+ * nunca passa por aqui: o git o pede ao helper pelo pipe.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const contrato_1 = require("./forja/contrato");
+const cli_1 = require("./forja/cli");
+const api_1 = require("./forja/api");
+const executor_1 = require("./forja/executor");
+const endereco_1 = require("./forja/endereco");
+const resolver_1 = require("./forja/resolver");
+const mcp_git_1 = require("./mcp-git");
+const rede_forja_1 = require("./rede-forja");
+const locale_1 = require("./locale");
+const mcp_transportes_1 = require("./mcp-transportes");
+/** O unico remoto que o `github-ssh` aceita, como sempre. */
+exports.URL_GITHUB_SSH = /^git@github\.com:[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9][A-Za-z0-9._-]*\.git$/;
+/** Cada recusa dos transportes fixados; todas tem a frase no catalogo (`transporteShip.recusa`). */
+exports.RECUSAS_DO_TRANSPORTE = ['urls', 'modo', 'forja', 'ssh.divergente', 'ssh.sem-resposta', 'ssh.revogada',
+    'ssh.nao-confirmada', 'ssh.impressao-divergente', 'ssh.known-hosts-ilegivel', 'ssh.caminho', 'ssh.known-hosts-alterado', 'https.sem-tls',
+    'ssh.credencial-na-url', 'https.credencial-na-url', 'https.divergente', 'sem-cli', 'sem-helper', 'sem-login', 'binario', 'ca', 'ca-alterada',
+    'fixacao-ausente', 'fixacao-insegura', 'fixacao-divergente', 'mudou-no-push', 'cli-config'];
+/** A recusa sai com o codigo `mcp.ship.transport.*` na frente: o servidor e o worker do SHIP so repassam `mcp.*`. */
+function recusar(codigo, detalhe) {
+    throw new locale_1.ErroDoCatalogo((m) => m.forja.transporteShip.recusa(`mcp.ship.transport.${codigo}`, detalhe));
+}
+/** A URL efetiva do origin, a mesma no fetch e no push. O push usa todas as URLs configuradas, nunca so a primeira. */
+function originUnicoMcp(raiz) {
+    const ler = (push) => {
+        const raw = (0, mcp_git_1.gitPassivoMcp)(raiz, ['remote', 'get-url', ...(push ? ['--push'] : []), '--all', 'origin']);
+        const urls = raw.split('\n');
+        if (urls[urls.length - 1] === '')
+            urls.pop();
+        if (urls.length !== 1 || !urls[0] || /[\x00-\x1f\x7f]/.test(urls[0]))
+            throw Error('mcp.ship.transport.urls: origin exige uma URL efetiva');
+        return urls[0];
+    };
+    const fetch = ler(false), push = ler(true);
+    if (fetch !== push)
+        throw Error('mcp.ship.transport.pushurl');
+    return fetch;
+}
+const sha256 = (b) => (0, node_crypto_1.createHash)('sha256').update(b).digest('hex');
+const CAMINHO_SEGURO = /^[A-Za-z0-9_./+-]+$/;
+const LIMITE_DA_FIXACAO = 65536, LIMITE_DA_CA = 1048576;
+const meuUid = () => process.getuid?.();
+/**
+ * Senha ou token na parte de usuario (`user:segredo@`), antes do primeiro `/` do endereco: `ssh://u:s@h/…` ou
+ * `u:s@h:caminho`. O usuario sozinho (`git@`) passa.
+ */
+function senhaNaUrl(bruta) {
+    const resto = bruta.replace(/^[a-z][a-z0-9+.-]*:\/\//i, ''), barra = resto.indexOf('/');
+    const autoridade = barra < 0 ? resto : resto.slice(0, barra), arroba = autoridade.lastIndexOf('@');
+    return arroba >= 0 && autoridade.slice(0, arroba).includes(':');
+}
+/** O usuario do SSH, quando vem: `ssh://user@h/…` ou `user@h:caminho`. */
+function usuarioDoSsh(bruta) {
+    const esquema = /^[a-z][a-z0-9+.-]*:\/\/([^/]*)/i.exec(bruta);
+    if (esquema) {
+        const i = esquema[1].lastIndexOf('@');
+        return i < 0 ? null : esquema[1].slice(0, i);
+    }
+    const scp = /^([^@:/]*)@/.exec(bruta);
+    return scp ? scp[1] : null;
+}
+const USUARIO_SSH = /^[A-Za-z0-9._][A-Za-z0-9._-]*$/;
+/**
+ * O que o origin diz ao transporte, de um parse so (`lerEnderecoDoRemoto`). `forja-ssh`: `ssh://` ou a forma scp,
+ * porta 22 quando nao vem, usuario e host que nao parecem opcao. `forja-https`: so `https://`, sem usuario nem token
+ * na URL; `http://` levaria a credencial em claro. Nos dois, senha ou token na URL recusa. O detalhe de uma recusa
+ * nunca leva o origin cru (pode ter token na query, no fragmento ou num userinfo malformado): no maximo o esquema e o
+ * host do parse, ou a palavra `origin` quando nao houve parse.
+ */
+function enderecoDoOrigin(transporte, url) {
+    return lerOrigin(transporte, url).endereco;
+}
+/** O parse do origin e o que ele diz ao transporte; a sonda da instalacao leva os dois, de uma leitura so. */
+function lerOrigin(transporte, url) {
+    const bruta = url.trim(), e = (0, endereco_1.lerEnderecoDoRemoto)(bruta);
+    const resumo = () => (e ? `${e.protocolo}://${e.host}${e.porta ? `:${e.porta}` : ''}` : 'origin');
+    if (transporte === 'forja-https') {
+        if (/^http:/i.test(bruta))
+            return recusar('https.sem-tls', resumo());
+        if (/^https:\/\//i.test(bruta)) {
+            let comCredencial = true;
+            try {
+                const u = new URL(bruta);
+                comCredencial = u.username !== '' || u.password !== '';
+            }
+            catch { /* sem parse: recusa */ }
+            if (comCredencial || /^https:\/\/[^/]*@/i.test(bruta))
+                return recusar('https.credencial-na-url', 'origin');
+        }
+    }
+    if (transporte === 'forja-ssh' && senhaNaUrl(bruta))
+        return recusar('ssh.credencial-na-url', 'origin');
+    if (!e)
+        return recusar(path.isAbsolute(bruta) ? 'modo' : 'urls', path.isAbsolute(bruta) ? 'bare-local' : 'origin');
+    if (transporte === 'forja-ssh') {
+        if (e.protocolo === 'https' || e.protocolo === 'http')
+            return recusar('modo', 'forja-https');
+        if (e.protocolo !== 'ssh' && e.protocolo !== 'scp')
+            return recusar('urls', resumo());
+        const usuario = usuarioDoSsh(bruta);
+        if (usuario !== null && !USUARIO_SSH.test(usuario))
+            return recusar('urls', resumo());
+        return { endereco: { transporte, host: e.host, porta: e.porta ?? 22 }, remoto: e };
+    }
+    if (e.protocolo === 'ssh' || e.protocolo === 'scp')
+        return recusar('modo', 'forja-ssh');
+    if (e.protocolo !== 'https')
+        return recusar('urls', resumo());
+    const porta = e.porta === 443 ? null : e.porta;
+    return { endereco: { transporte, host: e.host, porta, origem: `https://${porta === null ? e.host : `${e.host}:${porta}`}` }, remoto: e };
+}
+const TIPO_DE_CHAVE = /^(?:ssh-ed25519|ssh-rsa|ecdsa-sha2-nistp(?:256|384|521))$/;
+const BASE64 = /^[A-Za-z0-9+/]+={0,2}$/;
+const IMPRESSAO = /^SHA256:[A-Za-z0-9+/]{43}$/;
+const mesma = (a, b) => a.tipo === b.tipo && a.chave === b.chave;
+/** A impressao que o OpenSSH mostra (`ssh-keygen -lf -E sha256`): o sha256 do blob em base64, sem o `=` final. */
+const impressaoDaChave = (chave) => `SHA256:${(0, node_crypto_1.createHash)('sha256').update(Buffer.from(chave, 'base64')).digest('base64').replace(/=+$/, '')}`;
+exports.impressaoDaChave = impressaoDaChave;
+/** O nome do host no known_hosts: `host` na porta 22, `[host]:porta` nas outras. */
+const nomeNoKnownHosts = (host, porta) => (porta === 22 ? host : `[${host}]:${porta}`);
+exports.nomeNoKnownHosts = nomeNoKnownHosts;
+/** As chaves que o `ssh-keyscan` imprimiu para o nome exato, sem repeticao; comentario e tipo fora da lista caem. */
+function lerKeyscan(saida, nome) {
+    const chaves = [];
+    for (const bruta of saida.split('\n')) {
+        const linha = bruta.trim();
+        if (!linha || linha.startsWith('#'))
+            continue;
+        const c = linha.split(/\s+/);
+        if (c.length < 3 || c[0] !== nome || !TIPO_DE_CHAVE.test(c[1]) || !BASE64.test(c[2]))
+            continue;
+        const k = { tipo: c[1], chave: c[2] };
+        if (!chaves.some((x) => mesma(x, k)))
+            chaves.push(k);
+    }
+    return chaves;
+}
+/** Um padrao do known_hosts (`*` e `?`) casa o nome inteiro. */
+const casaPadrao = (padrao, nome) => new RegExp(`^${padrao.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.')}$`).test(nome);
+/**
+ * O campo de hosts aceita o nome: o hash `|1|sal|hmac` do `HashKnownHosts`, ou a lista separada por virgula com o nome
+ * exato. Como no OpenSSH, um `!padrao` que casa o nome tira a linha, mesmo com um positivo que case; curinga positivo
+ * nunca confirma.
+ */
+function casaNome(campo, nome) {
+    if (campo.startsWith('|1|')) {
+        const [, , sal, hash] = campo.split('|');
+        return !!sal && !!hash && (0, node_crypto_1.createHmac)('sha1', Buffer.from(sal, 'base64')).update(nome).digest('base64') === hash;
+    }
+    const padroes = campo.split(',');
+    if (padroes.some((p) => p.startsWith('!') && casaPadrao(p.slice(1), nome)))
+        return false;
+    return padroes.includes(nome);
+}
+/**
+ * As chaves que o known_hosts da pessoa aceita para o nome, e as que ele revoga. Toda linha `@revoked` conta, qualquer
+ * que seja o campo de hosts (`*`, curinga, hash, outro nome): a chave revogada nao entra por nenhum nome.
+ * `@cert-authority` cai.
+ */
+function lerKnownHosts(conteudo, nome) {
+    const aceitas = [], revogadas = [];
+    for (const bruta of conteudo.split('\n')) {
+        const linha = bruta.trim();
+        if (!linha || linha.startsWith('#'))
+            continue;
+        let c = linha.split(/\s+/), marca = null;
+        if (c[0].startsWith('@')) {
+            marca = c[0];
+            c = c.slice(1);
+        }
+        if (c.length < 3 || !TIPO_DE_CHAVE.test(c[1]) || !BASE64.test(c[2]))
+            continue;
+        if (marca === '@revoked')
+            revogadas.push({ tipo: c[1], chave: c[2] });
+        else if (marca === null && casaNome(c[0], nome))
+            aceitas.push({ tipo: c[1], chave: c[2] });
+    }
+    return { aceitas, revogadas };
+}
+const linhasDoKnownHosts = (chaves, nome) => chaves.map((k) => `${nome} ${k.tipo} ${k.chave}\n`).join('');
+exports.linhasDoKnownHosts = linhasDoKnownHosts;
+/**
+ * O ssh do push: `-F /dev/null` tira a config do usuario e a do sistema (nada de ProxyCommand nem HostName trocado);
+ * so o known_hosts fixado vale, sem pergunta e sem regravar chave. O caminho vai sem aspas porque o ssh separa
+ * `UserKnownHostsFile` por espaco: caminho com espaco ou caractere especial recusa.
+ */
+function comandoSsh(knownHosts) {
+    if (!path.isAbsolute(knownHosts) || !CAMINHO_SEGURO.test(knownHosts))
+        recusar('ssh.caminho', knownHosts);
+    return ['ssh', '-F', '/dev/null', '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=yes', '-o', `UserKnownHostsFile=${knownHosts}`,
+        '-o', 'GlobalKnownHostsFile=/dev/null', '-o', 'UpdateHostKeys=no', '-o', 'CheckHostIP=no', '-o', 'ConnectTimeout=30'].join(' ');
+}
+// ---------------------------------------------------------------------------
+// HTTPS: a credencial pela CLI logada.
+// ---------------------------------------------------------------------------
+/**
+ * A origem da credencial sai da chave do login da CLI (`host[:porta]`, nunca com o caminho base): o helper responde
+ * pelo mesmo host em que a CLI tem login. O git casa `credential.<url>` pelo esquema, host e porta; o caminho base
+ * vai a parte, para o `useHttpPath`.
+ */
+function alvoDaCredencial(f) {
+    const chave = (0, api_1.chaveDoLogin)(f);
+    if (!/^[a-z0-9.-]+(?::\d+)?$/.test(chave))
+        recusar('https.divergente', chave);
+    return { origem: `https://${chave}`, caminhoBase: f.caminhoBase };
+}
+// ---------------------------------------------------------------------------
+// A fixacao gravada na instalacao.
+// ---------------------------------------------------------------------------
+exports.ESQUEMA_DA_FIXACAO = 'ork.mcp-ship-transport/v1';
+/**
+ * O `-c` que o push e o `ls-remote` do SHIP levam. Nada de token: so o comando do ssh, o helper e a CA.
+ *
+ * No HTTPS, o git escolhe cada `http.*` pela regra de URL mais especifica (host, depois o caminho mais longo), e o
+ * `-c` vem por ultimo: so a URL exata do origin garante que nenhuma regra `http.<url>.*` do `~/.gitconfig` vence.
+ * Nela, o TLS fica ligado, o proxy sai (vazio desliga, inclusive o do ambiente), a lista de cabecalhos extras e
+ * zerada (vazio limpa o que veio antes), nenhum redirecionamento e seguido e a CA entra pela copia fixada. O certificado de cliente (`sslCert`, `sslKey`) fica com a
+ * config da pessoa: nao afrouxa a verificacao do servidor. A credencial casa sem o caminho (`useHttpPath`), pela origem.
+ */
+function configDeRede(fix, dir) {
+    if (fix.transporte === 'forja-ssh') {
+        return ['-c', `core.sshCommand=${comandoSsh(path.join(dir, 'known_hosts'))}`, '-c', 'ssh.variant=ssh', ...travasDoRemoto('ssh')];
+    }
+    const e = enderecoDoOrigin('forja-https', fix.url);
+    if (e.transporte !== 'forja-https' || e.origem !== fix.origem)
+        return recusar('https.divergente', fix.origem);
+    const url = fix.url;
+    return ['-c', 'credential.helper=', '-c', `credential.${fix.origem}.helper=${(0, rede_forja_1.helperDeCredencialDaCli)(fix.binario)}`,
+        '-c', `credential.${fix.origem}.useHttpPath=${fix.caminho}`, '-c', 'http.sslVerify=true',
+        '-c', `http.${url}.sslVerify=true`, '-c', `http.${url}.proxy=`, '-c', `http.${url}.extraHeader=`,
+        '-c', `http.${url}.followRedirects=false`,
+        ...(fix.ca ? ['-c', `http.${url}.sslCAInfo=${path.join(dir, ARQUIVO_DA_CA)}`] : []), ...travasDoRemoto('https')];
+}
+/**
+ * O que o git le da `.git/config` e da `.git/hooks` a cada comando, inclusive entre a ultima conferencia e o push:
+ * nenhum hook roda (`core.hooksPath=/dev/null` vence o da config do projeto e a pasta `hooks`) e so o protocolo do
+ * modo vale (`protocol.allow=never`). Um origin trocado para caminho local ou `file://`, com `receivepack` ou
+ * `uploadpack` proprios, recusa no protocolo sem rodar nada. O `-c remote.origin.url=` nao serviria: a chave tem
+ * varios valores, e o `-c` acrescenta um em vez de trocar.
+ */
+function travasDoRemoto(protocolo) {
+    return ['-c', 'core.hooksPath=/dev/null', '-c', 'protocol.allow=never', '-c', `protocol.${protocolo}.allow=always`];
+}
+/** O protocolo de uma lista de `configDeRede` ja validada: ssh com o ssh fixado, https sem ele; vazia, nenhum. */
+function protocoloDaConfigDeRede(config) {
+    if (!config.length)
+        return null;
+    return config.some((c) => c.startsWith('core.sshCommand=')) ? 'ssh' : 'https';
+}
+/** A URL exata das regras `http.<url>.*` de uma lista https validada (todas tem a mesma). */
+function urlDaConfigDeRede(config) {
+    for (const c of config) {
+        const m = /^http\.(https:\/\/[^=\s]+)\.sslVerify=/.exec(c);
+        if (m)
+            return m[1];
+    }
+    return null;
+}
+/**
+ * O gitdir de onde saem o push e os `ls-remote` do transporte fixado: um bare novo, 700, numa pasta do usuario, sem
+ * modelo (nenhum hook copiado), que le os objetos do projeto pelo `objects/info/alternates`. Nada da config, dos hooks,
+ * dos `insteadOf` nem das regras de protocolo do projeto entra no git que vai a rede: so o objeto que o ship decidiu.
+ */
+function criarGitdirDoPush(raiz, env = process.env) {
+    const comum = (0, mcp_git_1.gitPassivoMcp)(raiz, ['rev-parse', '--path-format=absolute', '--git-common-dir']).trim();
+    if (!path.isAbsolute(comum) || CONTROLE.test(comum))
+        recusar('urls', 'gitdir');
+    const objetos = fs.realpathSync(path.join(comum, 'objects'));
+    if (!fs.statSync(objetos).isDirectory() || CONTROLE.test(objetos))
+        recusar('urls', 'gitdir');
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-ship-push-'));
+    try {
+        fs.chmodSync(dir, 0o700);
+        conferirAncestrais(path.join(dir, 'x'), 'fixacao-insegura');
+        // Fora do projeto: com o cwd nele, o init leria a config local (`core.sharedRepository` afrouxaria os modos).
+        const r = (0, node_child_process_1.spawnSync)('git', ['init', '--bare', '--quiet', '--template=', '--', dir], { cwd: '/', encoding: 'utf8', timeout: 30000,
+            env: { ...env, GIT_ALLOW_PROTOCOL: '' }, stdio: ['ignore', 'pipe', 'pipe'] });
+        if (r.status !== 0)
+            recusar('urls', 'gitdir');
+        fs.mkdirSync(path.join(dir, 'objects', 'info'), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(path.join(dir, 'objects', 'info', 'alternates'), `${objetos}\n`, { mode: 0o600, flag: 'wx' });
+        return dir;
+    }
+    catch (e) {
+        fs.rmSync(dir, { recursive: true, force: true });
+        throw e;
+    }
+}
+const ESCAPE_DE_REGEX = (t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const MARCA_DO_KNOWN_HOSTS = '/__known_hosts__';
+const FORMA_DO_SSH = new RegExp(`^${ESCAPE_DE_REGEX(comandoSsh(MARCA_DO_KNOWN_HOSTS)).replace(ESCAPE_DE_REGEX(MARCA_DO_KNOWN_HOSTS), '(/[A-Za-z0-9_./+-]+/known_hosts)')}$`);
+const SUFIXO_DO_HELPER = ' auth git-credential';
+const CHAVE_DO_HTTP = /^http\.(https:\/\/[^=\s]+)\.(sslVerify|proxy|extraHeader|followRedirects|sslCAInfo)$/;
+const CHAVE_DA_CREDENCIAL = /^credential\.(https:\/\/[^=\s]+)\.(helper|useHttpPath)$/;
+/** O binario de um helper `!<caminho> auth git-credential` na forma exata de `helperDeCredencialDaCli`; senao, null. */
+function binarioDoHelper(valor) {
+    if (!valor.startsWith('!') || !valor.endsWith(SUFIXO_DO_HELPER))
+        return null;
+    const resto = valor.slice(1, -SUFIXO_DO_HELPER.length);
+    let binario;
+    if (CAMINHO_SEGURO.test(resto))
+        binario = resto;
+    else if (resto.length >= 2 && resto.startsWith("'") && resto.endsWith("'") && !resto.slice(1, -1).replace(/'\\''/g, '').includes("'")) {
+        binario = resto.slice(1, -1).replace(/'\\''/g, "'");
+    }
+    else
+        return null;
+    return path.isAbsolute(binario) && (0, rede_forja_1.helperDeCredencialDaCli)(binario) === valor ? binario : null;
+}
+/**
+ * Confere uma lista `-c chave=valor` contra o que `configDeRede` emite: cada chave tem so o valor da sua forma
+ * (TLS ligado, proxy e cabecalho vazios, sem redirecionamento, ssh sem config do usuario, helper da CLI, CA `ca.pem`),
+ * e toda URL da lista e a mesma. Devolve a chave recusada (nunca o valor) ou null quando a lista toda e valida.
+ */
+function chaveRecusadaDaConfigDeRede(config) {
+    const origens = new Set();
+    const urls = new Set();
+    const vistas = new Set();
+    if (config.length % 2 !== 0)
+        return '';
+    for (let i = 0; i < config.length; i += 2) {
+        const par = config[i + 1];
+        const igual = typeof par === 'string' ? par.indexOf('=') : -1;
+        const chave = igual > 0 ? par.slice(0, igual) : '';
+        const valor = igual > 0 ? par.slice(igual + 1) : '';
+        if (config[i] !== '-c' || chave === '' || /[\0\n\r]/.test(valor))
+            return chave;
+        let ok = false;
+        let m;
+        vistas.add(chave);
+        if (chave === 'core.sshCommand')
+            ok = FORMA_DO_SSH.test(valor);
+        else if (chave === 'core.hooksPath')
+            ok = valor === '/dev/null';
+        else if (chave === 'protocol.allow')
+            ok = valor === 'never';
+        else if (chave === 'protocol.ssh.allow' || chave === 'protocol.https.allow')
+            ok = valor === 'always';
+        else if (chave === 'ssh.variant')
+            ok = valor === 'ssh';
+        else if (chave === 'credential.helper')
+            ok = valor === '';
+        else if (chave === 'http.sslVerify')
+            ok = valor === 'true';
+        else if ((m = CHAVE_DA_CREDENCIAL.exec(chave))) {
+            origens.add(m[1]);
+            ok = m[2] === 'helper' ? binarioDoHelper(valor) !== null : valor === 'true' || valor === 'false';
+        }
+        else if ((m = CHAVE_DO_HTTP.exec(chave))) {
+            urls.add(m[1]);
+            const v = m[2];
+            ok = v === 'sslVerify' ? valor === 'true'
+                : v === 'followRedirects' ? valor === 'false'
+                    : v === 'sslCAInfo' ? path.isAbsolute(valor) && CAMINHO_SEGURO.test(valor) && path.basename(valor) === ARQUIVO_DA_CA
+                        : valor === '';
+        }
+        if (!ok)
+            return chave;
+    }
+    // Lista nao vazia leva as travas, e o protocolo liberado e o do modo: ssh com o ssh fixado, https sem ele.
+    if (config.length) {
+        const ssh = vistas.has('core.sshCommand') || vistas.has('ssh.variant');
+        const http = urls.size > 0 || origens.size > 0 || vistas.has('credential.helper') || vistas.has('http.sslVerify');
+        if (!vistas.has('core.hooksPath'))
+            return 'core.hooksPath';
+        if (!vistas.has('protocol.allow'))
+            return 'protocol.allow';
+        if (ssh === http)
+            return 'core.sshCommand/http';
+        if (vistas.has(ssh ? 'protocol.https.allow' : 'protocol.ssh.allow'))
+            return ssh ? 'protocol.https.allow' : 'protocol.ssh.allow';
+        if (!vistas.has(ssh ? 'protocol.ssh.allow' : 'protocol.https.allow'))
+            return ssh ? 'protocol.ssh.allow' : 'protocol.https.allow';
+    }
+    // Uma URL so, e a origem das credenciais e a do endereco dela.
+    if (urls.size > 1 || origens.size > 1)
+        return 'http/credential';
+    const [u] = [...urls];
+    const [o] = [...origens];
+    if (u !== undefined) {
+        try {
+            const e = enderecoDoOrigin('forja-https', u);
+            if (e.transporte !== 'forja-https' || (o !== undefined && e.origem !== o))
+                return 'http/credential';
+        }
+        catch {
+            return 'http/credential';
+        }
+    }
+    else if (o !== undefined)
+        return 'http/credential';
+    return null;
+}
+/** A variavel que diz a cada CLI onde esta a config (e o login) dela. */
+const CONFIG_DA_CLI = { gh: 'GH_CONFIG_DIR', glab: 'GLAB_CONFIG_DIR' };
+/** O que cada CLI recebe para nunca perguntar, checar versao ou enviar telemetria no meio do push. */
+const FIXAS_DA_CLI = {
+    gh: { GH_NO_UPDATE_NOTIFIER: '1', GH_PROMPT_DISABLED: '1' },
+    glab: { GLAB_CHECK_UPDATE: 'false', GLAB_SEND_TELEMETRY: 'false' },
+};
+const TOKENS_DA_CLI = ['GITLAB_TOKEN', 'GLAB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN', 'GH_ENTERPRISE_TOKEN', 'GITHUB_ENTERPRISE_TOKEN'];
+/**
+ * A pasta de config da CLI no ambiente de quem chama: `null` quando nao vem; pasta absoluta sem caractere de controle
+ * quando vem; outra coisa recusa (so o nome da variavel sai na recusa, nunca o valor).
+ */
+function configDaCliDoAmbiente(cli, env) {
+    const nome = CONFIG_DA_CLI[cli], v = env[nome];
+    if (v === undefined || v === '')
+        return null;
+    if (!absoluto(v))
+        return recusar('cli-config', nome);
+    return v;
+}
+/**
+ * O ambiente da CLI da forja no transporte HTTPS, o mesmo na sonda da instalacao e no worker do push: a pasta de
+ * config (so a variavel da propria CLI, quando o ambiente a traz), as variaveis que a mantem calada e, em `apagar`, o
+ * que nunca passa: token de qualquer nome conhecido e a variavel de config quando ela nao vem.
+ */
+function ambienteDaCliDoTransporte(cli, env) {
+    const config = configDaCliDoAmbiente(cli, env), acrescentar = { ...FIXAS_DA_CLI[cli] };
+    if (config !== null)
+        acrescentar[CONFIG_DA_CLI[cli]] = config;
+    const tokens = Object.keys(env).filter((n) => /^(GH|GLAB|GITLAB|GITHUB)_/.test(n) && /TOKEN/i.test(n));
+    return { acrescentar, apagar: [...new Set([...TOKENS_DA_CLI, ...tokens]), ...(config === null ? [CONFIG_DA_CLI[cli]] : [])] };
+}
+/** A pasta de config que o worker leva tem de ser a fixada na instalacao (ambas `null` quando nao havia). */
+function conferirConfigDaCli(f, envDoWorker) {
+    if (f.transporte !== 'forja-https')
+        return;
+    const nome = CONFIG_DA_CLI[f.cli], v = envDoWorker[nome];
+    if ((v === undefined || v === '' ? null : v) !== f.configDaCli)
+        recusar('fixacao-divergente', nome);
+}
+/**
+ * O que o transporte fixado acrescenta ao ambiente do worker: nenhuma pergunta (`GIT_ASKPASS` vazio desliga tambem o
+ * `core.askPass` e o `SSH_ASKPASS` no git). No HTTPS, o barramento da sessao, para a CLI ler o token do keyring do
+ * sistema, a pasta de config da CLI fixada (o login que o helper le) e as variaveis que a mantem calada. Nada de
+ * token do ambiente de quem chama.
+ */
+function ambienteDoTransporte(t, env = process.env, cli) {
+    const extra = { GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: '', SSH_ASKPASS_REQUIRE: 'never' };
+    if (t === 'forja-https') {
+        if (!cli)
+            throw Error('mcp.ship.transport.cli: a CLI fixada e obrigatoria no HTTPS');
+        for (const nome of ['DBUS_SESSION_BUS_ADDRESS', 'XDG_RUNTIME_DIR']) {
+            const v = env[nome];
+            if (v)
+                extra[nome] = v;
+        }
+        Object.assign(extra, ambienteDaCliDoTransporte(cli, env).acrescentar);
+    }
+    return extra;
+}
+/**
+ * O ambiente do worker do SHIP, por lista fechada: nada de `GIT_SSH*`, `GIT_ASKPASS`, `GIT_SSL_NO_VERIFY` ou
+ * `GIT_CONFIG_*` de quem iniciou o servidor chega ao git do push.
+ */
+function ambienteDoWorkerShip(origem = process.env) {
+    return { HOME: origem.HOME, USER: origem.USER, LOGNAME: origem.LOGNAME, XDG_CONFIG_HOME: origem.XDG_CONFIG_HOME,
+        SSH_AUTH_SOCK: origem.SSH_AUTH_SOCK, PATH: '/usr/bin:/bin', LANG: 'C.UTF-8', TMPDIR: '/tmp' };
+}
+/**
+ * O ambiente do worker para cada transporte: a lista fechada de `ambienteDoWorkerShip` e, nos transportes fixados,
+ * o que `ambienteDoTransporte` acrescenta (nenhuma pergunta; no HTTPS, o barramento da sessao). Nada mais.
+ */
+function ambienteDoWorkerDoTransporte(transporte, origem = process.env, cli) {
+    const base = ambienteDoWorkerShip(origem);
+    return (0, mcp_transportes_1.ehTransporteFixado)(transporte) ? { ...base, ...ambienteDoTransporte(transporte, origem, cli) } : base;
+}
+/** Uma pasta por raiz, na config do usuario: fora do projeto, longe do que o agente escreve. */
+function dirDaFixacao(raiz, env = process.env) {
+    const xdg = env.XDG_CONFIG_HOME;
+    const base = xdg && path.isAbsolute(xdg) ? xdg : path.join(env.HOME || os.homedir(), '.config');
+    return path.join(base, 'orkastery', 'mcp-ship', sha256(raiz).slice(0, 32));
+}
+const ARQUIVO_DA_CA = 'ca.pem';
+const CONTROLE = /[\x00-\x1f\x7f]/;
+/**
+ * Cada pasta acima de `alvo`, ate a raiz, como o `secure_path` do OpenSSH: pasta de verdade (sem link), do usuario
+ * ou do root, sem escrita de grupo e de outros; a do root com sticky (`/tmp`) passa, porque ali ninguem troca o que
+ * e de outro dono.
+ */
+function conferirAncestrais(alvo, codigo) {
+    for (let atual = path.dirname(alvo);; atual = path.dirname(atual)) {
+        const s = fs.lstatSync(atual, { throwIfNoEntry: false });
+        const dono = !!s && (s.uid === meuUid() || s.uid === 0);
+        const escrita = !!s && (s.mode & 0o022) !== 0 && !(s.uid === 0 && (s.mode & 0o1000) !== 0);
+        if (!s || !s.isDirectory() || !dono || escrita)
+            recusar(codigo, atual);
+        if (atual === path.dirname(atual))
+            return;
+    }
+}
+/** A pasta da fixacao: diretorio de verdade (sem link), do usuario, sem acesso de grupo e de outros; e toda pasta acima. */
+function conferirPasta(dir) {
+    const st = fs.lstatSync(dir, { throwIfNoEntry: false });
+    if (!st)
+        return recusar('fixacao-ausente', dir);
+    if (!st.isDirectory() || st.uid !== meuUid() || (st.mode & 0o077) !== 0)
+        recusar('fixacao-insegura', dir);
+    conferirAncestrais(dir, 'fixacao-insegura');
+}
+/** Arquivo da fixacao: regular, do usuario, sem acesso de grupo e de outros, um vinculo so, sem seguir link. */
+function lerDaFixacao(arquivo, limite = LIMITE_DA_FIXACAO) {
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (e) {
+        return recusar(e.code === 'ENOENT' ? 'fixacao-ausente' : 'fixacao-insegura', arquivo);
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.uid !== meuUid() || (st.mode & 0o077) !== 0 || st.nlink !== 1 || st.size > limite) {
+            recusar('fixacao-insegura', arquivo);
+        }
+        return fs.readFileSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+const ehPem = (bytes) => bytes.toString('latin1').includes('-----BEGIN CERTIFICATE-----');
+/** Le ate `limite + 1` bytes do descritor: o que passa do teto nunca entra inteiro na memoria. */
+function lerComTeto(fd, limite) {
+    const partes = [];
+    let total = 0;
+    for (;;) {
+        const b = Buffer.alloc(Math.min(65536, limite + 1 - total));
+        const n = fs.readSync(fd, b, 0, b.length, null);
+        if (n === 0)
+            break;
+        partes.push(b.subarray(0, n));
+        total += n;
+        if (total > limite)
+            break;
+    }
+    return Buffer.concat(partes, total);
+}
+/**
+ * A CA do manifesto, lida uma vez na instalacao: caminho absoluto, um PEM, ate 1 MiB, arquivo regular do usuario ou
+ * do root sem escrita de grupo ou de outros, e toda pasta do caminho real com a mesma regra. O caminho real e aberto
+ * sem seguir link e conferido pelo descritor aberto, o mesmo que se le. Os bytes vao para a copia da fixacao; o
+ * arquivo de origem nunca mais e lido.
+ */
+function lerCa(arquivo) {
+    if (!path.isAbsolute(arquivo) || CONTROLE.test(arquivo))
+        return recusar('ca', arquivo);
+    let bytes;
+    try {
+        const real = fs.realpathSync(arquivo);
+        conferirAncestrais(real, 'ca');
+        const fd = fs.openSync(real, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        try {
+            const st = fs.fstatSync(fd);
+            if (!st.isFile() || st.size > LIMITE_DA_CA || (st.mode & 0o022) !== 0 || (st.uid !== meuUid() && st.uid !== 0))
+                recusar('ca', arquivo);
+            bytes = lerComTeto(fd, LIMITE_DA_CA);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch (e) {
+        if (e instanceof locale_1.ErroDoCatalogo)
+            throw e;
+        return recusar('ca', arquivo);
+    }
+    if (bytes.length > LIMITE_DA_CA || !ehPem(bytes))
+        recusar('ca', arquivo);
+    return bytes;
+}
+/**
+ * A CLI do helper, pelo caminho real: arquivo executavel do usuario ou do root, sem escrita de grupo ou de outros,
+ * e toda pasta do caminho real com a mesma regra. Devolve o caminho real, que e o que se fixa e o que o git roda.
+ */
+function binarioReal(binario) {
+    try {
+        if (!path.isAbsolute(binario) || CONTROLE.test(binario))
+            recusar('binario', binario);
+        const real = fs.realpathSync(binario), st = fs.lstatSync(real);
+        const dono = st.uid === meuUid() || st.uid === 0;
+        if (!st.isFile() || !dono || (st.mode & 0o022) !== 0 || (st.mode & 0o111) === 0 || CONTROLE.test(real))
+            recusar('binario', binario);
+        conferirAncestrais(real, 'binario');
+        return real;
+    }
+    catch (e) {
+        if (e instanceof locale_1.ErroDoCatalogo)
+            throw e;
+        return recusar('binario', binario);
+    }
+}
+function gravarAtomico(arquivo, conteudo) {
+    const temp = `${arquivo}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    try {
+        fs.writeFileSync(temp, conteudo, { flag: 'wx', mode: 0o600 });
+        fs.renameSync(temp, arquivo);
+    }
+    finally {
+        fs.rmSync(temp, { force: true });
+    }
+}
+/**
+ * Grava a fixacao (pasta 700, arquivos 600, troca atomica). O known_hosts e a copia da CA so ficam quando a fixacao
+ * os pede; o que sobrou de outra instalacao sai. Os bytes da CA tem de ter o hash fixado.
+ */
+function gravarFixacao(dir, p) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    conferirPasta(dir);
+    if (p.knownHosts !== undefined)
+        gravarAtomico(path.join(dir, 'known_hosts'), p.knownHosts);
+    else
+        fs.rmSync(path.join(dir, 'known_hosts'), { force: true });
+    const ca = p.fixacao.transporte === 'forja-https' ? p.fixacao.ca : null;
+    if (ca) {
+        if (!p.ca || sha256(p.ca) !== ca.sha256 || !ehPem(p.ca) || p.ca.length > LIMITE_DA_CA)
+            recusar('ca', ca.arquivo);
+        gravarAtomico(path.join(dir, ARQUIVO_DA_CA), p.ca);
+    }
+    else
+        fs.rmSync(path.join(dir, ARQUIVO_DA_CA), { force: true });
+    gravarAtomico(path.join(dir, 'transporte.json'), `${JSON.stringify(p.fixacao, null, 2)}\n`);
+}
+const texto = (v) => typeof v === 'string' && v.length > 0 && v.length <= 4096 && !CONTROLE.test(v);
+const absoluto = (v) => texto(v) && path.isAbsolute(v);
+const hex64 = (v) => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+function formatoValido(v) {
+    const o = v;
+    if (!o || typeof o !== 'object' || o.schema !== exports.ESQUEMA_DA_FIXACAO || !texto(o.raiz) || !path.isAbsolute(o.raiz) || !texto(o.url))
+        return false;
+    if (o.transporte === 'forja-ssh') {
+        const chaves = o.chaves;
+        return texto(o.host) && endereco_1.HOST_DO_REMOTO.test(o.host) && Number.isInteger(o.porta) && o.porta >= 1 && o.porta <= 65535
+            && Array.isArray(chaves) && chaves.length > 0 && hex64(o.knownHostsSha256)
+            && chaves.every((k) => !!k && typeof k === 'object' && TIPO_DE_CHAVE.test(String(k.tipo))
+                && IMPRESSAO.test(String(k.impressao)));
+    }
+    if (o.transporte !== 'forja-https')
+        return false;
+    const ca = o.ca;
+    return contrato_1.TIPOS_DE_FORJA.includes(o.tipo) && typeof o.origem === 'string'
+        && /^https:\/\/[a-z0-9.-]+(?::\d+)?$/.test(o.origem) && typeof o.caminho === 'boolean' && (o.cli === 'gh' || o.cli === 'glab')
+        && absoluto(o.binario) && texto(o.versaoCli) && (o.configDaCli === null || absoluto(o.configDaCli)) && (ca === null || (typeof ca === 'object' && absoluto(ca.arquivo) && hex64(ca.sha256)));
+}
+/**
+ * Confere o que o push vai usar: o known_hosts pelo hash; a CLI pelo caminho real, pelo dono e pela escrita dela e de
+ * cada pasta acima; a copia da CA pelo hash, lida como os outros arquivos da fixacao (sem seguir link).
+ */
+function conferirFixacao(f, dir) {
+    conferirPasta(dir);
+    if (f.transporte === 'forja-ssh') {
+        const arquivo = path.join(dir, 'known_hosts');
+        if (sha256(lerDaFixacao(arquivo)) !== f.knownHostsSha256)
+            recusar('ssh.known-hosts-alterado', arquivo);
+        return;
+    }
+    if (binarioReal(f.binario) !== f.binario)
+        recusar('binario', f.binario);
+    const copia = path.join(dir, ARQUIVO_DA_CA);
+    if (f.ca && sha256(lerDaFixacao(copia, LIMITE_DA_CA)) !== f.ca.sha256)
+        recusar('ca-alterada', copia);
+}
+/** A fixacao desta raiz, deste transporte e deste origin, conferida; outra coisa recusa antes de qualquer rede. */
+function lerFixacao(raiz, transporte, url, env = process.env) {
+    const dir = dirDaFixacao(raiz, env);
+    if (!fs.lstatSync(dir, { throwIfNoEntry: false }))
+        recusar('fixacao-ausente', `ork mcp install --project ${raiz} --ship-transport ${transporte}`);
+    conferirPasta(dir);
+    const arquivo = path.join(dir, 'transporte.json');
+    let fixacao;
+    try {
+        fixacao = JSON.parse(lerDaFixacao(arquivo).toString('utf8'));
+    }
+    catch (e) {
+        if (e instanceof locale_1.ErroDoCatalogo)
+            throw e;
+        return recusar('fixacao-insegura', arquivo);
+    }
+    if (!formatoValido(fixacao))
+        return recusar('fixacao-insegura', arquivo);
+    if (fixacao.raiz !== raiz || fixacao.transporte !== transporte)
+        recusar('fixacao-divergente', `${fixacao.transporte} != ${transporte}`);
+    if (fixacao.url !== url)
+        recusar('fixacao-divergente', 'origin');
+    // O origin fixado tem de levar ao mesmo host e porta (SSH) ou a mesma origem (HTTPS) da chave e do helper fixados.
+    const e = enderecoDoOrigin(transporte, url);
+    if (fixacao.transporte === 'forja-ssh' && e.transporte === 'forja-ssh' && (e.host !== fixacao.host || e.porta !== fixacao.porta)) {
+        recusar('ssh.divergente', `${(0, exports.nomeNoKnownHosts)(e.host, e.porta)} != ${(0, exports.nomeNoKnownHosts)(fixacao.host, fixacao.porta)}`);
+    }
+    if (fixacao.transporte === 'forja-https' && e.transporte === 'forja-https' && e.origem !== fixacao.origem) {
+        recusar('https.divergente', `${e.origem} != ${fixacao.origem}`);
+    }
+    conferirFixacao(fixacao, dir);
+    return { fixacao, dir };
+}
+/** A linha que a instalacao mostra para a pessoa; na simulacao, o que seria fixado. */
+function textoDaFixacao(f, dir, simulacao = false) {
+    const t = (0, locale_1.msg)().forja.transporteShip;
+    const ssh = simulacao ? t.fixariaSsh : t.fixadoSsh, https = simulacao ? t.fixariaHttps : t.fixadoHttps;
+    return f.transporte === 'forja-ssh'
+        ? ssh((0, exports.nomeNoKnownHosts)(f.host, f.porta), f.chaves.map((k) => `${k.tipo} ${k.impressao}`).join(', '), path.join(dir, 'known_hosts'))
+        : https(f.origem, `${f.cli} ${f.versaoCli}`, f.ca?.arquivo ?? null);
+}
+/**
+ * A fixacao que esta raiz ja tem, para uma instalacao nao trocar a de outro host do projeto. `null` sem fixacao, ou
+ * com uma que nenhum servidor aceitaria (JSON quebrado, formato desconhecido, outra raiz): essa a instalacao refaz.
+ * Pasta ou arquivo inseguro (link, dono, modo, segundo vinculo) recusa: sobrescrever apagaria o sinal de que alguem
+ * mexeu ali, e a gravacao recusaria a pasta do mesmo jeito.
+ */
+function fixacaoInstalada(raiz, env = process.env) {
+    const dir = dirDaFixacao(raiz, env);
+    if (!fs.lstatSync(dir, { throwIfNoEntry: false }))
+        return null;
+    conferirPasta(dir);
+    const arquivo = path.join(dir, 'transporte.json');
+    if (!fs.lstatSync(arquivo, { throwIfNoEntry: false }))
+        return null;
+    const bytes = lerDaFixacao(arquivo);
+    let v;
+    try {
+        v = JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+    return formatoValido(v) && v.raiz === raiz ? v : null;
+}
+// ---------------------------------------------------------------------------
+// A sonda da instalacao.
+// ---------------------------------------------------------------------------
+/** O transporte que o origin pede, sem rede: bare local, o SSH do GitHub de sempre, SSH de outra forja ou HTTPS. */
+function proporTransporte(url) {
+    const t = url.trim();
+    if (path.isAbsolute(t))
+        return 'bare-local';
+    if (exports.URL_GITHUB_SSH.test(t))
+        return 'github-ssh';
+    const e = (0, endereco_1.lerEnderecoDoRemoto)(t);
+    if (!e)
+        return null;
+    return e.protocolo === 'ssh' || e.protocolo === 'scp' ? 'forja-ssh' : e.protocolo === 'https' ? 'forja-https' : null;
+}
+/** O `ssh-keyscan` desiste de cada host em 10 s; o processo inteiro, em 30 s. A CLI responde a versao e a ajuda em 10 s. */
+const PRAZO_DO_KEYSCAN_MS = 30_000, PRAZO_DA_CLI_MS = 10_000;
+const LIMITE_DO_KNOWN_HOSTS = 4 * 1048576;
+function sondasPadraoDoTransporte(env = process.env) {
+    const home = env.HOME || os.homedir();
+    return {
+        rodar: (binario, args, prazoMs) => {
+            const r = (0, node_child_process_1.spawnSync)(binario, [...args], { encoding: 'utf8', timeout: prazoMs, killSignal: 'SIGKILL', maxBuffer: 1024 * 1024,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: { PATH: '/usr/bin:/bin', HOME: home, LANG: 'C', LC_ALL: 'C', NO_COLOR: '1', GH_NO_UPDATE_NOTIFIER: '1',
+                    GH_PROMPT_DISABLED: '1', GLAB_CHECK_UPDATE: 'false', GLAB_SEND_TELEMETRY: 'false' } });
+            return { status: r.status, stdout: (r.stdout ?? '').toString(), stderr: (r.stderr ?? '').toString() };
+        },
+        env,
+        acharBinario: (cmd) => (0, rede_forja_1.acharBinario)(cmd, { env }),
+        knownHostsDoUsuario: path.join(home, '.ssh', 'known_hosts'),
+        knownHostsDoSistema: ['/etc/ssh/ssh_known_hosts', '/etc/ssh/ssh_known_hosts2'],
+    };
+}
+/**
+ * Sonda o origin no modo pedido e devolve a fixacao, sem gravar nada; o que nao fecha recusa com o motivo. Nesta
+ * ordem: o modo serve ao origin (um parse so dele), a forja resolve, e o SSH ou o HTTPS confere o resto.
+ */
+function prepararFixacao(e) {
+    const { endereco, remoto } = lerOrigin(e.transporte, e.url);
+    const r = (0, resolver_1.resolverForja)({ endereco: remoto, manifesto: e.manifesto, sondas: e.sondas.sondas });
+    // O detalhe do resolver pode citar o caminho do projeto: sai so o host, como em toda recusa do origin.
+    if (!r.ok)
+        return recusar('forja', (0, locale_1.msg)().forja.motivo({ codigo: r.erro.codigo, detalhe: r.erro.detalhe.split(remoto.caminho).join('<caminho>') }, null));
+    return endereco.transporte === 'forja-ssh' ? fixarSsh(e, endereco, r.valor) : fixarHttps(e, endereco, r.valor);
+}
+/** O conteudo de um known_hosts: `null` quando nao existe; `undefined` quando existe e nao se le (nao regular, grande demais). */
+function lerArquivoDeKnownHosts(arquivo) {
+    try {
+        const fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+        try {
+            if (!fs.fstatSync(fd).isFile())
+                return undefined;
+            const conteudo = lerComTeto(fd, LIMITE_DO_KNOWN_HOSTS);
+            return conteudo.length > LIMITE_DO_KNOWN_HOSTS ? undefined : conteudo.toString('utf8');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch (e) {
+        return e.code === 'ENOENT' ? null : undefined;
+    }
+}
+/**
+ * O known_hosts da pessoa para o nome: o que ele aceita e o que ele revoga. Sem arquivo, nada confirma (so a
+ * impressao dita); arquivo que existe e nao se le recusa, porque esconderia uma revogacao. Os known_hosts do sistema
+ * so acrescentam revogacoes, nunca confirmam: ausente ou ilegivel, nao e a confirmacao da pessoa e fica de fora.
+ */
+function conhecidasDoUsuario(arquivo, globais, nome) {
+    let conhecidas = { aceitas: [], revogadas: [] };
+    if (arquivo) {
+        const conteudo = lerArquivoDeKnownHosts(arquivo);
+        if (conteudo === undefined)
+            recusar('ssh.known-hosts-ilegivel', arquivo);
+        if (conteudo)
+            conhecidas = lerKnownHosts(conteudo, nome);
+    }
+    for (const global of globais) {
+        const conteudo = lerArquivoDeKnownHosts(global);
+        if (conteudo)
+            conhecidas.revogadas.push(...lerKnownHosts(conteudo, nome).revogadas);
+    }
+    return conhecidas;
+}
+const impressoes = (ks) => ks.map((k) => `${k.tipo} ${(0, exports.impressaoDaChave)(k.chave)}`).join(', ');
+/**
+ * A chave do servidor so entra confirmada: o known_hosts da pessoa a aceita, ou a impressao dita (`--ssh-fingerprint`)
+ * e a dela. Nunca a primeira que aparece. Revogada no known_hosts, trocada (o known_hosts guarda outra do mesmo tipo)
+ * ou impressao que o servidor nao apresentou recusam.
+ */
+function fixarSsh(e, origin, f) {
+    const { host, porta } = origin;
+    const alvo = { host: f.sshHost ?? f.host, porta: f.sshPorta ?? 22 };
+    if (host !== alvo.host || porta !== alvo.porta)
+        recusar('ssh.divergente', `${host}:${porta} != ${alvo.host}:${alvo.porta}`);
+    // O host vem do parse e nunca comeca por `-`; mesmo assim vai depois do `--`, para nunca virar opcao.
+    if (!endereco_1.HOST_DO_REMOTO.test(host) || !Number.isInteger(porta) || porta < 1 || porta > 65535)
+        recusar('urls', 'origin');
+    const nome = (0, exports.nomeNoKnownHosts)(host, porta);
+    const scan = e.sondas.rodar('ssh-keyscan', ['-T', '10', '-p', String(porta), '-t', 'ed25519,ecdsa,rsa', '--', host], PRAZO_DO_KEYSCAN_MS);
+    const doServidor = lerKeyscan(scan.stdout, nome);
+    if (!doServidor.length)
+        recusar('ssh.sem-resposta', nome);
+    const conhecidas = conhecidasDoUsuario(e.sondas.knownHostsDoUsuario, e.sondas.knownHostsDoSistema ?? [], nome);
+    if (doServidor.some((k) => conhecidas.revogadas.some((r) => mesma(k, r))))
+        recusar('ssh.revogada', nome);
+    const trocadas = doServidor.filter((k) => conhecidas.aceitas.some((u) => u.tipo === k.tipo) && !conhecidas.aceitas.some((u) => mesma(k, u)));
+    if (trocadas.length) {
+        const guardadas = conhecidas.aceitas.filter((u) => trocadas.some((t) => t.tipo === u.tipo));
+        recusar('ssh.impressao-divergente', `known_hosts ${nome}: ${impressoes(guardadas)} != ${impressoes(trocadas)}`);
+    }
+    const lista = impressoes(doServidor);
+    let dita = null;
+    if (e.impressao !== undefined) {
+        dita = e.impressao.trim().replace(/=+$/, '');
+        const valida = IMPRESSAO.test(dita);
+        if (!valida || !doServidor.some((k) => (0, exports.impressaoDaChave)(k.chave) === dita)) {
+            recusar('ssh.impressao-divergente', `${valida ? dita : '--ssh-fingerprint'}; ${nome}: ${lista}`);
+        }
+    }
+    const confirmadas = doServidor.filter((k) => conhecidas.aceitas.some((u) => mesma(k, u)) || (0, exports.impressaoDaChave)(k.chave) === dita);
+    if (!confirmadas.length)
+        recusar('ssh.nao-confirmada', `${nome}: ${lista}`);
+    const knownHosts = (0, exports.linhasDoKnownHosts)(confirmadas, nome);
+    return {
+        knownHosts,
+        fixacao: { schema: exports.ESQUEMA_DA_FIXACAO, raiz: e.raiz, url: e.url, transporte: 'forja-ssh', host, porta,
+            chaves: confirmadas.map((k) => ({ tipo: k.tipo, impressao: (0, exports.impressaoDaChave)(k.chave) })), knownHostsSha256: sha256(knownHosts) },
+    };
+}
+/**
+ * O helper e o da CLI do tipo, pelo caminho real, na versao minima, com `auth git-credential` e login no host exato
+ * (`host[:porta]`, nunca o caminho base). A CA do manifesto e lida uma vez aqui e segue em bytes para a copia fixada.
+ * A saida da CLI nunca e repetida: so o codigo de saida e a versao lida.
+ */
+function fixarHttps(e, origin, f) {
+    const alvo = { tipo: f.tipo, host: f.host, porta: f.porta, caminhoBase: f.caminhoBase, ca: f.ca };
+    const { origem } = alvoDaCredencial(alvo);
+    if (origin.origem !== origem)
+        recusar('https.divergente', `${origin.origem} != ${origem}`);
+    const ca = f.ca === null ? null : lerCa(f.ca);
+    const cli = cli_1.CLI_DA_FORJA[f.tipo];
+    const achado = e.sondas.acharBinario(cli.cmd);
+    if (!achado)
+        return recusar('sem-cli', `${cli.cmd} ${cli.minima}`);
+    const binario = binarioReal(achado);
+    const versao = cli.lerVersao(e.sondas.rodar(binario, ['--version'], PRAZO_DA_CLI_MS).stdout);
+    if (versao === null || (0, cli_1.versaoAbaixo)(versao, cli.minima))
+        return recusar('sem-helper', `${cli.cmd} ${versao ?? '?'} < ${cli.minima}`);
+    const ajuda = e.sondas.rodar(binario, ['auth', 'git-credential', '--help'], PRAZO_DA_CLI_MS);
+    if (ajuda.status !== 0 || !/git-credential/.test(`${ajuda.stdout}\n${ajuda.stderr}`))
+        recusar('sem-helper', `${cli.cmd} ${versao}, >= ${cli.minima}`);
+    // O login confere a mesma CLI que vai ser fixada, pelo caminho real, sem nova busca no PATH.
+    // O login confere no ambiente que o worker vai ter: a mesma pasta de config e as mesmas variaveis, sem token.
+    // A base e o ambiente literal do worker (a lista fechada mais o do transporte), e nao o reduzido do `ork`: proxy ou
+    // variavel da CLI que so quem instala tem nao aprova um login que o worker nao veria.
+    const env = e.sondas.env ?? process.env, amb = ambienteDaCliDoTransporte(cli.cmd, env), executor = e.sondas.rodarCli ?? executor_1.rodarCli;
+    const doWorker = ambienteDoWorkerDoTransporte('forja-https', env, cli.cmd);
+    const rodarLogin = (c) => executor({ ...c, base: doWorker, acrescentar: { ...c.acrescentar, ...amb.acrescentar },
+        apagar: [...(c.apagar ?? []), ...amb.apagar] });
+    if (!(0, api_1.temLogin)(alvo, rodarLogin, binario))
+        recusar('sem-login', `${cli.cmd} ${(0, api_1.chaveDoLogin)(alvo)}`);
+    return {
+        fixacao: { schema: exports.ESQUEMA_DA_FIXACAO, raiz: e.raiz, url: e.url, transporte: 'forja-https', tipo: f.tipo, origem,
+            // O git nunca manda o caminho ao helper (`useHttpPath=false`): a credencial casa pela origem `host[:porta]`.
+            caminho: false, cli: cli.cmd, binario, versaoCli: versao,
+            configDaCli: configDaCliDoAmbiente(cli.cmd, e.sondas.env ?? process.env),
+            ca: ca && f.ca ? { arquivo: f.ca, sha256: sha256(ca) } : null },
+        ...(ca ? { ca } : {}),
+    };
+}