mcp-wordpress 1.2.2 → 1.3.0

package/src/client/managers/AuthenticationManager.ts

@@ -3,10 +3,10 @@
  * Handles all authentication methods and token management
  */
 
-import type { AuthConfig, AuthMethod } from '../../types/client.js';
-import { AuthenticationError } from '../../types/client.js';
-import { BaseManager } from './BaseManager.js';
-import { debug } from '../../utils/debug.js';
+import type { AuthConfig, AuthMethod } from "../../types/client.js";
+import { AuthenticationError } from "../../types/client.js";
+import { BaseManager } from "./BaseManager.js";
+import { debug } from "../../utils/debug.js";
 
 export class AuthenticationManager extends BaseManager {
   private jwtToken: string | null = null;
@@ -17,44 +17,44 @@ export class AuthenticationManager extends BaseManager {
    */
   static getAuthFromEnv(): AuthConfig {
     const method: AuthMethod =
-      (process.env.WORDPRESS_AUTH_METHOD as AuthMethod) || 'app-password';
+      (process.env.WORDPRESS_AUTH_METHOD as AuthMethod) || "app-password";
 
     switch (method) {
-    case 'app-password':
+    case "app-password":
       return {
-        method: 'app-password',
-        username: process.env.WORDPRESS_USERNAME || '',
-        appPassword: process.env.WORDPRESS_APP_PASSWORD || ''
+        method: "app-password",
+        username: process.env.WORDPRESS_USERNAME || "",
+        appPassword: process.env.WORDPRESS_APP_PASSWORD || "",
       };
 
-    case 'jwt':
+    case "jwt":
       return {
-        method: 'jwt',
-        username: process.env.WORDPRESS_USERNAME || '',
+        method: "jwt",
+        username: process.env.WORDPRESS_USERNAME || "",
         password:
             process.env.WORDPRESS_JWT_PASSWORD ||
             process.env.WORDPRESS_PASSWORD ||
-            '',
-        secret: process.env.WORDPRESS_JWT_SECRET || ''
+            "",
+        secret: process.env.WORDPRESS_JWT_SECRET || "",
       };
 
-    case 'basic':
+    case "basic":
       return {
-        method: 'basic',
-        username: process.env.WORDPRESS_USERNAME || '',
-        password: process.env.WORDPRESS_PASSWORD || ''
+        method: "basic",
+        username: process.env.WORDPRESS_USERNAME || "",
+        password: process.env.WORDPRESS_PASSWORD || "",
       };
 
-    case 'api-key':
+    case "api-key":
       return {
-        method: 'api-key',
-        apiKey: process.env.WORDPRESS_API_KEY || ''
+        method: "api-key",
+        apiKey: process.env.WORDPRESS_API_KEY || "",
       };
 
     default:
       throw new AuthenticationError(
         `Unsupported authentication method: ${method}`,
-        method
+        method,
       );
     }
   }
@@ -66,48 +66,48 @@ export class AuthenticationManager extends BaseManager {
     const auth = this.config.auth;
 
     switch (auth.method) {
-    case 'app-password':
+    case "app-password":
       if (!auth.username || !auth.appPassword) {
         throw new AuthenticationError(
-          'Username and app password are required',
-          auth.method
+          "Username and app password are required",
+          auth.method,
         );
       }
 
       const credentials = Buffer.from(
-        `${auth.username}:${auth.appPassword}`
-      ).toString('base64');
+        `${auth.username}:${auth.appPassword}`,
+      ).toString("base64");
       return { Authorization: `Basic ${credentials}` };
 
-    case 'jwt':
+    case "jwt":
       if (!this.jwtToken) {
         await this.authenticateJWT();
       }
       return { Authorization: `Bearer ${this.jwtToken}` };
 
-    case 'basic':
+    case "basic":
       if (!auth.username || !auth.password) {
         throw new AuthenticationError(
-          'Username and password are required',
-          auth.method
+          "Username and password are required",
+          auth.method,
         );
       }
 
       const basicCredentials = Buffer.from(
-        `${auth.username}:${auth.password}`
-      ).toString('base64');
+        `${auth.username}:${auth.password}`,
+      ).toString("base64");
       return { Authorization: `Basic ${basicCredentials}` };
 
-    case 'api-key':
+    case "api-key":
       if (!auth.apiKey) {
-        throw new AuthenticationError('API key is required', auth.method);
+        throw new AuthenticationError("API key is required", auth.method);
       }
-      return { 'X-API-Key': auth.apiKey };
+      return { "X-API-Key": auth.apiKey };
 
     default:
       throw new AuthenticationError(
         `Unsupported authentication method: ${auth.method}`,
-        auth.method
+        auth.method,
       );
     }
   }
