@way_marks/server 0.9.0 → 2.0.0

package/dist/escalation/manager.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Escalation Manager — Core logic for approval escalation
+ *
+ * Responsibilities:
+ * - Check for stalled approval requests
+ * - Create escalation requests when approvals timeout
+ * - Determine escalation targets
+ * - Process escalation decisions
+ * - Track escalation history and audit trail
+ *
+ * Integration with Phase 2 Approval System:
+ * - Monitors approval_requests for timeout
+ * - Creates escalation_requests when deadline passed
+ * - Prevents rollback if escalation is blocked
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndEscalateStaleApprovals = checkAndEscalateStaleApprovals;
+exports.determineEscalationTargets = determineEscalationTargets;
+exports.submitEscalationDecision = submitEscalationDecision;
+exports.getEscalationStatus = getEscalationStatus;
+exports.canProceedWithRollbackAfterEscalation = canProceedWithRollbackAfterEscalation;
+exports.getEscalationHistoryForSession = getEscalationHistoryForSession;
+exports.startEscalationScheduler = startEscalationScheduler;
+exports.stopEscalationScheduler = stopEscalationScheduler;
+exports.isSchedulerRunning = isSchedulerRunning;
+const database_1 = require("../db/database");
+/**
+ * Check for stalled approval requests and trigger escalations
+ * Called periodically by scheduler (e.g., every minute)
+ */
+function checkAndEscalateStaleApprovals() {
+    const now = new Date().toISOString();
+    const staleApprovals = (0, database_1.getStaleApprovals)(now);
+    const rules = (0, database_1.getAllEscalationRules)();
+    const escalationsCreated = [];
+    for (const approval of staleApprovals) {
+        // For now, use default rule (escalate to all-targets rule if exists)
+        // In future, could match escalation rules based on approval attributes
+        const rule = rules.length > 0 ? rules[0] : null;
+        if (!rule)
+            continue;
+        const escalationTargets = JSON.parse(rule.escalation_targets);
+        const deadline = new Date(now);
+        deadline.setHours(deadline.getHours() + rule.timeout_hours);
+        const requestId = `escalation-${approval.approval_request_id}-${Date.now()}`;
+        try {
+            (0, database_1.createEscalationRequest)(requestId, approval.approval_request_id, approval.session_id, escalationTargets, deadline.toISOString());
+            escalationsCreated.push(requestId);
+        }
+        catch (err) {
+            console.error(`Failed to create escalation for ${approval.approval_request_id}:`, err);
+        }
+    }
+    return {
+        hasStaleApprovals: staleApprovals.length > 0,
+        staleApprovals,
+        escalationsCreated,
+        timestamp: now,
+    };
+}
+/**
+ * Determine escalation targets for a given approval request
+ */
+function determineEscalationTargets(approval_request_id) {
+    const rules = (0, database_1.getAllEscalationRules)();
+    // Simple logic: use first active rule's targets
+    // In future, could match based on approval attributes (session type, user, etc)
+    if (rules.length > 0) {
+        return JSON.parse(rules[0].escalation_targets);
+    }
+    return [];
+}
+/**
+ * Submit escalation decision
+ */
+function submitEscalationDecision(escalation_request_id, target_id, decision, reason) {
+    const escalation = (0, database_1.getEscalationRequest)(escalation_request_id);
+    if (!escalation) {
+        throw new Error(`Escalation request ${escalation_request_id} not found`);
+    }
+    const targets = JSON.parse(escalation.escalation_targets);
+    if (!targets.includes(target_id)) {
+        throw new Error(`${target_id} is not authorized to decide on this escalation`);
+    }
+    // Check if already decided by this target
+    const existingDecisions = (0, database_1.getEscalationDecisions)(escalation_request_id);
+    if (existingDecisions.some(d => d.target_id === target_id)) {
+        throw new Error(`${target_id} has already made a decision on this escalation`);
+    }
+    // Record decision
+    const decision_id = `escalation-decision-${escalation_request_id}-${target_id}-${Date.now()}`;
+    (0, database_1.submitEscalationDecision)(decision_id, escalation_request_id, target_id, decision, reason);
+    // Return updated status
+    return getEscalationStatus(escalation_request_id);
+}
+/**
+ * Get escalation status
+ */
+function getEscalationStatus(escalation_request_id) {
+    const escalation = (0, database_1.getEscalationRequest)(escalation_request_id);
+    if (!escalation) {
+        throw new Error(`Escalation request ${escalation_request_id} not found`);
+    }
+    const decisions = (0, database_1.getEscalationDecisions)(escalation_request_id);
+    const targets = JSON.parse(escalation.escalation_targets);
+    const blockDecisions = decisions.filter(d => d.decision === 'block');
+    const proceedDecisions = decisions.filter(d => d.decision === 'proceed');
+    // Status logic:
+    // - If any "block" → blocked
+    // - If all targets have decided with no blocks → proceeded
+    // - Otherwise → pending
+    let status = 'pending';
+    if (blockDecisions.length > 0) {
+        status = 'blocked';
+    }
+    else if (proceedDecisions.length === targets.length) {
+        status = 'proceeded';
+    }
+    return {
+        request_id: escalation_request_id,
+        status,
+        escalation_triggered_at: escalation.escalation_triggered_at || new Date().toISOString(),
+        escalation_deadline: escalation.escalation_deadline,
+        targets_count: targets.length,
+        decisions_received: decisions.length,
+        decisions: decisions.map(d => ({
+            target_id: d.target_id,
+            decision: d.decision,
+            reason: d.reason ?? undefined,
+        })),
+        can_proceed: status === 'proceeded',
+    };
+}
+/**
+ * Check if rollback can proceed given escalation status
+ * If escalation exists and is blocked, prevent rollback
+ */
+function canProceedWithRollbackAfterEscalation(approval_request_id) {
+    const pending = (0, database_1.getPendingEscalations)();
+    const escalation = pending.find(e => e.approval_request_id === approval_request_id);
+    if (!escalation) {
+        // No pending escalation → can proceed
+        return true;
+    }
+    // Check escalation status
+    try {
+        const status = getEscalationStatus(escalation.request_id);
+        return status.can_proceed;
+    }
+    catch {
+        // If error getting status, be conservative and block
+        return false;
+    }
+}
+/**
+ * Get escalation history for a session
+ */
+function getEscalationHistoryForSession(session_id) {
+    return (0, database_1.getEscalationHistory)(session_id);
+}
+let schedulerHandle = null;
+function startEscalationScheduler(config = { interval_ms: 60000, enabled: true }) {
+    if (!config.enabled) {
+        console.log('[Escalation] Scheduler disabled in config');
+        return;
+    }
+    if (schedulerHandle) {
+        console.log('[Escalation] Scheduler already running');
+        return;
+    }
+    console.log(`[Escalation] Starting scheduler (check every ${config.interval_ms}ms)`);
+    schedulerHandle = setInterval(() => {
+        try {
+            const result = checkAndEscalateStaleApprovals();
+            if (result.escalationsCreated.length > 0) {
+                console.log(`[Escalation] Created ${result.escalationsCreated.length} escalation requests`);
+            }
+        }
+        catch (err) {
+            console.error('[Escalation] Scheduler error:', err);
+        }
+    }, config.interval_ms);
+}
+function stopEscalationScheduler() {
+    if (schedulerHandle) {
+        clearInterval(schedulerHandle);
+        schedulerHandle = null;
+        console.log('[Escalation] Scheduler stopped');
+    }
+}
+function isSchedulerRunning() {
+    return schedulerHandle !== null;
+}
+exports.default = {
+    checkAndEscalateStaleApprovals,
+    determineEscalationTargets,
+    submitEscalationDecision,
+    getEscalationStatus,
+    canProceedWithRollbackAfterEscalation,
+    getEscalationHistoryForSession,
+    startEscalationScheduler,
+    stopEscalationScheduler,
+    isSchedulerRunning,
+};

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,
+};