primocode 10.12.0 → 10.14.0

package/lib/mcp.js

@@ -13,6 +13,9 @@
  *   ~/.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.
  *
@@ -51,7 +54,7 @@ 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);
-        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) if (s && s.command) out[nome] = s;
+        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) if (s && (s.command || s.url)) out[nome] = s;
     }
     return out;
 }
@@ -64,7 +67,12 @@ function expandir(args, env) {
     return (args || []).map((a) => String(a).replace(/\$\{([A-Z0-9_]+)\}/g, (_, k) => (env[k] != null ? env[k] : '')));
 }
 
-function conectar(def, { tetoMs = 60000 } = {}) {
+/** Sobe/abre o servidor: `url` → HTTP, senão stdio. Mesma interface: {pedir, fechar}. */
+function conectar(def, opcoes = {}) {
+    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), { env, stdio: ['pipe', 'pipe', 'pipe'] });
@@ -94,6 +102,229 @@ function conectar(def, { tetoMs = 60000 } = {}) {
     });
 }
 
+/* ── 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)[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) {
+    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` };
+    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) || {}) }));
 }
@@ -114,7 +345,7 @@ async function listar(pasta) {
     const out = {};
     await Promise.all(Object.entries(lista).map(async ([nome, def]) => {
         try {
-            const c = await conectar(def);
+            const c = await conectar(def, { nome });
             const r = await c.pedir('tools/list');
             c.fechar();
             out[nome] = resumirTools(r.tools);
@@ -127,7 +358,7 @@ async function listar(pasta) {
 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);
+    const c = await conectar(def, { nome: servidor });
     try {
         const r = await c.pedir('tools/call', { name: tool, arguments: args });
         return r;
@@ -173,6 +404,15 @@ const CURADOS = [
     { 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',
@@ -237,6 +477,8 @@ function doRegistro(item) {
 }
 
 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 })) }] };
 }
@@ -304,6 +546,28 @@ async function conectarNovo({ nome, command, comando, args, env } = {}, { config
     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".` };
@@ -332,7 +596,7 @@ async function conectarNovo({ nome, command, comando, args, env } = {}, { config
     gravarConfig(config, j);
     let c;
     try {
-        c = await conectar(def, { tetoMs });
+        c = await conectar(def, { tetoMs, nome: n });
         const r = await c.pedir('tools/list');
         const ferramentas = resumirTools(r.tools);
         gravarCache((sv) => { sv[n] = ferramentas; });
@@ -385,8 +649,24 @@ async function main(argv) {
             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; }
@@ -437,4 +717,4 @@ async function main(argv) {
     }
 }
 
-module.exports = { servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir };
+module.exports = { servidores, conectar, listar, chamar, usar, dica, main, procurar, doRegistro, conectarNovo, CURADOS, expandir, entrar, sair, renovarToken };

package/lib/perigo.js

@@ -17,6 +17,8 @@
  *   auto      — o padrão. Roda tudo, mas SEMPRE pergunta antes do perigoso.
  *   perguntar — pergunta antes de todo comando e de toda escrita de arquivo.
  *   livre     — nunca pergunta. Nem o perigoso.
+ *   plano     — SÓ LÊ: recusa escrita de arquivo, comando que muda coisa e MCP novo.
+ *               O agente investiga e entrega o plano; a pessoa executa em outro modo.
  */
 
 'use strict';
@@ -24,13 +26,13 @@
 const os = require('os');
 const path = require('path');
 
-const MODOS = ['auto', 'perguntar', 'livre'];
+const MODOS = ['auto', 'perguntar', 'livre', 'plano'];
 const COMANDOS = new Set(['run_shell', 'run_in_new_terminal']);
 const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
 
 function normalizarModo(m) {
     const s = String(m || '').trim().toLowerCase();
-    const apelido = { ask: 'perguntar', suggest: 'perguntar', full: 'livre', 'full-auto': 'livre', yolo: 'livre' };
+    const apelido = { ask: 'perguntar', suggest: 'perguntar', full: 'livre', 'full-auto': 'livre', yolo: 'livre', plan: 'plano', 'read-only': 'plano' };
     const n = apelido[s] || s;
     return MODOS.includes(n) ? n : 'auto';
 }
@@ -230,6 +232,24 @@ function classificar(nome, args, { projectDir } = {}) {
     return { perigoso: !!motivo, motivo: motivo || '' };
 }
 
