mcp-wordpress 2.4.2 → 2.5.1

package/src/server/ConnectionTester.ts

@@ -1,75 +1,164 @@
 import { WordPressClient } from "../client/api.js";
 import { getErrorMessage } from "../utils/error.js";
+import { LoggerFactory } from "../utils/logger.js";
+import { ConfigHelpers } from "../config/Config.js";
+
+interface ErrorWithResponse {
+  response?: {
+    status?: number;
+  };
+}
+
+interface ErrorWithCode {
+  code?: string;
+}
 
 /**
  * Service for testing WordPress client connections
  * Handles connection validation and health checks
  */
 export class ConnectionTester {
+  private static logger = LoggerFactory.server().child({ component: "ConnectionTester" });
+
   /**
-   * Test connections to all configured WordPress sites
+   * Test connections to all configured WordPress sites with timeout and concurrency control
    */
   public static async testClientConnections(
     wordpressClients: Map<string, WordPressClient>,
+    options: { timeout?: number; maxConcurrent?: number } = {},
   ): Promise<void> {
-    console.error(
-      "INFO: Testing connections to all configured WordPress sites...",
-    );
+    const { timeout = 5000, maxConcurrent = 3 } = options;
+
+    this.logger.info("Testing connections to WordPress sites", {
+      siteCount: wordpressClients.size,
+      timeout,
+      maxConcurrent,
+    });
+
+    const entries = Array.from(wordpressClients.entries());
+    const results: Array<{ siteId: string; success: boolean; error?: string }> = [];
 
-    const connectionPromises = Array.from(wordpressClients.entries()).map(
-      async ([siteId, client]) => {
+    // Process sites in batches to control concurrency
+    for (let i = 0; i < entries.length; i += maxConcurrent) {
+      const batch = entries.slice(i, i + maxConcurrent);
+
+      const batchPromises = batch.map(async ([siteId, client]) => {
+        const startTime = Date.now();
         try {
-          await client.ping();
-          console.error(`SUCCESS: Connection to site '${siteId}' successful.`);
-        } catch (error) {
-          console.error(
-            `ERROR: Failed to connect to site '${siteId}': ${getErrorMessage(error)}`,
-          );
-
-          if (ConnectionTester.isAuthenticationError(error)) {
-            console.error(
-              `Authentication may have failed for site '${siteId}'. Please check credentials.`,
-            );
+          // Add timeout to ping operation (skip timeout in tests to avoid timer issues)
+          if (ConfigHelpers.isTest()) {
+            // In test environment, just run the ping without timeout to avoid Jest timer issues
+            await client.ping();
+          } else {
+            await Promise.race([
+              client.ping(),
+              new Promise((_, reject) => setTimeout(() => reject(new Error("Connection timeout")), timeout)),
+            ]);
           }
+
+          const duration = Date.now() - startTime;
+          this.logger.info("Connection successful", { siteId, duration: `${duration}ms` });
+          results.push({ siteId, success: true });
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const errorMessage = getErrorMessage(error);
+
+          this.logger.warn("Connection failed", {
+            siteId,
+            error: errorMessage,
+            duration: `${duration}ms`,
+            isAuthError: ConnectionTester.isAuthenticationError(error),
+          });
+
+          results.push({ siteId, success: false, error: errorMessage });
         }
-      },
-    );
+      });
 
-    await Promise.all(connectionPromises);
-    console.error("INFO: Connection tests complete.");
+      await Promise.allSettled(batchPromises);
+    }
+
+    // Log summary
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.length - successful;
+
+    this.logger.info("Connection tests complete", {
+      total: results.length,
+      successful,
+      failed,
+      successRate: `${((successful / results.length) * 100).toFixed(1)}%`,
+    });
   }
 
   /**
    * Check if error is authentication-related
    */
-  private static isAuthenticationError(error: any): boolean {
-    if (error?.response?.status && [401, 403].includes(error.response.status)) {
-      return true;
+  private static isAuthenticationError(error: unknown): boolean {
+    // Check for HTTP response status
+    if (error && typeof error === "object" && "response" in error) {
+      const response = (error as ErrorWithResponse).response;
+      if (response?.status && [401, 403].includes(response.status)) {
+        return true;
+      }
     }
-    return error?.code === "WORDPRESS_AUTH_ERROR";
+    const errorMessage = getErrorMessage(error);
+    return (
+      errorMessage.includes("401") ||
+      errorMessage.includes("403") ||
+      errorMessage.includes("Unauthorized") ||
+      errorMessage.includes("Forbidden") ||
+      (error as ErrorWithCode)?.code === "WORDPRESS_AUTH_ERROR"
+    );
   }
 
   /**
-   * Perform health check for a specific client
+   * Perform health check for a specific client with timeout
    */
-  public static async healthCheck(client: WordPressClient): Promise<boolean> {
+  public static async healthCheck(client: WordPressClient, siteId?: string, timeout: number = 3000): Promise<boolean> {
     try {
-      await client.ping();
+      await Promise.race([
+        client.ping(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout)),
+      ]);
+
+      this.logger.debug("Health check passed", { siteId });
       return true;
     } catch (error) {
-      console.error(`Health check failed: ${getErrorMessage(error)}`);
+      this.logger.warn("Health check failed", {
+        siteId,
+        error: getErrorMessage(error),
+      });
       return false;
     }
   }
 
   /**
-   * Perform health checks for all clients
+   * Quick connectivity test without full authentication
    */
-  public static async healthCheckAll(
+  public static async quickConnectivityTest(
     wordpressClients: Map<string, WordPressClient>,
   ): Promise<Map<string, boolean>> {
     const results = new Map<string, boolean>();
 
+    const promises = Array.from(wordpressClients.entries()).map(async ([siteId, client]) => {
+      try {
+        // Just test basic connectivity, not full auth
+        const isHealthy = await this.healthCheck(client, siteId, 1000);
+        results.set(siteId, isHealthy);
+      } catch (_error) {
+        results.set(siteId, false);
+      }
+    });
+
+    await Promise.allSettled(promises);
+    return results;
+  }
+
+  /**
+   * Perform health checks for all clients
+   */
+  public static async healthCheckAll(wordpressClients: Map<string, WordPressClient>): Promise<Map<string, boolean>> {
+    const results = new Map<string, boolean>();
+
     for (const [siteId, client] of wordpressClients.entries()) {
       const isHealthy = await ConnectionTester.healthCheck(client);
       results.set(siteId, isHealthy);

package/src/server/ToolRegistry.ts

@@ -2,6 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WordPressClient } from "../client/api.js";
 import { getErrorMessage } from "../utils/error.js";
 import { EnhancedError, ErrorHandlers } from "../utils/enhancedError.js";
+import { config } from "../config/Config.js";
 import * as Tools from "../tools/index.js";
 import { z } from "zod";
 
@@ -13,11 +14,11 @@ export interface ToolDefinition {
   description?: string;
   parameters?: Array<{
     name: string;
-    type: string;
+    type?: string;
     description?: string;
     required?: boolean;
   }>;
-  handler: (client: WordPressClient, args: any) => Promise<any>;
+  handler: (client: WordPressClient, args: Record<string, unknown>) => Promise<unknown>;
 }
 
 /**
@@ -39,19 +40,19 @@ export class ToolRegistry {
   public registerAllTools(): void {
     // Register all tools from the tools directory
     Object.values(Tools).forEach((ToolClass) => {
-      let toolInstance: any;
+      let toolInstance: { getTools(): unknown[] };
 
       // Cache and Performance tools need the clients map
       if (ToolClass.name === "CacheTools" || ToolClass.name === "PerformanceTools") {
         toolInstance = new ToolClass(this.wordpressClients);
       } else {
-        toolInstance = new (ToolClass as new () => any)();
+        toolInstance = new (ToolClass as new () => { getTools(): unknown[] })();
       }
 
       const tools = toolInstance.getTools();
 
-      tools.forEach((tool: ToolDefinition) => {
-        this.registerTool(tool);
+      tools.forEach((tool: unknown) => {
+        this.registerTool(tool as ToolDefinition);
       });
     });
   }
@@ -74,8 +75,13 @@ export class ToolRegistry {
     const parameterSchema = this.buildParameterSchema(tool, baseSchema);
 
     // Make site parameter required if multiple sites are configured
-    if (this.wordpressClients.size > 1) {
-      parameterSchema.site = parameterSchema.site.describe(
+    if (
+      this.wordpressClients.size > 1 &&
+      parameterSchema.site &&
+      typeof parameterSchema.site === "object" &&
+      "describe" in parameterSchema.site
+    ) {
+      parameterSchema.site = (parameterSchema.site as z.ZodString).describe(
         "The ID of the WordPress site to target (from mcp-wordpress.config.json). Required when multiple sites are configured.",
       );
     }
@@ -84,7 +90,7 @@ export class ToolRegistry {
       tool.name,
       tool.description || `WordPress tool: ${tool.name}`,
       parameterSchema,
-      async (args: any) => {
+      async (args: Record<string, unknown>) => {
         try {
           let siteId = args.site;
 
@@ -108,11 +114,11 @@ export class ToolRegistry {
             siteId = this.selectBestSite(tool.name, args);
           }
 
-          const client = this.wordpressClients.get(siteId);
+          const client = this.wordpressClients.get(siteId as string);
 
           if (!client) {
             const availableSites = Array.from(this.wordpressClients.keys());
-            const error = ErrorHandlers.siteNotFound(siteId, availableSites);
+            const error = ErrorHandlers.siteNotFound(siteId as string, availableSites);
             return {
               content: [
                 {
@@ -178,14 +184,17 @@ export class ToolRegistry {
   /**
    * Build Zod parameter schema from tool definition
    */
-  private buildParameterSchema(tool: ToolDefinition, baseSchema: any): any {
+  private buildParameterSchema(tool: ToolDefinition, baseSchema: Record<string, unknown>): Record<string, unknown> {
     return (
       tool.parameters?.reduce(
-        (schema: any, param: any) => {
+        (
+          schema: Record<string, unknown>,
+          param: { name: string; type?: string; required?: boolean; [key: string]: unknown },
+        ) => {
           let zodType = this.getZodTypeForParameter(param);
 
           if (param.description) {
-            zodType = zodType.describe(param.description);
+            zodType = zodType.describe(param.description as string);
           }
 
           if (!param.required) {
@@ -203,7 +212,7 @@ export class ToolRegistry {
   /**
    * Get appropriate Zod type for parameter definition
    */
-  private getZodTypeForParameter(param: any): z.ZodType {
+  private getZodTypeForParameter(param: { type?: string; required?: boolean; [key: string]: unknown }): z.ZodType {
     switch (param.type) {
       case "string":
         return z.string();
@@ -214,7 +223,7 @@ export class ToolRegistry {
       case "array":
         return z.array(z.string());
       case "object":
-        return z.record(z.any());
+        return z.record(z.unknown());
       default:
         return z.string();
     }
@@ -223,7 +232,7 @@ export class ToolRegistry {
   /**
    * Intelligent site selection based on context
    */
-  private selectBestSite(toolName: string, args: any): string {
+  private selectBestSite(toolName: string, args: Record<string, unknown>): string {
     const availableSites = Array.from(this.wordpressClients.keys());
 
     // Single site scenario - use it directly
@@ -249,7 +258,7 @@ export class ToolRegistry {
       }
 
       // 3. For development/test operations, prefer dev sites
-      if (toolName.includes("test") || process.env.NODE_ENV === "development") {
+      if (toolName.includes("test") || config().app.isDevelopment) {
         const devSites = availableSites.filter((site) =>
           ["dev", "test", "staging", "local"].includes(site.toLowerCase()),
         );
@@ -269,10 +278,11 @@ export class ToolRegistry {
   /**
    * Check if error is authentication-related
    */
-  private isAuthenticationError(error: any): boolean {
-    if (error?.response?.status && [401, 403].includes(error.response.status)) {
+  private isAuthenticationError(error: unknown): boolean {
+    const errorObj = error as { response?: { status?: number }; code?: string };
+    if (errorObj?.response?.status && [401, 403].includes(errorObj.response.status)) {
       return true;
     }
-    return error?.code === "WORDPRESS_AUTH_ERROR";
+    return errorObj?.code === "WORDPRESS_AUTH_ERROR";
   }
 }