@wisewandtools/mcp-server 2.1.2 → 2.2.0

package/dist/index.d.ts

@@ -311,14 +311,6 @@ declare class WisewandMCPServer {
     getPromptCount(): number;
     getHealth(): HealthStatus | null;
     getMetrics(): Promise<string>;
-    /**
-     * Test API connection during startup
-     * Returns {ok: boolean, error?: string}
-     */
-    testAPIConnection(): Promise<{
-        ok: boolean;
-        error?: string;
-    }>;
 }
 
 export { WisewandMCPServer };

package/dist/index.js

@@ -134,11 +134,12 @@ var parseConfig = /* @__PURE__ */ __name(() => {
         strategy: process.env.CACHE_STRATEGY
       },
       monitoring: {
-        enableMetrics: process.env.ENABLE_METRICS !== "false",
+        // Default metrics and health check to false in MCP stdio mode (no port binding needed)
+        enableMetrics: process.env.ENABLE_METRICS === "true" ? true : process.env.ENABLE_METRICS === "false" ? false : process.env.MCP_MODE !== "stdio",
         metricsPort: process.env.METRICS_PORT ? parseInt(process.env.METRICS_PORT) : void 0,
         enableTracing: process.env.ENABLE_TRACING === "true",
         tracingEndpoint: process.env.TRACING_ENDPOINT,
-        enableHealthCheck: process.env.ENABLE_HEALTH_CHECK !== "false",
+        enableHealthCheck: process.env.ENABLE_HEALTH_CHECK === "true" ? true : process.env.ENABLE_HEALTH_CHECK === "false" ? false : process.env.MCP_MODE !== "stdio",
         healthCheckInterval: process.env.HEALTH_CHECK_INTERVAL ? parseInt(process.env.HEALTH_CHECK_INTERVAL) : void 0
       },
       features: {
@@ -264,13 +265,11 @@ var WisewandAPIClient = class {
       "User-Agent": "Wisewand-MCP/1.0.0",
       "Accept": "application/json"
     };
-    this.abortController = new AbortController();
   }
   static {
     __name(this, "WisewandAPIClient");
   }
   headers;
-  abortController;
   /**
    * Make HTTP request with retry logic
    */
@@ -278,25 +277,18 @@ var WisewandAPIClient = class {
     const url = `${this.config.apiUrl}${endpoint}`;
     return pRetry(
       async () => {
+        const abortController = new AbortController();
         const timeoutId = setTimeout(() => {
-          this.abortController.abort();
+          abortController.abort();
         }, this.config.timeout);
         try {
           const bodyJSON = body ? JSON.stringify(body) : void 0;
-          logger.info("API HTTP REQUEST - EXACT JSON", {
-            method,
-            endpoint,
-            url,
-            bodyJSON,
-            // The EXACT string being sent over HTTP
-            body_includes_apply_project_brief_config: bodyJSON?.includes("apply_project_brief_config"),
-            body_apply_project_brief_config_value: bodyJSON?.match(/"apply_project_brief_config":(true|false)/)?.[1]
-          });
+          logger.debug("API request", { method, endpoint, url });
           const response = await fetch(url, {
             method,
             headers: this.headers,
             body: bodyJSON,
-            signal: this.abortController.signal,
+            signal: abortController.signal,
             ...options
           });
           clearTimeout(timeoutId);
@@ -310,7 +302,6 @@ var WisewandAPIClient = class {
         } catch (error) {
           clearTimeout(timeoutId);
           if (error instanceof Error && error.name === "AbortError") {
-            this.abortController = new AbortController();
             throw new Error(`Request timeout after ${this.config.timeout}ms`);
           }
           throw error;
@@ -617,7 +608,6 @@ var APIError = class extends Error {
 
 // src/services/CacheManager.ts
 import NodeCache from "node-cache";
-import Redis from "ioredis";
 var CacheManager = class {
   constructor(config2, redisConfig) {
     this.config = config2;
@@ -644,6 +634,20 @@ var CacheManager = class {
       });
     }
     if ((this.strategy === "redis" || this.strategy === "hybrid") && this.redisConfig) {
+      this.initRedis();
+    }
+  }
+  static {
+    __name(this, "CacheManager");
+  }
+  memoryCache;
+  redisClient;
+  enabled;
+  strategy;
+  defaultTTL;
+  async initRedis() {
+    try {
+      const { default: Redis } = await import("ioredis");
       this.redisClient = new Redis({
         host: this.redisConfig.host,
         port: this.redisConfig.port,
@@ -664,16 +668,20 @@ var CacheManager = class {
       this.redisClient.on("error", (error) => {
         logger.error("Redis cache error", error);
       });
+    } catch (error) {
+      logger.warn("Failed to load ioredis, falling back to memory-only cache", { error });
+      this.strategy = "memory";
+      if (!this.memoryCache) {
+        this.memoryCache = new NodeCache({
+          stdTTL: this.defaultTTL,
+          checkperiod: 120,
+          useClones: false,
+          deleteOnExpire: true,
+          maxKeys: Math.floor(this.config.maxSizeMB * 1e3)
+        });
+      }
     }
   }
-  static {
-    __name(this, "CacheManager");
-  }
-  memoryCache;
-  redisClient;
-  enabled;
-  strategy;
-  defaultTTL;
   async get(key) {
     if (!this.enabled) return null;
     try {
@@ -869,8 +877,6 @@ var RateLimiter = class {
 };
 
 // src/monitoring/MetricsCollector.ts
-import { Counter, Histogram, Gauge, Registry, collectDefaultMetrics } from "prom-client";
-import express from "express";
 var MetricsCollector = class {
   static {
     __name(this, "MetricsCollector");
@@ -878,7 +884,8 @@ var MetricsCollector = class {
   registry;
   app;
   server;
-  // Metrics
+  enabled;
+  // Metrics (only initialized when enabled)
   toolCallCounter;
   toolCallDuration;
   apiCallCounter;
@@ -887,116 +894,156 @@ var MetricsCollector = class {
   cacheMissCounter;
   activeConnections;
   errorCounter;
-  constructor() {
-    this.registry = new Registry();
-    collectDefaultMetrics({ register: this.registry });
-    this.toolCallCounter = new Counter({
-      name: "mcp_tool_calls_total",
-      help: "Total number of tool calls",
-      labelNames: ["tool", "status"],
-      registers: [this.registry]
-    });
-    this.toolCallDuration = new Histogram({
-      name: "mcp_tool_call_duration_ms",
-      help: "Tool call duration in milliseconds",
-      labelNames: ["tool"],
-      buckets: [10, 50, 100, 500, 1e3, 5e3, 1e4],
-      registers: [this.registry]
-    });
-    this.apiCallCounter = new Counter({
-      name: "wisewand_api_calls_total",
-      help: "Total number of Wisewand API calls",
-      labelNames: ["endpoint", "status"],
-      registers: [this.registry]
-    });
-    this.apiCallDuration = new Histogram({
-      name: "wisewand_api_call_duration_ms",
-      help: "Wisewand API call duration in milliseconds",
-      labelNames: ["endpoint"],
-      buckets: [100, 500, 1e3, 2e3, 5e3, 1e4, 3e4],
-      registers: [this.registry]
-    });
-    this.cacheHitCounter = new Counter({
-      name: "cache_hits_total",
-      help: "Total number of cache hits",
-      labelNames: ["cache_type"],
-      registers: [this.registry]
-    });
-    this.cacheMissCounter = new Counter({
-      name: "cache_misses_total",
-      help: "Total number of cache misses",
-      labelNames: ["cache_type"],
-      registers: [this.registry]
-    });
-    this.activeConnections = new Gauge({
-      name: "mcp_active_connections",
-      help: "Number of active MCP connections",
-      registers: [this.registry]
-    });
-    this.errorCounter = new Counter({
-      name: "mcp_errors_total",
-      help: "Total number of errors",
-      labelNames: ["type", "source"],
-      registers: [this.registry]
-    });
-    logger.info("Metrics collector initialized");
+  constructor(enabled = true) {
+    this.enabled = enabled;
+    if (!this.enabled) {
+      logger.info("Metrics collector disabled");
+      return;
+    }
+  }
+  async init() {
+    if (!this.enabled) return;
+    try {
+      const { Counter, Histogram, Gauge, Registry, collectDefaultMetrics } = await import("prom-client");
+      this.registry = new Registry();
+      collectDefaultMetrics({ register: this.registry });
+      this.toolCallCounter = new Counter({
+        name: "mcp_tool_calls_total",
+        help: "Total number of tool calls",
+        labelNames: ["tool", "status"],
+        registers: [this.registry]
+      });
+      this.toolCallDuration = new Histogram({
+        name: "mcp_tool_call_duration_ms",
+        help: "Tool call duration in milliseconds",
+        labelNames: ["tool"],
+        buckets: [10, 50, 100, 500, 1e3, 5e3, 1e4],
+        registers: [this.registry]
+      });
+      this.apiCallCounter = new Counter({
+        name: "wisewand_api_calls_total",
+        help: "Total number of Wisewand API calls",
+        labelNames: ["endpoint", "status"],
+        registers: [this.registry]
+      });
+      this.apiCallDuration = new Histogram({
+        name: "wisewand_api_call_duration_ms",
+        help: "Wisewand API call duration in milliseconds",
+        labelNames: ["endpoint"],
+        buckets: [100, 500, 1e3, 2e3, 5e3, 1e4, 3e4],
+        registers: [this.registry]
+      });
+      this.cacheHitCounter = new Counter({
+        name: "cache_hits_total",
+        help: "Total number of cache hits",
+        labelNames: ["cache_type"],
+        registers: [this.registry]
+      });
+      this.cacheMissCounter = new Counter({
+        name: "cache_misses_total",
+        help: "Total number of cache misses",
+        labelNames: ["cache_type"],
+        registers: [this.registry]
+      });
+      this.activeConnections = new Gauge({
+        name: "mcp_active_connections",
+        help: "Number of active MCP connections",
+        registers: [this.registry]
+      });
+      this.errorCounter = new Counter({
+        name: "mcp_errors_total",
+        help: "Total number of errors",
+        labelNames: ["type", "source"],
+        registers: [this.registry]
+      });
+      logger.info("Metrics collector initialized");
+    } catch (error) {
+      logger.warn("Failed to initialize metrics collector, disabling", { error });
+      this.enabled = false;
+    }
   }
   recordToolCall(tool, status, durationMs) {
-    this.toolCallCounter.inc({ tool, status });
-    this.toolCallDuration.observe({ tool }, durationMs);
+    if (!this.enabled) return;
+    this.toolCallCounter?.inc({ tool, status });
+    this.toolCallDuration?.observe({ tool }, durationMs);
   }
   recordAPICall(endpoint, status, durationMs) {
-    this.apiCallCounter.inc({ endpoint, status });
+    if (!this.enabled) return;
+    this.apiCallCounter?.inc({ endpoint, status });
     if (durationMs) {
-      this.apiCallDuration.observe({ endpoint }, durationMs);
+      this.apiCallDuration?.observe({ endpoint }, durationMs);
     }
   }
   recordCacheHit(cacheType = "memory") {
-    this.cacheHitCounter.inc({ cache_type: cacheType });
+    if (!this.enabled) return;
+    this.cacheHitCounter?.inc({ cache_type: cacheType });
   }
   recordCacheMiss(cacheType = "memory") {
-    this.cacheMissCounter.inc({ cache_type: cacheType });
+    if (!this.enabled) return;
+    this.cacheMissCounter?.inc({ cache_type: cacheType });
   }
   setActiveConnections(count) {
-    this.activeConnections.set(count);
+    if (!this.enabled) return;
+    this.activeConnections?.set(count);
   }
   incrementActiveConnections() {
-    this.activeConnections.inc();
+    if (!this.enabled) return;
+    this.activeConnections?.inc();
   }
   decrementActiveConnections() {
-    this.activeConnections.dec();
+    if (!this.enabled) return;
+    this.activeConnections?.dec();
   }
   recordError(type, source) {
-    this.errorCounter.inc({ type, source });
+    if (!this.enabled) return;
+    this.errorCounter?.inc({ type, source });
   }
   async getMetrics() {
+    if (!this.enabled || !this.registry) return "";
     return await this.registry.metrics();
   }
   getMetricsContentType() {
+    if (!this.enabled || !this.registry) return "text/plain";
     return this.registry.contentType;
   }
-  startServer(port) {
+  async startServer(port) {
+    if (!this.enabled) return;
     if (this.server) {
       logger.warn("Metrics server already running");
       return;
     }
-    this.app = express();
-    this.app.get("/health", (_req, res) => {
-      res.status(200).json({ status: "healthy" });
-    });
-    this.app.get("/metrics", async (_req, res) => {
-      try {
-        res.set("Content-Type", this.getMetricsContentType());
-        const metrics = await this.getMetrics();
-        res.end(metrics);
-      } catch (error) {
-        logger.error("Error collecting metrics", error);
-        res.status(500).end();
+    try {
+      if (!this.registry) {
+        await this.init();
       }
-    });
-    this.server = this.app.listen(port, () => {
-      logger.info(`Metrics server started on port ${port}`);
-    });
+      if (!this.enabled) return;
+      const express = (await import("express")).default;
+      this.app = express();
+      this.app.get("/health", (_req, res) => {
+        res.status(200).json({ status: "healthy" });
+      });
+      this.app.get("/metrics", async (_req, res) => {
+        try {
+          res.set("Content-Type", this.getMetricsContentType());
+          const metrics = await this.getMetrics();
+          res.end(metrics);
+        } catch (error) {
+          logger.error("Error collecting metrics", error);
+          res.status(500).end();
+        }
+      });
+      this.server = this.app.listen(port, () => {
+        logger.info(`Metrics server started on port ${port}`);
+      });
+      this.server.on("error", (error) => {
+        logger.error(`Metrics server failed to bind port ${port}`, { error: error.message, code: error.code });
+        this.server = void 0;
+        this.enabled = false;
+      });
+    } catch (error) {
+      logger.error("Failed to start metrics server", { error });
+      this.enabled = false;
+    }
   }
   async stopServer() {
     if (this.server) {
@@ -1009,6 +1056,7 @@ var MetricsCollector = class {
     }
   }
   reset() {
+    if (!this.enabled || !this.registry) return;
     this.registry.clear();
   }
 };
@@ -6097,7 +6145,7 @@ var WisewandMCPServer = class {
     this.apiClient = new WisewandAPIClient(config2.wisewand);
     this.cacheManager = new CacheManager(config2.cache);
     this.rateLimiter = new RateLimiter(config2.security);
-    this.metrics = new MetricsCollector();
+    this.metrics = new MetricsCollector(config2.monitoring.enableMetrics);
     this.healthChecker = new HealthChecker(this.apiClient, this.cacheManager);
     this.articleHandler = new ArticleToolHandler(this.apiClient, this.cacheManager, this.metrics);
     this.projectHandler = new ProjectToolHandler(this.apiClient, this.cacheManager, this.metrics);
@@ -6289,32 +6337,9 @@ var WisewandMCPServer = class {
   getMetrics() {
     return this.metrics.getMetrics();
   }
-  /**
-   * Test API connection during startup
-   * Returns {ok: boolean, error?: string}
-   */
-  async testAPIConnection() {
-    try {
-      const health = await this.healthChecker.checkHealth();
-      if (health.checks.api) {
-        return { ok: true };
-      } else {
-        return {
-          ok: false,
-          error: "API health check failed - check API key and network connection"
-        };
-      }
-    } catch (error) {
-      return {
-        ok: false,
-        error: error.message || "Unknown error"
-      };
-    }
-  }
 };
 
 // src/utils/shutdown.ts
-import * as readline from "readline";
 function gracefulShutdown(server) {
   let isShuttingDown = false;
   const shutdown = /* @__PURE__ */ __name(async (signal) => {
@@ -6342,13 +6367,15 @@ function gracefulShutdown(server) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGHUP", () => shutdown("SIGHUP"));
-  if (process.platform === "win32") {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    rl.on("SIGINT", () => {
-      process.emit("SIGINT");
+  if (process.platform === "win32" && process.env.MCP_MODE !== "stdio") {
+    import("readline").then((readline) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr
+      });
+      rl.on("SIGINT", () => {
+        process.emit("SIGINT");
+      });
     });
   }
 }
@@ -6363,23 +6390,6 @@ async function main() {
       nodeVersion: process.version
     });
     const server = new WisewandMCPServer(config);
-    logger.info("Testing API connectivity...");
-    try {
-      const apiHealth = await server.testAPIConnection();
-      if (!apiHealth.ok) {
-        console.error("\u274C FATAL: Cannot connect to Wisewand API");
-        console.error(`   Reason: ${apiHealth.error}`);
-        console.error("   Check your WISEWAND_API_KEY and network connection");
-        console.error("   Get your API key from: https://app.wisewand.ai/api");
-        process.exit(1);
-      }
-      logger.info("\u2713 API connectivity verified");
-    } catch (error) {
-      console.error("\u274C FATAL: Failed to validate API connection");
-      console.error(`   Error: ${error.message}`);
-      console.error("   Check your WISEWAND_API_KEY and network connection");
-      process.exit(1);
-    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logger.info("Wisewand MCP Server started successfully", {
@@ -6396,11 +6406,9 @@ async function main() {
 __name(main, "main");
 process.on("uncaughtException", (error) => {
   logCriticalError("Uncaught Exception", error);
-  process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
   logCriticalError("Unhandled Rejection", reason);
-  process.exit(1);
 });
 main();
 export {