mcp-wordpress 1.2.2 → 1.3.0

package/src/config/ConfigurationSchema.ts

@@ -1,14 +1,14 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 /**
  * Zod schema for WordPress authentication methods
  */
 const AuthMethodSchema = z.enum([
-  'app-password',
-  'jwt',
-  'basic',
-  'api-key',
-  'cookie'
+  "app-password",
+  "jwt",
+  "basic",
+  "api-key",
+  "cookie",
 ] as const);
 
 /**
@@ -16,11 +16,11 @@ const AuthMethodSchema = z.enum([
  */
 const UrlSchema = z
   .string()
-  .url('Must be a valid URL')
+  .url("Must be a valid URL")
   .refine((url) => {
     const parsed = new URL(url);
-    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
-  }, 'URL must use http or https protocol');
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  }, "URL must use http or https protocol");
 
 /**
  * Zod schema for WordPress site configuration
@@ -29,18 +29,18 @@ const SiteConfigSchema = z.object({
   WORDPRESS_SITE_URL: UrlSchema,
   WORDPRESS_USERNAME: z
     .string()
-    .min(1, 'Username is required')
-    .max(60, 'Username must be 60 characters or less')
-    .regex(/^[a-zA-Z0-9._@-]+$/, 'Username contains invalid characters'),
+    .min(1, "Username is required")
+    .max(60, "Username must be 60 characters or less")
+    .regex(/^[a-zA-Z0-9._@-]+$/, "Username contains invalid characters"),
   WORDPRESS_APP_PASSWORD: z
     .string()
-    .min(1, 'Password is required')
+    .min(1, "Password is required")
     .refine((password) => {
       // WordPress app passwords are typically 24 characters with spaces
       // But we'll be flexible to support different auth methods
       return password.length >= 8;
-    }, 'Password must be at least 8 characters'),
-  WORDPRESS_AUTH_METHOD: AuthMethodSchema.optional().default('app-password')
+    }, "Password must be at least 8 characters"),
+  WORDPRESS_AUTH_METHOD: AuthMethodSchema.optional().default("app-password"),
 });
 
 /**
@@ -49,17 +49,17 @@ const SiteConfigSchema = z.object({
 const SiteSchema = z.object({
   id: z
     .string()
-    .min(1, 'Site ID is required')
-    .max(50, 'Site ID must be 50 characters or less')
+    .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'
+      "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
+    .min(1, "Site name is required")
+    .max(100, "Site name must be 100 characters or less"),
+  config: SiteConfigSchema,
 });
 
 /**
@@ -68,23 +68,23 @@ const SiteSchema = z.object({
 const MultiSiteConfigSchema = z.object({
   sites: z
     .array(SiteSchema)
-    .min(1, 'At least one site must be configured')
-    .max(50, 'Maximum of 50 sites supported')
+    .min(1, "At least one site must be configured")
+    .max(50, "Maximum of 50 sites supported")
     .refine((sites) => {
       const ids = sites.map((site) => site.id);
       const uniqueIds = new Set(ids);
       return ids.length === uniqueIds.size;
-    }, 'Site IDs must be unique')
+    }, "Site IDs must be unique")
     .refine((sites) => {
       const names = sites.map((site) => site.name);
       const uniqueNames = new Set(names);
       return names.length === uniqueNames.size;
-    }, 'Site names must be unique')
+    }, "Site names must be unique")
     .refine((sites) => {
       const urls = sites.map((site) => site.config.WORDPRESS_SITE_URL);
       const uniqueUrls = new Set(urls);
       return urls.length === uniqueUrls.size;
-    }, 'Site URLs must be unique')
+    }, "Site URLs must be unique"),
 });
 
 /**
@@ -94,12 +94,12 @@ const EnvironmentConfigSchema = z.object({
   WORDPRESS_SITE_URL: UrlSchema,
   WORDPRESS_USERNAME: SiteConfigSchema.shape.WORDPRESS_USERNAME,
   WORDPRESS_APP_PASSWORD: SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD,
-  WORDPRESS_AUTH_METHOD: AuthMethodSchema.optional().default('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"]).optional(),
   DEBUG: z.string().optional(),
   DISABLE_CACHE: z.string().optional(),
-  LOG_LEVEL: z.enum(['error', 'warn', 'info', 'debug']).optional()
+  LOG_LEVEL: z.enum(["error", "warn", "info", "debug"]).optional(),
 });
 
 /**
@@ -111,7 +111,7 @@ const McpConfigSchema = z
     wordpressUsername: SiteConfigSchema.shape.WORDPRESS_USERNAME.optional(),
     wordpressAppPassword:
       SiteConfigSchema.shape.WORDPRESS_APP_PASSWORD.optional(),
-    wordpressAuthMethod: AuthMethodSchema.optional()
+    wordpressAuthMethod: AuthMethodSchema.optional(),
   })
   .optional();
 
@@ -137,10 +137,10 @@ export class ConfigurationValidator {
     } catch (error) {
       if (error instanceof z.ZodError) {
         const messages = error.errors
-          .map((err) => `${err.path.join('.')}: ${err.message}`)
-          .join('; ');
+          .map((err) => `${err.path.join(".")}: ${err.message}`)
+          .join("; ");
         throw new Error(
-          `Multi-site configuration validation failed: ${messages}`
+          `Multi-site configuration validation failed: ${messages}`,
         );
       }
       throw error;
@@ -151,17 +151,17 @@ export class ConfigurationValidator {
    * Validate environment configuration for single-site mode
    */
   static validateEnvironmentConfig(
-    env: Record<string, string | undefined>
+    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('; ');
+          .map((err) => `${err.path.join(".")}: ${err.message}`)
+          .join("; ");
         throw new Error(
-          `Environment configuration validation failed: ${messages}`
+          `Environment configuration validation failed: ${messages}`,
         );
       }
       throw error;
