@hotmeshio/long-tail 0.1.5 → 0.1.7

package/build/routes/escalations/resolve.js

@@ -34,14 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerResolveRoutes = registerResolveRoutes;
-const escalationService = __importStar(require("../../services/escalation"));
-const taskService = __importStar(require("../../services/task"));
-const escalation_strategy_1 = require("../../services/escalation-strategy");
-const publish_1 = require("../../lib/events/publish");
-const ephemeral_1 = require("../../services/iam/ephemeral");
-const deployer_1 = require("../../services/yaml-workflow/deployer");
-const workers_1 = require("../../workers");
-const defaults_1 = require("../../modules/defaults");
+const api = __importStar(require("../../api/escalations"));
 function registerResolveRoutes(router) {
     /**
      * POST /api/escalations/:id/resolve
@@ -51,190 +44,7 @@ function registerResolveRoutes(router) {
      * Body: { resolverPayload: Record<string, any> }
      */
     router.post('/:id/resolve', async (req, res) => {
-        try {
-            const { resolverPayload } = req.body || {};
-            if (!resolverPayload) {
-                res.status(400).json({ error: 'resolverPayload is required' });
-                return;
-            }
-            // 1. Read escalation (verify pending)
-            const escalation = await escalationService.getEscalation(req.params.id);
-            if (!escalation) {
-                res.status(404).json({ error: 'Escalation not found' });
-                return;
-            }
-            if (escalation.status !== 'pending') {
-                res.status(409).json({ error: 'Escalation not available for resolution' });
-                return;
-            }
-            // 2. waitFor signal escalation -- signal the paused workflow directly
-            const signalRouting = escalation.metadata?.signal_routing;
-            if (signalRouting?.signalId) {
-                // Replace password fields with ephemeral tokens so plaintext never enters the signal store
-                let signalPayload = resolverPayload;
-                const formSchema = escalation.metadata?.form_schema;
-                if (formSchema?.properties) {
-                    signalPayload = { ...resolverPayload };
-                    for (const [key, def] of Object.entries(formSchema.properties)) {
-                        if (def?.format === 'password' && typeof signalPayload[key] === 'string') {
-                            const uuid = await (0, ephemeral_1.storeEphemeral)(signalPayload[key], {
-                                ttlSeconds: 900,
-                                label: key,
-                            });
-                            signalPayload[key] = (0, ephemeral_1.formatEphemeralToken)(uuid, key);
-                        }
-                    }
-                }
-                if (signalRouting.engine === 'yaml' && signalRouting.hookTopic && signalRouting.appId) {
-                    // YAML workflow: signal the HotMesh engine directly via hook topic.
-                    // Include job_id for hook match condition ({$job.metadata.jid} === {$self.hook.data.job_id}).
-                    const engine = await (0, deployer_1.getEngine)(signalRouting.appId);
-                    await engine.signal(signalRouting.hookTopic, {
-                        ...signalPayload,
-                        escalationId: escalation.id,
-                        job_id: signalRouting.jobId,
-                    });
-                }
-                else if (signalRouting.workflowId) {
-                    // Durable workflow: signal via workflow handle
-                    const client = (0, workers_1.createClient)();
-                    const handle = await client.workflow.getHandle(signalRouting.taskQueue, signalRouting.workflowType, signalRouting.workflowId);
-                    await handle.signal(signalRouting.signalId, signalPayload);
-                }
-                await escalationService.resolveEscalation(escalation.id, resolverPayload);
-                (0, publish_1.publishEscalationEvent)({
-                    type: 'escalation.resolved',
-                    source: 'api',
-                    workflowId: escalation.workflow_id || signalRouting.workflowId,
-                    workflowName: escalation.workflow_type || signalRouting.workflowType,
-                    taskQueue: escalation.task_queue || signalRouting.taskQueue || signalRouting.appId,
-                    taskId: escalation.task_id,
-                    escalationId: escalation.id,
-                    originId: escalation.origin_id ?? undefined,
-                    status: 'resolved',
-                });
-                res.json({ signaled: true, escalationId: escalation.id, workflowId: signalRouting.workflowId || signalRouting.appId });
-                return;
-            }
-            // 3. Reconstruct the original envelope from the escalation or task
-            let envelope = {};
-            if (escalation.envelope) {
-                try {
-                    envelope = JSON.parse(escalation.envelope);
-                }
-                catch { /* use empty */ }
-            }
-            else if (escalation.task_id) {
-                const task = await taskService.getTask(escalation.task_id);
-                if (task?.envelope) {
-                    try {
-                        envelope = JSON.parse(task.envelope);
-                    }
-                    catch { /* use empty */ }
-                }
-            }
-            // 4. Check escalation strategy for triage routing
-            const strategy = escalation_strategy_1.escalationStrategyRegistry.current;
-            if (strategy) {
-                const directive = await strategy.onResolution({
-                    escalation,
-                    resolverPayload,
-                    envelope,
-                });
-                if (directive.action === 'triage') {
-                    // Route to MCP triage orchestrator instead of standard re-run
-                    const originalTask = escalation.task_id
-                        ? await taskService.getTask(escalation.task_id)
-                        : null;
-                    const routing = originalTask?.metadata;
-                    const triageWorkflowId = `triage-${escalation.id}-${Date.now()}`;
-                    const client = (0, workers_1.createClient)();
-                    // Triage lives on a separate axis -- do NOT copy the original
-                    // task's parent routing (signalId, parentWorkflowId) into the
-                    // triage task. Otherwise the container interceptor would signal
-                    // the original parent when triage completes, prematurely closing
-                    // the original workflow. Triage exits the vortex by creating a
-                    // targeted escalation on the original task instead.
-                    await taskService.createTask({
-                        workflow_id: triageWorkflowId,
-                        workflow_type: 'mcpTriageRouter',
-                        lt_type: 'mcpTriage',
-                        task_queue: 'long-tail-system',
-                        signal_id: `lt-triage-${triageWorkflowId}`,
-                        parent_workflow_id: triageWorkflowId,
-                        origin_id: escalation.origin_id || triageWorkflowId,
-                        parent_id: escalation.parent_id ?? undefined,
-                        envelope: JSON.stringify(directive.triageEnvelope),
-                    });
-                    await client.workflow.start({
-                        workflowName: 'mcpTriageRouter',
-                        args: [directive.triageEnvelope],
-                        taskQueue: 'long-tail-system',
-                        workflowId: triageWorkflowId,
-                        expire: defaults_1.JOB_EXPIRE_SECS,
-                        entity: 'mcpTriageRouter',
-                    });
-                    // Mark escalation as resolved (triage is handling it)
-                    await escalationService.resolveEscalation(escalation.id, {
-                        ...resolverPayload,
-                        _lt: { ...resolverPayload._lt, triaged: true, triageWorkflowId },
-                    });
-                    (0, publish_1.publishEscalationEvent)({
-                        type: 'escalation.resolved',
-                        source: 'api',
-                        workflowId: escalation.workflow_id,
-                        workflowName: escalation.workflow_type,
-                        taskQueue: escalation.task_queue,
-                        taskId: escalation.task_id,
-                        escalationId: escalation.id,
-                        originId: escalation.origin_id ?? undefined,
-                        status: 'resolved',
-                    });
-                    res.json({
-                        started: true,
-                        escalationId: escalation.id,
-                        workflowId: triageWorkflowId,
-                        triage: true,
-                    });
-                    return;
-                }
-            }
-            // 5. If no workflow_type, this is a notification-only escalation -- acknowledge and close
-            if (!escalation.workflow_type || !escalation.task_queue) {
-                await escalationService.resolveEscalation(escalation.id, resolverPayload);
-                res.json({ acknowledged: true, escalationId: escalation.id });
-                return;
-            }
-            // 6. Standard re-run: inject resolver data and start original workflow
-            envelope.resolver = resolverPayload;
-            envelope.lt = {
-                ...envelope.lt,
-                escalationId: escalation.id,
-            };
-            const newWorkflowId = `rerun-${escalation.id}-${Date.now()}`;
-            const client = (0, workers_1.createClient)();
-            await client.workflow.start({
-                workflowName: escalation.workflow_type,
-                args: [envelope],
-                taskQueue: escalation.task_queue,
-                workflowId: newWorkflowId,
-                expire: 180,
-            });
-            (0, publish_1.publishEscalationEvent)({
-                type: 'escalation.resolved',
-                source: 'api',
-                workflowId: escalation.workflow_id,
-                workflowName: escalation.workflow_type,
-                taskQueue: escalation.task_queue,
-                taskId: escalation.task_id,
-                escalationId: escalation.id,
-                originId: escalation.origin_id ?? undefined,
-                status: 'resolved',
-            });
-            res.json({ started: true, escalationId: escalation.id, workflowId: newWorkflowId });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.resolveEscalation({ id: req.params.id, resolverPayload: req.body?.resolverPayload }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
 }

package/build/routes/escalations/single.js

@@ -34,10 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerSingleRoutes = registerSingleRoutes;
-const escalationService = __importStar(require("../../services/escalation"));
-const userService = __importStar(require("../../services/user"));
-const roleService = __importStar(require("../../services/role"));
-const publish_1 = require("../../lib/events/publish");
+const api = __importStar(require("../../api/escalations"));
 function registerSingleRoutes(router) {
     /**
      * PATCH /api/escalations/:id/escalate
@@ -45,51 +42,18 @@ function registerSingleRoutes(router) {
      * Body: { targetRole: string }
      */
     router.patch('/:id/escalate', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const { targetRole } = req.body || {};
-            if (!targetRole || typeof targetRole !== 'string') {
-                res.status(400).json({ error: 'targetRole is required' });
-                return;
-            }
-            const escalation = await escalationService.getEscalation(req.params.id);
-            if (!escalation) {
-                res.status(404).json({ error: 'Escalation not found' });
-                return;
-            }
-            if (escalation.status !== 'pending') {
-                res.status(409).json({ error: 'Escalation is not pending' });
-                return;
-            }
-            // Authorization: user must be able to escalate from current role to target role
-            const canEscalate = await roleService.canEscalateTo(userId, escalation.role, targetRole);
-            if (!canEscalate) {
-                res.status(403).json({ error: 'Not authorized to escalate to this role' });
-                return;
-            }
-            const updated = await escalationService.escalateToRole(req.params.id, targetRole);
-            if (!updated) {
-                res.status(409).json({ error: 'Escalation could not be updated' });
-                return;
-            }
-            res.json(updated);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.escalateToRole({ id: req.params.id, targetRole: req.body?.targetRole }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * GET /api/escalations/by-workflow/:workflowId
      * List escalations linked to a specific workflow.
      */
     router.get('/by-workflow/:workflowId', async (req, res) => {
-        try {
-            const escalations = await escalationService.getEscalationsByWorkflowId(req.params.workflowId);
-            res.json({ escalations });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.getEscalationsByWorkflowId({
+            workflowId: req.params.workflowId,
+        });
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     // -- Parameterized routes (must come after literal paths) --
     /**
@@ -98,26 +62,8 @@ function registerSingleRoutes(router) {
      * RBAC: superadmin sees all; others must hold the escalation's role.
      */
     router.get('/:id', async (req, res) => {
-        try {
-            const escalation = await escalationService.getEscalation(req.params.id);
-            if (!escalation) {
-                res.status(404).json({ error: 'Escalation not found' });
-                return;
-            }
-            const userId = req.auth.userId;
-            const isSuperAdminUser = await userService.isSuperAdmin(userId);
-            if (!isSuperAdminUser) {
-                const userHasRole = await userService.hasRole(userId, escalation.role);
-                if (!userHasRole) {
-                    res.status(403).json({ error: 'Not authorized to view this escalation' });
-                    return;
-                }
-            }
-            res.json(escalation);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.getEscalation({ id: req.params.id }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * POST /api/escalations/:id/claim
@@ -125,43 +71,8 @@ function registerSingleRoutes(router) {
      * Body: { durationMinutes?: number }
      */
     router.post('/:id/claim', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const { durationMinutes } = req.body || {};
-            // Role check: user must hold the escalation's role or be superadmin
-            const escalation = await escalationService.getEscalation(req.params.id);
-            if (!escalation) {
-                res.status(404).json({ error: 'Escalation not found' });
-                return;
-            }
-            const isSuperAdminUser = await userService.isSuperAdmin(userId);
-            if (!isSuperAdminUser) {
-                const userHasRole = await userService.hasRole(userId, escalation.role);
-                if (!userHasRole) {
-                    res.status(403).json({ error: `You must have the "${escalation.role}" role to claim this escalation` });
-                    return;
-                }
-            }
-            const result = await escalationService.claimEscalation(req.params.id, userId, durationMinutes);
-            if (!result) {
-                res.status(409).json({ error: 'Escalation not available for claim' });
-                return;
-            }
-            res.json(result);
-            (0, publish_1.publishEscalationEvent)({
-                type: 'escalation.claimed',
-                source: 'api',
-                workflowId: escalation.workflow_id || '',
-                workflowName: escalation.workflow_type || '',
-                taskQueue: escalation.task_queue || '',
-                escalationId: req.params.id,
-                status: 'claimed',
-                data: { assigned_to: userId },
-            });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.claimEscalation({ id: req.params.id, durationMinutes: req.body?.durationMinutes }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * POST /api/escalations/:id/release
@@ -169,27 +80,7 @@ function registerSingleRoutes(router) {
      * Only the assigned user may release their own claim.
      */
     router.post('/:id/release', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const result = await escalationService.releaseEscalation(req.params.id, userId);
-            if (!result) {
-                res.status(409).json({ error: 'Escalation not found or not claimed by you' });
-                return;
-            }
-            res.json({ escalation: result });
-            (0, publish_1.publishEscalationEvent)({
-                type: 'escalation.released',
-                source: 'api',
-                workflowId: result.workflow_id || '',
-                workflowName: result.workflow_type || '',
-                taskQueue: result.task_queue || '',
-                escalationId: req.params.id,
-                status: 'released',
-                data: { released_by: userId },
-            });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.releaseEscalation({ id: req.params.id }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
 }

package/build/routes/exports.js

@@ -34,130 +34,79 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
-const exportService = __importStar(require("../services/export"));
-const resolve_1 = require("./resolve");
+const api = __importStar(require("../api/exports"));
 const router = (0, express_1.Router)();
 /**
  * GET /api/workflow-states/jobs
  * List workflow jobs with optional filtering and pagination.
  */
 router.get('/jobs', async (req, res) => {
-    try {
-        const result = await exportService.listJobs({
-            limit: parseInt(req.query.limit) || undefined,
-            offset: parseInt(req.query.offset) || undefined,
-            entity: req.query.entity || undefined,
-            search: req.query.search || undefined,
-            status: req.query.status || undefined,
-            sort_by: req.query.sort_by || undefined,
-            order: req.query.order || undefined,
-            registered: req.query.registered || undefined,
-        });
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.listJobs({
+        limit: parseInt(req.query.limit) || undefined,
+        offset: parseInt(req.query.offset) || undefined,
+        entity: req.query.entity || undefined,
+        search: req.query.search || undefined,
+        status: req.query.status || undefined,
+        sort_by: req.query.sort_by || undefined,
+        order: req.query.order || undefined,
+        registered: req.query.registered || undefined,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/workflow-states/:workflowId
  * Export the full workflow state using HotMesh's durable export.
  */
 router.get('/:workflowId', async (req, res) => {
-    try {
-        const resolved = await (0, resolve_1.resolveHandle)(req, res);
-        if (!resolved)
-            return;
-        const allow = req.query.allow
-            ? req.query.allow.split(',')
-            : undefined;
-        const block = req.query.block
-            ? req.query.block.split(',')
-            : undefined;
-        const values = req.query.values === 'false' ? false : undefined;
-        const exported = await exportService.exportWorkflow(req.params.workflowId, resolved.taskQueue, resolved.workflowName, { allow, block, values });
-        res.json(exported);
-    }
-    catch (err) {
-        const msg = err.message ?? '';
-        if (msg.includes('not found') || msg.includes('undefined')) {
-            res.status(404).json({
-                error: 'Workflow data is no longer available (job may have expired)',
-            });
-            return;
-        }
-        res.status(500).json({ error: msg });
-    }
+    const allow = req.query.allow
+        ? req.query.allow.split(',')
+        : undefined;
+    const block = req.query.block
+        ? req.query.block.split(',')
+        : undefined;
+    const values = req.query.values === 'false' ? false : undefined;
+    const result = await api.exportWorkflowState({
+        workflowId: req.params.workflowId,
+        allow,
+        block,
+        values,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/workflow-states/:workflowId/execution
  * Export workflow state as a structured execution event history.
  */
 router.get('/:workflowId/execution', async (req, res) => {
-    try {
-        const resolved = await (0, resolve_1.resolveHandle)(req, res);
-        if (!resolved)
-            return;
-        const execution = await exportService.exportWorkflowExecution(req.params.workflowId, resolved.taskQueue, resolved.workflowName, {
-            exclude_system: req.query.excludeSystem === 'true',
-            omit_results: req.query.omitResults === 'true',
-            mode: req.query.mode || undefined,
-            max_depth: req.query.maxDepth
-                ? parseInt(req.query.maxDepth, 10)
-                : undefined,
-            enrich_inputs: true,
-        });
-        res.json(execution);
-    }
-    catch (err) {
-        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
-        res.status(status).json({
-            error: status === 404
-                ? 'Workflow data is no longer available (job may have expired)'
-                : err.message,
-        });
-    }
+    const result = await api.exportWorkflowExecution({
+        workflowId: req.params.workflowId,
+        excludeSystem: req.query.excludeSystem === 'true',
+        omitResults: req.query.omitResults === 'true',
+        mode: req.query.mode || undefined,
+        maxDepth: req.query.maxDepth
+            ? parseInt(req.query.maxDepth, 10)
+            : undefined,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/workflow-states/:workflowId/status
  * Return only the numeric status semaphore.
  */
 router.get('/:workflowId/status', async (req, res) => {
-    try {
-        const resolved = await (0, resolve_1.resolveHandle)(req, res);
-        if (!resolved)
-            return;
-        const result = await exportService.getWorkflowStatus(req.params.workflowId, resolved.taskQueue, resolved.workflowName);
-        res.json(result);
-    }
-    catch (err) {
-        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
-        res.status(status).json({
-            error: status === 404
-                ? 'Workflow data is no longer available (job may have expired)'
-                : err.message,
-        });
-    }
+    const result = await api.getWorkflowStatus({
+        workflowId: req.params.workflowId,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/workflow-states/:workflowId/state
  * Return the current job state of the workflow.
  */
 router.get('/:workflowId/state', async (req, res) => {
-    try {
-        const resolved = await (0, resolve_1.resolveHandle)(req, res);
-        if (!resolved)
-            return;
-        const result = await exportService.getWorkflowState(req.params.workflowId, resolved.taskQueue, resolved.workflowName);
-        res.json(result);
-    }
-    catch (err) {
-        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
-        res.status(status).json({
-            error: status === 404
-                ? 'Workflow data is no longer available (job may have expired)'
-                : err.message,
-        });
-    }
+    const result = await api.getWorkflowState({
+        workflowId: req.params.workflowId,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;

package/build/routes/index.js

@@ -26,6 +26,7 @@ const files_1 = __importDefault(require("./files"));
 const controlplane_1 = __importDefault(require("./controlplane"));
 const bot_accounts_1 = __importDefault(require("./bot-accounts"));
 const docs_1 = __importDefault(require("./docs"));
+const workflow_sets_1 = __importDefault(require("./workflow-sets"));
 const router = (0, express_1.Router)();
 // Public routes (no auth required — they handle their own auth)
 router.use('/auth', auth_2.default);
@@ -51,4 +52,5 @@ router.use('/namespaces', namespaces_1.default);
 router.use('/controlplane', controlplane_1.default);
 router.use('/bot-accounts', bot_accounts_1.default);
 router.use('/docs', docs_1.default);
+router.use('/workflow-sets', workflow_sets_1.default);
 exports.default = router;