mcp-wordpress 2.6.4 → 2.7.0

package/src/client/managers/ComposedRequestManager.ts

@@ -0,0 +1,336 @@
+/**
+ * Composed Request Manager
+ * Uses composition instead of inheritance for better testability and flexibility
+ */
+
+import type { HTTPMethod, RequestOptions, ClientStats, WordPressClientConfig } from "@/types/client.js";
+import { WordPressAPIError, RateLimitError } from "@/types/client.js";
+import { config } from "@/config/Config.js";
+import { startTimer } from "@/utils/debug.js";
+import { getUserAgent } from "@/utils/version.js";
+
+import type {
+  ConfigurationProvider,
+  ErrorHandler,
+  ParameterValidator,
+  AuthenticationProvider,
+  RequestHandler,
+} from "./interfaces/ManagerInterfaces.js";
+
+import { ConfigurationProviderImpl } from "./implementations/ConfigurationProviderImpl.js";
+import { ErrorHandlerImpl } from "./implementations/ErrorHandlerImpl.js";
+import { ParameterValidatorImpl } from "./implementations/ParameterValidatorImpl.js";
+
+interface ComposedRequestManagerDependencies {
+  configProvider: ConfigurationProvider;
+  errorHandler: ErrorHandler;
+  validator: ParameterValidator;
+  authProvider: AuthenticationProvider;
+}
+
+export class ComposedRequestManager implements RequestHandler {
+  private stats: ClientStats;
+  private lastRequestTime: number = 0;
+  private requestInterval: number;
+  private initialized: boolean = false;
+
+  constructor(private dependencies: ComposedRequestManagerDependencies) {
+    this.requestInterval = 60000 / config().security.rateLimit;
+    this.stats = {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      averageResponseTime: 0,
+      rateLimitHits: 0,
+      authFailures: 0,
+      errors: 0,
+    };
+  }
+
+  /**
+   * Factory method to create ComposedRequestManager with default implementations
+   */
+  static create(clientConfig: WordPressClientConfig, authProvider: AuthenticationProvider): ComposedRequestManager {
+    const configProvider = new ConfigurationProviderImpl(clientConfig);
+    const errorHandler = new ErrorHandlerImpl(configProvider);
+    const validator = new ParameterValidatorImpl();
+
+    return new ComposedRequestManager({
+      configProvider,
+      errorHandler,
+      validator,
+      authProvider,
+    });
+  }
+
+  /**
+   * Initialize the manager
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    try {
+      // Validate configuration
+      if (!this.dependencies.configProvider.config.baseUrl) {
+        throw new Error("Base URL is required");
+      }
+
+      // Ensure authentication is ready
+      await this.dependencies.authProvider.authenticate();
+
+      this.initialized = true;
+    } catch (error) {
+      this.dependencies.errorHandler.handleError(error, "initialize request manager");
+    }
+  }
+
+  /**
+   * Make HTTP request with retry logic and rate limiting
+   */
+  async request<T>(method: HTTPMethod, endpoint: string, data?: unknown, options: RequestOptions = {}): Promise<T> {
+    this.ensureInitialized();
+
+    const timer = startTimer();
+    this.stats.totalRequests++;
+
+    try {
+      // Validate inputs
+      this.dependencies.validator.validateString(method, "method", { required: true });
+      this.dependencies.validator.validateString(endpoint, "endpoint", { required: true });
+
+      await this.enforceRateLimit();
+
+      const response = await this.makeRequestWithRetry(method, endpoint, data, options);
+
+      this.stats.successfulRequests++;
+      this.updateAverageResponseTime(timer.end());
+
+      this.dependencies.errorHandler.logSuccess(`${method} ${endpoint}`, { responseTime: timer.end() });
+
+      return response as T;
+    } catch (error) {
+      this.stats.failedRequests++;
+      this.stats.errors++;
+
+      if (error instanceof RateLimitError) {
+        this.stats.rateLimitHits++;
+      }
+
+      this.dependencies.errorHandler.handleError(error, `${method} ${endpoint}`);
+    }
+  }
+
+  /**
+   * Get request statistics
+   */
+  getStats(): ClientStats {
+    return { ...this.stats };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats(): void {
+    this.stats = {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      averageResponseTime: 0,
+      rateLimitHits: 0,
+      authFailures: 0,
+      errors: 0,
+    };
+  }
+
+  /**
+   * Enforce rate limiting
+   */
+  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));
+    }
+
+    this.lastRequestTime = Date.now();
+  }
+
+  /**
+   * Make request with retry logic
+   */
+  private async makeRequestWithRetry<T>(
+    method: HTTPMethod,
+    endpoint: string,
+    data?: unknown,
+    options: RequestOptions = {},
+    attempt: number = 1,
+  ): Promise<T> {
+    const maxRetries = 3; // Use default retries for composed manager
+
+    try {
+      return await this.makeRequest<T>(method, endpoint, data, options);
+    } catch (error) {
+      if (attempt <= maxRetries && this.shouldRetry(error)) {
+        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.makeRequestWithRetry<T>(method, endpoint, data, options, attempt + 1);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Make actual HTTP request
+   */
+  private async makeRequest<T>(
+    method: HTTPMethod,
+    endpoint: string,
+    data?: unknown,
+    options: RequestOptions = {},
+  ): Promise<T> {
+    const url = this.buildUrl(endpoint);
+    const requestOptions = await this.buildRequestOptions(method, data, options);
+
+    const response = await fetch(url, requestOptions);
+
+    if (!response.ok) {
+      await this.handleHttpError(response);
+    }
+
+    const contentType = response.headers.get("content-type");
+
+    if (contentType && contentType.includes("application/json")) {
+      return (await response.json()) as T;
+    }
+
+    return (await response.text()) as unknown as T;
+  }
+
+  /**
+   * Build full URL for request
+   */
+  private buildUrl(endpoint: string): string {
+    const baseUrl = this.dependencies.configProvider.config.baseUrl;
+    const cleanBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const cleanEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+
+    return `${cleanBase}/wp-json${cleanEndpoint}`;
+  }
+
+  /**
+   * Build request options with authentication
+   */
+  private async buildRequestOptions(
+    method: HTTPMethod,
+    data?: unknown,
+    options: RequestOptions = {},
+  ): Promise<RequestInit> {
+    const authHeaders = this.dependencies.authProvider.getAuthHeaders();
+    const timeout = this.dependencies.configProvider.config.timeout || 30000;
+
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": getUserAgent(),
+      ...authHeaders,
+      ...options.headers,
+    };
+
+    const requestOptions: RequestInit = {
+      method,
+      headers,
+      signal: typeof AbortSignal !== "undefined" && AbortSignal.timeout ? AbortSignal.timeout(timeout) : null,
+    };
+
+    if (data && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      requestOptions.body = JSON.stringify(data);
+    }
+
+    return requestOptions;
+  }
+
+  /**
+   * Handle HTTP error responses
+   */
+  private async handleHttpError(response: Response): Promise<never> {
+    const statusCode = response.status;
+
+    if (statusCode === 401) {
+      this.stats.authFailures++;
+
+      // Try to refresh authentication
+      try {
+        await this.dependencies.authProvider.handleAuthFailure(new Error(`HTTP ${statusCode}`));
+        // If refresh succeeds, the caller should retry
+        throw new WordPressAPIError("Authentication refreshed, retry needed", 401, "auth_refreshed");
+      } catch (_authError) {
+        throw new WordPressAPIError("Authentication failed", 401, "auth_failed");
+      }
+    }
+
+    if (statusCode === 429) {
+      const retryAfter = response.headers.get("retry-after");
+      const delay = retryAfter ? parseInt(retryAfter, 10) : 60;
+      throw new RateLimitError("Rate limit exceeded", delay);
+    }
+
+    let errorMessage = `HTTP ${statusCode}: ${response.statusText}`;
+
+    try {
+      const errorBody = (await response.json()) as { message?: string };
+      if (errorBody.message) {
+        errorMessage = errorBody.message;
+      }
+    } catch {
+      // Ignore JSON parsing errors for non-JSON error responses
+    }
+
+    throw new WordPressAPIError(errorMessage, statusCode, "http_error");
+  }
+
+  /**
+   * Determine if error is retryable
+   */
+  private shouldRetry(error: unknown): boolean {
+    if (error instanceof WordPressAPIError) {
+      const nonRetryableCodes = [400, 401, 403, 404];
+      return !nonRetryableCodes.includes(error.statusCode || 500);
+    }
+
+    if (error instanceof Error) {
+      const retryableErrors = ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN"];
+      return retryableErrors.some((code) => error.message.includes(code));
+    }
+
+    return false;
+  }
+
+  /**
+   * Update average response time with new measurement
+   */
+  private updateAverageResponseTime(newTime: number): void {
+    const total = this.stats.averageResponseTime * (this.stats.successfulRequests - 1) + newTime;
+    this.stats.averageResponseTime = Math.round(total / this.stats.successfulRequests);
+  }
+
+  /**
+   * Ensure manager is initialized before operations
+   */
+  private ensureInitialized(): void {
+    if (!this.initialized) {
+      throw new Error("ComposedRequestManager not initialized. Call initialize() first.");
+    }
+  }
+
+  /**
+   * Cleanup resources
+   */
+  dispose(): void {
+    // Cleanup any resources, timers, etc.
+    this.initialized = false;
+  }
+}

package/src/client/managers/JWTAuthImplementation.ts

@@ -0,0 +1,326 @@
+/**
+ * JWT Authentication Implementation
+ * Complete JWT authentication with token refresh and RequestManager integration
+ */
+
+import type { AuthConfig, RequestOptions } from "@/types/client.js";
+import { AuthenticationError } from "@/types/client.js";
+import { AUTH_METHODS } from "@/types/wordpress.js";
+import { LoggerFactory } from "@/utils/logger.js";
+import type { RequestManager } from "./RequestManager.js";
+
+export interface JWTTokenResponse {
+  token: string;
+  user_email: string;
+  user_nicename: string;
+  user_display_name: string;
+  expires_in?: number;
+}
+
+export interface JWTValidateResponse {
+  code: string;
+  data: {
+    status: number;
+  };
+}
+
+export interface JWTRefreshResponse {
+  token: string;
+  expires_in?: number;
+}
+
+export class JWTAuthImplementation {
+  private logger = LoggerFactory.api();
+  private jwtToken: string | null = null;
+  private tokenExpiry: number | null = null;
+  private refreshTokenValue: string | null = null;
+  
+  constructor(
+    private requestManager: RequestManager,
+    private authConfig: AuthConfig
+  ) {}
+
+  /**
+   * Complete JWT authentication implementation
+   */
+  async authenticateJWT(): Promise<void> {
+    if (!this.authConfig.username || !this.authConfig.password) {
+      throw new AuthenticationError("JWT authentication requires username and password", AUTH_METHODS.JWT);
+    }
+
+    try {
+      this.logger.info("Starting JWT authentication", { 
+        username: this.authConfig.username,
+        endpoint: "jwt-auth/v1/token"
+      });
+
+      const response = await this.requestManager.request<JWTTokenResponse>(
+        "POST",
+        "jwt-auth/v1/token",
+        {
+          username: this.authConfig.username,
+          password: this.authConfig.password,
+        },
+        {
+          skipAuth: true, // Don't use auth headers for the auth request itself
+          timeout: 10000,
+        } as RequestOptions & { skipAuth: boolean }
+      );
+
+      if (!response.token) {
+        throw new AuthenticationError("JWT token not received in response", AUTH_METHODS.JWT);
+      }
+
+      // Store the JWT token
+      this.jwtToken = response.token;
+      
+      // Calculate token expiry (default to 24 hours if not provided)
+      const expiresInSeconds = response.expires_in || (24 * 60 * 60);
+      this.tokenExpiry = Date.now() + (expiresInSeconds * 1000);
+
+      this.logger.info("JWT authentication successful", {
+        user: response.user_nicename,
+        expiresAt: new Date(this.tokenExpiry).toISOString(),
+      });
+
+      // Test the token by validating it
+      await this.validateToken();
+
+    } catch (error) {
+      this.jwtToken = null;
+      this.tokenExpiry = null;
+      this.logger.error("JWT authentication failed", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      
+      if (error instanceof Error) {
+        throw new AuthenticationError(`JWT authentication failed: ${error.message}`, AUTH_METHODS.JWT);
+      }
+      throw new AuthenticationError("JWT authentication failed", AUTH_METHODS.JWT);
+    }
+  }
+
+  /**
+   * Validate JWT token
+   */
+  async validateToken(): Promise<boolean> {
+    if (!this.jwtToken) {
+      return false;
+    }
+
+    try {
+      const response = await this.requestManager.request<JWTValidateResponse>(
+        "POST",
+        "jwt-auth/v1/token/validate",
+        {},
+        {
+          headers: {
+            Authorization: `Bearer ${this.jwtToken}`,
+          },
+          timeout: 5000,
+        }
+      );
+
+      const isValid = response.data.status === 200;
+      
+      if (!isValid) {
+        this.logger.warn("JWT token validation failed", { response });
+        this.jwtToken = null;
+        this.tokenExpiry = null;
+      }
+
+      return isValid;
+
+    } catch (error) {
+      this.logger.warn("JWT token validation error", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Refresh JWT token
+   */
+  async refreshToken(): Promise<void> {
+    if (!this.jwtToken) {
+      throw new AuthenticationError("No JWT token to refresh", AUTH_METHODS.JWT);
+    }
+
+    try {
+      this.logger.debug("Refreshing JWT token");
+
+      // Some JWT implementations support refresh endpoints
+      // First try the refresh endpoint if available
+      try {
+        const refreshResponse = await this.requestManager.request<JWTRefreshResponse>(
+          "POST",
+          "jwt-auth/v1/token/refresh",
+          {},
+          {
+            headers: {
+              Authorization: `Bearer ${this.jwtToken}`,
+            },
+            timeout: 5000,
+          }
+        );
+
+        if (refreshResponse.token) {
+          this.jwtToken = refreshResponse.token;
+          const expiresInSeconds = refreshResponse.expires_in || (24 * 60 * 60);
+          this.tokenExpiry = Date.now() + (expiresInSeconds * 1000);
+          
+          this.logger.info("JWT token refreshed successfully", {
+            expiresAt: new Date(this.tokenExpiry).toISOString(),
+          });
+          return;
+        }
+      } catch (_refreshError) {
+        this.logger.debug("JWT refresh endpoint not available, falling back to re-authentication");
+      }
+
+      // Fallback: Re-authenticate with original credentials
+      if (!this.authConfig.username || !this.authConfig.password) {
+        throw new AuthenticationError("Cannot refresh JWT token: original credentials not available", AUTH_METHODS.JWT);
+      }
+
+      this.logger.debug("Re-authenticating to refresh JWT token");
+      await this.authenticateJWT();
+
+    } catch (error) {
+      this.jwtToken = null;
+      this.tokenExpiry = null;
+      this.logger.error("JWT token refresh failed", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      
+      throw new AuthenticationError(
+        `JWT token refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        AUTH_METHODS.JWT
+      );
+    }
+  }
+
+  /**
+   * Check if JWT token is expired
+   */
+  isTokenExpired(): boolean {
+    if (!this.tokenExpiry) {
+      return true;
+    }
+    
+    // Consider token expired if it expires within 5 minutes (300000ms)
+    const buffer = 5 * 60 * 1000;
+    return Date.now() >= (this.tokenExpiry - buffer);
+  }
+
+  /**
+   * Get current JWT token
+   */
+  getToken(): string | null {
+    return this.jwtToken;
+  }
+
+  /**
+   * Get token expiry timestamp
+   */
+  getTokenExpiry(): number | null {
+    return this.tokenExpiry;
+  }
+
+  /**
+   * Clear JWT token and expiry
+   */
+  clearToken(): void {
+    this.jwtToken = null;
+    this.tokenExpiry = null;
+    this.refreshTokenValue = null;
+    this.logger.debug("JWT token cleared");
+  }
+
+  /**
+   * Get JWT auth headers
+   */
+  getAuthHeaders(): Record<string, string> {
+    if (!this.jwtToken) {
+      return {};
+    }
+    
+    return {
+      Authorization: `Bearer ${this.jwtToken}`,
+    };
+  }
+
+  /**
+   * Check if we have a valid JWT token
+   */
+  hasValidToken(): boolean {
+    return this.jwtToken !== null && !this.isTokenExpired();
+  }
+
+  /**
+   * Automatic token refresh if needed
+   */
+  async ensureValidToken(): Promise<void> {
+    if (!this.jwtToken) {
+      // No token, need to authenticate
+      await this.authenticateJWT();
+      return;
+    }
+
+    if (this.isTokenExpired()) {
+      // Token expired, need to refresh
+      await this.refreshToken();
+      return;
+    }
+
+    // Token is still valid
+  }
+
+  /**
+   * Logout and invalidate token
+   */
+  async logout(): Promise<void> {
+    if (!this.jwtToken) {
+      return;
+    }
+
+    try {
+      // Try to invalidate the token on the server
+      await this.requestManager.request(
+        "POST",
+        "jwt-auth/v1/token/invalidate",
+        {},
+        {
+          headers: this.getAuthHeaders(),
+          timeout: 5000,
+        }
+      );
+      
+      this.logger.info("JWT token invalidated on server");
+    } catch (error) {
+      this.logger.warn("Failed to invalidate JWT token on server", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+
+    this.clearToken();
+  }
+
+  /**
+   * Get token information
+   */
+  getTokenInfo(): {
+    hasToken: boolean;
+    isExpired: boolean;
+    expiresAt: string | null;
+    expiresIn: number | null;
+  } {
+    return {
+      hasToken: this.jwtToken !== null,
+      isExpired: this.isTokenExpired(),
+      expiresAt: this.tokenExpiry ? new Date(this.tokenExpiry).toISOString() : null,
+      expiresIn: this.tokenExpiry ? Math.max(0, this.tokenExpiry - Date.now()) : null,
+    };
+  }
+}

package/src/client/managers/ManagersIndex.ts

@@ -0,0 +1,6 @@
+/**
+ * Managers Index
+ * Export all manager classes
+ */
+
+export { AuthManager, type JWTToken } from "./AuthManager.js";

package/src/client/managers/RequestManager.ts

@@ -4,12 +4,13 @@
  */
 
 // Use native fetch in Node.js 18+
-import type { HTTPMethod, RequestOptions, ClientStats, WordPressClientConfig } from "../../types/client.js";
-import { WordPressAPIError, RateLimitError } from "../../types/client.js";
-import { config } from "../../config/Config.js";
+import type { HTTPMethod, RequestOptions, ClientStats, WordPressClientConfig } from "@/types/client.js";
+import { WordPressAPIError, RateLimitError } from "@/types/client.js";
+import { config } from "@/config/Config.js";
 import { BaseManager } from "./BaseManager.js";
 import { AuthenticationManager } from "./AuthenticationManager.js";
-import { debug, startTimer } from "../../utils/debug.js";
+import { debug, startTimer } from "@/utils/debug.js";
+import { getUserAgent } from "@/utils/version.js";
 
 export class RequestManager extends BaseManager {
   private stats: ClientStats;
@@ -29,6 +30,7 @@ export class RequestManager extends BaseManager {
       averageResponseTime: 0,
       rateLimitHits: 0,
       authFailures: 0,
+      errors: 0,
     };
   }
 
@@ -47,9 +49,9 @@ export class RequestManager extends BaseManager {
       this.updateAverageResponseTime(timer.end());
 
       return response as T;
-    } catch (error) {
+    } catch (_error) {
       this.stats.failedRequests++;
-      this.handleError(error, `${method} ${endpoint}`);
+      this.handleError(_error, `${method} ${endpoint}`);
     } finally {
       this.stats.totalRequests++;
     }
@@ -118,7 +120,7 @@ export class RequestManager extends BaseManager {
         method,
         headers: {
           "Content-Type": "application/json",
-          "User-Agent": "MCP-WordPress/1.1.1",
+          "User-Agent": getUserAgent(),
           ...authHeaders, // Add auth headers before custom headers
           ...options.headers,
         },