@hotmeshio/long-tail 0.1.4 → 0.1.6

package/build/routes/escalations/bulk.js

@@ -39,12 +39,41 @@ 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");
+const publish_1 = require("../../lib/events/publish");
+// ── Shared helpers ──────────────────────────────────────────────────────────
+function validateIds(ids) {
+    return Array.isArray(ids) && ids.length > 0;
+}
+async function requireBulkPermission(userId, ids, res) {
+    const isSuperAdminUser = await userService.isSuperAdmin(userId);
+    if (isSuperAdminUser)
+        return true;
+    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 false;
+        }
+    }
+    return true;
+}
+function publishBulkClaimEvents(ids, assignedTo) {
+    for (const id of ids) {
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.claimed',
+            source: 'api',
+            workflowId: '',
+            workflowName: '',
+            taskQueue: '',
+            escalationId: id,
+            status: 'claimed',
+            data: { assigned_to: assignedTo, bulk: true },
+        });
+    }
+}
+// ── Routes ──────────────────────────────────────────────────────────────────
 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();
@@ -54,38 +83,15 @@ function registerBulkRoutes(router) {
             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' });
+            if (!validateIds(ids))
+                return res.status(400).json({ error: 'ids must be a non-empty array' });
+            if (![1, 2, 3, 4].includes(priority))
+                return res.status(400).json({ error: 'priority must be 1, 2, 3, or 4' });
+            if (!await requireBulkPermission(req.auth.userId, ids, res))
                 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 });
         }
@@ -93,138 +99,62 @@ function registerBulkRoutes(router) {
             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' });
+            if (!validateIds(ids))
+                return res.status(400).json({ error: 'ids must be a non-empty array' });
+            if (!await requireBulkPermission(userId, ids, res))
                 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 },
-                    });
-                }
-            }
+            if (result.claimed > 0)
+                publishBulkClaimEvents(ids, userId);
         }
         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' });
+            if (!validateIds(ids))
+                return res.status(400).json({ error: 'ids must be a non-empty array' });
+            if (!targetUserId || typeof targetUserId !== 'string')
+                return res.status(400).json({ error: 'targetUserId is required' });
+            if (!await requireBulkPermission(userId, ids, res))
                 return;
-            }
-            if (!targetUserId || typeof targetUserId !== 'string') {
-                res.status(400).json({ error: 'targetUserId is required' });
-                return;
-            }
+            // Non-superadmin: target user must hold each escalation's role
             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
+                const roles = await escalationService.getEscalationRoles(ids);
                 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;
+                        return res.status(400).json({ error: `Target user does not hold the "${role}" role` });
                     }
                 }
             }
             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 },
-                    });
-                }
-            }
+            if (result.assigned > 0)
+                publishBulkClaimEvents(ids, targetUserId);
         }
         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' });
+            if (!validateIds(ids))
+                return res.status(400).json({ error: 'ids must be a non-empty array' });
+            if (!targetRole || typeof targetRole !== 'string')
+                return res.status(400).json({ error: 'targetRole is required' });
+            if (!await requireBulkPermission(req.auth.userId, ids, res))
                 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 });
         }
@@ -232,87 +162,18 @@ function registerBulkRoutes(router) {
             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' });
+            if (!validateIds(ids))
+                return res.status(400).json({ error: 'ids must be a non-empty array' });
+            if (!await requireBulkPermission(req.auth.userId, ids, res))
                 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',
-                });
+                const triageWorkflowId = await startTriageWorkflow(escalation, hint, req.auth?.userId, client);
                 workflowIds.push(triageWorkflowId);
             }
             res.json({ triaged: resolved.length, workflows: workflowIds });
@@ -322,3 +183,60 @@ function registerBulkRoutes(router) {
         }
     });
 }
+// ── Triage workflow launcher ────────────────────────────────────────────────
+async function startTriageWorkflow(escalation, hint, userId, client) {
+    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 },
+    };
+    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',
+    });
+    return triageWorkflowId;
+}

package/build/routes/escalations/resolve.js

@@ -37,7 +37,7 @@ 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("../../services/events/publish");
+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");

package/build/routes/escalations/single.js

