@wisewandtools/mcp-server 2.1.2 → 2.2.1

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();
   }
 };
@@ -1121,6 +1169,42 @@ var HealthChecker = class {
 
 // src/handlers/tools/ArticleToolHandler.ts
 import { z as z2 } from "zod";
+
+// src/utils/tool-helpers.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ToolInputError = class extends Error {
+  static {
+    __name(this, "ToolInputError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "ToolInputError";
+  }
+};
+function resolveId(args, ...fallbackKeys) {
+  const value = args.id ?? args.Id ?? args.ID;
+  if (value !== void 0 && value !== null) {
+    return validateUuid(value);
+  }
+  for (const key of fallbackKeys) {
+    if (args[key] !== void 0 && args[key] !== null) {
+      return validateUuid(args[key]);
+    }
+  }
+  const tried = ["id", ...fallbackKeys].join(", ");
+  throw new ToolInputError(`Missing required ID. Provide one of: ${tried}`);
+}
+__name(resolveId, "resolveId");
+function validateUuid(value) {
+  const str = String(value);
+  if (!UUID_REGEX.test(str)) {
+    throw new ToolInputError(`Invalid ID format: "${str}" is not a valid UUID`);
+  }
+  return str;
+}
+__name(validateUuid, "validateUuid");
+
+// src/handlers/tools/ArticleToolHandler.ts
 var boolField = z2.union([z2.boolean(), z2.string()]).transform(
   (val) => typeof val === "string" ? val === "true" : val
 ).optional().default(false);
@@ -1500,8 +1584,8 @@ var ArticleToolHandler = class {
                 title: article.title || "Article created",
                 message: `Article "${article.title || validated.subject}" created successfully.`,
                 next_steps: [
-                  `Use 'generate_article' with article_id: ${article.id} to start content generation`,
-                  `Use 'get_article' with article_id: ${article.id} to check status`
+                  `Use 'generate_article' with id: ${article.id} to start content generation`,
+                  `Use 'get_article' with id: ${article.id} to check status`
                 ]
               }, null, 2)
             }]
@@ -1524,15 +1608,16 @@ var ArticleToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          article_id: { type: "string", format: "uuid", description: "ID of the article to generate" },
+          id: { type: "string", format: "uuid", description: "ID of the article to generate" },
           wait_for_completion: { type: "boolean", description: "Wait for generation to complete (may take several minutes)", default: true },
           max_wait_time: { type: "number", description: "Maximum time to wait in seconds", default: 300, maximum: 600 }
         },
-        required: ["article_id"]
+        required: ["id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { article_id, wait_for_completion = true, max_wait_time = 300 } = args;
+          const article_id = resolveId(args, "article_id");
+          const { wait_for_completion = true, max_wait_time = 300 } = args;
           await this.apiClient.runArticleGeneration(article_id);
           if (!wait_for_completion) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, message: "Article generation started", article_id, next_step: `Use 'get_article' or 'get_article_output' to check status` }, null, 2) }] };
@@ -1583,12 +1668,12 @@ var ArticleToolHandler = class {
       description: "Get article details and status",
       inputSchema: {
         type: "object",
-        properties: { article_id: { type: "string", format: "uuid", description: "ID of the article to retrieve" } },
-        required: ["article_id"]
+        properties: { id: { type: "string", format: "uuid", description: "ID of the article to retrieve" } },
+        required: ["id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { article_id } = args;
+          const article_id = resolveId(args, "article_id");
           const cached = await this.cache.get(`article:${article_id}`);
           if (cached) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, article: cached, from_cache: true }, null, 2) }] };
