snow-flow 3.0.9 → 3.0.13

package/dist/utils/anti-mock-data-validator.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * Anti-Mock Data Validator
+ *
+ * This utility ensures NO mock, demo, sample, or fake data is ever used in any MCP tools.
+ * All data must come from real ServiceNow instances.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataReport = exports.checkDataIntegrity = exports.validateRealData = exports.antiMockValidator = exports.AntiMockDataValidator = void 0;
+const logger_js_1 = require("./logger.js");
+class AntiMockDataValidator {
+    constructor() {
+        // Patterns that indicate mock/demo/test data
+        this.MOCK_DATA_PATTERNS = [
+            // Explicit mock indicators
+            /\bmock\b/i,
+            /\bdemo\b/i,
+            /\bsample\b/i,
+            /\btest\b/i,
+            /\bfake\b/i,
+            /\bplaceholder\b/i,
+            /\bdummy\b/i,
+            /\bexample\b/i,
+            // Common test values
+            /^test$/i,
+            /^demo$/i,
+            /test.*user/i,
+            /demo.*user/i,
+            /sample.*data/i,
+            /example.*com/i,
+            /test@test\.com/i,
+            /demo@demo\.com/i,
+            // Sequential test patterns
+            /test\d+/i,
+            /demo\d+/i,
+            /user\d+$/i,
+            /item\d+$/i,
+            // Placeholder values
+            /^n\/a$/i,
+            /^tbd$/i,
+            /^to.*be.*determined/i,
+            /^pending$/i,
+            /^xxx+$/i,
+            /^temp/i,
+            // Mock ServiceNow patterns
+            /^INC\d{7}000\d+$/, // Sequential incident numbers indicating test data
+            /^CHG\d{7}000\d+$/, // Sequential change numbers indicating test data
+            /^PRB\d{7}000\d+$/, // Sequential problem numbers indicating test data
+        ];
+        // Suspicious numeric patterns that might indicate generated/mock data
+        this.SUSPICIOUS_NUMERIC_PATTERNS = [
+            /^123+$/, // 123, 1234, 12345...
+            /^999+$/, // 999, 9999, 99999...
+            /^111+$/, // 111, 1111, 11111...
+            /^000+$/, // 000, 0000, 00000...
+            /^(12){2,}$/, // 121212...
+            /^(99){2,}$/, // 999999...
+        ];
+        this.logger = new logger_js_1.Logger('AntiMockDataValidator');
+    }
+    /**
+     * Validate that dataset contains only real ServiceNow data
+     */
+    validateDataset(data, source = 'unknown') {
+        if (!data || data.length === 0) {
+            return {
+                isValid: false,
+                violations: ['Empty dataset - no real data to validate'],
+                suspiciousFields: [],
+                suspiciousValues: []
+            };
+        }
+        const violations = [];
+        const suspiciousFields = [];
+        const suspiciousValues = [];
+        // Check each record
+        data.forEach((record, index) => {
+            if (!record || typeof record !== 'object') {
+                violations.push(`Record ${index}: Invalid record structure`);
+                return;
+            }
+            // Check each field in the record
+            Object.entries(record).forEach(([field, value]) => {
+                const fieldViolations = this.validateFieldValue(field, value, source);
+                if (fieldViolations.length > 0) {
+                    violations.push(`Record ${index}, Field '${field}': ${fieldViolations.join(', ')}`);
+                    if (!suspiciousFields.includes(field)) {
+                        suspiciousFields.push(field);
+                    }
+                    if (!suspiciousValues.includes(value)) {
+                        suspiciousValues.push(value);
+                    }
+                }
+            });
+        });
+        // Additional dataset-level checks
+        const datasetViolations = this.validateDatasetPatterns(data, source);
+        violations.push(...datasetViolations);
+        return {
+            isValid: violations.length === 0,
+            violations,
+            suspiciousFields,
+            suspiciousValues
+        };
+    }
+    /**
+     * Validate individual field value
+     */
+    validateFieldValue(field, value, source) {
+        const violations = [];
+        if (value === null || value === undefined) {
+            return violations; // Null values are acceptable
+        }
+        const stringValue = String(value);
+        // Check for mock data patterns
+        for (const pattern of this.MOCK_DATA_PATTERNS) {
+            if (pattern.test(stringValue)) {
+                violations.push(`Matches mock data pattern: ${pattern.source}`);
+            }
+        }
+        // Check numeric patterns for suspicious sequences
+        if (typeof value === 'number' || /^\d+$/.test(stringValue)) {
+            for (const pattern of this.SUSPICIOUS_NUMERIC_PATTERNS) {
+                if (pattern.test(stringValue)) {
+                    violations.push(`Suspicious numeric pattern: ${stringValue}`);
+                }
+            }
+        }
+        // Field-specific validation
+        if (field.toLowerCase().includes('email') && stringValue.includes('@')) {
+            if (/@(test|demo|example|mock|fake)\.(com|org|net)$/i.test(stringValue)) {
+                violations.push('Test/demo email domain detected');
+            }
+        }
+        if (field.toLowerCase().includes('name') || field.toLowerCase().includes('user')) {
+            if (/^(test|demo|sample|mock|fake|admin|user)\d*$/i.test(stringValue)) {
+                violations.push('Generic test/demo name pattern');
+            }
+        }
+        return violations;
+    }
+    /**
+     * Validate patterns across the entire dataset
+     */
+    validateDatasetPatterns(data, source) {
+        const violations = [];
+        // Check for suspiciously uniform data
+        if (data.length > 10) {
+            const firstRecord = data[0];
+            const identicalCount = data.filter(record => JSON.stringify(record) === JSON.stringify(firstRecord)).length;
+            if (identicalCount > data.length * 0.8) {
+                violations.push('Dataset appears to have too many identical records (possible mock data)');
+            }
+        }
+        // Check for sequential IDs indicating generated data
+        const sysIds = data.map(record => record.sys_id).filter(id => id);
+        if (sysIds.length > 5) {
+            const sequentialCount = this.countSequentialIds(sysIds);
+            if (sequentialCount > sysIds.length * 0.7) {
+                violations.push('Too many sequential sys_id values (indicates generated test data)');
+            }
+        }
+        // Check creation dates for suspicious patterns
+        const createdDates = data.map(record => record.sys_created_on).filter(date => date);
+        if (createdDates.length > 5) {
+            const simultaneousCreations = this.countSimultaneousCreations(createdDates);
+            if (simultaneousCreations > createdDates.length * 0.8) {
+                violations.push('Too many records created simultaneously (indicates bulk test data creation)');
+            }
+        }
+        return violations;
+    }
+    /**
+     * Count sequential sys_id patterns
+     */
+    countSequentialIds(sysIds) {
+        let sequentialCount = 0;
+        const sortedIds = sysIds.sort();
+        for (let i = 1; i < sortedIds.length; i++) {
+            const current = sortedIds[i];
+            const previous = sortedIds[i - 1];
+            // Check if IDs follow a sequential pattern
+            if (this.areIdsSequential(previous, current)) {
+                sequentialCount++;
+            }
+        }
+        return sequentialCount;
+    }
+    /**
+     * Check if two sys_ids are sequential
+     */
+    areIdsSequential(id1, id2) {
+        if (id1.length !== id2.length)
+            return false;
+        if (id1.length !== 32)
+            return false; // ServiceNow sys_ids are 32 chars
+        // Convert hex to numbers and check if they're sequential
+        try {
+            const num1 = parseInt(id1.slice(-8), 16);
+            const num2 = parseInt(id2.slice(-8), 16);
+            return Math.abs(num2 - num1) === 1;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Count records created at exactly the same time
+     */
+    countSimultaneousCreations(dates) {
+        const dateMap = new Map();
+        dates.forEach(date => {
+            const normalizedDate = new Date(date).toISOString();
+            dateMap.set(normalizedDate, (dateMap.get(normalizedDate) || 0) + 1);
+        });
+        let simultaneousCount = 0;
+        dateMap.forEach(count => {
+            if (count > 1) {
+                simultaneousCount += count;
+            }
+        });
+        return simultaneousCount;
+    }
+    /**
+     * Perform comprehensive data integrity check
+     */
+    performDataIntegrityCheck(data, source = 'unknown') {
+        const validation = this.validateDataset(data, source);
+        let qualityScore = 100;
+        // Deduct points for violations
+        qualityScore -= validation.violations.length * 10;
+        qualityScore -= validation.suspiciousFields.length * 5;
+        qualityScore -= validation.suspiciousValues.length * 2;
+        // Ensure score doesn't go below 0
+        qualityScore = Math.max(0, qualityScore);
+        return {
+            hasRealData: validation.isValid && qualityScore > 70,
+            dataQualityScore: qualityScore,
+            mockDataDetected: !validation.isValid,
+            details: [
+                `Validation result: ${validation.isValid ? 'PASSED' : 'FAILED'}`,
+                `Total violations: ${validation.violations.length}`,
+                `Suspicious fields: ${validation.suspiciousFields.length}`,
+                `Data quality score: ${qualityScore}/100`,
+                `Source: ${source}`,
+                ...validation.violations.slice(0, 5) // Show first 5 violations
+            ]
+        };
+    }
+    /**
+     * Enforce zero tolerance policy for mock data
+     */
+    enforceZeroTolerancePolicy(data, source = 'unknown') {
+        const validation = this.validateDataset(data, source);
+        if (!validation.isValid) {
+            const errorMessage = [
+                '🚨 MOCK DATA DETECTED - ZERO TOLERANCE POLICY VIOLATED!',
+                `Source: ${source}`,
+                `Violations found: ${validation.violations.length}`,
+                '',
+                'Violations:',
+                ...validation.violations.slice(0, 10),
+                '',
+                '❌ This operation has been BLOCKED.',
+                '✅ Only REAL ServiceNow data is allowed.',
+                '',
+                'Please verify your data source and try again with actual ServiceNow records.'
+            ].join('\n');
+            this.logger.error(errorMessage);
+            throw new Error(`Mock data detected in ${source}. Only real ServiceNow data allowed.`);
+        }
+        this.logger.info(`✅ Data validation passed for ${source} - ${data.length} real records confirmed`);
+    }
+    /**
+     * Generate validation report
+     */
+    generateValidationReport(data, source = 'unknown') {
+        const integrityCheck = this.performDataIntegrityCheck(data, source);
+        return [
+            '🔥 ANTI-MOCK DATA VALIDATION REPORT',
+            '='.repeat(50),
+            `📊 Source: ${source}`,
+            `📈 Records Analyzed: ${data.length}`,
+            `🎯 Data Quality Score: ${integrityCheck.dataQualityScore}/100`,
+            `✅ Real Data Status: ${integrityCheck.hasRealData ? 'CONFIRMED' : 'SUSPICIOUS'}`,
+            `🚨 Mock Data Detected: ${integrityCheck.mockDataDetected ? 'YES - BLOCKED' : 'NO - SAFE'}`,
+            '',
+            '📝 Details:',
+            ...integrityCheck.details.map(detail => `  - ${detail}`),
+            '',
+            integrityCheck.hasRealData
+                ? '🎉 VALIDATION PASSED - Real ServiceNow data confirmed!'
+                : '❌ VALIDATION FAILED - Suspicious data patterns detected!',
+            '',
+            '🔐 Zero Mock Data Policy: ENFORCED',
+            '📋 Only 100% real ServiceNow data allowed'
+        ].join('\n');
+    }
+}
+exports.AntiMockDataValidator = AntiMockDataValidator;
+// Export singleton instance
+exports.antiMockValidator = new AntiMockDataValidator();
+// Export validation utilities for use in MCP servers
+const validateRealData = (data, source = 'MCP Operation') => {
+    return exports.antiMockValidator.enforceZeroTolerancePolicy(data, source);
+};
+exports.validateRealData = validateRealData;
+const checkDataIntegrity = (data, source = 'MCP Operation') => {
+    return exports.antiMockValidator.performDataIntegrityCheck(data, source);
+};
+exports.checkDataIntegrity = checkDataIntegrity;
+const generateDataReport = (data, source = 'MCP Operation') => {
+    return exports.antiMockValidator.generateValidationReport(data, source);
+};
+exports.generateDataReport = generateDataReport;
+//# sourceMappingURL=anti-mock-data-validator.js.map

package/dist/utils/servicenow-eventual-consistency.d.ts

@@ -0,0 +1,120 @@
+/**
+ * ServiceNow Eventual Consistency Handler
+ *
+ * ServiceNow uses a distributed database architecture with eventual consistency:
+ * - Write operations go to primary database (immediate)
+ * - Read operations may use read replicas (1-3 second lag)
+ * - This causes race conditions in deployment verification
+ */
+import { ServiceNowClient } from './servicenow-client.js';
+export interface RetryConfig {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+}
+export interface VerificationResult {
+    success: boolean;
+    attempts: number;
+    finalAttemptError?: any;
+    isLikelyTimingIssue: boolean;
+}
+export declare class ServiceNowEventualConsistency {
+    private logger;
+    constructor(loggerName?: string);
+    /**
+     * Retry a ServiceNow operation with exponential backoff
+     * Designed specifically for post-deployment verification
+     */
+    retryWithBackoff<T>(operation: () => Promise<T>, config?: RetryConfig): Promise<{
+        result: T | null;
+        success: boolean;
+        attempts: number;
+    }>;
+    /**
+     * Verify a ServiceNow record exists with retry logic
+     */
+    verifyRecordExists(client: ServiceNowClient, table: string, sys_id: string, config?: RetryConfig): Promise<VerificationResult>;
+    /**
+     * Verify multiple records exist (batch verification)
+     */
+    verifyMultipleRecords(client: ServiceNowClient, verifications: Array<{
+        table: string;
+        sys_id: string;
+        name?: string;
+    }>, config?: RetryConfig): Promise<Array<VerificationResult & {
+        table: string;
+        sys_id: string;
+        name?: string;
+    }>>;
+    /**
+     * Execute operation with eventual consistency retry
+     * Generic wrapper for any ServiceNow operation that might fail due to timing
+     */
+    executeWithRetry<T>(operationName: string, operation: () => Promise<T>, validator: (result: T) => boolean, config?: RetryConfig): Promise<{
+        result: T | null;
+        success: boolean;
+        metadata: any;
+    }>;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+    /**
+     * Determine if an error indicates a permanent failure vs timing issue
+     */
+    private isPermanentError;
+    /**
+     * Get user-friendly error description
+     */
+    private getErrorDescription;
+    /**
+     * Assess if failure is likely due to timing issues
+     */
+    private assessIfTimingIssue;
+    /**
+     * Create a pre-configured instance for widget deployments
+     */
+    static createForWidgets(): ServiceNowEventualConsistency;
+    /**
+     * Create a pre-configured instance for flow deployments
+     */
+    static createForFlows(): ServiceNowEventualConsistency;
+    /**
+     * Create a pre-configured instance for application deployments
+     */
+    static createForApplications(): ServiceNowEventualConsistency;
+}
+/**
+ * Default configuration for different deployment types
+ */
+export declare const CONSISTENCY_CONFIGS: {
+    WIDGET: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+    FLOW: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+    APPLICATION: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+    BATCH: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+};
+export declare const widgetConsistency: ServiceNowEventualConsistency;
+export declare const flowConsistency: ServiceNowEventualConsistency;
+export declare const appConsistency: ServiceNowEventualConsistency;
+//# sourceMappingURL=servicenow-eventual-consistency.d.ts.map

package/dist/utils/servicenow-eventual-consistency.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * ServiceNow Eventual Consistency Handler
+ *
+ * ServiceNow uses a distributed database architecture with eventual consistency:
+ * - Write operations go to primary database (immediate)
+ * - Read operations may use read replicas (1-3 second lag)
+ * - This causes race conditions in deployment verification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appConsistency = exports.flowConsistency = exports.widgetConsistency = exports.CONSISTENCY_CONFIGS = exports.ServiceNowEventualConsistency = void 0;
+const logger_js_1 = require("./logger.js");
+class ServiceNowEventualConsistency {
+    constructor(loggerName = 'EventualConsistency') {
+        this.logger = new logger_js_1.Logger(loggerName);
+    }
+    /**
+     * Retry a ServiceNow operation with exponential backoff
+     * Designed specifically for post-deployment verification
+     */
+    async retryWithBackoff(operation, config = {}) {
+        const { maxRetries = 5, baseDelay = 1000, maxDelay = 8000, backoffMultiplier = 1.5 } = config;
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+                    this.logger.info(`⏳ Retry attempt ${attempt + 1}/${maxRetries} (waiting ${delay}ms for consistency)`);
+                    await this.sleep(delay);
+                }
+                const result = await operation();
+                if (result) {
+                    this.logger.info(`✅ Operation succeeded on attempt ${attempt + 1}`);
+                    return { result, success: true, attempts: attempt + 1 };
+                }
+            }
+            catch (error) {
+                lastError = error;
+                if (this.isPermanentError(error)) {
+                    this.logger.error(`❌ Permanent error detected:`, error);
+                    return { result: null, success: false, attempts: attempt + 1 };
+                }
+                if (attempt === 0) {
+                    this.logger.info(`⏳ ${this.getErrorDescription(error)} - typical ServiceNow consistency issue`);
+                }
+                else {
+                    this.logger.info(`⏳ Still getting ${error.status || 'error'}, retrying...`);
+                }
+            }
+        }
+        this.logger.warn(`⚠️ Operation failed after ${maxRetries} attempts`);
+        this.logger.warn(`⚠️ Last error: ${lastError?.message || 'Unknown'}`);
+        return { result: null, success: false, attempts: maxRetries };
+    }
+    /**
+     * Verify a ServiceNow record exists with retry logic
+     */
+    async verifyRecordExists(client, table, sys_id, config = {}) {
+        this.logger.info(`🔍 Verifying ${table} record ${sys_id} (handling eventual consistency)`);
+        const operation = async () => {
+            const response = await client.getRecord(table, sys_id);
+            return response && response.sys_id === sys_id ? response : null;
+        };
+        const { result, success, attempts } = await this.retryWithBackoff(operation, config);
+        if (!success) {
+            const isLikelyTimingIssue = this.assessIfTimingIssue(attempts, config.maxRetries);
+            if (isLikelyTimingIssue) {
+                this.logger.warn(`⚠️ This appears to be a ServiceNow consistency issue, not a deployment failure`);
+                this.logger.warn(`⚠️ Check directly: /${table}.do?sys_id=${sys_id}`);
+            }
+            return {
+                success: false,
+                attempts,
+                isLikelyTimingIssue
+            };
+        }
+        return {
+            success: true,
+            attempts,
+            isLikelyTimingIssue: false
+        };
+    }
+    /**
+     * Verify multiple records exist (batch verification)
+     */
+    async verifyMultipleRecords(client, verifications, config = {}) {
+        const results = [];
+        for (const verification of verifications) {
+            const result = await this.verifyRecordExists(client, verification.table, verification.sys_id, config);
+            results.push({
+                ...result,
+                table: verification.table,
+                sys_id: verification.sys_id,
+                name: verification.name
+            });
+            // Small delay between verifications to avoid rate limiting
+            if (verifications.length > 1) {
+                await this.sleep(200);
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute operation with eventual consistency retry
+     * Generic wrapper for any ServiceNow operation that might fail due to timing
+     */
+    async executeWithRetry(operationName, operation, validator, config = {}) {
+        this.logger.info(`🚀 Executing ${operationName} with consistency handling`);
+        const { result, success, attempts } = await this.retryWithBackoff(async () => {
+            const opResult = await operation();
+            return validator(opResult) ? opResult : null;
+        }, config);
+        return {
+            result,
+            success,
+            metadata: {
+                operationName,
+                attempts,
+                isLikelyTimingIssue: !success && this.assessIfTimingIssue(attempts, config.maxRetries)
+            }
+        };
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Determine if an error indicates a permanent failure vs timing issue
+     */
+    isPermanentError(error) {
+        // Permanent errors that shouldn't be retried
+        if (error.status === 401)
+            return true; // Authentication
+        if (error.status === 400 && !error.message?.includes('null'))
+            return true; // Bad request
+        if (error.message?.includes('table does not exist'))
+            return true; // Invalid table
+        if (error.message?.includes('permission denied') && error.status !== 403)
+            return true; // Real permission issues
+        return false;
+    }
+    /**
+     * Get user-friendly error description
+     */
+    getErrorDescription(error) {
+        if (error.status === 403)
+            return 'Access temporarily denied (403)';
+        if (error.status === 404)
+            return 'Record not found (404)';
+        if (error.message?.includes('null'))
+            return 'Null response received';
+        return `Error ${error.status || 'unknown'}`;
+    }
+    /**
+     * Assess if failure is likely due to timing issues
+     */
+    assessIfTimingIssue(attempts, maxRetries = 5) {
+        // If we exhausted all retries and got timing-related errors, it's likely a timing issue
+        return attempts >= maxRetries;
+    }
+    /**
+     * Create a pre-configured instance for widget deployments
+     */
+    static createForWidgets() {
+        return new ServiceNowEventualConsistency('WidgetConsistency');
+    }
+    /**
+     * Create a pre-configured instance for flow deployments
+     */
+    static createForFlows() {
+        return new ServiceNowEventualConsistency('FlowConsistency');
+    }
+    /**
+     * Create a pre-configured instance for application deployments
+     */
+    static createForApplications() {
+        return new ServiceNowEventualConsistency('AppConsistency');
+    }
+}
+exports.ServiceNowEventualConsistency = ServiceNowEventualConsistency;
+/**
+ * Default configuration for different deployment types
+ */
+exports.CONSISTENCY_CONFIGS = {
+    // Fast retry for simple records
+    WIDGET: {
+        maxRetries: 5,
+        baseDelay: 800,
+        maxDelay: 6000,
+        backoffMultiplier: 1.4
+    },
+    // Medium retry for complex records
+    FLOW: {
+        maxRetries: 6,
+        baseDelay: 1200,
+        maxDelay: 8000,
+        backoffMultiplier: 1.5
+    },
+    // Longer retry for applications with dependencies
+    APPLICATION: {
+        maxRetries: 8,
+        baseDelay: 1500,
+        maxDelay: 12000,
+        backoffMultiplier: 1.6
+    },
+    // Quick check for batch operations
+    BATCH: {
+        maxRetries: 3,
+        baseDelay: 500,
+        maxDelay: 3000,
+        backoffMultiplier: 1.3
+    }
+};
+// Export singleton instances
+exports.widgetConsistency = ServiceNowEventualConsistency.createForWidgets();
+exports.flowConsistency = ServiceNowEventualConsistency.createForFlows();
+exports.appConsistency = ServiceNowEventualConsistency.createForApplications();
+//# sourceMappingURL=servicenow-eventual-consistency.js.map

package/memory/agents/README.md

@@ -28,4 +28,4 @@ memory/agents/
 5. **Cleanup**: Remove directories for terminated agents periodically
 
 ## Last Updated
-2025-08-07T11:22:36.537Z
+2025-08-07T21:13:17.654Z

package/memory/claude-flow-data.json

@@ -1,5 +1,5 @@
 {
   "agents": [],
   "tasks": [],
-  "lastUpdated": 1754565756537
+  "lastUpdated": 1754601197654
 }

package/memory/sessions/README.md

@@ -29,4 +29,4 @@ memory/sessions/
 5. **State Preservation**: Snapshot coordination state regularly
 
 ## Last Updated
-2025-08-07T11:22:36.537Z
+2025-08-07T21:13:17.654Z