mcp-wordpress 1.1.2

package/src/client/managers/BaseManager.ts

@@ -0,0 +1,73 @@
+/**
+ * Base class for all client managers
+ * Provides common functionality and error handling
+ */
+
+import type { WordPressClientConfig, RequestOptions } from "../../types/client.js";
+import { WordPressAPIError, AuthenticationError, RateLimitError } from "../../types/client.js";
+import { debug, logError } from "../../utils/debug.js";
+import { getErrorMessage } from "../../utils/error.js";
+
+export abstract class BaseManager {
+  protected config: WordPressClientConfig;
+
+  constructor(config: WordPressClientConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Standardized error handling for all managers
+   */
+  protected handleError(error: any, operation: string): never {
+    logError(`${operation} failed:`, error);
+
+    if (error instanceof WordPressAPIError) {
+      throw error;
+    }
+
+    if (error.name === "AbortError" || error.code === "ABORT_ERR") {
+      throw new WordPressAPIError(
+        `Request timeout after ${this.config.timeout}ms`,
+        408,
+        "timeout"
+      );
+    }
+
+    if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+      throw new WordPressAPIError(
+        `Cannot connect to WordPress site: ${this.config.baseUrl}`,
+        503,
+        "connection_failed"
+      );
+    }
+
+    const message = getErrorMessage(error);
+    throw new WordPressAPIError(
+      `${operation} failed: ${message}`,
+      500,
+      "unknown_error"
+    );
+  }
+
+  /**
+   * Standardized success logging
+   */
+  protected logSuccess(operation: string, details?: any): void {
+    debug.log(`${operation} completed successfully`, details);
+  }
+
+  /**
+   * Validate required parameters
+   */
+  protected validateRequired(params: Record<string, any>, requiredFields: string[]): void {
+    for (const field of requiredFields) {
+      if (params[field] === undefined || params[field] === null) {
+        throw new WordPressAPIError(
+          `Missing required parameter: ${field}`,
+          400,
+          "missing_parameter"
+        );
+      }
+    }
+  }
+}

package/src/client/managers/RequestManager.ts

