mcp-wordpress 1.5.2 → 2.0.0

package/src/client/managers/AuthenticationManager.ts

@@ -16,8 +16,7 @@ export class AuthenticationManager extends BaseManager {
    * Get authentication from environment variables
    */
   static getAuthFromEnv(): AuthConfig {
-    const method: AuthMethod =
-      (process.env.WORDPRESS_AUTH_METHOD as AuthMethod) || "app-password";
+    const method: AuthMethod = (process.env.WORDPRESS_AUTH_METHOD as AuthMethod) || "app-password";
 
     switch (method) {
       case "app-password":
@@ -31,10 +30,7 @@ export class AuthenticationManager extends BaseManager {
         return {
           method: "jwt",
           username: process.env.WORDPRESS_USERNAME || "",
-          password:
-            process.env.WORDPRESS_JWT_PASSWORD ||
-            process.env.WORDPRESS_PASSWORD ||
-            "",
+          password: process.env.WORDPRESS_JWT_PASSWORD || process.env.WORDPRESS_PASSWORD || "",
           secret: process.env.WORDPRESS_JWT_SECRET || "",
         };
 
@@ -52,10 +48,7 @@ export class AuthenticationManager extends BaseManager {
         };
 
       default:
-        throw new AuthenticationError(
-          `Unsupported authentication method: ${method}`,
-          method,
-        );
+        throw new AuthenticationError(`Unsupported authentication method: ${method}`, method);
     }
   }
 
@@ -65,18 +58,17 @@ export class AuthenticationManager extends BaseManager {
   async getAuthHeaders(): Promise<Record<string, string>> {
     const auth = this.config.auth;
 
+    if (!auth) {
+      throw new AuthenticationError("Authentication configuration is required", "app-password");
+    }
+
     switch (auth.method) {
       case "app-password":
         if (!auth.username || !auth.appPassword) {
-          throw new AuthenticationError(
-            "Username and app password are required",
-            auth.method,
-          );
+          throw new AuthenticationError("Username and app password are required", auth.method);
         }
 
-        const credentials = Buffer.from(
-          `${auth.username}:${auth.appPassword}`,
-        ).toString("base64");
+        const credentials = Buffer.from(`${auth.username}:${auth.appPassword}`).toString("base64");
         return { Authorization: `Basic ${credentials}` };
 
       case "jwt":
@@ -87,15 +79,10 @@ export class AuthenticationManager extends BaseManager {
 
       case "basic":
         if (!auth.username || !auth.password) {
-          throw new AuthenticationError(
-            "Username and password are required",
-            auth.method,
-          );
+          throw new AuthenticationError("Username and password are required", auth.method);
         }
 
-        const basicCredentials = Buffer.from(
-          `${auth.username}:${auth.password}`,
-        ).toString("base64");
+        const basicCredentials = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
         return { Authorization: `Basic ${basicCredentials}` };
 
       case "api-key":
@@ -105,10 +92,7 @@ export class AuthenticationManager extends BaseManager {
         return { "X-API-Key": auth.apiKey };
 
       default:
-        throw new AuthenticationError(
-          `Unsupported authentication method: ${auth.method}`,
-          auth.method,
-        );
+        throw new AuthenticationError(`Unsupported authentication method: ${auth.method}`, auth.method);
     }
   }
 
@@ -119,19 +103,13 @@ export class AuthenticationManager extends BaseManager {
     const auth = this.config.auth;
 
     if (auth.method !== "jwt" || !auth.username || !auth.password) {
-      throw new AuthenticationError(
-        "JWT authentication requires username and password",
-        "jwt",
-      );
+      throw new AuthenticationError("JWT authentication requires username and password", "jwt");
     }
 
     try {
       // This would need the RequestManager instance to make the request
       // For now, we'll throw an error indicating this needs to be implemented
-      throw new AuthenticationError(
-        "JWT authentication requires RequestManager integration",
-        "jwt",
-      );
+      throw new AuthenticationError("JWT authentication requires RequestManager integration", "jwt");
     } catch (error) {
       this.handleError(error, "JWT authentication");
     }
@@ -180,10 +158,7 @@ export class AuthenticationManager extends BaseManager {
     const auth = this.config.auth;
 
     if (!auth.method) {
-      throw new AuthenticationError(
-        "Authentication method is required",
-        "app-password",
-      );
+      throw new AuthenticationError("Authentication method is required", "app-password");
     }
 
     switch (auth.method) {
@@ -198,36 +173,24 @@ export class AuthenticationManager extends BaseManager {
 
       case "jwt":
         if (!auth.username || !auth.password || !auth.secret) {
-          throw new AuthenticationError(
-            "JWT authentication requires username, password, and secret",
-            "jwt",
-          );
+          throw new AuthenticationError("JWT authentication requires username, password, and secret", "jwt");
         }
         break;
 
       case "basic":
         if (!auth.username || !auth.password) {
-          throw new AuthenticationError(
-            "Basic authentication requires username and password",
-            "basic",
-          );
+          throw new AuthenticationError("Basic authentication requires username and password", "basic");
         }
         break;
 
       case "api-key":
         if (!auth.apiKey) {
-          throw new AuthenticationError(
-            "API key authentication requires apiKey",
-            "api-key",
-          );
+          throw new AuthenticationError("API key authentication requires apiKey", "api-key");
         }
         break;
 
       default:
-        throw new AuthenticationError(
-          `Unsupported authentication method: ${auth.method}`,
-          auth.method,
-        );
+        throw new AuthenticationError(`Unsupported authentication method: ${auth.method}`, auth.method);
     }
   }
 }

package/src/config/ConfigurationSchema.ts

@@ -3,13 +3,7 @@ import { z } from "zod";
 /**
  * Zod schema for WordPress authentication methods
  */
-const AuthMethodSchema = z.enum([
-  "app-password",
-  "jwt",
-  "basic",
-  "api-key",
-  "cookie",
-] as const);
+const AuthMethodSchema = z.enum(["app-password", "jwt", "basic", "api-key", "cookie"] as const);
 
 /**
  * Zod schema for URL validation
@@ -51,14 +45,8 @@ const SiteSchema = z.object({
     .string()
     .min(1, "Site ID is required")
     .max(50, "Site ID must be 50 characters or less")
-    .regex(
-      /^[a-zA-Z0-9_-]+$/,
-      "Site ID can only contain letters, numbers, underscores, and hyphens",
-    ),
-  name: z
-    .string()
-    .min(1, "Site name is required")
-    .max(100, "Site name must be 100 characters or less"),
+    .regex(/^[a-zA-Z0-9_-]+$/, "Site ID can only contain letters, numbers, underscores, and hyphens"),
+  name: z.string().min(1, "Site name is required").max(100, "Site name must be 100 characters or less"),
   config: SiteConfigSchema,
 });
 
@@ -96,7 +84,7 @@ const EnvironmentConfigSchema = z.object({
   WORDPRESS_APP_PASSWORD: SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD,
   WORDPRESS_AUTH_METHOD: AuthMethodSchema.optional().default("app-password"),
   // Optional environment variables
-  NODE_ENV: z.enum(["development", "production", "test"]).optional(),
+  NODE_ENV: z.enum(["development", "production", "test", "dxt", "ci"]).optional(),
   DEBUG: z.string().optional(),
   DISABLE_CACHE: z.string().optional(),
   LOG_LEVEL: z.enum(["error", "warn", "info", "debug"]).optional(),
@@ -109,8 +97,7 @@ const McpConfigSchema = z
   .object({
     wordpressSiteUrl: UrlSchema.optional(),
     wordpressUsername: SiteConfigSchema.shape.WORDPRESS_USERNAME.optional(),
-    wordpressAppPassword:
-      SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD.optional(),
+    wordpressAppPassword: SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD.optional(),
     wordpressAuthMethod: AuthMethodSchema.optional(),
   })
   .optional();
@@ -136,12 +123,8 @@ export class ConfigurationValidator {
       return MultiSiteConfigSchema.parse(config);
     } catch (error) {
       if (error instanceof z.ZodError) {
-        const messages = error.errors
-          .map((err) => `${err.path.join(".")}: ${err.message}`)
-          .join("; ");
-        throw new Error(
-          `Multi-site configuration validation failed: ${messages}`,
-        );
+        const messages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
+        throw new Error(`Multi-site configuration validation failed: ${messages}`);
       }
       throw error;
     }
@@ -150,19 +133,13 @@ export class ConfigurationValidator {
   /**
    * Validate environment configuration for single-site mode
    */
-  static validateEnvironmentConfig(
-    env: Record<string, string | undefined>,
-  ): EnvironmentConfigType {
+  static validateEnvironmentConfig(env: Record<string, string | undefined>): EnvironmentConfigType {
     try {
       return EnvironmentConfigSchema.parse(env);
     } catch (error) {
       if (error instanceof z.ZodError) {
-        const messages = error.errors
-          .map((err) => `${err.path.join(".")}: ${err.message}`)
-          .join("; ");
-        throw new Error(
-          `Environment configuration validation failed: ${messages}`,
-        );
+        const messages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
+        throw new Error(`Environment configuration validation failed: ${messages}`);
       }
       throw error;
     }
@@ -176,9 +153,7 @@ export class ConfigurationValidator {
       return McpConfigSchema.parse(config);
     } catch (error) {
       if (error instanceof z.ZodError) {
-        const messages = error.errors
-          .map((err) => `${err.path.join(".")}: ${err.message}`)
-          .join("; ");
+        const messages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
         throw new Error(`MCP configuration validation failed: ${messages}`);
       }
       throw error;
@@ -193,9 +168,7 @@ export class ConfigurationValidator {
       return SiteSchema.parse(config);
     } catch (error) {
       if (error instanceof z.ZodError) {
-        const messages = error.errors
-          .map((err) => `${err.path.join(".")}: ${err.message}`)
-          .join("; ");
+        const messages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
         throw new Error(`Site configuration validation failed: ${messages}`);
       }
       throw error;
@@ -213,9 +186,7 @@ export class ConfigurationValidator {
   /**
    * Check if environment configuration is valid without throwing
    */
-  static isValidEnvironmentConfig(
-    env: Record<string, string | undefined>,
-  ): boolean {
+  static isValidEnvironmentConfig(env: Record<string, string | undefined>): boolean {
     const result = EnvironmentConfigSchema.safeParse(env);
     return result.success;
   }
@@ -228,9 +199,7 @@ export class ConfigurationValidator {
     if (result.success) {
       return [];
     }
-    return result.error.errors.map(
-      (err) => `${err.path.join(".")}: ${err.message}`,
-    );
+    return result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`);
   }
 }
 

package/src/config/ServerConfiguration.ts

@@ -4,6 +4,7 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import { WordPressClient } from "../client/api.js";
 import { CachedWordPressClient } from "../client/CachedWordPressClient.js";
+import { MockWordPressClient } from "../client/MockWordPressClient.js";
 import { WordPressClientConfig } from "../types/client.js";
 import { getErrorMessage } from "../utils/error.js";
 import {
@@ -34,13 +35,14 @@ export class ServerConfiguration {
     // Load environment variables
     dotenv.config({ path: this.envPath });
 
-    // Debug output for DXT troubleshooting
-    console.error("DEBUG: ServerConfiguration initialized");
-    console.error(`DEBUG: Root directory: ${this.rootDir}`);
-    console.error(`DEBUG: Environment file path: ${this.envPath}`);
-    console.error(
-      `DEBUG: Environment file exists: ${fs.existsSync(this.envPath)}`,
-    );
+    // Debug output for DXT troubleshooting (reduced in DXT mode)
+    const isDXTMode = process.env.NODE_ENV === "dxt";
+    if (!isDXTMode) {
+      console.error("DEBUG: ServerConfiguration initialized");
+      console.error(`DEBUG: Root directory: ${this.rootDir}`);
+      console.error(`DEBUG: Environment file path: ${this.envPath}`);
+      console.error(`DEBUG: Environment file exists: ${fs.existsSync(this.envPath)}`);
+    }
   }
 
   /**
@@ -65,9 +67,7 @@ export class ServerConfiguration {
 
     if (fs.existsSync(configPath)) {
       if (process.env.NODE_ENV !== "test") {
-        console.error(
-          "INFO: Found mcp-wordpress.config.json, loading multi-site configuration.",
-        );
+        console.error("INFO: Found mcp-wordpress.config.json, loading multi-site configuration.");
       }
       return this.loadMultiSiteConfig(configPath);
     } else {
@@ -116,21 +116,69 @@ export class ServerConfiguration {
         validConfigs.push(site);
 
         if (process.env.NODE_ENV !== "test") {
-          console.error(
-            `INFO: Initialized client for site: ${site.name} (ID: ${site.id})`,
-          );
+          console.error(`INFO: Initialized client for site: ${site.name} (ID: ${site.id})`);
         }
       }
 
       return { clients, configs: validConfigs };
     } catch (error) {
-      console.error(
-        `FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`,
-      );
+      console.error(`FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`);
       process.exit(1);
     }
   }
 
+  /**
+   * Check if we're in CI environment
+   */
+  private isCIEnvironment(): boolean {
+    return (
+      process.env.CI === "true" ||
+      process.env.NODE_ENV === "ci" ||
+      process.env.NODE_ENV === "test" ||
+      process.env.GITHUB_ACTIONS === "true" ||
+      process.env.TRAVIS === "true" ||
+      process.env.CIRCLECI === "true"
+    );
+  }
+
+  /**
+   * Create mock configuration for CI environments
+   */
+  private createMockConfiguration(): {
+    clients: Map<string, WordPressClient>;
+    configs: SiteConfig[];
+  } {
+    const mockConfig = {
+      WORDPRESS_SITE_URL: "https://demo.wordpress.com",
+      WORDPRESS_USERNAME: "ci-user",
+      WORDPRESS_APP_PASSWORD: "ci-mock-password",
+      WORDPRESS_AUTH_METHOD: "app-password" as const,
+    };
+
+    const clientConfig: WordPressClientConfig = {
+      baseUrl: mockConfig.WORDPRESS_SITE_URL,
+      auth: {
+        method: mockConfig.WORDPRESS_AUTH_METHOD,
+        username: mockConfig.WORDPRESS_USERNAME,
+        appPassword: mockConfig.WORDPRESS_APP_PASSWORD,
+      },
+    };
+
+    // Create mock client that won't actually connect to WordPress
+    const client = new MockWordPressClient(clientConfig);
+    const clients = new Map<string, WordPressClient>();
+    clients.set("default", client);
+
+    const siteConfig: SiteConfig = {
+      id: "default",
+      name: "Demo Site (CI Mode)",
+      config: mockConfig,
+    };
+
+    console.error("INFO: Using mock configuration for CI environment.");
+    return { clients, configs: [siteConfig] };
+  }
+
   /**
    * Load single-site configuration from environment variables
    */
@@ -139,66 +187,49 @@ export class ServerConfiguration {
     configs: SiteConfig[];
   } {
     try {
-      // Debug output for DXT troubleshooting
-      console.error("DEBUG: loadSingleSiteFromEnv called");
-      console.error(`DEBUG: mcpConfig provided: ${mcpConfig ? "YES" : "NO"}`);
-      console.error("DEBUG: Current environment variables:");
-      console.error(
-        `  WORDPRESS_SITE_URL: ${process.env.WORDPRESS_SITE_URL || "NOT SET"}`,
-      );
-      console.error(
-        `  WORDPRESS_USERNAME: ${process.env.WORDPRESS_USERNAME || "NOT SET"}`,
-      );
-      console.error(
-        `  WORDPRESS_APP_PASSWORD: ${process.env.WORDPRESS_APP_PASSWORD ? "SET" : "NOT SET"}`,
-      );
-      console.error(
-        `  WORDPRESS_AUTH_METHOD: ${process.env.WORDPRESS_AUTH_METHOD || "NOT SET"}`,
-      );
+      // Debug output for DXT troubleshooting (reduced in DXT mode)
+      const isDXTMode = process.env.NODE_ENV === "dxt";
+      if (!isDXTMode) {
+        console.error("DEBUG: loadSingleSiteFromEnv called");
+        console.error(`DEBUG: mcpConfig provided: ${mcpConfig ? "YES" : "NO"}`);
+        console.error("DEBUG: Current environment variables:");
+        console.error(`  WORDPRESS_SITE_URL: ${process.env.WORDPRESS_SITE_URL || "NOT SET"}`);
+        console.error(`  WORDPRESS_USERNAME: ${process.env.WORDPRESS_USERNAME || "NOT SET"}`);
+        console.error(`  WORDPRESS_APP_PASSWORD: ${process.env.WORDPRESS_APP_PASSWORD ? "SET" : "NOT SET"}`);
+        console.error(`  WORDPRESS_AUTH_METHOD: ${process.env.WORDPRESS_AUTH_METHOD || "NOT SET"}`);
+      }
+
+      // Check if we're in CI environment and credentials are missing
+      if (this.isCIEnvironment() && !process.env.WORDPRESS_SITE_URL) {
+        return this.createMockConfiguration();
+      }
 
       // Validate MCP config if provided
-      const validatedMcpConfig = mcpConfig
-        ? ConfigurationValidator.validateMcpConfig(mcpConfig)
-        : undefined;
+      const validatedMcpConfig = mcpConfig ? ConfigurationValidator.validateMcpConfig(mcpConfig) : undefined;
 
       // Prepare environment configuration for validation
       const envConfig = {
-        WORDPRESS_SITE_URL:
-          validatedMcpConfig?.wordpressSiteUrl ||
-          process.env.WORDPRESS_SITE_URL,
-        WORDPRESS_USERNAME:
-          validatedMcpConfig?.wordpressUsername ||
-          process.env.WORDPRESS_USERNAME,
-        WORDPRESS_APP_PASSWORD:
-          validatedMcpConfig?.wordpressAppPassword ||
-          process.env.WORDPRESS_APP_PASSWORD,
+        WORDPRESS_SITE_URL: validatedMcpConfig?.wordpressSiteUrl || process.env.WORDPRESS_SITE_URL,
+        WORDPRESS_USERNAME: validatedMcpConfig?.wordpressUsername || process.env.WORDPRESS_USERNAME,
+        WORDPRESS_APP_PASSWORD: validatedMcpConfig?.wordpressAppPassword || process.env.WORDPRESS_APP_PASSWORD,
         WORDPRESS_AUTH_METHOD:
-          validatedMcpConfig?.wordpressAuthMethod ||
-          process.env.WORDPRESS_AUTH_METHOD ||
-          "app-password",
+          validatedMcpConfig?.wordpressAuthMethod || process.env.WORDPRESS_AUTH_METHOD || "app-password",
         NODE_ENV: process.env.NODE_ENV,
         DEBUG: process.env.DEBUG,
         DISABLE_CACHE: process.env.DISABLE_CACHE,
         LOG_LEVEL: process.env.LOG_LEVEL,
       };
 
-      console.error("DEBUG: Final envConfig for validation:");
-      console.error(
-        `  WORDPRESS_SITE_URL: ${envConfig.WORDPRESS_SITE_URL || "NOT SET"}`,
-      );
-      console.error(
-        `  WORDPRESS_USERNAME: ${envConfig.WORDPRESS_USERNAME || "NOT SET"}`,
-      );
-      console.error(
-        `  WORDPRESS_APP_PASSWORD: ${envConfig.WORDPRESS_APP_PASSWORD ? "SET" : "NOT SET"}`,
-      );
-      console.error(
-        `  WORDPRESS_AUTH_METHOD: ${envConfig.WORDPRESS_AUTH_METHOD || "NOT SET"}`,
-      );
+      if (!isDXTMode) {
+        console.error("DEBUG: Final envConfig for validation:");
+        console.error(`  WORDPRESS_SITE_URL: ${envConfig.WORDPRESS_SITE_URL || "NOT SET"}`);
+        console.error(`  WORDPRESS_USERNAME: ${envConfig.WORDPRESS_USERNAME || "NOT SET"}`);
+        console.error(`  WORDPRESS_APP_PASSWORD: ${envConfig.WORDPRESS_APP_PASSWORD ? "SET" : "NOT SET"}`);
+        console.error(`  WORDPRESS_AUTH_METHOD: ${envConfig.WORDPRESS_AUTH_METHOD || "NOT SET"}`);
+      }
 
       // Validate environment configuration using Zod schema
-      const validatedConfig =
-        ConfigurationValidator.validateEnvironmentConfig(envConfig);
+      const validatedConfig = ConfigurationValidator.validateEnvironmentConfig(envConfig);
 
       const clientConfig: WordPressClientConfig = {
         baseUrl: validatedConfig.WORDPRESS_SITE_URL,
@@ -228,19 +259,15 @@ export class ServerConfiguration {
         },
       };
 
-      console.error(
-        "INFO: Initialized client for default site in single-site mode.",
-      );
+      if (!isDXTMode) {
+        console.error("INFO: Initialized client for default site in single-site mode.");
+      }
 
       return { clients, configs: [siteConfig] };
     } catch (error) {
-      console.error(
-        "ERROR: Configuration validation failed for single-site mode.",
-      );
+      console.error("ERROR: Configuration validation failed for single-site mode.");
       console.error(`Details: ${getErrorMessage(error)}`);
-      console.error(
-        "Please check your environment variables or MCP configuration.",
-      );
+      console.error("Please check your environment variables or MCP configuration.");
       return { clients: new Map(), configs: [] };
     }
   }