next-finance-mcp 0.3.2 → 0.4.1

package/dist/client.d.ts

@@ -13,9 +13,42 @@ export declare function login(email: string, senha: string): Promise<Record<stri
 export declare function tryRestoreSession(): Promise<boolean>;
 export declare function listarCarteiras(): Promise<unknown>;
 export declare function selecionarCarteira(idCarteira: string): Promise<Record<string, unknown>>;
-export declare function listarContas(): Promise<unknown>;
-export declare function buscarLancamentos(opts: {
+export interface FiltroContas {
+    busca?: string;
+    tipos?: number[];
+    pagina?: number;
+    limite?: number;
+}
+export interface PaginaMeta {
+    pagina: number;
+    limite: number;
+    total: number;
+    paginas: number;
+    tem_mais: boolean;
+}
+export interface ResultadoContas {
+    contas: Record<string, unknown>[];
+    paginacao: PaginaMeta;
+    _debug?: {
+        estrutura: string;
+        campos_exemplo: string[];
+    };
+}
+export declare function listarContas(filtro?: FiltroContas): Promise<ResultadoContas>;
+export interface FiltroLancamentos {
     idConta: string;
     dataInicio?: string;
     dataFim?: string;
-}): Promise<unknown>;
+    busca?: string;
+    pagina?: number;
+    limite?: number;
+}
+export interface ResultadoLancamentos {
+    lancamentos: unknown[];
+    paginacao: PaginaMeta;
+    periodo: {
+        inicio: string;
+        fim: string;
+    };
+}
+export declare function buscarLancamentos(opts: FiltroLancamentos): Promise<ResultadoLancamentos>;

package/dist/client.js

@@ -181,31 +181,160 @@ export async function selecionarCarteira(idCarteira) {
     }
     return { sucesso: ok, mensagem: ok ? `Carteira ${idCarteira} selecionada.` : `Falha ao selecionar carteira (${resp.status}).` };
 }
