@hotmeshio/long-tail 0.1.0

package/build/routes/escalations/bulk.js

@@ -0,0 +1,324 @@
+"use strict";
+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.registerBulkRoutes = registerBulkRoutes;
+const escalationService = __importStar(require("../../services/escalation"));
+const taskService = __importStar(require("../../services/task"));
+const userService = __importStar(require("../../services/user"));
+const workers_1 = require("../../workers");
+const defaults_1 = require("../../modules/defaults");
+const publish_1 = require("../../services/events/publish");
+function registerBulkRoutes(router) {
+    /**
+     * POST /api/escalations/release-expired
+     * Optional cleanup of stale assignment data.
+     */
+    router.post('/release-expired', async (_req, res) => {
+        try {
+            const released = await escalationService.releaseExpiredClaims();
+            res.json({ released });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * PATCH /api/escalations/priority
+     * Bulk update priority for selected escalations.
+     * Body: { ids: string[], priority: 1|2|3|4 }
+     * Requires admin/superadmin permission for the escalation roles.
+     */
+    router.patch('/priority', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const { ids, priority } = req.body || {};
+            if (!Array.isArray(ids) || ids.length === 0) {
+                res.status(400).json({ error: 'ids must be a non-empty array' });
+                return;
+            }
+            if (![1, 2, 3, 4].includes(priority)) {
+                res.status(400).json({ error: 'priority must be 1, 2, 3, or 4' });
+                return;
+            }
+            // Permission check: superadmin can update any; admin only for their roles
+            const isSuperAdminUser = await userService.isSuperAdmin(userId);
+            if (!isSuperAdminUser) {
+                const roles = await escalationService.getEscalationRoles(ids);
+                for (const role of roles) {
+                    const canManage = await userService.isGroupAdmin(userId, role);
+                    if (!canManage) {
+                        res.status(403).json({
+                            error: `Insufficient permissions for role "${role}"`,
+                        });
+                        return;
+                    }
+                }
+            }
+            const updated = await escalationService.updateEscalationsPriority(ids, priority);
+            res.json({ updated });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * POST /api/escalations/bulk-claim
+     * Bulk claim selected escalations for the authenticated user.
+     * Body: { ids: string[], durationMinutes?: number }
+     */
+    router.post('/bulk-claim', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const { ids, durationMinutes } = req.body || {};
+            if (!Array.isArray(ids) || ids.length === 0) {
+                res.status(400).json({ error: 'ids must be a non-empty array' });
+                return;
+            }
+            const isSuperAdminUser = await userService.isSuperAdmin(userId);
+            if (!isSuperAdminUser) {
+                const roles = await escalationService.getEscalationRoles(ids);
+                for (const role of roles) {
+                    const canManage = await userService.isGroupAdmin(userId, role);
+                    if (!canManage) {
+                        res.status(403).json({ error: `Insufficient permissions for role "${role}"` });
+                        return;
+                    }
+                }
+            }
+            const result = await escalationService.bulkClaimEscalations(ids, userId, durationMinutes ?? 30);
+            res.json(result);
+            if (result.claimed > 0) {
+                for (const id of ids) {
+                    (0, publish_1.publishEscalationEvent)({
+                        type: 'escalation.claimed',
+                        source: 'api',
+                        workflowId: '',
+                        workflowName: '',
+                        taskQueue: '',
+                        escalationId: id,
+                        status: 'claimed',
+                        data: { assigned_to: userId, bulk: true },
+                    });
+                }
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * POST /api/escalations/bulk-assign
+     * Bulk assign selected escalations to a specific user.
+     * Body: { ids: string[], targetUserId: string, durationMinutes?: number }
+     * Superadmin: can assign anyone. Admin: target must hold escalation role.
+     */
+    router.post('/bulk-assign', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const { ids, targetUserId, durationMinutes } = req.body || {};
+            if (!Array.isArray(ids) || ids.length === 0) {
+                res.status(400).json({ error: 'ids must be a non-empty array' });
+                return;
+            }
+            if (!targetUserId || typeof targetUserId !== 'string') {
+                res.status(400).json({ error: 'targetUserId is required' });
+                return;
+            }
+            const isSuperAdminUser = await userService.isSuperAdmin(userId);
+            const roles = await escalationService.getEscalationRoles(ids);
+            if (!isSuperAdminUser) {
+                // Caller must be group admin for each escalation's role
+                for (const role of roles) {
+                    const canManage = await userService.isGroupAdmin(userId, role);
+                    if (!canManage) {
+                        res.status(403).json({ error: `Insufficient permissions for role "${role}"` });
+                        return;
+                    }
+                }
+                // Target user must hold each escalation's role
+                for (const role of roles) {
+                    const targetHasRole = await userService.hasRole(targetUserId, role);
+                    if (!targetHasRole) {
+                        res.status(400).json({ error: `Target user does not hold the "${role}" role` });
+                        return;
+                    }
+                }
+            }
+            const result = await escalationService.bulkAssignEscalations(ids, targetUserId, durationMinutes ?? 30);
+            res.json(result);
+            if (result.assigned > 0) {
+                for (const id of ids) {
+                    (0, publish_1.publishEscalationEvent)({
+                        type: 'escalation.claimed',
+                        source: 'api',
+                        workflowId: '',
+                        workflowName: '',
+                        taskQueue: '',
+                        escalationId: id,
+                        status: 'claimed',
+                        data: { assigned_to: targetUserId, bulk: true },
+                    });
+                }
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * PATCH /api/escalations/bulk-escalate
+     * Bulk reassign selected escalations to a different role.
+     * Body: { ids: string[], targetRole: string }
+     */
+    router.patch('/bulk-escalate', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const { ids, targetRole } = req.body || {};
+            if (!Array.isArray(ids) || ids.length === 0) {
+                res.status(400).json({ error: 'ids must be a non-empty array' });
+                return;
+            }
+            if (!targetRole || typeof targetRole !== 'string') {
+                res.status(400).json({ error: 'targetRole is required' });
+                return;
+            }
+            const isSuperAdminUser = await userService.isSuperAdmin(userId);
+            if (!isSuperAdminUser) {
+                const roles = await escalationService.getEscalationRoles(ids);
+                for (const role of roles) {
+                    const canManage = await userService.isGroupAdmin(userId, role);
+                    if (!canManage) {
+                        res.status(403).json({ error: `Insufficient permissions for role "${role}"` });
+                        return;
+                    }
+                }
+            }
+            const updated = await escalationService.bulkEscalateToRole(ids, targetRole);
+            res.json({ updated });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * POST /api/escalations/bulk-triage
+     * Bulk resolve selected escalations and start AI triage workflows.
+     * Body: { ids: string[], hint?: string }
+     */
+    router.post('/bulk-triage', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const { ids, hint } = req.body || {};
+            if (!Array.isArray(ids) || ids.length === 0) {
+                res.status(400).json({ error: 'ids must be a non-empty array' });
+                return;
+            }
+            const isSuperAdminUser = await userService.isSuperAdmin(userId);
+            if (!isSuperAdminUser) {
+                const roles = await escalationService.getEscalationRoles(ids);
+                for (const role of roles) {
+                    const canManage = await userService.isGroupAdmin(userId, role);
+                    if (!canManage) {
+                        res.status(403).json({ error: `Insufficient permissions for role "${role}"` });
+                        return;
+                    }
+                }
+            }
+            const resolved = await escalationService.bulkResolveForTriage(ids, hint);
+            const client = (0, workers_1.createClient)();
+            const workflowIds = [];
+            for (const escalation of resolved) {
+                let escalationPayload = {};
+                if (escalation.escalation_payload) {
+                    try {
+                        escalationPayload = JSON.parse(escalation.escalation_payload);
+                    }
+                    catch { }
+                }
+                let envelope = {};
+                if (escalation.envelope) {
+                    try {
+                        envelope = JSON.parse(escalation.envelope);
+                    }
+                    catch { }
+                }
+                const triageWorkflowId = `triage-${escalation.id}-${Date.now()}`;
+                const triageEnvelope = {
+                    data: {
+                        escalationId: escalation.id,
+                        originId: escalation.origin_id ?? undefined,
+                        originalWorkflowType: escalation.workflow_type,
+                        originalTaskQueue: escalation.task_queue,
+                        originalTaskId: escalation.task_id,
+                        escalationPayload,
+                        resolverPayload: {
+                            _lt: { needsTriage: true, ...(hint ? { hint } : {}) },
+                        },
+                    },
+                    metadata: envelope.metadata || {},
+                    lt: { ...(envelope.lt || {}), userId: req.auth?.userId },
+                };
+                const routing = escalation.task_id
+                    ? (await taskService.getTask(escalation.task_id))?.metadata
+                    : null;
+                await taskService.createTask({
+                    workflow_id: triageWorkflowId,
+                    workflow_type: 'mcpTriage',
+                    lt_type: 'mcpTriage',
+                    task_queue: 'long-tail-system',
+                    signal_id: `lt-triage-${triageWorkflowId}`,
+                    parent_workflow_id: routing?.parentWorkflowId || triageWorkflowId,
+                    origin_id: escalation.origin_id || triageWorkflowId,
+                    parent_id: escalation.parent_id ?? undefined,
+                    envelope: JSON.stringify(triageEnvelope),
+                    metadata: routing || undefined,
+                });
+                await client.workflow.start({
+                    workflowName: 'mcpTriage',
+                    args: [triageEnvelope],
+                    taskQueue: 'long-tail-system',
+                    workflowId: triageWorkflowId,
+                    expire: defaults_1.JOB_EXPIRE_SECS,
+                    entity: 'mcpTriage',
+                });
+                workflowIds.push(triageWorkflowId);
+            }
+            res.json({ triaged: resolved.length, workflows: workflowIds });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+}

package/build/routes/escalations/helpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Return the role names visible to a user, or undefined if superadmin (no filter).
+ * Returns an empty array when the user holds no roles at all.
+ */
+export declare function getVisibleRoles(userId: string): Promise<string[] | undefined>;

package/build/routes/escalations/helpers.js

@@ -0,0 +1,48 @@
+"use strict";
+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.getVisibleRoles = getVisibleRoles;
+const userService = __importStar(require("../../services/user"));
+/**
+ * Return the role names visible to a user, or undefined if superadmin (no filter).
+ * Returns an empty array when the user holds no roles at all.
+ */
+async function getVisibleRoles(userId) {
+    const isSuperAdminUser = await userService.isSuperAdmin(userId);
+    if (isSuperAdminUser)
+        return undefined;
+    const userRoles = await userService.getUserRoles(userId);
+    return userRoles.map((r) => r.role);
+}

package/build/routes/escalations/index.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/escalations/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const list_1 = require("./list");
+const bulk_1 = require("./bulk");
+const single_1 = require("./single");
+const resolve_1 = require("./resolve");
+const router = (0, express_1.Router)();
+// Registration order matters: literal paths before parameterized /:id routes.
+// GET /, /available, /types, /stats
+(0, list_1.registerListRoutes)(router);
+// POST /release-expired, PATCH /priority, POST /bulk-claim,
+// POST /bulk-assign, PATCH /bulk-escalate, POST /bulk-triage
+(0, bulk_1.registerBulkRoutes)(router);
+// PATCH /:id/escalate, GET /by-workflow/:workflowId,
+// GET /:id, POST /:id/claim, POST /:id/release
+(0, single_1.registerSingleRoutes)(router);
+// POST /:id/resolve
+(0, resolve_1.registerResolveRoutes)(router);
+exports.default = router;

package/build/routes/escalations/list.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'express';
+export declare function registerListRoutes(router: Router): void;

package/build/routes/escalations/list.js

@@ -0,0 +1,140 @@
+"use strict";
+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.registerListRoutes = registerListRoutes;
+const escalationService = __importStar(require("../../services/escalation"));
+const helpers_1 = require("./helpers");
+function registerListRoutes(router) {
+    /**
+     * GET /api/escalations
+     * List escalations with optional filters.
+     * RBAC: superadmin sees all; others see only roles they belong to.
+     */
+    router.get('/', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const visibleRoles = await (0, helpers_1.getVisibleRoles)(userId);
+            if (visibleRoles && visibleRoles.length === 0) {
+                res.json({ escalations: [], total: 0 });
+                return;
+            }
+            const result = await escalationService.listEscalations({
+                status: req.query.status,
+                role: req.query.role,
+                type: req.query.type,
+                subtype: req.query.subtype,
+                assigned_to: req.query.assigned_to,
+                priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
+                limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+                offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+                sort_by: req.query.sort_by,
+                order: req.query.order,
+                visibleRoles,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * GET /api/escalations/available
+     * List available escalations (pending, unassigned or expired claim).
+     * RBAC: superadmin sees all; others see only roles they belong to.
+     */
+    router.get('/available', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const visibleRoles = await (0, helpers_1.getVisibleRoles)(userId);
+            if (visibleRoles && visibleRoles.length === 0) {
+                res.json({ escalations: [], total: 0 });
+                return;
+            }
+            const result = await escalationService.listAvailableEscalations({
+                role: req.query.role,
+                type: req.query.type,
+                subtype: req.query.subtype,
+                priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
+                limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+                offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+                sort_by: req.query.sort_by,
+                order: req.query.order,
+                visibleRoles,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * GET /api/escalations/types
+     * Returns distinct escalation type values.
+     */
+    router.get('/types', async (_req, res) => {
+        try {
+            const types = await escalationService.listDistinctTypes();
+            res.json({ types });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    /**
+     * GET /api/escalations/stats
+     * Aggregated escalation statistics.
+     * RBAC: superadmin sees all; others scoped to their roles.
+     */
+    router.get('/stats', async (req, res) => {
+        try {
+            const userId = req.auth.userId;
+            const visibleRoles = await (0, helpers_1.getVisibleRoles)(userId);
+            if (visibleRoles && visibleRoles.length === 0) {
+                res.json({
+                    pending: 0, claimed: 0,
+                    created: 0, resolved: 0,
+                    by_role: [], by_type: [],
+                });
+                return;
+            }
+            const period = req.query.period || undefined;
+            const stats = await escalationService.getEscalationStats(visibleRoles, period);
+            res.json(stats);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+}

package/build/routes/escalations/resolve.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'express';
+export declare function registerResolveRoutes(router: Router): void;