mcp-wordpress 2.6.4 → 2.7.0

package/src/security/SecurityConfigManager.ts

@@ -247,7 +247,7 @@ const SecurityPolicySchema = z.object({
         paths: z.array(z.string()).optional(),
         userRoles: z.array(z.string()).optional(),
       }),
-      parameters: z.record(z.unknown()),
+      parameters: z.record(z.string(), z.unknown()),
       exceptions: z.array(z.string()),
     }),
   ),
@@ -287,7 +287,7 @@ export class SecurityConfigManager {
 
     logger.info("Loaded configurations and policies", {
       configurationCount: this.configurations.size,
-      policyCount: this.policies.size
+      policyCount: this.policies.size,
     });
   }
 
@@ -309,8 +309,8 @@ export class SecurityConfigManager {
     // Validate policy
     try {
       SecurityPolicySchema.parse(policy);
-    } catch (error) {
-      throw new SecurityValidationError("Invalid security policy", [{ message: String(error) }]);
+    } catch (_error) {
+      throw new SecurityValidationError("Invalid security policy", [{ message: String(_error) }]);
     }
 
     this.policies.set(policy.id, policy);
@@ -342,8 +342,8 @@ export class SecurityConfigManager {
     // Validate updated policy
     try {
       SecurityPolicySchema.parse(updatedPolicy);
-    } catch (error) {
-      throw new SecurityValidationError("Invalid policy update", [{ message: String(error) }]);
+    } catch (_error) {
+      throw new SecurityValidationError("Invalid policy update", [{ message: String(_error) }]);
     }
 
     this.policies.set(policyId, updatedPolicy);
@@ -786,8 +786,8 @@ export class SecurityConfigManager {
       await fs.unlink(filePath);
       logger.info(`Deleted policy: ${policy.name}`, { policyId });
       return true;
-    } catch (error) {
-      logger.warn("Failed to delete policy file", { error });
+    } catch (_error) {
+      logger.warn("Failed to delete policy file", { _error });
       return false;
     }
   }
@@ -826,8 +826,8 @@ export class SecurityConfigManager {
 
       logger.info(`Imported configuration for environment: ${config.environment}`, { environment: config.environment });
       return config;
-    } catch (error) {
-      throw new SecurityValidationError("Failed to import configuration", [{ message: String(error) }]);
+    } catch (_error) {
+      throw new SecurityValidationError("Failed to import configuration", [{ message: String(_error) }]);
     }
   }
 }

package/src/security/SecurityMonitoring.ts

@@ -282,10 +282,10 @@ export class SecurityMonitor extends EventEmitter {
 
       action.result = "success";
       action.details += " - executed successfully";
-    } catch (error) {
+    } catch (_error) {
       action.result = "failure";
-      action.details += ` - failed: ${error instanceof Error ? error.message : String(error)}`;
-      logger.error(`Action ${type} failed`, { type, error });
+      action.details += ` - failed: ${_error instanceof Error ? _error.message : String(_error)}`;
+      logger.error(`Action ${type} failed`, { type, _error });
     }
 
     return action;