-// ── Contas ──────────────────────────────────────────────────────────────────
-export async function listarContas() {
+/**
+ * Extrai o array de contas de qualquer estrutura de resposta da API.
+ * Tenta array direto, depois chaves comuns de envelope, depois primeira array encontrada.
+ */
+function extrairArray(data) {
+    if (Array.isArray(data))
+        return data;
+    if (data && typeof data === "object") {
+        const obj = data;
+        // Chaves comuns de envelope em APIs C#/EF
+        for (const key of ["data", "items", "contas", "resultado", "list", "records", "Data", "Items", "Contas", "Resultado", "Lista", "lista", "value", "Value"]) {
+            if (Array.isArray(obj[key]))
+                return obj[key];
+        }
+        // Fallback: primeira propriedade que seja array
+        for (const val of Object.values(obj)) {
+            if (Array.isArray(val))
+                return val;
+        }
+    }
+    return [];
+}
+/**
+ * Retorna apenas campos essenciais de uma conta, descartando metadados pesados.
+ * Usa allowlist por padrão de nome (case-insensitive) — valores primitivos apenas.
+ */
+function enxugarConta(conta) {
+    if (!conta || typeof conta !== "object")
+        return {};
+    const obj = conta;
+    // Padrões que identificam campos essenciais de conta
+    const KEEP = [/id/i, /nome/i, /descri/i, /tipo/i, /ativo/i, /status/i, /situac/i,
+        /banco/i, /agenci/i, /saldo/i, /codigo/i, /numero/i, /moeda/i, /cartei/i];
+    const slim = {};
+    for (const [k, v] of Object.entries(obj)) {
+        // só primitivos (sem objetos/arrays aninhados) e com nome relevante
+        if (v !== null && typeof v !== "object" && KEEP.some(p => p.test(k))) {
+            slim[k] = v;
+        }
+    }
+    // Fallback: se nada foi selecionado, devolve todos os primitivos (melhor que vazio)
+    if (Object.keys(slim).length === 0) {
+        for (const [k, v] of Object.entries(obj)) {
+            if (v !== null && typeof v !== "object")
+                slim[k] = v;
+        }
+    }
+    return slim;
+}
+export async function listarContas(filtro = {}) {
     const resp = await webGet("/ContaAjax/ListarTodos");
     if (resp.status !== 200)
         throw new Error(`Erro ${resp.status} ao listar contas.`);
-    return JSON.parse(resp.text);
+    const raw = JSON.parse(resp.text);
+    // 1. Extrai array independente da estrutura de envelope
+    const estrutura = Array.isArray(raw) ? "array_direto"
+        : (typeof raw === "object" ? `objeto{${Object.keys(raw).join(",")}}` : typeof raw);
+    let contas = extrairArray(raw);
+    // 2. Enxuga campos ANTES de filtrar/paginar (resolve o estouro de 1MB)
+    let contasSlim = contas.map(enxugarConta);
+    // 3. Filtro por busca textual em todos os campos string da versão enxuta
+    if (filtro.busca?.trim()) {
+        const termo = filtro.busca.trim().toLowerCase();
+        contasSlim = contasSlim.filter(c => Object.values(c)
+            .filter(v => typeof v === "string")
+            .some(v => v.toLowerCase().includes(termo)));
+    }
+    // 4. Filtro por tipo — tenta todos os campos cujo nome contenha "tipo" (string ou número)
+    if (filtro.tipos && filtro.tipos.length > 0) {
+        const tiposStr = new Set(filtro.tipos.map(String));
+        contasSlim = contasSlim.filter(c => {
+            for (const [k, v] of Object.entries(c)) {
+                if (/tipo/i.test(k) && v != null && tiposStr.has(String(v)))
+                    return true;
+            }
+            return false;
+        });
+    }
+    // 5. Paginação
+    const pagina = Math.max(1, filtro.pagina ?? 1);
+    const limite = Math.min(200, Math.max(1, filtro.limite ?? 30));
+    const total = contasSlim.length;
+    const inicio = (pagina - 1) * limite;
+    const slice = contasSlim.slice(inicio, inicio + limite);
+    // _debug: mostra estrutura e campos da 1ª conta — útil para diagnosticar filtro por tipo
+    const primeiraRaw = contas[0] && typeof contas[0] === "object"
+        ? Object.keys(contas[0])
+        : [];
+    return {
+        contas: slice,
+        paginacao: { pagina, limite, total, paginas: Math.ceil(total / limite), tem_mais: inicio + limite < total },
+        _debug: { estrutura, campos_exemplo: primeiraRaw.slice(0, 30) },
+    };
 }
-// ── Lançamentos ─────────────────────────────────────────────────────────────
-//
-// O endpoint usa jQuery $.ajax padrão → form-urlencoded com chaves aninhadas:
-//   filtro[IdConta]=X&filtro[IntervaloDeDatas][DataInicio]=Y&filtro[IntervaloDeDatas][DataFim]=Z
-//
-// IdConta é OBRIGATÓRIO (cada chamada é por conta).
 export async function buscarLancamentos(opts) {
-    // DataInicio e DataFim são obrigatórios pela API; usar mês atual como default
     const today = new Date();
-    const defaultInicio = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}-01`;
-    const defaultFim = today.toISOString().slice(0, 10);
+    const dataInicio = opts.dataInicio ?? `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}-01`;
+    const dataFim = opts.dataFim ?? today.toISOString().slice(0, 10);
     const params = new URLSearchParams();
     params.set("filtro[IdConta]", opts.idConta);
-    params.set("filtro[IntervaloDeDatas][DataInicio]", opts.dataInicio ?? defaultInicio);
-    params.set("filtro[IntervaloDeDatas][DataFim]", opts.dataFim ?? defaultFim);
+    params.set("filtro[IntervaloDeDatas][DataInicio]", dataInicio);
+    params.set("filtro[IntervaloDeDatas][DataFim]", dataFim);
     params.set("filtro[ListarOrdenadoPelaDataDeModificacao]", "false");
     const resp = await webPost("/LancamentoAjax/Filtrar", params.toString(), "application/x-www-form-urlencoded");
     if (resp.status !== 200)
         throw new Error(`Erro ${resp.status}: ${resp.text.slice(0, 200)}`);
-    return JSON.parse(resp.text);
+    const raw = JSON.parse(resp.text);
+    // Extrai array independente do envelope
+    let lancamentos = extrairArray(raw);
+    // Enxuga campos: mantém apenas essenciais de lançamento
+    const KEEP_LANC = [/id/i, /data/i, /valor/i, /descri/i, /histor/i, /observ/i,
+        /categ/i, /plano/i, /conta/i, /tipo/i, /status/i, /situac/i,
+        /document/i, /numero/i, /compet/i, /vencim/i];
+    let lancsSlim = lancamentos.map(l => {
+        if (!l || typeof l !== "object")
+            return {};
+        const obj = l;
+        const slim = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (v !== null && typeof v !== "object" && KEEP_LANC.some(p => p.test(k))) {
+                slim[k] = v;
+            }
+        }
+        // Fallback: todos os primitivos se nada foi capturado
+        if (Object.keys(slim).length === 0) {
+            for (const [k, v] of Object.entries(obj)) {
+                if (v !== null && typeof v !== "object")
+                    slim[k] = v;
+            }
+        }
+        return slim;
+    });
+    // Filtro por busca textual em todos os campos string
+    if (opts.busca?.trim()) {
+        const termo = opts.busca.trim().toLowerCase();
+        lancsSlim = lancsSlim.filter(l => Object.values(l)
+            .filter(v => typeof v === "string")
+            .some(v => v.toLowerCase().includes(termo)));
+    }
+    // Paginação
+    const pagina = Math.max(1, opts.pagina ?? 1);
+    const limite = Math.min(500, Math.max(1, opts.limite ?? 50));
+    const total = lancsSlim.length;
+    const inicio = (pagina - 1) * limite;
+    const slice = lancsSlim.slice(inicio, inicio + limite);
+    return {
+        lancamentos: slice,
+        paginacao: {
+            pagina,
+            limite,
+            total,
+            paginas: Math.ceil(total / limite),
+            tem_mais: inicio + limite < total,
+        },
+        periodo: { inicio: dataInicio, fim: dataFim },
+    };
 }

package/dist/finance-client.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Cliente HTTP para o NEXT Finance — instanciável por usuário (multi-tenant).
+ */
+interface Cookie {
+    name: string;
+    value: string;
+    domain: string;
+}
+export declare class NextFinanceClient {
+    private cookieStore;
+    private _loggedIn;
+    private _selectedWallet;
+    private storeCookies;
+    private getCookieHeader;
+    getCookies(): Cookie[];
+    setCookies(cookies: Cookie[]): void;
+    getSelectedWallet(): string | null;
+    setSelectedWallet(id: string | null): void;
+    isAuthenticated(): boolean;
+    logout(): void;
+    private webGet;
+    private webPost;
+    private extractCsrf;
+    login(email: string, senha: string): Promise<{
+        sucesso: boolean;
+        mensagem: string;
+    }>;
+    /** Verifica se a sessão ainda funciona fazendo uma chamada leve. */
+    checkSession(): Promise<boolean>;
+    listarCarteiras(): Promise<unknown>;
+    selecionarCarteira(idCarteira: string): Promise<{
+        sucesso: boolean;
+        mensagem: string;
+    }>;
+    listarContas(): Promise<unknown>;
+    buscarLancamentos(opts: {
+        idConta: string;
+        dataInicio?: string;
+        dataFim?: string;
+    }): Promise<unknown>;
+}
+export {};

package/dist/finance-client.js

@@ -0,0 +1,151 @@
+/**
+ * Cliente HTTP para o NEXT Finance — instanciável por usuário (multi-tenant).
+ */
+const WEB_BASE = "https://finance.net.br";
+const BASE_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+};
+export class NextFinanceClient {
+    cookieStore = [];
+    _loggedIn = false;
+    _selectedWallet = null;
+    // ── Cookie store ────────────────────────────────────────────────────────────
+    storeCookies(setCookieHeaders, domain) {
+        for (const header of setCookieHeaders) {
+            const pair = header.split(";")[0].trim();
+            const eqIdx = pair.indexOf("=");
+            if (eqIdx < 0)
+                continue;
+            const name = pair.slice(0, eqIdx).trim();
+            const value = pair.slice(eqIdx + 1).trim();
+            const idx = this.cookieStore.findIndex(c => c.name === name && c.domain === domain);
+            if (idx >= 0)
+                this.cookieStore[idx].value = value;
+            else
+                this.cookieStore.push({ name, value, domain });
+        }
+    }
+    getCookieHeader(domain) {
+        return this.cookieStore
+            .filter(c => domain.includes(c.domain) || c.domain.includes(domain))
+            .map(c => `${c.name}=${c.value}`)
+            .join("; ");
+    }
+    getCookies() { return [...this.cookieStore]; }
+    setCookies(cookies) { this.cookieStore = [...cookies]; }
+    getSelectedWallet() { return this._selectedWallet; }
+    setSelectedWallet(id) { this._selectedWallet = id; }
+    // ── Estado ──────────────────────────────────────────────────────────────────
+    isAuthenticated() { return this._loggedIn; }
+    logout() {
+        this.cookieStore = [];
+        this._loggedIn = false;
+        this._selectedWallet = null;
+    }
+    // ── HTTP helpers ────────────────────────────────────────────────────────────
+    async webGet(path) {
+        const res = await fetch(`${WEB_BASE}${path}`, {
+            headers: {
+                ...BASE_HEADERS,
+                Cookie: this.getCookieHeader("finance.net.br"),
+                Accept: "text/html,application/xhtml+xml,application/json,*/*;q=0.8",
+            },
+            redirect: "follow",
+        });
+        this.storeCookies(res.headers.getSetCookie?.() ?? [], "finance.net.br");
+        return { status: res.status, text: await res.text() };
+    }
+    async webPost(path, body, contentType, followRedirect = true) {
+        const res = await fetch(`${WEB_BASE}${path}`, {
+            method: "POST",
+            headers: {
+                ...BASE_HEADERS,
+                Cookie: this.getCookieHeader("finance.net.br"),
+                "Content-Type": contentType,
+                Accept: "application/json, text/html, */*",
+                "X-Requested-With": "XMLHttpRequest",
+            },
+            body,
+            redirect: followRedirect ? "follow" : "manual",
+        });
+        this.storeCookies(res.headers.getSetCookie?.() ?? [], "finance.net.br");
+        return { status: res.status, text: await res.text(), location: res.headers.get("location") ?? undefined };
+    }
+    extractCsrf(html) {
+        return html.match(/name="__RequestVerificationToken"[^>]+value="([^"]+)"/)?.[1] ?? "";
+    }
+    // ── Auth ────────────────────────────────────────────────────────────────────
+    async login(email, senha) {
+        this.logout();
+        const loginPage = await this.webGet("/Login");
+        const csrf = this.extractCsrf(loginPage.text);
+        if (!csrf)
+            return { sucesso: false, mensagem: "Não foi possível obter o token CSRF da página de login." };
+        const formBody = new URLSearchParams({ Email: email, Senha: senha, __RequestVerificationToken: csrf }).toString();
+        const resp = await this.webPost("/Login", formBody, "application/x-www-form-urlencoded", false);
+        const isSuccess = resp.status === 302 && (resp.location?.includes("/Carteira") ||
+            resp.location?.includes("/carteira") ||
+            resp.location === "/");
+        if (!isSuccess) {
+            const errMsg = resp.text.match(/mensagemErroVal\"[^>]+value=\"([^\"]+)\"/)?.[1]?.trim() ??
+                resp.text.match(/texto-mensagem-erro[^>]*>([^<]+)/)?.[1]?.trim() ??
+                `Credenciais inválidas (status ${resp.status}).`;
+            return { sucesso: false, mensagem: errMsg };
+        }
+        this._loggedIn = true;
+        return { sucesso: true, mensagem: "Login realizado com sucesso." };
+    }
+    /** Verifica se a sessão ainda funciona fazendo uma chamada leve. */
+    async checkSession() {
+        try {
+            const resp = await this.webGet("/CarteiraAjax/Listar");
+            if (resp.status === 200) {
+                this._loggedIn = true;
+                return true;
+            }
+        }
+        catch { /* ignora */ }
+        this.logout();
+        return false;
+    }
+    // ── Carteiras ───────────────────────────────────────────────────────────────
+    async listarCarteiras() {
+        const resp = await this.webGet("/CarteiraAjax/Listar");
+        if (resp.status !== 200)
+            throw new Error(`Erro ${resp.status} ao listar carteiras.`);
+        return JSON.parse(resp.text);
+    }
+    async selecionarCarteira(idCarteira) {
+        const cartPage = await this.webGet("/Carteira");
+        const csrf = this.extractCsrf(cartPage.text);
+        const formBody = new URLSearchParams({ __RequestVerificationToken: csrf, idCarteira }).toString();
+        const resp = await this.webPost("/Carteira", formBody, "application/x-www-form-urlencoded", false);
+        const ok = resp.status === 302;
+        if (ok)
+            this._selectedWallet = idCarteira;
+        return { sucesso: ok, mensagem: ok ? `Carteira ${idCarteira} selecionada.` : `Falha ao selecionar (${resp.status}).` };
+    }
+    // ── Contas ──────────────────────────────────────────────────────────────────
+    async listarContas() {
+        const resp = await this.webGet("/ContaAjax/ListarTodos");
+        if (resp.status !== 200)
+            throw new Error(`Erro ${resp.status} ao listar contas.`);
+        return JSON.parse(resp.text);
+    }
+    // ── Lançamentos ─────────────────────────────────────────────────────────────
+    async buscarLancamentos(opts) {
+        const today = new Date();
+        const defaultInicio = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}-01`;
+        const defaultFim = today.toISOString().slice(0, 10);
+        const params = new URLSearchParams();
+        params.set("filtro[IdConta]", opts.idConta);
+        params.set("filtro[IntervaloDeDatas][DataInicio]", opts.dataInicio ?? defaultInicio);
+        params.set("filtro[IntervaloDeDatas][DataFim]", opts.dataFim ?? defaultFim);
+        params.set("filtro[ListarOrdenadoPelaDataDeModificacao]", "false");
+        const resp = await this.webPost("/LancamentoAjax/Filtrar", params.toString(), "application/x-www-form-urlencoded");
+        if (resp.status !== 200)
+            throw new Error(`Erro ${resp.status}: ${resp.text.slice(0, 200)}`);
+        return JSON.parse(resp.text);
+    }
+}

