@fontdata/ai-harness 2.5.1 → 2.7.0

package/dist/banco/lgpd/aplicar.js

@@ -0,0 +1,168 @@
+import { identificadoresDoSql } from '../somente-leitura.js';
+import { classificarColuna, classificarNumero, encontrarNoTexto } from './detectar.js';
+import { mascararValor, OCULTO } from './mascarar.js';
+function lerRegras(entradas) {
+    return entradas
+        .map((entrada) => entrada.trim().toLowerCase().split('.'))
+        .filter((partes) => partes.every((p) => p !== ''))
+        .map((partes) => partes.length === 1 ? { tabela: null, coluna: partes[0] } : { tabela: partes.at(-2), coluna: partes.at(-1) });
+}
+function casa(regras, nome, origem) {
+    const coluna = (origem ? origem.coluna : nome).toLowerCase();
+    const tabela = origem ? (origem.tabela.toLowerCase().split('.').at(-1) ?? '') : null;
+    return regras.some((r) => r.coluna === coluna && (r.tabela === null || r.tabela === tabela));
+}
+function identificadores(sql, dialeto) {
+    try {
+        return identificadoresDoSql(sql, dialeto).map((id) => id.toLowerCase());
+    }
+    catch {
+        // Sem tokenização, qualquer palavra do texto conta como identificador: mascara a mais, nunca a menos.
+        return Array.from(sql.matchAll(/[\p{L}_][\p{L}\p{N}_$]*/gu), (m) => m[0].toLowerCase());
+    }
+}
+function colunaPessoalCitada(opcoes, mascarar) {
+    const extras = new Set(mascarar.map((r) => r.coluna));
+    for (const id of identificadores(opcoes.sql, opcoes.dialeto)) {
+        const categoria = classificarColuna(id);
+        if (categoria)
+            return categoria;
+        if (extras.has(id))
+            return 'mascarar_colunas';
+    }
+    return null;
+}
+function ehBinario(valor) {
+    return valor instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(valor));
+}
+function mascararStringLivre(texto, contador) {
+    const inicio = texto.trimStart()[0];
+    if (inicio === '{' || inicio === '[') {
+        let objeto;
+        try {
+            objeto = JSON.parse(texto);
+        }
+        catch {
+            objeto = undefined;
+        }
+        if (objeto !== undefined)
+            return JSON.stringify(mascararEstrutura(objeto, contador));
+    }
+    const trechos = encontrarNoTexto(texto);
+    if (trechos.length === 0)
+        return texto;
+    let saida = '';
+    let posicao = 0;
+    for (const t of trechos) {
+        saida += texto.slice(posicao, t.inicio) + String(mascararValor(texto.slice(t.inicio, t.fim), t.categoria));
+        posicao = t.fim;
+    }
+    contador.valores += trechos.length;
+    return saida + texto.slice(posicao);
+}
+function mascararPorValor(valor, testarNumero, contador) {
+    if (typeof valor === 'string')
+        return mascararStringLivre(valor, contador);
+    if (typeof valor === 'number' || typeof valor === 'bigint') {
+        if (testarNumero && classificarNumero(valor) !== null) {
+            contador.valores += 1;
+            return OCULTO;
+        }
+        return valor;
+    }
+    if (ehBinario(valor)) {
+        contador.valores += 1;
+        return OCULTO;
+    }
+    if (valor instanceof Date)
+        return valor;
+    if (valor !== null && typeof valor === 'object')
+        return mascararEstrutura(valor, contador);
+    return valor;
+}
+function mascararEstrutura(valor, contador) {
+    if (Array.isArray(valor))
+        return valor.map((item) => mascararPorValor(item, true, contador));
+    if (valor === null || typeof valor !== 'object' || valor instanceof Date || ehBinario(valor)) {
+        return mascararPorValor(valor, true, contador);
+    }
+    const saida = {};
+    for (const [chave, item] of Object.entries(valor)) {
+        const categoria = classificarColuna(chave);
+        if (categoria === null) {
+            saida[chave] = mascararPorValor(item, true, contador);
+        }
+        else {
+            const mascarado = mascararValor(item, categoria);
+            if (mascarado !== item)
+                contador.valores += 1;
+            saida[chave] = mascarado;
+        }
+    }
+    return saida;
+}
+function tratamentoDaColuna(nome, origem, mascarar, liberar) {
+    if (casa(mascarar, nome, origem))
+        return { tipo: 'ocultar', categoria: 'mascarar_colunas' };
+    const semOrigem = !origem;
+    if (casa(liberar, nome, origem))
+        return { tipo: 'valor', calculada: false, numero: semOrigem };
+    const categoria = classificarColuna(origem ? origem.coluna : nome);
+    if (categoria)
+        return { tipo: 'categoria', categoria };
+    return { tipo: 'valor', calculada: origem === null, numero: semOrigem };
+}
+/**
+ * Mascara os dados pessoais de um resultado pela origem da coluna, pelo nome, pelas regras do projeto e pelo
+ * valor. Não altera o resultado recebido; com `ativo: false`, devolve-o sem mudança.
+ */
+export function mascararResultado(resultado, opcoes) {
+    if (!opcoes.ativo)
+        return { resultado, colunasMascaradas: [], valoresEmTexto: 0 };
+    const mascarar = lerRegras(opcoes.regras.mascarar_colunas);
+    const liberar = lerRegras(opcoes.regras.liberar_colunas);
+    const tratamentos = resultado.colunas.map((nome, i) => tratamentoDaColuna(nome, resultado.origens === undefined ? undefined : resultado.origens[i], mascarar, liberar));
+    let citada;
+    const citacao = () => {
+        if (citada === undefined)
+            citada = colunaPessoalCitada(opcoes, mascarar);
+        return citada;
+    };
+    const marcadas = new Map();
+    const contador = { valores: 0 };
+    const linhas = resultado.linhas.map((linha) => linha.map((valor, i) => {
+        const t = tratamentos[i] ?? { tipo: 'valor', calculada: false, numero: true };
+        if (t.tipo === 'ocultar') {
+            marcadas.set(i, t.categoria);
+            return valor === null || valor === undefined ? valor : OCULTO;
+        }
+        if (t.tipo === 'categoria') {
+            marcadas.set(i, t.categoria);
+            return mascararValor(valor, t.categoria);
+        }
+        if (t.calculada && typeof valor === 'string') {
+            const categoria = citacao();
+            if (categoria !== null) {
+                marcadas.set(i, categoria);
+                return OCULTO;
+            }
+        }
+        return mascararPorValor(valor, t.numero, contador);
+    }));
+    const copia = { ...resultado, colunas: [...resultado.colunas], linhas };
+    if (resultado.origens !== undefined)
+        copia.origens = resultado.origens.map((o) => (o ? { ...o } : o));
+    const colunasMascaradas = [...marcadas.keys()]
+        .sort((a, b) => a - b)
+        .map((i) => ({ coluna: resultado.colunas[i] ?? String(i), categoria: marcadas.get(i) }));
+    return { resultado: copia, colunasMascaradas, valoresEmTexto: contador.valores };
+}
+/** Categoria com que a coluna `tabela.coluna` sai mascarada pelo nome ou pelas regras do projeto, ou `null`. */
+export function categoriaDaColuna(tabela, coluna, regras) {
+    const t = tratamentoDaColuna(coluna, { tabela, coluna }, lerRegras(regras.mascarar_colunas), lerRegras(regras.liberar_colunas));
+    return t.tipo === 'valor' ? null : t.categoria;
+}
+/** Aplica a detecção por valor a um texto solto, como a mensagem de erro do banco. */
+export function mascararTexto(texto) {
+    return mascararStringLivre(texto, { valores: 0 });
+}

