mcp-wordpress 2.4.2 → 2.5.0

package/src/security/SecurityConfigManager.ts

@@ -6,8 +6,11 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { z } from "zod";
-import { SecurityUtils } from "./SecurityConfig";
-import { SecurityValidationError } from "./InputValidator";
+import { SecurityUtils } from "./SecurityConfig.js";
+import { SecurityValidationError } from "./InputValidator.js";
+import { LoggerFactory } from "../utils/logger.js";
+
+const logger = LoggerFactory.security();
 
 interface SecurityPolicy {
   id: string;
@@ -40,7 +43,7 @@ interface SecurityPolicyRule {
     paths?: string[];
     userRoles?: string[];
   };
-  parameters: Record<string, any>;
+  parameters: Record<string, unknown>;
   exceptions: string[];
 }
 
@@ -58,7 +61,7 @@ interface SecurityConfiguration {
     logging: LoggingSettings;
     monitoring: MonitoringSettings;
   };
-  overrides: Record<string, any>;
+  overrides: Record<string, unknown>;
   metadata: {
     lastUpdated: Date;
     checksum: string;
@@ -244,7 +247,7 @@ const SecurityPolicySchema = z.object({
         paths: z.array(z.string()).optional(),
         userRoles: z.array(z.string()).optional(),
       }),
-      parameters: z.record(z.any()),
+      parameters: z.record(z.unknown()),
       exceptions: z.array(z.string()),
     }),
   ),
