snow-flow 2.6.3 → 2.6.5

package/dist/mcp/servicenow-security-compliance-mcp-refactored.js

@@ -1,600 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * servicenow-security-compliance MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowSecurityComplianceMCP = void 0;
-const base_mcp_server_js_1 = require("./base-mcp-server.js");
-class ServiceNowSecurityComplianceMCP extends base_mcp_server_js_1.BaseMCPServer {
-    constructor() {
-        super({
-            name: 'servicenow-security-compliance',
-            version: '2.0.0',
-            description: 'Handles security policies, compliance rules, and audit operations'
-        });
-    }
-    setupTools() {
-        // Tools are defined in getTools() method
-    }
-    getTools() {
-        return [
-            {
-                name: 'snow_create_security_policy',
-                description: 'Create Security Policy with dynamic rule discovery - NO hardcoded values',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Security policy name' },
-                        type: { type: 'string', description: 'Policy type (access, data, network, etc.)' },
-                        description: { type: 'string', description: 'Policy description' },
-                        enforcement: { type: 'string', description: 'Enforcement level (strict, moderate, advisory)' },
-                        scope: { type: 'string', description: 'Policy scope (global, application, table)' },
-                        rules: { type: 'array', description: 'Security rules and conditions' },
-                        active: { type: 'boolean', description: 'Policy active status' }
-                    },
-                    required: ['name', 'type', 'rules']
-                }
-            },
-            {
-                name: 'snow_create_compliance_rule',
-                description: 'Create Compliance Rule with dynamic framework discovery',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Compliance rule name' },
-                        framework: { type: 'string', description: 'Compliance framework (SOX, GDPR, HIPAA, etc.)' },
-                        requirement: { type: 'string', description: 'Specific requirement or control' },
-                        validation: { type: 'string', description: 'Validation script or condition' },
-                        remediation: { type: 'string', description: 'Remediation actions' },
-                        severity: { type: 'string', description: 'Severity level (critical, high, medium, low)' },
-                        active: { type: 'boolean', description: 'Rule active status' }
-                    },
-                    required: ['name', 'framework', 'requirement', 'validation']
-                }
-            },
-            {
-                name: 'snow_create_audit_rule',
-                description: 'Create Audit Rule with dynamic event discovery',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Audit rule name' },
-                        table: { type: 'string', description: 'Table to audit' },
-                        events: { type: 'array', description: 'Events to audit (create, update, delete)' },
-                        fields: { type: 'array', description: 'Fields to audit' },
-                        retention: { type: 'number', description: 'Retention period in days' },
-                        filter: { type: 'string', description: 'Filter conditions' },
-                        active: { type: 'boolean', description: 'Audit rule active status' }
-                    },
-                    required: ['name', 'table', 'events']
-                }
-            },
-            {
-                name: 'snow_create_access_control',
-                description: 'Create Access Control with dynamic role discovery',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Access control name' },
-                        table: { type: 'string', description: 'Protected table' },
-                        operation: { type: 'string', description: 'Operation (read, write, create, delete)' },
-                        roles: { type: 'array', description: 'Allowed roles' },
-                        condition: { type: 'string', description: 'Access condition script' },
-                        advanced: { type: 'boolean', description: 'Advanced access control' },
-                        active: { type: 'boolean', description: 'Access control active status' }
-                    },
-                    required: ['name', 'table', 'operation']
-                }
-            },
-            {
-                name: 'snow_create_data_policy',
-                description: 'Create Data Policy with dynamic field discovery',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Data policy name' },
-                        table: { type: 'string', description: 'Target table' },
-                        fields: { type: 'array', description: 'Fields to protect' },
-                        classification: { type: 'string', description: 'Data classification (public, internal, confidential, restricted)' },
-                        encryption: { type: 'boolean', description: 'Require encryption' },
-                        masking: { type: 'boolean', description: 'Apply data masking' },
-                        retention: { type: 'number', description: 'Data retention period' },
-                        active: { type: 'boolean', description: 'Policy active status' }
-                    },
-                    required: ['name', 'table', 'fields', 'classification']
-                }
-            },
-            {
-                name: 'snow_create_vulnerability_scan',
-                description: 'Create Vulnerability Scan with dynamic discovery',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Scan name' },
-                        scope: { type: 'string', description: 'Scan scope (application, platform, integrations)' },
-                        schedule: { type: 'string', description: 'Scan schedule' },
-                        severity: { type: 'string', description: 'Minimum severity to report' },
-                        notifications: { type: 'array', description: 'Notification recipients' },
-                        remediation: { type: 'boolean', description: 'Auto-remediation enabled' },
-                        active: { type: 'boolean', description: 'Scan active status' }
-                    },
-                    required: ['name', 'scope']
-                }
-            },
-            {
-                name: 'snow_discover_security_frameworks',
-                description: 'Discover available security and compliance frameworks',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        type: { type: 'string', description: 'Framework type (security, compliance, audit)' }
-                    }
-                }
-            },
-            {
-                name: 'snow_discover_security_policies',
-                description: 'Discover existing security policies and rules',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        category: { type: 'string', description: 'Policy category filter' },
-                        active: { type: 'boolean', description: 'Filter by active status' }
-                    }
-                }
-            },
-            {
-                name: 'snow_run_compliance_scan',
-                description: 'Run compliance scan with dynamic rule discovery',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        framework: { type: 'string', description: 'Compliance framework to scan' },
-                        scope: { type: 'string', description: 'Scan scope (instance, application, table)' },
-                        generateReport: { type: 'boolean', description: 'Generate compliance report' }
-                    },
-                    required: ['framework']
-                }
-            },
-            {
-                name: 'snow_audit_trail__analysis',
-                description: 'Analyze audit trails for security incidents',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        timeframe: { type: 'string', description: 'Analysis timeframe (24h, 7d, 30d)' },
-                        table: { type: 'string', description: 'Filter by specific table' },
-                        user: { type: 'string', description: 'Filter by specific user' },
-                        anomalies: { type: 'boolean', description: 'Detect anomalies' },
-                        exportFormat: { type: 'string', description: 'Export format (json, csv, pdf)' }
-                    }
-                }
-            },
-            {
-                name: 'snow_security_risk_assessment',
-                description: 'Perform security risk assessment',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        scope: { type: 'string', description: 'Assessment scope' },
-                        riskLevel: { type: 'string', description: 'Minimum risk level to assess' },
-                        generateMitigation: { type: 'boolean', description: 'Generate mitigation recommendations' }
-                    }
-                }
-            }
-        ];
-    }
-    async executeTool(name, args) {
-        const startTime = Date.now();
-        switch (name) {
-            case 'snow_create_security_policy':
-                return await this.handleSnowCreateSecurityPolicy(args);
-            case 'snow_create_compliance_rule':
-                return await this.handleSnowCreateComplianceRule(args);
-            case 'snow_create_audit_rule':
-                return await this.handleSnowCreateAuditRule(args);
-            case 'snow_create_access_control':
-                return await this.handleSnowCreateAccessControl(args);
-            case 'snow_create_data_policy':
-                return await this.handleSnowCreateDataPolicy(args);
-            case 'snow_create_vulnerability_scan':
-                return await this.handleSnowCreateVulnerabilityScan(args);
-            case 'snow_discover_security_frameworks':
-                return await this.handleSnowDiscoverSecurityFrameworks(args);
-            case 'snow_discover_security_policies':
-                return await this.handleSnowDiscoverSecurityPolicies(args);
-            case 'snow_run_compliance_scan':
-                return await this.handleSnowRunComplianceScan(args);
-            case 'snow_audit_trail__analysis':
-                return await this.handleSnowAuditTrailAnalysis(args);
-            case 'snow_security_risk_assessment':
-                return await this.handleSnowSecurityRiskAssessment(args);
-            default:
-                return {
-                    success: false,
-                    error: `Unknown tool: ${name}`
-                };
-        }
-    }
-    // Tool handlers
-    async handleSnowCreateSecurityPolicy(args) {
-        const startTime = Date.now();
-        try {
-            const policyData = {
-                name: args.name,
-                type: args.type,
-                description: args.description || '',
-                enforcement_level: args.enforcement || 'moderate',
-                scope: args.scope || 'global',
-                rules: JSON.stringify(args.rules),
-                active: args.active !== false
-            };
-            // Security policies might be in different tables based on type
-            const table = 'sys_security_policy'; // This is a simplified assumption
-            const result = await this.client.createRecord(table, policyData);
-            return {
-                success: result.success,
-                result: result.result,
-                error: result.success ? undefined : 'Failed to create security policy',
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create security policy',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowCreateComplianceRule(args) {
-        const startTime = Date.now();
-        try {
-            const ruleData = {
-                name: args.name,
-                framework: args.framework,
-                requirement: args.requirement,
-                validation_script: args.validation,
-                remediation: args.remediation || '',
-                severity: args.severity || 'medium',
-                active: args.active !== false
-            };
-            const result = await this.client.createRecord('sys_compliance_rule', ruleData);
-            return {
-                success: result.success,
-                result: result.result,
-                error: result.success ? undefined : 'Failed to create compliance rule',
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create compliance rule',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowCreateAuditRule(args) {
-        const startTime = Date.now();
-        try {
-            const auditData = {
-                name: args.name,
-                table: args.table,
-                audit_events: args.events.join(','),
-                audit_fields: args.fields ? args.fields.join(',') : '',
-                retention_days: args.retention || 90,
-                filter_condition: args.filter || '',
-                active: args.active !== false
-            };
-            const result = await this.client.createRecord('sys_audit_rule', auditData);
-            return {
-                success: result.success,
-                result: result.result,
-                error: result.success ? undefined : 'Failed to create audit rule',
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create audit rule',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowCreateAccessControl(args) {
-        const startTime = Date.now();
-        try {
-            const aclData = {
-                name: args.name,
-                admin_override: false,
-                advanced: args.advanced || false,
-                active: args.active !== false,
-                condition: args.condition || '',
-                operation: args.operation,
-                script: 'true',
-                description: `Access control for ${args.operation} on ${args.table}`,
-                type: 'record'
-            };
-            // Set table name - ACLs reference tables via sys_id typically
-            // This would need table resolution in a real implementation
-            aclData.name = `${args.table}.${args.operation}`;
-            const result = await this.client.createRecord('sys_security_acl', aclData);
-            // If roles are specified, create role entries
-            if (result.success && args.roles && args.roles.length > 0) {
-                // Would need to create sys_security_acl_role entries
-            }
-            return {
-                success: result.success,
-                result: result.result,
-                error: result.success ? undefined : 'Failed to create access control',
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create access control',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowCreateDataPolicy(args) {
-        const startTime = Date.now();
-        try {
-            const policyData = {
-                name: args.name,
-                table: args.table,
-                fields: args.fields.join(','),
-                classification: args.classification,
-                encryption_required: args.encryption || false,
-                masking_enabled: args.masking || false,
-                retention_period: args.retention || 0,
-                active: args.active !== false
-            };
-            const result = await this.client.createRecord('sys_data_policy', policyData);
-            return {
-                success: result.success,
-                result: result.result,
-                error: result.success ? undefined : 'Failed to create data policy',
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create data policy',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowCreateVulnerabilityScan(args) {
-        const startTime = Date.now();
-        try {
-            const scanData = {
-                name: args.name,
-                scan_scope: args.scope,
-                schedule: args.schedule || 'weekly',
-                min_severity: args.severity || 'medium',
-                notification_list: args.notifications ? args.notifications.join(',') : '',
-                auto_remediation: args.remediation || false,
-                active: args.active !== false
-            };
-            const result = await this.client.createRecord('sys_vulnerability_scan', scanData);
-            return {
-                success: result.success,
-                result: result.result,
-                error: result.success ? undefined : 'Failed to create vulnerability scan',
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create vulnerability scan',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowDiscoverSecurityFrameworks(args) {
-        const startTime = Date.now();
-        try {
-            const frameworks = [];
-            const type = args?.type || 'all';
-            // Discover compliance frameworks
-            if (type === 'all' || type === 'compliance') {
-                frameworks.push({ name: 'SOX', type: 'compliance', description: 'Sarbanes-Oxley Act' }, { name: 'GDPR', type: 'compliance', description: 'General Data Protection Regulation' }, { name: 'HIPAA', type: 'compliance', description: 'Health Insurance Portability and Accountability Act' }, { name: 'PCI-DSS', type: 'compliance', description: 'Payment Card Industry Data Security Standard' }, { name: 'ISO27001', type: 'compliance', description: 'Information Security Management' });
-            }
-            // Discover security frameworks
-            if (type === 'all' || type === 'security') {
-                frameworks.push({ name: 'NIST', type: 'security', description: 'NIST Cybersecurity Framework' }, { name: 'CIS', type: 'security', description: 'Center for Internet Security Controls' }, { name: 'OWASP', type: 'security', description: 'Open Web Application Security Project' });
-            }
-            return {
-                success: true,
-                result: { frameworks },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to discover security frameworks',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowDiscoverSecurityPolicies(args) {
-        const startTime = Date.now();
-        try {
-            const policies = [];
-            // Build query
-            let query = '';
-            if (args.active !== undefined) {
-                query = `active=${args.active}`;
-            }
-            // Discover policies
-            const policyResponse = await this.client.searchRecords('sys_security_policy', query, 50);
-            if (policyResponse.success && policyResponse.data) {
-                policies.push(...policyResponse.data.result.map((policy) => ({
-                    name: policy.name,
-                    type: policy.type,
-                    enforcement: policy.enforcement_level,
-                    scope: policy.scope,
-                    active: policy.active
-                })));
-            }
-            // Also check ACLs
-            const aclResponse = await this.client.searchRecords('sys_security_acl', query, 50);
-            if (aclResponse.success && aclResponse.data) {
-                policies.push(...aclResponse.data.result.map((acl) => ({
-                    name: acl.name,
-                    type: 'access_control',
-                    operation: acl.operation,
-                    table: acl.name.split('.')[0],
-                    active: acl.active
-                })));
-            }
-            return {
-                success: true,
-                result: { policies },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to discover security policies',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowRunComplianceScan(args) {
-        const startTime = Date.now();
-        try {
-            // This would be a complex operation in reality
-            // For now, simulate a compliance scan
-            const scanResult = {
-                framework: args.framework,
-                scope: args.scope || 'instance',
-                scan_date: new Date().toISOString(),
-                total_checks: 150,
-                passed: 142,
-                failed: 8,
-                warnings: 12,
-                compliance_score: 94.7,
-                critical_findings: 2,
-                high_findings: 6,
-                report_generated: args.generateReport || false
-            };
-            return {
-                success: true,
-                result: scanResult,
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to run compliance scan',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async handleSnowAuditTrailAnalysis(args) {
-        const executionStartTime = Date.now(); // 🔴 SNOW-004 FIX: Rename to avoid variable shadowing
-        try {
-            // Build query for audit records
-            let query = '';
-            const timeframe = args.timeframe || '24h';
-            // Convert timeframe to datetime
-            const now = new Date();
-            let queryStartTime; // 🔴 SNOW-004 FIX: Rename to avoid confusion
-            switch (timeframe) {
-                case '24h':
-                    queryStartTime = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-                    break;
-                case '7d':
-                    queryStartTime = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
-                    break;
-                case '30d':
-                    queryStartTime = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
-                    break;
-                default:
-                    queryStartTime = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-            }
-            query = `sys_created_on>=${queryStartTime.toISOString()}`;
-            if (args.table) {
-                query += `^tablename=${args.table}`;
-            }
-            if (args.user) {
-                query += `^user=${args.user}`;
-            }
-            const auditResponse = await this.client.searchRecords('sys_audit', query, 100);
-            const analysisResult = {
-                timeframe: timeframe,
-                total_events: auditResponse.data?.result?.length || 0,
-                tables_affected: new Set(auditResponse.data?.result?.map((r) => r.tablename)).size,
-                users_involved: new Set(auditResponse.data?.result?.map((r) => r.user)).size,
-                anomalies_detected: args.anomalies ? Math.floor(Math.random() * 5) : 0,
-                export_format: args.exportFormat || 'json'
-            };
-            return {
-                success: true,
-                result: analysisResult,
-                executionTime: Date.now() - executionStartTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to analyze audit trail',
-                executionTime: Date.now() - executionStartTime
-            };
-        }
-    }
-    async handleSnowSecurityRiskAssessment(args) {
-        const startTime = Date.now();
-        try {
-            // Simulate risk assessment
-            const assessment = {
-                scope: args.scope || 'instance',
-                assessment_date: new Date().toISOString(),
-                risk_level: args.riskLevel || 'all',
-                total_risks_identified: 25,
-                critical_risks: 3,
-                high_risks: 7,
-                medium_risks: 10,
-                low_risks: 5,
-                overall_risk_score: 'Medium',
-                mitigation_recommendations: args.generateMitigation ? [
-                    'Implement multi-factor authentication',
-                    'Update access control policies',
-                    'Enable encryption for sensitive data',
-                    'Regular security training for users',
-                    'Implement network segmentation'
-                ] : []
-            };
-            return {
-                success: true,
-                result: assessment,
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to perform security risk assessment',
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-}
-exports.ServiceNowSecurityComplianceMCP = ServiceNowSecurityComplianceMCP;
-// Create and run the server
-if (require.main === module) {
-    const server = new ServiceNowSecurityComplianceMCP();
-    server.start().catch(console.error);
-}
-//# sourceMappingURL=servicenow-security-compliance-mcp-refactored.js.map

package/dist/mcp/servicenow-update-set-mcp-refactored.d.ts

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-/**
- * ServiceNow Update Set Management MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- * Ensures all changes are tracked in Update Sets for safe deployment
- */
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare class ServiceNowUpdateSetMCP extends BaseMCPServer {
-    protected setupTools(): void;
-    private currentSession;
-    private sessionsPath;
-    constructor();
-    protected getTools(): Tool[];
-    protected executeTool(name: string, args: any): Promise<ToolResult>;
-    private createUpdateSet;
-    private switchUpdateSet;
-    private getCurrentUpdateSet;
-    private listUpdateSets;
-    private completeUpdateSet;
-    private addArtifactToSession;
-    private ensureActiveUpdateSet;
-    private previewUpdateSet;
-    private exportUpdateSet;
-    private switchToUpdateSet;
-    private ensureSessionsDirectory;
-    private saveSession;
-    private loadSessionById;
-    private loadActiveSession;
-}
-//# sourceMappingURL=servicenow-update-set-mcp-refactored.d.ts.map