@warmio/mcp 1.0.0 → 1.0.1

package/README.md

@@ -2,97 +2,53 @@
 
 MCP server that gives Claude Code (or any MCP client) read-only access to your Warm financial data.
 
-## Quick Install
+## Quick Start
 
 ```bash
 npx @warmio/mcp
 ```
 
-Works on macOS, Linux, and Windows. Auto-configures: Claude Code, Cursor, Windsurf, Claude Desktop, OpenCode, Codex CLI, Antigravity, Gemini CLI.
+Detects installed MCP clients, prompts for your API key, and configures everything automatically.
+Works on macOS, Linux, and Windows. Supports: Claude Code, Claude Desktop, Cursor, Windsurf, OpenCode, Codex CLI, Antigravity, Gemini CLI.
 
-## Manual Installation
-
-### Claude Code (easiest)
-
-```bash
-claude mcp add --scope user --env WARM_API_KEY=your-key warm -- npx -y @warmio/mcp
-```
-
-### Other Tools
-
-Add to your tool's MCP config file:
-
-| Tool           | Config Path                                                       | Format |
-| -------------- | ----------------------------------------------------------------- | ------ |
-| Claude Code    | `~/.claude.json`                                                  | JSON   |
-| Cursor         | `~/.cursor/mcp.json`                                              | JSON   |
-| Windsurf       | `~/.codeium/windsurf/mcp_config.json`                             | JSON   |
-| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` | JSON   |
-| OpenCode       | `~/.config/opencode/opencode.json`                                | JSON   |
-| Codex CLI      | `~/.codex/config.toml`                                            | TOML   |
-| Antigravity    | `~/.gemini/antigravity/mcp_config.json`                           | JSON   |
-| Gemini CLI     | `~/.gemini/settings.json`                                         | JSON   |
-
-**JSON format** (most tools):
-
-```json
-{
-  "mcpServers": {
-    "warm": {
-      "command": "npx",
-      "args": ["-y", "@warmio/mcp"],
-      "env": { "WARM_API_KEY": "your-api-key" }
-    }
-  }
-}
-```
-
-**TOML format** (Codex CLI):
-
-```toml
-[mcp_servers.warm]
-command = "npx"
-args = ["-y", "@warmio/mcp"]
+After setup, open your MCP client and ask:
+- "What's my net worth?"
+- "How much did I spend on restaurants last month?"
+- "Show me my subscriptions"
 
-[mcp_servers.warm.env]
-WARM_API_KEY = "your-api-key"
-```
+## Options
 
-Get your API key from [warm.io/settings](https://warm.io/settings) → API Keys.
+| Command | Description |
+|---------|-------------|
+| `npx @warmio/mcp` | Run the installer / configurator |
+| `npx @warmio/mcp --force` | Re-run installer (updates API key in all configs) |
+| `npx @warmio/mcp --server` | Start the MCP server (used internally by clients) |
 
 ## Requirements
 
 - **Pro subscription** — API access requires Warm Pro
-- **API key** — Generate in Settings → API Keys
+- **API key** — Generate in [Settings → API Keys](https://warm.io/settings)
 - **Node.js 18+** — For running the MCP server
 
-## Available Tools
+## How It Works
 
-| Tool               | Description                                    |
-| ------------------ | ---------------------------------------------- |
-| `get_accounts`     | List all connected bank accounts with balances |
-| `get_transactions` | Get transactions with date/limit filters       |
-| `get_recurring`    | Show subscriptions and recurring payments      |
-| `get_snapshots`    | Net worth history (daily or monthly)           |
-| `verify_key`       | Check if API key is valid                      |
+1. You run `npx @warmio/mcp` once
+2. It detects which MCP clients you have installed
+3. Prompts for your Warm API key
+4. Writes the server config into each client's settings
+5. Each client is configured to run `npx -y @warmio/mcp --server` on demand
 
-## Usage
+The MCP server starts automatically when your client needs it — you never run it manually.
 
-Once configured, just ask Claude naturally:
-
-- "How much did I spend on restaurants last month?"
-- "What's my net worth?"
-- "Show my subscriptions"
-- "What are my biggest expenses?"
-
-Claude will automatically use the MCP tools to query your data.
-
-## Configuration
+## Available Tools
 
-| Environment Variable | Description                  | Default           |
-| -------------------- | ---------------------------- | ----------------- |
-| `WARM_API_KEY`       | Your Warm API key (required) | —                 |
-| `WARM_API_URL`       | API base URL                 | `https://warm.io` |
+| Tool | Description |
+|------|-------------|
+| `get_accounts` | List all connected bank accounts with balances |
+| `get_transactions` | Get transactions with date/limit filters |
+| `get_recurring` | Show subscriptions and recurring payments |
+| `get_snapshots` | Net worth history (daily or monthly) |
+| `verify_key` | Check if API key is valid |
 
 ## Security
 