@@ -1614,8 +1699,7 @@ var ArticleToolHandler = class {
         properties: {
           search: { type: "string", description: "Search term to filter articles" },
           status: { type: "string", description: "Filter by status" },
-          projectId: { type: "string", format: "uuid", description: "Filter by project (camelCase as per API)" },
-          project_id: { type: "string", format: "uuid", description: "Filter by project (alias)" },
+          project_id: { type: "string", format: "uuid", description: "Filter by project" },
           maker: { type: "string", description: "Filter by maker" },
           persona: { type: "string", description: "Filter by persona" },
           author: { type: "string", description: "Filter by author" },
@@ -1629,7 +1713,12 @@ var ArticleToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const result2 = await this.apiClient.listArticles(args);
+          const apiParams = { ...args };
+          if (apiParams.project_id) {
+            apiParams.projectId = apiParams.project_id;
+            delete apiParams.project_id;
+          }
+          const result2 = await this.apiClient.listArticles(apiParams);
           this.metrics.recordAPICall("list_articles", "success");
           return {
             content: [{
@@ -1638,7 +1727,17 @@ var ArticleToolHandler = class {
                 success: true,
                 total: result2.total,
                 count: result2.items.length,
-                articles: result2.items.map((a) => ({ id: a.id, title: a.title, status: a.status, created_at: a.created_at, type: a.data?.input?.type })),
+                articles: result2.items.map((a) => ({
+                  id: a.id,
+                  title: a.title,
+                  status: a.status,
+                  created_at: a.created_at,
+                  type: a.data?.input?.type,
+                  project_id: a.data?.input?.project_id,
+                  target_keyword: a.data?.input?.target_keyword,
+                  lang: a.data?.input?.lang,
+                  subject: a.data?.input?.subject
+                })),
                 pagination: { skip: result2.skip, take: result2.take, has_more: result2.skip + result2.take < result2.total }
               }, null, 2)
             }]
@@ -1658,18 +1757,19 @@ var ArticleToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          article_id: { type: "string", format: "uuid", description: "ID of the article to update" },
+          id: { type: "string", format: "uuid", description: "ID of the article to update" },
           updates: {
             type: "object",
             description: "Fields to update (supports all create_article parameters)",
             properties: this.buildArticleInputSchema()
           }
         },
-        required: ["article_id", "updates"]
+        required: ["id", "updates"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { article_id, updates } = args;
+          const article_id = resolveId(args, "article_id");
+          const { updates } = args;
           await this.apiClient.updateArticle(article_id, updates);
           await this.cache.delete(`article:${article_id}`);
           this.metrics.recordAPICall("update_article", "success");
@@ -1691,14 +1791,15 @@ var ArticleToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          article_id: { type: "string", format: "uuid", description: "ID of the article" },
+          id: { type: "string", format: "uuid", description: "ID of the article" },
           format: { type: "string", enum: ["full", "html", "markdown", "summary"], description: "Output format", default: "full" }
         },
-        required: ["article_id"]
+        required: ["id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { article_id, format = "full" } = args;
+          const article_id = resolveId(args, "article_id");
+          const { format = "full" } = args;
           const cacheKey = `article:output:${article_id}`;
           const cached = await this.cache.get(cacheKey);
           const output = cached || await this.apiClient.getArticleOutput(article_id);
@@ -1736,15 +1837,16 @@ var ArticleToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          article_id: { type: "string", format: "uuid", description: "ID of the article" },
+          id: { type: "string", format: "uuid", description: "ID of the article" },
           output_id: { type: "string", format: "uuid", description: "ID of the output to update" },
           updates: { type: "object", description: "Fields to update in the output" }
         },
-        required: ["article_id", "output_id", "updates"]
+        required: ["id", "output_id", "updates"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { article_id, output_id, updates } = args;
+          const article_id = resolveId(args, "article_id");
+          const { output_id, updates } = args;
           const result2 = await this.apiClient.updateArticleOutput(article_id, output_id, updates);
           await this.cache.delete(`article:output:${article_id}`);
           this.metrics.recordAPICall("update_article_output", "success");
@@ -1899,18 +2001,18 @@ var ProjectToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          project_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Project ID"
           }
         },
-        required: ["project_id"]
+        required: ["id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { project_id } = args;
-          const cached = await this.cache.get(`project:${project_id}`);
+          const id = resolveId(args, "project_id");
+          const cached = await this.cache.get(`project:${id}`);
           if (cached) {
             return {
               content: [
@@ -1925,8 +2027,8 @@ var ProjectToolHandler = class {
               ]
             };
           }
-          const project = await this.apiClient.getProject(project_id);
-          await this.cache.set(`project:${project_id}`, project, 600);
+          const project = await this.apiClient.getProject(id);
+          await this.cache.set(`project:${id}`, project, 600);
           this.metrics.recordAPICall("get_project", "success");
           return {
             content: [
@@ -1994,12 +2096,7 @@ var ProjectToolHandler = class {
                   success: true,
                   total: result2.total,
                   count: result2.items.length,
-                  projects: result2.items.map((p) => ({
-                    id: p.id,
-                    name: p.name,
-                    website_url: p.website_url,
-                    created_at: p.created_at
-                  }))
+                  projects: result2.items
                 }, null, 2)
               }
             ]
@@ -2030,7 +2127,7 @@ var ProjectToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          project_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Project ID"
@@ -2047,13 +2144,14 @@ var ProjectToolHandler = class {
             }
           }
         },
