@way_marks/server 0.9.0 → 1.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,
+};