@warmio/mcp 4.2.2 → 4.3.2

package/README.md

@@ -2,18 +2,22 @@
 
 Read-only MCP server for Warm financial data.
 
-This package supports local `stdio` transport only.
+This package starts in local `stdio` mode by default and also supports optional Streamable HTTP.
 
 ## Install
 
 ```bash
-npx @warmio/mcp
+npx -y @warmio/mcp@latest
 ```
 
 The installer detects supported MCP clients, prompts for your Warm API key, and writes the local
 `stdio` server config automatically. The key is stored once in your local Warm profile instead of
 being duplicated into every MCP client config.
 
+Use `@latest` when you want the newest published package. Bare `npx @warmio/mcp` can reuse a
+cached or local copy and leave you on an older version. If you want a deterministic install,
+replace `@latest` with an exact version such as `@warmio/mcp@4.3.2`.
+
 When launched without arguments in a non-interactive context, the binary automatically starts the
 `stdio` server instead of the installer. This keeps MCP clients that invoke the package directly
 from falling into the interactive setup flow.
@@ -34,12 +38,15 @@ stay secret-free:
   "mcpServers": {
     "warm": {
       "command": "npx",
-      "args": ["-y", "@warmio/mcp", "--server"]
+      "args": ["-y", "@warmio/mcp@latest", "--server"]
     }
   }
 }
 ```
 
+If you already have a client config that uses bare `@warmio/mcp`, update it to `@warmio/mcp@latest`
+or an exact version and restart the client.
+
 Optional auth overrides:
 
 - `WARM_API_KEY`
@@ -52,12 +59,27 @@ On Windows, prefer:
   "mcpServers": {
     "warm": {
       "command": "cmd",
-      "args": ["/c", "npx", "-y", "@warmio/mcp", "--server"]
+      "args": ["/c", "npx", "-y", "@warmio/mcp@latest", "--server"]
     }
   }
 }
 ```
 
+## Optional Streamable HTTP
+
+If your MCP client supports Streamable HTTP, you can run:
+
+```bash
+npx -y @warmio/mcp@latest http --host 127.0.0.1 --port 3000 --path /mcp
+```
+
+Relevant optional environment variables:
+
+- `WARM_MCP_HTTP_HOST`
+- `WARM_MCP_HTTP_PORT`
+- `WARM_MCP_HTTP_PATH`
+- `WARM_MCP_ALLOWED_HOSTS`
+
 ## Core Tools
 
 Warm's published/documented MCP surface is the following four-tool core:

package/dist/config-paths.d.ts

@@ -1,2 +1,3 @@
 export declare function getWarmConfigDir(): string;
 export declare function getWarmApiKeyPath(): string;
+export declare function readConfigFile(configPath: string): string | null;

package/dist/config-paths.js

@@ -1,3 +1,4 @@
+import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 export function getWarmConfigDir() {
@@ -21,3 +22,11 @@ export function getWarmApiKeyPath() {
     }
     return path.join(getWarmConfigDir(), 'api_key');
 }