@@ -118,10 +118,10 @@ export class AuthenticationManager extends BaseManager {
   private async authenticateJWT(): Promise<void> {
     const auth = this.config.auth;
 
-    if (auth.method !== 'jwt' || !auth.username || !auth.password) {
+    if (auth.method !== "jwt" || !auth.username || !auth.password) {
       throw new AuthenticationError(
-        'JWT authentication requires username and password',
-        'jwt'
+        "JWT authentication requires username and password",
+        "jwt",
       );
     }
 
@@ -129,11 +129,11 @@ export class AuthenticationManager extends BaseManager {
       // 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'
+        "JWT authentication requires RequestManager integration",
+        "jwt",
       );
     } catch (error) {
-      this.handleError(error, 'JWT authentication');
+      this.handleError(error, "JWT authentication");
     }
   }
 
@@ -143,8 +143,8 @@ export class AuthenticationManager extends BaseManager {
   async testAuthentication(): Promise<boolean> {
     try {
       const _headers = await this.getAuthHeaders();
-      debug.log('Authentication headers prepared', {
-        method: this.config.auth.method
+      debug.log("Authentication headers prepared", {
+        method: this.config.auth.method,
       });
 
       // This would need the RequestManager to actually test the connection
@@ -153,7 +153,7 @@ export class AuthenticationManager extends BaseManager {
       return true;
     } catch (error) {
       this.authenticated = false;
-      debug.log('Authentication test failed', error);
+      debug.log("Authentication test failed", error);
       return false;
     }
   }
@@ -181,44 +181,44 @@ export class AuthenticationManager extends BaseManager {
 
     if (!auth.method) {
       throw new AuthenticationError(
-        'Authentication method is required',
-        'app-password'
+        "Authentication method is required",
+        "app-password",
       );
     }
 
     switch (auth.method) {
-    case 'app-password':
+    case "app-password":
       if (!auth.username || !auth.appPassword) {
         throw new AuthenticationError(
-          'App password authentication requires username and appPassword',
-          'app-password'
+          "App password authentication requires username and appPassword",
+          "app-password",
         );
       }
       break;
 
-    case 'jwt':
+    case "jwt":
       if (!auth.username || !auth.password || !auth.secret) {
         throw new AuthenticationError(
-          'JWT authentication requires username, password, and secret',
-          'jwt'
+          "JWT authentication requires username, password, and secret",
+          "jwt",
         );
       }
       break;
 
-    case 'basic':
+    case "basic":
       if (!auth.username || !auth.password) {
         throw new AuthenticationError(
-          'Basic authentication requires username and password',
-          'basic'
+          "Basic authentication requires username and password",
+          "basic",
         );
       }
       break;
 
-    case 'api-key':
+    case "api-key":
       if (!auth.apiKey) {
         throw new AuthenticationError(
-          'API key authentication requires apiKey',
-          'api-key'
+          "API key authentication requires apiKey",
+          "api-key",
         );
       }
       break;
@@ -226,7 +226,7 @@ export class AuthenticationManager extends BaseManager {
     default:
       throw new AuthenticationError(
         `Unsupported authentication method: ${auth.method}`,
-        auth.method
+        auth.method,
       );
     }
   }

package/src/client/managers/BaseManager.ts

@@ -3,10 +3,10 @@
  * Provides common functionality and error handling
  */
 
-import type { WordPressClientConfig } from '../../types/client.js';
-import { WordPressAPIError } from '../../types/client.js';
-import { debug, logError } from '../../utils/debug.js';
-import { getErrorMessage } from '../../utils/error.js';
+import type { WordPressClientConfig } from "../../types/client.js";
+import { WordPressAPIError } from "../../types/client.js";
+import { debug, logError } from "../../utils/debug.js";
+import { getErrorMessage } from "../../utils/error.js";
 
 export abstract class BaseManager {
   protected config: WordPressClientConfig;
@@ -25,19 +25,19 @@ export abstract class BaseManager {
       throw error;
     }
 
-    if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
+    if (error.name === "AbortError" || error.code === "ABORT_ERR") {
       throw new WordPressAPIError(
         `Request timeout after ${this.config.timeout}ms`,
         408,
-        'timeout'
+        "timeout",
       );
     }
 
-    if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+    if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
       throw new WordPressAPIError(
         `Cannot connect to WordPress site: ${this.config.baseUrl}`,
         503,
-        'connection_failed'
+        "connection_failed",
       );
     }
 
@@ -45,7 +45,7 @@ export abstract class BaseManager {
     throw new WordPressAPIError(
       `${operation} failed: ${message}`,
       500,
-      'unknown_error'
+      "unknown_error",
     );
   }
 
@@ -61,14 +61,14 @@ export abstract class BaseManager {
    */
   protected validateRequired(
     params: Record<string, any>,
-    requiredFields: string[]
+    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'
+          "missing_parameter",
         );
       }
     }

package/src/client/managers/RequestManager.ts

@@ -3,33 +3,39 @@
  * Handles all HTTP operations, rate limiting, and retries
  */
 
-import fetch from 'node-fetch';
-import type { 
-  HTTPMethod, 
-  RequestOptions, 
+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';
+  WordPressClientConfig,
+} from "../../types/client.js";
+import { WordPressAPIError, RateLimitError } from "../../types/client.js";
+import { BaseManager } from "./BaseManager.js";
+import { AuthenticationManager } from "./AuthenticationManager.js";
+import { debug, startTimer } from "../../utils/debug.js";
 
 export class RequestManager extends BaseManager {
   private stats: ClientStats;
   private lastRequestTime: number = 0;
   private requestInterval: number;
+  private authManager: AuthenticationManager;
 
-  constructor(config: WordPressClientConfig) {
+  constructor(
+    config: WordPressClientConfig,
+    authManager: AuthenticationManager,
+  ) {
     super(config);
-    
-    this.requestInterval = 60000 / parseInt(process.env.RATE_LIMIT || '60');
+
+    this.authManager = authManager;
+    this.requestInterval = 60000 / parseInt(process.env.RATE_LIMIT || "60");
     this.stats = {
       totalRequests: 0,
       successfulRequests: 0,
       failedRequests: 0,
       averageResponseTime: 0,
       rateLimitHits: 0,
-      authFailures: 0
+      authFailures: 0,
     };
   }
 
@@ -40,18 +46,23 @@ export class RequestManager extends BaseManager {
     method: HTTPMethod,
     endpoint: string,
     data?: any,
-    options: RequestOptions = {}
+    options: RequestOptions = {},
   ): Promise<T> {
     const timer = startTimer();
-    
+
     try {
       await this.enforceRateLimit();
-      
-      const response = await this.makeRequestWithRetry(method, endpoint, data, options);
-      
+
+      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++;
@@ -68,7 +79,7 @@ export class RequestManager extends BaseManager {
     method: HTTPMethod,
     endpoint: string,
     data?: any,
-    options: RequestOptions = {}
+    options: RequestOptions = {},
   ): Promise<T> {
     let lastError: any;
     const maxRetries = options.retries ?? this.config.maxRetries ?? 3;
@@ -78,17 +89,20 @@ export class RequestManager extends BaseManager {
         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);
-        
+        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));
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
 
@@ -102,40 +116,57 @@ export class RequestManager extends BaseManager {
     method: HTTPMethod,
     endpoint: string,
     data?: any,
-    options: RequestOptions = {}
+    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 {
+      // Get authentication headers
+      const authHeaders = await this.authManager.getAuthHeaders();
+
       const fetchOptions: any = {
         method,
         headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'MCP-WordPress/1.1.1',
-          ...options.headers
+          "Content-Type": "application/json",
+          "User-Agent": "MCP-WordPress/1.1.1",
+          ...authHeaders, // Add auth headers before custom headers
+          ...options.headers,
         },
-        signal: controller.signal
+        signal: controller.signal,
       };
 
-      if (data && method !== 'GET') {
-        fetchOptions.body = JSON.stringify(data);
+      if (data && method !== "GET") {
+        if (
+          data instanceof FormData ||
+          (data && typeof data.append === "function")
+        ) {
+          // For FormData, don't set Content-Type (let fetch set it with boundary)
+          delete fetchOptions.headers["Content-Type"];
+          fetchOptions.body = data;
+        } else if (Buffer.isBuffer(data)) {
+          // For Buffer data, keep Content-Type from headers
+          fetchOptions.body = data;
+        } else if (typeof data === "string") {
+          fetchOptions.body = data;
+        } else {
+          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);
     }
@@ -146,15 +177,16 @@ export class RequestManager extends BaseManager {
    */
   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';
+    const message =
+      errorData.message || `HTTP ${response.status}: ${response.statusText}`;
+    const code = errorData.code || "http_error";
 
     if (response.status === 429) {
       this.stats.rateLimitHits++;
@@ -172,10 +204,10 @@ export class RequestManager extends BaseManager {
    * 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}`;
-    
+    const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+    const apiBase = "/wp-json/wp/v2";
+    const cleanEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+
     return `${baseUrl}${apiBase}${cleanEndpoint}`;
   }
 
@@ -185,12 +217,12 @@ export class RequestManager extends BaseManager {
   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));
+      await new Promise((resolve) => setTimeout(resolve, delay));
     }
-    
+
     this.lastRequestTime = Date.now();
   }
 
@@ -200,8 +232,8 @@ export class RequestManager extends BaseManager {
   private updateAverageResponseTime(responseTime: number): void {
     const totalRequests = this.stats.successfulRequests;
     const currentAverage = this.stats.averageResponseTime;
-    
-    this.stats.averageResponseTime = 
+
+    this.stats.averageResponseTime =
       (currentAverage * (totalRequests - 1) + responseTime) / totalRequests;
   }
 

package/src/client/managers/index.ts

@@ -3,6 +3,6 @@
  * Exports all manager classes for the WordPress client
  */
 
-export { BaseManager } from './BaseManager.js';
-export { AuthenticationManager } from './AuthenticationManager.js';
-export { RequestManager } from './RequestManager.js';
+export { BaseManager } from "./BaseManager.js";
+export { AuthenticationManager } from "./AuthenticationManager.js";
+export { RequestManager } from "./RequestManager.js";