@@ -0,0 +1,214 @@
+/**
+ * HTTP Request Manager
+ * Handles all HTTP operations, rate limiting, and retries
+ */
+
+import fetch from "node-fetch";
+import type { 
+  HTTPMethod, 
+  RequestOptions, 
+  ClientStats,
+  WordPressClientConfig 
+} from "../../types/client.js";
+import { WordPressAPIError, RateLimitError } from "../../types/client.js";
+import { BaseManager } from "./BaseManager.js";
+import { debug, startTimer } from "../../utils/debug.js";
+
+export class RequestManager extends BaseManager {
+  private stats: ClientStats;
+  private lastRequestTime: number = 0;
+  private requestInterval: number;
+
+  constructor(config: WordPressClientConfig) {
+    super(config);
+    
+    this.requestInterval = 60000 / parseInt(process.env.RATE_LIMIT || "60");
+    this.stats = {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      averageResponseTime: 0,
+      rateLimitHits: 0,
+      authFailures: 0,
+    };
+  }
+
+  /**
+   * Make HTTP request with retry logic and rate limiting
+   */
+  async request<T>(
+    method: HTTPMethod,
+    endpoint: string,
+    data?: any,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const timer = startTimer();
+    
+    try {
+      await this.enforceRateLimit();
+      
+      const response = await this.makeRequestWithRetry(method, endpoint, data, options);
+      
+      this.stats.successfulRequests++;
+      this.updateAverageResponseTime(timer.end());
+      
+      return response as T;
+    } catch (error) {
+      this.stats.failedRequests++;
+      this.handleError(error, `${method} ${endpoint}`);
+    } finally {
+      this.stats.totalRequests++;
+    }
+  }
+
+  /**
+   * Make request with retry logic
+   */
+  private async makeRequestWithRetry<T>(
+    method: HTTPMethod,
+    endpoint: string,
+    data?: any,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    let lastError: any;
+    const maxRetries = options.retries ?? this.config.maxRetries ?? 3;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await this.makeRequest<T>(method, endpoint, data, options);
+      } catch (error: any) {
+        lastError = error;
+        
+        // Don't retry on authentication errors or client errors
+        if (error.statusCode < 500 || attempt === maxRetries) {
+          throw error;
+        }
+
+        debug.log(`Request failed (attempt ${attempt}/${maxRetries}):`, error.message);
+        
+        // Exponential backoff
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+
+    throw lastError;
+  }
+
+  /**
+   * Make single HTTP request
+   */
+  private async makeRequest<T>(
+    method: HTTPMethod,
+    endpoint: string,
+    data?: any,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const url = this.buildUrl(endpoint);
+    const timeout = options.timeout ?? this.config.timeout ?? 30000;
+    
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const fetchOptions: any = {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": "MCP-WordPress/1.1.1",
+          ...options.headers,
+        },
+        signal: controller.signal,
+      };
+
+      if (data && method !== "GET") {
+        fetchOptions.body = JSON.stringify(data);
+      }
+
+      debug.log(`API Request: ${method} ${url}`);
+      
+      const response = await fetch(url, fetchOptions);
+      
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+
+      const responseData = await response.json();
+      return responseData as T;
+      
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * Handle HTTP error responses
+   */
+  private async handleErrorResponse(response: any): Promise<never> {
+    let errorData: any = {};
+    
+    try {
+      errorData = await response.json();
+    } catch {
+      // Ignore JSON parsing errors
+    }
+
+    const message = errorData.message || `HTTP ${response.status}: ${response.statusText}`;
+    const code = errorData.code || "http_error";
+
+    if (response.status === 429) {
+      this.stats.rateLimitHits++;
+      throw new RateLimitError(message, Date.now() + 60000); // Retry after 1 minute
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      this.stats.authFailures++;
+    }
+
+    throw new WordPressAPIError(message, response.status, code, errorData);
+  }
+
+  /**
+   * Build full URL from endpoint
+   */
+  private buildUrl(endpoint: string): string {
+    const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+    const apiBase = "/wp-json/wp/v2";
+    const cleanEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    
+    return `${baseUrl}${apiBase}${cleanEndpoint}`;
+  }
+
+  /**
+   * Enforce rate limiting
+   */
+  private async enforceRateLimit(): Promise<void> {
+    const now = Date.now();
+    const timeSinceLastRequest = now - this.lastRequestTime;
+    
+    if (timeSinceLastRequest < this.requestInterval) {
+      const delay = this.requestInterval - timeSinceLastRequest;
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+    
+    this.lastRequestTime = Date.now();
+  }
+
+  /**
+   * Update average response time
+   */
+  private updateAverageResponseTime(responseTime: number): void {
+    const totalRequests = this.stats.successfulRequests;
+    const currentAverage = this.stats.averageResponseTime;
+    
+    this.stats.averageResponseTime = 
+      (currentAverage * (totalRequests - 1) + responseTime) / totalRequests;
+  }
+
+  /**
+   * Get request statistics
+   */
+  getStats(): ClientStats {
+    return { ...this.stats };
+  }
+}

package/src/client/managers/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Client Managers Index
+ * Exports all manager classes for the WordPress client
+ */
+
+export { BaseManager } from "./BaseManager.js";
+export { AuthenticationManager } from "./AuthenticationManager.js";
+export { RequestManager } from "./RequestManager.js";

package/src/index.ts

@@ -0,0 +1,337 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import dotenv from "dotenv";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { WordPressClient } from "./client/api.js";
+import { AuthMethod, WordPressClientConfig } from "./types/client.js";
+import * as Tools from "./tools/index.js";
+import { getErrorMessage } from "./utils/error.js";
+import { z } from "zod";
+
+// --- Constants ---
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, "..");
+const envPath = path.resolve(rootDir, ".env");
+dotenv.config({ path: envPath });
+
+const SERVER_VERSION = "1.1.1"; // Updated version with test fixes
+
+// --- Main Server Class ---
+class MCPWordPressServer {
+  private server: McpServer;
+  // MODIFICATION: Manages multiple WordPress clients, keyed by site ID.
+  private wordpressClients: Map<string, WordPressClient> = new Map();
+  private initialized: boolean = false;
+  // MODIFICATION: Stores the configurations for all loaded sites.
+  private siteConfigs: any[] = [];
+
+  constructor(mcpConfig?: any) {
+    this.loadConfiguration(mcpConfig);
+
+    if (this.wordpressClients.size === 0) {
+      console.error(
+        "No WordPress sites were configured. Please create mcp-wordpress.config.json or set environment variables.",
+      );
+      process.exit(1);
+    }
+
+    this.server = new McpServer({
+      name: "mcp-wordpress",
+      version: SERVER_VERSION,
+    });
+
+    this.setupTools();
+  }
+
+  private loadConfiguration(mcpConfig?: any) {
+    const configPath = path.resolve(rootDir, "mcp-wordpress.config.json");
+
+    if (fs.existsSync(configPath)) {
+      console.error(
+        "INFO: Found mcp-wordpress.config.json, loading multi-site configuration.",
+      );
+      this.loadMultiSiteConfig(configPath);
+    } else {
+      console.error(
+        "INFO: mcp-wordpress.config.json not found, falling back to environment variables for single-site mode.",
+      );
+      this.loadSingleSiteFromEnv(mcpConfig);
+    }
+  }
+
+  private loadMultiSiteConfig(configPath: string) {
+    try {
+      const configFile = fs.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(configFile);
+
+      if (!config.sites || !Array.isArray(config.sites)) {
+        throw new Error('Configuration file must have a "sites" array.');
+      }
+
+      this.siteConfigs = config.sites;
+      for (const site of this.siteConfigs) {
+        if (site.id && site.name && site.config) {
+          const clientConfig: WordPressClientConfig = {
+            baseUrl: site.config.WORDPRESS_SITE_URL,
+            auth: {
+              method:
+                (site.config.WORDPRESS_AUTH_METHOD as AuthMethod) ||
+                "app-password",
+              username: site.config.WORDPRESS_USERNAME,
+              appPassword: site.config.WORDPRESS_APP_PASSWORD,
+            },
+          };
+          const client = new WordPressClient(clientConfig);
+          this.wordpressClients.set(site.id, client);
+          console.error(
+            `INFO: Initialized client for site: ${site.name} (ID: ${site.id})`,
+          );
+        } else {
+          console.warn(
+            "WARN: Skipping invalid site entry in config. Must have id, name, and config.",
+            site,
+          );
+        }
+      }
+    } catch (error) {
+      console.error(
+        `FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`,
+      );
+      process.exit(1);
+    }
+  }
+
+  private loadSingleSiteFromEnv(mcpConfig?: any) {
+    const siteUrl =
+      mcpConfig?.wordpressSiteUrl || process.env.WORDPRESS_SITE_URL;
+    const username =
+      mcpConfig?.wordpressUsername || process.env.WORDPRESS_USERNAME;
+    const password =
+      mcpConfig?.wordpressAppPassword || process.env.WORDPRESS_APP_PASSWORD;
+    const authMethod = (mcpConfig?.wordpressAuthMethod ||
+      process.env.WORDPRESS_AUTH_METHOD ||
+      "app-password") as AuthMethod;
+
+    if (!siteUrl || !username || !password) {
+      console.error(
+        "ERROR: Missing required credentials for single-site mode.",
+      );
+      console.error(
+        "Please set WORDPRESS_SITE_URL, WORDPRESS_USERNAME, and WORDPRESS_APP_PASSWORD environment variables.",
+      );
+      return;
+    }
+
+    const singleSiteConfig: WordPressClientConfig = {
+      baseUrl: siteUrl,
+      auth: { method: authMethod, username, appPassword: password },
+    };
+    const client = new WordPressClient(singleSiteConfig);
+    this.wordpressClients.set("default", client);
+    this.siteConfigs.push({
+      id: "default",
+      name: "Default Site",
+      config: singleSiteConfig,
+    });
+    console.error(
+      "INFO: Initialized client for default site in single-site mode.",
+    );
+  }
+
+  private setupTools() {
+    // Register all tools from the tools directory
+    Object.values(Tools).forEach((ToolClass) => {
+      const toolInstance = new ToolClass();
+      const tools = toolInstance.getTools();
+      
+      tools.forEach((tool) => {
+        this.registerTool(tool);
+      });
+    });
+  }
+
+  private registerTool(tool: any) {
+    // Create base parameter schema with site parameter
+    const baseSchema = {
+      site: z.string()
+        .optional()
+        .describe("The ID of the WordPress site to target (from mcp-wordpress.config.json). Required if multiple sites are configured."),
+    };
+
+    // Merge with tool-specific parameters
+    const parameterSchema = tool.parameters?.reduce((schema: any, param: any) => {
+      let zodType;
+      
+      switch (param.type) {
+        case 'string':
+          zodType = z.string();
+          break;
+        case 'number':
+          zodType = z.number();
+          break;
+        case 'boolean':
+          zodType = z.boolean();
+          break;
+        case 'array':
+          zodType = z.array(z.string());
+          break;
+        case 'object':
+          zodType = z.record(z.any());
+          break;
+        default:
+          zodType = z.string();
+      }
+
+      if (param.description) {
+        zodType = zodType.describe(param.description);
+      }
+
+      if (!param.required) {
+        zodType = zodType.optional();
+      }
+
+      schema[param.name] = zodType;
+      return schema;
+    }, { ...baseSchema }) || baseSchema;
+
+    // Make site parameter required if multiple sites are configured
+    if (this.wordpressClients.size > 1) {
+      parameterSchema.site = parameterSchema.site.describe("The ID of the WordPress site to target (from mcp-wordpress.config.json). Required when multiple sites are configured.");
+    }
+
+    this.server.tool(
+      tool.name,
+      tool.description || `WordPress tool: ${tool.name}`,
+      parameterSchema,
+      async (args: any) => {
+        try {
+          const siteId = args.site || "default";
+          const client = this.wordpressClients.get(siteId);
+
+          if (!client) {
+            const availableSites = Array.from(this.wordpressClients.keys()).join(", ");
+            return {
+              content: [{
+                type: "text" as const,
+                text: `Error: Site with ID '${siteId}' not found. Available sites: ${availableSites}`
+              }],
+              isError: true
+            };
+          }
+
+          // Call the tool handler with the client and parameters
+          const result = await tool.handler(client, args);
+          
+          return {
+            content: [{
+              type: "text" as const,
+              text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+            }]
+          };
+
+        } catch (error) {
+          if (this.isAuthenticationError(error)) {
+            return {
+              content: [{
+                type: "text" as const,
+                text: `Authentication failed for site '${args.site || "default"}'. Please check your credentials.`
+              }],
+              isError: true
+            };
+          }
+          
+          return {
+            content: [{
+              type: "text" as const,
+              text: `Error: ${getErrorMessage(error)}`
+            }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+
+  private async testClientConnections(): Promise<void> {
+    console.error(
+      "INFO: Testing connections to all configured WordPress sites...",
+    );
+    const connectionPromises = Array.from(this.wordpressClients.entries()).map(
+      async ([siteId, client]) => {
+        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 (this.isAuthenticationError(error)) {
+            console.error(
+              `Authentication may have failed for site '${siteId}'. Please check credentials.`,
+            );
+          }
+        }
+      },
+    );
+    await Promise.all(connectionPromises);
+    this.initialized = true;
+    console.error("INFO: Connection tests complete.");
+  }
+
+  private isAuthenticationError(error: any): boolean {
+    if (error?.response?.status && [401, 403].includes(error.response.status)) {
+      return true;
+    }
+    return error?.code === "WORDPRESS_AUTH_ERROR";
+  }
+
+  async run() {
+    if (!this.initialized) {
+      await this.testClientConnections();
+    }
+    console.error("INFO: Starting MCP WordPress Server...");
+    
+    // Connect to stdio transport
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    
+    console.error(
+      `INFO: Server started and connected. Tools available for ${this.wordpressClients.size} site(s).`,
+    );
+  }
+
+  async shutdown() {
+    console.error("INFO: Shutting down MCP WordPress Server...");
+    await this.server.close();
+    console.error("INFO: Server stopped.");
+  }
+}
+
+// --- Main Execution ---
+async function main() {
+  try {
+    const mcpServer = new MCPWordPressServer();
+    await mcpServer.run();
+
+    const shutdown = async () => {
+      await mcpServer.shutdown();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (error) {
+    console.error(`FATAL: Failed to start server: ${getErrorMessage(error)}`);
+    process.exit(1);
+  }
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main();
+}
+
+export default MCPWordPressServer;
+export { MCPWordPressServer };

package/src/server.ts

@@ -0,0 +1,7 @@
+/**
+ * Compatibility export for tests
+ * Re-exports the main MCP server class for backward compatibility
+ */
+
+export { default as MCPWordPressServer } from './index.js';
+export { default } from './index.js';