package/dist/index.d.ts

@@ -1,8 +1,2 @@
 #!/usr/bin/env node
-/**
- * Warm MCP Server
- *
- * Provides financial data from the Warm API as MCP tools.
- * Reads API key from ~/.config/warm/api_key or WARM_API_KEY env var.
- */
 export {};

package/dist/index.js

@@ -1,230 +1,10 @@
 #!/usr/bin/env node
-/**
- * Warm MCP Server
- *
- * Provides financial data from the Warm API as MCP tools.
- * Reads API key from ~/.config/warm/api_key or WARM_API_KEY env var.
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-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';
-function getApiKey() {
-    // Environment variable takes precedence
-    if (process.env.WARM_API_KEY) {
-        return process.env.WARM_API_KEY;
-    }
-    // Fall back to config file
-    const configPath = path.join(os.homedir(), '.config', 'warm', 'api_key');
-    try {
-        return fs.readFileSync(configPath, 'utf-8').trim();
-    }
-    catch {
-        return null;
-    }
+const args = process.argv.slice(2);
+if (args.includes('--server')) {
+    await import('./server.js');
 }
-async function apiRequest(endpoint, params = {}) {
-    const apiKey = getApiKey();
-    if (!apiKey) {
-        throw new Error('WARM_API_KEY not set. Add your API key from https://warm.io/settings');
-    }
-    const url = new URL(endpoint, API_URL);
-    Object.entries(params).forEach(([key, value]) => {
-        if (value)
-            url.searchParams.append(key, value);
-    });
-    const response = await fetch(url.toString(), {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            Accept: 'application/json',
-        },
-    });
-    if (!response.ok) {
-        const errorMessages = {
-            401: 'Invalid or expired API key. Regenerate at https://warm.io/settings',
-            403: 'Pro subscription required. Upgrade at https://warm.io/settings',
-            429: 'Rate limit exceeded. Try again in a few minutes.',
-        };
-        throw new Error(errorMessages[response.status] || `HTTP ${response.status}`);
-    }
-    return response.json();
+else {
+    const { install } = await import('./install.js');
+    await install();
 }
-const server = new Server({ name: 'warm', version: '1.0.0' }, { 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.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    since: {
-                        type: 'string',
-                        description: 'Filter accounts updated since this date (ISO format)',
-                    },
-                },
-            },
-        },
-        {
-            name: 'get_transactions',
-            description: 'Get transactions from connected accounts. Supports pagination and date filtering.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    limit: {
-                        type: 'number',
-                        description: 'Maximum number of transactions to return (default: 100)',
-                    },
-                    since: {
-                        type: 'string',
-                        description: 'Get transactions since this date (ISO format, e.g., 2024-01-01)',
-                    },
-                    cursor: {
-                        type: 'string',
-                        description: 'Pagination cursor for fetching more results',
-                    },
-                },
-            },
-        },
-        {
-            name: 'get_recurring',
-            description: 'Get recurring payments and subscriptions detected from transaction history.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    since: {
-                        type: 'string',
-                        description: 'Filter recurring items detected since this date',
-                    },
-                },
-            },
-        },
-        {
-            name: 'get_snapshots',
-            description: 'Get net worth snapshots over time (daily or monthly aggregation).',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    granularity: {
-                        type: 'string',
-                        enum: ['daily', 'monthly'],
-                        description: 'Aggregation level (default: daily)',
-                    },
-                    limit: {
-                        type: 'number',
-                        description: 'Number of snapshots to return',
-                    },
-                    since: {
-                        type: 'string',
-                        description: 'Start date for snapshots (ISO format)',
-                    },
-                },
-            },
-        },
-        {
-            name: 'verify_key',
-            description: 'Check if the Warm API key is valid and working.',
-            inputSchema: {
-                type: 'object',
-                properties: {},
-            },
-        },
-    ],
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    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) }] };
-            }
-            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) }] };
-            }
-            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) }] };
-            }
-            case 'get_snapshots': {
-                // Fetch transactions which includes snapshots
-                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 since = args?.since;
-                let filtered = snapshots;
-                if (since) {
-                    filtered = filtered.filter((s) => String(s.snapshot_date) >= since);
-                }
-                if (granularity === 'monthly') {
-                    // Group by month, take last snapshot of each month
-                    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)) {
-                            byMonth.set(month, s);
-                        }
-                    });
-                    filtered = Array.from(byMonth.values());
-                }
-                // Sort descending and limit
-                filtered.sort((a, b) => String(b.snapshot_date).localeCompare(String(a.snapshot_date)));
-                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) }] };
-            }
-            case 'verify_key': {
-                const data = await apiRequest('/api/verify');
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
-            isError: true,
-        };
-    }
-});
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}
-main().catch(console.error);
+export {};

package/dist/install.d.ts

@@ -0,0 +1 @@
+export declare function install(): Promise<void>;

package/dist/install.js

@@ -0,0 +1,140 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir, platform } from 'os';
+import { createInterface } from 'readline';
+const HOME = homedir();
+function getClaudeDesktopPath() {
+    if (platform() === 'win32') {
+        return join(process.env.APPDATA || join(HOME, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    }
+    if (platform() === 'darwin') {
+        return join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    return join(HOME, '.config', 'claude', 'claude_desktop_config.json');
+}
+const ALL_CLIENTS = [
+    { name: 'Claude Code', configPath: join(HOME, '.claude.json'), format: 'json', alwaysInclude: true },
+    { name: 'Claude Desktop', configPath: getClaudeDesktopPath(), format: 'json' },
+    { name: 'Cursor', configPath: join(HOME, '.cursor', 'mcp.json'), format: 'json' },
+    { name: 'Windsurf', configPath: join(HOME, '.codeium', 'windsurf', 'mcp_config.json'), format: 'json' },
+    { name: 'OpenCode', configPath: join(HOME, '.config', 'opencode', 'opencode.json'), format: 'json' },
+    { name: 'Codex CLI', configPath: join(HOME, '.codex', 'config.toml'), format: 'toml' },
+    { name: 'Antigravity', configPath: join(HOME, '.gemini', 'antigravity', 'mcp_config.json'), format: 'json' },
+    { name: 'Gemini CLI', configPath: join(HOME, '.gemini', 'settings.json'), format: 'json' },
+];
+const MCP_CONFIG = {
+    command: 'npx',
+    args: ['-y', '@warmio/mcp', '--server'],
+};
+function isDetected(client) {
+    if (client.alwaysInclude)
+        return true;
+    return existsSync(dirname(client.configPath));
+}
+function isConfigured(client) {
+    if (!existsSync(client.configPath))
+        return false;
+    try {
+        const content = readFileSync(client.configPath, 'utf-8');
+        if (client.format === 'toml')
+            return content.includes('[mcp_servers.warm]');
+        return !!JSON.parse(content)?.mcpServers?.warm;
+    }
+    catch {
+        return false;
+    }
+}
+function configureJson(client, apiKey) {
+    let config = {};
+    if (existsSync(client.configPath)) {
+        try {
+            config = JSON.parse(readFileSync(client.configPath, 'utf-8'));
+        }
+        catch { /* start fresh */ }
+    }
+    if (!config.mcpServers)
+        config.mcpServers = {};
+    config.mcpServers.warm = {
+        ...MCP_CONFIG,
+        env: { WARM_API_KEY: apiKey },
+    };
+    mkdirSync(dirname(client.configPath), { recursive: true });
+    writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n');
+}
+function configureToml(client, apiKey) {
+    let content = '';
+    if (existsSync(client.configPath)) {
+        content = readFileSync(client.configPath, 'utf-8');
+        if (!content.endsWith('\n'))
+            content += '\n';
+    }
+    content += `\n[mcp_servers.warm]\ncommand = "npx"\nargs = ["-y", "@warmio/mcp", "--server"]\n\n[mcp_servers.warm.env]\nWARM_API_KEY = "${apiKey}"\n`;
+    mkdirSync(dirname(client.configPath), { recursive: true });
+    writeFileSync(client.configPath, content);
+}
+function configure(client, apiKey) {
+    if (client.format === 'json')
+        configureJson(client, apiKey);
+    else
+        configureToml(client, apiKey);
+}
+function shortPath(p) {
+    return p.replace(HOME, '~');
+}
+function prompt(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function install() {
+    const force = process.argv.includes('--force');
+    console.log('');
+    console.log('  Warm MCP Server Installer');
+    console.log('  -------------------------');
+    console.log('');
+    const detected = ALL_CLIENTS.filter(isDetected);
+    const needsSetup = detected.filter((c) => !isConfigured(c) || force);
+    // Show detected clients and their status
+    console.log('  MCP clients found:');
+    detected.forEach((client) => {
+        const configured = isConfigured(client);
+        const status = configured && !force ? 'configured' : 'not configured';
+        console.log(`    ${client.name.padEnd(18)} ${shortPath(client.configPath).padEnd(60)} ${status}`);
+    });
+    console.log('');
+    // Nothing to do
+    if (needsSetup.length === 0) {
+        console.log('  All clients already configured!');
+        console.log('  Run with --force to update the API key.');
+        console.log('');
+        return;
+    }
+    // Prompt for API key
+    const apiKey = await prompt('  Warm API key: ');
+    if (!apiKey) {
+        console.log('');
+        console.log('  No key provided. Get one at https://warm.io/settings');
+        console.log('');
+        return;
+    }
+    console.log('');
+    console.log('  Configuring...');
+    console.log('');
+    needsSetup.forEach((client) => {
+        try {
+            configure(client, apiKey);
+            console.log(`    ${client.name.padEnd(18)} done`);
+        }
+        catch (err) {
+            console.log(`    ${client.name.padEnd(18)} failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    console.log('');
+    console.log('  All set! Restart your MCP clients and try:');
+    console.log('    "What\'s my net worth?"');
+    console.log('');
+}

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Warm MCP Server
+ *
+ * Provides financial data from the Warm API as MCP tools.
+ * Reads API key from WARM_API_KEY env var or ~/.config/warm/api_key.
+ */
+export {};

package/dist/server.js

@@ -0,0 +1,221 @@
+/**
+ * Warm MCP Server
+ *
+ * Provides financial data from the Warm API as MCP tools.
+ * Reads API key from WARM_API_KEY env var or ~/.config/warm/api_key.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+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';
+function getApiKey() {
+    if (process.env.WARM_API_KEY) {
+        return process.env.WARM_API_KEY;
+    }
+    const configPath = path.join(os.homedir(), '.config', 'warm', 'api_key');
+    try {
+        return fs.readFileSync(configPath, 'utf-8').trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function apiRequest(endpoint, params = {}) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        throw new Error('WARM_API_KEY not set. Run "npx @warmio/mcp" to configure.');
+    }
+    const url = new URL(endpoint, API_URL);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value)
+            url.searchParams.append(key, value);
+    });
+    const response = await fetch(url.toString(), {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        const errorMessages = {
+            401: 'Invalid or expired API key. Regenerate at https://warm.io/settings',
+            403: 'Pro subscription required. Upgrade at https://warm.io/settings',
+            429: 'Rate limit exceeded. Try again in a few minutes.',
+        };
+        throw new Error(errorMessages[response.status] || `HTTP ${response.status}`);
+    }
+    return response.json();
+}
+const server = new Server({ name: 'warm', version: '1.0.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.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    since: {
+                        type: 'string',
+                        description: 'Filter accounts updated since this date (ISO format)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_transactions',
+            description: 'Get transactions from connected accounts. Supports pagination and date filtering.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of transactions to return (default: 100)',
+                    },
+                    since: {
+                        type: 'string',
+                        description: 'Get transactions since this date (ISO format, e.g., 2024-01-01)',
+                    },
+                    cursor: {
+                        type: 'string',
+                        description: 'Pagination cursor for fetching more results',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_recurring',
+            description: 'Get recurring payments and subscriptions detected from transaction history.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    since: {
+                        type: 'string',
+                        description: 'Filter recurring items detected since this date',
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_snapshots',
+            description: 'Get net worth snapshots over time (daily or monthly aggregation).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    granularity: {
+                        type: 'string',
+                        enum: ['daily', 'monthly'],
+                        description: 'Aggregation level (default: daily)',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Number of snapshots to return',
+                    },
+                    since: {
+                        type: 'string',
+                        description: 'Start date for snapshots (ISO format)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'verify_key',
+            description: 'Check if the Warm API key is valid and working.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    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) }] };
+            }
+            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) }] };
+            }
+            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) }] };
+            }
+            case 'get_snapshots': {
+                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 since = args?.since;
+                let filtered = snapshots;
+                if (since) {
+                    filtered = filtered.filter((s) => String(s.snapshot_date) >= since);
+                }
+                if (granularity === 'monthly') {
+                    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)) {
+                            byMonth.set(month, s);
+                        }
+                    });
+                    filtered = Array.from(byMonth.values());
+                }
+                filtered.sort((a, b) => String(b.snapshot_date).localeCompare(String(a.snapshot_date)));
+                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) }] };
+            }
+            case 'verify_key': {
+                const data = await apiRequest('/api/verify');
+                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
+            isError: true,
+        };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

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