mcp-wordpress 1.1.2 → 1.1.7

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;
@@ -16,40 +16,46 @@ 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":
-        return {
-          method: "app-password",
-          username: process.env.WORDPRESS_USERNAME || "",
-          appPassword: process.env.WORDPRESS_APP_PASSWORD || "",
-        };
-
-      case "jwt":
-        return {
-          method: "jwt",
-          username: process.env.WORDPRESS_USERNAME || "",
-          password: process.env.WORDPRESS_JWT_PASSWORD || process.env.WORDPRESS_PASSWORD || "",
-          secret: process.env.WORDPRESS_JWT_SECRET || "",
-        };
-
-      case "basic":
-        return {
-          method: "basic",
-          username: process.env.WORDPRESS_USERNAME || "",
-          password: process.env.WORDPRESS_PASSWORD || "",
-        };
-
-      case "api-key":
-        return {
-          method: "api-key",
-          apiKey: process.env.WORDPRESS_API_KEY || "",
-        };
-
-      default:
-        throw new AuthenticationError(`Unsupported authentication method: ${method}`, method);
+    case 'app-password':
+      return {
+        method: 'app-password',
+        username: process.env.WORDPRESS_USERNAME || '',
+        appPassword: process.env.WORDPRESS_APP_PASSWORD || ''
+      };
+
+    case 'jwt':
+      return {
+        method: 'jwt',
+        username: process.env.WORDPRESS_USERNAME || '',
+        password:
+            process.env.WORDPRESS_JWT_PASSWORD ||
+            process.env.WORDPRESS_PASSWORD ||
+            '',
+        secret: process.env.WORDPRESS_JWT_SECRET || ''
+      };
+
+    case 'basic':
+      return {
+        method: 'basic',
+        username: process.env.WORDPRESS_USERNAME || '',
+        password: process.env.WORDPRESS_PASSWORD || ''
+      };
+
+    case 'api-key':
+      return {
+        method: 'api-key',
+        apiKey: process.env.WORDPRESS_API_KEY || ''
+      };
+
+    default:
+      throw new AuthenticationError(
+        `Unsupported authentication method: ${method}`,
+        method
+      );
     }
   }
 
@@ -60,36 +66,49 @@ export class AuthenticationManager extends BaseManager {
     const auth = this.config.auth;
 
     switch (auth.method) {
-      case "app-password":
-        if (!auth.username || !auth.appPassword) {
-          throw new AuthenticationError("Username and app password are required", auth.method);
-        }
-        
-        const credentials = Buffer.from(`${auth.username}:${auth.appPassword}`).toString("base64");
-        return { Authorization: `Basic ${credentials}` };
-
-      case "jwt":
-        if (!this.jwtToken) {
-          await this.authenticateJWT();
-        }
-        return { Authorization: `Bearer ${this.jwtToken}` };
-
-      case "basic":
-        if (!auth.username || !auth.password) {
-          throw new AuthenticationError("Username and password are required", auth.method);
-        }
-        
-        const basicCredentials = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
-        return { Authorization: `Basic ${basicCredentials}` };
-
-      case "api-key":
-        if (!auth.apiKey) {
-          throw new AuthenticationError("API key is required", auth.method);
-        }
-        return { "X-API-Key": auth.apiKey };
-
-      default:
-        throw new AuthenticationError(`Unsupported authentication method: ${auth.method}`, auth.method);
+    case 'app-password':
+      if (!auth.username || !auth.appPassword) {
+        throw new AuthenticationError(
+          'Username and app password are required',
+          auth.method
+        );
+      }
+
+      const credentials = Buffer.from(
+        `${auth.username}:${auth.appPassword}`
+      ).toString('base64');
+      return { Authorization: `Basic ${credentials}` };
+
+    case 'jwt':
+      if (!this.jwtToken) {
+        await this.authenticateJWT();
+      }
+      return { Authorization: `Bearer ${this.jwtToken}` };
+
+    case 'basic':
+      if (!auth.username || !auth.password) {
+        throw new AuthenticationError(
+          'Username and password are required',
+          auth.method
+        );
+      }
+
+      const basicCredentials = Buffer.from(
+        `${auth.username}:${auth.password}`
+      ).toString('base64');
+      return { Authorization: `Basic ${basicCredentials}` };
+
+    case 'api-key':
+      if (!auth.apiKey) {
+        throw new AuthenticationError('API key is required', auth.method);
+      }
+      return { 'X-API-Key': auth.apiKey };
+
+    default:
+      throw new AuthenticationError(
+        `Unsupported authentication method: ${auth.method}`,
+        auth.method
+      );
     }
   }
 
