snow-flow 4.1.2 → 4.2.0

package/dist/mcp/servicenow-notifications-mcp.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ServiceNow Notifications Framework MCP Server
+ *
+ * Provides comprehensive notification capabilities including:
+ * - Multi-channel notifications (Email, SMS, Push, Slack, Teams)
+ * - Template management and personalization
+ * - Delivery tracking and analytics
+ * - Notification preferences and routing
+ * - Emergency notification broadcasting
+ *
+ * Enhanced notification capabilities previously missing from Snow-Flow
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNowNotificationsMCP = void 0;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const enhanced_base_mcp_server_js_1 = require("./shared/enhanced-base-mcp-server.js");
+class ServiceNowNotificationsMCP extends enhanced_base_mcp_server_js_1.EnhancedBaseMCPServer {
+    constructor() {
+        super('servicenow-notifications', '1.0.0');
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'snow_send_notification',
+                    description: 'Send multi-channel notification with template support and delivery tracking',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            recipients: { type: 'array', items: { type: 'string' }, description: 'User sys_ids or email addresses' },
+                            channel: { type: 'string', description: 'Notification channel', enum: ['email', 'sms', 'push', 'slack', 'teams', 'all'] },
+                            template: { type: 'string', description: 'Notification template name or sys_id' },
+                            subject: { type: 'string', description: 'Notification subject/title' },
+                            message: { type: 'string', description: 'Notification message body' },
+                            priority: { type: 'string', description: 'Notification priority', enum: ['low', 'normal', 'high', 'urgent'] },
+                            personalization: { type: 'object', description: 'Template variables for personalization' },
+                            track_delivery: { type: 'boolean', description: 'Enable delivery tracking' }
+                        },
+                        required: ['recipients', 'channel', 'subject', 'message']
+                    }
+                },
+                {
+                    name: 'snow_create_notification_template',
+                    description: 'Create reusable notification template with multi-channel support',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            template_name: { type: 'string', description: 'Template name' },
+                            template_type: { type: 'string', description: 'Template type', enum: ['incident', 'change', 'approval', 'alert', 'reminder'] },
+                            channels: { type: 'array', items: { type: 'string' }, description: 'Supported channels' },
+                            subject_template: { type: 'string', description: 'Subject template with variables' },
+                            body_template: { type: 'string', description: 'Body template with variables' },
+                            variables: { type: 'array', items: { type: 'string' }, description: 'Available template variables' },
+                            active: { type: 'boolean', description: 'Template is active' }
+                        },
+                        required: ['template_name', 'template_type', 'subject_template', 'body_template']
+                    }
+                },
+                {
+                    name: 'snow_notification_preferences',
+                    description: 'Manage user notification preferences and routing rules',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            user_id: { type: 'string', description: 'User sys_id' },
+                            action: { type: 'string', description: 'Action to perform', enum: ['get', 'set', 'update'] },
+                            preferences: {
+                                type: 'object',
+                                properties: {
+                                    email_enabled: { type: 'boolean' },
+                                    sms_enabled: { type: 'boolean' },
+                                    push_enabled: { type: 'boolean' },
+                                    quiet_hours_start: { type: 'string', description: 'HH:MM format' },
+                                    quiet_hours_end: { type: 'string', description: 'HH:MM format' },
+                                    escalation_channels: { type: 'array', items: { type: 'string' } }
+                                }
+                            }
+                        },
+                        required: ['user_id', 'action']
+                    }
+                },
+                {
+                    name: 'snow_emergency_broadcast',
+                    description: 'Send emergency broadcast notification to all users or specific groups',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            broadcast_type: { type: 'string', description: 'Broadcast type', enum: ['system_outage', 'security_alert', 'maintenance', 'emergency'] },
+                            target_audience: { type: 'string', description: 'Target audience', enum: ['all_users', 'it_staff', 'management', 'specific_group'] },
+                            group_id: { type: 'string', description: 'Group sys_id if target is specific_group' },
+                            message: { type: 'string', description: 'Emergency message' },
+                            channels: { type: 'array', items: { type: 'string' }, description: 'Channels to use for broadcast' },
+                            override_preferences: { type: 'boolean', description: 'Override user quiet hours/preferences' },
+                            require_acknowledgment: { type: 'boolean', description: 'Require user acknowledgment' }
+                        },
+                        required: ['broadcast_type', 'target_audience', 'message']
+                    }
+                },
+                {
+                    name: 'snow_notification_analytics',
+                    description: 'Analyze notification delivery rates, engagement, and effectiveness',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            analytics_type: { type: 'string', description: 'Analytics type', enum: ['delivery_rates', 'engagement', 'channel_effectiveness', 'template_performance'] },
+                            time_period: { type: 'string', description: 'Analysis time period', enum: ['24_hours', '7_days', '30_days', '90_days'] },
+                            channel_filter: { type: 'string', description: 'Filter by channel' },
+                            template_filter: { type: 'string', description: 'Filter by template' }
+                        },
+                        required: ['analytics_type']
+                    }
+                },
+                {
+                    name: 'snow_schedule_notification',
+                    description: 'Schedule future notification delivery with advanced scheduling options',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            recipients: { type: 'array', items: { type: 'string' }, description: 'Recipient user sys_ids' },
+                            template: { type: 'string', description: 'Template sys_id or name' },
+                            schedule_type: { type: 'string', description: 'Schedule type', enum: ['once', 'recurring', 'conditional'] },
+                            schedule_time: { type: 'string', description: 'ISO timestamp for one-time or start of recurring' },
+                            recurrence_pattern: { type: 'string', description: 'Cron expression for recurring notifications' },
+                            conditions: { type: 'object', description: 'Conditions for conditional notifications' },
+                            personalization: { type: 'object', description: 'Template personalization data' }
+                        },
+                        required: ['recipients', 'template', 'schedule_type', 'schedule_time']
+                    }
+                }
+            ]
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                let result;
+                switch (name) {
+                    case 'snow_send_notification':
+                        result = await this.sendNotification(args);
+                        break;
+                    case 'snow_create_notification_template':
+                        result = await this.createNotificationTemplate(args);
+                        break;
+                    case 'snow_notification_preferences':
+                        result = await this.manageNotificationPreferences(args);
+                        break;
+                    case 'snow_emergency_broadcast':
+                        result = await this.sendEmergencyBroadcast(args);
+                        break;
+                    case 'snow_notification_analytics':
+                        result = await this.generateNotificationAnalytics(args);
+                        break;
+                    case 'snow_schedule_notification':
+                        result = await this.scheduleNotification(args);
+                        break;
+                    default:
+                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: result
+                        }
+                    ]
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Notification Error: ${errorMessage}`
+                        }
+                    ]
+                };
+            }
+        });
+    }
+    async sendNotification(args) {
+        const { recipients, channel, template, subject, message, priority = 'normal', personalization = {}, track_delivery = true } = args;
+        // Process recipients
+        const processedRecipients = [];
+        for (const recipient of recipients) {
+            if (recipient.includes('@')) {
+                // Email address
+                processedRecipients.push({ type: 'email', value: recipient });
+            }
+            else {
+                // User sys_id - get user details
+                const user = await this.client.getRecord('sys_user', recipient);
+                if (user) {
+                    processedRecipients.push({
+                        type: 'user',
+                        sys_id: recipient,
+                        name: user.name,
+                        email: user.email,
+                        phone: user.phone
+                    });
+                }
+            }
+        }
+        // Send notifications based on channel
+        const deliveryResults = [];
+        if (channel === 'all' || channel === 'email') {
+            const emailResult = await this.sendEmailNotification(processedRecipients, subject, message, template, personalization);
+            deliveryResults.push(emailResult);
+        }
+        if (channel === 'all' || channel === 'sms') {
+            const smsResult = await this.sendSMSNotification(processedRecipients, message);
+            deliveryResults.push(smsResult);
+        }
+        if (channel === 'all' || channel === 'push') {
+            const pushResult = await this.sendPushNotification(processedRecipients, subject, message);
+            deliveryResults.push(pushResult);
+        }
+        const successCount = deliveryResults.filter(r => r.success).length;
+        const totalSent = deliveryResults.reduce((sum, r) => sum + r.sent, 0);
+        return `📤 **Notification Sent Successfully**
+
+📋 **Details**:
+- **Recipients**: ${recipients.length} (${processedRecipients.length} processed)
+- **Channel(s)**: ${channel}
+- **Subject**: ${subject}
+- **Priority**: ${priority.toUpperCase()}
+
+📊 **Delivery Results**:
+- **Total Sent**: ${totalSent}
+- **Channels Used**: ${successCount}/${deliveryResults.length}
+- **Success Rate**: ${((successCount / deliveryResults.length) * 100).toFixed(1)}%
+
+${track_delivery ? `🔍 **Tracking**: Delivery tracking enabled - check notification logs for detailed status` : ''}
+
+⏰ **Sent**: ${new Date().toISOString()}`;
+    }
+    async sendEmailNotification(recipients, subject, message, template, personalization) {
+        // Create email notification records
+        let sentCount = 0;
+        for (const recipient of recipients) {
+            if (recipient.email || recipient.type === 'email') {
+                try {
+                    await this.client.createRecord('sysevent_email_action', {
+                        event: 'notification.send',
+                        recipient: recipient.email || recipient.value,
+                        subject: subject,
+                        message: this.personalizeMessage(message, personalization, recipient),
+                        template: template || '',
+                        priority: 'normal'
+                    });
+                    sentCount++;
+                }
+                catch (error) {
+                    this.logger.error(`Failed to send email to ${recipient.email || recipient.value}:`, error);
+                }
+            }
+        }
+        return { success: sentCount > 0, sent: sentCount };
+    }
+    async sendSMSNotification(recipients, message) {
+        let sentCount = 0;
+        for (const recipient of recipients) {
+            if (recipient.phone) {
+                try {
+                    await this.client.createRecord('sys_sms', {
+                        recipient: recipient.phone,
+                        message: message.substring(0, 160), // SMS length limit
+                        type: 'notification'
+                    });
+                    sentCount++;
+                }
+                catch (error) {
+                    this.logger.error(`Failed to send SMS to ${recipient.phone}:`, error);
+                }
+            }
+        }
+        return { success: sentCount > 0, sent: sentCount };
+    }
+    async sendPushNotification(recipients, title, message) {
+        let sentCount = 0;
+        for (const recipient of recipients) {
+            if (recipient.sys_id) {
+                try {
+                    await this.client.createRecord('sys_push_notif_msg', {
+                        user: recipient.sys_id,
+                        title: title,
+                        message: message,
+                        type: 'notification'
+                    });
+                    sentCount++;
+                }
+                catch (error) {
+                    this.logger.error(`Failed to send push notification to ${recipient.name}:`, error);
+                }
+            }
+        }
+        return { success: sentCount > 0, sent: sentCount };
+    }
+    personalizeMessage(message, personalization, recipient) {
+        let personalizedMessage = message;
+        // Replace common variables
+        if (recipient.name) {
+            personalizedMessage = personalizedMessage.replace(/\{name\}/g, recipient.name);
+        }
+        // Replace custom variables
+        Object.entries(personalization || {}).forEach(([key, value]) => {
+            const regex = new RegExp(`\\{${key}\\}`, 'g');
+            personalizedMessage = personalizedMessage.replace(regex, String(value));
+        });
+        return personalizedMessage;
+    }
+}
+exports.ServiceNowNotificationsMCP = ServiceNowNotificationsMCP;
+// Start the server
+async function main() {
+    const server = new ServiceNowNotificationsMCP();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.server.connect(transport);
+    console.error('📨 ServiceNow Notifications MCP Server started');
+}
+if (require.main === module) {
+    main().catch(console.error);
+}
+//# sourceMappingURL=servicenow-notifications-mcp.js.map

package/dist/mcp/servicenow-secops-mcp.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+/**
+ * ServiceNow Security Operations (SecOps) MCP Server
+ *
+ * Provides comprehensive Security Operations capabilities including:
+ * - Security incident management and response
+ * - Threat intelligence correlation and analysis
+ * - Vulnerability assessment and management
+ * - Security playbook automation
+ * - SOAR (Security Orchestration, Automation & Response)
+ *
+ * Critical enterprise security module previously missing from Snow-Flow
+ */
+import { EnhancedBaseMCPServer } from './shared/enhanced-base-mcp-server.js';
+export declare class ServiceNowSecOpsMCP extends EnhancedBaseMCPServer {
+    constructor();
+    private setupHandlers;
+    private createSecurityIncident;
+    private analyzeThreatIntelligence;
+    private executeSecurityPlaybook;
+    private assessVulnerabilityRisk;
+    private generateSecurityDashboard;
+    private automateThreatResponse;
+    private mapPriorityToNumber;
+    private calculateImpact;
+    private detectIOCType;
+}
+//# sourceMappingURL=servicenow-secops-mcp.d.ts.map