@@ -37,7 +37,7 @@ 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("../../services/events/publish");
+const publish_1 = require("../../lib/events/publish");
 function registerSingleRoutes(router) {
     /**
      * PATCH /api/escalations/:id/escalate

package/build/routes/files.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const path_1 = __importDefault(require("path"));
-const storage_1 = require("../services/storage");
+const storage_1 = require("../lib/storage");
 const router = (0, express_1.Router)();
 const MIME_TYPES = {
     '.png': 'image/png',

package/build/routes/index.js

@@ -25,6 +25,7 @@ const namespaces_1 = __importDefault(require("./namespaces"));
 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 router = (0, express_1.Router)();
 // Public routes (no auth required — they handle their own auth)
 router.use('/auth', auth_2.default);
@@ -49,4 +50,5 @@ router.use('/mcp-runs', mcp_runs_1.default);
 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);
 exports.default = router;

package/build/routes/insight.js

@@ -10,7 +10,7 @@ const router = (0, express_1.Router)();
  */
 router.post('/mcp-query', async (req, res) => {
     try {
-        const { prompt, tags, wait, direct } = req.body;
+        const { prompt, tags, wait, direct, context } = req.body;
         if (!prompt || typeof prompt !== 'string') {
             res.status(400).json({ error: 'prompt is required' });
             return;
@@ -24,6 +24,7 @@ router.post('/mcp-query', async (req, res) => {
             tags,
             wait,
             direct,
+            context,
             userId: req.auth?.userId,
         });
         res.json(result);
@@ -36,6 +37,69 @@ router.post('/mcp-query', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+/**
+ * POST /api/insight/build-workflow
+ * Build a HotMesh YAML DAG directly from a natural language description.
+ * The LLM reasons about tool schemas and constructs the YAML declaratively.
+ * Body: { prompt: string, tags?: string[], wait?: boolean, feedback?: string, prior_yaml?: string }
+ */
+router.post('/build-workflow', async (req, res) => {
+    try {
+        const { prompt, tags, wait, feedback, prior_yaml, answers, prior_questions } = req.body;
+        if (!prompt || typeof prompt !== 'string') {
+            res.status(400).json({ error: 'prompt is required' });
+            return;
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            res.status(503).json({ error: 'Workflow builder requires an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY)' });
+            return;
+        }
+        const result = await (0, insight_1.startWorkflowBuilder)({
+            prompt,
+            tags,
+            wait,
+            feedback,
+            prior_yaml,
+            answers,
+            prior_questions,
+            userId: req.auth?.userId,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        if (err.message?.includes('timeout') || err.message?.includes('TIMEOUT')) {
+            res.status(504).json({ error: 'Workflow builder timed out. Try a simpler description.' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/insight/build-workflow/refine
+ * Refine a previously built workflow using execution feedback.
+ * Body: { prompt: string, prior_yaml: string, feedback: string, tags?: string[], wait?: boolean }
+ */
+router.post('/build-workflow/refine', async (req, res) => {
+    try {
+        const { prompt, prior_yaml, feedback, tags, wait } = req.body;
+        if (!prompt || !prior_yaml || !feedback) {
+            res.status(400).json({ error: 'prompt, prior_yaml, and feedback are required' });
+            return;
+        }
+        const result = await (0, insight_1.startWorkflowBuilder)({
+            prompt,
+            tags,
+            wait,
+            feedback,
+            prior_yaml,
+            userId: req.auth?.userId,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 /**
  * POST /api/insight/mcp-query/describe
  * Generate a workflow description and suggested tags from prompt and result.

package/build/routes/mcp.js

@@ -66,7 +66,7 @@ router.get('/servers', async (req, res) => {
  */
 router.post('/servers', async (req, res) => {
     try {
-        const { name, description, transport_type, transport_config, auto_connect, metadata } = req.body;
+        const { name, description, transport_type, transport_config, auto_connect, metadata, tags, compile_hints, credential_providers } = req.body;
         if (!name || !transport_type || !transport_config) {
             res.status(400).json({ error: 'name, transport_type, and transport_config are required' });
             return;
@@ -78,6 +78,9 @@ router.post('/servers', async (req, res) => {
             transport_config,
             auto_connect,
             metadata,
+            tags,
+            compile_hints,
+            credential_providers,
         });
         res.status(201).json(server);
     }
@@ -89,6 +92,25 @@ router.post('/servers', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+/**
+ * POST /api/mcp/servers/test-connection
+ * Test connectivity to an MCP server without persisting it.
+ */
+router.post('/servers/test-connection', async (req, res) => {
+    try {
+        const { transport_type, transport_config } = req.body;
+        if (!transport_type || !transport_config) {
+            res.status(400).json({ error: 'transport_type and transport_config are required' });
+            return;
+        }
+        const { testConnection } = await Promise.resolve().then(() => __importStar(require('../services/mcp/client/connection')));
+        const result = await testConnection(transport_type, transport_config);
+        res.json(result);
+    }
+    catch (err) {
+        res.json({ success: false, error: err.message, tools: [] });
+    }
+});
 // ── Parameterized routes (must come after literal paths) ──────────────
 /**
  * GET /api/mcp/servers/:id
@@ -243,8 +265,9 @@ router.post('/servers/:id/tools/:toolName/call', async (req, res) => {
             res.status(400).json({ error: 'MCP adapter not registered' });
             return;
         }
-        const authContext = req.auth?.userId
-            ? { userId: req.auth.userId }
+        const executeAs = req.body.execute_as;
+        const authContext = (executeAs || req.auth?.userId)
+            ? { userId: executeAs || req.auth?.userId }
             : undefined;
         const result = await adapter.callTool(req.params.id, req.params.toolName, req.body.arguments || {}, authContext);
         res.json({ result });

package/build/routes/oauth.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setOAuthConfig = setOAuthConfig;
 const express_1 = require("express");
 const auth_1 = require("../modules/auth");
-const logger_1 = require("../services/logger");
+const logger_1 = require("../lib/logger");
 const oauth_1 = require("../services/oauth");
 const user_1 = require("../services/user");
 const router = (0, express_1.Router)();

package/build/routes/settings.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
-const telemetry_1 = require("../services/telemetry");
-const events_1 = require("../services/events");
-const nats_1 = require("../services/events/nats");
-const socketio_1 = require("../services/events/socketio");
+const telemetry_1 = require("../lib/telemetry");
+const events_1 = require("../lib/events");
+const nats_1 = require("../lib/events/nats");
+const socketio_1 = require("../lib/events/socketio");
 const defaults_1 = require("../modules/defaults");
 const router = (0, express_1.Router)();
 /**

package/build/routes/workflows/discovery.js

@@ -36,8 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const configService = __importStar(require("../../services/config"));
 const cron_1 = require("../../services/cron");
-const db_1 = require("../../services/db");
+const db_1 = require("../../lib/db");
 const registry_1 = require("../../services/workers/registry");
+const sql_1 = require("../../services/mcp-runs/sql");
 const router = (0, express_1.Router)();
 // ── Active workers ───────────────────────────────────────────────────────────
 /**
@@ -78,9 +79,8 @@ router.get('/discovered', async (req, res) => {
         // 1. Active workers from in-memory registry
         const activeWorkers = (0, registry_1.getRegisteredWorkers)();
         // 2. Historical entities from durable.jobs
-        const DISTINCT_ENTITIES = `SELECT DISTINCT entity FROM durable.jobs WHERE entity IS NOT NULL AND entity != '' ORDER BY entity`;
         const pool = (0, db_1.getPool)();
-        const { rows: entityRows } = await pool.query(DISTINCT_ENTITIES);
+        const { rows: entityRows } = await pool.query(sql_1.DISTINCT_ENTITIES_DURABLE);
         const historicalEntities = new Set(entityRows.map((r) => r.entity));
         // 3. Registered configs
         const configs = await configService.listWorkflowConfigs();

package/build/routes/workflows/invocation.js

@@ -136,7 +136,7 @@ router.post('/:workflowId/terminate', async (req, res) => {
             return;
         const client = (0, workers_1.createClient)();
         const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, req.params.workflowId);
-        await handle.interrupt();
+        await handle.terminate();
         res.json({ terminated: true, workflowId: req.params.workflowId });
     }
     catch (err) {

package/build/routes/yaml-workflows/cron.d.ts

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