@@ -276,15 +279,16 @@ export class SecurityConfigManager {
    * Initialize security configuration manager
    */
   async initialize(): Promise<void> {
-    console.log("[Security Config] Initializing security configuration manager");
+    logger.info("Initializing security configuration manager");
 
     await this.ensureConfigDirectory();
     await this.loadConfigurations();
     await this.loadPolicies();
 
-    console.log(
-      `[Security Config] Loaded ${this.configurations.size} configurations and ${this.policies.size} policies`,
-    );
+    logger.info("Loaded configurations and policies", {
+      configurationCount: this.configurations.size,
+      policyCount: this.policies.size
+    });
   }
 
   /**
@@ -312,7 +316,7 @@ export class SecurityConfigManager {
     this.policies.set(policy.id, policy);
     await this.savePolicyToFile(policy);
 
-    console.log(`[Security Config] Created policy: ${policy.name} (${policy.id})`);
+    logger.info(`Created policy: ${policy.name}`, { policyId: policy.id });
     return policy;
   }
 
@@ -345,7 +349,7 @@ export class SecurityConfigManager {
     this.policies.set(policyId, updatedPolicy);
     await this.savePolicyToFile(updatedPolicy);
 
-    console.log(`[Security Config] Updated policy: ${updatedPolicy.name} (${policyId})`);
+    logger.info(`Updated policy: ${updatedPolicy.name}`, { policyId });
     return updatedPolicy;
   }
 
@@ -375,7 +379,7 @@ export class SecurityConfigManager {
     this.configurations.set(environment, config);
     await this.saveConfigurationToFile(config);
 
-    console.log(`[Security Config] Created configuration for environment: ${environment}`);
+    logger.info(`Created configuration for environment: ${environment}`, { environment });
     return config;
   }
 
@@ -411,7 +415,7 @@ export class SecurityConfigManager {
         throw new SecurityValidationError("Policy not found", [{ message: `Policy ${policyId} not found` }]);
       }
       if (!policy.enabled) {
-        console.warn(`[Security Config] Skipping disabled policy: ${policy.name}`);
+        logger.warn(`Skipping disabled policy: ${policy.name}`, { policyName: policy.name });
         continue;
       }
       policies.push(policy);
@@ -424,7 +428,7 @@ export class SecurityConfigManager {
     this.configurations.set(environment, config);
     await this.saveConfigurationToFile(config);
 
-    console.log(`[Security Config] Applied ${policies.length} policies to ${environment}`);
+    logger.info(`Applied policies to ${environment}`, { policyCount: policies.length, environment });
     return config;
   }
 
@@ -673,7 +677,7 @@ export class SecurityConfigManager {
         }
       }
     } catch (_error) {
-      console.log("[Security Config] No existing configurations found, will create new ones");
+      logger.info("No existing configurations found, will create new ones");
     }
   }
 
@@ -701,7 +705,7 @@ export class SecurityConfigManager {
         }
       }
     } catch (_error) {
-      console.log("[Security Config] No existing policies found");
+      logger.info("No existing policies found");
     }
   }
 
@@ -780,10 +784,10 @@ export class SecurityConfigManager {
     try {
       const filePath = path.join(this.configPath, "policies", `${policyId}.json`);
       await fs.unlink(filePath);
-      console.log(`[Security Config] Deleted policy: ${policy.name} (${policyId})`);
+      logger.info(`Deleted policy: ${policy.name}`, { policyId });
       return true;
     } catch (error) {
-      console.warn(`[Security Config] Failed to delete policy file: ${error}`);
+      logger.warn("Failed to delete policy file", { error });
       return false;
     }
   }
@@ -820,7 +824,7 @@ export class SecurityConfigManager {
       this.configurations.set(config.environment, config);
       await this.saveConfigurationToFile(config);
 
-      console.log(`[Security Config] Imported configuration for environment: ${config.environment}`);
+      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) }]);

package/src/security/SecurityMonitoring.ts

@@ -4,7 +4,10 @@
  */
 
 import { EventEmitter } from "events";
-import { SecurityUtils } from "./SecurityConfig";
+import { SecurityUtils } from "./SecurityConfig.js";
+import { LoggerFactory } from "../utils/logger.js";
+
+const logger = LoggerFactory.security();
 
 export interface SecurityEvent {
   id: string;
@@ -19,9 +22,9 @@ export interface SecurityEvent {
     userAgent?: string;
     endpoint?: string;
     method?: string;
-    payload?: any;
+    payload?: unknown;
     error?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
   };
   description: string;
   riskScore: number;
@@ -131,12 +134,12 @@ export class SecurityMonitor extends EventEmitter {
    */
   start(): void {
     if (this.isMonitoring) {
-      console.warn("[Security Monitor] Already monitoring");
+      logger.warn("Already monitoring");
       return;
     }
 
     this.isMonitoring = true;
-    console.log("[Security Monitor] Starting security monitoring");
+    logger.info("Starting security monitoring");
 
     // Start metrics collection
     this.metricsInterval = setInterval(() => {
@@ -151,7 +154,7 @@ export class SecurityMonitor extends EventEmitter {
    */
   stop(): void {
     if (!this.isMonitoring) {
-      console.warn("[Security Monitor] Not currently monitoring");
+      logger.warn("Not currently monitoring");
       return;
     }
 
@@ -162,7 +165,7 @@ export class SecurityMonitor extends EventEmitter {
       this.metricsInterval = undefined;
     }
 
-    console.log("[Security Monitor] Stopped security monitoring");
+    logger.info("Stopped security monitoring");
     this.emit("monitoring-stopped");
   }
 
@@ -191,7 +194,7 @@ export class SecurityMonitor extends EventEmitter {
     // Emit event for real-time processing
     this.emit("security-event", event);
 
-    console.log(`[Security Monitor] Logged ${event.severity} event: ${event.type} - ${event.description}`);
+    logger.info(`Logged ${event.severity} event: ${event.type} - ${event.description}`);
 
     return event;
   }
@@ -274,7 +277,7 @@ export class SecurityMonitor extends EventEmitter {
           await this.executeLogAction(event);
           break;
         default:
-          console.log(`[Security Monitor] Action ${type} queued for manual processing`);
+          logger.info(`Action ${type} queued for manual processing`, { type });
       }
 
       action.result = "success";
@@ -282,7 +285,7 @@ export class SecurityMonitor extends EventEmitter {
     } catch (error) {
       action.result = "failure";
       action.details += ` - failed: ${error instanceof Error ? error.message : String(error)}`;
-      console.error(`[Security Monitor] Action ${type} failed:`, error);
+      logger.error(`Action ${type} failed`, { type, error });
     }
 
     return action;
@@ -293,7 +296,7 @@ export class SecurityMonitor extends EventEmitter {
    */
   private async executeBlockAction(event: SecurityEvent): Promise<void> {
     if (event.details.ipAddress) {
-      console.log(`[Security Monitor] Blocking IP: ${event.details.ipAddress}`);
+      logger.info(`Blocking IP: ${event.details.ipAddress}`);
       // In a real implementation, this would interface with firewall/load balancer
       this.emit("ip-blocked", { ip: event.details.ipAddress, reason: event.description });
     }
@@ -304,7 +307,7 @@ export class SecurityMonitor extends EventEmitter {
    */
   private async executeThrottleAction(event: SecurityEvent): Promise<void> {
     if (event.details.userId) {
-      console.log(`[Security Monitor] Throttling user: ${event.details.userId}`);
+      logger.info(`Throttling user: ${event.details.userId}`);
       // In a real implementation, this would apply rate limiting
       this.emit("user-throttled", { userId: event.details.userId, reason: event.description });
     }
@@ -314,7 +317,7 @@ export class SecurityMonitor extends EventEmitter {
    * Execute alert action
    */
   private async executeAlertAction(event: SecurityEvent): Promise<void> {
-    console.log(`[Security Monitor] Alert triggered for event: ${event.id}`);
+    logger.info(`Alert triggered for event: ${event.id}`);
     this.emit("security-alert", event);
   }
 
@@ -322,7 +325,7 @@ export class SecurityMonitor extends EventEmitter {
    * Execute log action
    */
   private async executeLogAction(event: SecurityEvent): Promise<void> {
-    console.log(`[Security Monitor] Enhanced logging for event: ${event.id}`);
+    logger.info(`Enhanced logging for event: ${event.id}`);
     // Additional detailed logging would go here
   }
 
@@ -346,7 +349,7 @@ export class SecurityMonitor extends EventEmitter {
 
     this.alerts.push(alert);
 
-    console.log(`[Security Monitor] Created ${alert.severity} alert: ${alert.title}`);
+    logger.info(`Created ${alert.severity} alert: ${alert.title}`);
     this.emit("alert-created", alert);
 
     return alert;
@@ -611,9 +614,9 @@ export class SecurityMonitor extends EventEmitter {
   /**
    * Group array by property
    */
-  private groupBy(array: any[], property: string): Record<string, number> {
-    return array.reduce((acc, item) => {
-      const key = item[property] || "unknown";
+  private groupBy(array: Array<Record<string, any>>, property: string): Record<string, number> { // eslint-disable-line @typescript-eslint/no-explicit-any
+    return array.reduce<Record<string, number>>((acc, item) => {
+      const key = (item && item[property]) || "unknown";
       acc[key] = (acc[key] || 0) + 1;
       return acc;
     }, {});
@@ -664,7 +667,7 @@ export class SecurityMonitor extends EventEmitter {
    */
   addThreatIntelligence(threat: ThreatIntelligence): void {
     this.threatIntel.set(threat.value, threat);
-    console.log(`[Security Monitor] Added threat intelligence: ${threat.type} - ${threat.value}`);
+    logger.info(`Added threat intelligence: ${threat.type} - ${threat.value}`);
   }
 
   /**
@@ -673,7 +676,7 @@ export class SecurityMonitor extends EventEmitter {
   removeThreatIntelligence(value: string): boolean {
     const removed = this.threatIntel.delete(value);
     if (removed) {
-      console.log(`[Security Monitor] Removed threat intelligence: ${value}`);
+      logger.info(`Removed threat intelligence: ${value}`);
     }
     return removed;
   }
@@ -700,7 +703,7 @@ export class SecurityMonitor extends EventEmitter {
       };
     }
 
-    console.log(`[Security Monitor] Updated alert ${alertId} status to ${status}`);
+    logger.info(`Updated alert ${alertId} status to ${status}`);
     this.emit("alert-updated", alert);
     return true;
   }

package/src/security/SecurityReviewer.ts

@@ -5,8 +5,9 @@
 
 import * as fs from "fs/promises";
 import * as path from "path";
-import { SecurityUtils } from "./SecurityConfig";
-import { SecurityValidationError } from "./InputValidator";
+import { SecurityUtils } from "./SecurityConfig.js";
+import { SecurityValidationError } from "./InputValidator.js";
+import { LoggerFactory } from "../utils/logger.js";
 
 interface SecurityReviewRule {
   id: string;
@@ -345,7 +346,8 @@ export class SecurityReviewer {
     } = {},
   ): Promise<CodeReviewResult> {
     const reviewId = SecurityUtils.generateSecureToken(16);
-    console.log(`[Security Reviewer] Reviewing file: ${filePath}`);
+    const logger = LoggerFactory.security();
+    logger.info("Reviewing file", { filePath, reviewId });
 
     try {
       const content = await fs.readFile(filePath, "utf-8");
@@ -376,11 +378,11 @@ export class SecurityReviewer {
       };
 
       this.reviewHistory.push(result);
-      console.log(`[Security Reviewer] Review completed: ${findings.length} findings`);
+      logger.info("Review completed", { filePath, findingsCount: findings.length, reviewId });
 
       return result;
     } catch (error) {
-      console.error(`[Security Reviewer] Review failed for ${filePath}:`, error);
+      logger.error("Review failed", { filePath, reviewId, error: error instanceof Error ? error.message : String(error) });
       throw new SecurityValidationError("Security review failed", [{ message: String(error) }]);
     }
   }
@@ -398,7 +400,8 @@ export class SecurityReviewer {
       aiAnalysis?: boolean;
     } = {},
   ): Promise<CodeReviewResult[]> {
-    console.log(`[Security Reviewer] Reviewing directory: ${dirPath}`);
+    const logger = LoggerFactory.security();
+    logger.info("Reviewing directory", { dirPath });
 
     const results: CodeReviewResult[] = [];
     const filePattern = options.filePattern || /\.(ts|js|jsx|tsx)$/;
@@ -420,7 +423,7 @@ export class SecurityReviewer {
 
       return results;
     } catch (error) {
-      console.error(`[Security Reviewer] Directory review failed for ${dirPath}:`, 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

@@ -4,8 +4,9 @@
  */
 
 // Core Security Components
-export { SecurityConfig, SecurityUtils, createSecureError, getEnvironmentSecurity } from "./SecurityConfig";
-import { SecurityValidationError } from "./InputValidator";
+export { SecurityConfig, SecurityUtils, createSecureError, getEnvironmentSecurity } from "./SecurityConfig.js";
+import { SecurityValidationError } from "./InputValidator.js";
+import { LoggerFactory } from "../utils/logger.js";
 export {
   InputSanitizer,
   SecuritySchemas,
@@ -13,31 +14,32 @@ export {
   SecurityValidationError,
   validateSecurity,
   ToolSchemas,
-} from "./InputValidator";
+} from "./InputValidator.js";
 
 // AI-Powered Security Scanner
-import { AISecurityScanner } from "./AISecurityScanner";
-export { AISecurityScanner } from "./AISecurityScanner";
+import { AISecurityScanner } from "./AISecurityScanner.js";
+import type { SecurityScanResult } from "./AISecurityScanner.js";
+export { AISecurityScanner } from "./AISecurityScanner.js";
 
 // Automated Remediation System
-import { AutomatedRemediation, RemediationResult as _RemediationResult } from "./AutomatedRemediation";
-export { AutomatedRemediation, RemediationResult } from "./AutomatedRemediation";
+import { AutomatedRemediation, RemediationResult as _RemediationResult } from "./AutomatedRemediation.js";
+export { AutomatedRemediation, RemediationResult } from "./AutomatedRemediation.js";
 
 // Security Code Reviewer
-import { SecurityReviewer, CodeReviewResult as _CodeReviewResult } from "./SecurityReviewer";
-export { SecurityReviewer, CodeReviewResult } from "./SecurityReviewer";
+import { SecurityReviewer, CodeReviewResult as _CodeReviewResult } from "./SecurityReviewer.js";
+export { SecurityReviewer, CodeReviewResult } from "./SecurityReviewer.js";
 
 // Security Configuration Manager
-import { SecurityConfigManager } from "./SecurityConfigManager";
-export { SecurityConfigManager } from "./SecurityConfigManager";
+import { SecurityConfigManager } from "./SecurityConfigManager.js";
+export { SecurityConfigManager } from "./SecurityConfigManager.js";
 
 // Security Monitoring and Alerting
-import { SecurityMonitor, SecurityEvent as _SecurityEvent } from "./SecurityMonitoring";
-export { SecurityMonitor, SecurityEvent } from "./SecurityMonitoring";
+import { SecurityMonitor, SecurityEvent as _SecurityEvent } from "./SecurityMonitoring.js";
+export { SecurityMonitor, SecurityEvent } from "./SecurityMonitoring.js";
 
 // CI/CD Pipeline Integration
-import { SecurityCIPipeline, PipelineSecurityReport as _PipelineSecurityReport } from "./SecurityCIPipeline";
-export { SecurityCIPipeline, PipelineSecurityReport } from "./SecurityCIPipeline";
+import { SecurityCIPipeline, PipelineSecurityReport as _PipelineSecurityReport } from "./SecurityCIPipeline.js";
+export { SecurityCIPipeline, PipelineSecurityReport } from "./SecurityCIPipeline.js";
 
 // Type definitions for external use
 export interface SecurityScanOptions {
@@ -87,11 +89,13 @@ export class SecuritySystem {
    */
   async initialize(): Promise<void> {
     if (this.initialized) {
-      console.log("[Security System] Already initialized");
+      const logger = LoggerFactory.security();
+      logger.info("Security system already initialized");
       return;
     }
 
-    console.log("[Security System] Initializing comprehensive security system...");
+    const logger = LoggerFactory.security();
+    logger.info("Initializing comprehensive security system");
 
     try {
       // Initialize all components
@@ -102,9 +106,11 @@ export class SecuritySystem {
       this.monitor.start();
 
       this.initialized = true;
-      console.log("[Security System] Security system initialized successfully");
+      logger.info("Security system initialized successfully");
     } catch (error) {
-      console.error("[Security System] Initialization failed:", error);
+      logger.error("Security system initialization failed", {
+        error: error instanceof Error ? error.message : String(error),
+      });
       throw new SecurityValidationError("Security system initialization failed", [{ message: String(error) }]);
     }
   }
@@ -128,26 +134,54 @@ export class SecuritySystem {
   /**
    * Create and execute remediation plan
    */
-  async remediate(scanResult: any, dryRun = false): Promise<_RemediationResult[]> {
+  async remediate(scanResult: unknown, dryRun = false): Promise<_RemediationResult[]> {
     this.ensureInitialized();
-    const plan = await this.remediation.createRemediationPlan(scanResult);
+    const plan = await this.remediation.createRemediationPlan(scanResult as SecurityScanResult);
     return await this.remediation.executeRemediationPlan(plan, { dryRun });
   }
 
   /**
    * Execute security gates for CI/CD
    */
-  async executeGates(stage: string, context: any, options?: SecurityGateOptions): Promise<_PipelineSecurityReport> {
+  async executeGates(stage: string, context: unknown, options?: SecurityGateOptions): Promise<_PipelineSecurityReport> {
     this.ensureInitialized();
-    return await this.pipeline.executeSecurityGates(stage as any, context, options);
+    const validStages = ["pre-commit", "pre-build", "pre-deploy", "post-deploy"] as const;
+    type ValidStage = (typeof validStages)[number];
+    const validStage = validStages.includes(stage as ValidStage) ? (stage as ValidStage) : "pre-commit";
+
+    // Create a minimal PipelineContext from unknown input
+    const pipelineContext = {
+      repositoryUrl: "",
+      branch: "",
+      commit: "",
+      author: "",
+      environment: "development",
+      buildNumber: "",
+      artifacts: [],
+      ...(typeof context === "object" && context !== null ? context : {}),
+    };
+
+    return await this.pipeline.executeSecurityGates(validStage, pipelineContext, options);
   }
 
   /**
    * Log security event
    */
-  async logEvent(eventData: any): Promise<_SecurityEvent> {
+  async logEvent(eventData: unknown): Promise<_SecurityEvent> {
     this.ensureInitialized();
-    return await this.monitor.logSecurityEvent(eventData);
+
+    // Create a minimal SecurityEvent from unknown input
+    const securityEventData = {
+      type: "system" as const,
+      description: "Security event",
+      severity: "low" as const,
+      source: "unknown",
+      details: {},
+      riskScore: 0,
+      ...(typeof eventData === "object" && eventData !== null ? eventData : {}),
+    };
+
+    return await this.monitor.logSecurityEvent(securityEventData);
   }
 
   /**
@@ -171,12 +205,13 @@ export class SecuritySystem {
       return;
     }
 
-    console.log("[Security System] Shutting down security system...");
+    const logger = LoggerFactory.security();
+    logger.info("Shutting down security system");
 
     this.monitor.stop();
     this.initialized = false;
 
-    console.log("[Security System] Security system shutdown complete");
+    logger.info("Security system shutdown complete");
   }
 
   /**
@@ -225,12 +260,12 @@ export const security = {
   /**
    * Quick remediation
    */
-  remediate: (scanResult: any, dryRun = true) => securitySystem.remediate(scanResult, dryRun),
+  remediate: (scanResult: unknown, dryRun = true) => securitySystem.remediate(scanResult, dryRun),
 
   /**
    * Log security event
    */
-  logEvent: (eventData: any) => securitySystem.logEvent(eventData),
+  logEvent: (eventData: unknown) => securitySystem.logEvent(eventData),
 
   /**
    * Get security status