package/dist/http-index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Servidor MCP remoto para o NEXT Finance — modo HTTP (para Claude Mobile e outros clientes remotos).
+ *
+ * Variáveis de ambiente obrigatórias:
+ *   NEXT_FINANCE_EMAIL    — e-mail da sua conta no NEXT Finance
+ *   NEXT_FINANCE_PASSWORD — senha da sua conta no NEXT Finance
+ *   API_KEY               — chave secreta para autenticar o cliente MCP (você escolhe)
+ *
+ * Opcional:
+ *   PORT                  — porta do servidor (padrão: 3000)
+ */
+export {};

package/dist/http-index.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/**
+ * Servidor MCP remoto para o NEXT Finance — modo HTTP (para Claude Mobile e outros clientes remotos).
+ *
+ * Variáveis de ambiente obrigatórias:
+ *   NEXT_FINANCE_EMAIL    — e-mail da sua conta no NEXT Finance
+ *   NEXT_FINANCE_PASSWORD — senha da sua conta no NEXT Finance
+ *   API_KEY               — chave secreta para autenticar o cliente MCP (você escolhe)
+ *
+ * Opcional:
+ *   PORT                  — porta do servidor (padrão: 3000)
+ */
+import express from "express";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "crypto";
+import * as client from "./client.js";
+// ── Configuração ─────────────────────────────────────────────────────────────
+const PORT = parseInt(process.env.PORT ?? "3000", 10);
+const API_KEY = process.env.API_KEY ?? "";
+const NF_EMAIL = process.env.NEXT_FINANCE_EMAIL ?? "";
+const NF_PASS = process.env.NEXT_FINANCE_PASSWORD ?? "";
+if (!API_KEY) {
+    console.error("❌ Variável de ambiente API_KEY não definida.");
+    process.exit(1);
+}
+if (!NF_EMAIL) {
+    console.error("❌ Variável de ambiente NEXT_FINANCE_EMAIL não definida.");
+    process.exit(1);
+}
+if (!NF_PASS) {
+    console.error("❌ Variável de ambiente NEXT_FINANCE_PASSWORD não definida.");
+    process.exit(1);
+}
+// ── Auto-login ───────────────────────────────────────────────────────────────
+let loginAttempted = false;
+async function ensureLoggedIn() {
+    if (client.isAuthenticated())
+        return null;
+    if (loginAttempted)
+        return "Aguardando login. Tente novamente em alguns segundos.";
+    loginAttempted = true;
+    console.log("🔐 Fazendo login no NEXT Finance...");
+    const result = await client.login(NF_EMAIL, NF_PASS);
+    loginAttempted = false;
+    if (!result.sucesso) {
+        return `Falha no login: ${result.mensagem}`;
+    }
+    console.log("✅ Login realizado com sucesso.");
+    return null;
+}
+// Re-login automático a cada 2 dias
+setInterval(() => {
+    client.logout();
+    ensureLoggedIn().catch(console.error);
+}, 2 * 24 * 60 * 60 * 1000);
+// ── Cria servidor MCP ────────────────────────────────────────────────────────
+function createMcpServer() {
+    const server = new Server({ name: "next-finance-mcp", version: "0.3.2" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: "login",
+                description: "Verifica e restabelece a sessão no NEXT Finance (usa credenciais configuradas no servidor).",
+                inputSchema: { type: "object", properties: {} },
+            },
+            {
+                name: "logout",
+                description: "Encerra a sessão atual.",
+                inputSchema: { type: "object", properties: {} },
+            },
+            {
+                name: "listar_carteiras",
+                description: "Lista todas as carteiras disponíveis para o usuário logado.",
+                inputSchema: { type: "object", properties: {} },
+            },
+            {
+                name: "selecionar_carteira",
+                description: "Seleciona uma carteira pelo ID (necessário antes de listar contas e lançamentos).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id_carteira: { type: "string", description: "ID da carteira" },
+                    },
+                    required: ["id_carteira"],
+                },
+            },
+            {
+                name: "listar_contas",
+                description: "Lista as contas da carteira selecionada.",
+                inputSchema: { type: "object", properties: {} },
+            },
+            {
+                name: "buscar_lancamentos",
+                description: "Busca lançamentos/transações de uma conta. Se não informar datas, retorna o mês atual.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id_conta: { type: "string", description: "ID da conta (use listar_contas para descobrir)" },
+                        data_inicio: { type: "string", description: "Data início YYYY-MM-DD (padrão: 1º do mês atual)" },
+                        data_fim: { type: "string", description: "Data fim YYYY-MM-DD (padrão: hoje)" },
+                    },
+                    required: ["id_conta"],
+                },
+            },
+        ],
+    }));
+    function ok(data) {
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+    function requireWallet() {
+        if (!client.getSelectedWallet())
+            return ok({ erro: "Nenhuma carteira selecionada. Use `selecionar_carteira` primeiro." });
+        return null;
+    }
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const { name, arguments: args = {} } = req.params;
+        try {
+            // Garante login antes de qualquer operação (exceto login/logout)
+            if (name !== "login" && name !== "logout") {
+                const loginErr = await ensureLoggedIn();
+                if (loginErr)
+                    return ok({ erro: loginErr });
+            }
+            switch (name) {
+                case "login": {
+                    const err = await ensureLoggedIn();
+                    if (err) {
+                        // Forçar novo login
+                        client.logout();
+                        const result = await client.login(NF_EMAIL, NF_PASS);
+                        return ok(result);
+                    }
+                    return ok({ sucesso: true, mensagem: "Sessão ativa. Pronto para usar!" });
+                }
+                case "logout": {
+                    client.logout();
+                    return ok({ mensagem: "Sessão encerrada." });
+                }
+                case "listar_carteiras":
+                    return ok(await client.listarCarteiras());
+                case "selecionar_carteira":
+                    return ok(await client.selecionarCarteira(args["id_carteira"]));
+                case "listar_contas": {
+                    const walErr = requireWallet();
+                    if (walErr)
+                        return walErr;
+                    return ok(await client.listarContas());
+                }
+                case "buscar_lancamentos": {
+                    const walErr = requireWallet();
+                    if (walErr)
+                        return walErr;
+                    return ok(await client.buscarLancamentos({
+                        idConta: args["id_conta"],
+                        dataInicio: args["data_inicio"],
+                        dataFim: args["data_fim"],
+                    }));
+                }
+                default:
+                    return ok({ erro: `Ferramenta desconhecida: ${name}` });
+            }
+        }
+        catch (err) {
+            return ok({ erro: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    return server;
+}
+// ── Express app ──────────────────────────────────────────────────────────────
+const app = express();
+app.use(express.json());
+// Middleware de autenticação via Bearer token
+app.use((req, res, next) => {
+    // Health check não exige auth
+    if (req.path === "/health" && req.method === "GET") {
+        next();
+        return;
+    }
+    const auth = req.headers.authorization ?? "";
+    const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+    if (token !== API_KEY) {
+        res.status(401).json({ error: "Unauthorized — API_KEY inválida." });
+        return;
+    }
+    next();
+});
+// Health check
+app.get("/health", (_req, res) => {
+    res.json({ status: "ok", authenticated: client.isAuthenticated() });
+});
+// Sessões MCP ativas
+const sessions = new Map();
+// Endpoint MCP principal (POST inicia sessão, GET/DELETE gerencia)
+app.all("/mcp", async (req, res) => {
+    try {
+        // Reutilizar sessão existente se o header Mcp-Session-Id for enviado
+        const sessionId = req.headers["mcp-session-id"];
+        let transport = sessionId ? sessions.get(sessionId) : undefined;
+        if (!transport) {
+            // Nova sessão
+            const newId = randomUUID();
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => newId,
+                onsessioninitialized: (id) => {
+                    sessions.set(id, transport);
+                },
+            });
+            transport.onclose = () => {
+                sessions.delete(newId);
+            };
+            const server = createMcpServer();
+            await server.connect(transport);
+        }
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch (err) {
+        console.error("Erro no handler MCP:", err);
+        if (!res.headersSent) {
+            res.status(500).json({ error: "Erro interno do servidor." });
+        }
+    }
+});
+// ── Inicialização ─────────────────────────────────────────────────────────────
+async function main() {
+    // Login inicial ao subir o servidor
+    await ensureLoggedIn();
+    app.listen(PORT, () => {
+        console.log(`🚀 NEXT Finance MCP Server rodando na porta ${PORT}`);
+        console.log(`📡 Endpoint MCP: http://localhost:${PORT}/mcp`);
+        console.log(`❤️  Health check: http://localhost:${PORT}/health`);
+    });
+}
+main().catch((err) => { console.error("Erro fatal:", err); process.exit(1); });

package/dist/index.js

@@ -43,20 +43,33 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "listar_contas",
-            description: "Lista as contas da carteira selecionada.",
-            inputSchema: { type: "object", properties: {} },
+            description: "Lista as contas da carteira selecionada com suporte a filtro e paginação. " +
+                "Use 'busca' para filtrar por nome. Use 'pagina' e 'limite' para navegar em carteiras grandes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    busca: { type: "string", description: "Filtra contas cujo nome contenha este texto (ex: 'Inter', 'Bradesco')" },
+                    tipos: { type: "array", items: { type: "number" }, description: "Filtra por tipo(s) de conta (ex: [1, 2])" },
+                    pagina: { type: "number", description: "Página a retornar (começa em 1, padrão: 1)" },
+                    limite: { type: "number", description: "Contas por página (padrão: 30, máximo: 200)" },
+                },
+            },
         },
         {
             name: "buscar_lancamentos",
-            description: "Busca lançamentos/transações de uma conta. " +
-                "Use listar_contas para obter os IDs de conta disponíveis. " +
-                "Se não informar datas, retorna o mês atual.",
+            description: "Busca lançamentos/transações de uma conta com filtro e paginação. " +
+                "Use listar_contas para obter os IDs de conta. " +
+                "Se não informar datas, retorna o mês atual. " +
+                "Em períodos longos ou contas movimentadas, use 'pagina' para navegar.",
             inputSchema: {
                 type: "object",
                 properties: {
                     id_conta: { type: "string", description: "ID da conta (use listar_contas para descobrir)" },
                     data_inicio: { type: "string", description: "Data início YYYY-MM-DD (padrão: 1º do mês atual)" },
                     data_fim: { type: "string", description: "Data fim YYYY-MM-DD (padrão: hoje)" },
+                    busca: { type: "string", description: "Filtra lançamentos cuja descrição/histórico contenha este texto" },
+                    pagina: { type: "number", description: "Página a retornar (começa em 1, padrão: 1)" },
+                    limite: { type: "number", description: "Lançamentos por página (padrão: 50, máximo: 500)" },
                 },
                 required: ["id_conta"],
             },
@@ -117,7 +130,12 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
                 const walErr = requireWallet();
                 if (walErr)
                     return walErr;
-                return ok(await client.listarContas());
+                return ok(await client.listarContas({
+                    busca: args["busca"],
+                    tipos: args["tipos"],
+                    pagina: args["pagina"],
+                    limite: args["limite"],
+                }));
             }
             case "buscar_lancamentos": {
                 const authErr = requireAuth();
@@ -130,6 +148,9 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
                     idConta: args["id_conta"],
                     dataInicio: args["data_inicio"],
                     dataFim: args["data_fim"],
+                    busca: args["busca"],
+                    pagina: args["pagina"],
+                    limite: args["limite"],
                 }));
             }
             default:

