mcp-researchpowerpack 3.9.4 → 4.3.0

package/dist/index.js

@@ -1,356 +1,299 @@
 #!/usr/bin/env node
-/**
- * Research Powerpack MCP Server
- * Implements robust error handling - server NEVER crashes on tool failures
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { TOOLS } from './tools/definitions.js';
-import { executeTool, getToolCapabilities } from './tools/registry.js';
-import { classifyError, createToolErrorFromStructured } from './utils/errors.js';
-import { SERVER, getCapabilities } from './config/index.js';
-import { initLogger } from './utils/logger.js';
-const BROKEN_PIPE_ERROR_CODES = new Set([
-    'EPIPE',
-    'EIO',
-    'ERR_STREAM_DESTROYED',
-    'ERR_STREAM_WRITE_AFTER_END',
-]);
-const DEFAULT_MCP_PORT = 3000;
-function extractErrorCode(error) {
-    if (!error || typeof error !== 'object')
-        return undefined;
-    const maybeCode = error.code;
-    return typeof maybeCode === 'string' ? maybeCode : undefined;
+if (!process.env.UV_THREADPOOL_SIZE) {
+  process.env.UV_THREADPOOL_SIZE = "8";
 }
-function extractErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    return typeof error === 'string' ? error : String(error);
+import { Logger } from "mcp-use";
+import {
+  InMemorySessionStore,
+  InMemoryStreamManager,
+  MCPServer,
+  RedisSessionStore,
+  RedisStreamManager,
+  object
+} from "mcp-use/server";
+import { createClient } from "redis";
+import { SERVER } from "./src/config/index.js";
+import { getLLMHealth } from "./src/services/llm-processor.js";
+import {
+  closeWorkflowStateStore,
+  configureWorkflowStateStore,
+  getWorkflowStateStore
+} from "./src/services/workflow-state.js";
+import { registerAllTools } from "./src/tools/registry.js";
+const DEFAULT_PORT = 3e3;
+const SHUTDOWN_TIMEOUT_MS = 1e4;
+const WEBSITE_URL = "https://github.com/yigitkonur/mcp-researchpowerpack-http";
+const LOCAL_DEFAULT_HOST = "127.0.0.1";
+const startupLogger = Logger.get("startup");
+function parseCsvEnv(value) {
+  if (!value) return void 0;
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
 }
-function isBrokenPipeLikeError(error) {
-    const code = extractErrorCode(error);
-    if (code && BROKEN_PIPE_ERROR_CODES.has(code))
-        return true;
-    const message = extractErrorMessage(error).toLowerCase();
-    return (message.includes('epipe') ||
-        message.includes('eio') ||
-        message.includes('broken pipe') ||
-        message.includes('stream destroyed') ||
-        message.includes('write after end'));
+function parsePort(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return fallback;
 }
-function safeStderrWrite(line) {
-    try {
-        process.stderr.write(`${line}\n`);
-    }
-    catch {
-        // Swallow stderr failures while shutting down from stream errors.
-    }
+function resolvePort() {
+  const portFlagIndex = process.argv.findIndex((arg) => arg === "--port");
+  if (portFlagIndex >= 0) {
+    return parsePort(process.argv[portFlagIndex + 1], DEFAULT_PORT);
+  }
+  return parsePort(process.env.PORT, DEFAULT_PORT);
 }
-let streamExitInProgress = false;
-let fatalHandlerInProgress = false;
-function exitOnBrokenPipe(source, error) {
-    if (streamExitInProgress || !isBrokenPipeLikeError(error))
-        return;
-    streamExitInProgress = true;
-    safeStderrWrite(`[MCP Server] ${source} broken pipe at ${new Date().toISOString()}, exiting`);
-    process.exit(fatalHandlerInProgress ? 1 : 0);
+function resolveHost() {
+  const explicitHost = process.env.HOST?.trim();
+  if (explicitHost) {
+    return explicitHost;
+  }
+  if (process.env.PORT?.trim()) {
+    return "0.0.0.0";
+  }
+  return LOCAL_DEFAULT_HOST;
 }
-// Install stream guards early (before startup logs) to avoid orphaned hot loops.
-process.stdout.on('error', (err) => exitOnBrokenPipe('stdout', err));
-process.stderr.on('error', (err) => exitOnBrokenPipe('stderr', err));
-// ============================================================================
-// Capability Detection (uses registry for tool capability mapping)
-// ============================================================================
-const capabilities = getCapabilities();
-const { enabled: enabledTools, disabled: disabledTools } = getToolCapabilities();
-if (enabledTools.length > 0) {
-    console.error(`✅ Enabled tools: ${enabledTools.join(', ')}`);
+function buildCors(allowedOrigins) {
+  if (!allowedOrigins || allowedOrigins.length === 0) {
+    return void 0;
+  }
+  return {
+    origin: allowedOrigins,
+    allowMethods: ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"],
+    allowHeaders: [
+      "Content-Type",
+      "Accept",
+      "Authorization",
+      "mcp-protocol-version",
+      "mcp-session-id",
+      "X-Proxy-Token",
+      "X-Target-URL"
+    ],
+    exposeHeaders: ["mcp-session-id"]
+  };
 }
-if (disabledTools.length > 0) {
-    console.error(`⚠️ Disabled tools (missing ENV): ${disabledTools.join(', ')}`);
+function configureLogging() {
+  Logger.configure({
+    level: process.env.NODE_ENV === "production" ? "info" : "debug",
+    format: "minimal"
+  });
+  const debug = process.env.DEBUG?.trim();
+  if (debug === "2") {
+    Logger.setDebug(2);
+  } else if (debug) {
+    Logger.setDebug(1);
+  }
 }
-if (capabilities.scraping && !capabilities.llmExtraction) {
-    console.error(`ℹ️ scrape_links: AI extraction (use_llm) disabled - set OPENROUTER_API_KEY to enable`);
+function normalizeOrigin(value, envName) {
+  try {
+    return new URL(value).origin;
+  } catch {
+    throw new Error(`${envName} must contain absolute URLs with protocol. Received: ${value}`);
+  }
 }
-// ============================================================================
-// Server Setup
-// ============================================================================
-/**
- * Register shared tool handlers on any Server instance.
- * Used by both STDIO and HTTP session servers to avoid duplication.
- */
-function registerToolHandlers(srv) {
-    srv.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-    srv.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        try {
-            return await executeTool(name, args, capabilities);
-        }
-        catch (error) {
-            if (error instanceof McpError)
-                throw error;
-            const structuredError = classifyError(error);
-            console.error(`[MCP Server] Tool "${name}" error:`, {
-                code: structuredError.code,
-                message: structuredError.message,
-                retryable: structuredError.retryable,
-            });
-            return createToolErrorFromStructured(structuredError);
-        }
-    });
+function resolveAllowedOrigins() {
+  const explicitOrigins = parseCsvEnv(process.env.ALLOWED_ORIGINS);
+  if (explicitOrigins && explicitOrigins.length > 0) {
+    return explicitOrigins.map((origin) => normalizeOrigin(origin, "ALLOWED_ORIGINS"));
+  }
+  return void 0;
 }