-        required: ["project_id", "updates"]
+        required: ["id", "updates"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { project_id, updates } = args;
-          await this.apiClient.updateProject(project_id, updates);
-          await this.cache.delete(`project:${project_id}`);
+          const id = resolveId(args, "project_id");
+          const { updates } = args;
+          await this.apiClient.updateProject(id, updates);
+          await this.cache.delete(`project:${id}`);
           this.metrics.recordAPICall("update_project", "success");
           return {
             content: [
@@ -2062,7 +2160,7 @@ var ProjectToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   message: "Project updated successfully",
-                  project_id,
+                  project_id: id,
                   updated_fields: Object.keys(updates)
                 }, null, 2)
               }
@@ -2094,7 +2192,7 @@ var ProjectToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          project_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Project ID to delete"
@@ -2105,11 +2203,12 @@ var ProjectToolHandler = class {
             const: true
           }
         },
-        required: ["project_id", "confirm"]
+        required: ["id", "confirm"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { project_id, confirm } = args;
+          const id = resolveId(args, "project_id");
+          const { confirm } = args;
           if (!confirm) {
             return {
               content: [
@@ -2124,8 +2223,8 @@ var ProjectToolHandler = class {
               isError: true
             };
           }
-          await this.apiClient.deleteProject(project_id);
-          await this.cache.delete(`project:${project_id}`);
+          await this.apiClient.deleteProject(id);
+          await this.cache.delete(`project:${id}`);
           this.metrics.recordAPICall("delete_project", "success");
           return {
             content: [
@@ -2134,7 +2233,7 @@ var ProjectToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   message: "Project deleted successfully",
-                  project_id
+                  project_id: id
                 }, null, 2)
               }
             ]
@@ -2448,18 +2547,18 @@ var PersonaToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          persona_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Persona ID"
           }
         },
-        required: ["persona_id"]
+        required: ["id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { persona_id } = args;
-          const cached = await this.cache.get(`persona:${persona_id}`);
+          const id = resolveId(args, "persona_id");
+          const cached = await this.cache.get(`persona:${id}`);
           if (cached) {
             return {
               content: [
@@ -2474,8 +2573,8 @@ var PersonaToolHandler = class {
               ]
             };
           }
-          const persona = await this.apiClient.getPersona(persona_id);
-          await this.cache.set(`persona:${persona_id}`, persona, 600);
+          const persona = await this.apiClient.getPersona(id);
+          await this.cache.set(`persona:${id}`, persona, 600);
           this.metrics.recordAPICall("get_persona", "success");
           return {
             content: [
@@ -2580,7 +2679,7 @@ var PersonaToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          persona_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Persona ID"
@@ -2601,13 +2700,14 @@ var PersonaToolHandler = class {
             }
           }
         },
-        required: ["persona_id", "updates"]
+        required: ["id", "updates"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { persona_id, updates } = args;
-          await this.apiClient.updatePersona(persona_id, updates);
-          await this.cache.delete(`persona:${persona_id}`);
+          const id = resolveId(args, "persona_id");
+          const { updates } = args;
+          await this.apiClient.updatePersona(id, updates);
+          await this.cache.delete(`persona:${id}`);
           this.metrics.recordAPICall("update_persona", "success");
           return {
             content: [
@@ -2616,7 +2716,7 @@ var PersonaToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   message: "Persona updated successfully",
-                  persona_id,
+                  persona_id: id,
                   updated_fields: Object.keys(updates)
                 }, null, 2)
               }
@@ -2648,7 +2748,7 @@ var PersonaToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          persona_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Persona ID to delete"
@@ -2659,11 +2759,12 @@ var PersonaToolHandler = class {
             const: true
           }
         },
-        required: ["persona_id", "confirm"]
+        required: ["id", "confirm"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { persona_id, confirm } = args;
+          const id = resolveId(args, "persona_id");
+          const { confirm } = args;
           if (!confirm) {
             return {
               content: [
@@ -2678,8 +2779,8 @@ var PersonaToolHandler = class {
               isError: true
             };
           }
-          await this.apiClient.deletePersona(persona_id);
-          await this.cache.delete(`persona:${persona_id}`);
+          await this.apiClient.deletePersona(id);
+          await this.cache.delete(`persona:${id}`);
           this.metrics.recordAPICall("delete_persona", "success");
           return {
             content: [
@@ -2688,7 +2789,7 @@ var PersonaToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   message: "Persona deleted successfully",
-                  persona_id
+                  persona_id: id
                 }, null, 2)
               }
             ]
@@ -3045,18 +3146,18 @@ var ConnectionsToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          connection_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Connection ID"
           }
         },
