primocode 10.19.0 → 11.1.0

package/lib/mcp/mcp.js

@@ -0,0 +1,819 @@
+/**
+ * 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/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 };