snow-flow 2.0.2 → 2.0.4

package/src/mcp/servicenow-security-compliance-mcp-refactored.ts

@@ -1,642 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-security-compliance MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-
-export class ServiceNowSecurityComplianceMCP extends BaseMCPServer {
-  constructor() {
-    super({
-      name: 'servicenow-security-compliance',
-      version: '2.0.0',
-      description: 'Handles security policies, compliance rules, and audit operations'
-    });
-  }
-
-  protected setupTools(): void {
-    // Tools are defined in getTools() method
-  }
-
-  protected getTools(): Tool[] {
-    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' }
-          }
-        }
-      }
-    ];
-  }
-
-  protected async executeTool(name: string, args: any): Promise<ToolResult> {
-    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
-  private async handleSnowCreateSecurityPolicy(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowCreateComplianceRule(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowCreateAuditRule(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowCreateAccessControl(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowCreateDataPolicy(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowCreateVulnerabilityScan(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowDiscoverSecurityFrameworks(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const frameworks: any[] = [];
-      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
-      };
-    }
-  }
-
-  private async handleSnowDiscoverSecurityPolicies(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const policies: any[] = [];
-
-      // 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: any) => ({
-          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: any) => ({
-          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
-      };
-    }
-  }
-
-  private async handleSnowRunComplianceScan(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-
-  private async handleSnowAuditTrailAnalysis(args: any): Promise<ToolResult> {
-    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: Date; // 🔴 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: any) => r.tablename)).size,
-        users_involved: new Set(auditResponse.data?.result?.map((r: any) => 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
-      };
-    }
-  }
-
-  private async handleSnowSecurityRiskAssessment(args: any): Promise<ToolResult> {
-    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
-      };
-    }
-  }
-}
-
-// Create and run the server
-if (require.main === module) {
-  const server = new ServiceNowSecurityComplianceMCP();
-  server.start().catch(console.error);
-}