@@ -614,9 +614,9 @@ export class SecurityMonitor extends EventEmitter {
   /**
    * Group array by property
    */
-  private groupBy(array: Array<Record<string, any>>, property: string): Record<string, number> { // eslint-disable-line @typescript-eslint/no-explicit-any
+  private groupBy(array: SecurityEvent[], property: string): Record<string, number> {
     return array.reduce<Record<string, number>>((acc, item) => {
-      const key = (item && item[property]) || "unknown";
+      const key = String((item as unknown as Record<string, unknown>)[property]) || "unknown";
       acc[key] = (acc[key] || 0) + 1;
       return acc;
     }, {});

package/src/security/SecurityReviewer.ts

@@ -381,9 +381,13 @@ export class SecurityReviewer {
       logger.info("Review completed", { filePath, findingsCount: findings.length, reviewId });
 
       return result;
-    } catch (error) {
-      logger.error("Review failed", { filePath, reviewId, error: error instanceof Error ? error.message : String(error) });
-      throw new SecurityValidationError("Security review failed", [{ message: String(error) }]);
+    } catch (_error) {
+      logger.error("Review failed", {
+        filePath,
+        reviewId,
+        _error: _error instanceof Error ? _error.message : String(_error),
+      });
+      throw new SecurityValidationError("Security review failed", [{ message: String(_error) }]);
     }
   }
 
@@ -422,9 +426,12 @@ export class SecurityReviewer {
       }
 
       return results;
-    } catch (error) {
-      logger.error("Directory review failed", { dirPath, error: error instanceof Error ? error.message : String(error) });
-      throw new SecurityValidationError("Directory review failed", [{ message: String(error) }]);
+    } catch (_error) {
+      logger.error("Directory review failed", {
+        dirPath,
+        _error: _error instanceof Error ? _error.message : String(_error),
+      });
+      throw new SecurityValidationError("Directory review failed", [{ message: String(_error) }]);
     }
   }
 

package/src/security/index.ts

@@ -107,11 +107,11 @@ export class SecuritySystem {
 
       this.initialized = true;
       logger.info("Security system initialized successfully");
-    } catch (error) {
+    } catch (_error) {
       logger.error("Security system initialization failed", {
-        error: error instanceof Error ? error.message : String(error),
+        _error: _error instanceof Error ? _error.message : String(_error),
       });
-      throw new SecurityValidationError("Security system initialization failed", [{ message: String(error) }]);
+      throw new SecurityValidationError("Security system initialization failed", [{ message: String(_error) }]);
     }
   }
 

package/src/server/ConnectionTester.ts