@@ -177,8 +177,8 @@ export class ConfigurationValidator {
     } catch (error) {
       if (error instanceof z.ZodError) {
         const messages = error.errors
-          .map((err) => `${err.path.join('.')}: ${err.message}`)
-          .join('; ');
+          .map((err) => `${err.path.join(".")}: ${err.message}`)
+          .join("; ");
         throw new Error(`MCP configuration validation failed: ${messages}`);
       }
       throw error;
@@ -194,8 +194,8 @@ export class ConfigurationValidator {
     } catch (error) {
       if (error instanceof z.ZodError) {
         const messages = error.errors
-          .map((err) => `${err.path.join('.')}: ${err.message}`)
-          .join('; ');
+          .map((err) => `${err.path.join(".")}: ${err.message}`)
+          .join("; ");
         throw new Error(`Site configuration validation failed: ${messages}`);
       }
       throw error;
@@ -214,7 +214,7 @@ export class ConfigurationValidator {
    * Check if environment configuration is valid without throwing
    */
   static isValidEnvironmentConfig(
-    env: Record<string, string | undefined>
+    env: Record<string, string | undefined>,
   ): boolean {
     const result = EnvironmentConfigSchema.safeParse(env);
     return result.success;
@@ -229,7 +229,7 @@ export class ConfigurationValidator {
       return [];
     }
     return result.error.errors.map(
-      (err) => `${err.path.join('.')}: ${err.message}`
+      (err) => `${err.path.join(".")}: ${err.message}`,
     );
   }
 }
@@ -242,5 +242,5 @@ export {
   EnvironmentConfigSchema,
   McpConfigSchema,
   AuthMethodSchema,
-  UrlSchema
+  UrlSchema,
 };

package/src/config/ServerConfiguration.ts

@@ -1,17 +1,17 @@
-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 { CachedWordPressClient } from '../client/CachedWordPressClient.js';
-import { WordPressClientConfig } from '../types/client.js';
-import { getErrorMessage } from '../utils/error.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 { CachedWordPressClient } from "../client/CachedWordPressClient.js";
+import { WordPressClientConfig } from "../types/client.js";
+import { getErrorMessage } from "../utils/error.js";
 import {
   ConfigurationValidator,
   type SiteType as SiteConfig,
   type MultiSiteConfigType as MultiSiteConfig,
-  type McpConfigType
-} from './ConfigurationSchema.js';
+  type McpConfigType,
+} from "./ConfigurationSchema.js";
 
 // Re-export types from schema for backward compatibility
 export type { SiteConfig, MultiSiteConfig };
@@ -28,8 +28,8 @@ export class ServerConfiguration {
   constructor() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    this.rootDir = path.resolve(__dirname, '../..');
-    this.envPath = path.resolve(this.rootDir, '.env');
+    this.rootDir = path.resolve(__dirname, "../..");
+    this.envPath = path.resolve(this.rootDir, ".env");
 
     // Load environment variables
     dotenv.config({ path: this.envPath });
@@ -53,19 +53,19 @@ export class ServerConfiguration {
     clients: Map<string, WordPressClient>;
     configs: SiteConfig[];
   } {
-    const configPath = path.resolve(this.rootDir, 'mcp-wordpress.config.json');
+    const configPath = path.resolve(this.rootDir, "mcp-wordpress.config.json");
 
     if (fs.existsSync(configPath)) {
-      if (process.env.NODE_ENV !== 'test') {
+      if (process.env.NODE_ENV !== "test") {
         console.error(
-          'INFO: Found mcp-wordpress.config.json, loading multi-site configuration.'
+          "INFO: Found mcp-wordpress.config.json, loading multi-site configuration.",
         );
       }
       return this.loadMultiSiteConfig(configPath);
     } else {
-      if (process.env.NODE_ENV !== 'test') {
+      if (process.env.NODE_ENV !== "test") {
         console.error(
-          'INFO: mcp-wordpress.config.json not found, falling back to environment variables for single-site mode.'
+          "INFO: mcp-wordpress.config.json not found, falling back to environment variables for single-site mode.",
         );
       }
       return this.loadSingleSiteFromEnv(mcpConfig);
@@ -80,7 +80,7 @@ export class ServerConfiguration {
     configs: SiteConfig[];
   } {
     try {
-      const configFile = fs.readFileSync(configPath, 'utf-8');
+      const configFile = fs.readFileSync(configPath, "utf-8");
       const rawConfig = JSON.parse(configFile);
 
       // Validate configuration using Zod schema
@@ -93,23 +93,23 @@ export class ServerConfiguration {
         const clientConfig: WordPressClientConfig = {
           baseUrl: site.config.WORDPRESS_SITE_URL,
           auth: {
-            method: site.config.WORDPRESS_AUTH_METHOD || 'app-password',
+            method: site.config.WORDPRESS_AUTH_METHOD || "app-password",
             username: site.config.WORDPRESS_USERNAME,
-            appPassword: site.config.WORDPRESS_APP_PASSWORD
-          }
+            appPassword: site.config.WORDPRESS_APP_PASSWORD,
+          },
         };
 
         // Use cached client for better performance
         const client =
-          process.env.DISABLE_CACHE === 'true'
+          process.env.DISABLE_CACHE === "true"
             ? new WordPressClient(clientConfig)
             : new CachedWordPressClient(clientConfig, site.id);
         clients.set(site.id, client);
         validConfigs.push(site);
 
-        if (process.env.NODE_ENV !== 'test') {
+        if (process.env.NODE_ENV !== "test") {
           console.error(
-            `INFO: Initialized client for site: ${site.name} (ID: ${site.id})`
+            `INFO: Initialized client for site: ${site.name} (ID: ${site.id})`,
           );
         }
       }
@@ -117,7 +117,7 @@ export class ServerConfiguration {
       return { clients, configs: validConfigs };
     } catch (error) {
       console.error(
-        `FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`
+        `FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`,
       );
       process.exit(1);
     }
@@ -150,11 +150,11 @@ export class ServerConfiguration {
         WORDPRESS_AUTH_METHOD:
           validatedMcpConfig?.wordpressAuthMethod ||
           process.env.WORDPRESS_AUTH_METHOD ||
-          'app-password',
+          "app-password",
         NODE_ENV: process.env.NODE_ENV,
         DEBUG: process.env.DEBUG,
         DISABLE_CACHE: process.env.DISABLE_CACHE,
-        LOG_LEVEL: process.env.LOG_LEVEL
+        LOG_LEVEL: process.env.LOG_LEVEL,
       };
 
       // Validate environment configuration using Zod schema
@@ -166,41 +166,41 @@ export class ServerConfiguration {
         auth: {
           method: validatedConfig.WORDPRESS_AUTH_METHOD,
           username: validatedConfig.WORDPRESS_USERNAME,
-          appPassword: validatedConfig.WORDPRESS_APP_PASSWORD
-        }
+          appPassword: validatedConfig.WORDPRESS_APP_PASSWORD,
+        },
       };
 
       // Use cached client for better performance
       const client =
-        process.env.DISABLE_CACHE === 'true'
+        process.env.DISABLE_CACHE === "true"
           ? new WordPressClient(clientConfig)
-          : new CachedWordPressClient(clientConfig, 'default');
+          : new CachedWordPressClient(clientConfig, "default");
       const clients = new Map<string, WordPressClient>();
-      clients.set('default', client);
+      clients.set("default", client);
 
       const siteConfig: SiteConfig = {
-        id: 'default',
-        name: 'Default Site',
+        id: "default",
+        name: "Default Site",
         config: {
           WORDPRESS_SITE_URL: validatedConfig.WORDPRESS_SITE_URL,
           WORDPRESS_USERNAME: validatedConfig.WORDPRESS_USERNAME,
           WORDPRESS_APP_PASSWORD: validatedConfig.WORDPRESS_APP_PASSWORD,
-          WORDPRESS_AUTH_METHOD: validatedConfig.WORDPRESS_AUTH_METHOD
-        }
+          WORDPRESS_AUTH_METHOD: validatedConfig.WORDPRESS_AUTH_METHOD,
+        },
       };
 
       console.error(
-        'INFO: Initialized client for default site in single-site mode.'
+        "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.'
+        "ERROR: Configuration validation failed for single-site mode.",
       );
       console.error(`Details: ${getErrorMessage(error)}`);
       console.error(
-        'Please check your environment variables or MCP configuration.'
+        "Please check your environment variables or MCP configuration.",
       );
       return { clients: new Map(), configs: [] };
     }