@@ -98,18 +117,23 @@ export class AuthenticationManager extends BaseManager {
    */
   private async authenticateJWT(): Promise<void> {
     const auth = this.config.auth;
-    
-    if (auth.method !== "jwt" || !auth.username || !auth.password) {
-      throw new AuthenticationError("JWT authentication requires username and password", "jwt");
+
+    if (auth.method !== 'jwt' || !auth.username || !auth.password) {
+      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");
+      this.handleError(error, 'JWT authentication');
     }
   }
 
@@ -118,17 +142,18 @@ 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 });
-      
+      const _headers = await this.getAuthHeaders();
+      debug.log('Authentication headers prepared', {
+        method: this.config.auth.method
+      });
+
       // This would need the RequestManager to actually test the connection
       // For now, we'll return true if headers can be generated
       this.authenticated = true;
       return true;
-      
     } catch (error) {
       this.authenticated = false;
-      debug.log("Authentication test failed", error);
+      debug.log('Authentication test failed', error);
       return false;
     }
   }
@@ -155,36 +180,54 @@ 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) {
-      case "app-password":
-        if (!auth.username || !auth.appPassword) {
-          throw new AuthenticationError("App password authentication requires username and appPassword", "app-password");
-        }
-        break;
-
-      case "jwt":
-        if (!auth.username || !auth.password || !auth.secret) {
-          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");
-        }
-        break;
-
-      case "api-key":
-        if (!auth.apiKey) {
-          throw new AuthenticationError("API key authentication requires apiKey", "api-key");
-        }
-        break;
-
-      default:
-        throw new AuthenticationError(`Unsupported authentication method: ${auth.method}`, auth.method);
+    case 'app-password':
+      if (!auth.username || !auth.appPassword) {
+        throw new AuthenticationError(
+          'App password authentication requires username and appPassword',
+          'app-password'
+        );
+      }
+      break;
+
+    case 'jwt':
+      if (!auth.username || !auth.password || !auth.secret) {
+        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'
+        );
+      }
+      break;
+
+    case 'api-key':
+      if (!auth.apiKey) {
+        throw new AuthenticationError(
+          'API key authentication requires apiKey',
+          'api-key'
+        );
+      }
+      break;
+
+    default:
+      throw new AuthenticationError(
+        `Unsupported authentication method: ${auth.method}`,
+        auth.method
+      );
     }
   }
-}
+}

package/src/client/managers/BaseManager.ts

@@ -3,10 +3,10 @@
  * 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";
+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'
     );
   }
 
@@ -59,15 +59,18 @@ export abstract class BaseManager {
   /**
    * Validate required parameters
    */
-  protected validateRequired(params: Record<string, any>, requiredFields: string[]): void {
+  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"
+          'missing_parameter'
         );
       }
     }
   }
-}
+}

package/src/client/managers/RequestManager.ts

@@ -3,16 +3,16 @@
  * Handles all HTTP operations, rate limiting, and retries
  */
 
-import fetch from "node-fetch";
+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";
+} 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;
@@ -22,14 +22,14 @@ export class RequestManager extends BaseManager {
   constructor(config: WordPressClientConfig) {
     super(config);
     
-    this.requestInterval = 60000 / parseInt(process.env.RATE_LIMIT || "60");
+    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
     };
   }
 
@@ -114,14 +114,14 @@ export class RequestManager extends BaseManager {
       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',
+          ...options.headers
         },
-        signal: controller.signal,
+        signal: controller.signal
       };
 
-      if (data && method !== "GET") {
+      if (data && method !== 'GET') {
         fetchOptions.body = JSON.stringify(data);
       }
 
@@ -154,7 +154,7 @@ export class RequestManager extends BaseManager {
     }
 
     const message = errorData.message || `HTTP ${response.status}: ${response.statusText}`;
-    const code = errorData.code || "http_error";
+    const code = errorData.code || 'http_error';
 
     if (response.status === 429) {
       this.stats.rateLimitHits++;
@@ -172,9 +172,9 @@ 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}`;
   }
@@ -211,4 +211,4 @@ export class RequestManager extends BaseManager {
   getStats(): ClientStats {
     return { ...this.stats };
   }
-}
+}

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';