primocode 11.0.0 → 11.1.0

package/lib/mcp.js

@@ -1,819 +0,0 @@
-/**
- * mcp.js — os servidores MCP ao alcance do agente, sem mudar o servidor.
- *
- *   "Coloca MCP, coloca coisas pra otimizar ele." (30/09)
- *
- * Quem declara as ferramentas ao modelo é o servidor do PrimoCode, que este
- * cliente não muda. Então o MCP entra como o editor de vídeo entrou: um
- * subcomando que se descreve (`primocode mcp list`, `primocode mcp call`), e
- * o agente chama pelo run_shell. A lista curta dos servidores e das tools vai
- * no contexto — guardada em cache, para não subir servidor a cada pedido.
- *
- * A configuração é a mesma do Claude Code, para quem já tem uma:
- *   ~/.primocode/mcp.json   e   <pasta do projeto>/.mcp.json
- *   { "mcpServers": { "nome": { "command": "npx", "args": [...], "env": {...} } } }
- *
- * Servidor remoto: { "type": "http", "url": "…", "headers": {…} } (HTTP streamable,
- * com login OAuth: `primocode mcp login <nome>`).
- *
- * O cliente é o mínimo do protocolo por stdio: JSON-RPC 2.0, uma mensagem por
- * linha — initialize, notifications/initialized, tools/list, tools/call.
- *
- * ── MCP PRIMEIRO, MOUSE POR ÚLTIMO ───────────────────────────────────────
- *   "Para a IA não ter que fazer as coisas manualmente no computador do
- *    usuário. Sempre procurar um MCP primeiro; se não tiver, pesquisar se a
- *    ferramenta tem MCP e, se tiver, conectar." (11/10)
- *
- * Clicar no Notion pela tela são vinte ações que quebram com um pop-up; a
- * API do Notion é uma. Por isso `procurar` (a lista curada daqui + o registro
- * oficial em registry.modelcontextprotocol.io) e `conectarNovo` (grava, sobe,
- * lista as tools — e desfaz se não subir). Hoje viram tools nativas
- * (mcp_procurar · mcp_conectar · mcp_usar), sem passar pelo run_shell.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const CASA = path.join(os.homedir(), '.primocode');
-const CONFIG = path.join(CASA, 'mcp.json');
-const CACHE = path.join(CASA, 'mcp-cache.json');
-
-function lerJson(arq) { try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return null; } }
-
-/* O PADRÃO: o Context7, a documentação ATUAL de qualquer biblioteca. É o
-   que mais melhora a programação de um modelo grátis — ele para de chutar a
-   API de memória. Só sobe quando o agente chama; PRIMOCODE_SEM_MCP=1 tira. */
-const PADRAO = { context7: { command: 'npx', args: ['-y', '@upstash/context7-mcp@latest'] } };
-
-/** Os servidores configurados: o padrão, o do usuário e o do projeto (o do projeto vence). */
-function servidores(pasta = process.cwd()) {
-    const out = process.env.PRIMOCODE_SEM_MCP === '1' ? {} : { ...PADRAO };
-    for (const arq of [CONFIG, path.join(pasta, '.mcp.json')]) {
-        const j = lerJson(arq);
-        const doProjeto = arq !== CONFIG;
-        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) {
-            if (s && (s.command || s.url)) out[nome] = doProjeto ? marcarProjeto(s, nome, pasta) : s;
-        }
-    }
-    return out;
-}
-
-/* ── SERVIDOR QUE VEM DO PROJETO ─────────────────────────────────────────
- * O .mcp.json de um repo clonado roda comando na máquina de quem abre. Então
- * servidor do PROJETO (não o do ~/.primocode/mcp.json) só sobe com o sim da
- * pessoa, mesmo no modo auto — lembrado por projeto + configuração exata
- * (hash de command+args+env…): mudou o .mcp.json, pergunta de novo. Sem
- * ninguém para perguntar (headless), não sobe. */
-const APROVADOS = path.join(CASA, 'mcp-aprovados.json');
-let perguntador = null;   // async ({ nome, pasta, def, resumo }) → boolean
-let filaDePerguntas = Promise.resolve();
-
-function marcarProjeto(def, nome, pasta) {
-    const c = { ...def };
-    Object.defineProperty(c, '_projeto', { value: { nome, pasta: path.resolve(pasta) }, enumerable: false });
-    return c;
-}
-
-function hashDoServidor(def) {
-    const d = def || {};
-    const base = JSON.stringify([d.type || '', d.command || '', d.args || [], d.env || {}, d.url || '', d.headers || {}]);
-    return require('crypto').createHash('sha256').update(base).digest('hex');
-}
-
-function usarPerguntador(fn) { perguntador = typeof fn === 'function' ? fn : null; }
-
-function jaAprovado(pasta, def) {
-    const j = lerJson(APROVADOS) || {};
-    return !!(j[path.resolve(pasta)] || {})[hashDoServidor(def)];
-}
-
-function aprovarProjeto(pasta, def, nome = '') {
-    const j = lerJson(APROVADOS) || {};
-    const k = path.resolve(pasta);
-    j[k] = j[k] || {};
-    j[k][hashDoServidor(def)] = nome || true;
-    fs.mkdirSync(CASA, { recursive: true });
-    fs.writeFileSync(APROVADOS, JSON.stringify(j, null, 2), { mode: 0o600 });
-}
-
-function resumoDoServidor(def) {
-    return def.url ? `${def.url}` : [def.command, ...(def.args || [])].join(' ');
-}
-
-/** Lança se o servidor do projeto não foi aprovado (e não há como perguntar). */
-async function autorizarProjeto(def, nomeDado) {
-    const info = def && def._projeto;
-    if (!info) return;
-    const nome = nomeDado || info.nome;
-    if (jaAprovado(info.pasta, def)) return;
-    const recusa = (porque) => {
-        process.stderr.write(`[mcp] servidor "${nome}" do .mcp.json do projeto NÃO foi iniciado: ${porque}\n`);
-        throw new Error(`o servidor MCP "${nome}" vem do .mcp.json deste projeto e não foi aprovado (${porque}). `
-            + 'Rode o PrimoCode neste terminal para aprovar, ou mova o servidor para ~/.primocode/mcp.json.');
-    };
-    if (!perguntador) recusa('sem terminal para pedir o sim');
-    const ok = await (filaDePerguntas = filaDePerguntas.catch(() => {}).then(async () => {
-        if (jaAprovado(info.pasta, def)) return true;
-        const r = await perguntador({ nome, pasta: info.pasta, def, resumo: resumoDoServidor(def) });
-        if (r) aprovarProjeto(info.pasta, def, nome);
-        return !!r;
-    }));
-    if (!ok) recusa('a pessoa não aprovou');
-}
-
-/* Variáveis que o `${VAR}` de um servidor do PROJETO pode ler. O resto vira
-   vazio: um .mcp.json clonado não pode mandar GITHUB_TOKEN para uma URL. Quem
-   quer liberar mais escreve "envPermitidas": ["X"] no ~/.primocode/mcp.json. */
-const ENV_PERMITIDAS = ['HOME', 'USER', 'PATH', 'PWD', 'TMPDIR', 'LANG', 'SHELL'];
-
-function permitidasDoUsuario() {
-    const j = lerJson(CONFIG);
-    return Array.isArray(j && j.envPermitidas) ? j.envPermitidas.map(String) : [];
-}
-
-/** Abre um servidor, faz o aperto de mão e devolve {pedir, fechar}. */
-/* `${VAR}` no argumento vira o valor do env. Sem shell no meio (spawn puro),
-   ninguém expandiria — e é assim que o token entra no header do mcp-remote
-   sem ficar escrito duas vezes no mcp.json. */
-function expandir(args, env, { projeto = false, permitidas = [], aviso = null } = {}) {
-    const livres = new Set([...ENV_PERMITIDAS, ...permitidas]);
-    return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => {
-        if (projeto && !livres.has(k)) {
-            (aviso || ((m) => process.stderr.write(`[mcp] ${m}\n`)))(`\${${k}} no .mcp.json do projeto não é permitida e virou vazia`);
-            return '';
-        }
-        return env[k] != null ? env[k] : '';
-    }));
-}
-
-/** O que o `${VAR}` deste servidor pode ver: o do projeto só lê a lista permitida. */
-function opcoesDeExpansao(def) {
-    return def && def._projeto ? { projeto: true, permitidas: [...permitidasDoUsuario(), ...Object.keys(def.env || {})] } : {};
-}
-
-/** Sobe/abre o servidor: `url` → HTTP, senão stdio. Mesma interface: {pedir, fechar}. */
-async function conectar(def, opcoes = {}) {
-    await autorizarProjeto(def, opcoes.nome);
-    return def && def.url ? conectarHttp(def, opcoes) : conectarStdio(def, opcoes);
-}
-
-function conectarStdio(def, { tetoMs = 60000 } = {}) {
-    return new Promise((resolve, reject) => {
-        const env = { ...process.env, ...(def.env || {}) };
-        const p = spawn(def.command, expandir(def.args, env, opcoesDeExpansao(def)), { env, stdio: ['pipe', 'pipe', 'pipe'] });
-        let buf = '', id = 0;
-        const espera = new Map();
-        const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error('o servidor MCP não respondeu')); }, tetoMs);
-        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
-        p.stdout.on('data', (d) => {
-            buf += d.toString();
-            let i;
-            while ((i = buf.indexOf('\n')) >= 0) {
-                const linha = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
-                if (!linha) continue;
-                let m; try { m = JSON.parse(linha); } catch { continue; }
-                if (m.id != null && espera.has(m.id)) { const w = espera.get(m.id); espera.delete(m.id); m.error ? w.rej(new Error(m.error.message || 'erro do MCP')) : w.res(m.result); }
-            }
-        });
-        const pedir = (method, params = {}) => new Promise((res, rej) => {
-            const meu = ++id;
-            espera.set(meu, { res, rej });
-            p.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: meu, method, params }) + '\n');
-        });
-        const avisar = (method, params = {}) => p.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
-        pedir('initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'primocode', version: '10' } })
-            .then(() => { avisar('notifications/initialized'); clearTimeout(relogio); resolve({ pedir, fechar: () => { try { p.kill(); } catch {} } }); })
-            .catch((e) => { clearTimeout(relogio); try { p.kill(); } catch {} reject(e); });
-    });
-}
-
-/* ── MCP REMOTO (HTTP "streamable") ─────────────────────────────────────
- * Entrada de config: { "type": "http", "url": "https://…/mcp", "headers": {…} }.
- * Cada mensagem é um POST com JSON-RPC; a resposta vem como JSON ou como SSE.
- * O servidor pode dar um `mcp-session-id` no initialize — vai em todo POST
- * depois. 401 → login OAuth (`primocode mcp login <nome>`), mais abaixo. */
-const TOKENS = path.join(CASA, 'mcp-tokens.json');
-const PROTOCOLO = '2025-06-18';
-
-function lerTokens() { return lerJson(TOKENS) || {}; }
-function gravarTokens(mudar) {
-    const t = lerTokens();
-    mudar(t);
-    fs.mkdirSync(CASA, { recursive: true });
-    fs.writeFileSync(TOKENS, JSON.stringify(t, null, 2), { mode: 0o600 });
-    try { fs.chmodSync(TOKENS, 0o600); } catch { /* sem chmod */ }
-}
-
-/** Lê uma resposta SSE até achar a mensagem do id pedido (sem esperar o stream fechar). */
-async function lerSse(res, id) {
-    const dec = new TextDecoder();
-    let buf = '', achada = null;
-    const tratar = (bloco) => {
-        const dados = bloco.split(/\r?\n/).filter((l) => l.startsWith('data:')).map((l) => l.slice(5).replace(/^ /, '')).join('\n');
-        if (!dados) return;
-        let m; try { m = JSON.parse(dados); } catch { return; }
-        if (m && m.id === id && (m.result !== undefined || m.error)) achada = m;
-    };
-    const rd = res.body.getReader();
-    try {
-        for (;;) {
-            const { done, value } = await rd.read();
-            if (value) buf += dec.decode(value, { stream: !done });
-            let i;
-            while ((i = buf.search(/\r?\n\r?\n/)) >= 0) {
-                tratar(buf.slice(0, i));
-                buf = buf.slice(i).replace(/^\r?\n\r?\n/, '');
-                if (achada) return achada;
-            }
-            if (done) break;
-        }
-        if (buf.trim()) tratar(buf);
-    } finally { try { await rd.cancel(); } catch { /* já fechou */ } }
-    return achada;
-}
-
-function conectarHttp(def, { tetoMs = 60000, nome, buscar = globalThis.fetch } = {}) {
-    let sessao = null, id = 0;
-    const cabecalhos = () => {
-        const h = { 'content-type': 'application/json', accept: 'application/json, text/event-stream', 'mcp-protocol-version': PROTOCOLO };
-        const env = { ...process.env, ...(def.env || {}) };
-        // ID token da conta do PrimoCode já logada (o preset primocode-clube usa no lugar de OAuth).
-        if (env.PRIMOCODE_ID_TOKEN == null) { try { env.PRIMOCODE_ID_TOKEN = require('./config.js').tokenDaConta() || ''; } catch { env.PRIMOCODE_ID_TOKEN = ''; } }
-        for (const [k, v] of Object.entries(def.headers || {})) h[k.toLowerCase()] = expandir([v], env, opcoesDeExpansao(def))[0];
-        const tk = nome && lerTokens()[nome];
-        if (tk && tk.access_token && !h.authorization) h.authorization = `Bearer ${tk.access_token}`;
-        if (sessao) h['mcp-session-id'] = sessao;
-        return h;
-    };
-    const postar = async (corpo, jaRenovou = false) => {
-        const res = await buscar(def.url, { method: 'POST', headers: cabecalhos(), body: JSON.stringify(corpo), signal: AbortSignal.timeout(tetoMs) });
-        if (res.status === 401) {
-            try { await res.arrayBuffer(); } catch { /* sem corpo */ }
-            if (!jaRenovou && nome && await renovarToken(nome, { buscar })) return postar(corpo, true);
-            const e = new Error(`o servidor "${nome || def.url}" pede login — rode: primocode mcp login ${nome || '<nome>'}`);
-            e.precisaLogin = true; e.wwwAuthenticate = res.headers.get('www-authenticate') || '';
-            throw e;
-        }
-        return res;
-    };
-    const pedir = async (method, params = {}) => {
-        const meu = ++id;
-        const res = await postar({ jsonrpc: '2.0', id: meu, method, params });
-        const s = res.headers.get('mcp-session-id');
-        if (s) sessao = s;
-        if (!res.ok) throw new Error(`o servidor MCP respondeu HTTP ${res.status}`);
-        const tipo = String(res.headers.get('content-type') || '');
-        const m = /event-stream/i.test(tipo) ? await lerSse(res, meu) : await res.json();
-        if (!m) throw new Error('o servidor MCP não respondeu à chamada');
-        if (m.error) throw new Error(m.error.message || 'erro do MCP');
-        return m.result;
-    };
-    const avisar = async (method, params = {}) => {
-        const res = await postar({ jsonrpc: '2.0', method, params });
-        try { await res.arrayBuffer(); } catch { /* 202 sem corpo */ }
-    };
-    const fechar = () => {
-        if (!sessao) return;
-        buscar(def.url, { method: 'DELETE', headers: cabecalhos(), signal: AbortSignal.timeout(3000) }).catch(() => {});
-    };
-    return pedir('initialize', { protocolVersion: PROTOCOLO, capabilities: {}, clientInfo: { name: 'primocode', version: '10' } })
-        .then(async () => { await avisar('notifications/initialized'); return { pedir, fechar }; });
-}
-
-/* ── LOGIN OAUTH 2.1 (PKCE + registro dinâmico) ─────────────────────────
- * 401 → /.well-known/oauth-protected-resource → servidor de autorização →
- * /.well-known/oauth-authorization-server. Registra o cliente (DCR) com
- * redirect em 127.0.0.1:<porta>/callback, abre o navegador, recebe o code,
- * troca por token. Token só em ~/.primocode/mcp-tokens.json (0600): nunca no
- * repo, nunca no log. */
-const b64url = (b) => Buffer.from(b).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-
-function abrirUrl(url) {
-    if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return false;   // app do Primo (voz): navegador só com clique explícito
-    const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
-        : process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', url]]
-            : ['xdg-open', [url]];
-    try { spawn(cmd, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref(); return true; }
-    catch { return false; }
-}
-
-async function jsonDe(buscar, url, opcoes) {
-    const r = await buscar(url, { signal: AbortSignal.timeout(15000), ...opcoes });
-    let j = null; try { j = await r.json(); } catch { /* sem JSON */ }
-    return { ok: r.ok, status: r.status, j: j || {} };
-}
-
-async function descobrirOAuth(def, wwwAuth, buscar) {
-    const u = new URL(def.url);
-    const dica = /resource_metadata="?([^",\s]+)"?/i.exec(wwwAuth || '');
-    const candidatos = [dica && dica[1], `${u.origin}/.well-known/oauth-protected-resource${u.pathname === '/' ? '' : u.pathname}`, `${u.origin}/.well-known/oauth-protected-resource`].filter(Boolean);
-    let recurso = null;
-    for (const c of candidatos) { const r = await jsonDe(buscar, c).catch(() => null); if (r && r.ok && r.j.authorization_servers) { recurso = r.j; break; } }
-    const emissor = String((recurso && recurso.authorization_servers && recurso.authorization_servers[0]) || u.origin).replace(/\/$/, '');
-    let meta = null;
-    for (const p of ['/.well-known/oauth-authorization-server', '/.well-known/openid-configuration']) {
-        const r = await jsonDe(buscar, emissor + p).catch(() => null);
-        if (r && r.ok && r.j.authorization_endpoint && r.j.token_endpoint) { meta = r.j; break; }
-    }
-    if (!meta) throw new Error(`não achei os metadados OAuth de ${emissor}`);
-    return { meta, escopos: (recurso && recurso.scopes_supported) || [], recurso: (recurso && recurso.resource) || def.url };
-}
-
-/** Espera o navegador voltar em 127.0.0.1:<porta>/callback. Devolve {porta, esperar, fechar}. */
-function ouvirCallback(estado, prazoMs) {
-    const http = require('http');
-    return new Promise((resolve, reject) => {
-        let fim;
-        const esperando = new Promise((res, rej) => { fim = { res, rej }; });
-        esperando.catch(() => {});
-        const srv = http.createServer((req, resp) => {
-            const q = new URL(req.url, 'http://127.0.0.1').searchParams;
-            if (!req.url.startsWith('/callback')) { resp.statusCode = 404; return resp.end(); }
-            const ok = q.get('code') && q.get('state') === estado;
-            resp.writeHead(ok ? 200 : 400, { 'content-type': 'text/html; charset=utf-8' });
-            resp.end(`<!doctype html><meta charset="utf-8"><title>PrimoCode</title><body style="font:16px system-ui;text-align:center;padding:4rem">${ok ? 'Pronto, pode fechar esta aba e voltar ao PrimoCode.' : 'Login não concluído. Volte ao terminal.'}`);
-            if (ok) fim.res(q.get('code')); else fim.rej(new Error(q.get('error_description') || q.get('error') || 'resposta de login inválida'));
-        });
-        srv.on('error', reject);
-        srv.listen(0, '127.0.0.1', () => {
-            const t = setTimeout(() => fim.rej(new Error('o login demorou demais')), prazoMs);
-            resolve({ porta: srv.address().port, esperar: () => esperando, fechar: () => { clearTimeout(t); srv.close(); } });
-        });
-    });
-}
-
-/**
- * `primocode mcp login <nome>`. `abrir` e `buscar` são injetáveis (o teste não abre navegador).
- * @returns {Promise<{ok:boolean, servidor?:string, error?:string}>}
- */
-async function entrar(nome, { pasta, abrir = abrirUrl, aviso = () => {}, buscar = globalThis.fetch, prazoMs = 5 * 60000 } = {}) {
-    const def = servidores(pasta)[nome];
-    if (!def || !def.url) return { ok: false, error: `"${nome}" não é um servidor MCP remoto (type http com url) — veja primocode mcp list` };
-    try { await autorizarProjeto(def, nome); } catch (e) { return { ok: false, error: e.message }; }
-    let cb;
-    try {
-        // Sem token (o do header manual não conta): o 401 diz onde está o OAuth.
-        let www = '';
-        try { await conectarHttp({ ...def, headers: {} }, { buscar }).then((c) => c.fechar()); }
-        catch (e) { if (!e.precisaLogin) throw e; www = e.wwwAuthenticate; }
-        const { meta, escopos, recurso } = await descobrirOAuth(def, www, buscar);
-        const estado = b64url(require('crypto').randomBytes(16));
-        cb = await ouvirCallback(estado, prazoMs);
-        const redirect = `http://127.0.0.1:${cb.porta}/callback`;
-        if (!meta.registration_endpoint) throw new Error('o servidor não aceita registro dinâmico de cliente');
-        const reg = await jsonDe(buscar, meta.registration_endpoint, { method: 'POST', headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ client_name: 'PrimoCode', redirect_uris: [redirect], grant_types: ['authorization_code', 'refresh_token'],
-                response_types: ['code'], token_endpoint_auth_method: 'none', ...(escopos.length ? { scope: escopos.join(' ') } : {}) }) });
-        if (!reg.j.client_id) throw new Error(`o registro do cliente falhou (HTTP ${reg.status})`);
-        const verificador = b64url(require('crypto').randomBytes(32));
-        const desafio = b64url(require('crypto').createHash('sha256').update(verificador).digest());
-        const auth = new URL(meta.authorization_endpoint);
-        for (const [k, v] of Object.entries({ response_type: 'code', client_id: reg.j.client_id, redirect_uri: redirect, state: estado,
-            code_challenge: desafio, code_challenge_method: 'S256', resource: recurso, ...(escopos.length ? { scope: escopos.join(' ') } : {}) })) auth.searchParams.set(k, v);
-        aviso(auth.toString());
-        await abrir(auth.toString());
-        const code = await cb.esperar();
-        const tk = await jsonDe(buscar, meta.token_endpoint, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' },
-            body: new URLSearchParams({ grant_type: 'authorization_code', code, redirect_uri: redirect, client_id: reg.j.client_id, code_verifier: verificador, resource: recurso }).toString() });
-        if (!tk.j.access_token) throw new Error(`a troca do code falhou: ${tk.j.error_description || tk.j.error || 'HTTP ' + tk.status}`);
-        gravarTokens((t) => { t[nome] = { access_token: tk.j.access_token, refresh_token: tk.j.refresh_token || null,
-            expira_em: tk.j.expires_in ? Date.now() + Number(tk.j.expires_in) * 1000 : null,
-            client_id: reg.j.client_id, token_endpoint: meta.token_endpoint, revocation_endpoint: meta.revocation_endpoint || null, resource: recurso }; });
-        return { ok: true, servidor: nome };
-    } catch (e) { return { ok: false, error: e.message }; }
-    finally { if (cb) cb.fechar(); }
-}
-
-/** Troca o refresh_token por um access_token novo. Devolve false se não deu. */
-async function renovarToken(nome, { buscar = globalThis.fetch } = {}) {
-    const tk = lerTokens()[nome];
-    if (!tk || !tk.refresh_token || !tk.token_endpoint) return false;
-    try {
-        const r = await jsonDe(buscar, tk.token_endpoint, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' },
-            body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: tk.refresh_token, client_id: tk.client_id, ...(tk.resource ? { resource: tk.resource } : {}) }).toString() });
-        if (!r.j.access_token) return false;
-        gravarTokens((t) => { t[nome] = { ...tk, access_token: r.j.access_token, refresh_token: r.j.refresh_token || tk.refresh_token,
-            expira_em: r.j.expires_in ? Date.now() + Number(r.j.expires_in) * 1000 : null }; });
-        return true;
-    } catch { return false; }
-}
-
-/** `primocode mcp logout <nome>`: revoga (se o servidor deixa) e apaga o token local. */
-async function sair(nome, { buscar = globalThis.fetch } = {}) {
-    const tk = lerTokens()[nome];
-    if (!tk) return { ok: false, error: `não há login guardado para "${nome}"` };
-    if (tk.revocation_endpoint) {
-        const corpo = (token, tipo) => jsonDe(buscar, tk.revocation_endpoint, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' },
-            body: new URLSearchParams({ token, token_type_hint: tipo, client_id: tk.client_id }).toString() }).catch(() => null);
-        if (tk.refresh_token) await corpo(tk.refresh_token, 'refresh_token');
-        await corpo(tk.access_token, 'access_token');
-    }
-    gravarTokens((t) => { delete t[nome]; });
-    return { ok: true, servidor: nome };
-}
-
-function resumirTools(tools) {
-    return (tools || []).map((t) => ({ nome: t.name, descricao: String(t.description || '').split(/\n|\. /)[0].slice(0, 120), args: Object.keys((t.inputSchema && t.inputSchema.properties) || {}) }));
-}
-
-function gravarCache(mudar) {
-    try {
-        const c = lerJson(CACHE) || { servidores: {} };
-        c.servidores = c.servidores || {};
-        mudar(c.servidores);
-        c.quando = Date.now();
-        fs.mkdirSync(CASA, { recursive: true });
-        fs.writeFileSync(CACHE, JSON.stringify(c, null, 2));
-    } catch { /* sem cache */ }
-}
-
-async function listar(pasta) {
-    const lista = servidores(pasta);
-    const out = {};
-    await Promise.all(Object.entries(lista).map(async ([nome, def]) => {
-        try {
-            const c = await conectar(def, { nome });
-            const r = await c.pedir('tools/list');
-            c.fechar();
-            out[nome] = resumirTools(r.tools);
-        } catch (e) { out[nome] = { erro: e.message }; }
-    }));
-    gravarCache((sv) => { for (const k of Object.keys(sv)) delete sv[k]; Object.assign(sv, out); });
-    return out;
-}
-
-async function chamar(servidor, tool, args = {}, pasta) {
-    const def = servidores(pasta)[servidor];
-    if (!def) throw new Error(`não há servidor MCP "${servidor}" — veja primocode mcp list`);
-    const c = await conectar(def, { nome: servidor });
-    try {
-        const r = await c.pedir('tools/call', { name: tool, arguments: args });
-        return r;
-    } finally { c.fechar(); }
-}
-
-/* ── A LISTA CURADA ─────────────────────────────────────────────────────
- * Vem antes do registro, e funciona sem internet. O registro tem milhares de
- * entradas, e na busca "github" as primeiras são de terceiros que pedem a
- * chave da Smithery — o servidor OFICIAL do GitHub nem aparece. Aqui ficam os
- * conhecidos, conferidos um a um (npm view / registro em 11/10): pacote que
- * existe, não deprecado, e a chave que ele pede com onde pegar.
- * `<...>` nos args é o que o usuário precisa dizer (a pasta, o banco). */
-const REMOTO = (url, header) => ({ command: 'npx', args: ['-y', 'mcp-remote', url, ...(header ? ['--header', header] : [])] });
-const CURADOS = [
-    { nome: 'github', termos: /git ?hub|reposit|pull request|\bpr\b|issue/i, descricao: 'GitHub oficial: repos, issues, PRs, Actions',
-      ...REMOTO('https://api.githubcopilot.com/mcp/', 'Authorization:Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}'),
-      precisa: [{ nome: 'GITHUB_PERSONAL_ACCESS_TOKEN', onde: 'github.com/settings/tokens' }] },
-    { nome: 'notion', termos: /notion/i, descricao: 'Notion oficial: páginas, bancos, busca',
-      command: 'npx', args: ['-y', '@notionhq/notion-mcp-server'],
-      precisa: [{ nome: 'NOTION_TOKEN', onde: 'notion.so/profile/integrations (integração interna, ntn_…)' }] },
-    { nome: 'slack', termos: /slack/i, descricao: 'Slack: canais, mensagens, busca',
-      command: 'npx', args: ['-y', 'slack-mcp-server@latest', '--transport', 'stdio'],
-      precisa: [{ nome: 'SLACK_MCP_XOXP_TOKEN', onde: 'api.slack.com/apps → OAuth & Permissions (User OAuth Token xoxp-…)' }] },
-    { nome: 'google-drive', termos: /google ?drive|\bdrive\b|planilha|sheets|google docs/i, descricao: 'Google Drive, Docs e Sheets',
-      command: 'npx', args: ['-y', '@piotr-agier/google-drive-mcp'],
-      precisa: [{ nome: 'GOOGLE_DRIVE_OAUTH_CREDENTIALS', onde: 'caminho do JSON de credencial OAuth (console.cloud.google.com → Credenciais)' }] },
-    { nome: 'figma', termos: /figma/i, descricao: 'Figma: lê arquivos, frames e estilos',
-      command: 'npx', args: ['-y', 'figma-developer-mcp', '--stdio'],
-      precisa: [{ nome: 'FIGMA_API_KEY', onde: 'figma.com → Settings → Personal access tokens' }] },
-    { nome: 'postgres', termos: /postgres|banco de dados|\bsql\b|\bbanco\b/i, descricao: 'Postgres: consulta, esquema, saúde do banco',
-      command: 'uvx', args: ['postgres-mcp', '--access-mode=restricted'],
-      precisa: [{ nome: 'DATABASE_URI', onde: 'a URL do banco (postgresql://usuario:senha@host:5432/banco)' }] },
-    { nome: 'sqlite', termos: /sqlite|\.db\b/i, descricao: 'SQLite: consulta um arquivo .db',
-      command: 'npx', args: ['-y', 'mcp-server-sqlite-npx', '<caminho do arquivo .db>'], precisa: [] },
-    { nome: 'filesystem', termos: /arquivos? (de|em) outra pasta|filesystem|sistema de arquivos/i, descricao: 'Arquivos de uma pasta fora do projeto',
-      command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '<pasta>'], precisa: [] },
-    { nome: 'playwright', termos: /playwright|navegador|browser|site|p[áa]gina/i, descricao: 'Playwright (Microsoft): navegador por acessibilidade, sem pixel',
-      command: 'npx', args: ['-y', '@playwright/mcp@latest'], precisa: [] },
-    { nome: 'supabase', termos: /supabase/i, descricao: 'Supabase oficial: projetos, tabelas, SQL, edge functions',
-      command: 'npx', args: ['-y', '@supabase/mcp-server-supabase@latest'],
-      precisa: [{ nome: 'SUPABASE_ACCESS_TOKEN', onde: 'supabase.com/dashboard/account/tokens' }] },
-    { nome: 'stripe', termos: /stripe|pagamento|cobran[çc]a/i, descricao: 'Stripe oficial: clientes, cobranças, links de pagamento',
-      command: 'npx', args: ['-y', '@stripe/mcp', '--tools=all'],
-      precisa: [{ nome: 'STRIPE_SECRET_KEY', onde: 'dashboard.stripe.com/apikeys (de preferência uma restricted key)' }] },
-    { nome: 'clube-do-motion', termos: /clube do motion|motion|anima[çc][aã]o|refer[êe]ncias? de motion/i,
-      descricao: 'projetos de motion completos, referências, skills e músicas (precisa de conta assinante do Clube do Motion)',
-      type: 'http', url: 'https://clubedomotion.com/mcp', precisa: [] },
-    /* O Clube do próprio PrimoCode (server/lib/clube-mcp.js). Sem OAuth por ora: o header leva o
-       ID token da conta já logada no CLI (${PRIMOCODE_ID_TOKEN}, preenchido em conectarHttp). TODO: OAuth. */
-    { nome: 'primocode-clube', termos: /primocode clube|clube do primocode/i,
-      descricao: 'Clube do PrimoCode: projetos, skills, referências e músicas (grátis vê resumo; completo é do plano pago)',
-      type: 'http', url: 'https://primocode-server-production.up.railway.app/mcp',
-      headers: { Authorization: 'Bearer ${PRIMOCODE_ID_TOKEN}' }, precisa: [] },
-    { nome: 'linear', termos: /linear/i, descricao: 'Linear oficial: issues, projetos (login pelo navegador)',
-      ...REMOTO('https://mcp.linear.app/mcp'), precisa: [] },
-    { nome: 'sentry', termos: /sentry/i, descricao: 'Sentry oficial: erros, issues, releases',
-      command: 'npx', args: ['-y', '@sentry/mcp-server@latest'],
-      precisa: [{ nome: 'SENTRY_ACCESS_TOKEN', onde: 'sentry.io → Settings → Auth Tokens' }] },
-    { nome: 'vercel', termos: /vercel/i, descricao: 'Vercel oficial: projetos, deploys, logs (login pelo navegador)',
-      ...REMOTO('https://mcp.vercel.com'), precisa: [] },
-    { nome: 'cloudflare', termos: /cloudflare|workers?\b/i, descricao: 'Cloudflare oficial: Workers, KV, R2, D1 (login pelo navegador)',
-      ...REMOTO('https://bindings.mcp.cloudflare.com/mcp'), precisa: [] },
-    { nome: 'firebase', termos: /firebase|firestore/i, descricao: 'Firebase oficial (firebase-tools): projetos, Firestore, Auth',
-      command: 'npx', args: ['-y', 'firebase-tools@latest', 'mcp'], precisa: [] },
-];
-
-const REGISTRO = 'https://registry.modelcontextprotocol.io/v0/servers';
-
-/* O nome que fica no mcp.json: o pedaço final, curto. "io.github.github/
-   github-mcp-server" vira "github-mcp-server". */
-function nomeCurto(n) {
-    return String(n || '').split('/').pop().replace(/[^a-zA-Z0-9_.-]+/g, '-').toLowerCase().slice(0, 40) || 'mcp';
-}
-
-/* Uma entrada do registro vira candidatos de instalação. Cada formato tem o
-   seu lançador: npm → npx, pypi → uvx, oci → docker; remoto (http/sse) entra
-   pelo mcp-remote, que fala stdio deste lado. */
-function doRegistro(item) {
-    const s = (item && item.server) || item || {};
-    const instalar = [];
-    for (const pk of s.packages || []) {
-        const env = (pk.environmentVariables || []).map((e) => ({ nome: e.name, descricao: String(e.description || '').slice(0, 140), obrigatorio: !!e.isRequired, segredo: !!e.isSecret }));
-        const t = pk.transport && pk.transport.type;
-        if (t && t !== 'stdio') continue;
-        const extra = (pk.packageArguments || []).filter((a) => a.isRequired).flatMap((a) => {
-            const v = a.value || a.default || `<${a.valueHint || a.name || 'valor'}>`;
-            return a.type === 'named' ? [a.name, v] : [v];
-        });
-        if (pk.registryType === 'npm') instalar.push({ tipo: 'npm', command: 'npx', args: ['-y', pk.identifier, ...extra], env });
-        else if (pk.registryType === 'pypi') instalar.push({ tipo: 'pypi', command: 'uvx', args: [pk.identifier, ...extra], env });
-        else if (pk.registryType === 'oci') instalar.push({ tipo: 'oci', command: 'docker', args: ['run', '-i', '--rm', ...env.flatMap((e) => ['-e', e.nome]), pk.identifier, ...extra], env });
-    }
-    for (const r of s.remotes || []) {
-        if (!/^https:\/\//.test(r.url || '') || /\{/.test(r.url)) continue; // URL com molde pede dado que não temos
-        const env = [];
-        const args = ['-y', 'mcp-remote', r.url];
-        for (const h of r.headers || []) {
-            if (!h.isRequired && !h.isSecret) continue;
-            // "Bearer {smithery_api_key}" → "Bearer ${SMITHERY_API_KEY}"; sem molde, o header inteiro vem do env.
-            let valor = h.value ? String(h.value).replace(/\{([a-zA-Z0-9_]+)\}/g, (_, k) => {
-                const n = k.toUpperCase();
-                env.push({ nome: n, descricao: String(h.description || '').slice(0, 140), obrigatorio: true, segredo: true });
-                return '${' + n + '}';
-            }) : null;
-            if (!valor) {
-                const n = `MCP_${String(h.name).toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`;
-                env.push({ nome: n, descricao: `valor do header ${h.name} (ex: Bearer <token>)`, obrigatorio: true, segredo: true });
-                valor = '${' + n + '}';
-            }
-            args.push('--header', `${h.name}:${valor}`);
-        }
-        instalar.push({ tipo: r.type || 'remoto', command: 'npx', args, env });
-    }
-    return { nome: nomeCurto(s.name), registro: s.name, descricao: String(s.title ? `${s.title} — ${s.description || ''}` : s.description || '').slice(0, 160), versao: s.version, instalar };
-}
-
-function doCurado(c) {
-    if (c.url) return { nome: c.nome, fonte: 'curado', descricao: c.descricao,
-        instalar: [{ tipo: 'curado', command: 'primocode', args: ['mcp', 'conectar', c.nome], env: [] }] };
-    return { nome: c.nome, fonte: 'curado', descricao: c.descricao,
-        instalar: [{ tipo: 'curado', command: c.command, args: c.args, env: (c.precisa || []).map((p) => ({ nome: p.nome, descricao: p.onde, obrigatorio: true, segredo: true })) }] };
-}
-
-/**
- * Procura um servidor MCP para o serviço: a lista curada primeiro, depois o
- * registro oficial. `buscar` é o fetch (o teste troca; sem rede, só a curada).
- */
-async function procurar(q, { buscar = globalThis.fetch, limite = 8, tetoMs = 8000 } = {}) {
-    const busca = String(q || '').trim();
-    if (!busca) return { ok: false, error: 'Diga o serviço ou app a procurar (ex: "notion", "github").' };
-    const ja = servidores();
-    const curados = CURADOS.filter((c) => c.termos.test(busca) || busca.toLowerCase().includes(c.nome)).map(doCurado);
-    let registro = [], aviso;
-    if (typeof buscar === 'function') {
-        const ctl = typeof AbortController === 'function' ? new AbortController() : null;
-        const relogio = ctl ? setTimeout(() => ctl.abort(), tetoMs) : null;
-        try {
-            const url = `${REGISTRO}?search=${encodeURIComponent(busca)}&limit=${Math.max(limite * 3, 20)}&version=latest`;
-            const r = await buscar(url, ctl ? { signal: ctl.signal } : {});
-            if (!r.ok) throw new Error(`registro respondeu ${r.status}`);
-            const j = await r.json();
-            const termo = busca.toLowerCase().split(/\s+/)[0];
-            registro = (j.servers || [])
-                // version=latest já filtra; a marca isLatest é a rede caso o parâmetro mude.
-                .filter((x) => { const m = x._meta && x._meta['io.modelcontextprotocol.registry/official']; return !m || m.isLatest !== false; })
-                .map(doRegistro)
-                .filter((x) => x.instalar.length)
-                // A busca do registro casa até a URL do repositório ("github" traz
-                // tudo que mora no GitHub). Fica o que fala do serviço no nome ou na descrição.
-                // O prefixo "io.github.<dono>/" não conta: é onde mora, não o que faz.
-                .filter((x) => `${x.nome} ${x.descricao}`.toLowerCase().includes(termo))
-                .map((x) => ({ ...x, fonte: 'registro',
-                    // Relevância: o nome casa com a busca, e tem pacote que roda local (sem chave de intermediário).
-                    pontos: (x.nome.includes(termo) ? 2 : 0) + (x.instalar.some((i) => i.tipo === 'npm') ? 1 : 0) - (/smithery/.test(x.registro) ? 2 : 0) }))
-                .sort((a, b) => b.pontos - a.pontos)
-                .map(({ pontos, ...x }) => x);
-        } catch (e) { aviso = `registro indisponível (${e.name === 'AbortError' ? 'demorou' : e.message}) — só a lista curada`; }
-        finally { if (relogio) clearTimeout(relogio); }
-    }
-    const vistos = new Set();
-    const resultados = [...curados, ...registro].filter((x) => !vistos.has(x.nome) && vistos.add(x.nome)).slice(0, limite)
-        .map((x) => ({ ...x, jaConectado: !!ja[x.nome] }));
-    return { ok: true, busca, resultados,
-        ...(aviso ? { aviso } : {}),
-        proximo: resultados.length
-            ? 'Escolha o primeiro que serve e chame mcp_conectar {nome, comando, args, env} com o "instalar" dele (curado: só {nome} basta). Env obrigatório sem valor: PEÇA a chave ao usuário antes.'
-            : 'Nenhum MCP para isso. Tente API/CLI pelo run_shell; o mouse (desktop_*) é o último recurso.' };
-}
-
-function lerConfig(arq) { const j = lerJson(arq) || {}; j.mcpServers = j.mcpServers || {}; return j; }
-function gravarConfig(arq, j) {
-    fs.mkdirSync(path.dirname(arq), { recursive: true });
-    // Pode levar token: só o dono lê.
-    fs.writeFileSync(arq, JSON.stringify(j, null, 2), { mode: 0o600 });
-}
-
-/**
- * Grava, sobe e valida um servidor novo. Não salva o que não subiria: sem a
- * chave obrigatória, devolve o que perguntar ao usuário; se não responder ao
- * tools/list, desfaz a gravação.
- */
-async function conectarNovo({ nome, command, comando, args, env } = {}, { config = CONFIG, tetoMs = 120000 } = {}) {
-    const n = String(nome || '').trim().toLowerCase();
-    if (!/^[a-z0-9][a-z0-9_.-]{0,40}$/.test(n)) return { ok: false, error: 'nome inválido: letras, números, - _ . (ex: "notion")' };
-    const curado = CURADOS.find((c) => c.nome === n);
-    let cmd = command || comando;
-    if (!cmd && curado && curado.url) {
-        // Servidor remoto (HTTP): grava, tenta; se pede login, o registro fica e o usuário entra.
-        const def = { type: 'http', url: curado.url };
-        if (curado.headers) def.headers = curado.headers;
-        const j = lerConfig(config);
-        const antes = j.mcpServers[n];
-        j.mcpServers[n] = def;
-        gravarConfig(config, j);
-        let c;
-        try {
-            c = await conectar(def, { tetoMs, nome: n });
-            const ferramentas = resumirTools((await c.pedir('tools/list')).tools);
-            gravarCache((sv) => { sv[n] = ferramentas; });
-            return { ok: true, servidor: n, ferramentas, proximo: `Conectado. Use mcp_usar {servidor:"${n}", ferramenta, argumentos}.` };
-        } catch (e) {
-            if (e.precisaLogin) return { ok: false, salvo: true, precisaLogin: true, error: `"${n}" foi salvo e precisa de login. Peça ao usuário para rodar: primocode mcp login ${n}` };
-            const k = lerConfig(config);
-            if (antes) k.mcpServers[n] = antes; else delete k.mcpServers[n];
-            gravarConfig(config, k);
-            return { ok: false, salvo: false, error: `o servidor "${n}" não subiu: ${e.message}. Nada ficou salvo.` };
-        } finally { if (c) c.fechar(); }
-    }
-    let lista = Array.isArray(args) ? args.map(String) : (typeof args === 'string' && args.trim() ? args.trim().split(/\s+/) : null);
-    if (!cmd && curado) { cmd = curado.command; lista = lista || curado.args.slice(); }
-    if (!cmd) return { ok: false, error: `não conheço "${n}" de cor — chame mcp_procurar primeiro e passe comando e args do "instalar".` };
-    lista = lista || [];
-    const vars = {};
-    for (const [k, v] of Object.entries(env || {})) if (v != null && String(v).trim() !== '') vars[k] = String(v);
-
-    const molde = lista.filter((a) => /<[^>]+>/.test(a));
-    if (molde.length) return { ok: false, salvo: false, falta: molde, error: `Falta preencher ${molde.join(', ')} nos args. Pergunte ao usuário e chame de novo.` };
-
-    // A chave que falta: a da curadoria e a que os args citam como ${VAR}.
-    const pedidas = new Map((curado && cmd === curado.command ? curado.precisa : []).map((p) => [p.nome, p.onde]));
-    for (const a of lista) for (const m of a.matchAll(/\$\{([A-Z0-9_]+)\}/g)) if (!pedidas.has(m[1])) pedidas.set(m[1], '');
-    const faltam = [...pedidas].filter(([k]) => !vars[k] && !process.env[k]).map(([k, onde]) => ({ nome: k, onde }));
-    if (faltam.length) {
-        return { ok: false, salvo: false, precisaDe: faltam,
-            error: `O MCP "${n}" precisa de ${faltam.map((f) => f.nome).join(', ')}. NÃO salvei nada. Peça ao usuário`
-                + `${faltam.some((f) => f.onde) ? ` (onde pegar: ${faltam.filter((f) => f.onde).map((f) => `${f.nome} → ${f.onde}`).join('; ')})` : ''}`
-                + ' e chame mcp_conectar de novo com env.' };
-    }
-
-    const def = { command: cmd, args: lista, ...(Object.keys(vars).length ? { env: vars } : {}) };
-    const j = lerConfig(config);
-    const antes = j.mcpServers[n];
-    j.mcpServers[n] = def;
-    gravarConfig(config, j);
-    let c;
-    try {
-        c = await conectar(def, { tetoMs, nome: n });
-        const r = await c.pedir('tools/list');
-        const ferramentas = resumirTools(r.tools);
-        gravarCache((sv) => { sv[n] = ferramentas; });
-        return { ok: true, servidor: n, ferramentas,
-            proximo: `Conectado. Use mcp_usar {servidor:"${n}", ferramenta, argumentos}.` };
-    } catch (e) {
-        // Não subiu: o mcp.json volta a ser o que era.
-        const k = lerConfig(config);
-        if (antes) k.mcpServers[n] = antes; else delete k.mcpServers[n];
-        gravarConfig(config, k);
-        return { ok: false, salvo: false, error: `o servidor "${n}" não subiu: ${e.message}. Nada ficou salvo.` };
-    } finally { if (c) c.fechar(); }
-}
-
-function textoDe(r) {
-    return (r.content || []).map((x) => (x.type === 'text' ? x.text : `[${x.type}]`)).join('\n');
-}
-
-/** A tool nativa mcp_usar: chama e devolve o texto, no formato das outras tools. */
-async function usar(servidor, ferramenta, argumentos = {}, pasta) {
-    if (!servidor || !ferramenta) return { ok: false, error: 'Diga servidor e ferramenta (veja [mcp] no contexto, ou mcp_procurar).' };
-    let a = argumentos;
-    if (typeof a === 'string') { try { a = JSON.parse(a || '{}'); } catch { return { ok: false, error: 'argumentos não é JSON válido' }; } }
-    const r = await chamar(servidor, ferramenta, a || {}, pasta);
-    return { ok: !r.isError, servidor, ferramenta, resultado: textoDe(r).slice(0, 20000) };
-}
-
-/** A linha do contexto: só se houver servidor configurado, a partir do cache. */
-function dica(pasta) {
-    const lista = Object.keys(servidores(pasta));
-    if (!lista.length) return '';
-    const c = lerJson(CACHE);
-    const det = lista.map((n) => {
-        const tools = c && c.servidores && Array.isArray(c.servidores[n]) ? c.servidores[n].map((t) => t.nome).slice(0, 8).join(', ') : '';
-        return tools ? `${n} (${tools})` : n;
-    }).join(' · ');
-    return `[mcp] Servidores MCP disponíveis: ${det}. Use com mcp_usar {servidor, ferramenta, argumentos}. `
-        + 'Serviço sem MCP aqui: mcp_procurar → mcp_conectar.'
-        + (c ? '' : ' (primocode mcp list mostra as tools.)');
-}
-
-/** `primocode mcp …` */
-async function main(argv) {
-    const [op, ...resto] = argv;
-    if (!perguntador && process.stdin.isTTY && process.stdout.isTTY) {
-        perguntador = ({ nome, resumo }) => new Promise((res) => {
-            const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
-            rl.question(`O servidor MCP "${nome}" vem do .mcp.json deste projeto e vai rodar: ${resumo}\nIniciar? (s/N) `, (r) => {
-                rl.close(); res(/^(s|sim|y|yes)\b/i.test(String(r).trim()));
-            });
-        });
-    }
-    const json = (() => { const i = resto.indexOf('--json'); try { return i >= 0 ? JSON.parse(resto[i + 1] || '{}') : {}; } catch { return null; } })();
-    try {
-        if (!op || op === 'help') {
-            console.log('primocode mcp list                         — servidores e tools (de ~/.primocode/mcp.json e .mcp.json)');
-            console.log("primocode mcp call <servidor> <tool> --json '{...}'  — chama uma tool; sai o resultado em JSON");
-            console.log('primocode mcp add <nome> -- <comando> [args…]  — guarda um servidor em ~/.primocode/mcp.json');
-            console.log('primocode mcp procurar <serviço>           — acha o MCP de um serviço (lista curada + registro oficial)');
-            console.log('primocode mcp conectar <nome> [--env K=V…] [-- <comando> [args…]]  — grava, sobe e valida');
-            console.log('primocode mcp login <nome>                 — entra num servidor remoto (OAuth pelo navegador); ex: clube-do-motion');
-            console.log('primocode mcp logout <nome>                — apaga o login guardado em ~/.primocode/mcp-tokens.json');
-            return 0;
-        }
-        if (op === 'login' || op === 'logout') {
-            if (!resto[0]) { console.log(`uso: primocode mcp ${op} <nome>`); return 1; }
-            if (op === 'login') {
-                // Servidor da lista curada ainda não gravado: grava antes de entrar.
-                const cur = CURADOS.find((c) => c.nome === resto[0] && c.url);
-                if (cur && !servidores(process.cwd())[cur.nome]) { const j = lerConfig(CONFIG); j.mcpServers[cur.nome] = { type: 'http', url: cur.url }; gravarConfig(CONFIG, j); }
-                const r = await entrar(resto[0], { pasta: process.cwd(), aviso: (u) => console.log(`abrindo o navegador… se não abrir, cole este link:\n${u}`) });
-                console.log(r.ok ? `login feito: ${r.servidor}` : r.error);
-                return r.ok ? 0 : 1;
-            }
-            const r = await sair(resto[0]);
-            console.log(r.ok ? `login apagado: ${r.servidor}` : r.error);
-            return r.ok ? 0 : 1;
-        }
-        if (op === 'list') { console.log(JSON.stringify(await listar(process.cwd()))); return 0; }
-        if (op === 'call') {
-            if (json === null) { console.log(JSON.stringify({ ok: false, error: '--json inválido' })); return 1; }
-            const r = await chamar(resto[0], resto[1], json, process.cwd());
-            console.log(JSON.stringify({ ok: !r.isError, resultado: textoDe(r).slice(0, 20000) }));
-            return r.isError ? 1 : 0;
-        }
-        if (op === 'add') {
-            const i = resto.indexOf('--');
-            const nome = resto[0];
-            const cmd = i >= 0 ? resto.slice(i + 1) : resto.slice(1);
-            if (!nome || !cmd.length) { console.log('uso: primocode mcp add <nome> -- <comando> [args…]'); return 1; }
-            const j = lerConfig(CONFIG);
-            j.mcpServers[nome] = { command: cmd[0], args: cmd.slice(1) };
-            gravarConfig(CONFIG, j);
-            console.log(JSON.stringify({ ok: true, servidor: nome }));
-            return 0;
-        }
-        if (op === 'procurar' || op === 'search') {
-            const r = await procurar(resto.join(' '));
-            if (!r.ok) { console.log(r.error); return 1; }
-            for (const x of r.resultados) {
-                const i = x.instalar[0];
-                const chaves = i.env.filter((e) => e.obrigatorio).map((e) => e.nome);
-                console.log(`${x.jaConectado ? '✔' : '·'} ${x.nome}  [${x.fonte}]  ${x.descricao}`);
-                console.log(`    ${i.command} ${i.args.join(' ')}${chaves.length ? `   (precisa: ${chaves.join(', ')})` : ''}`);
-            }
-            if (!r.resultados.length) console.log('nada encontrado.');
-            if (r.aviso) console.log(r.aviso);
-            return 0;
-        }
-        if (op === 'conectar' || op === 'connect') {
-            const i = resto.indexOf('--');
-            const antes = i >= 0 ? resto.slice(0, i) : resto;
-            const cmd = i >= 0 ? resto.slice(i + 1) : [];
-            const env = {};
-            antes.forEach((x, k) => { if (x === '--env' && antes[k + 1]) { const [a, ...b] = antes[k + 1].split('='); env[a] = b.join('='); } });
-            const r = await conectarNovo({ nome: antes[0], command: cmd[0], args: cmd.length ? cmd.slice(1) : undefined, env });
-            if (r.ok) console.log(`conectado: ${r.servidor} — ${r.ferramentas.length} tools (${r.ferramentas.map((t) => t.nome).slice(0, 10).join(', ')})`);
-            else console.log(r.error);
-            return r.ok ? 0 : 1;
-        }
-        console.log(JSON.stringify({ ok: false, error: `operação desconhecida: ${op}` }));
-        return 1;
-    } catch (e) {
-        console.log(JSON.stringify({ ok: false, error: e.message }));
-        return 1;
-    }
-}
-
-module.exports = { usarPerguntador, aprovarProjeto, jaAprovado, hashDoServidor, ENV_PERMITIDAS, servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir, entrar, sair, renovarToken };