In n8n-MCP, the AI-written workflow telemetry sanitizer incorrectly allowed partial values from URL-shaped node parameters to persist in telemetry events, potentially leaking sensitive data.

+}+ export class WorkflowSanitizer {-  private static readonly SENSITIVE_PATTERNS = [+  private static readonly SENSITIVE_PATTERNS: PatternDefinition[] = [     // Webhook URLs (replace with placeholder but keep structure) - MUST BE FIRST-    /https?:\/\/[^\s/]+\/webhook\/[^\s]+/g,-    /https?:\/\/[^\s/]+\/hook\/[^\s]+/g,--    // API keys and tokens-    /sk-[a-zA-Z0-9]{16,}/g, // OpenAI keys-    /Bearer\s+[^\s]+/gi,    // Bearer tokens-    /[a-zA-Z0-9_-]{20,}/g,  // Long alphanumeric strings (API keys) - reduced threshold-    /token['":\s]+[^,}]+/gi, // Token fields-    /apikey['":\s]+[^,}]+/gi, // API key fields-    /api_key['":\s]+[^,}]+/gi,-    /secret['":\s]+[^,}]+/gi,-    /password['":\s]+[^,}]+/gi,-    /credential['":\s]+[^,}]+/gi,--    // URLs with authentication-    /https?:\/\/[^:]+:[^@]+@[^\s/]+/g, // URLs with auth-    /wss?:\/\/[^:]+:[^@]+@[^\s/]+/g,+    { pattern: /https?:\/\/[^\s/]+\/webhook\/[^\s]+/g, placeholder: '[REDACTED_WEBHOOK]' },+    { pattern: /https?:\/\/[^\s/]+\/hook\/[^\s]+/g, placeholder: '[REDACTED_WEBHOOK]' },++    // URLs with authentication - MUST BE BEFORE BEARER TOKENS+    { pattern: /https?:\/\/[^:]+:[^@]+@[^\s/]+/g, placeholder: '[REDACTED_URL_WITH_AUTH]' },+    { pattern: /wss?:\/\/[^:]+:[^@]+@[^\s/]+/g, placeholder: '[REDACTED_URL_WITH_AUTH]' },+    { pattern: /(?:postgres|mysql|mongodb|redis):\/\/[^:]+:[^@]+@[^\s]+/g, placeholder: '[REDACTED_URL_WITH_AUTH]' }, // Database protocols - includes port and path++    // API keys and tokens - ORDER MATTERS!+    // More specific patterns first, then general patterns+    { pattern: /sk-[a-zA-Z0-9]{16,}/g, placeholder: '[REDACTED_APIKEY]' }, // OpenAI keys+    { pattern: /Bearer\s+[^\s]+/gi, placeholder: 'Bearer [REDACTED]', preservePrefix: true }, // Bearer tokens+    { pattern: /\b[a-zA-Z0-9_-]{32,}\b/g, placeholder: '[REDACTED_TOKEN]' }, // Long tokens (32+ chars)+    { pattern: /\b[a-zA-Z0-9_-]{20,31}\b/g, placeholder: '[REDACTED]' }, // Short tokens (20-31 chars)      // Email addresses (optional - uncomment if needed)-    // /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,+    // { pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, placeholder: '[REDACTED_EMAIL]' },   ];    private static readonly SENSITIVE_FIELDS = [@@ -178,19 +181,34 @@ export class WorkflowSanitizer {     const sanitized: any = {};      for (const [key, value] of Object.entries(obj)) {-      // Check if key is sensitive-      if (this.isSensitiveField(key)) {-        sanitized[key] = '[REDACTED]';-        continue;-      }+      // Check if field name is sensitive+      const isSensitive = this.isSensitiveField(key);+      const isUrlField = key.toLowerCase().includes('url') ||+                         key.toLowerCase().includes('endpoint') ||+                         key.toLowerCase().includes('webhook'); -      // Recursively sanitize nested objects+      // Recursively sanitize nested objects (unless it's a sensitive non-URL field)       if (typeof value === 'object' && value !== null) {-        sanitized[key] = this.sanitizeObject(value);+        if (isSensitive && !isUrlField) {+          // For sensitive object fields (like 'authentication'), redact completely+          sanitized[key] = '[REDACTED]';+        } else {+          sanitized[key] = this.sanitizeObject(value);+        }       }       // Sanitize string values       else if (typeof value === 'string') {-        sanitized[key] = this.sanitizeString(value, key);+        // For sensitive fields (except URL fields), use generic redaction+        if (isSensitive && !isUrlField) {+          sanitized[key] = '[REDACTED]';+        } else {+          // For URL fields or non-sensitive fields, use pattern-specific sanitization+          sanitized[key] = this.sanitizeString(value, key);+        }+      }+      // For non-string sensitive fields, redact completely

        // Sanitize user intent       const sanitizedIntent = intentSanitizer.sanitize(data.userIntent);@@ -200,98 +200,6 @@ export class MutationTracker {     return metrics;   } -  /**-   * Sanitize a full workflow while preserving structure-   * Removes credentials and sensitive data but keeps all nodes, connections, parameters-   */-  private sanitizeFullWorkflow(workflow: any): any {-    if (!workflow) return workflow;--    // Deep clone to avoid modifying original-    const sanitized = JSON.parse(JSON.stringify(workflow));--    // Remove sensitive workflow-level fields-    delete sanitized.credentials;-    delete sanitized.sharedWorkflows;-    delete sanitized.ownedBy;-    delete sanitized.createdBy;-    delete sanitized.updatedBy;--    // Sanitize each node-    if (sanitized.nodes && Array.isArray(sanitized.nodes)) {-      sanitized.nodes = sanitized.nodes.map((node: any) => {-        const sanitizedNode = { ...node };--        // Remove credentials field-        delete sanitizedNode.credentials;--        // Sanitize parameters if present-        if (sanitizedNode.parameters && typeof sanitizedNode.parameters === 'object') {-          sanitizedNode.parameters = this.sanitizeParameters(sanitizedNode.parameters);-        }--        return sanitizedNode;-      });-    }--    return sanitized;-  }--  /**-   * Recursively sanitize parameters object-   */-  private sanitizeParameters(params: any): any {-    if (!params || typeof params !== 'object') return params;--    const sensitiveKeys = [-      'apiKey', 'api_key', 'token', 'secret', 'password', 'credential',-      'auth', 'authorization', 'privateKey', 'accessToken', 'refreshToken'-    ];--    const sanitized: any = Array.isArray(params) ? [] : {};--    for (const [key, value] of Object.entries(params)) {-      const lowerKey = key.toLowerCase();--      // Check if key is sensitive-      if (sensitiveKeys.some(sk => lowerKey.includes(sk.toLowerCase()))) {-        sanitized[key] = '[REDACTED]';-      } else if (typeof value === 'object' && value !== null) {-        // Recursively sanitize nested objects-        sanitized[key] = this.sanitizeParameters(value);-      } else if (typeof value === 'string') {-        // Sanitize string values that might contain sensitive data-        sanitized[key] = this.sanitizeStringValue(value);-      } else {-        sanitized[key] = value;-      }-    }--    return sanitized;-  }--  /**-   * Sanitize string values that might contain sensitive data-   */-  private sanitizeStringValue(value: string): string {-    if (!value || typeof value !== 'string') return value;

+let cachedValidator: WorkflowValidator | null = null;++/**+ * Get or create cached workflow validator instance+ * Reuses the same validator to avoid redundant NodeSimilarityService initialization+ */+function getValidator(repository: NodeRepository): WorkflowValidator {+  if (!cachedValidator) {+    cachedValidator = new WorkflowValidator(repository, EnhancedConfigValidator);+  }+  return cachedValidator;+}  // Zod schema for the diff request const workflowDiffSchema = z.object({@@ -62,6 +78,8 @@ export async function handleUpdatePartialWorkflow(   const startTime = Date.now();   const sessionId = `mutation_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;   let workflowBefore: any = null;+  let validationBefore: any = null;+  let validationAfter: any = null;    try {     // Debug logging (only in debug mode)@@ -92,6 +110,24 @@ export async function handleUpdatePartialWorkflow(       workflow = await client.getWorkflow(input.id);       // Store original workflow for telemetry       workflowBefore = JSON.parse(JSON.stringify(workflow));++      // Validate workflow BEFORE mutation (for telemetry)+      try {+        const validator = getValidator(repository);+        validationBefore = await validator.validateWorkflow(workflowBefore, {+          validateNodes: true,+          validateConnections: true,+          validateExpressions: true,+          profile: 'runtime'+        });+      } catch (validationError) {+        logger.debug('Pre-mutation validation failed (non-blocking):', validationError);+        // Don't block mutation on validation errors+        validationBefore = {+          valid: false,+          errors: [{ type: 'validation_error', message: 'Validation failed' }]+        };+      }     } catch (error) {       if (error instanceof N8nApiError) {         return {@@ -257,6 +293,24 @@ export async function handleUpdatePartialWorkflow(       let finalWorkflow = updatedWorkflow;       let activationMessage = ''; +      // Validate workflow AFTER mutation (for telemetry)+      try {+        const validator = getValidator(repository);+        validationAfter = await validator.validateWorkflow(finalWorkflow, {+          validateNodes: true,+          validateConnections: true,+          validateExpressions: true,+          profile: 'runtime'+        });+      } catch (validationError) {+        logger.debug('Post-mutation validation failed (non-blocking):', validationError);+        // Don't block on validation errors+        validationAfter = {+          valid: false,+          errors: [{ type: 'validation_error', message: 'Validation failed' }]+        };+      }+       if (diffResult.shouldActivate) {         try {           finalWorkflow = await client.activateWorkflow(input.id);@@ -298,6 +352,8 @@ export async function handleUpdatePartialWorkflow(           operations: input.operations,           workflowBefore,           workflowAfter: finalWorkflow,+          validationBefore,+          validationAfter,           mutationSuccess: true,           durationMs: Date.now() - startTime,

   }@@ -242,34 +242,26 @@ export class WorkflowSanitizer {     const sanitized: any = {};      for (const [key, value] of Object.entries(obj)) {-      // Check if field name is sensitive+      const lowerKey = key.toLowerCase();       const isSensitive = this.isSensitiveField(key);-      const isUrlField = key.toLowerCase().includes('url') ||-                         key.toLowerCase().includes('endpoint') ||-                         key.toLowerCase().includes('webhook');--      // Recursively sanitize nested objects (unless it's a sensitive non-URL field)-      if (typeof value === 'object' && value !== null) {-        if (isSensitive && !isUrlField) {-          // For sensitive object fields (like 'authentication'), redact completely-          sanitized[key] = '[REDACTED]';-        } else {-          sanitized[key] = this.sanitizeObject(value);-        }+      const isUrlField = lowerKey.includes('url') ||+                         lowerKey.includes('endpoint') ||+                         lowerKey.includes('webhook');++      // SECURITY (GHSA-f3rg-xqjj-cj9w): URL-like fields (url, endpoint, webhook)+      // are fully redacted rather than partially sanitized, because preserving+      // the path or query string leaks customer IDs, tenant identifiers, signed+      // request parameters, and tokens shorter than the generic-token threshold.+      if (isSensitive) {+        sanitized[key] = isUrlField ? '[REDACTED_URL]' : '[REDACTED]';       }-      // Sanitize string values-      else if (typeof value === 'string') {-        // For sensitive fields (except URL fields), use generic redaction-        if (isSensitive && !isUrlField) {-          sanitized[key] = '[REDACTED]';-        } else {-          // For URL fields or non-sensitive fields, use pattern-specific sanitization-          sanitized[key] = this.sanitizeString(value, key);-        }+      // Recursively sanitize non-sensitive nested objects+      else if (typeof value === 'object' && value !== null) {+        sanitized[key] = this.sanitizeObject(value);       }-      // For non-string sensitive fields, redact completely-      else if (isSensitive) {-        sanitized[key] = '[REDACTED]';+      // Pattern-sanitize non-sensitive strings+      else if (typeof value === 'string') {+        sanitized[key] = this.sanitizeString(value);       }       // Keep other types as-is       else {@@ -283,7 +275,7 @@ export class WorkflowSanitizer {   /**    * Sanitize string values    */-  private static sanitizeString(value: string, fieldName: string): string {+  private static sanitizeString(value: string): string {     // First check if this is a webhook URL     if (value.includes('/webhook/') || value.includes('/hook/')) {       return 'https://[webhook-url]';@@ -324,27 +316,6 @@ export class WorkflowSanitizer {       sanitized = sanitized.replace(patternDef.pattern, patternDef.placeholder);     } -    // Additional sanitization for specific field types-    if (fieldName.toLowerCase().includes('url') ||-        fieldName.toLowerCase().includes('endpoint')) {-      // Keep URL structure but remove domain details-      if (sanitized.startsWith('http://') || sanitized.startsWith('https://')) {-        // If value has been redacted with URL_WITH_AUTH, preserve it-        if (sanitized.includes('[REDACTED_URL_WITH_AUTH]')) {-          return sanitized; // Already properly sanitized with path preserved-        }-        // If value has other redactions, leave it as is-        if (sanitized.includes('[REDACTED]')) {-          return sanitized;-        }-        const urlParts = sanitized.split('/');-        if (urlParts.length > 2) {-          urlParts[2] = '[domain]';

+// would silently widen this allow-list every time the general schema gains a+// field, defeating the purpose of `.strict()`. Differences vs. that schema:+// omits `credentials` (deleted by `WorkflowSanitizer.sanitizeNode`), adds+// `onError` and `webhookId` (legitimate post-sanitization node fields not+// yet covered by `workflowNodeSchema`), and applies `.strict()` so an unknown+// node-level key surfaces as a validation failure rather than silently+// propagating to Supabase.+const sanitizedNodeSchema = z.object({+  id: z.string(),+  name: z.string(),+  type: z.string(),+  typeVersion: z.number(),+  position: z.tuple([z.number(), z.number()]),+  parameters: z.record(z.string(), z.unknown()),+  disabled: z.boolean().optional(),+  notes: z.string().optional(),+  notesInFlow: z.boolean().optional(),+  continueOnFail: z.boolean().optional(),+  retryOnFail: z.boolean().optional(),+  maxTries: z.number().optional(),+  waitBetweenTries: z.number().optional(),+  alwaysOutputData: z.boolean().optional(),+  executeOnce: z.boolean().optional(),+  onError: z.enum(['continueRegularOutput', 'continueErrorOutput', 'stopWorkflow']).optional(),+  webhookId: z.string().optional(),+}).strict();+ // Schema for workflow telemetry export const workflowTelemetrySchema = z.object({   user_id: z.string().min(1).max(64),@@ -62,7 +93,7 @@ export const workflowTelemetrySchema = z.object({   has_webhook: z.boolean(),   complexity: z.enum(['simple', 'medium', 'complex']),   sanitized_workflow: z.object({-    nodes: z.array(z.any()).max(1000),+    nodes: z.array(sanitizedNodeSchema).max(1000),     connections: z.record(z.any())   }),   created_at: z.string().datetime().optional()

     }@@ -76,36 +76,27 @@ class WorkflowSanitizer {         }         const sanitized = {};         for (const [key, value] of Object.entries(obj)) {+            const lowerKey = key.toLowerCase();             const isSensitive = this.isSensitiveField(key);-            const isUrlField = key.toLowerCase().includes('url') ||-                key.toLowerCase().includes('endpoint') ||-                key.toLowerCase().includes('webhook');-            if (typeof value === 'object' && value !== null) {-                if (isSensitive && !isUrlField) {-                    sanitized[key] = '[REDACTED]';-                }-                else {-                    sanitized[key] = this.sanitizeObject(value);-                }+            const isUrlField = lowerKey.includes('url') ||+                lowerKey.includes('endpoint') ||+                lowerKey.includes('webhook');+            if (isSensitive) {+                sanitized[key] = isUrlField ? '[REDACTED_URL]' : '[REDACTED]';             }-            else if (typeof value === 'string') {-                if (isSensitive && !isUrlField) {-                    sanitized[key] = '[REDACTED]';-                }-                else {-                    sanitized[key] = this.sanitizeString(value, key);-                }+            else if (typeof value === 'object' && value !== null) {+                sanitized[key] = this.sanitizeObject(value);             }-            else if (isSensitive) {-                sanitized[key] = '[REDACTED]';+            else if (typeof value === 'string') {+                sanitized[key] = this.sanitizeString(value);             }             else {                 sanitized[key] = value;             }         }         return sanitized;     }-    static sanitizeString(value, fieldName) {+    static sanitizeString(value) {         if (value.includes('/webhook/') || value.includes('/hook/')) {             return 'https://[webhook-url]';         }@@ -135,22 +126,6 @@ class WorkflowSanitizer {             }             sanitized = sanitized.replace(patternDef.pattern, patternDef.placeholder);         }-        if (fieldName.toLowerCase().includes('url') ||-            fieldName.toLowerCase().includes('endpoint')) {-            if (sanitized.startsWith('http://') || sanitized.startsWith('https://')) {-                if (sanitized.includes('[REDACTED_URL_WITH_AUTH]')) {-                    return sanitized;-                }-                if (sanitized.includes('[REDACTED]')) {-                    return sanitized;-                }-                const urlParts = sanitized.split('/');-                if (urlParts.length > 2) {-                    urlParts[2] = '[domain]';-                    sanitized = urlParts.join('/');-                }-            }-        }         return sanitized;     }     static isSensitiveField(fieldName) {