mcp-wordpress 2.6.3 → 2.7.0

package/src/client/api.ts

@@ -5,8 +5,9 @@
 
 // Use native fetch in Node.js 18+
 import FormData from "form-data";
-import * as fs from "fs";
+import { promises as fsPromises } from "fs";
 import * as path from "path";
+import { getUserAgent } from "../utils/version.js";
 import type {
   IWordPressClient,
   WordPressClientConfig,
@@ -166,7 +167,33 @@ export class WordPressClient implements IWordPressClient {
     this.maxRetries = options.maxRetries || cfg.wordpress.maxRetries;
 
     // Authentication configuration
-    this.auth = options.auth || this.getAuthFromEnv();
+    if (options.auth) {
+      // If auth is provided but without method, infer it
+      if (!options.auth.method) {
+        const auth = options.auth as AuthConfig & {
+          username?: string;
+          appPassword?: string;
+          password?: string;
+          secret?: string;
+          apiKey?: string;
+        };
+        if (auth.username && auth.appPassword) {
+          this.auth = { ...auth, method: "app-password" };
+        } else if (auth.username && auth.password && auth.secret) {
+          this.auth = { ...auth, method: "jwt" };
+        } else if (auth.username && auth.password) {
+          this.auth = { ...auth, method: "basic" };
+        } else if (auth.apiKey) {
+          this.auth = { ...auth, method: "api-key" };
+        } else {
+          this.auth = { ...auth, method: "app-password" }; // default
+        }
+      } else {
+        this.auth = options.auth;
+      }
+    } else {
+      this.auth = this.getAuthFromEnv();
+    }
 
     // Rate limiting
     this.requestInterval = 60000 / cfg.security.rateLimit;
@@ -179,6 +206,7 @@ export class WordPressClient implements IWordPressClient {
       averageResponseTime: 0,
       rateLimitHits: 0,
       authFailures: 0,
+      errors: 0,
     };
 
     // Validate configuration
@@ -239,11 +267,11 @@ export class WordPressClient implements IWordPressClient {
 
       // Return clean URL without query parameters or fragments
       return `${parsed.protocol}//${parsed.host}${parsed.pathname}`.replace(/\/$/, "");
-    } catch (error) {
-      if (error instanceof TypeError) {
+    } catch (_error) {
+      if (_error instanceof TypeError) {
         throw new Error("Invalid WordPress site URL format");
       }
-      throw error;
+      throw _error;
     }
   }
 
@@ -407,10 +435,10 @@ export class WordPressClient implements IWordPressClient {
         default:
           throw new Error(`Unsupported authentication method: ${method}`);
       }
-    } catch (error) {
+    } catch (_error) {
       this._stats.authFailures++;
-      logError(error as Error, { method });
-      throw error;
+      logError(_error as Error, { method });
+      throw _error;
     }
   }
 
@@ -436,8 +464,8 @@ export class WordPressClient implements IWordPressClient {
       this.authenticated = true;
       debug.log("Basic/Application Password authentication successful");
       return true;
-    } catch (error) {
-      throw new AuthenticationError(`Basic authentication failed: ${(error as Error).message}`, this.auth.method);
+    } catch (_error) {
+      throw new AuthenticationError(`Basic authentication failed: ${(_error as Error).message}`, this.auth.method);
     }
   }
 
@@ -473,8 +501,8 @@ export class WordPressClient implements IWordPressClient {
       this.authenticated = true;
       debug.log("JWT authentication successful");
       return true;
-    } catch (error) {
-      throw new AuthenticationError(`JWT authentication failed: ${(error as Error).message}`, this.auth.method);
+    } catch (_error) {
+      throw new AuthenticationError(`JWT authentication failed: ${(_error as Error).message}`, this.auth.method);
     }
   }
 
@@ -508,7 +536,7 @@ export class WordPressClient implements IWordPressClient {
 
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
-      "User-Agent": "MCP-WordPress/1.0.0",
+      "User-Agent": getUserAgent(),
       ...options.headers,
     };
 