package/dist/user-store.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Armazenamento persistente de usuários com credenciais criptografadas (AES-256-GCM).
+ * Cada usuário tem uma API key única gerada no registro.
+ */
+export interface UserRecord {
+    apiKey: string;
+    email: string;
+    encEmail: {
+        iv: string;
+        tag: string;
+        data: string;
+    };
+    encPassword: {
+        iv: string;
+        tag: string;
+        data: string;
+    };
+    createdAt: string;
+}
+/** Registra um novo usuário. Retorna a API key gerada. */
+export declare function registerUser(email: string, password: string): string;
+/** Retorna credenciais decifradas dado a API key. */
+export declare function getCredentials(apiKey: string): {
+    email: string;
+    password: string;
+} | null;
+/** Remove um usuário. */
+export declare function removeUser(apiKey: string): boolean;
+/** Conta total de usuários registrados. */
+export declare function userCount(): number;

package/dist/user-store.js

@@ -0,0 +1,110 @@
+/**
+ * Armazenamento persistente de usuários com credenciais criptografadas (AES-256-GCM).
+ * Cada usuário tem uma API key única gerada no registro.
+ */
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+const STORE_FILE = process.env.STORE_FILE ?? path.join(process.cwd(), "users.json");
+const ENCRYPTION_KEY_RAW = process.env.ENCRYPTION_KEY ?? "";
+if (!ENCRYPTION_KEY_RAW) {
+    console.error("❌ Variável de ambiente ENCRYPTION_KEY não definida.");
+    process.exit(1);
+}
+// Deriva uma chave de 32 bytes do valor fornecido
+const ENC_KEY = crypto.createHash("sha256").update(ENCRYPTION_KEY_RAW).digest();
+// ── Criptografia ─────────────────────────────────────────────────────────────
+function encrypt(text) {
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv("aes-256-gcm", ENC_KEY, iv);
+    const encrypted = Buffer.concat([cipher.update(text, "utf8"), cipher.final()]);
+    return {
+        iv: iv.toString("hex"),
+        tag: cipher.getAuthTag().toString("hex"),
+        data: encrypted.toString("hex"),
+    };
+}
+function decrypt(enc) {
+    const decipher = crypto.createDecipheriv("aes-256-gcm", ENC_KEY, Buffer.from(enc.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(enc.tag, "hex"));
+    return Buffer.concat([
+        decipher.update(Buffer.from(enc.data, "hex")),
+        decipher.final(),
+    ]).toString("utf8");
+}
+// ── Persistência ──────────────────────────────────────────────────────────────
+let store = new Map(); // apiKey → UserRecord
+function loadStore() {
+    try {
+        if (!fs.existsSync(STORE_FILE))
+            return;
+        const records = JSON.parse(fs.readFileSync(STORE_FILE, "utf-8"));
+        store = new Map(records.map(r => [r.apiKey, r]));
+        console.log(`📂 ${store.size} usuário(s) carregado(s) do arquivo.`);
+    }
+    catch (err) {
+        console.error("Erro ao carregar store:", err);
+    }
+}
+function saveStore() {
+    try {
+        fs.writeFileSync(STORE_FILE, JSON.stringify([...store.values()], null, 2), "utf-8");
+    }
+    catch (err) {
+        console.error("Erro ao salvar store:", err);
+    }
+}
+// Carrega ao importar
+loadStore();
+// ── API pública ───────────────────────────────────────────────────────────────
+/** Registra um novo usuário. Retorna a API key gerada. */
+export function registerUser(email, password) {
+    // Verifica se e-mail já existe
+    for (const r of store.values()) {
+        try {
+            if (decrypt(r.encEmail) === email) {
+                // Atualiza a senha e retorna a chave existente
+                r.encPassword = encrypt(password);
+                saveStore();
+                return r.apiKey;
+            }
+        }
+        catch { /* ignora registros corrompidos */ }
+    }
+    const apiKey = crypto.randomBytes(32).toString("hex");
+    const record = {
+        apiKey,
+        email: email.split("@")[0] + "@***", // ofuscado no arquivo
+        encEmail: encrypt(email),
+        encPassword: encrypt(password),
+        createdAt: new Date().toISOString(),
+    };
+    store.set(apiKey, record);
+    saveStore();
+    return apiKey;
+}
+/** Retorna credenciais decifradas dado a API key. */
+export function getCredentials(apiKey) {
+    const record = store.get(apiKey);
+    if (!record)
+        return null;
+    try {
+        return {
+            email: decrypt(record.encEmail),
+            password: decrypt(record.encPassword),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove um usuário. */
+export function removeUser(apiKey) {
+    if (!store.has(apiKey))
+        return false;
+    store.delete(apiKey);
+    saveStore();
+    return true;
+}
+/** Conta total de usuários registrados. */
+export function userCount() { return store.size; }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "next-finance-mcp",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "mcpName": "io.github.paivapiovesan/next-finance",
   "description": "MCP Server para o NEXT Finance (finance.net.br) — login via browser, listagem de carteiras, contas e lançamentos",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "next-finance-mcp": "dist/index.js"
+    "next-finance-mcp": "dist/index.js",
+    "next-finance-mcp-server": "dist/http-index.js"
   },
   "files": [
     "dist"
@@ -15,6 +16,7 @@
     "build": "tsc",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
+    "start:server": "node dist/http-index.js",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -36,9 +38,11 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "express": "^5.2.1"
   },
   "devDependencies": {
+    "@types/express": "^5.0.6",
     "@types/node": "^22.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"