@warmio/mcp 1.0.3 → 1.2.1

package/dist/install.js

@@ -4,6 +4,9 @@ import { homedir, platform } from 'os';
 import { createInterface } from 'readline';
 const HOME = homedir();
 const CWD = process.cwd();
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function getClaudeDesktopPath() {
     if (platform() === 'win32') {
         return join(process.env.APPDATA || join(HOME, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
@@ -74,14 +77,14 @@ function configureJson(client, apiKey) {
     if (!config.mcpServers)
         config.mcpServers = {};
     const servers = config.mcpServers;
-    const existing = servers.warm;
+    const existing = isRecord(servers.warm) ? servers.warm : undefined;
+    const existingEnv = isRecord(existing?.env) ? existing.env : {};
     // For project-level configs, preserve existing command/args if present — only inject the key.
     if (client.isProjectLevel && existing?.command) {
-        existing.env = { WARM_API_KEY: apiKey };
-        servers.warm = existing;
+        servers.warm = { ...existing, env: { ...existingEnv, WARM_API_KEY: apiKey } };
     }
     else {
-        servers.warm = { ...MCP_CONFIG, env: { WARM_API_KEY: apiKey } };
+        servers.warm = { ...existing, ...MCP_CONFIG, env: { ...existingEnv, WARM_API_KEY: apiKey } };
     }
     mkdirSync(dirname(client.configPath), { recursive: true });
     writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n');
@@ -97,9 +100,15 @@ function configureToml(client, apiKey) {
     const tomlArgs = platform() === 'win32'
         ? '["/c", "npx", "-y", "@warmio/mcp", "--server"]'
         : '["-y", "@warmio/mcp", "--server"]';
-    content += `\n[mcp_servers.warm]\ncommand = "${tomlCommand}"\nargs = ${tomlArgs}\n\n[mcp_servers.warm.env]\nWARM_API_KEY = "${apiKey}"\n`;
+    const warmBlock = `[mcp_servers.warm]\ncommand = "${tomlCommand}"\nargs = ${tomlArgs}\n\n[mcp_servers.warm.env]\nWARM_API_KEY = "${apiKey}"\n`;
+    const warmBlockPattern = /\n?\[mcp_servers\.warm\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
+    let nextContent = content.replace(warmBlockPattern, '').trimEnd();
+    if (nextContent.length > 0) {
+        nextContent += '\n\n';
+    }
+    nextContent += warmBlock;
     mkdirSync(dirname(client.configPath), { recursive: true });
-    writeFileSync(client.configPath, content);
+    writeFileSync(client.configPath, nextContent.endsWith('\n') ? nextContent : `${nextContent}\n`);
 }
 function configure(client, apiKey) {
     if (client.format === 'json')

package/dist/server.js

@@ -11,17 +11,72 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 const API_URL = process.env.WARM_API_URL || 'https://warm.io';
+const MAX_RESPONSE_SIZE = 50_000;
+const MAX_TRANSACTION_PAGES = 10;
+const MAX_TRANSACTION_SCAN = 5_000;
+const TRANSACTION_PAGE_SIZE = 200;
+const REQUEST_TIMEOUT_MS = (() => {
+    const raw = Number(process.env.WARM_API_TIMEOUT_MS || 10_000);
+    return Number.isFinite(raw) && raw > 0 ? raw : 10_000;
+})();
+let cachedApiKey;
+function compactTransaction(t) {
+    return {
+        d: t.date,
+        a: t.amount,
+        m: t.merchant_name || t.name || 'Unknown',
+        c: t.category || null,
+    };
+}
+function matchesSearch(t, search) {
+    const s = search.toLowerCase();
+    const merchant = (t.merchant_name || t.name || '').toLowerCase();
+    const category = (t.category || '').toLowerCase();
+    return merchant.includes(s) || category.includes(s);
+}
+function inDateRange(t, since, until) {
+    if (since && t.date < since)
+        return false;
+    if (until && t.date > until)
+        return false;
+    return true;
+}
+function calculateSummary(transactions) {
+    if (transactions.length === 0) {
+        return { total: 0, count: 0, avg: 0 };
+    }
+    const total = transactions.reduce((sum, t) => sum + t.a, 0);
+    return {
+        total: Math.round(total * 100) / 100,
+        count: transactions.length,
+        avg: Math.round((total / transactions.length) * 100) / 100,
+    };
+}
 function getApiKey() {
+    if (cachedApiKey !== undefined) {
+        return cachedApiKey;
+    }
     if (process.env.WARM_API_KEY) {
-        return process.env.WARM_API_KEY;
+        cachedApiKey = process.env.WARM_API_KEY;
+        return cachedApiKey;
     }
     const configPath = path.join(os.homedir(), '.config', 'warm', 'api_key');
     try {
-        return fs.readFileSync(configPath, 'utf-8').trim();
+        cachedApiKey = fs.readFileSync(configPath, 'utf-8').trim();
     }
     catch {
-        return null;
+        cachedApiKey = null;
     }
+    return cachedApiKey;
+}
+function getRequestSignal(timeoutMs) {
+    if (typeof AbortSignal.timeout === 'function') {
+        return AbortSignal.timeout(timeoutMs);
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    return controller.signal;
 }
 async function apiRequest(endpoint, params = {}) {
     const apiKey = getApiKey();
@@ -33,12 +88,25 @@ async function apiRequest(endpoint, params = {}) {
         if (value)
             url.searchParams.append(key, value);
     });
-    const response = await fetch(url.toString(), {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            Accept: 'application/json',
-        },
-    });
+    let response;
+    try {
+        response = await fetch(url.toString(), {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                Accept: 'application/json',
+            },
+            signal: getRequestSignal(REQUEST_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'TimeoutError') {
+            throw new Error(`Warm API timed out after ${REQUEST_TIMEOUT_MS}ms`);
+        }
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Warm API request aborted after ${REQUEST_TIMEOUT_MS}ms`);
+        }
+        throw error;
+    }
     if (!response.ok) {
         const errorMessages = {
             401: 'Invalid or expired API key. Regenerate at https://warm.io/settings',
@@ -49,85 +117,84 @@ async function apiRequest(endpoint, params = {}) {
     }
     return response.json();
 }
-const server = new Server({ name: 'warm', version: '1.0.3' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'warm', version: '1.2.1' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: 'get_accounts',
-            description: 'Get all connected bank accounts with balances. Returns account names, types, balances, and institutions.',
+            description: 'Get all connected bank accounts with balances. Use for: "What accounts do I have?", "What is my checking balance?", "Show my credit cards". Returns: array of {name, type, balance, institution}.',
             inputSchema: {
                 type: 'object',
-                properties: {
-                    since: {
-                        type: 'string',
-                        description: 'Filter accounts updated since this date (ISO format)',
-                    },
-                },
+                properties: {},
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'get_transactions',
-            description: 'Get transactions from connected accounts. Supports pagination and date filtering.',
+            description: 'Search and analyze transactions. Use for: "How much did I spend on X?", "Show my Amazon purchases", "What did I buy last month?". Returns: {summary: {total, count, avg}, txns: [{d, a, m, c}]} where d=date, a=amount, m=merchant, c=category.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    limit: {
-                        type: 'number',
-                        description: 'Maximum number of transactions to return (default: 100)',
+                    search: {
+                        type: 'string',
+                        description: 'Filter by merchant or category (e.g., "coffee", "amazon", "groceries")',
                     },
                     since: {
                         type: 'string',
-                        description: 'Get transactions since this date (ISO format, e.g., 2024-01-01)',
+                        description: 'Start date inclusive (YYYY-MM-DD)',
                     },
-                    cursor: {
+                    until: {
                         type: 'string',
-                        description: 'Pagination cursor for fetching more results',
+                        description: 'End date inclusive (YYYY-MM-DD)',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max transactions (default: 50, max: 200)',
                     },
                 },
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'get_recurring',
-            description: 'Get recurring payments and subscriptions detected from transaction history.',
+            description: 'Get detected subscriptions and recurring payments. Use for: "What subscriptions do I have?", "Show my monthly bills", "What are my recurring charges?". Returns: {recurring: [{merchant, amount, frequency, next_date}]}.',
             inputSchema: {
                 type: 'object',
-                properties: {
-                    since: {
-                        type: 'string',
-                        description: 'Filter recurring items detected since this date',
-                    },
-                },
+                properties: {},
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'get_snapshots',
-            description: 'Get net worth snapshots over time (daily or monthly aggregation).',
+            description: 'Get net worth history over time. Use for: "How has my net worth changed?", "Show my financial progress", "What was my balance last month?". Returns: {snapshots: [{d, nw, a, l}]} where nw=net_worth, a=assets, l=liabilities.',
             inputSchema: {
                 type: 'object',
                 properties: {
                     granularity: {
                         type: 'string',
                         enum: ['daily', 'monthly'],
-                        description: 'Aggregation level (default: daily)',
+                        description: 'daily or monthly (default: daily)',
                     },
                     limit: {
                         type: 'number',
-                        description: 'Number of snapshots to return',
+                        description: 'Number of snapshots (default: 30)',
                     },
                     since: {
                         type: 'string',
-                        description: 'Start date for snapshots (ISO format)',
+                        description: 'Start date (YYYY-MM-DD)',
                     },
                 },
             },
+            annotations: { readOnlyHint: true },
         },
         {
             name: 'verify_key',
-            description: 'Check if the Warm API key is valid and working.',
+            description: 'Check if API key is valid and working.',
             inputSchema: {
                 type: 'object',
                 properties: {},
             },
+            annotations: { readOnlyHint: true },
         },
     ],
 }));
@@ -136,37 +203,80 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (name) {
             case 'get_accounts': {
-                const params = {};
-                if (args?.since)
-                    params.since = String(args.since);
-                const data = await apiRequest('/api/accounts', params);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                const data = await apiRequest('/api/accounts');
+                return { content: [{ type: 'text', text: JSON.stringify(data) }] };
             }
             case 'get_transactions': {
-                const params = {};
-                if (args?.limit)
-                    params.limit = String(args.limit);
-                if (args?.since)
-                    params.last_knowledge = String(args.since);
-                if (args?.cursor)
-                    params.cursor = String(args.cursor);
-                const data = await apiRequest('/api/transactions', params);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                const search = args?.search ? String(args.search) : undefined;
+                const since = args?.since ? String(args.since) : undefined;
+                const until = args?.until ? String(args.until) : undefined;
+                const parsedLimit = args?.limit ? Number(args.limit) : 50;
+                const requestedLimit = Number.isFinite(parsedLimit)
+                    ? Math.max(1, Math.min(Math.floor(parsedLimit), 200))
+                    : 50;
+                const needsClientFiltering = Boolean(search || until);
+                let transactions = [];
+                let cursor;
+                let pagesFetched = 0;
+                let scanned = 0;
+                do {
+                    const params = {
+                        limit: String(needsClientFiltering ? TRANSACTION_PAGE_SIZE : requestedLimit),
+                    };
+                    if (since)
+                        params.last_knowledge = since;
+                    if (cursor)
+                        params.cursor = cursor;
+                    const response = (await apiRequest('/api/transactions', params));
+                    const batch = (response.transactions || []);
+                    transactions.push(...batch);
+                    scanned += batch.length;
+                    pagesFetched += 1;
+                    cursor = response.cursor;
+                    if (!needsClientFiltering) {
+                        break;
+                    }
+                } while (cursor && pagesFetched < MAX_TRANSACTION_PAGES && scanned < MAX_TRANSACTION_SCAN);
+                // Apply date range filter (until is client-side since API only supports since)
+                if (until) {
+                    transactions = transactions.filter((t) => inDateRange(t, since, until));
+                }
+                // Apply search filter
+                if (search) {
+                    transactions = transactions.filter((t) => matchesSearch(t, search));
+                }
+                const compactTxns = transactions.map(compactTransaction);
+                // Calculate summary on ALL matching transactions
+                const summary = calculateSummary(compactTxns);
+                // Apply limit for display
+                const limited = compactTxns.slice(0, requestedLimit);
+                const truncated = compactTxns.length > requestedLimit;
+                // Build compact result
+                const result = { summary, txns: limited };
+                if (truncated) {
+                    result.more = compactTxns.length - requestedLimit;
+                }
+                // Size check and reduce if needed
+                let output = JSON.stringify(result);
+                if (output.length > MAX_RESPONSE_SIZE) {
+                    const reducedCount = Math.floor(limited.length * (MAX_RESPONSE_SIZE / output.length) * 0.8);
+                    result.txns = limited.slice(0, reducedCount);
+                    result.more = compactTxns.length - reducedCount;
+                    output = JSON.stringify(result);
+                }
+                return { content: [{ type: 'text', text: output }] };
             }
             case 'get_recurring': {
-                const params = {};
-                if (args?.since)
-                    params.since = String(args.since);
-                const data = await apiRequest('/api/recurring', params);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                const response = (await apiRequest('/api/transactions', { limit: '1' }));
+                const recurring = response.recurring || [];
+                return { content: [{ type: 'text', text: JSON.stringify({ recurring }) }] };
             }
             case 'get_snapshots': {
-                const response = (await apiRequest('/api/transactions', {
-                    limit: '1',
-                }));
+                const response = (await apiRequest('/api/transactions', { limit: '1' }));
                 const snapshots = response.snapshots || [];
                 const granularity = args?.granularity || 'daily';
-                const limit = args?.limit ? Number(args.limit) : granularity === 'daily' ? 100 : 0;
+                const defaultLimit = granularity === 'daily' ? 30 : 0;
+                const limit = args?.limit ? Number(args.limit) : defaultLimit;
                 const since = args?.since;
                 let filtered = snapshots;
                 if (since) {
@@ -176,8 +286,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const byMonth = new Map();
                     filtered.forEach((s) => {
                         const month = String(s.snapshot_date).substring(0, 7);
-                        if (!byMonth.has(month) ||
-                            String(s.snapshot_date) > String(byMonth.get(month).snapshot_date)) {
+                        if (!byMonth.has(month) || String(s.snapshot_date) > String(byMonth.get(month).snapshot_date)) {
                             byMonth.set(month, s);
                         }
                     });
@@ -187,23 +296,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (limit > 0) {
                     filtered = filtered.slice(0, limit);
                 }
-                const result = {
-                    granularity,
-                    snapshots: filtered.map((s) => ({
-                        date: s.snapshot_date,
-                        ...(granularity === 'monthly' && {
-                            month: String(s.snapshot_date).substring(0, 7),
-                        }),
-                        net_worth: s.net_worth,
-                        total_assets: s.total_assets,
-                        total_liabilities: s.total_liabilities,
-                    })),
-                };
-                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                // Compact output
+                const result = filtered.map((s) => ({
+                    d: s.snapshot_date,
+                    nw: s.net_worth,
+                    a: s.total_assets,
+                    l: s.total_liabilities,
+                }));
+                return { content: [{ type: 'text', text: JSON.stringify({ granularity, snapshots: result }) }] };
             }
             case 'verify_key': {
                 const data = await apiRequest('/api/verify');
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+                return { content: [{ type: 'text', text: JSON.stringify(data) }] };
             }
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -212,7 +316,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
-            content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
+            content: [{ type: 'text', text: JSON.stringify({ error: message }) }],
             isError: true,
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warmio/mcp",
-  "version": "1.0.3",
+  "version": "1.2.1",
   "description": "MCP server for Warm Financial API",
   "type": "module",
   "main": "dist/index.js",