@@ -536,8 +564,7 @@ export class WordPressClient implements IWordPressClient {
         // For FormData, check if it has getHeaders method (form-data package)
         if (typeof (data as { getHeaders?: () => Record<string, string> }).getHeaders === "function") {
           // Use headers from form-data package
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const formHeaders = (data as any).getHeaders();
+          const formHeaders = (data as unknown as { getHeaders(): Record<string, string> }).getHeaders();
           Object.assign(headers, formHeaders);
         } else {
           // For native FormData, don't set Content-Type (let fetch set it with boundary)
@@ -681,12 +708,12 @@ export class WordPressClient implements IWordPressClient {
           this.updateAverageResponseTime(duration);
           return responseText as T;
         }
-      } catch (error) {
+      } catch (_error) {
         clearTimeout(timeoutId);
-        lastError = error as Error;
+        lastError = _error as Error;
 
         // Handle timeout errors
-        if ((error as Error & { name?: string }).name === "AbortError") {
+        if ((_error as Error & { name?: string }).name === "AbortError") {
           lastError = new Error(`Request timeout after ${requestTimeout}ms`);
         }
 
@@ -819,13 +846,15 @@ export class WordPressClient implements IWordPressClient {
   }
 
   async uploadMedia(data: UploadMediaRequest): Promise<WordPressMedia> {
-    if (!fs.existsSync(data.file_path)) {
+    try {
+      await fsPromises.access(data.file_path);
+    } catch {
       throw new Error(`File not found: ${data.file_path}`);
     }
 
-    const stats = fs.statSync(data.file_path);
+    const stats = await fsPromises.stat(data.file_path);
     const filename = data.title || path.basename(data.file_path);
-    const fileBuffer = fs.readFileSync(data.file_path);
+    const fileBuffer = await fsPromises.readFile(data.file_path);
 
     // Check if file is too large (WordPress default is 2MB for most installs)
     const maxSize = 10 * 1024 * 1024; // 10MB reasonable limit

package/src/client/auth.ts

@@ -42,9 +42,9 @@ export class WordPressAuth {
         default:
           throw new Error(`Unsupported authentication type: ${this.authType}`);
       }
-    } catch (error) {
-      logger.error("Authentication failed:", error);
-      throw error;
+    } catch (_error) {
+      logger.error("Authentication failed:", _error);
+      throw _error;
     }
   }
 
@@ -66,10 +66,10 @@ export class WordPressAuth {
       const user = await this.client.getCurrentUser();
       logger.log(`✅ Application Password authentication successful for user: ${user.name} (${user.username})`);
       return true;
-    } catch (error) {
+    } catch (_error) {
       const message =
         "Application Password authentication failed. Please check your credentials and ensure the application password is valid.";
-      logger.error(message, error);
+      logger.error(message, _error);
       throw new Error(message);
     }
   }
@@ -88,9 +88,9 @@ export class WordPressAuth {
       const user = await this.client.getCurrentUser();
       logger.log(`✅ Basic authentication successful for user: ${user.name} (${user.username})`);
       return true;
-    } catch (error) {
+    } catch (_error) {
       const message = "Basic authentication failed. Please check your username and password.";
-      logger.error(message, error);
+      logger.error(message, _error);
       throw new Error(message);
     }
   }
@@ -113,10 +113,10 @@ export class WordPressAuth {
       const user = await this.client.getCurrentUser();
       logger.log(`✅ JWT authentication successful for user: ${user.name} (${user.username})`);
       return true;
-    } catch (error) {
+    } catch (_error) {
       const message =
         "JWT authentication failed. Please check your credentials and ensure the JWT plugin is installed and configured.";
-      logger.error(message, error);
+      logger.error(message, _error);
       throw new Error(message);
     }
   }
@@ -136,9 +136,9 @@ export class WordPressAuth {
       await this.client.getSiteInfo();
       logger.log("✅ API Key authentication successful");
       return true;
-    } catch (error) {
+    } catch (_error) {
       const message = "API Key authentication failed. Please check your API key.";
-      logger.error(message, error);
+      logger.error(message, _error);
       throw new Error(message);
     }
   }
@@ -158,9 +158,9 @@ export class WordPressAuth {
       await this.client.getSiteInfo();
       logger.log("✅ Cookie authentication configured (note: write operations may require valid nonce)");
       return true;
-    } catch (error) {
+    } catch (_error) {
       const message = "Cookie authentication failed. Please ensure you are properly logged into WordPress.";
-      logger.error(message, error);
+      logger.error(message, _error);
       throw new Error(message);
     }
   }
@@ -185,8 +185,8 @@ export class WordPressAuth {
     try {
       // Re-authenticate to get a new token
       return await this.handleJWTAuth();
-    } catch (error) {
-      logger.error("Failed to refresh JWT token:", error);
+    } catch (_error) {
+      logger.error("Failed to refresh JWT token:", _error);
       return false;
     }
   }
@@ -198,8 +198,8 @@ export class WordPressAuth {
     try {
       await this.client.getCurrentUser();
       return true;
-    } catch (error) {
-      logger.error("Authentication validation failed:", error);
+    } catch (_error) {
+      logger.error("Authentication validation failed:", _error);
       return false;
     }
   }
@@ -220,11 +220,11 @@ export class WordPressAuth {
         method: this.authType,
         user,
       };
-    } catch (error) {
+    } catch (_error) {
       return {
         authenticated: false,
         method: this.authType,
-        error: (error as Error).message,
+        error: (_error as Error).message,
       };
     }
   }