-        required: ["connection_id"]
+        required: ["id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { connection_id } = args;
-          const cached = await this.cache.get(`connection:${connection_id}`);
+          const id = resolveId(args, "connection_id");
+          const cached = await this.cache.get(`connection:${id}`);
           if (cached) {
             return {
               content: [
@@ -3071,8 +3172,8 @@ var ConnectionsToolHandler = class {
               ]
             };
           }
-          const connection = await this.apiClient.getConnection(connection_id);
-          await this.cache.set(`connection:${connection_id}`, connection, 600);
+          const connection = await this.apiClient.getConnection(id);
+          await this.cache.set(`connection:${id}`, connection, 600);
           this.metrics.recordAPICall("get_connection", "success");
           return {
             content: [
@@ -3175,7 +3276,7 @@ var ConnectionsToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          connection_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Connection ID"
@@ -3188,13 +3289,14 @@ var ConnectionsToolHandler = class {
             }
           }
         },
-        required: ["connection_id", "updates"]
+        required: ["id", "updates"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { connection_id, updates } = args;
-          await this.apiClient.updateConnection(connection_id, updates);
-          await this.cache.delete(`connection:${connection_id}`);
+          const id = resolveId(args, "connection_id");
+          const { updates } = args;
+          await this.apiClient.updateConnection(id, updates);
+          await this.cache.delete(`connection:${id}`);
           this.metrics.recordAPICall("update_connection", "success");
           return {
             content: [
@@ -3203,7 +3305,7 @@ var ConnectionsToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   message: "Connection updated successfully",
-                  connection_id
+                  connection_id: id
                 }, null, 2)
               }
             ]
@@ -3234,7 +3336,7 @@ var ConnectionsToolHandler = class {
       inputSchema: {
         type: "object",
         properties: {
-          connection_id: {
+          id: {
             type: "string",
             format: "uuid",
             description: "Connection ID to delete"
@@ -3245,11 +3347,12 @@ var ConnectionsToolHandler = class {
             const: true
           }
         },
-        required: ["connection_id", "confirm"]
+        required: ["id", "confirm"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { connection_id, confirm } = args;
+          const id = resolveId(args, "connection_id");
+          const { confirm } = args;
           if (!confirm) {
             return {
               content: [
@@ -3264,8 +3367,8 @@ var ConnectionsToolHandler = class {
               isError: true
             };
           }
-          await this.apiClient.deleteConnection(connection_id);
-          await this.cache.delete(`connection:${connection_id}`);
+          await this.apiClient.deleteConnection(id);
+          await this.cache.delete(`connection:${id}`);
           this.metrics.recordAPICall("delete_connection", "success");
           return {
             content: [
@@ -3274,7 +3377,7 @@ var ConnectionsToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   message: "Connection deleted successfully",
-                  connection_id
+                  connection_id: id
                 }, null, 2)
               }
             ]
@@ -3588,7 +3691,7 @@ var CategoryPagesToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid", description: "ID of the category page" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cached = await this.cache.get(`category_page:${id}`);
           if (cached) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, category_page: cached, from_cache: true }, null, 2) }] };
@@ -3648,7 +3751,8 @@ var CategoryPagesToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id, updates } = args;
+          const id = resolveId(args);
+          const { updates } = args;
           await this.apiClient.updateCategoryPage(id, updates);
           await this.cache.delete(`category_page:${id}`);
           this.metrics.recordAPICall("update_category_page", "success");
