@warmio/mcp 4.2.2 → 4.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 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
 
@@ -58,6 +58,21 @@ On Windows, prefer:
 }
 ```
 
+## Optional Streamable HTTP
+
+If your MCP client supports Streamable HTTP, you can run:
+
+```bash
+npx @warmio/mcp 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/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 });
+            return;
+        }
+    }
+}