+/* Comando que só olha: todo trecho começa por uma palavra de leitura, sem
+   redirecionar para arquivo. Na dúvida, não é leitura. */
+const LEITURA = new Set([...SO_LE, 'pwd', 'echo', 'find', 'tree', 'which', 'diff', 'sort', 'uniq', 'du', 'df']);
+const GIT_LE = new Set(['status', 'diff', 'log', 'show', 'branch', 'ls-files', 'blame', 'rev-parse']);
+function somenteLeitura(comando) {
+    const s = String(comando || '');
+    if (/[>`]|\$\(|\bfind\b[^;&|]*(-delete|-exec)/.test(s)) return false;
+    const ts = trechos(s);
+    if (!ts.length) return false;
+    return ts.every((t) => {
+        const p = t.palavras.filter((x) => !PREFIXOS.has(x) && !/^[A-Za-z_]\w*=/.test(x));
+        if (!p.length) return false;
+        const cmd = path.basename(p[0]);
+        if (cmd === 'git') return GIT_LE.has(p.slice(1).find((x) => !x.startsWith('-')));
+        return LEITURA.has(cmd);
+    });
+}
+
 function novo() { return { liberados: new Set(), negados: new Set() }; }
 
 /* Uma pergunta por vez. Subagentes rodam em paralelo (Promise.all) e dois
@@ -246,6 +266,14 @@ function emFila(fn) { const p = fila.then(fn, fn); fila = p.catch(() => {}); ret
 async function portao(estado, { modo, nome, args, projectDir, subagent = false, perguntar = null }) {
     const m = normalizarModo(modo);
     if (m === 'livre') return { ok: true };
+    if (m === 'plano') {
+        const mexe = ESCRITAS.has(nome) || nome === 'mcp_conectar'
+            || (COMANDOS.has(nome) && !somenteLeitura((args || {}).command));
+        if (mexe) {
+            return { ok: false, motivo: 'modo plano', error: 'Recusado: o modo plano só lê. Investigue com read_file, grep e comandos de leitura, e entregue o plano; a pessoa muda de modo (/permissoes auto) para executar.' };
+        }
+        return { ok: true };
+    }
     const { perigoso, motivo: motivoPerigo } = classificar(nome, args, { projectDir });
     const tipo = perigoso ? 'perigo' : (m === 'perguntar' && (COMANDOS.has(nome) || nome === 'mcp_usar')) ? 'comando'
         : (m === 'perguntar' && ESCRITAS.has(nome)) ? 'arquivo' : null;
@@ -285,4 +313,4 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
     return recusa(negado);
 }
 
-module.exports = { classificar, portao, novo, normalizarModo, trechos, MODOS };
+module.exports = { somenteLeitura, classificar, portao, novo, normalizarModo, trechos, MODOS };

package/lib/planos.js

@@ -15,17 +15,20 @@
 const https = require('https');
 const http = require('http');
 
+const R = (videosMes, resolucao, marcaDagua, narracaoPremium, clubeCompleto, scriptsAE, prioridade, subagentes) =>
+    ({ videosMes, resolucao, marcaDagua, narracaoPremium, clubeCompleto, scriptsAE, prioridade, subagentes });
+const GRATIS = { id: 'free', nome: 'Grátis', preco: 0, recursos: R(3, 720, true, false, false, false, 0, 0), inclui: [] };
 const RESERVA = [
-    { id: 'primo', nome: 'Primo', preco: 69.9, inclui: ['app e site sem configurar nada', 'modelos do servidor', 'vídeo em 720p'] },
-    { id: 'pro', nome: 'Primo Pro', preco: 129.9, inclui: ['limite alto', 'estúdio de vídeo completo, em 1080p', 'cenários salvos'] },
-    { id: 'max', nome: 'Primo Max', preco: 299.9, inclui: ['sem limite por hora', 'prioridade na fila', 'os melhores modelos', 'vídeos longos'] },
-    { id: 'studio', nome: 'Primo Studio', preco: 599.9, inclui: ['para agência e empresa', 'várias pessoas', 'marca própria nos vídeos'] },
+    { id: 'primo', nome: 'Primo', preco: 69.9, recursos: R(15, 720, false, false, true, false, 0, 0), inclui: [] },
+    { id: 'pro', nome: 'Primo Pro', preco: 129.9, recursos: R(60, 1080, false, true, true, true, 1, 1), inclui: [] },
+    { id: 'max', nome: 'Primo Max', preco: 299.9, recursos: R(200, 2160, false, true, true, true, 2, 3), inclui: [] },
+    { id: 'studio', nome: 'Primo Studio', preco: 599.9, recursos: R(800, 2160, false, true, true, true, 3, 8), inclui: [] },
 ];
 
 function buscarPlanos(servidor, { timeout = 8000 } = {}) {
     return new Promise((resolve) => {
         let url;
-        try { url = new URL('/api/planos', servidor); } catch { return resolve({ ok: false, planos: RESERVA }); }
+        try { url = new URL('/api/planos', servidor); } catch { return resolve({ ok: false, planos: RESERVA, gratis: GRATIS }); }
         const lib = url.protocol === 'https:' ? https : http;
         const req = lib.get(url, { timeout }, (res) => {
             let t = '';
@@ -35,37 +38,62 @@ function buscarPlanos(servidor, { timeout = 8000 } = {}) {
                 try {
                     const j = JSON.parse(t);
                     const lista = Array.isArray(j) ? j : j && j.planos;
-                    if (res.statusCode === 200 && Array.isArray(lista) && lista.length) return resolve({ ok: true, planos: lista });
+                    if (res.statusCode === 200 && Array.isArray(lista) && lista.length) return resolve({ ok: true, planos: lista, gratis: (j && j.gratis) || GRATIS });
                 } catch { /* cai na reserva */ }
-                resolve({ ok: false, planos: RESERVA });
+                resolve({ ok: false, planos: RESERVA, gratis: GRATIS });
             });
         });
         req.on('timeout', () => req.destroy());
-        req.on('error', () => resolve({ ok: false, planos: RESERVA }));
+        req.on('error', () => resolve({ ok: false, planos: RESERVA, gratis: GRATIS }));
     });
 }
 
 const reais = (n) => `R$ ${Number(n).toFixed(2).replace('.', ',')}`;
 
+const ALTURA = { 720: '720p', 1080: '1080p', 2160: '4K' };
+/* As linhas da tabela: o que cada degrau compra. Cada função lê o recurso de um plano. */
+const LINHAS = [
+    ['Vídeos por mês', (r) => String(r.videosMes || 'sem teto')],
+    ['Resolução', (r) => ALTURA[r.resolucao] || `${r.resolucao}p`],
+    ['Marca d\'água', (r) => (r.marcaDagua ? 'sim' : 'sem')],
+    ['Narração premium', (r) => (r.narracaoPremium ? '✓' : '—')],
+    ['Projetos do Clube', (r) => (r.clubeCompleto ? 'completos' : 'resumo')],
+    ['Scripts AE modelo', (r) => (r.scriptsAE ? '✓' : '—')],
+    ['Prioridade na cadeia', (r) => (r.prioridade ? '●'.repeat(r.prioridade) : '—')],
+    ['Subagentes', (r) => (r.subagentes ? String(r.subagentes) : '—')],
+];
+
 /**
- * As linhas da tela. `atual` é o id do plano da pessoa (ou null).
- * @param {{planos:object[], ok:boolean}} r
+ * A tabela comparativa, um plano por coluna. `atual` é o id do plano da pessoa.
+ * Cada coluna tem 13 caracteres; o plano da pessoa leva ● no título.
+ * @param {{planos:object[], gratis?:object, ok:boolean}} r
  * @param {{cores:object, atual?:string, site:string}} op
  */
-function desenhar({ planos, ok }, { cores: c, atual = null, site }) {
+function desenhar({ planos, gratis, ok }, { cores: c, atual = null, site }) {
+    const todos = [gratis || GRATIS, ...planos].filter((p) => p.recursos);
+    const L = 21, W = 13;
+    const ce = (t, n) => { t = String(t); const f = Math.max(0, n - t.length); return ' '.repeat(f >> 1) + t + ' '.repeat(f - (f >> 1)); };
+    const meu = (p) => (atual ? p.id === atual : p.id === 'free');
     const linhas = ['', c.white('  Planos do PrimoCode') + c.dim('  · por mês, cancele quando quiser'), ''];
-    for (const p of planos) {
-        const meu = atual && p.id === atual;
-        linhas.push('  ' + (meu ? c.ok('● ') : '  ') + c.brand(p.nome.padEnd(14)) + c.white(reais(p.preco).padStart(11))
-            + c.dim(' /mês') + (meu ? c.ok('  ← o seu') : ''));
-        linhas.push('      ' + c.muted((p.inclui || []).join(' · ')));
-        if (ok && !meu) linhas.push('      ' + (p.checkout ? c.dim('assinar: ') + c.brand(p.checkout) : c.dim('checkout em breve')));
+    linhas.push('  ' + ' '.repeat(L) + todos.map((p) => c.brand(ce((meu(p) ? '● ' : '') + p.nome.replace('Primo ', ''), W))).join(''));
+    linhas.push('  ' + ' '.repeat(L) + todos.map((p) => c.white(ce(p.preco ? reais(p.preco) : 'R$ 0', W))).join(''));
+    linhas.push(c.dim('  ' + '─'.repeat(L + W * todos.length)));
+    for (const [nome, f] of LINHAS) {
+        linhas.push('  ' + c.muted(nome.padEnd(L)) + todos.map((p) => c.white(ce(f(p.recursos), W))).join(''));
+    }
+    linhas.push('');
+    if (ok) {
+        for (const p of planos) {
+            if (atual && p.id === atual) continue;
+            linhas.push('  ' + c.dim('assinar ') + c.brand(p.nome.padEnd(13)) + (p.checkout ? c.brand(p.checkout) : c.dim('checkout em breve')));
+        }
         linhas.push('');
+    } else {
+        linhas.push(c.dim('  (sem resposta do servidor: valores de referência, sem link de compra)'), '');
     }
-    if (!ok) linhas.push(c.dim('  (sem resposta do servidor: preços de referência, sem link de compra)'));
     linhas.push(c.dim('  Também em ') + c.brand(`${site}/planos`) + c.dim(' · já assinou? ') + c.brand('/account') + c.dim(' atualiza.'));
     linhas.push('');
     return linhas;
 }
 
-module.exports = { buscarPlanos, desenhar, RESERVA, reais };
+module.exports = { buscarPlanos, desenhar, RESERVA, GRATIS, reais };