@warmio/mcp 1.2.0 → 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

@@ -12,6 +12,14 @@ 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,
@@ -45,16 +53,30 @@ function calculateSummary(transactions) {
     };
 }
 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();
@@ -66,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',
@@ -82,7 +117,7 @@ async function apiRequest(endpoint, params = {}) {
     }
     return response.json();
 }
-const server = new Server({ name: 'warm', version: '1.2.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'warm', version: '1.2.1' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
@@ -175,14 +210,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 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 requestedLimit = args?.limit ? Math.min(Number(args.limit), 200) : 50;
-                // Fetch more if filtering, since we'll reduce the set
-                const fetchLimit = search || until ? Math.min(requestedLimit * 10, 1000) : requestedLimit;
-                const params = { limit: String(fetchLimit) };
-                if (since)
-                    params.last_knowledge = since;
-                const response = (await apiRequest('/api/transactions', params));
-                let transactions = (response.transactions || []);
+                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));
@@ -191,7 +245,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (search) {
                     transactions = transactions.filter((t) => matchesSearch(t, search));
                 }
-                // Convert to compact format
                 const compactTxns = transactions.map(compactTransaction);
                 // Calculate summary on ALL matching transactions
                 const summary = calculateSummary(compactTxns);

package/package.json

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