package/dist/banco/lgpd/detectar.js

@@ -0,0 +1,210 @@
+const PARTES_ISOLADAS = [
+    ['cpf', ['cpf']],
+    ['cnpj', ['cnpj']],
+    ['documento', ['rg', 'pis', 'nis', 'pasep', 'cnh', 'ctps', 'passaporte', 'passport', 'documento']],
+    ['email', ['email', 'mail']],
+    ['telefone', ['telefone', 'celular', 'fone', 'phone', 'tel', 'whatsapp', 'fax']],
+    ['endereco', ['endereco', 'logradouro', 'rua', 'bairro', 'complemento', 'address', 'street']],
+    ['cep', ['cep', 'zip', 'postal']],
+    ['nascimento', ['nascimento', 'nasc', 'birth', 'birthday']],
+    ['nome', ['sobrenome']],
+    ['financeiro', ['salario', 'renda', 'salary', 'income', 'agencia', 'iban', 'pix']],
+    ['cartao', ['cartao', 'card', 'cvv', 'cvc']],
+    ['ip', ['ip']],
+    ['segredo', ['senha', 'password', 'passwd', 'pwd', 'hash', 'token', 'secret', 'apikey']],
+    [
+        'sensivel',
+        [
+            'saude', 'diagnostico', 'cid', 'doenca', 'prontuario', 'biometria', 'digital', 'face', 'religiao', 'etnia',
+            'raca', 'sindical', 'deficiencia', 'genetico',
+        ],
+    ],
+];
+const PARTES_DE_PESSOA = [
+    'completo', 'cliente', 'pessoa', 'mae', 'pai', 'social', 'responsavel', 'contato', 'usuario', 'funcionario',
+    'paciente', 'aluno', 'titular', 'motorista', 'condutor', 'socio',
+];
+/** Cada combinação exige uma parte de cada lista. */
+const COMBINACOES = [
+    ['documento', [['titulo'], ['eleitor']]],
+    ['email', [['e'], ['mail']]],
+    ['ip', [['ip'], ['address']]],
+    ['segredo', [['api'], ['key']]],
+    ['sensivel', [['orientacao'], ['sexual']]],
+    ['financeiro', [['conta'], ['corrente', 'bancaria', 'numero']]],
+    ['nome', [['first', 'last', 'full'], ['name']]],
+    ['nome', [['nome', 'name'], PARTES_DE_PESSOA]],
+];
+const TERMOS_FORTES = [
+    ['cpf', 'cpf'],
+    ['cnpj', 'cnpj'],
+    ['email', 'email'],
+    ['telefone', 'telefone'],
+    ['celular', 'telefone'],
+    ['nascimento', 'nascimento'],
+    ['nasc', 'nascimento'],
+    ['senha', 'segredo'],
+    ['password', 'segredo'],
+];
+const MARCAS_DIACRITICAS = /\p{M}/gu;
+const MINUSCULA_MAIUSCULA = /([\p{Ll}\p{N}])(\p{Lu})/gu;
+const SIGLA_PALAVRA = /(\p{Lu})(\p{Lu}\p{Ll})/gu;
+const LETRA_DIGITO = /(\p{L})(\p{N})/gu;
+const DIGITO_LETRA = /(\p{N})(\p{L})/gu;
+const SEPARADORES = /[^\p{L}\p{N}]+/u;
+export function partesDoNome(nome) {
+    return nome
+        .normalize('NFD')
+        .replace(MARCAS_DIACRITICAS, '')
+        .replace(MINUSCULA_MAIUSCULA, '$1 $2')
+        .replace(SIGLA_PALAVRA, '$1 $2')
+        .replace(LETRA_DIGITO, '$1 $2')
+        .replace(DIGITO_LETRA, '$1 $2')
+        .toLowerCase()
+        .split(SEPARADORES)
+        .filter((p) => p !== '');
+}
+export function classificarColuna(nome) {
+    const partes = partesDoNome(nome);
+    const tem = new Set(partes);
+    for (const [categoria, listas] of COMBINACOES) {
+        if (listas.every((lista) => lista.some((p) => tem.has(p))))
+            return categoria;
+    }
+    if (partes.length === 1 && (partes[0] === 'nome' || partes[0] === 'name'))
+        return 'nome';
+    for (const [categoria, lista] of PARTES_ISOLADAS) {
+        if (lista.some((p) => tem.has(p)))
+            return categoria;
+    }
+    for (const [termo, categoria] of TERMOS_FORTES) {
+        if (partes.some((p) => p.includes(termo)))
+            return categoria;
+    }
+    return null;
+}
+const NAO_DIGITO = /\D/g;
+const DIGITOS_REPETIDOS = /^(\d)\1*$/;
+function soDigitos(texto) {
+    return texto.replace(NAO_DIGITO, '');
+}
+function digitoVerificador(digitos, pesos) {
+    let soma = 0;
+    for (let i = 0; i < pesos.length; i++)
+        soma += Number(digitos[i]) * (pesos[i] ?? 0);
+    const resto = soma % 11;
+    return resto < 2 ? 0 : 11 - resto;
+}
+export function cpfValido(cpf) {
+    const d = soDigitos(cpf);
+    if (d.length !== 11 || DIGITOS_REPETIDOS.test(d))
+        return false;
+    return (digitoVerificador(d, [10, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[9]) &&
+        digitoVerificador(d, [11, 10, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[10]));
+}
+export function cnpjValido(cnpj) {
+    const d = soDigitos(cnpj);
+    if (d.length !== 14 || DIGITOS_REPETIDOS.test(d))
+        return false;
+    return (digitoVerificador(d, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[12]) &&
+        digitoVerificador(d, [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[13]));
+}
+export function luhnValido(numero) {
+    const d = soDigitos(numero);
+    if (d.length < 2)
+        return false;
+    let soma = 0;
+    for (let i = 0; i < d.length; i++) {
+        let n = Number(d[d.length - 1 - i]);
+        if (i % 2 === 1) {
+            n *= 2;
+            if (n > 9)
+                n -= 9;
+        }
+        soma += n;
+    }
+    return soma % 10 === 0;
+}
+const SEQUENCIA_DE_DIGITOS = /\d+(?:(?:[.\-/]|\s+)\d+)*/g;
+const GRUPO_DE_DIGITOS = /\d+/g;
+const MAX_DIGITOS = 19;
+const CPF_FORMATADO = /^\d{3}\.\d{3}\.\d{3}-\d{2}$/;
+const CNPJ_FORMATADO = /^\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}$/;
+const EMAIL = /[\p{L}\p{M}\p{N}._%+-]+@[\p{L}\p{M}\p{N}-]+(?:\.[\p{L}\p{M}\p{N}-]+)*\.[\p{L}\p{M}]{2,}/gu;
+const TELEFONE = /(?<![\d+])(?:\+55\s?)?(?:\(\d{2}\)\s?|\d{2}[\s-])9?\d{4}[\s-]?\d{4}(?!\d)/g;
+/** `seq` é um trecho de grupos inteiros com no máximo `MAX_DIGITOS` dígitos. */
+function classificarSequencia(seq) {
+    if (CPF_FORMATADO.test(seq))
+        return 'cpf';
+    if (CNPJ_FORMATADO.test(seq))
+        return 'cnpj';
+    const d = soDigitos(seq);
+    if (d.length === 11 && cpfValido(d))
+        return 'cpf';
+    if (d.length === 14 && cnpjValido(d))
+        return 'cnpj';
+    if (d.length >= 13 && luhnValido(d))
+        return 'cartao';
+    return null;
+}
+/** Candidatos em cada trecho contíguo de grupos inteiros da sequência, sem quebrar um grupo por dentro. */
+function trechosDeDigitos(texto) {
+    const achados = [];
+    for (const m of texto.matchAll(SEQUENCIA_DE_DIGITOS)) {
+        const grupos = Array.from(m[0].matchAll(GRUPO_DE_DIGITOS), (g) => ({ inicio: g.index, fim: g.index + g[0].length }));
+        for (let i = 0; i < grupos.length; i++) {
+            let digitos = 0;
+            for (let j = i; j < grupos.length; j++) {
+                const a = grupos[i];
+                const b = grupos[j];
+                if (!a || !b)
+                    break;
+                digitos += b.fim - b.inicio;
+                if (digitos > MAX_DIGITOS)
+                    break;
+                const categoria = classificarSequencia(m[0].slice(a.inicio, b.fim));
+                if (categoria)
+                    achados.push({ inicio: m.index + a.inicio, fim: m.index + b.fim, categoria });
+            }
+        }
+    }
+    return achados;
+}
+function trechosDe(texto, re, categoria) {
+    return Array.from(texto.matchAll(re), (m) => ({ inicio: m.index, fim: m.index + m[0].length, categoria }));
+}
+function prioridade(categoria) {
+    return categoria === 'telefone' ? 1 : 0;
+}
+/**
+ * Trechos com dado pessoal, em ordem e sem sobreposição. Entre dois que se cruzam, telefone perde para os
+ * demais; na mesma prioridade, vence o mais longo e, empatado, o que começa antes.
+ */
+export function encontrarNoTexto(texto) {
+    const candidatos = [
+        ...trechosDe(texto, EMAIL, 'email'),
+        ...trechosDe(texto, TELEFONE, 'telefone'),
+        ...trechosDeDigitos(texto),
+    ].sort((a, b) => prioridade(a.categoria) - prioridade(b.categoria) || b.fim - b.inicio - (a.fim - a.inicio) || a.inicio - b.inicio);
+    const escolhidos = [];
+    for (const t of candidatos) {
+        if (escolhidos.every((e) => t.fim <= e.inicio || t.inicio >= e.fim))
+            escolhidos.push(t);
+    }
+    return escolhidos.sort((a, b) => a.inicio - b.inicio);
+}
+/** Testa um inteiro não negativo como CPF (9 a 11 dígitos), CNPJ (12 a 14) ou cartão (13 a 19, Luhn). */
+export function classificarNumero(valor) {
+    if (typeof valor === 'number' && !Number.isSafeInteger(valor))
+        return null;
+    if (valor < 0)
+        return null;
+    const d = valor.toString();
+    if (d.length >= 9 && d.length <= 11 && cpfValido(d.padStart(11, '0')))
+        return 'cpf';
+    if (d.length >= 12 && d.length <= 14 && cnpjValido(d.padStart(14, '0')))
+        return 'cnpj';
+    if (d.length >= 13 && d.length <= 19 && luhnValido(d))
+        return 'cartao';
+    return null;
+}

package/dist/banco/lgpd/mascarar.js

@@ -0,0 +1,114 @@
+export const OCULTO = '[OCULTO]';
+const CONECTIVOS = new Set(['da', 'de', 'do', 'das', 'dos', 'e']);
+function manterIntervalo(texto, inicio, fim) {
+    let posicao = 0;
+    return texto.replace(/\d/g, (digito) => {
+        posicao += 1;
+        return posicao >= inicio && posicao <= fim ? digito : '*';
+    });
+}
+function mascararCpf(texto) {
+    if (!/^(\d{3}\.\d{3}\.\d{3}-\d{2}|\d{11})$/.test(texto))
+        return OCULTO;
+    return manterIntervalo(texto, 4, 9);
+}
+function mascararCnpj(texto) {
+    if (!/^(\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}|\d{14})$/.test(texto))
+        return OCULTO;
+    return manterIntervalo(texto, 3, 12);
+}
+function mascararDocumento(texto) {
+    if (!/^[A-Za-z0-9./\s-]+$/.test(texto))
+        return OCULTO;
+    const total = texto.replace(/[^A-Za-z0-9]/g, '').length;
+    if (total < 4)
+        return OCULTO;
+    let posicao = 0;
+    return texto.replace(/[A-Za-z0-9]/g, (caractere) => {
+        posicao += 1;
+        return posicao > total - 2 ? caractere : '*';
+    });
+}
+function mascararEmail(texto) {
+    const partes = /^([^\s@]+)@([^\s@]+)$/.exec(texto);
+    if (!partes)
+        return OCULTO;
+    return `${[...partes[1]][0]}***@${partes[2]}`;
+}
+function mascararTelefone(texto) {
+    if (!/^\+?[\d\s()-]+$/.test(texto))
+        return OCULTO;
+    let digitos = texto.replace(/\D/g, '');
+    if (texto.startsWith('+')) {
+        if (!digitos.startsWith('55'))
+            return OCULTO;
+        digitos = digitos.slice(2);
+    }
+    if (digitos.length !== 10 && digitos.length !== 11)
+        return OCULTO;
+    return `(${digitos.slice(0, 2)}) *****-${digitos.slice(-4)}`;
+}
+function mascararCep(texto) {
+    if (!/^\d{5}-\d{3}$/.test(texto))
+        return OCULTO;
+    return `${texto.slice(0, 2)}***-***`;
+}
+function mascararNome(texto) {
+    if (!/\p{L}/u.test(texto))
+        return OCULTO;
+    const iniciais = texto
+        .split(/\s+/)
+        .filter((palavra) => palavra !== '' && !CONECTIVOS.has(palavra.toLowerCase()))
+        .map((palavra) => `${[...palavra][0]}***`);
+    return iniciais.length === 0 ? OCULTO : iniciais.join(' ');
+}
+function mascararNascimento(valor) {
+    if (valor instanceof Date) {
+        const ano = valor.getFullYear();
+        return Number.isNaN(ano) ? OCULTO : `${String(ano).padStart(4, '0')}-**-**`;
+    }
+    const partes = /^(\d{4})-\d{2}-\d{2}(T.*)?$/.exec(valor);
+    return partes ? `${partes[1]}-**-**` : OCULTO;
+}
+function mascararCartao(texto) {
+    if (!/^[\d\s-]+$/.test(texto))
+        return OCULTO;
+    const digitos = texto.replace(/\D/g, '');
+    if (digitos.length < 13 || digitos.length > 19)
+        return OCULTO;
+    return `**** **** **** ${digitos.slice(-4)}`;
+}
+function mascararIp(texto) {
+    const octetos = texto.split('.');
+    const valido = octetos.length === 4 && octetos.every((o) => /^\d{1,3}$/.test(o) && Number(o) <= 255);
+    return valido ? `${octetos[0]}.${octetos[1]}.*.*` : OCULTO;
+}
+const MASCARAS = {
+    cpf: mascararCpf,
+    cnpj: mascararCnpj,
+    documento: mascararDocumento,
+    email: mascararEmail,
+    telefone: mascararTelefone,
+    endereco: () => OCULTO,
+    cep: mascararCep,
+    nascimento: mascararNascimento,
+    nome: mascararNome,
+    financeiro: () => OCULTO,
+    cartao: mascararCartao,
+    ip: mascararIp,
+    segredo: () => OCULTO,
+    sensivel: () => OCULTO,
+};
+/**
+ * Mascara um valor já classificado, mantendo o formato quando possível.
+ * `null` e `undefined` passam intactos; valor não textual ou fora do formato vira `[OCULTO]`.
+ */
+export function mascararValor(valor, categoria) {
+    if (valor === null || valor === undefined)
+        return valor;
+    if (valor instanceof Date && categoria === 'nascimento')
+        return mascararNascimento(valor);
+    if (typeof valor !== 'string')
+        return OCULTO;
+    return MASCARAS[categoria](valor.trim());
+}

package/dist/banco/mcp.js

@@ -0,0 +1,101 @@
+import { readFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { raizDoProjeto } from './conexao.js';
+import { executarFerramenta, FERRAMENTAS, INSTRUCOES } from './ferramentas.js';
+const VERSOES_PROTOCOLO = ['2024-11-05', '2025-03-26', '2025-06-18'];
+const VERSAO_PADRAO = '2025-06-18';
+class FalhaRpc extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function versaoPacote() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function responder(metodo, params, contexto) {
+    const parametros = isObject(params) ? params : {};
+    switch (metodo) {
+        case 'initialize': {
+            const pedida = parametros.protocolVersion;
+            return {
+                protocolVersion: typeof pedida === 'string' && VERSOES_PROTOCOLO.includes(pedida) ? pedida : VERSAO_PADRAO,
+                capabilities: { tools: {} },
+                serverInfo: { name: 'ai-harness-banco', version: versaoPacote() },
+                instructions: INSTRUCOES,
+            };
+        }
+        case 'ping':
+            return {};
+        case 'tools/list':
+            return { tools: FERRAMENTAS };
+        case 'tools/call': {
+            if (typeof parametros.name !== 'string')
+                throw new FalhaRpc(-32602, 'tools/call exige params.name');
+            return executarFerramenta(parametros.name, parametros.arguments ?? {}, contexto);
+        }
+        default:
+            throw new FalhaRpc(-32601, `Método não encontrado: ${metodo}`);
+    }
+}
+/** Atende JSON-RPC 2.0 com uma mensagem por linha; a saída recebe só respostas JSON-RPC. */
+export function iniciarServidorMcp(opcoes) {
+    const contexto = opcoes.contexto ?? { raiz: raizDoProjeto() };
+    const enviar = (id, corpo) => {
+        opcoes.saida.write(`${JSON.stringify({ jsonrpc: '2.0', id, ...corpo })}\n`);
+    };
+    const atender = async (linha) => {
+        if (!linha.trim())
+            return;
+        let mensagem;
+        try {
+            mensagem = JSON.parse(linha);
+        }
+        catch {
+            enviar(null, { error: { code: -32700, message: 'JSON inválido' } });
+            return;
+        }
+        if (!isObject(mensagem)) {
+            enviar(null, { error: { code: -32600, message: 'Requisição inválida' } });
+            return;
+        }
+        const id = mensagem.id;
+        if (id === undefined)
+            return;
+        const idValido = typeof id === 'string' || typeof id === 'number' ? id : null;
+        if (typeof mensagem.method !== 'string') {
+            if (!('result' in mensagem) && !('error' in mensagem)) {
+                enviar(idValido, { error: { code: -32600, message: 'Requisição inválida' } });
+            }
+            return;
+        }
+        try {
+            enviar(idValido, { result: await responder(mensagem.method, mensagem.params, contexto) });
+        }
+        catch (falha) {
+            const code = falha instanceof FalhaRpc ? falha.code : -32603;
+            const message = falha instanceof FalhaRpc ? falha.message : 'Erro interno do servidor';
+            enviar(idValido, { error: { code, message } });
+        }
+    };
+    return new Promise((resolver, rejeitar) => {
+        let fila = Promise.resolve();
+        const leitor = createInterface({ input: opcoes.entrada, crlfDelay: Infinity });
+        leitor.on('line', (linha) => {
+            fila = fila.then(() => atender(linha));
+        });
+        leitor.on('close', () => {
+            fila.then(resolver, rejeitar);
+        });
+    });
+}