+export function readConfigFile(configPath) {
+    try {
+        return fs.readFileSync(configPath, 'utf-8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/http.d.ts

@@ -1,9 +1,8 @@
-import type { Server as HttpServer } from 'http';
-export interface WarmHttpServerOptions {
+export interface HttpServerOptions {
+    allowedHosts?: string[];
     host?: string;
-    port?: number;
     path?: string;
-    allowedHosts?: string[];
+    port?: number;
 }
-export declare function resolveHttpServerOptions(overrides?: WarmHttpServerOptions): Required<WarmHttpServerOptions>;
-export declare function startHttpServer(options?: WarmHttpServerOptions): Promise<HttpServer>;
+export declare function resolveHttpServerOptions(overrides?: HttpServerOptions): Required<HttpServerOptions>;
+export declare function startHttpServer(options?: HttpServerOptions): Promise<any>;

package/dist/http.js

@@ -25,36 +25,38 @@ function parseAllowedHosts(value) {
 }
 function jsonRpcError(message) {
     return {
-        jsonrpc: '2.0',
         error: {
             code: -32000,
             message,
         },
         id: null,
+        jsonrpc: '2.0',
     };
 }
-function sendMethodNotAllowed(res) {
-    res.status(405).set('Allow', 'POST').json(jsonRpcError('Method not allowed.'));
-}
 export function resolveHttpServerOptions(overrides = {}) {
     return {
+        allowedHosts: overrides.allowedHosts ??
+            parseAllowedHosts(process.env.WARM_MCP_ALLOWED_HOSTS || process.env.MCP_ALLOWED_HOSTS),
         host: overrides.host ||
             process.env.WARM_MCP_HTTP_HOST ||
             process.env.MCP_HOST ||
             process.env.HOST ||
             DEFAULT_HTTP_HOST,
+        path: normalizePath(overrides.path || process.env.WARM_MCP_HTTP_PATH || process.env.MCP_PATH || DEFAULT_HTTP_PATH),
         port: overrides.port ??
             parsePort(process.env.WARM_MCP_HTTP_PORT || process.env.MCP_PORT || process.env.PORT, DEFAULT_HTTP_PORT),
-        path: normalizePath(overrides.path || process.env.WARM_MCP_HTTP_PATH || process.env.MCP_PATH || DEFAULT_HTTP_PATH),
-        allowedHosts: overrides.allowedHosts ??
-            parseAllowedHosts(process.env.WARM_MCP_ALLOWED_HOSTS || process.env.MCP_ALLOWED_HOSTS),
     };
 }
+function sendJsonMethodNotAllowed(res) {
+    res.status(405);
+    res.set('Allow', 'POST');
+    res.json(jsonRpcError('Method not allowed.'));
+}
 export async function startHttpServer(options = {}) {
     const resolved = resolveHttpServerOptions(options);
     const app = createMcpExpressApp({
-        host: resolved.host,
         ...(resolved.allowedHosts.length > 0 ? { allowedHosts: resolved.allowedHosts } : {}),
+        host: resolved.host,
     });
     app.post(resolved.path, async (req, res) => {
         const server = createWarmServer();
@@ -85,10 +87,10 @@ export async function startHttpServer(options = {}) {
         }
     });
     app.get(resolved.path, (_req, res) => {
-        sendMethodNotAllowed(res);
+        sendJsonMethodNotAllowed(res);
     });
     app.delete(resolved.path, (_req, res) => {
-        sendMethodNotAllowed(res);
+        sendJsonMethodNotAllowed(res);
     });
     const listener = await new Promise((resolve, reject) => {
         const httpServer = app.listen(resolved.port, resolved.host, () => {

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export declare function startStdioServer(): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;

package/dist/index.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { install } from './install.js';
-import { startStdioServer } from './server.js';
+import { startHttpServer } from './http.js';
+import { loadDotEnv } from './load-env.js';
+import { createWarmServer } from './server.js';
+import { AdaptiveStdioTransport } from './stdio.js';
 function isInteractiveSession() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -15,6 +18,7 @@ function printUsage() {
     console.log('');
     console.log('  warm-mcp install [--force] [--no-validate]');
     console.log('  warm-mcp stdio');
+    console.log('  warm-mcp http [--host 127.0.0.1] [--port 3000] [--path /mcp]');
     console.log('');
     console.log('  Aliases:');
     console.log('    --server, --stdio    Start stdio mode');
@@ -40,6 +44,33 @@ function parseCliArgs(args) {
             options.command = 'stdio';
             continue;
         }
+        if (arg === 'http') {
+            options.command = 'http';
+            continue;
+        }
+        if (arg === '--host') {
+            options.httpHost = args[index + 1];
+            index += 1;
+            continue;
+        }
+        if (arg === '--path') {
+            options.httpPath = args[index + 1];
+            index += 1;
+            continue;
+        }
+        if (arg === '--port') {
+            const nextArg = args[index + 1];
+            if (!nextArg) {
+                throw new Error('Missing value for --port');
+            }
+            const port = Number.parseInt(nextArg, 10);
+            if (!Number.isInteger(port) || port <= 0) {
+                throw new Error(`Invalid value for --port: ${nextArg}`);
+            }
+            options.httpPort = port;
+            index += 1;
+            continue;
+        }
         if (arg === '--force') {
             options.force = true;
             continue;
@@ -52,7 +83,14 @@ function parseCliArgs(args) {
     }
     return options;
 }
+export async function startStdioServer() {
+    const server = createWarmServer();
+    const transport = new AdaptiveStdioTransport();
+    await server.connect(transport);
+    return server;
+}
 async function main() {
+    loadDotEnv();
     const options = parseCliArgs(process.argv.slice(2));
     switch (options.command) {
         case 'help':
@@ -61,6 +99,13 @@ async function main() {
         case 'stdio':
             await startStdioServer();
             return;
+        case 'http':
+            await startHttpServer({
+                host: options.httpHost,
+                path: options.httpPath,
+                port: options.httpPort,
+            });
+            return;
         case 'install':
             await install({
                 force: options.force,
@@ -73,8 +118,7 @@ try {
     await main();
 }
 catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = error instanceof Error ? error.stack || error.message : String(error);
     console.error(message);
-    console.error('Run "warm-mcp --help" for usage.');
     process.exit(1);
 }

package/dist/install.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { homedir, platform } from 'os';
 import { verifyWarmApiKey } from './server.js';
-import { getWarmApiKeyPath } from './config-paths.js';
+import { getWarmApiKeyPath, readConfigFile } from './config-paths.js';
 const HOME = homedir();
 const CWD = process.cwd();
 function isRecord(value) {
@@ -46,10 +46,13 @@ const GLOBAL_CLIENTS = [
     { name: 'Gemini CLI', configPath: join(HOME, '.gemini', 'settings.json'), format: 'json' },
 ];
 const PROJECT_CONFIGS = ['.mcp.json', '.cursor/mcp.json', '.vscode/mcp.json'];
+const MCP_PACKAGE_SPEC = '@warmio/mcp@latest';
 const MCP_CONFIG = platform() === 'win32'
-    ? { command: 'cmd', args: ['/c', 'npx', '-y', '@warmio/mcp', '--server'] }
-    : { command: 'npx', args: ['-y', '@warmio/mcp', '--server'] };
+    ? { command: 'cmd', args: ['/c', 'npx', '-y', MCP_PACKAGE_SPEC, '--server'] }
+    : { command: 'npx', args: ['-y', MCP_PACKAGE_SPEC, '--server'] };
 const WARM_API_KEY_PATH = getWarmApiKeyPath();
+const WARM_TOML_BLOCK_PATTERN = /\n?\[mcp_servers\.warm\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
+const WARM_TOML_ENV_BLOCK_PATTERN = /\n?\[mcp_servers\.warm\.env\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
 function detectProjectClients() {
     const found = [];
     for (const name of PROJECT_CONFIGS) {
@@ -71,20 +74,133 @@ function isDetected(client) {
     }
     return existsSync(dirname(client.configPath));
 }
-function isConfigured(client) {
-    if (!existsSync(client.configPath)) {
-        return false;
+function getStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
     }
+    return value.filter((entry) => typeof entry === 'string');
+}
+function isWarmPackageSpecifier(value) {
+    return /^@warmio\/mcp(?:@.+)?$/.test(value);
+}
+function isLegacyWarmPackageSpecifier(value) {
+    return /^@anthropic\/warm-mcp-server(?:@.+)?$/.test(value);
+}
+function normalizePathLikeValue(value) {
+    return value.replace(/\\/g, '/').toLowerCase();
+}
+function isLocalWarmMcpPath(value) {
+    const normalized = normalizePathLikeValue(value);
+    return normalized.includes('/warm-mcp/dist/index.js') || normalized.endsWith('/warm-mcp');
+}
+function isSupportedWarmInvocation(command, args) {
+    return [command, ...args].some((value) => typeof value === 'string' &&
+        (isWarmPackageSpecifier(value) || isLocalWarmMcpPath(value)));
+}
+function isLegacyWarmInvocation(command, args) {
+    return [command, ...args].some((value) => typeof value === 'string' && isLegacyWarmPackageSpecifier(value));
+}
+function getJsonEnvStatus(server) {
+    const env = isRecord(server?.env) ? server.env : undefined;
+    const inlineApiKey = typeof env?.WARM_API_KEY === 'string' && env.WARM_API_KEY.trim()
+        ? env.WARM_API_KEY.trim()
+        : null;
+    return {
+        hasApiKeyFileOverride: typeof env?.WARM_API_KEY_FILE === 'string' && env.WARM_API_KEY_FILE.trim().length > 0,
+        inlineApiKey,
+    };
+}
+function getJsonStatus(client, content) {
     try {
-        const content = readFileSync(client.configPath, 'utf-8');
-        if (client.format === 'toml') {
-            return content.includes('[mcp_servers.warm]');
+        const parsed = JSON.parse(content);
+        const servers = isRecord(parsed.mcpServers) ? parsed.mcpServers : undefined;
+        const server = isRecord(servers?.warm) ? servers.warm : undefined;
+        const envStatus = getJsonEnvStatus(server);
+        if (!server) {
+            return { client, state: 'missing', ...envStatus };
+        }
+        const command = typeof server.command === 'string' ? server.command : undefined;
+        const args = getStringArray(server.args);
+        if (client.isProjectLevel && command && !isLegacyWarmInvocation(command, args)) {
+            return { client, state: 'configured', ...envStatus };
         }
-        return !!JSON.parse(content)?.mcpServers?.warm;
+        if (isSupportedWarmInvocation(command, args)) {
+            return { client, state: 'configured', ...envStatus };
+        }
+        return { client, state: 'needs_migration', ...envStatus };
     }
     catch {
-        return false;
+        return { client, state: 'missing', hasApiKeyFileOverride: false, inlineApiKey: null };
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getTomlSection(content, sectionName) {
+    const pattern = new RegExp(`(?:^|\\n)\\[${escapeRegExp(sectionName)}\\]\\n([\\s\\S]*?)(?=\\n\\[[^\\n]+\\]|\\s*$)`);
+    const match = content.match(pattern);
+    return match ? match[0].replace(/^\n/, '') : null;
+}
+function getTomlStringValue(block, key) {
+    if (!block) {
+        return undefined;
+    }
+    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*(?:"([^"]*)"|'([^']*)')\\s*$`, 'm');
+    const match = block.match(pattern);
+    return match?.[1] ?? match?.[2];
+}
+function getTomlStringArrayValue(block, key) {
+    if (!block) {
+        return [];
+    }
+    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*\\[([\\s\\S]*?)\\]\\s*$`, 'm');
+    const match = block.match(pattern);
+    if (!match) {
+        return [];
+    }
+    const values = [];
+    const valuePattern = /"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'/g;
+    for (const item of match[1].matchAll(valuePattern)) {
+        values.push(item[1] ?? item[2] ?? '');
+    }
+    return values;
+}
+function getTomlEnvStatus(content) {
+    const envBlock = getTomlSection(content, 'mcp_servers.warm.env');
+    if (!envBlock) {
+        return { envLines: [], hasApiKeyFileOverride: false, inlineApiKey: null };
+    }
+    const envLines = envBlock.split('\n').slice(1).filter((line) => line.trim().length > 0);
+    const inlineApiKey = getTomlStringValue(envBlock, 'WARM_API_KEY')?.trim() || null;
+    const apiKeyFile = getTomlStringValue(envBlock, 'WARM_API_KEY_FILE');
+    return {
+        envLines,
+        hasApiKeyFileOverride: typeof apiKeyFile === 'string' && apiKeyFile.trim().length > 0,
+        inlineApiKey,
+    };
+}
+function getTomlStatus(client, content) {
+    const warmBlock = getTomlSection(content, 'mcp_servers.warm');
+    const envStatus = getTomlEnvStatus(content);
+    if (!warmBlock) {
+        return { client, state: 'missing', ...envStatus };
+    }
+    const command = getTomlStringValue(warmBlock, 'command');
+    const args = getTomlStringArrayValue(warmBlock, 'args');
+    if (isSupportedWarmInvocation(command, args)) {
+        return { client, state: 'configured', ...envStatus };
+    }
+    return { client, state: 'needs_migration', ...envStatus };
+}
+function getClientStatus(client) {
+    if (!existsSync(client.configPath)) {
+        return { client, state: 'missing', hasApiKeyFileOverride: false, inlineApiKey: null };
     }
+    const content = readFileSync(client.configPath, 'utf-8');
+    if (client.format === 'toml') {
+        return getTomlStatus(client, content);
+    }
+    return getJsonStatus(client, content);
 }
 function configureJson(client) {
     let config = {};
@@ -103,8 +219,14 @@ function configureJson(client) {
     const existing = isRecord(servers.warm) ? servers.warm : undefined;
     const existingEnv = isRecord(existing?.env) ? existing.env : {};
     const nextEnv = { ...existingEnv };
+    const existingCommand = typeof existing?.command === 'string' ? existing.command : undefined;
+    const existingArgs = getStringArray(existing?.args);
+    const preserveProjectCommand = client.isProjectLevel &&
+        !!existingCommand &&
+        !isLegacyWarmInvocation(existingCommand, existingArgs) &&
+        !isWarmPackageSpecifier(existingCommand);
     delete nextEnv.WARM_API_KEY;
-    if (client.isProjectLevel && existing?.command) {
+    if (preserveProjectCommand) {
         servers.warm = {
             ...existing,
             ...(Object.keys(nextEnv).length > 0 ? { env: nextEnv } : {}),
@@ -130,15 +252,21 @@ function configureToml(client) {
     }
     const tomlCommand = platform() === 'win32' ? 'cmd' : 'npx';
     const tomlArgs = platform() === 'win32'
-        ? '["/c", "npx", "-y", "@warmio/mcp", "--server"]'
-        : '["-y", "@warmio/mcp", "--server"]';
+        ? `["/c", "npx", "-y", "${MCP_PACKAGE_SPEC}", "--server"]`
+        : `["-y", "${MCP_PACKAGE_SPEC}", "--server"]`;
     const warmBlock = `[mcp_servers.warm]\ncommand = "${tomlCommand}"\nargs = ${tomlArgs}\n`;
-    const warmBlockPattern = /\n?\[mcp_servers\.warm\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
-    let nextContent = content.replace(warmBlockPattern, '').trimEnd();
+    const preservedEnvLines = getTomlEnvStatus(content).envLines.filter((line) => !/^\s*WARM_API_KEY\s*=/.test(line));
+    let nextContent = content
+        .replace(WARM_TOML_ENV_BLOCK_PATTERN, '')
+        .replace(WARM_TOML_BLOCK_PATTERN, '')
+        .trimEnd();
     if (nextContent.length > 0) {
         nextContent += '\n\n';
     }
     nextContent += warmBlock;
+    if (preservedEnvLines.length > 0) {
+        nextContent += `\n[mcp_servers.warm.env]\n${preservedEnvLines.join('\n')}\n`;
+    }
     mkdirSync(dirname(client.configPath), { recursive: true });
     writeFileSync(client.configPath, nextContent.endsWith('\n') ? nextContent : `${nextContent}\n`);
 }
@@ -197,6 +325,18 @@ function storeApiKey(apiKey) {
     mkdirSync(dirname(WARM_API_KEY_PATH), { recursive: true });
     writeFileSync(WARM_API_KEY_PATH, `${apiKey}\n`, { mode: 0o600 });
 }
+function getStatusLabel(status, force) {
+    if (force) {
+        return 'not configured';
+    }
+    if (status === 'configured') {
+        return 'configured';
+    }
+    if (status === 'needs_migration') {
+        return 'needs migration';
+    }
+    return 'not configured';
+}
 export async function install(options = {}) {
     const force = options.force ?? false;
     const shouldValidateApiKey = options.validateApiKey ?? true;
@@ -207,12 +347,11 @@ export async function install(options = {}) {
     const globalClients = GLOBAL_CLIENTS.filter(isDetected);
     const projectClients = detectProjectClients();
     const allClients = [...globalClients, ...projectClients];
-    const needsSetup = allClients.filter((client) => !isConfigured(client) || force);
+    const clientStatuses = allClients.map(getClientStatus);
+    const needsSetup = clientStatuses.filter((status) => force || status.state !== 'configured');
     console.log('  MCP clients found:');
-    allClients.forEach((client) => {
-        const configured = isConfigured(client);
-        const status = configured && !force ? 'configured' : 'not configured';
-        console.log(`    ${client.name.padEnd(22)} ${shortPath(client.configPath).padEnd(55)} ${status}`);
+    clientStatuses.forEach((status) => {
+        console.log(`    ${status.client.name.padEnd(22)} ${shortPath(status.client.configPath).padEnd(55)} ${getStatusLabel(status.state, force)}`);
     });
     console.log('');
     if (needsSetup.length === 0) {
@@ -221,34 +360,69 @@ export async function install(options = {}) {
         console.log('');
         return;
     }
-    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;
+    const storedApiKey = readConfigFile(WARM_API_KEY_PATH);
+    const migratedApiKey = needsSetup.find((status) => typeof status.inlineApiKey === 'string' && status.inlineApiKey.length > 0)
+        ?.inlineApiKey ?? null;
+    const hasApiKeyFileOverride = needsSetup.some((status) => status.hasApiKeyFileOverride);
+    let apiKeyToStore = null;
+    let shouldStoreApiKey = false;
+    let shouldPromptForApiKey = force;
+    if (!shouldPromptForApiKey) {
+        if (storedApiKey) {
+            console.log('  Using stored Warm API key.');
+            console.log('');
+            apiKeyToStore = storedApiKey;
+        }
+        else if (migratedApiKey) {
+            console.log('  Reusing Warm API key from existing client config.');
+            console.log('');
+            apiKeyToStore = migratedApiKey;
+            shouldStoreApiKey = true;
+        }
+        else if (hasApiKeyFileOverride) {
+            console.log('  Reusing existing WARM_API_KEY_FILE override.');
+            console.log('');
+        }
+        else {
+            shouldPromptForApiKey = true;
+        }
+    }
+    if (shouldPromptForApiKey) {
+        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;
+        }
+        apiKeyToStore = apiKey;
+        shouldStoreApiKey = true;
     }
-    if (shouldValidateApiKey) {
-        const isValid = await validateApiKey(apiKey);
+    if (apiKeyToStore && shouldValidateApiKey && (shouldStoreApiKey || force)) {
+        const isValid = await validateApiKey(apiKeyToStore);
         if (!isValid) {
             return;
         }
     }
-    storeApiKey(apiKey);
+    if (apiKeyToStore && shouldStoreApiKey) {
+        storeApiKey(apiKeyToStore);
+    }
     console.log('  Configuring...');
     console.log('');
-    needsSetup.forEach((client) => {
+    needsSetup.forEach((status) => {
         try {
-            configure(client);
-            console.log(`    ${client.name.padEnd(22)} done`);
+            configure(status.client);
+            console.log(`    ${status.client.name.padEnd(22)} done`);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            console.log(`    ${client.name.padEnd(22)} failed: ${message}`);
+            console.log(`    ${status.client.name.padEnd(22)} failed: ${message}`);
         }
     });
     console.log('');
-    console.log(`  Stored API key at ${shortPath(WARM_API_KEY_PATH)}`);
+    if (apiKeyToStore) {
+        console.log(`  Stored API key at ${shortPath(WARM_API_KEY_PATH)}`);
+    }
     console.log('  All set! Restart your MCP clients and try:');
     console.log('    "What\'s my net worth?"');
     console.log('');

package/dist/load-env.d.ts

@@ -0,0 +1 @@
+export declare function loadDotEnv(): void;

package/dist/load-env.js

@@ -0,0 +1,36 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { config as loadEnvFile } from 'dotenv';
+let loaded = false;
+export function loadDotEnv() {
+    if (loaded) {
+        return;
+    }
+    loaded = true;
+    const candidates = new Set();
+    let currentDir = process.cwd();
+    while (true) {
+        candidates.add(path.join(currentDir, '.env'));
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    let moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        candidates.add(path.join(moduleDir, '.env'));
+        const parentDir = path.dirname(moduleDir);
+        if (parentDir === moduleDir) {
+            break;
+        }
+        moduleDir = parentDir;
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            loadEnvFile({ path: candidate, override: false, quiet: true });
+            return;
+        }
+    }
+}