package/src/client/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Client Barrel Export
+ * Centralized exports for all client classes and utilities
+ */
+
+// Main Client Classes
+export { WordPressClient } from './api.js';
+export { CachedWordPressClient } from './CachedWordPressClient.js';
+export { SEOWordPressClient } from './SEOWordPressClient.js';
+export { MockWordPressClient } from './MockWordPressClient.js';
+
+// Authentication utilities
+export * from './auth.js';
+
+// Manager exports (already has its own index)
+export * from './managers/index.js';

package/src/client/managers/AuthManager.ts

@@ -0,0 +1,175 @@
+/**
+ * Authentication Manager
+ * Handles all authentication methods for WordPress REST API
+ */
+
+import type { WordPressClient } from "../api.js";
+import type { AuthConfig, AuthMethod } from "@/types/client.js";
+import { AuthenticationError } from "@/types/client.js";
+import { LoggerFactory } from "@/utils/logger.js";
+
+export interface JWTToken {
+  token: string;
+  user_email: string;
+  user_nicename: string;
+  user_display_name: string;
+  expiresAt: number;
+}
+
+export class AuthManager {
+  private logger = LoggerFactory.api();
+  private jwtToken?: JWTToken;
+
+  constructor(
+    private client: WordPressClient,
+    private authConfig: AuthConfig
+  ) {}
+
+  /**
+   * Authenticate using the configured method
+   */
+  async authenticate(): Promise<boolean> {
+    this.logger.info("Authenticating with method", { method: this.authConfig.method });
+
+    try {
+      switch (this.authConfig.method) {
+        case "app-password":
+          return this.authenticateWithAppPassword();
+        case "jwt":
+          return this.authenticateWithJWT();
+        case "basic":
+          return this.authenticateWithBasic();
+        case "cookie":
+          return this.authenticateWithCookie();
+        case "api-key":
+          return this.authenticateWithAPIKey();
+        default:
+          throw new AuthenticationError(`Unsupported authentication method: ${this.authConfig.method}`, this.authConfig.method);
+      }
+    } catch (error) {
+      this.logger.error("Authentication failed", { 
+        method: this.authConfig.method,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Get current authentication headers
+   */
+  getAuthHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {};
+
+    switch (this.authConfig.method) {
+      case "app-password":
+      case "basic":
+        if (this.authConfig.username && this.authConfig.appPassword) {
+          const credentials = Buffer.from(`${this.authConfig.username}:${this.authConfig.appPassword}`).toString("base64");
+          headers.Authorization = `Basic ${credentials}`;
+        }
+        break;
+
+      case "jwt":
+        if (this.jwtToken && !this.isTokenExpired()) {
+          headers.Authorization = `Bearer ${this.jwtToken.token}`;
+        }
+        break;
+
+      case "api-key":
+        if (this.authConfig.apiKey) {
+          headers["X-API-Key"] = this.authConfig.apiKey;
+        }
+        break;
+
+      case "cookie":
+        // Cookie authentication is handled by the browser/client
+        // Headers are set automatically after successful login
+        break;
+    }
+
+    return headers;
+  }
+
+  /**
+   * JWT authentication
+   */
+  private async authenticateWithJWT(): Promise<boolean> {
+    if (!this.authConfig.username || !this.authConfig.password) {
+      throw new AuthenticationError("Username and password are required for JWT authentication", this.authConfig.method);
+    }
+
+    try {
+      const response = await this.client.post<{
+        token: string;
+        user_email: string;
+        user_nicename: string;
+        user_display_name: string;
+      }>("jwt-auth/v1/token", {
+        username: this.authConfig.username,
+        password: this.authConfig.password,
+      });
+
+      if (!response.token) {
+        throw new AuthenticationError("JWT token not received", this.authConfig.method);
+      }
+
+      // Calculate expiration time (typically 24 hours for JWT)
+      const expiresAt = Date.now() + (24 * 60 * 60 * 1000); // 24 hours
+
+      this.jwtToken = {
+        token: response.token,
+        user_email: response.user_email,
+        user_nicename: response.user_nicename,
+        user_display_name: response.user_display_name,
+        expiresAt,
+      };
+
+      this.logger.info("JWT authentication successful", {
+        user: response.user_nicename,
+        expiresAt: new Date(expiresAt).toISOString(),
+      });
+
+      return true;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new AuthenticationError(`JWT authentication failed: ${error.message}`, this.authConfig.method);
+      }
+      throw new AuthenticationError("JWT authentication failed", this.authConfig.method);
+    }
+  }
+
+  private authenticateWithAppPassword(): boolean {
+    if (!this.authConfig.username || !this.authConfig.appPassword) {
+      throw new AuthenticationError("Username and app password are required", this.authConfig.method);
+    }
+    return true;
+  }
+
+  private authenticateWithBasic(): boolean {
+    if (!this.authConfig.username || !this.authConfig.password) {
+      throw new AuthenticationError("Username and password are required", this.authConfig.method);
+    }
+    return true;
+  }
+
+  private async authenticateWithCookie(): Promise<boolean> {
+    throw new AuthenticationError("Cookie authentication not implemented", this.authConfig.method);
+  }
+
+  private authenticateWithAPIKey(): boolean {
+    if (!this.authConfig.apiKey) {
+      throw new AuthenticationError("API key is required", this.authConfig.method);
+    }
+    return true;
+  }
+
+  private isTokenExpired(): boolean {
+    if (!this.jwtToken) return true;
+    return Date.now() > this.jwtToken.expiresAt;
+  }
+
+  getAuthMethod(): AuthMethod {
+    return this.authConfig.method;
+  }
+}

package/src/client/managers/AuthenticationManager.ts

@@ -11,12 +11,12 @@ import type {
   JwtCredentials,
   BasicCredentials,
   ApiKeyCredentials,
-} from "../../types/client.js";
-import { AuthenticationError } from "../../types/client.js";
-import { AUTH_METHODS, type AuthMethod } from "../../types/wordpress.js";
-import { config } from "../../config/Config.js";
+} from "@/types/client.js";
+import { AuthenticationError } from "@/types/client.js";
+import { AUTH_METHODS, type AuthMethod } from "@/types/wordpress.js";
+import { config } from "@/config/Config.js";
 import { BaseManager } from "./BaseManager.js";
-import { debug } from "../../utils/debug.js";
+import { debug } from "@/utils/debug.js";
 
 interface AuthManagerConfig extends WordPressClientConfig {
   siteUrl: string; // Required based on constructor validation
@@ -42,12 +42,16 @@ export class AuthenticationManager extends BaseManager {
       throw new AuthenticationError("Site URL is required", AUTH_METHODS.APP_PASSWORD);
     }
 
-    // Validate site URL format
+    // Validate and normalize site URL format
     try {
       new URL(config.siteUrl);
     } catch {
       throw new AuthenticationError("Invalid site URL", AUTH_METHODS.APP_PASSWORD);
     }
+    
+    // Normalize URL by removing trailing slash
+    const normalizedSiteUrl = config.siteUrl.replace(/\/$/, '');
+    config.siteUrl = normalizedSiteUrl;
 
     // Validate auth method using centralized constants
     const validMethods = Object.values(AUTH_METHODS);
@@ -200,8 +204,8 @@ export class AuthenticationManager extends BaseManager {
         "JWT authentication requires RequestManager integration - not yet implemented",
         AUTH_METHODS.JWT,
       );
-    } catch (error) {
-      this.handleError(error, "JWT authentication");
+    } catch (_error) {
+      this.handleError(_error, "JWT authentication");
     }
   }
 