@@ -3676,7 +3780,8 @@ var CategoryPagesToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id, wait_for_completion = true, max_wait_time = 300 } = args;
+          const id = resolveId(args);
+          const { wait_for_completion = true, max_wait_time = 300 } = args;
           await this.apiClient.runCategoryPageGeneration(id);
           if (!wait_for_completion) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, message: "Category page generation started", category_page_id: id }, null, 2) }] };
@@ -3712,7 +3817,7 @@ var CategoryPagesToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid", description: "ID of the category page" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cacheKey = `category_page:output:${id}`;
           const cached = await this.cache.get(cacheKey);
           const output = cached || await this.apiClient.getCategoryPageOutput(id);
@@ -3900,7 +4005,7 @@ var ProductPagesToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid", description: "ID of the product page" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cached = await this.cache.get(`product_page:${id}`);
           if (cached) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, product_page: cached, from_cache: true }, null, 2) }] };
@@ -3951,7 +4056,8 @@ var ProductPagesToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid", description: "ID of the product page to update" }, updates: { type: "object", description: "Fields to update" } }, required: ["id", "updates"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id, updates } = args;
+          const id = resolveId(args);
+          const { updates } = args;
           await this.apiClient.updateProductPage(id, updates);
           await this.cache.delete(`product_page:${id}`);
           this.metrics.recordAPICall("update_product_page", "success");
@@ -3971,7 +4077,8 @@ var ProductPagesToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid" }, wait_for_completion: { type: "boolean", default: true }, max_wait_time: { type: "number", default: 300, maximum: 600 } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id, wait_for_completion = true, max_wait_time = 300 } = args;
+          const id = resolveId(args);
+          const { wait_for_completion = true, max_wait_time = 300 } = args;
           await this.apiClient.runProductPageGeneration(id);
           if (!wait_for_completion) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, message: "Product page generation started", product_page_id: id }, null, 2) }] };
@@ -4007,7 +4114,7 @@ var ProductPagesToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cacheKey = `product_page:output:${id}`;
           const cached = await this.cache.get(cacheKey);
           const output = cached || await this.apiClient.getProductPageOutput(id);
@@ -4287,7 +4394,7 @@ var DiscoverToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cached = await this.cache.get(`discover:${id}`);
           if (cached) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, discovery: cached, from_cache: true }, null, 2) }] };
@@ -4338,7 +4445,8 @@ var DiscoverToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid" }, updates: { type: "object", description: "Fields to update" } }, required: ["id", "updates"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id, updates } = args;
+          const id = resolveId(args);
+          const { updates } = args;
           await this.apiClient.updateDiscoverArticle(id, updates);
           await this.cache.delete(`discover:${id}`);
           this.metrics.recordAPICall("update_discover_article", "success");
@@ -4358,7 +4466,7 @@ var DiscoverToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           await this.apiClient.runDiscovery(id);
           await this.cache.delete(`discover:${id}`);
           this.metrics.recordAPICall("run_discovery", "success");
@@ -4378,7 +4486,7 @@ var DiscoverToolHandler = class {
       inputSchema: { type: "object", properties: { id: { type: "string", format: "uuid" } }, required: ["id"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cacheKey = `discover:output:${id}`;
           const cached = await this.cache.get(cacheKey);
           const output = cached || await this.apiClient.getDiscoverArticleOutput(id);
@@ -4534,7 +4642,7 @@ var RSSToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const cached = await this.cache.get(`feed:${id}`);
           if (cached) {
             return { content: [{ type: "text", text: JSON.stringify({ success: true, feed: cached, from_cache: true }, null, 2) }] };
@@ -4624,7 +4732,8 @@ var RSSToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id, updates } = args;
+          const id = resolveId(args);
+          const { updates } = args;
           await this.apiClient.updateFeed(id, updates);
           await this.cache.delete(`feed:${id}`);
           this.metrics.recordAPICall("update_feed", "success");
@@ -4650,7 +4759,7 @@ var RSSToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           await this.apiClient.deleteFeed(id);
           await this.cache.delete(`feed:${id}`);
           this.metrics.recordAPICall("delete_feed", "success");
@@ -4772,7 +4881,7 @@ var JobsToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { id } = args;
+          const id = resolveId(args);
           const job = await this.apiClient.getJob(id);
           this.metrics.recordAPICall("get_job", "success");
           return {
@@ -6097,7 +6206,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 +6398,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 +6428,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 +6451,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 +6467,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 {