@@ -59,15 +59,15 @@ export class ConnectionTester {
           const duration = Date.now() - startTime;
           this.logger.info("Connection successful", { siteId, duration: `${duration}ms` });
           results.push({ siteId, success: true });
-        } catch (error) {
+        } catch (_error) {
           const duration = Date.now() - startTime;
-          const errorMessage = getErrorMessage(error);
+          const errorMessage = getErrorMessage(_error);
 
           this.logger.warn("Connection failed", {
             siteId,
             error: errorMessage,
             duration: `${duration}ms`,
-            isAuthError: ConnectionTester.isAuthenticationError(error),
+            isAuthError: ConnectionTester.isAuthenticationError(_error),
           });
 
           results.push({ siteId, success: false, error: errorMessage });
@@ -122,10 +122,10 @@ export class ConnectionTester {
 
       this.logger.debug("Health check passed", { siteId });
       return true;
-    } catch (error) {
+    } catch (_error) {
       this.logger.warn("Health check failed", {
         siteId,
-        error: getErrorMessage(error),
+        _error: getErrorMessage(_error),
       });
       return false;
     }

package/src/server/ToolRegistry.ts

@@ -26,8 +26,9 @@ export interface ToolDefinition {
  * Handles tool registration, parameter validation, and execution
  */
 export class ToolRegistry {
-  private server: McpServer;
-  private wordpressClients: Map<string, WordPressClient>;
+  // Exposed for tests that assert presence of these fields
+  public server: McpServer;
+  public wordpressClients: Map<string, WordPressClient>;
 
   constructor(server: McpServer, wordpressClients: Map<string, WordPressClient>) {
     this.server = server;
@@ -141,8 +142,8 @@ export class ToolRegistry {
               },
             ],
           };
-        } catch (error) {
-          if (this.isAuthenticationError(error)) {
+        } catch (_error) {
+          if (this.isAuthenticationError(_error)) {
             return {
               content: [
                 {
@@ -155,12 +156,12 @@ export class ToolRegistry {
           }
 
           // Handle enhanced errors with suggestions
-          if (error instanceof EnhancedError) {
+          if (_error instanceof EnhancedError) {
             return {
               content: [
                 {
                   type: "text" as const,
-                  text: error.toString(),
+                  text: _error.toString(),
                 },
               ],
               isError: true,
@@ -171,7 +172,7 @@ export class ToolRegistry {
             content: [
               {
                 type: "text" as const,
-                text: `Error: ${getErrorMessage(error)}`,
+                text: `Error: ${getErrorMessage(_error)}`,
               },
             ],
             isError: true,
@@ -223,7 +224,7 @@ export class ToolRegistry {
       case "array":
         return z.array(z.string());
       case "object":
-        return z.record(z.unknown());
+        return z.record(z.string(), z.unknown());
       default:
         return z.string();
     }

package/src/server/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Server Barrel Export
+ * Centralized exports for server components
+ */
+
+// Connection Testing
+export { ConnectionTester } from './ConnectionTester.js';
+
+// Tool Registry Management
+export { ToolRegistry } from './ToolRegistry.js';

package/src/tools/BaseToolManager.ts

@@ -33,10 +33,10 @@ export class BaseToolUtils {
    */
   static validateParams<T extends Record<string, unknown>>(
     params: unknown,
-    rules: readonly ParameterValidationRule[]
+    rules: readonly ParameterValidationRule[],
   ): Result<T, Error> {
-    if (!params || typeof params !== 'object' || Array.isArray(params)) {
-      return createError(new ValidationError('Parameters must be a non-null object', 'params', params));
+    if (!params || typeof params !== "object" || Array.isArray(params)) {
+      return createError(new ValidationError("Parameters must be a non-null object", "params", params));
     }
 
     const typedParams = params as Record<string, unknown>;
@@ -48,11 +48,9 @@ export class BaseToolUtils {
 
       // Check required fields
       if (rule.required && (!exists || value === undefined || value === null)) {
-        errors.push(new ValidationError(
-          rule.errorMessage || `Missing required parameter: ${rule.key}`,
-          rule.key,
-          value
-        ));
+        errors.push(
+          new ValidationError(rule.errorMessage || `Missing required parameter: ${rule.key}`, rule.key, value),
+        );
         continue;
       }
 
@@ -63,21 +61,21 @@ export class BaseToolUtils {
 
       // Type validation
       if (rule.type && typeof value !== rule.type) {
-        errors.push(new ValidationError(
-          `Parameter ${rule.key} must be of type ${rule.type}, got ${typeof value}`,
-          rule.key,
-          value
-        ));
+        errors.push(
+          new ValidationError(
+            `Parameter ${rule.key} must be of type ${rule.type}, got ${typeof value}`,
+            rule.key,
+            value,
+          ),
+        );
         continue;
       }
 
       // Custom validation
       if (rule.validator && !rule.validator(value)) {
-        errors.push(new ValidationError(
-          rule.errorMessage || `Parameter ${rule.key} failed validation`,
-          rule.key,
-          value
-        ));
+        errors.push(
+          new ValidationError(rule.errorMessage || `Parameter ${rule.key} failed validation`, rule.key, value),
+        );
         continue;
       }
 
@@ -85,12 +83,14 @@ export class BaseToolUtils {
       if (rule.transformer) {
         try {
           typedParams[rule.key] = rule.transformer(value);
-        } catch (error) {
-          errors.push(new ValidationError(
-            `Failed to transform parameter ${rule.key}: ${getErrorMessage(error)}`,
-            rule.key,
-            value
-          ));
+        } catch (_error) {
+          errors.push(
+            new ValidationError(
+              `Failed to transform parameter ${rule.key}: ${getErrorMessage(_error)}`,
+              rule.key,
+              value,
+            ),
+          );
         }
       }
     }
@@ -109,19 +109,11 @@ export class BaseToolUtils {
     try {
       const numId = Number(id);
       if (!Number.isInteger(numId) || numId <= 0) {
-        return createError(new ValidationError(
-          `Invalid ${name}: must be a positive integer`,
-          name,
-          id
-        ));
+        return createError(new ValidationError(`Invalid ${name}: must be a positive integer`, name, id));
       }
       return createSuccess(createWordPressId(numId));
-    } catch (error) {
-      return createError(new ValidationError(
-        `Invalid ${name}: ${getErrorMessage(error)}`,
-        name,
-        id
-      ));
+    } catch (_error) {
+      return createError(new ValidationError(`Invalid ${name}: ${getErrorMessage(_error)}`, name, id));
     }
   }
 
@@ -130,7 +122,7 @@ export class BaseToolUtils {
    */
   static validateIds(ids: unknown[], name = "ids"): Result<readonly WordPressId[], Error> {
     const validatedIds: WordPressId[] = [];
-    
+
     for (let i = 0; i < ids.length; i++) {
       const result = this.validateId(ids[i], `${name}[${i}]`);
       if (!result.success) {
@@ -138,7 +130,7 @@ export class BaseToolUtils {
       }
       validatedIds.push(result.data);
     }
-    
+
     return createSuccess(validatedIds as readonly WordPressId[]);
   }
 
@@ -148,13 +140,13 @@ export class BaseToolUtils {
   static handleError(error: unknown, operation: string, context?: Record<string, unknown> | undefined): Error {
     const errorMessage = getErrorMessage(error);
     const enhancedMessage = `Error in ${operation}: ${errorMessage}`;
-    
+
     const enhancedError = new Error(enhancedMessage) as EnhancedError;
     enhancedError.originalError = error;
     enhancedError.operation = operation;
     enhancedError.context = context;
     enhancedError.timestamp = new Date();
-    
+
     return enhancedError;
   }
 
@@ -162,18 +154,14 @@ export class BaseToolUtils {
    * Generate cache keys with enhanced options
    */
   static generateCacheKey(
-    operation: string, 
+    operation: string,
     params: DeepReadonly<Record<string, unknown>>,
-    options: CacheKeyOptions = {}
+    options: CacheKeyOptions = {},
   ): string {
-    const {
-      namespace = 'wp',
-      includeTimestamp = false,
-      customHasher
-    } = options;
+    const { namespace = "wp", includeTimestamp = false, customHasher } = options;
 
     const site = params.site || "default";
-    
+
     let paramStr: string;
     if (customHasher) {
       paramStr = customHasher(params as Record<string, unknown>);
@@ -186,12 +174,12 @@ export class BaseToolUtils {
     }
 
     let cacheKey = `${namespace}:${site}:${operation}:${paramStr}`;
-    
+
     if (includeTimestamp) {
       const timestamp = Math.floor(Date.now() / 1000);
       cacheKey += `:${timestamp}`;
     }
-    
+
     return cacheKey;
   }
 
@@ -200,17 +188,17 @@ export class BaseToolUtils {
    */
   static formatSuccessMessage(operation: string, details?: string, count?: number): string {
     let message = operation;
-    
+
     if (count !== undefined) {
-      message += ` (${count} ${count === 1 ? 'item' : 'items'})`;
+      message += ` (${count} ${count === 1 ? "item" : "items"})`;
     }
-    
+
     if (details) {
       message += `: ${details}`;
     } else {
       message += " completed successfully";
     }
-    
+
     return message;
   }
 
@@ -218,7 +206,7 @@ export class BaseToolUtils {
    * Validate string parameters with enhanced checks
    */
   static validateString(
-    value: unknown, 
+    value: unknown,
     name: string,
     options: {
       readonly required?: boolean;
@@ -226,7 +214,7 @@ export class BaseToolUtils {
       readonly maxLength?: number;
       readonly pattern?: RegExp;
       readonly allowEmpty?: boolean;
-    } = {}
+    } = {},
   ): Result<string, Error> {
     const { required = true, minLength, maxLength, pattern, allowEmpty = false } = options;
 
@@ -234,10 +222,10 @@ export class BaseToolUtils {
       if (required) {
         return createError(new ValidationError(`${name} is required`, name, value));
       }
-      return createSuccess('');
+      return createSuccess("");
     }
 
-    if (typeof value !== 'string') {
+    if (typeof value !== "string") {
       return createError(new ValidationError(`${name} must be a string`, name, value));
     }
 
@@ -246,27 +234,15 @@ export class BaseToolUtils {
     }
 
     if (minLength !== undefined && value.length < minLength) {
-      return createError(new ValidationError(
-        `${name} must be at least ${minLength} characters long`, 
-        name, 
-        value
-      ));
+      return createError(new ValidationError(`${name} must be at least ${minLength} characters long`, name, value));
     }
 
     if (maxLength !== undefined && value.length > maxLength) {
-      return createError(new ValidationError(
-        `${name} must be no more than ${maxLength} characters long`, 
-        name, 
-        value
-      ));
+      return createError(new ValidationError(`${name} must be no more than ${maxLength} characters long`, name, value));
     }
 
     if (pattern && !pattern.test(value)) {
-      return createError(new ValidationError(
-        `${name} does not match required pattern`, 
-        name, 
-        value
-      ));
+      return createError(new ValidationError(`${name} does not match required pattern`, name, value));
     }
 
     return createSuccess(value);
@@ -275,25 +251,21 @@ export class BaseToolUtils {
   /**
    * Type-safe parameter extraction
    */
-  static extractParam<T>(
-    params: DeepReadonly<Record<string, unknown>>, 
-    key: string, 
-    defaultValue?: T
-  ): T | undefined {
+  static extractParam<T>(params: DeepReadonly<Record<string, unknown>>, key: string, defaultValue?: T): T | undefined {
     const value = params[key];
-    return value !== undefined ? value as T : defaultValue;
+    return value !== undefined ? (value as T) : defaultValue;
   }
 
   /**
    * Safe array extraction with type validation
    */
   static extractArray<T>(
-    params: DeepReadonly<Record<string, unknown>>, 
+    params: DeepReadonly<Record<string, unknown>>,
     key: string,
-    itemValidator?: (item: unknown) => item is T
+    itemValidator?: (item: unknown) => item is T,
   ): readonly T[] {
     const value = params[key];
-    
+
     if (!Array.isArray(value)) {
       return [];
     }
@@ -311,9 +283,9 @@ class ValidationError extends Error {
   constructor(
     message: string,
     public readonly field: string,
-    public readonly value: unknown
+    public readonly value: unknown,
   ) {
     super(message);
-    this.name = 'ValidationError';
+    this.name = "ValidationError";
   }
 }

package/src/tools/auth.ts

@@ -14,7 +14,14 @@ export class AuthTools {
   public getTools(): Array<{
     name: string;
     description: string;
-    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    parameters?: Array<{
+      name: string;
+      type?: string;
+      description?: string;
+      required?: boolean;
+      enum?: string[];
+      items?: unknown;
+    }>;
     handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
   }> {
     return [
@@ -94,8 +101,8 @@ export class AuthTools {
         "Your WordPress connection is working properly.";
 
       return { content };
-    } catch (error) {
-      throw new Error(`Authentication test failed: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Authentication test failed: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -126,8 +133,8 @@ export class AuthTools {
       }
 
       return { content };
-    } catch (error) {
-      throw new Error(`Failed to get auth status: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to get auth status: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -138,11 +145,13 @@ export class AuthTools {
    * @param params - The parameters for the tool request, including the new auth details.
    * @returns A promise that resolves to an MCPToolResponse.
    */
-  public async handleSwitchAuthMethod(
-    client: WordPressClient,
-    params: Record<string, unknown>,
-  ): Promise<unknown> {
-    const { method: _method, username: _username, password: _password, jwt_token: _jwt_token } = params as {
+  public async handleSwitchAuthMethod(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const {
+      method: _method,
+      username: _username,
+      password: _password,
+      jwt_token: _jwt_token,
+    } = params as {
       method: AuthMethod;
       username?: string;
       password?: string;
@@ -154,8 +163,8 @@ export class AuthTools {
       throw new Error(
         "Dynamic authentication method switching is not currently supported. Please update your configuration file and restart the server.",
       );
-    } catch (error) {
-      throw new Error(`Failed to switch auth method: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to switch auth method: ${getErrorMessage(_error)}`);
     }
   }
 }