primocode 11.0.0 → 11.2.0

package/lib/app-server/servidor.js

@@ -0,0 +1,685 @@
+// App-server local: JSON-RPC 2.0 que expõe o motor às telas (docs/estrutura.md, seção 3).
+// Dois transportes: stdio (uma mensagem JSON por linha) e WebSocket em 127.0.0.1
+// com token de sessão. Com `rede: true` (primocode server --ws --rede) escuta na rede local e aceita
+// também tokens de PAREAMENTO (um por celular, revogável, com poderes limitados). Node puro, sem dependência.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const crypto = require('crypto');
+const P = require('./protocolo');
+const WS = require('./websocket');
+const { criarPareamentos } = require('./pareamento');
+const { criarPortao } = require('../motor/aprovacao');
+
+const { ERRO, erro } = P;
+const MAX_LEITURA = 1024 * 1024;
+const BLOQUEADOS = /(^|[\\/])(\.ssh|\.aws|\.gnupg|\.env[^\\/]*|app-server\.json|pareamentos\.json|config\.json)$/;
+const CAMPOS_CONFIG = ['effort', 'model', 'mode', 'permissoes', 'userName', 'mascot', 'reacoes', 'theme', 'autoApply', 'piloto', 'grupo', 'inicioFeito'];
+const PILOTO_MS = Number(process.env.PRIMOCODE_PILOTO_MS) || 15 * 60000;
+
+const RAIZ_TELA = path.join(__dirname, '..', '..', 'app', 'renderer');
+const TIPOS_ESTATICOS = {
+    '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.mjs': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8', '.svg': 'image/svg+xml', '.png': 'image/png', '.json': 'application/json', '.ico': 'image/x-icon', '.woff2': 'font/woff2',
+};
+
+/* O que um celular pareado pode pedir ao motor: acompanhar, aprovar, mandar pedido, ver entrega e histórico.
+   Fica de fora: arquivos, configuração, projetos e agentes (escrita), terminal, abrir coisas no computador. */
+const PAREADO_PODE = new Set([
+    'thread/start', 'thread/list', 'thread/resume', 'thread/rename', 'turn/start', 'turn/interrupt', 'turn/queue',
+    'approval/respond', 'question/respond', 'notice/list', 'notice/read', 'studio/history', 'project/list', 'agent/list', 'config/read',
+    'account/status',   // só ver se há conta; entrar, sair e o login pelo navegador são do computador
+]);
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+
+const texto = (v) => (typeof v === 'string' ? v : '');
+
+/* Abre um arquivo ou pasta no programa do sistema. Só caminho já validado chega aqui; sem shell. */
+function abrirNoSistema(abs) {
+    // Teste de tela: PRIMOCODE_ABRIR_LOG troca o programa do sistema por uma linha no arquivo.
+    if (process.env.PRIMOCODE_ABRIR_LOG) { try { fs.appendFileSync(process.env.PRIMOCODE_ABRIR_LOG, `${abs}\n`); } catch { /* sem log */ } return; }
+    const { spawn } = require('child_process');
+    const [cmd, args] = process.platform === 'darwin' ? ['open', [abs]] : process.platform === 'win32' ? ['explorer.exe', [abs]] : ['xdg-open', [abs]];
+    try { const f = spawn(cmd, args, { detached: true, stdio: 'ignore' }); f.on('error', () => {}); f.unref(); } catch { /* sem programa para abrir */ }
+}
+const MIDIAS = { '.mp4': 'video/mp4', '.webm': 'video/webm', '.mov': 'video/quicktime', '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' };
+
+function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false, enderecos, conta: contaOp = {} } = {}) {
+    const cfg = require('../config/config');
+    const m = motor || require('../motor');
+    const base = casa || cfg.CONFIG_DIR;
+    const pastaThreads = path.join(base, 'threads');
+    const arquivoInfo = path.join(base, 'app-server.json');
+    const token = crypto.randomBytes(24).toString('hex');
+    const Pareamentos = criarPareamentos({ arquivo: path.join(base, 'pareamentos.json') });
+    let modoRede = !!rede;
+    const permitidas = (raizes || [os.homedir()]).map((r) => path.resolve(r));
+
+    const dirAgentes = path.join(base, 'agentes');
+    const arqAvisos = path.join(base, 'avisos.json');
+    const Conta = require('../config/conta');
+    const Agentes = require('../agentes-pessoais');
+    const Avisos = require('../avisos');
+    const Projetos = require('../projetos-meta');
+    const Marca = require('../plugin/marca-kit');
+    const Piloto = require('../piloto');
+    const Voz = voz || require('../motor/voz').criarVoz({ pasta: path.join(base, 'voz') });
+    let loginNavegador = null;
+    const statusConta = () => {
+        const a = Conta.atual();
+        return a ? { logado: true, email: a.email, plano: a.plano, planoAte: a.planoAte, pro: !!a.pro }
+            : { logado: false, email: null, plano: null, planoAte: null, pro: false };
+    };
+    let timerPiloto = null;
+    let pilotoRodando = false;
+
+    const pastaTela = telaDir === undefined ? RAIZ_TELA : telaDir;
+    const conexoes = new Set();
+    const threads = new Map();      // id → { dados, dono, assinantes, rodando }: dono = quem mandou por último; assinantes = todos que abriram a conversa (recebem os eventos)
+    let http_ = null;
+    let porta = null;
+
+    /* ── Conversas: um JSON por thread em ~/.primocode/threads ── */
+    const arquivoDe = (id) => path.join(pastaThreads, `${id}.json`);
+    function salvar(t) {
+        try {
+            fs.mkdirSync(pastaThreads, { recursive: true, mode: 0o700 });
+            fs.writeFileSync(arquivoDe(t.dados.id), JSON.stringify(t.dados), { mode: 0o600 });
+        } catch { /* falhar em guardar não derruba o turno */ }
+    }
+    function carregar(id) {
+        if (!/^[\w-]{1,64}$/.test(String(id || ''))) throw erro(ERRO.PARAMS, 'thread inválida');
+        if (threads.has(id)) return threads.get(id);
+        let dados;
+        try { dados = JSON.parse(fs.readFileSync(arquivoDe(id), 'utf8')); } catch { throw erro(ERRO.NAO_ACHEI, `não achei a conversa ${id}`); }
+        const t = { dados, dono: null, assinantes: new Set(), rodando: false };
+        threads.set(id, t);
+        return t;
+    }
+    const resumoDe = (d) => ({
+        id: d.id, titulo: d.titulo, criada: d.criada, atualizada: d.atualizada,
+        projeto: d.projeto || null, arquivada: !!d.arquivada, mensagens: (d.historico || []).length,
+    });
+    function listarDoDisco() {
+        let nomes = [];
+        try { nomes = fs.readdirSync(pastaThreads).filter((n) => n.endsWith('.json')); } catch { /* ainda não há */ }
+        const out = [];
+        for (const n of nomes) {
+            const id = n.slice(0, -5);
+            try { out.push(resumoDe((threads.get(id) || carregar(id)).dados)); } catch { /* arquivo quebrado: pula */ }
+        }
+        return out.sort((a, b) => (b.atualizada || 0) - (a.atualizada || 0));
+    }
+
+    /* ── Avisos: gravam em avisos.json e chegam a todas as telas abertas ── */
+    const difundir = (metodo, params) => { for (const c of conexoes) { try { c.enviar(P.notificacao(metodo, params)); } catch { /* conexão caiu */ } } };
+    const contagemAvisos = () => Avisos.contagem(Avisos.ler({ arquivo: arqAvisos }));
+    function novoAviso(dados) {
+        const av = Avisos.criar(dados, { arquivo: arqAvisos });
+        difundir('notice/created', { ...av, ...contagemAvisos(), estado: av.nivel === 'erro' ? 'erro' : 'ok', aviso: av });
+        return av;
+    }
+    const pilotoLigado = () => cfg.loadConfig().piloto === true;
+    /* O emissor de um turno: o que o motor emite vai à tela dona da conversa. Com o piloto ligado
+       (ou num turno do piloto) a aprovação vira aviso pendente, em vez de cartão no compositor;
+       todo notice/created do motor é gravado em avisos.json. */
+    function emissorDe(t) {
+        return (ev) => {
+            if (ev.evento === 'notice/created') {
+                novoAviso({ tipo: 'aviso', nivel: ev.estado === 'erro' ? 'erro' : 'ok', texto: ev.texto || (ev.erro && ev.erro.message) || '', thread: t.dados.id, agente: t.agente });
+                return;
+            }
+            if (ev.evento === 'approval/requested' && (t.agente || pilotoLigado())) {
+                novoAviso({ tipo: 'aprovacao', texto: ev.texto, thread: t.dados.id, aprovacao: ev.id, agente: t.agente });
+                return;
+            }
+            // Desktop e celular acompanham o MESMO turno: todo assinante da conversa (quem fez thread/resume ou mandou) recebe.
+            const msg = P.notificacao(ev.evento, { thread: t.dados.id, ...ev });
+            const para = new Set(t.assinantes);
+            if (t.dono) para.add(t.dono);
+            for (const c of para) { try { c.enviar(msg); } catch { /* conexão caiu */ } }
+        };
+    }
+
+    /* ── Caminhos: só dentro das raízes permitidas, sem segredos ── */
+    function caminhoSeguro(p) {
+        const abs = path.resolve(texto(p));
+        if (!texto(p)) throw erro(ERRO.PARAMS, 'falta path');
+        const dentro = permitidas.some((r) => abs === r || abs.startsWith(r + path.sep));
+        if (!dentro) throw erro(ERRO.NEGADO, 'caminho fora das pastas permitidas');
+        if (BLOQUEADOS.test(abs)) throw erro(ERRO.NEGADO, 'arquivo protegido');
+        return abs;
+    }
+
+    /* ── Métodos. Cada um: (params, conn) → resultado, ou lança erro(). ── */
+    const metodos = {
+        'thread/start'(p, conn) {
+            const agora = Date.now();
+            const dados = {
+                id: crypto.randomBytes(8).toString('hex'),
+                titulo: texto(p.titulo) || 'Nova conversa',
+                criada: agora, atualizada: agora,
+                projeto: texto(p.projeto) || null, arquivada: false,
+                historico: [],
+            };
+            const t = { dados, dono: conn, assinantes: new Set(conn ? [conn] : []), rodando: false };
+            threads.set(dados.id, t);
+            salvar(t);
+            return resumoDe(dados);
+        },
+        'thread/list'(p) {
+            const todas = listarDoDisco();
+            return { threads: p.arquivadas ? todas : todas.filter((x) => !x.arquivada) };
+        },
+        'thread/resume'(p, conn) {
+            const t = carregar(p.thread);
+            if (conn) { t.assinantes.add(conn); if (!t.rodando) t.dono = conn; }
+            return { ...resumoDe(t.dados), mensagens: t.dados.historico, rodando: t.rodando };
+        },
+        'thread/rename'(p) {
+            const t = carregar(p.thread);
+            const titulo = texto(p.titulo).trim();
+            if (!titulo) throw erro(ERRO.PARAMS, 'falta titulo');
+            t.dados.titulo = titulo.slice(0, 120);
+            salvar(t);
+            return resumoDe(t.dados);
+        },
+        'thread/archive'(p) {
+            const t = carregar(p.thread);
+            t.dados.arquivada = p.arquivar !== false;
+            salvar(t);
+            return resumoDe(t.dados);
+        },
+
+        async 'turn/start'(p, conn) {
+            const pedido = texto(p.texto).trim();
+            if (!pedido) throw erro(ERRO.PARAMS, 'falta texto');
+            if (conn && conn.pareado) {
+                // O celular não lê arquivos nem escolhe pasta: só usa um projeto já registrado, sem menções nem anexos.
+                if (p.projeto && !Projetos.listar().some((x) => x.caminho === p.projeto)) throw erro(ERRO.NEGADO, 'projeto desconhecido');
+                p = { ...p, mencoes: undefined, anexos: undefined };
+            }
+            let t;
+            if (p.thread) t = carregar(p.thread);
+            else { const novo = metodos['thread/start']({ projeto: p.projeto }, conn); t = threads.get(novo.id); }
+            if (t.rodando) throw erro(ERRO.OCUPADO, 'já há um turno rodando nesta conversa; use turn/queue');
+            if (pilotoRodando) throw erro(ERRO.OCUPADO, 'o piloto automático está trabalhando; espere ou desligue-o');
+            t.dono = conn;
+            if (conn) t.assinantes.add(conn);
+            t.rodando = true;
+            const dados = t.dados;
+            const c = cfg.loadConfig();
+            const projeto = texto(p.projeto) || dados.projeto || undefined;
+            if (projeto) dados.projeto = projeto;
+            if (dados.titulo === 'Nova conversa' && !dados.historico.length) dados.titulo = pedido.replace(/\s+/g, ' ').slice(0, 60);
+
+            // Menções (@arquivo) e anexos entram como instrução: não viram a fala da pessoa.
+            const partes = [];
+            if (Array.isArray(p.mencoes) && p.mencoes.length && projeto) {
+                const { arquivos } = require('../mencoes').mencoes(p.mencoes.map((x) => `@"${x}"`).join(' '), projeto);
+                for (const a of arquivos) {
+                    try { partes.push(`Arquivo mencionado ${a.rel}:\n${fs.readFileSync(a.abs, 'utf8')}`); } catch { /* sumiu */ }
+                }
+            }
+            if (Array.isArray(p.anexos) && p.anexos.length) partes.push(`Anexos do pedido: ${p.anexos.map(String).join(', ')}`);
+            if (p.tipo) partes.push(require('../plugin/estudio/criar').instrucaoDoTipo(texto(p.tipo)));
+            // @agente chama na hora; os ligados vão de cardápio (a IA escolhe, não a regex).
+            const ag = Agentes.instrucao(pedido, p.agentes, { dir: dirAgentes });
+            if (ag.texto) partes.push(ag.texto);
+
+            const emitir = emissorDe(t);
+            t.portao = criarPortao({ emitir });
+            const memoria = require('../session/memoria-conversa');
+            const opts = {
+                texto: pedido, emitir, portao: t.portao,
+                autorizar: t.portao.autorizar, perguntar: t.portao.perguntar,
+                server: c.server, model: c.model, effort: texto(p.esforco) || c.effort, token: c.token,
+                history: memoria.paraEnviar(memoria.nova(), dados.historico),
+                projectDir: projeto, projectName: projeto ? path.basename(projeto) : undefined,
+                permissoes: c.permissoes, semTerminal: false,
+                instrucao: partes.join('\n\n'),
+            };
+            // O turno roda solto: o cliente recebe turn/* por notificação, não pela resposta.
+            Promise.resolve().then(() => m.iniciarTurno(opts)).then((r) => {
+                if (r && r.userMessage && !r.parado) {
+                    dados.historico.push(r.userMessage);
+                    if (r.assistantMessage) dados.historico.push(r.assistantMessage);
+                }
+            }).catch((e) => {
+                // O motor já emite turn/interrupted com o erro; aqui só garante que a tela saiba.
+                emitir({ evento: 'notice/created', estado: 'erro', texto: e && e.message });
+            }).finally(() => {
+                t.rodando = false;
+                if (t.portao) t.portao.cancelar();
+                dados.atualizada = Date.now();
+                salvar(t);
+            });
+            return { thread: dados.id };
+        },
+        'turn/interrupt'(p) {
+            const t = p.thread ? carregar(p.thread) : null;
+            if (t && !t.rodando) return { interrompido: false };
+            // Quem espera uma resposta é solto como NÃO antes de parar o turno.
+            for (const x of t ? [t] : threads.values()) if (x.portao) x.portao.cancelar();
+            m.interromper();
+            return { interrompido: true };
+        },
+        'turn/queue'(p) {
+            const pedido = texto(p.texto).trim();
+            if (!pedido) throw erro(ERRO.PARAMS, 'falta texto');
+            return { enfileirado: !!m.mandarDuranteATarefa(pedido) };
+        },
+
+        // Respostas ao que o motor pediu (approval/requested, question/requested).
+        'approval/respond'(p) {
+            const id = texto(p.id);
+            if (!id) throw erro(ERRO.PARAMS, 'falta id');
+            if (!p.aceitar && !p.recusar && !p.sempre) throw erro(ERRO.PARAMS, 'diga aceitar, recusar ou sempre');
+            for (const t of p.thread ? [carregar(p.thread)] : threads.values()) {
+                if (t.portao && t.portao.responderAprovacao(id, p)) {
+                    Avisos.resolverAprovacao(id, p.recusar ? 'nao' : p.sempre ? 'sessao' : 'agora', { arquivo: arqAvisos });
+                    difundir('notice/changed', contagemAvisos());
+                    return { ok: true, ...contagemAvisos() };
+                }
+            }
+            throw erro(ERRO.NAO_ACHEI, `não há aprovação pendente ${id}`);
+        },
+        'question/respond'(p) {
+            const id = texto(p.id);
+            if (!id) throw erro(ERRO.PARAMS, 'falta id');
+            if (!Array.isArray(p.respostas)) throw erro(ERRO.PARAMS, 'falta respostas (lista)');
+            for (const t of p.thread ? [carregar(p.thread)] : threads.values()) {
+                if (t.portao && t.portao.responderPergunta(id, p.respostas)) return { ok: true };
+            }
+            throw erro(ERRO.NAO_ACHEI, `não há pergunta pendente ${id}`);
+        },
+
+        /* ── Projetos (pasta + ícone + cor + descrição) ── */
+        'project/list'(p) { return { projetos: Projetos.listar({ arquivados: !!p.arquivados }) }; },
+        'project/create'(p) {
+            try { const r = Projetos.criar(p); difundir('project/changed', { id: r.id }); return r; } catch (e) { throw erro(ERRO.PARAMS, e.message); }
+        },
+        'project/update'(p) {
+            try { const r = Projetos.atualizar(p.id, p); difundir('project/changed', { id: r.id }); return r; } catch (e) { throw erro(/não achei/.test(e.message) ? ERRO.NAO_ACHEI : ERRO.PARAMS, e.message); }
+        },
+        'project/delete'(p) {
+            try { const r = Projetos.arquivar(p.id); difundir('project/changed', { id: r.id }); return r; } catch (e) { throw erro(ERRO.NAO_ACHEI, e.message); }
+        },
+
+        /* ── Kit da marca (lib/marca-kit.js) ── */
+        'brand/read'(p) {
+            const vista = (k) => ({
+                nome: k.nome, cores: k.cores || {}, fontes: k.fontes || {}, tom: k.tom || '', slogan: k.slogan || '',
+                site: k.site || '', redes: k.redes || '', temLogo: !!k.logo, contraste: Marca.validarContraste(k.cores || {}),
+            });
+            const ativa = (() => { try { return fs.readFileSync(path.join(Marca.raiz(), '.ativa'), 'utf8').trim() || null; } catch { return null; } })();
+            if (p.nome) { const k = Marca.ler(p.nome); if (!k) throw erro(ERRO.NAO_ACHEI, `não há kit "${p.nome}"`); return { kit: vista(k), ativa }; }
+            return { kits: Marca.listar().map(vista), ativa };
+        },
+        'brand/write'(p) {
+            const nome = texto(p.nome).trim();
+            if (!nome) throw erro(ERRO.PARAMS, 'falta nome');
+            if (p.apagar) { const r = Marca.apagar(nome); if (!r.ok) throw erro(ERRO.NAO_ACHEI, r.error); return { apagado: true }; }
+            const atual = Marca.ler(nome) || {};
+            const m = { ...atual, nome };
+            for (const k of ['tom', 'slogan', 'site', 'redes']) if (k in p) m[k] = texto(p[k]).slice(0, 300);
+            if (p.cores && typeof p.cores === 'object') m.cores = { ...(atual.cores || {}), ...Object.fromEntries(Object.entries(p.cores).map(([k, v]) => [k, Marca.normHex(v) || v])) };
+            if (p.fontes && typeof p.fontes === 'object') m.fontes = { ...(atual.fontes || {}), titulo: texto(p.fontes.titulo || (atual.fontes || {}).titulo), texto: texto(p.fontes.texto || (atual.fontes || {}).texto) };
+            const r = Marca.salvar(m);
+            if (!r.ok) throw erro(ERRO.PARAMS, r.error);
+            if (p.ativar) Marca.usar(nome);
+            return metodos['brand/read']({ nome });
+        },
+
+        /* ── Agentes ── */
+        'agent/list'() { return { agentes: Agentes.listar({ dir: dirAgentes }), piloto: pilotoEstado() }; },
+        'agent/create'(p) { return agenteOp(() => Agentes.criar(p, { dir: dirAgentes })); },
+        'agent/update'(p) { return agenteOp(() => Agentes.atualizar(p.nome, p, { dir: dirAgentes })); },
+        'agent/delete'(p) { return agenteOp(() => Agentes.apagar(p.nome, { dir: dirAgentes })); },
+        'agent/toggle'(p) { return agenteOp(() => Agentes.alternar(p.nome, typeof p.ligado === 'boolean' ? p.ligado : undefined, { dir: dirAgentes })); },
+
+        /* ── Piloto automático e avisos ── */
+        'autopilot/set'(p) {
+            const mudar = {};
+            if ('ligado' in p) mudar.piloto = p.ligado === true;
+            if ('grupo' in p) mudar.grupo = p.grupo === true;
+            if (!Object.keys(mudar).length) throw erro(ERRO.PARAMS, 'diga ligado e/ou grupo');
+            cfg.saveConfig(mudar);
+            agendarPiloto();
+            const r = pilotoEstado();
+            difundir('agent/changed', { piloto: r });
+            return r;
+        },
+        async 'autopilot/run'() {
+            if (pilotoRodando) throw erro(ERRO.OCUPADO, 'o piloto já está num ciclo');
+            return rodarCiclo();
+        },
+        'notice/list'() { return Avisos.listar({ arquivo: arqAvisos }); },
+        'notice/read'(p) {
+            if (!p.id && !p.todos) throw erro(ERRO.PARAMS, 'diga id ou todos');
+            try { const r = Avisos.marcarLido({ id: p.id, todos: !!p.todos }, { arquivo: arqAvisos }); difundir('notice/changed', contagemAvisos()); return r; } catch (e) { throw erro(ERRO.NAO_ACHEI, e.message); }
+        },
+
+        /* ── Pareamento do celular (só o computador, nunca um celular pareado) ── */
+        'pairing/info'() { return { rede: modoRede, porta, enderecos: modoRede ? enderecosLocais() : [], pareamentos: Pareamentos.listar() }; },
+        'pairing/create'(p) {
+            if (!modoRede) throw erro(ERRO.NEGADO, 'o servidor está só em 127.0.0.1. Suba com `primocode server --ws --rede` para parear um celular');
+            const ips = enderecosLocais();
+            if (!ips.length) throw erro(ERRO.NEGADO, 'não achei um endereço de rede local neste computador');
+            const r = Pareamentos.criar(p.nome);
+            const urls = ips.map((ip) => `ws://${ip}:${porta}`);
+            const codigo = `${urls[0]}/?token=${r.token}`;
+            const q = require('../qr').gerarQR(codigo, { ecc: 'M' });
+            // A tela desenha o QR com estas linhas ('1' = módulo escuro); nenhum HTML vem do motor.
+            return { ...r, urls, codigo, qr: { tamanho: q.tamanho, linhas: q.modulos.map((l) => l.map((b) => (b ? '1' : '0')).join('')) } };
+        },
+        'pairing/list'() { return { pareamentos: Pareamentos.listar() }; },
+        'pairing/revoke'(p) {
+            const id = texto(p.id);
+            if (!Pareamentos.revogar(id)) throw erro(ERRO.NAO_ACHEI, 'não existe esse pareamento');
+            for (const c of [...conexoes]) if (c.pareado && c.pareado.id === id && c.fechar) c.fechar();
+            return { revogado: id, pareamentos: Pareamentos.listar() };
+        },
+
+        'config/read'(p, conn) {
+            const c = cfg.loadConfig();
+            const out = {};
+            for (const k of CAMPOS_CONFIG) out[k] = c[k];
+            out.servidor = c.server;
+            out.temToken = !!c.token;
+            out.projetoAtual = c.currentProject;
+            if (conn && conn.pareado) out.pareado = true;
+            return out;
+        },
+        'config/write'(p) {
+            const mudar = {};
+            for (const k of CAMPOS_CONFIG) if (k in p) mudar[k] = p[k];
+            if (!Object.keys(mudar).length) throw erro(ERRO.PARAMS, `nada para gravar (campos: ${CAMPOS_CONFIG.join(', ')})`);
+            cfg.saveConfig(mudar);
+            return metodos['config/read']();
+        },
+
+        /* ── Conta (login do app): só as funções de lib/config/conta.js. Nunca devolve token. ── */
+        'account/status'() { return statusConta(); },
+        async 'account/login'(p) {
+            const r = await Conta.entrar({ email: texto(p.email), senha: texto(p.senha) }, { buscar: contaOp.buscar });
+            if (!r.ok) return { ok: false, error: r.error };
+            difundir('account/changed', statusConta());
+            return { ok: true, ...statusConta() };
+        },
+        async 'account/login-browser'() {
+            if (loginNavegador) return { ok: true, emAndamento: true, url: loginNavegador.url };
+            let urlPronta;
+            const aUrl = new Promise((res) => { urlPronta = res; });
+            const estado = { url: null };
+            loginNavegador = estado;
+            Conta.entrarPeloNavegador({ abrir: contaOp.abrir, buscar: contaOp.buscar, aviso: (u) => { estado.url = u; urlPronta(u); } })
+                .then((r) => difundir('account/changed', { ...statusConta(), ...(r && r.ok ? {} : { erro: (r && r.error) || 'o login não concluiu.' }) }))
+                .catch((e) => difundir('account/changed', { ...statusConta(), erro: e.message }))
+                .finally(() => { loginNavegador = null; urlPronta(null); });
+            const url = await aUrl;
+            return { ok: true, iniciado: true, url };
+        },
+        'account/logout'() {
+            Conta.sair();
+            difundir('account/changed', statusConta());
+            return { ok: true, ...statusConta() };
+        },
+
+        /* ── Voz (6.9): provedor trocável em lib/motor/voz.js; só gera arquivo, nunca toca ── */
+        async 'voice/start'(p) { return Voz.iniciar({ texto: p && p.texto }); },
+        'voice/stop'() { return Voz.parar(); },
+
+        /* ── Studio: histórico do que o Estúdio gerou e abrir no sistema ── */
+        'studio/history'(p) {
+            const r = require('../plugin/estudio/historico').historico({ busca: texto(p.busca), limite: p.limite });
+            return { ...r, tipos: Object.keys(require('../plugin/estudio/criar').QUADRADOS) };
+        },
+        'studio/open'(p) {
+            let abs = caminhoSeguro(p.path);
+            if (!fs.existsSync(abs)) throw erro(ERRO.NAO_ACHEI, 'não achei o arquivo');
+            if (p.pasta && !fs.statSync(abs).isDirectory()) abs = path.dirname(abs);
+            (abrir || abrirNoSistema)(abs);
+            return { aberto: abs };
+        },
+
+        'fs/list'(p) {
+            const abs = caminhoSeguro(p.path);
+            let itens;
+            try { itens = fs.readdirSync(abs, { withFileTypes: true }); } catch (e) { throw erro(ERRO.NAO_ACHEI, `não consegui listar: ${e.code || e.message}`); }
+            return {
+                path: abs,
+                itens: itens.filter((d) => !BLOQUEADOS.test(path.join(abs, d.name)))
+                    .map((d) => ({ nome: d.name, tipo: d.isDirectory() ? 'pasta' : 'arquivo' }))
+                    .sort((a, b) => (a.tipo === b.tipo ? a.nome.localeCompare(b.nome) : a.tipo === 'pasta' ? -1 : 1)),
+            };
+        },
+        'fs/read'(p) {
+            const abs = caminhoSeguro(p.path);
+            let st;
+            try { st = fs.statSync(abs); } catch (e) { throw erro(ERRO.NAO_ACHEI, `não achei: ${e.code || e.message}`); }
+            if (!st.isFile()) throw erro(ERRO.PARAMS, 'não é arquivo');
+            if (st.size > MAX_LEITURA) throw erro(ERRO.PARAMS, `grande demais (limite ${MAX_LEITURA / 1024} KB)`);
+            return { path: abs, bytes: st.size, conteudo: fs.readFileSync(abs, 'utf8') };
+        },
+    };
+
+
+    /* ── Agentes e piloto: helpers ── */
+    function agenteOp(fn) {
+        try { const r = fn(); difundir('agent/changed', { nome: r.nome }); return r; } catch (e) { throw erro(/não achei/.test(e.message) ? ERRO.NAO_ACHEI : ERRO.PARAMS, e.message); }
+    }
+    const pilotoEstado = () => { const c = cfg.loadConfig(); return { ligado: c.piloto === true, grupo: c.grupo === true, rodando: pilotoRodando }; };
+    const algumRodando = () => [...threads.values()].some((x) => x.rodando);
+
+    /* Um agente do piloto roda como uma conversa própria, com o ofício na frente. Aprovações viram aviso. */
+    async function executarAgente(agente, pedido) {
+        const c = cfg.loadConfig();
+        const dados = { id: `piloto-${agente.nome}-${Date.now().toString(36)}`, titulo: `@${agente.nome} (piloto)`, criada: Date.now(), atualizada: Date.now(), projeto: null, arquivada: true, historico: [] };
+        const t = { dados, dono: null, assinantes: new Set(), rodando: true, agente: agente.nome };
+        threads.set(dados.id, t);
+        const emitir = emissorDe(t);
+        t.portao = criarPortao({ emitir });
+        const proj = agente.onde && agente.onde !== 'fora' ? Projetos.pastaDe(agente.onde) : null;
+        try {
+            const r = await m.iniciarTurno({
+                texto: pedido, emitir, portao: t.portao, autorizar: t.portao.autorizar, perguntar: t.portao.perguntar,
+                server: c.server, model: c.model, effort: c.effort, token: c.token, history: [],
+                projectDir: proj || undefined, projectName: proj ? path.basename(proj) : undefined,
+                permissoes: 'perguntar', semTerminal: false,
+                instrucao: `Seu ofício:\n${agente.oficio}`,
+            });
+            return r && r.assistantMessage ? textoDe(r.assistantMessage.content) : '';
+        } finally {
+            t.rodando = false;
+            if (t.portao) t.portao.cancelar();
+            threads.delete(dados.id);
+        }
+    }
+    const textoDe = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => (x && x.text) || '').join('') : '');
+
+    async function rodarCiclo() {
+        pilotoRodando = true;
+        difundir('agent/changed', { piloto: pilotoEstado() });
+        try {
+            const c = cfg.loadConfig();
+            const r = await Piloto.ciclo({
+                agentes: Agentes.listar({ dir: dirAgentes }), grupo: c.grupo === true,
+                executar: executarAgente, ocupado: () => [...threads.values()].some((x) => x.rodando && !x.agente),
+                freio: opcoesPiloto.freio,
+            });
+            for (const e of r.executados) novoAviso({ tipo: 'aviso', nivel: e.ok ? 'ok' : 'erro', texto: `@${e.agente}: ${e.resumo || (e.ok ? 'terminou' : 'falhou')}`, agente: e.agente });
+            return r;
+        } finally { pilotoRodando = false; difundir('agent/changed', { piloto: pilotoEstado() }); }
+    }
+    const opcoesPiloto = { freio: undefined };
+    function agendarPiloto() {
+        if (timerPiloto) { clearInterval(timerPiloto); timerPiloto = null; }
+        if (!pilotoLigado()) return;
+        timerPiloto = setInterval(() => { if (!pilotoRodando && !algumRodando()) rodarCiclo().catch(() => {}); }, PILOTO_MS);
+        timerPiloto.unref();
+    }
+    agendarPiloto();
+
+    /* ── Despacho: uma mensagem de uma conexão ── */
+    async function tratar(linha, conn) {
+        const r = P.interpretar(linha);
+        if (r.vazio || r.resposta) return;
+        if (r.erro) { conn.enviar(r.erro); return; }
+        const { msg } = r;
+        const temId = 'id' in msg;
+        const fn = Object.prototype.hasOwnProperty.call(metodos, msg.method) ? metodos[msg.method] : null;
+        if (fn && conn.pareado && !PAREADO_PODE.has(msg.method)) {
+            if (temId) conn.enviar(P.respostaErro(msg.id, ERRO.NEGADO, `um celular pareado não pode usar ${msg.method}`));
+            return;
+        }
+        if (fn && conn.pareado) Pareamentos.marcarUso(conn.pareado.id);
+        if (!fn) { if (temId) conn.enviar(P.respostaErro(msg.id, ERRO.METODO, `método não existe: ${msg.method}`)); return; }
+        try {
+            const res = await fn(msg.params || {}, conn);
+            if (temId) conn.enviar(P.resposta(msg.id, res));
+        } catch (e) {
+            if (!temId) return;
+            if (e && e.codigo) conn.enviar(P.respostaErro(msg.id, e.codigo, e.message, e.data));
+            else conn.enviar(P.respostaErro(msg.id, ERRO.INTERNO, e && e.message));
+        }
+    }
+
+    function soltar(conn) {
+        conexoes.delete(conn);
+        for (const t of threads.values()) { if (t.dono === conn) t.dono = null; t.assinantes.delete(conn); }
+    }
+
+    /* ── Transporte stdio ── */
+    function stdio(entrada = process.stdin, saida = process.stdout) {
+        const conn = { enviar: (obj) => { try { saida.write(P.serializar(obj)); } catch { /* pipe fechou */ } } };
+        conexoes.add(conn);
+        const corta = P.cortador();
+        entrada.setEncoding && entrada.setEncoding('utf8');
+        entrada.on('data', (d) => { for (const l of corta.push(d)) tratar(l, conn); });
+        entrada.on('end', () => { const s = corta.sobra(); if (s) tratar(s, conn); soltar(conn); });
+        return conn;
+    }
+
+    /* ── Transporte WebSocket: token na URL (?token=) ou em Authorization: Bearer ──
+       O token de sessão só vale vindo do próprio computador; da rede só entra token de pareamento. */
+    const iguais = (a, b) => { const x = Buffer.from(a); const y = Buffer.from(b); return x.length === y.length && crypto.timingSafeEqual(x, y); };
+    function autenticar(req) {
+        let dado = '';
+        try { dado = new URL(req.url, 'http://127.0.0.1').searchParams.get('token') || ''; } catch { /* url torta */ }
+        const auth = String(req.headers.authorization || '');
+        if (!dado && /^Bearer /i.test(auth)) dado = auth.slice(7).trim();
+        if (!dado) return null;
+        if (iguais(dado, token)) return LOOPBACK.has(req.socket.remoteAddress) ? { tipo: 'mestre' } : null;
+        const r = Pareamentos.validar(dado);
+        return r ? { tipo: 'pareado', pareado: r } : null;
+    }
+    const tokenBate = (req) => !!autenticar(req);
+    function enderecosLocais() {
+        if (enderecos) return enderecos();   // teste: endereços de mentira
+        const out = [];
+        for (const lista of Object.values(os.networkInterfaces())) for (const i of lista || []) if (i.family === 'IPv4' && !i.internal) out.push(i.address);
+        return out;
+    }
+    /* Anti-rebind: no padrão só 127.0.0.1/localhost; com --rede também o IP (literal) de uma interface do computador. Nome de host nunca. */
+    function hostPermitido(cabecalho) {
+        const host = String(cabecalho || '').replace(/:\d+$/, '');
+        if (host === '127.0.0.1' || host === 'localhost') return true;
+        return modoRede && /^\d{1,3}(\.\d{1,3}){3}$/.test(host) && enderecosLocais().includes(host);
+    }
+
+    /* GET / e arquivos de app/renderer: só 127.0.0.1 (Host conferido contra rebind). O token
+       continua exigido no WebSocket; a página só entrega o HTML e o JS. */
+    function estatico(req, res) {
+        const nega = (c, m) => { res.writeHead(c, { 'Content-Type': 'text/plain; charset=utf-8' }); res.end(m); };
+        if (!hostPermitido(req.headers.host)) return nega(403, 'host não permitido');
+        if (req.method !== 'GET' && req.method !== 'HEAD') return nega(426, 'use WebSocket');
+        if (/^\/midia(\?|$)/.test(req.url)) return midia(req, res, nega);
+        // O app do celular pergunta se o token ainda vale (revogado?). Só diz sim ou não ao dono do token; CORS aberto porque a página do celular é de outra origem.
+        if (/^\/pareamento\/valido(\?|$)/.test(req.url)) {
+            const q = autenticar(req);
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': '*' });
+            return res.end(JSON.stringify({ valido: !!(q && q.tipo === 'pareado') }));
+        }
+        if (!pastaTela) return nega(426, 'use WebSocket');
+        let rel;
+        try { rel = decodeURIComponent(new URL(req.url, 'http://127.0.0.1').pathname); } catch { return nega(400, 'url torta'); }
+        if (rel === '/') rel = '/index.html';
+        const abs = path.join(pastaTela, rel);
+        if (abs !== pastaTela && !abs.startsWith(pastaTela + path.sep)) return nega(403, 'fora da pasta');
+        fs.readFile(abs, (e, dados) => {
+            if (e) return nega(404, 'não achei');
+            res.writeHead(200, {
+                'Content-Type': TIPOS_ESTATICOS[path.extname(abs)] || 'application/octet-stream',
+                'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer',
+            });
+            res.end(req.method === 'HEAD' ? undefined : dados);
+        });
+    }
+
+    /* GET /midia?path=…&token=…: a prévia do que o Estúdio gerou (vídeo, PDF, imagem). Exige o token,
+       só serve dentro das raízes permitidas e só as extensões de mídia; vídeo aceita Range. */
+    function midia(req, res, nega) {
+        if (!tokenBate(req)) return nega(401, 'sem token');
+        let abs;
+        try { abs = caminhoSeguro(new URL(req.url, 'http://127.0.0.1').searchParams.get('path')); } catch { return nega(403, 'caminho não permitido'); }
+        const tipo = MIDIAS[path.extname(abs).toLowerCase()];
+        if (!tipo) return nega(403, 'tipo não permitido');
+        let st; try { st = fs.statSync(abs); if (!st.isFile()) throw new Error('x'); } catch { return nega(404, 'não achei'); }
+        const cab = { 'Content-Type': tipo, 'Accept-Ranges': 'bytes', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' };
+        const m = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range || ''));
+        let ini = 0; let fim = st.size - 1; let codigo = 200;
+        if (m && (m[1] || m[2])) {
+            if (m[1]) { ini = Number(m[1]); if (m[2]) fim = Math.min(fim, Number(m[2])); } else { ini = Math.max(0, st.size - Number(m[2])); }
+            if (ini > fim || ini >= st.size) { res.writeHead(416, { 'Content-Range': `bytes */${st.size}` }); return res.end(); }
+            codigo = 206; cab['Content-Range'] = `bytes ${ini}-${fim}/${st.size}`;
+        }
+        cab['Content-Length'] = st.size ? fim - ini + 1 : 0;
+        res.writeHead(codigo, cab);
+        if (req.method === 'HEAD' || !st.size) return res.end();
+        fs.createReadStream(abs, { start: ini, end: fim }).on('error', () => res.destroy()).pipe(res);
+    }
+
+    function ws({ porta: pedida = 0, rede: pedirRede } = {}) {
+        if (pedirRede !== undefined) modoRede = !!pedirRede;
+        return new Promise((resolve, reject) => {
+            http_ = http.createServer(estatico);
+            http_.on('upgrade', (req, socket) => {
+                const recusar = (codigo, frase) => { socket.write(`HTTP/1.1 ${codigo} ${frase}\r\nConnection: close\r\n\r\n`); socket.destroy(); };
+                const quem = autenticar(req);
+                if (!quem) return recusar(401, 'Unauthorized');
+                if (String(req.headers.upgrade || '').toLowerCase() !== 'websocket' || !req.headers['sec-websocket-key']) return recusar(400, 'Bad Request');
+                const conn = quem.pareado ? { pareado: quem.pareado } : {};
+                const sock = WS.aceitar(req, socket, { aoTexto: (t) => tratar(t, conn), aoFechar: () => soltar(conn) });
+                conn.enviar = (obj) => sock.enviar(JSON.stringify(obj, (k, v) => (v instanceof Error ? { mensagem: v.message, nome: v.name } : v)));
+                conn.fechar = sock.fechar;
+                conexoes.add(conn);
+            });
+            http_.on('error', reject);
+            http_.listen(pedida, modoRede ? '0.0.0.0' : '127.0.0.1', () => {
+                porta = http_.address().port;
+                try {
+                    fs.mkdirSync(base, { recursive: true });
+                    fs.writeFileSync(arquivoInfo, JSON.stringify({ porta, token, pid: process.pid, rede: modoRede }), { mode: 0o600 });
+                    fs.chmodSync(arquivoInfo, 0o600);
+                } catch { /* sem gravar, o cliente ainda recebe porta e token pelo retorno */ }
+                resolve({ porta, token });
+            });
+        });
+    }
+
+    function fechar() {
+        if (timerPiloto) { clearInterval(timerPiloto); timerPiloto = null; }
+        for (const c of [...conexoes]) if (c.fechar) c.fechar();
+        conexoes.clear();
+        try { if (porta && JSON.parse(fs.readFileSync(arquivoInfo, 'utf8')).token === token) fs.rmSync(arquivoInfo, { force: true }); } catch { /* nada a limpar */ }
+        return new Promise((res) => { if (http_) { http_.close(() => res()); http_.closeAllConnections && http_.closeAllConnections(); } else res(); });
+    }
+
+    return { stdio, ws, fechar, tratar, metodos: Object.keys(metodos), token, arquivoInfo, pastaThreads, opcoesPiloto };
+}
+
+module.exports = { criarServidor };