@@ -219,9 +223,9 @@ export class AuthenticationManager extends BaseManager {
       // For now, we'll return true if headers can be generated
       this.authenticated = true;
       return true;
-    } catch (error) {
+    } catch (_error) {
       this.authenticated = false;
-      debug.log("Authentication test failed", error);
+      debug.log("Authentication test failed", _error);
       return false;
     }
   }
@@ -450,14 +454,12 @@ export class AuthenticationManager extends BaseManager {
     const isExpired = this.isTokenExpired();
 
     const status: AuthStatus = {
-      method,
-      username: this.authConfig.username,
       isAuthenticated: method === AUTH_METHODS.JWT ? !isExpired : true,
-      tokenExpired: isExpired,
+      method,
     };
 
     if (method === AUTH_METHODS.JWT && this.authConfig.tokenExpiry) {
-      status.tokenExpiry = this.authConfig.tokenExpiry;
+      status.tokenExpiry = new Date(this.authConfig.tokenExpiry);
     }
 
     return status;

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;
@@ -36,7 +36,26 @@ export abstract class BaseManager {
       }
 
       if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
-        throw new WordPressAPIError(`Cannot connect to WordPress site: ${this.config.baseUrl}`, 503, "connection_failed");
+        throw new WordPressAPIError(
+          `Cannot connect to WordPress site: ${this.config.baseUrl}`,
+          503,
+          "connection_failed",
+        );
+      }
+
+      // Preserve custom error properties if they exist
+      const errorObj = error as Record<string, unknown>;
+      const customCode = errorObj.code;
+      const customDetails = errorObj.details;
+      if (
+        customCode &&
+        typeof customCode === "string" &&
+        customCode !== "ECONNREFUSED" &&
+        customCode !== "ENOTFOUND" &&
+        customCode !== "ABORT_ERR"
+      ) {
+        const message = getErrorMessage(error);
+        throw new WordPressAPIError(`${operation} failed: ${message}`, 500, customCode, customDetails);
       }
     }