@orkastery/cli 0.5.1 → 0.5.6

package/dist/rede-forja.js

@@ -0,0 +1,289 @@
+"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.ORDEM_DAS_FORJAS = void 0;
+exports.pastasDeBinarios = pastasDeBinarios;
+exports.acharBinario = acharBinario;
+exports.versaoDoBinario = versaoDoBinario;
+exports.comGitIsolado = comGitIsolado;
+exports.forjaPorNome = forjaPorNome;
+exports.forjasDaMaquina = forjasDaMaquina;
+exports.ehNomeDeForja = ehNomeDeForja;
+/**
+ * RM-053: a forja da pessoa (GitHub pelo `gh`, GitLab pelo `glab`) atras de uma interface so.
+ *
+ * D4: a identidade vem da CLI da forja ja autenticada. Daqui so sai o LOGIN (o campo `login` de
+ * `gh api user`, o `username` de `glab api user`); plano, e-mail e qualquer outro campo da resposta
+ * sao descartados na leitura. O git autentica pelo helper de credencial da propria CLI
+ * (`gh auth git-credential`, `glab auth git-credential`), configurado so no cache bare da rede: o
+ * `ork` nunca le, copia nem guarda token.
+ *
+ * D11: binario e procurado no PATH e nas pastas de usuario comuns. O cron do pulse tem PATH curto,
+ * e sem isso o retrato da maquina oscilaria entre a batida e o terminal. `ORK_BINARIOS_EXTRA`
+ * substitui a lista de pastas extras (os testes zeram, para nunca achar a forja de verdade).
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const redacao_url_1 = require("./redacao-url");
+exports.ORDEM_DAS_FORJAS = ['github', 'gitlab'];
+const LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,254})$/;
+const HOST = /^[A-Za-z0-9.-]+(?::\d+)?$/;
+const VERSAO = /\b(\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.]{1,20})?)\b/;
+const ambienteDe = (amb) => amb.env ?? process.env;
+const homeDe = (amb) => amb.home ?? os.homedir();
+/** As pastas onde a rede procura binarios: PATH primeiro, depois as de usuario (D11). */
+function pastasDeBinarios(amb = {}) {
+    const env = ambienteDe(amb), home = homeDe(amb);
+    const doPath = (env.PATH ?? '').split(path.delimiter).filter(Boolean);
+    const extras = env.ORK_BINARIOS_EXTRA !== undefined
+        ? env.ORK_BINARIOS_EXTRA.split(path.delimiter).filter(Boolean)
+        : [...['.local/bin', '.npm-global/bin', 'bin', '.bun/bin', '.volta/bin', '.claude/local'].map((d) => path.join(home, d)),
+            '/usr/local/bin', '/opt/homebrew/bin'];
+    return [...new Set([...doPath, ...extras])];
+}
+/** O primeiro executavel com esse nome nas pastas da rede, ou `null`. */
+function acharBinario(nome, amb = {}) {
+    for (const dir of pastasDeBinarios(amb)) {
+        const candidato = path.join(dir, nome);
+        try {
+            fs.accessSync(candidato, fs.constants.X_OK);
+            if (fs.statSync(candidato).isFile())
+                return candidato;
+        }
+        catch { /* proxima pasta */ }
+    }
+    return null;
+}
+/** Roda a CLI sem prompt nem cor; a saida de erro so volta curta e sem credencial em URL. */
+function rodar(binario, args, amb, timeoutMs) {
+    const env = { ...ambienteDe(amb), GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', NO_PROMPT: '1', NO_COLOR: '1' };
+    const r = (0, node_child_process_1.spawnSync)(binario, args, { encoding: 'utf8', timeout: timeoutMs, env, maxBuffer: 1024 * 1024 });
+    return { ok: r.status === 0, stdout: (r.stdout ?? '').toString(), stderr: (r.stderr ?? '').toString() };
+}
+/** A versao do binario (`<bin> --version`), so quando casa o formato de versao; o resto vira `null`. */
+function versaoDoBinario(binario, amb = {}) {
+    const r = rodar(binario, ['--version'], amb, 5000);
+    const m = VERSAO.exec(`${r.stdout}\n${r.stderr}`.slice(0, 400));
+    return m && m[1].length <= 40 ? m[1] : null;
+}
+function json(texto) {
+    try {
+        const v = JSON.parse(texto);
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Variaveis que redirecionam o git para outro repositorio (um hook do git exporta GIT_DIR). */
+const GIT_REDIRECIONA = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_COMMON_DIR', 'GIT_OBJECT_DIRECTORY',
+    'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_NAMESPACE', 'GIT_QUARANTINE_PATH', 'GIT_PREFIX'];
+/**
+ * Roda `f` com o git da rede isolado do ambiente de quem chamou (GO-FIX 1 do CHECK 1 e GO-FIX 2):
+ *   - sem as variaveis que redirecionam o repositorio: chamado de um hook, o git do cache miraria o
+ *     projeto e regravaria a config dele (A2);
+ *   - sem a config que um hook injeta (`GIT_CONFIG_PARAMETERS`, `GIT_CONFIG_COUNT/KEY_n/VALUE_n`):
+ *     um `-c credential.helper=` zeraria o helper da forja no cache (S5);
+ *   - sem prompt: nem terminal, nem askpass (`GIT_ASKPASS` vazio desliga tambem `core.askPass` e
+ *     `SSH_ASKPASS`), nem SSH interativo, porque a batida roda sem ninguem olhando (M5, S5);
+ *   - em ingles, porque o nucleo interpreta o stderr do git (B5);
+ *   - com autor e committer fixos na maquina, quando ha identidade: `GIT_AUTHOR_EMAIL` e cia. do
+ *     ambiente poriam o e-mail real da pessoa nos commits da casa (B8).
+ * O ambiente volta como estava na saida, inclusive em chamada aninhada.
+ */
+function comGitIsolado(f, identidade, opcoes = {}) {
+    const antes = new Map();
+    const trocar = (k, v) => {
+        if (!antes.has(k))
+            antes.set(k, process.env[k]);
+        if (v === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = v;
+    };
+    for (const k of GIT_REDIRECIONA)
+        trocar(k, undefined);
+    for (const k of Object.keys(process.env))
+        if (/^GIT_CONFIG_(?:PARAMETERS|COUNT|KEY_\d+|VALUE_\d+)$/.test(k))
+            trocar(k, undefined);
+    trocar('GIT_TERMINAL_PROMPT', '0');
+    trocar('GIT_ASKPASS', '');
+    trocar('SSH_ASKPASS_REQUIRE', 'never');
+    // S4: `GIT_SSH_COMMAND` vence `core.sshCommand`; so entra quando ninguem disse como rodar o ssh.
+    if ((opcoes.ssh ?? 'lote') === 'lote' && !process.env.GIT_SSH_COMMAND && !process.env.GIT_SSH)
+        trocar('GIT_SSH_COMMAND', 'ssh -o BatchMode=yes');
+    trocar('LC_ALL', 'C');
+    trocar('LANGUAGE', 'C');
+    const quem = identidade ?? opcoes.identidade;
+    if (quem) {
+        for (const papel of ['AUTHOR', 'COMMITTER']) {
+            trocar(`GIT_${papel}_NAME`, quem.nome);
+            trocar(`GIT_${papel}_EMAIL`, quem.email);
+        }
+    }
+    try {
+        return f();
+    }
+    finally {
+        for (const [k, v] of antes) {
+            if (v === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = v;
+        }
+    }
+}
+const naoEncontrado = (s) => /HTTP 404|404 Not Found|"status"\s*:\s*"?404/i.test(`${s.stdout}\n${s.stderr}`);
+function falhou(cli, rota, s) {
+    const linha = (0, redacao_url_1.redigirCredenciaisUrl)(s.stderr.trim().split('\n').pop() ?? '').slice(0, 200);
+    return new Error(`rede.forja: ${cli} api ${rota} falhou${linha ? `: ${linha}` : ''}`);
+}
+/** A resposta de quem nao tem login (ou tem credencial recusada), no `gh` e no `glab`. */
+const SEM_LOGIN = /auth login|not logged|not authenticated|authentication|HTTP 401|401 Unauthorized|Bad credentials|no token/i;
+/** `usuario: null` so e falta de login quando a forja disse isso; o resto e falha da leitura. */
+function falhaDoLogin(cli, s) {
+    if (!s.ok && SEM_LOGIN.test(`${s.stderr}\n${s.stdout}`))
+        return {};
+    if (s.ok)
+        return { falha: `${cli} api user devolveu uma resposta sem login legivel` };
+    return { falha: falhou(cli, 'user', s.stderr.trim() ? s : { ...s, stderr: 'sem resposta da forja no prazo' }).message.replace(/^rede\.forja: /, '') };
+}
+/** Caminho seguro para o shell que o git usa no helper: aspas simples, com `'` escapada (B10). */
+const citar = (caminho) => /^[A-Za-z0-9_./+-]+$/.test(caminho) ? caminho : `'${caminho.replace(/'/g, `'\\''`)}'`;
+const helper = (binario) => `!${citar(binario)} auth git-credential`;
+/**
+ * Privado de verdade (B1): no GitHub, `internal` vem com `private: true`, e a empresa inteira le.
+ * Quando a forja diz a visibilidade, so `private` conta; sem ela, o booleano.
+ */
+function privadoDe(v) {
+    if (typeof v.visibility === 'string')
+        return v.visibility === 'private';
+    return typeof v.private === 'boolean' ? v.private : null;
+}
+function github(binario, amb, host = 'github.com') {
+    // B2: a casa vai sempre por HTTPS, com o helper da propria CLI; SSH pediria agente, que o cron nao tem.
+    const repositorioDe = (v) => {
+        if (!v)
+            throw new Error('rede.forja: gh devolveu um repositorio ilegivel');
+        return { existe: true, privado: privadoDe(v), url: typeof v.clone_url === 'string' ? v.clone_url : null };
+    };
+    // B9: o host da casa vai em toda chamada; o cron nao tem o ambiente do terminal.
+    const api = (args, timeoutMs) => rodar(binario, ['api', '--hostname', host, ...args], amb, timeoutMs);
+    return {
+        nome: 'github', host, cli: 'gh', binario,
+        identidade() {
+            const r = api(['user'], 15000);
+            const login = r.ok ? json(r.stdout)?.login : null;
+            const usuario = typeof login === 'string' && LOGIN.test(login) ? login : null;
+            return { forja: 'github', host, cli: 'gh', versao: versaoDoBinario(binario, amb), usuario, ...(usuario ? {} : falhaDoLogin('gh', r)) };
+        },
+        repositorio(dono, nome) {
+            const rota = `repos/${dono}/${nome}`;
+            const r = api([rota], 15000);
+            if (!r.ok) {
+                if (naoEncontrado(r))
+                    return { existe: false, privado: null, url: null };
+                throw falhou('gh', rota, r);
+            }
+            return repositorioDe(json(r.stdout));
+        },
+        criarPrivado(nome, descricao) {
+            const r = api(['-X', 'POST', 'user/repos', '-f', `name=${nome}`, '-F', 'private=true',
+                '-f', `description=${descricao}`, '-F', 'has_issues=false', '-F', 'has_wiki=false'], 30000);
+            if (!r.ok)
+                throw falhou('gh', 'user/repos', r);
+            return repositorioDe(json(r.stdout));
+        },
+        helperDeCredencial: () => helper(binario),
+    };
+}
+function hostDoGitlab(amb) {
+    const bruto = (ambienteDe(amb).GITLAB_HOST ?? '').trim().replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+    return HOST.test(bruto) ? bruto : 'gitlab.com';
+}
+function gitlab(binario, amb, hostPedido) {
+    const host = hostPedido ?? hostDoGitlab(amb);
+    const repositorioDe = (v) => {
+        if (!v)
+            throw new Error('rede.forja: glab devolveu um projeto ilegivel');
+        return { existe: true, privado: privadoDe(v), url: typeof v.http_url_to_repo === 'string' ? v.http_url_to_repo : null };
+    };
+    const api = (args, timeoutMs) => rodar(binario, ['api', '--hostname', host, ...args], amb, timeoutMs);
+    return {
+        nome: 'gitlab', host, cli: 'glab', binario,
+        identidade() {
+            const r = api(['user'], 15000);
+            const login = r.ok ? json(r.stdout)?.username : null;
+            const usuario = typeof login === 'string' && LOGIN.test(login) ? login : null;
+            return { forja: 'gitlab', host, cli: 'glab', versao: versaoDoBinario(binario, amb), usuario, ...(usuario ? {} : falhaDoLogin('glab', r)) };
+        },
+        repositorio(dono, nome) {
+            const rota = `projects/${encodeURIComponent(`${dono}/${nome}`)}`;
+            const r = api([rota], 15000);
+            if (!r.ok) {
+                if (naoEncontrado(r))
+                    return { existe: false, privado: null, url: null };
+                throw falhou('glab', rota, r);
+            }
+            return repositorioDe(json(r.stdout));
+        },
+        criarPrivado(nome, descricao) {
+            const r = api(['-X', 'POST', 'projects', '-f', `name=${nome}`, '-f', 'visibility=private',
+                '-f', `description=${descricao}`], 30000);
+            if (!r.ok)
+                throw falhou('glab', 'projects', r);
+            return repositorioDe(json(r.stdout));
+        },
+        helperDeCredencial: () => helper(binario),
+    };
+}
+const CLI_DA_FORJA = { github: 'gh', gitlab: 'glab' };
+/** A forja pelo nome, quando a CLI dela existe nesta maquina; `host` e o da casa gravada, quando ha. */
+function forjaPorNome(nome, amb = {}, host) {
+    const binario = acharBinario(CLI_DA_FORJA[nome], amb);
+    if (!binario)
+        return null;
+    const h = host && HOST.test(host) ? host : undefined;
+    return nome === 'github' ? github(binario, amb, h) : gitlab(binario, amb, h);
+}
+/** As forjas cuja CLI existe nesta maquina, GitHub primeiro. */
+function forjasDaMaquina(amb = {}) {
+    return exports.ORDEM_DAS_FORJAS.map((n) => forjaPorNome(n, amb)).filter((f) => f !== null);
+}
+function ehNomeDeForja(v) {
+    return v === 'github' || v === 'gitlab';
+}

package/dist/rede-projetos.js

@@ -0,0 +1,239 @@
+"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.ehNomeDeProjeto = exports.INVISIVEL = exports.emUmaLinha = exports.CONTRATO_DO_REGISTRO = void 0;
+exports.limparRemoto = limparRemoto;
+exports.lerRegistroDeProjetos = lerRegistroDeProjetos;
+exports.projetoDoDiretorio = projetoDoDiretorio;
+exports.projetosConhecidos = projetosConhecidos;
+/**
+ * RM-053 (D7): os projetos conhecidos desta maquina, na fronteira com a RM-052.
+ *
+ * A RM-052 e a dona do registro `~/.orkastery/projetos.json` (`ork.projetos/v1`); a rede so o LE,
+ * por este adaptador, e nunca o grava. Campos lidos: `nome`, `raiz` (ou `caminho`) e `remoto` (ou
+ * `remotos`, com preferencia por `origin`); o resto e ignorado. Se a forma final da RM-052 mudar,
+ * so este arquivo muda.
+ *
+ * Enquanto o registro nao existe (ou e de outra versao), a lista cai na reserva: o projeto do
+ * diretorio atual e os projetos do ultimo retrato desta maquina cujo caminho ainda tem manifesto.
+ * A reserva do retrato e o que impede a lista de oscilar entre os crons de projetos diferentes.
+ *
+ * Remoto sai sem credencial: usuario e senha da URL somem inteiros, nao so redigidos.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const estado_thread_1 = require("./estado-thread");
+const manifest_1 = require("./manifest");
+const maquina_1 = require("./maquina");
+const rede_forja_1 = require("./rede-forja");
+const saida_segura_1 = require("./saida-segura");
+Object.defineProperty(exports, "emUmaLinha", { enumerable: true, get: function () { return saida_segura_1.emUmaLinha; } });
+Object.defineProperty(exports, "INVISIVEL", { enumerable: true, get: function () { return saida_segura_1.INVISIVEL; } });
+exports.CONTRATO_DO_REGISTRO = 'ork.projetos/v1';
+/**
+ * V3 da revisao 4 e W1 da revisao 5: a regra UNICA de nome de projeto. Cabe no leitor
+ * (`normalizarRetrato`: sem caractere invisivel, ate 80 unidades UTF-16) e pede mais: sem espaco
+ * nas pontas, com algo visivel e sem `://`. O registro e o ultimo retrato a aplicam na leitura; o
+ * escritor tira do retrato, com aviso, o projeto do diretorio atual que a descumpre. Nome de pasta
+ * comum (`c++-tools`, `app (1)`, `r&d`, `Orçamento`) passa: o que o Markdown executaria, a celula
+ * do `REDE.md` escapa.
+ */
+const ehNomeDeProjeto = (nome) => typeof nome === 'string' && nome.length > 0 && nome.length <= 80 && nome === nome.trim() && !saida_segura_1.INVISIVEL.test(nome)
+    // X3 da revisao 6: ao menos uma letra, digito, pontuacao ou simbolo (um nome so de ZWJ nao se ve).
+    // X1: nada de `://`, que o GitHub e o GitLab transformam em link no `REDE.md`.
+    && /[\p{L}\p{N}\p{P}\p{S}]/u.test(nome) && !nome.includes('://');
+exports.ehNomeDeProjeto = ehNomeDeProjeto;
+/** Esquemas de remoto que o retrato mostra; outro esquema vira `null`. */
+const ESQUEMAS = new Set(['https', 'http', 'ssh', 'git', 'git+ssh', 'ssh+git']);
+/** Host: nome DNS ou IPv4 em conjunto fechado, ou IPv6 entre colchetes. */
+const HOST_DO_REMOTO = /^(?:[A-Za-z0-9](?:[A-Za-z0-9.-]{0,251}[A-Za-z0-9])?|\[[0-9A-Fa-f:.]{2,45}\])$/;
+/** Caminho: sem `@`, `:`, `\`, `?` ou `#`; `%` so fora de `%40` (@) e `%3A` (:). */
+const CAMINHO_DO_REMOTO = /^\/(?:[A-Za-z0-9._~/+-]|%(?!40|3[Aa])[0-9A-Fa-f]{2})*$/;
+/**
+ * O remoto como pode ir ao retrato, MONTADO a partir de partes validadas (GO-FIX 3, U1 da revisao 3).
+ *
+ * Tres rodadas de revisao acharam variantes de senha passando pela limpeza do texto de entrada
+ * (usuario:senha na forma scp; `\` num usuario de dominio, que o `URL` do WHATWG le como `/` e o
+ * git nao; a propria saida vazada de uma versao anterior). Aqui a saida so tem esquema conhecido,
+ * host em conjunto fechado, porta numerica e caminho sem `@`, `:` nem `\`: usuario, senha, query e
+ * fragmento nunca sao copiados. Na duvida, `null` (o projeto continua, sem remoto).
+ */
+function limparRemoto(bruto) {
+    if (typeof bruto !== 'string')
+        return null;
+    const texto = bruto.trim();
+    // `\`: o WHATWG e o git discordam sobre onde ela termina o usuario; nao ha remoto legitimo com ela.
+    if (!texto || texto.length > 500 || /[\s\x00-\x1f\x7f\\]/.test(texto))
+        return null;
+    let esquema, host, porta = '', caminho;
+    const url = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(?:[^/?#]*@)?([^/?#:@[\]]+|\[[^\]/?#@]*\])(?::(\d{1,5}))?(\/[^?#]*)?([?#].*)?$/.exec(texto);
+    if (url) {
+        [esquema, host, porta, caminho] = [url[1].toLowerCase(), url[2], url[3] ?? '', url[4] ?? '/'];
+        // V1 da revisao 4: no ssh e no git://, o git nao corta a autoridade em `?` nem `#` (o host vai ate
+        // a primeira `/`, depois de decodificar a URL): la, `?` e `#` ainda sao usuario e senha.
+        if (!/^https?$/.test(esquema) && /[?#]/.test(texto))
+            return null;
+        // No http(s), query e fragmento saem; com `@` neles, nao ha remoto legitimo (defesa em profundidade).
+        if (url[5]?.includes('@'))
+            return null;
+    }
+    else {
+        if (/^[A-Za-z]:[/]/.test(texto))
+            return null;
+        // Forma scp (`git@host:dono/repo.git`): vira `ssh://host/dono/repo.git`, a forma usual das forjas.
+        const scp = /^(?:[^@\s:/]+@)?([A-Za-z0-9.-]{2,}):(?!\/\/)([^\s@]+)$/.exec(texto);
+        if (!scp)
+            return path.isAbsolute(texto) && CAMINHO_DO_REMOTO.test(texto) ? texto : null;
+        [esquema, host, caminho] = ['ssh', scp[1], `/${scp[2].replace(/^\/+/, '')}`];
+    }
+    if (!ESQUEMAS.has(esquema) || !HOST_DO_REMOTO.test(host) || !CAMINHO_DO_REMOTO.test(caminho))
+        return null;
+    if (porta && (Number(porta) < 1 || Number(porta) > 65535))
+        return null;
+    // O host fica como veio: em minusculas, a varredura de segredo (sensivel a caixa, como o `AKIA`) nao o veria.
+    return `${esquema}://${host}${porta ? `:${porta}` : ''}${caminho}`;
+}
+function temManifesto(dir) {
+    return [manifest_1.NOME_MANIFESTO, manifest_1.NOME_MANIFESTO_LEGADO].some((n) => fs.existsSync(path.join(dir, n)));
+}
+function remotoDe(v) {
+    if (typeof v.remoto === 'string')
+        return limparRemoto(v.remoto);
+    const remotos = v.remotos;
+    if (Array.isArray(remotos)) {
+        const lista = remotos.filter((r) => !!r && typeof r === 'object');
+        const escolhido = lista.find((r) => r.nome === 'origin' || r.name === 'origin') ?? lista[0];
+        return escolhido ? limparRemoto(escolhido.url) : null;
+    }
+    if (remotos && typeof remotos === 'object') {
+        const mapa = remotos;
+        return limparRemoto(mapa.origin ?? Object.values(mapa)[0]);
+    }
+    return null;
+}
+function projetoDoRegistro(bruto, nomeDaChave) {
+    if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto))
+        return null;
+    const v = bruto;
+    const nome = typeof v.nome === 'string' ? v.nome : nomeDaChave;
+    const caminho = typeof v.raiz === 'string' ? v.raiz : typeof v.caminho === 'string' ? v.caminho : null;
+    if (!(0, exports.ehNomeDeProjeto)(nome) || !caminho || !path.isAbsolute(caminho) || caminho.length > 1024 || saida_segura_1.INVISIVEL.test(caminho))
+        return null;
+    const normal = path.normalize(caminho);
+    return { nome, remoto: remotoDe(v), caminho: normal, fonte: 'registro', presente: temManifesto(normal) };
+}
+/** O registro da RM-052, lido de forma tolerante. Nunca lanca: registro ruim vira `invalido`. */
+function lerRegistroDeProjetos(arquivo = path.join((0, maquina_1.pastaDoUsuario)(), 'projetos.json')) {
+    let bruto;
+    try {
+        if (fs.statSync(arquivo).size > 1024 * 1024)
+            return { arquivo, estado: 'invalido', projetos: [] };
+        bruto = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    }
+    catch (e) {
+        return { arquivo, estado: e.code === 'ENOENT' ? 'ausente' : 'invalido', projetos: [] };
+    }
+    if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto))
+        return { arquivo, estado: 'invalido', projetos: [] };
+    const v = bruto;
+    if (v.contrato !== undefined && v.contrato !== exports.CONTRATO_DO_REGISTRO)
+        return { arquivo, estado: 'invalido', projetos: [] };
+    const lista = Array.isArray(v.projetos) ? v.projetos.map((p) => projetoDoRegistro(p))
+        : v.projetos && typeof v.projetos === 'object'
+            ? Object.entries(v.projetos).map(([nome, p]) => projetoDoRegistro(p, nome)) : null;
+    if (!lista)
+        return { arquivo, estado: 'invalido', projetos: [] };
+    return { arquivo, estado: 'lido', projetos: lista.filter((p) => p !== null) };
+}
+/** O projeto do diretorio atual, pela raiz canonica (a arvore principal, nunca a worktree). */
+function projetoDoDiretorio(dir) {
+    let carregado;
+    try {
+        carregado = (0, manifest_1.carregarManifesto)(dir);
+    }
+    catch {
+        return null;
+    }
+    if (!carregado || carregado.erros.length > 0)
+        return null;
+    let raiz;
+    try {
+        raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz);
+    }
+    catch {
+        raiz = carregado.raiz;
+    }
+    // RM-047: o `fabrica.remoto` vem do manifesto versionado; fora do formato de remoto, nada vai ao git.
+    const nomeDoRemoto = carregado.manifesto.fabrica.remoto;
+    const remoto = (0, branch_de_estado_1.remotoValido)(nomeDoRemoto) ? (0, rede_forja_1.comGitIsolado)(() => (0, branch_de_estado_1.git)(carregado.raiz, ['remote', 'get-url', '--', nomeDoRemoto])) : null;
+    return { nome: carregado.manifesto.project.name, remoto: remoto?.ok ? limparRemoto(remoto.stdout.trim()) : null,
+        caminho: raiz, fonte: 'cwd', presente: true };
+}
+const chave = (caminho) => { try {
+    return fs.realpathSync(caminho);
+}
+catch {
+    return path.normalize(caminho);
+} };
+/**
+ * Os projetos conhecidos: registro > diretorio atual > ultimo retrato, sem repetir raiz. So entram
+ * do retrato os que ainda tem manifesto no caminho; do registro entram todos, com `presente`.
+ */
+function projetosConhecidos(opcoes = {}) {
+    const registro = lerRegistroDeProjetos(opcoes.arquivo);
+    const vistos = new Map();
+    const somar = (p) => {
+        if (!p)
+            return;
+        const k = chave(p.caminho), atual = vistos.get(k);
+        if (!atual)
+            vistos.set(k, p);
+        else if (!atual.remoto && p.remoto)
+            vistos.set(k, { ...atual, remoto: p.remoto });
+    };
+    registro.projetos.forEach(somar);
+    if (opcoes.diretorio)
+        somar(projetoDoDiretorio(opcoes.diretorio));
+    for (const a of opcoes.anteriores ?? []) {
+        if (!a || !(0, exports.ehNomeDeProjeto)(a.nome) || typeof a.caminho !== 'string' || !path.isAbsolute(a.caminho) || saida_segura_1.INVISIVEL.test(a.caminho))
+            continue;
+        if (!temManifesto(a.caminho))
+            continue;
+        somar({ nome: a.nome, remoto: limparRemoto(a.remoto), caminho: path.normalize(a.caminho), fonte: 'retrato', presente: true });
+    }
+    const projetos = [...vistos.values()].sort((a, b) => a.nome.localeCompare(b.nome) || a.caminho.localeCompare(b.caminho));
+    return { registro, projetos };
+}