-const server = new Server({ name: SERVER.NAME, version: SERVER.VERSION }, { capabilities: { tools: {}, logging: {} } });
-initLogger(server);
-registerToolHandlers(server);
-// ============================================================================
-// Global Error Handlers - MUST EXIT on fatal errors per Node.js best practices
-// See: https://nodejs.org/api/process.html#warning-using-uncaughtexception-correctly
-// ============================================================================
-// Track shutdown state to prevent double shutdown
-let isShuttingDown = false;
-/**
- * Graceful shutdown handler - closes server and exits
- * @param exitCode - Exit code (0 for clean shutdown, 1 for error)
- */
-async function gracefulShutdown(exitCode) {
-    if (isShuttingDown)
-        return;
-    isShuttingDown = true;
-    try {
-        await server.close();
-        safeStderrWrite(`[MCP Server] Server closed at ${new Date().toISOString()}`);
-    }
-    catch (closeError) {
-        if (isBrokenPipeLikeError(closeError)) {
-            // Preserve caller intent: fatal paths should still exit non-zero.
-            process.exit(exitCode);
-            return;
-        }
-        safeStderrWrite(`[MCP Server] Error closing server: ${safeErrorString(closeError)}`);
-    }
-    finally {
-        process.exit(exitCode);
-    }
+async function buildSessionConfig() {
+  const redisUrl = process.env.REDIS_URL?.trim();
+  if (!redisUrl) {
+    return {
+      sessionConfig: {
+        sessionStore: new InMemorySessionStore(),
+        streamManager: new InMemoryStreamManager()
+      },
+      cleanupFns: []
+    };
+  }
+  const commandClient = createClient({ url: redisUrl });
+  const pubSubClient = commandClient.duplicate();
+  await Promise.all([commandClient.connect(), pubSubClient.connect()]);
+  return {
+    sessionConfig: {
+      sessionStore: new RedisSessionStore({
+        client: commandClient
+      }),
+      streamManager: new RedisStreamManager({
+        client: commandClient,
+        pubSubClient
+      })
+    },
+    cleanupFns: [
+      async () => {
+        await pubSubClient.quit();
+      },
+      async () => {
+        await commandClient.quit();
+      }
+    ]
+  };
 }
-/**
- * Safely extract error information without triggering another exception
- * Prevents infinite loops when error objects have problematic getters
- */
-function safeErrorString(error) {
-    try {
-        if (error instanceof Error) {
-            // Try to get message and stack safely
-            const message = String(error.message || 'Unknown error');
-            try {
-                const stack = String(error.stack || '');
-                if (!stack) {
-                    return message;
-                }
-                // Avoid duplicating the message when the stack already includes it
-                return stack.includes(message) ? stack : `${message}\n${stack}`;
-            }
-            catch {
-                return message; // Stack serialization failed, just return message
-            }
-        }
-        return String(error);
-    }
-    catch {
-        // Even String() can fail on some objects
-        return '[Error: Unable to serialize error object]';
-    }
+function buildHealthPayload(server, startedAt) {
+  const llm = getLLMHealth();
+  let workflowStateSize = null;
+  try {
+    const store = getWorkflowStateStore();
+    workflowStateSize = store.size?.() ?? null;
+  } catch {
+  }
+  return {
+    status: "ok",
+    name: SERVER.NAME,
+    version: SERVER.VERSION,
+    transport: "http",
+    uptime_seconds: Math.floor((Date.now() - startedAt) / 1e3),
+    active_sessions: server.getActiveSessions().length,
+    workflow_state_size: workflowStateSize,
+    // LLM health — surfaced so capability-aware clients render degraded mode
+    // once at session start instead of parsing per-call footers.
+    llm_planner_ok: llm.lastPlannerOk,
+    llm_extractor_ok: llm.lastExtractorOk,
+    llm_planner_checked_at: llm.lastPlannerCheckedAt,
+    llm_extractor_checked_at: llm.lastExtractorCheckedAt,
+    llm_planner_error: llm.lastPlannerError,
+    llm_extractor_error: llm.lastExtractorError,
+    planner_configured: llm.plannerConfigured,
+    extractor_configured: llm.extractorConfigured,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-// Handle uncaught exceptions - MUST EXIT per Node.js docs
-// The VM is in an unstable state after uncaught exception
-process.on('uncaughtException', (error) => {
-    if (isBrokenPipeLikeError(error)) {
-        exitOnBrokenPipe('uncaughtException', error);
-        return;
-    }
-    if (fatalHandlerInProgress) {
-        process.exit(1);
-        return;
-    }
-    fatalHandlerInProgress = true;
-    try {
-        safeStderrWrite(`[MCP Server] FATAL uncaughtException at ${new Date().toISOString()}:`);
-        safeStderrWrite(safeErrorString(error));
-    }
-    catch {
-        // Even logging failed - just exit
-        safeStderrWrite('[MCP Server] FATAL uncaughtException (unable to log details)');
-    }
-    gracefulShutdown(1).catch(() => process.exit(1));
-});
-// Handle unhandled promise rejections - MUST EXIT (Node v15+ behavior)
-// Suppressing this risks memory leaks and corrupted state
-process.on('unhandledRejection', (reason) => {
-    if (isBrokenPipeLikeError(reason)) {
-        exitOnBrokenPipe('unhandledRejection', reason);
-        return;
-    }
-    if (fatalHandlerInProgress) {
-        process.exit(1);
-        return;
+async function main() {
+  configureLogging();
+  const isProduction = process.env.NODE_ENV === "production";
+  const host = resolveHost();
+  const port = resolvePort();
+  const baseUrl = process.env.MCP_URL?.trim() || void 0;
+  const allowedOrigins = resolveAllowedOrigins();
+  const { sessionConfig, cleanupFns } = await buildSessionConfig();
+  await configureWorkflowStateStore(process.env.REDIS_URL?.trim());
+  startupLogger.info(`Starting ${SERVER.NAME} v${SERVER.VERSION}`);
+  startupLogger.info(`Binding HTTP server to ${host}:${port}`);
+  if (allowedOrigins && allowedOrigins.length > 0) {
+    startupLogger.info(`Host validation enabled for origins: ${allowedOrigins.join(", ")}`);
+  } else if (isProduction) {
+    if (!baseUrl) {
+      startupLogger.error(
+        "Production mode requires ALLOWED_ORIGINS or MCP_URL to be set. Without host validation, the server is vulnerable to DNS rebinding attacks. Set ALLOWED_ORIGINS to the public deployment URL or custom domain."
+      );
+      process.exit(1);
     }
-    fatalHandlerInProgress = true;
-    try {
-        const error = classifyError(reason);
-        safeStderrWrite(`[MCP Server] FATAL unhandledRejection at ${new Date().toISOString()}:`);
-        safeStderrWrite(`  Message: ${error.message}`);
-        safeStderrWrite(`  Code: ${error.code}`);
-    }
-    catch {
-        // classifyError or logging failed, use safeErrorString as fallback
-        safeStderrWrite('[MCP Server] FATAL unhandledRejection (unable to classify error):');
-        safeStderrWrite(safeErrorString(reason));
-    }
-    gracefulShutdown(1).catch(() => process.exit(1));
-});
-// Handle SIGTERM gracefully (Docker/Kubernetes stop signal)
-process.on('SIGTERM', () => {
-    safeStderrWrite(`[MCP Server] Received SIGTERM at ${new Date().toISOString()}, shutting down gracefully`);
-    gracefulShutdown(0);
-});
-// Handle SIGINT gracefully (Ctrl+C) - use once() to prevent double-fire
-process.once('SIGINT', () => {
-    safeStderrWrite(`[MCP Server] Received SIGINT at ${new Date().toISOString()}, shutting down gracefully`);
-    gracefulShutdown(0);
-});
-// ============================================================================
-// Stdin disconnect detection
-// The MCP SDK's StdioServerTransport does NOT listen for stdin 'close'/'end'.
-// When the parent process disconnects (closes the pipe), stdin emits these
-// events but nobody handles them — Node.js keeps polling the dead fd at 100%
-// CPU. We fix this by detecting the disconnect and exiting cleanly.
-// ============================================================================
-process.stdin.on('close', () => {
-    safeStderrWrite(`[MCP Server] stdin closed (parent disconnected) at ${new Date().toISOString()}, shutting down`);
-    gracefulShutdown(0);
-});
-process.stdin.on('end', () => {
-    safeStderrWrite(`[MCP Server] stdin ended (parent disconnected) at ${new Date().toISOString()}, shutting down`);
-    gracefulShutdown(0);
-});
-// ============================================================================
-// Start Server — STDIO (default) or HTTP Streamable (MCP_TRANSPORT=http)
-// ============================================================================
-const transportMode = (process.env.MCP_TRANSPORT || 'stdio').toLowerCase();
-if (transportMode === 'http') {
-    // HTTP Streamable transport — stateful sessions over HTTP
-    const { StreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
-    const { createServer: createHttpServer } = await import('node:http');
-    const { randomUUID } = await import('node:crypto');
-    const PORT = parseInt(process.env.MCP_PORT || String(DEFAULT_MCP_PORT), 10);
-    // Map of session ID → transport + server for multi-session support
-    const sessions = new Map();
-    /** Safely close a session's server, ignoring errors. */
-    async function closeSession(session, sessionId) {
-        sessions.delete(sessionId);
+    startupLogger.warn(
+      "Host validation is disabled because ALLOWED_ORIGINS is not set. MCP_URL is set, so the server will start \u2014 but set ALLOWED_ORIGINS for full origin protection."
+    );
+  } else {
+    startupLogger.info("Host validation disabled for local development");
+  }
+  const server = new MCPServer({
+    name: SERVER.NAME,
+    title: "Research Powerpack",
+    version: SERVER.VERSION,
+    description: SERVER.DESCRIPTION,
+    websiteUrl: WEBSITE_URL,
+    host,
+    baseUrl,
+    cors: buildCors(allowedOrigins),
+    allowedOrigins,
+    ...sessionConfig
+  });
+  registerAllTools(server);
+  try {
+    const patched = server;
+    const original = patched.getServerForSession?.bind(server);
+    if (original) {
+      patched.getServerForSession = (sessionId) => {
+        const native = original(sessionId);
         try {
-            await session.server.close();
-        }
-        catch { /* ignore close errors */ }
-    }
-    /** Handle GET /mcp — resume existing session's SSE stream. */
-    async function handleMcpGet(req, res, sessionId) {
-        if (sessionId && sessions.has(sessionId)) {
-            await sessions.get(sessionId).transport.handleRequest(req, res);
-        }
-        else {
-            res.writeHead(400).end('Bad request — missing session ID');
-        }
-    }
-    /** Handle POST /mcp — route to existing session or create a new one. */
-    async function handleMcpPost(req, res, sessionId) {
-        if (sessionId && sessions.has(sessionId)) {
-            await sessions.get(sessionId).transport.handleRequest(req, res);
-            return;
-        }
-        if (sessionId) {
-            res.writeHead(400).end('Bad request — missing session ID');
-            return;
-        }
-        // New session (initialization)
-        const sessionServer = new Server({ name: SERVER.NAME, version: SERVER.VERSION }, { capabilities: { tools: {}, logging: {} } });
-        const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => randomUUID(),
-            onsessioninitialized: (id) => {
-                sessions.set(id, { transport, server: sessionServer });
-                console.error(`[HTTP] Session ${id} initialized`);
-            },
-            onsessionclosed: async (id) => {
-                const session = sessions.get(id);
-                if (session) {
-                    await closeSession(session, id);
-                }
-                console.error(`[HTTP] Session ${id} closed`);
-            },
-        });
-        // Note: initLogger overwrites a global serverRef, so logs from all
-        // HTTP sessions route to the most-recently-initialized session.
-        // A true per-session logger is out of scope for this fix.
-        initLogger(sessionServer);
-        registerToolHandlers(sessionServer);
-        await sessionServer.connect(transport);
-        await transport.handleRequest(req, res);
-    }
-    /** Handle DELETE /mcp — terminate a session. */
-    async function handleMcpDelete(req, res, sessionId) {
-        if (sessionId && sessions.has(sessionId)) {
-            const session = sessions.get(sessionId);
-            await session.transport.handleRequest(req, res);
-            await closeSession(session, sessionId);
-        }
-        else {
-            res.writeHead(404).end('Session not found');
-        }
-    }
-    const httpServer = createHttpServer(async (req, res) => {
-        const url = new URL(req.url || '/', `http://localhost:${PORT}`);
-        // Health check
-        if (url.pathname === '/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', name: SERVER.NAME, version: SERVER.VERSION }));
-            return;
-        }
-        // MCP endpoint
-        if (url.pathname === '/mcp') {
-            const sessionId = req.headers['mcp-session-id'];
-            switch (req.method) {
-                case 'DELETE':
-                    await handleMcpDelete(req, res, sessionId);
-                    return;
-                case 'GET':
-                    await handleMcpGet(req, res, sessionId);
-                    return;
-                case 'POST':
-                    await handleMcpPost(req, res, sessionId);
-                    return;
-                default:
-                    res.writeHead(405).end('Method not allowed');
-                    return;
+          const llm = getLLMHealth();
+          native.server?.registerCapabilities?.({
+            experimental: {
+              research_powerpack: {
+                planner_available: llm.plannerConfigured,
+                extractor_available: llm.extractorConfigured,
+                planner_model: process.env.LLM_MODEL ?? process.env.LLM_EXTRACTION_MODEL ?? null,
+                extractor_model: process.env.LLM_MODEL ?? process.env.LLM_EXTRACTION_MODEL ?? null,
+                // Tools that require start-research to bootstrap the session first.
+                requires_bootstrap: ["web-search", "scrape-links", "get-reddit-post"]
+              }
             }
+          });
+        } catch {
         }
-        res.writeHead(404).end('Not found');
-    });
-    httpServer.listen(PORT, () => {
-        console.error(`🚀 ${SERVER.NAME} v${SERVER.VERSION} listening on http://localhost:${PORT}/mcp`);
-    });
-}
-else {
-    // STDIO transport (default)
-    const transport = new StdioServerTransport();
-    try {
-        await server.connect(transport);
-        console.error(`🚀 ${SERVER.NAME} v${SERVER.VERSION} ready (stdio)`);
+        return native;
+      };
     }
-    catch (error) {
-        const err = classifyError(error);
-        console.error(`[MCP Server] Failed to start: ${err.message}`);
-        process.exit(1);
+  } catch (err) {
+    startupLogger.warn(`Could not patch session-server factory: ${String(err)}`);
+  }
+  const startedAt = Date.now();
+  server.get("/health", (c) => c.json(buildHealthPayload(server, startedAt)));
+  server.get("/healthz", (c) => c.json(buildHealthPayload(server, startedAt)));
+  const resourceBaseUrl = baseUrl ?? `http://${host}:${port}`;
+  server.get(
+    "/.well-known/oauth-protected-resource",
+    (c) => c.json({ resource: resourceBaseUrl })
+  );
+  server.get(
+    "/.well-known/oauth-protected-resource/mcp",
+    (c) => c.json({ resource: `${resourceBaseUrl}/mcp` })
+  );
+  server.resource(
+    {
+      name: "server-health",
+      uri: "health://status",
+      description: "Current server health, uptime, and active MCP session count.",
+      mimeType: "application/json"
+    },
+    async () => object(buildHealthPayload(server, startedAt))
+  );
+  let isShuttingDown = false;
+  async function shutdown(signal, exitCode) {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    const forceExit = setTimeout(() => {
+      startupLogger.error(`Forced exit after ${SHUTDOWN_TIMEOUT_MS}ms (${signal})`);
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    try {
+      startupLogger.warn(`Shutdown signal received: ${signal}`);
+      await server.close();
+      await closeWorkflowStateStore();
+      for (const cleanupFn of cleanupFns) {
+        await cleanupFn();
+      }
+      clearTimeout(forceExit);
+      process.exit(exitCode);
+    } catch (error) {
+      clearTimeout(forceExit);
+      const message = error instanceof Error ? error.stack ?? error.message : String(error);
+      startupLogger.error(`Error while stopping server: ${message}`);
+      process.exit(1);
     }
+  }
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM", 0);
+  });
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT", 0);
+  });
+  process.on("uncaughtException", (error) => {
+    startupLogger.error(`Uncaught exception: ${error.stack ?? error.message}`);
+    void shutdown("uncaughtException", 1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    startupLogger.error(`Unhandled rejection: ${String(reason)}`);
+    void shutdown("unhandledRejection", 1);
+  });
+  await server.listen(port);
+  startupLogger.info(`${SERVER.NAME} v${SERVER.VERSION} listening on http://${host}:${port}/mcp`);
 }
-//# sourceMappingURL=index.js.map
+void main().catch((error) => {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  startupLogger.error(`Server failed to start: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map