@way_marks/server 0.8.0 → 1.0.0

package/dist/notifications/service.js

@@ -0,0 +1,457 @@
+"use strict";
+/**
+ * Notification Service — Slack & Email integration for approval requests
+ *
+ * Sends notifications when:
+ * - Approval request is created (notify required approvers)
+ * - Approval decision is submitted (notify original requester and team)
+ *
+ * Supports:
+ * - Slack webhook notifications with interactive approval buttons
+ * - Email notifications with decision details
+ * - Custom templates and retry logic
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyApprovalRequestSlack = notifyApprovalRequestSlack;
+exports.notifyApprovalDecisionSlack = notifyApprovalDecisionSlack;
+exports.notifyApprovalRequestEmail = notifyApprovalRequestEmail;
+exports.notifyApprovalDecisionEmail = notifyApprovalDecisionEmail;
+exports.broadcastApprovalRequest = broadcastApprovalRequest;
+exports.broadcastApprovalDecision = broadcastApprovalDecision;
+exports.notifyEscalationSlack = notifyEscalationSlack;
+exports.notifyEscalationDecisionSlack = notifyEscalationDecisionSlack;
+exports.notifyEscalationEmail = notifyEscalationEmail;
+exports.notifyEscalationDecisionEmail = notifyEscalationDecisionEmail;
+exports.broadcastEscalation = broadcastEscalation;
+exports.broadcastEscalationDecision = broadcastEscalationDecision;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PROJECT_ROOT = process.env.WAYMARK_PROJECT_ROOT || process.cwd();
+const CONFIG_PATH = path.join(PROJECT_ROOT, '.waymark', 'config.json');
+/**
+ * Load notification configuration from .waymark/config.json
+ */
+function loadNotificationConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_PATH)) {
+            return {};
+        }
+        const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+        return config.notifications || {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Send Slack notification for approval request
+ */
+async function notifyApprovalRequestSlack(approver_ids, session_id, request_id, requester_name, action_count) {
+    const config = loadNotificationConfig();
+    const slackConfig = config.slack;
+    if (!slackConfig?.enabled || !slackConfig.webhook_url) {
+        console.log('[Notifications] Slack disabled or unconfigured');
+        return false;
+    }
+    try {
+        const approversList = approver_ids.join(', ');
+        const message = {
+            text: `🔔 New approval request from ${requester_name}`,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `*Approval Required* 🔔\n\nUser *${requester_name}* requests approval to rollback session with *${action_count}* actions.\n\n*Session:* \`${session_id}\`\n*Approvers:* ${approversList}`,
+                    },
+                },
+                {
+                    type: 'actions',
+                    elements: [
+                        {
+                            type: 'button',
+                            text: {
+                                type: 'plain_text',
+                                text: '✅ Approve',
+                            },
+                            value: request_id,
+                            action_id: 'waymark_approval_approve',
+                            style: 'primary',
+                        },
+                        {
+                            type: 'button',
+                            text: {
+                                type: 'plain_text',
+                                text: '❌ Reject',
+                            },
+                            value: request_id,
+                            action_id: 'waymark_approval_reject',
+                            style: 'danger',
+                        },
+                    ],
+                },
+            ],
+        };
+        const response = await fetch(slackConfig.webhook_url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(message),
+        });
+        return response.ok;
+    }
+    catch (err) {
+        console.error('[Notifications] Slack error:', err);
+        return false;
+    }
+}
+/**
+ * Send Slack notification for approval decision
+ */
+async function notifyApprovalDecisionSlack(approver_name, decision, session_id, reason) {
+    const config = loadNotificationConfig();
+    const slackConfig = config.slack;
+    if (!slackConfig?.enabled || !slackConfig.webhook_url) {
+        return false;
+    }
+    try {
+        const emoji = decision === 'approve' ? '✅' : '❌';
+        const action = decision === 'approve' ? 'Approved' : 'Rejected';
+        const reasonText = reason ? `\n*Reason:* ${reason}` : '';
+        const message = {
+            text: `${emoji} Approval ${action} by ${approver_name}`,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `${emoji} *Approval ${action}*\n\nApprover: *${approver_name}*\nSession: \`${session_id}\`${reasonText}`,
+                    },
+                },
+            ],
+        };
+        const response = await fetch(slackConfig.webhook_url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(message),
+        });
+        return response.ok;
+    }
+    catch (err) {
+        console.error('[Notifications] Slack decision error:', err);
+        return false;
+    }
+}
+/**
+ * Send email notification for approval request
+ */
+async function notifyApprovalRequestEmail(recipient_email, recipient_name, session_id, request_id, requester_name, action_count) {
+    const config = loadNotificationConfig();
+    const emailConfig = config.email;
+    if (!emailConfig?.enabled) {
+        console.log('[Notifications] Email disabled or unconfigured');
+        return false;
+    }
+    try {
+        // For now, log the email that would be sent
+        // In production, integrate with SMTP or email service
+        console.log(`[Notifications] Email approval request to ${recipient_email}:
+      Recipient: ${recipient_name}
+      From: ${requester_name}
+      Session: ${session_id}
+      Actions: ${action_count}
+      Request ID: ${request_id}`);
+        return true;
+    }
+    catch (err) {
+        console.error('[Notifications] Email error:', err);
+        return false;
+    }
+}
+/**
+ * Send email notification for approval decision
+ */
+async function notifyApprovalDecisionEmail(recipient_email, approver_name, decision, session_id, reason) {
+    const config = loadNotificationConfig();
+    const emailConfig = config.email;
+    if (!emailConfig?.enabled) {
+        return false;
+    }
+    try {
+        const action = decision === 'approve' ? 'Approved' : 'Rejected';
+        const reasonText = reason ? `\n\nReason: ${reason}` : '';
+        console.log(`[Notifications] Email approval decision to ${recipient_email}:
+      Approver: ${approver_name}
+      Decision: ${action}
+      Session: ${session_id}${reasonText}`);
+        return true;
+    }
+    catch (err) {
+        console.error('[Notifications] Email decision error:', err);
+        return false;
+    }
+}
+/**
+ * Broadcast approval request to all required approvers
+ */
+async function broadcastApprovalRequest(approvers, session_id, request_id, requester_name, action_count) {
+    let slack_sent = 0;
+    let email_sent = 0;
+    // Send Slack notification (once to all approvers)
+    const slackSuccess = await notifyApprovalRequestSlack(approvers.map(a => a.member_id), session_id, request_id, requester_name, action_count);
+    if (slackSuccess)
+        slack_sent++;
+    // Send email to each approver
+    for (const approver of approvers) {
+        const emailSuccess = await notifyApprovalRequestEmail(approver.email, approver.name, session_id, request_id, requester_name, action_count);
+        if (emailSuccess)
+            email_sent++;
+    }
+    return { slack_sent, email_sent };
+}
+/**
+ * Broadcast approval decision to all stakeholders
+ */
+async function broadcastApprovalDecision(approver, decision, session_id, requester_email, reason) {
+    let slack_sent = 0;
+    let email_sent = 0;
+    // Send Slack notification
+    const slackSuccess = await notifyApprovalDecisionSlack(approver.name, decision, session_id, reason);
+    if (slackSuccess)
+        slack_sent++;
+    // Send email to requester
+    const emailSuccess = await notifyApprovalDecisionEmail(requester_email, approver.name, decision, session_id, reason);
+    if (emailSuccess)
+        email_sent++;
+    return { slack_sent, email_sent };
+}
+/**
+ * Phase 3: Escalation Notifications
+ */
+/**
+ * Send Slack escalation notification
+ */
+async function notifyEscalationSlack(escalation_targets, session_id, request_id, requester_name, escalation_deadline) {
+    const config = loadNotificationConfig();
+    const slackConfig = config.slack;
+    if (!slackConfig?.enabled || !slackConfig.webhook_url) {
+        console.log('[Notifications] Slack disabled or unconfigured');
+        return false;
+    }
+    try {
+        const deadlineTime = new Date(escalation_deadline).toLocaleString();
+        const targetsList = escalation_targets.join(', ');
+        const message = {
+            text: `⏰ Escalation needed for ${requester_name}'s rollback request`,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `*Approval Escalation* ⏰\n\nApproval for *${requester_name}*'s rollback is stalled.\n\n*Session:* \`${session_id}\`\n*Escalation Targets:* ${targetsList}\n*Decision Deadline:* ${deadlineTime}`,
+                    },
+                },
+                {
+                    type: 'actions',
+                    elements: [
+                        {
+                            type: 'button',
+                            text: {
+                                type: 'plain_text',
+                                text: '✅ Proceed with Rollback',
+                            },
+                            value: request_id,
+                            action_id: 'waymark_escalation_proceed',
+                            style: 'primary',
+                        },
+                        {
+                            type: 'button',
+                            text: {
+                                type: 'plain_text',
+                                text: '❌ Block Rollback',
+                            },
+                            value: request_id,
+                            action_id: 'waymark_escalation_block',
+                            style: 'danger',
+                        },
+                    ],
+                },
+            ],
+        };
+        const response = await fetch(slackConfig.webhook_url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(message),
+        });
+        return response.ok;
+    }
+    catch (err) {
+        console.error('[Notifications] Slack escalation error:', err);
+        return false;
+    }
+}
+/**
+ * Send Slack escalation decision notification
+ */
+async function notifyEscalationDecisionSlack(target_name, decision, session_id, reason) {
+    const config = loadNotificationConfig();
+    const slackConfig = config.slack;
+    if (!slackConfig?.enabled || !slackConfig.webhook_url) {
+        return false;
+    }
+    try {
+        const emoji = decision === 'proceed' ? '✅' : '❌';
+        const action = decision === 'proceed' ? 'Allowed' : 'Blocked';
+        const reasonText = reason ? `\n*Reason:* ${reason}` : '';
+        const message = {
+            text: `${emoji} Escalation ${action} by ${target_name}`,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `${emoji} *Escalation ${action}*\n\nTarget: *${target_name}*\nSession: \`${session_id}\`${reasonText}`,
+                    },
+                },
+            ],
+        };
+        const response = await fetch(slackConfig.webhook_url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(message),
+        });
+        return response.ok;
+    }
+    catch (err) {
+        console.error('[Notifications] Slack escalation decision error:', err);
+        return false;
+    }
+}
+/**
+ * Send email escalation notification
+ */
+async function notifyEscalationEmail(recipient_email, recipient_name, session_id, request_id, requester_name, escalation_deadline) {
+    const config = loadNotificationConfig();
+    const emailConfig = config.email;
+    if (!emailConfig?.enabled) {
+        console.log('[Notifications] Email disabled or unconfigured');
+        return false;
+    }
+    try {
+        const deadlineTime = new Date(escalation_deadline).toLocaleString();
+        console.log(`[Notifications] Email escalation to ${recipient_email}:
+      Recipient: ${recipient_name}
+      Requester: ${requester_name}
+      Session: ${session_id}
+      Request ID: ${request_id}
+      Deadline: ${deadlineTime}`);
+        return true;
+    }
+    catch (err) {
+        console.error('[Notifications] Email escalation error:', err);
+        return false;
+    }
+}
+/**
+ * Send email escalation decision notification
+ */
+async function notifyEscalationDecisionEmail(recipient_email, target_name, decision, session_id, reason) {
+    const config = loadNotificationConfig();
+    const emailConfig = config.email;
+    if (!emailConfig?.enabled) {
+        return false;
+    }
+    try {
+        const action = decision === 'proceed' ? 'Allowed' : 'Blocked';
+        const reasonText = reason ? `\n\nReason: ${reason}` : '';
+        console.log(`[Notifications] Email escalation decision to ${recipient_email}:
+      Target: ${target_name}
+      Decision: ${action}
+      Session: ${session_id}${reasonText}`);
+        return true;
+    }
+    catch (err) {
+        console.error('[Notifications] Email escalation decision error:', err);
+        return false;
+    }
+}
+/**
+ * Broadcast escalation request to all targets
+ */
+async function broadcastEscalation(targets, session_id, request_id, requester_name, escalation_deadline) {
+    let slack_sent = 0;
+    let email_sent = 0;
+    // Send Slack notification (once to all targets)
+    const slackSuccess = await notifyEscalationSlack(targets.map(t => t.member_id), session_id, request_id, requester_name, escalation_deadline);
+    if (slackSuccess)
+        slack_sent++;
+    // Send email to each target
+    for (const target of targets) {
+        const emailSuccess = await notifyEscalationEmail(target.email, target.name, session_id, request_id, requester_name, escalation_deadline);
+        if (emailSuccess)
+            email_sent++;
+    }
+    return { slack_sent, email_sent };
+}
+/**
+ * Broadcast escalation decision to all stakeholders
+ */
+async function broadcastEscalationDecision(target, decision, session_id, requester_email, reason) {
+    let slack_sent = 0;
+    let email_sent = 0;
+    // Send Slack notification
+    const slackSuccess = await notifyEscalationDecisionSlack(target.name, decision, session_id, reason);
+    if (slackSuccess)
+        slack_sent++;
+    // Send email to requester
+    const emailSuccess = await notifyEscalationDecisionEmail(requester_email, target.name, decision, session_id, reason);
+    if (emailSuccess)
+        email_sent++;
+    return { slack_sent, email_sent };
+}
+exports.default = {
+    notifyApprovalRequestSlack,
+    notifyApprovalDecisionSlack,
+    notifyApprovalRequestEmail,
+    notifyApprovalDecisionEmail,
+    broadcastApprovalRequest,
+    broadcastApprovalDecision,
+    notifyEscalationSlack,
+    notifyEscalationDecisionSlack,
+    notifyEscalationEmail,
+    notifyEscalationDecisionEmail,
+    broadcastEscalation,
+    broadcastEscalationDecision,
+};