@hotmeshio/long-tail 0.1.0

package/build/routes/users.js

@@ -0,0 +1,206 @@
+"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 });
+const express_1 = require("express");
+const auth_1 = require("../modules/auth");
+const userService = __importStar(require("../services/user"));
+const router = (0, express_1.Router)();
+// ── User CRUD ─────────────────────────────────────────────────────────────────
+/**
+ * GET /api/users
+ * List users with optional filters.
+ * Query: ?role=reviewer&roleType=admin&status=active&limit=50&offset=0
+ */
+router.get('/', async (req, res) => {
+    try {
+        const result = await userService.listUsers({
+            role: req.query.role,
+            roleType: req.query.roleType,
+            status: req.query.status,
+            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/users/:id
+ * Get a single user by ID.
+ */
+router.get('/:id', async (req, res) => {
+    try {
+        const user = await userService.getUser(req.params.id);
+        if (!user) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        res.json(user);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/users
+ * Create a new user.
+ * Body: { external_id, email?, display_name?, roles?: [{ role, type }], metadata? }
+ */
+router.post('/', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const { external_id, email, display_name, roles, metadata } = req.body || {};
+        if (!external_id) {
+            res.status(400).json({ error: 'external_id is required' });
+            return;
+        }
+        if (roles) {
+            for (const r of roles) {
+                if (!r.role || !r.type || !userService.isValidRoleType(r.type)) {
+                    res.status(400).json({
+                        error: 'Each role must have a role name and type (superadmin, admin, member)',
+                    });
+                    return;
+                }
+            }
+        }
+        const user = await userService.createUser({
+            external_id,
+            email,
+            display_name,
+            roles,
+            metadata,
+        });
+        res.status(201).json(user);
+    }
+    catch (err) {
+        if (err.code === '23505') {
+            res.status(409).json({ error: 'User with this external_id already exists' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * PUT /api/users/:id
+ * Update a user.
+ * Body: { email?, display_name?, status?, metadata? }
+ */
+router.put('/:id', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const user = await userService.updateUser(req.params.id, req.body || {});
+        if (!user) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        res.json(user);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * DELETE /api/users/:id
+ * Delete a user.
+ */
+router.delete('/:id', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const deleted = await userService.deleteUser(req.params.id);
+        if (!deleted) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        res.json({ deleted: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Role management ─────────────────────────────────────────────────────────
+/**
+ * GET /api/users/:id/roles
+ * Get all roles for a user.
+ */
+router.get('/:id/roles', async (req, res) => {
+    try {
+        const roles = await userService.getUserRoles(req.params.id);
+        res.json({ roles });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/users/:id/roles
+ * Add a role to a user.
+ * Body: { role, type } — type must be superadmin, admin, or member
+ */
+router.post('/:id/roles', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const { role, type } = req.body || {};
+        if (!role || !type) {
+            res.status(400).json({ error: 'role and type are required' });
+            return;
+        }
+        if (!userService.isValidRoleType(type)) {
+            res.status(400).json({ error: 'type must be superadmin, admin, or member' });
+            return;
+        }
+        const result = await userService.addUserRole(req.params.id, role, type);
+        res.status(201).json(result);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * DELETE /api/users/:id/roles/:role
+ * Remove a role from a user.
+ */
+router.delete('/:id/roles/:role', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const removed = await userService.removeUserRole(req.params.id, req.params.role);
+        if (!removed) {
+            res.status(404).json({ error: 'Role not found' });
+            return;
+        }
+        res.json({ removed: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/workflows/config.d.ts

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

package/build/routes/workflows/config.js

@@ -0,0 +1,123 @@
+"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 });
+const express_1 = require("express");
+const configService = __importStar(require("../../services/config"));
+const auth_1 = require("../../modules/auth");
+const ltconfig_1 = require("../../modules/ltconfig");
+const cron_1 = require("../../services/cron");
+const router = (0, express_1.Router)();
+// ── Workflow configuration ────────────────────────────────────────────────────
+/**
+ * GET /api/workflows/config
+ * List all workflow configurations.
+ */
+router.get('/config', async (_req, res) => {
+    try {
+        const configs = await configService.listWorkflowConfigs();
+        res.json({ workflows: configs });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/workflows/:type/config
+ * Get a single workflow configuration.
+ */
+router.get('/:type/config', async (req, res) => {
+    try {
+        const config = await configService.getWorkflowConfig(req.params.type);
+        if (!config) {
+            res.status(404).json({ error: 'Workflow config not found' });
+            return;
+        }
+        res.json(config);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * PUT /api/workflows/:type/config
+ * Create or replace a workflow configuration.
+ * Requires admin or superadmin role.
+ */
+router.put('/:type/config', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const config = await configService.upsertWorkflowConfig({
+            workflow_type: req.params.type,
+            invocable: req.body.invocable ?? false,
+            task_queue: req.body.task_queue ?? null,
+            default_role: req.body.default_role ?? 'reviewer',
+            description: req.body.description ?? null,
+            execute_as: req.body.execute_as ?? null,
+            roles: req.body.roles ?? [],
+            invocation_roles: req.body.invocation_roles ?? [],
+            consumes: req.body.consumes ?? [],
+            tool_tags: req.body.tool_tags ?? [],
+            envelope_schema: req.body.envelope_schema ?? null,
+            resolver_schema: req.body.resolver_schema ?? null,
+            cron_schedule: req.body.cron_schedule ?? null,
+        });
+        ltconfig_1.ltConfig.invalidate();
+        // Restart cron if schedule changed
+        await cron_1.cronRegistry.restartCron(config);
+        res.json(config);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * DELETE /api/workflows/:type/config
+ * Delete a workflow configuration and all sub-entities (cascade).
+ * Requires admin or superadmin role.
+ */
+router.delete('/:type/config', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const deleted = await configService.deleteWorkflowConfig(req.params.type);
+        if (!deleted) {
+            res.status(404).json({ error: 'Workflow config not found' });
+            return;
+        }
+        ltconfig_1.ltConfig.invalidate();
+        res.json({ deleted: true, workflow_type: req.params.type });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/workflows/discovery.d.ts

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

package/build/routes/workflows/discovery.js

@@ -0,0 +1,146 @@
+"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 });
+const express_1 = require("express");
+const configService = __importStar(require("../../services/config"));
+const cron_1 = require("../../services/cron");
+const db_1 = require("../../services/db");
+const registry_1 = require("../../services/workers/registry");
+const router = (0, express_1.Router)();
+// ── Active workers ───────────────────────────────────────────────────────────
+/**
+ * GET /api/workflows/workers
+ * Returns in-memory active workers with their registration status.
+ * System workflows excluded unless ?include_system=true.
+ */
+router.get('/workers', async (req, res) => {
+    try {
+        const includeSystem = req.query.include_system === 'true';
+        const activeWorkers = (0, registry_1.getRegisteredWorkers)();
+        const configs = await configService.listWorkflowConfigs();
+        const registeredTypes = new Set(configs.map((c) => c.workflow_type));
+        const workers = [...activeWorkers.entries()]
+            .filter(([name]) => includeSystem || !registry_1.SYSTEM_WORKFLOWS.has(name))
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, { taskQueue }]) => ({
+            name,
+            task_queue: taskQueue,
+            registered: registeredTypes.has(name),
+            system: registry_1.SYSTEM_WORKFLOWS.has(name),
+        }));
+        res.json({ workers });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Discovered workflows ─────────────────────────────────────────────────────
+/**
+ * GET /api/workflows/discovered
+ * Merges active workers, historical entities, and registered configs
+ * into a unified list. System workflows excluded unless ?include_system=true.
+ */
+router.get('/discovered', async (req, res) => {
+    try {
+        const includeSystem = req.query.include_system === 'true';
+        // 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 historicalEntities = new Set(entityRows.map((r) => r.entity));
+        // 3. Registered configs
+        const configs = await configService.listWorkflowConfigs();
+        const configMap = new Map(configs.map((c) => [c.workflow_type, c]));
+        // Build unified set of all workflow types
+        const allTypes = new Set();
+        for (const [name] of activeWorkers)
+            allTypes.add(name);
+        for (const entity of historicalEntities)
+            allTypes.add(entity);
+        for (const c of configs)
+            allTypes.add(c.workflow_type);
+        const workflows = [...allTypes]
+            .filter((t) => includeSystem || !registry_1.SYSTEM_WORKFLOWS.has(t))
+            .sort()
+            .map((workflowType) => {
+            const config = configMap.get(workflowType);
+            const worker = activeWorkers.get(workflowType);
+            return {
+                workflow_type: workflowType,
+                task_queue: config?.task_queue ?? worker?.taskQueue ?? null,
+                registered: !!config,
+                active: !!worker,
+                invocable: config?.invocable ?? !!worker,
+                system: registry_1.SYSTEM_WORKFLOWS.has(workflowType),
+                description: config?.description ?? null,
+                roles: config?.roles ?? [],
+                invocation_roles: config?.invocation_roles ?? [],
+                execute_as: config?.execute_as ?? null,
+            };
+        });
+        res.json({ workflows });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Cron status ─────────────────────────────────────────────────────────────
+/**
+ * GET /api/workflows/cron/status
+ * List all cron-configured workflows and whether each is actively running.
+ */
+router.get('/cron/status', async (_req, res) => {
+    try {
+        const configs = await configService.listWorkflowConfigs();
+        const cronConfigs = configs.filter((c) => c.cron_schedule);
+        const activeTypes = cron_1.cronRegistry.activeWorkflowTypes;
+        const schedules = cronConfigs.map((c) => ({
+            workflow_type: c.workflow_type,
+            cron_schedule: c.cron_schedule,
+            description: c.description,
+            task_queue: c.task_queue,
+            invocable: c.invocable,
+            active: activeTypes.includes(c.workflow_type),
+            envelope_schema: c.envelope_schema,
+        }));
+        res.json({ schedules });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

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

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

package/build/routes/workflows/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const discovery_1 = __importDefault(require("./discovery"));
+const config_1 = __importDefault(require("./config"));
+const invocation_1 = __importDefault(require("./invocation"));
+const router = (0, express_1.Router)();
+// Mount in original route registration order:
+// 1. Discovery: /workers, /discovered, /cron/status
+router.use(discovery_1.default);
+// 2. Config: /config, /:type/config (GET, PUT, DELETE)
+router.use(config_1.default);
+// 3. Invocation & observation: /:type/invoke, /:workflowId/*
+router.use(invocation_1.default);
+exports.default = router;

package/build/routes/workflows/invocation.d.ts

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

package/build/routes/workflows/invocation.js

@@ -0,0 +1,162 @@
+"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 });
+const express_1 = require("express");
+const workers_1 = require("../../workers");
+const exportService = __importStar(require("../../services/export"));
+const resolve_1 = require("../resolve");
+const workflow_invocation_1 = require("../../services/workflow-invocation");
+const router = (0, express_1.Router)();
+// ── Workflow invocation ─────────────────────────────────────────────────────
+/**
+ * POST /api/workflows/:type/invoke
+ * Start a workflow by its registered type.
+ *
+ * The workflow must have `invocable: true` in its config. If the config
+ * includes `invocation_roles`, the authenticated user must hold at least
+ * one of those roles. When invocation_roles is empty, any authenticated
+ * user can invoke.
+ *
+ * Body: { data: Record<string, any>, metadata?: Record<string, any> }
+ */
+router.post('/:type/invoke', async (req, res) => {
+    try {
+        const workflowType = req.params.type;
+        const userId = req.auth?.userId ?? '';
+        // Role check (requires DB lookup, kept separate from core invoke)
+        await (0, workflow_invocation_1.checkInvocationRoles)(workflowType, userId);
+        const { data, metadata, execute_as: executeAs } = req.body || {};
+        const result = await (0, workflow_invocation_1.invokeWorkflow)({
+            workflowType,
+            data,
+            metadata,
+            executeAs,
+            auth: {
+                userId,
+                role: req.auth?.role,
+                scopes: req.auth?.scopes,
+            },
+        });
+        res.status(202).json({
+            workflowId: result.workflowId,
+            message: 'Workflow started',
+        });
+    }
+    catch (err) {
+        const status = err instanceof workflow_invocation_1.InvocationError ? err.statusCode : 500;
+        res.status(status).json({ error: err.message });
+    }
+});
+// ── Workflow observation ────────────────────────────────────────────────────
+/**
+ * GET /api/workflows/:workflowId/status
+ * Get the status of a workflow. Only the workflowId is needed.
+ */
+router.get('/:workflowId/status', async (req, res) => {
+    try {
+        const resolved = await (0, resolve_1.resolveHandle)(req, res);
+        if (!resolved)
+            return;
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, req.params.workflowId);
+        const status = await handle.status();
+        res.json({ workflowId: req.params.workflowId, status });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/workflows/:workflowId/result
+ * Return the workflow result if complete, or 202 if still running.
+ * Never blocks — always returns immediately.
+ */
+router.get('/:workflowId/result', async (req, res) => {
+    try {
+        const resolved = await (0, resolve_1.resolveHandle)(req, res);
+        if (!resolved)
+            return;
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, req.params.workflowId);
+        const status = await handle.status();
+        if (status !== 0) {
+            res.status(202).json({
+                workflowId: req.params.workflowId,
+                status: 'running',
+            });
+            return;
+        }
+        const result = await handle.result();
+        res.json({ workflowId: req.params.workflowId, result });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/workflows/:workflowId/terminate
+ * Interrupt/terminate a running workflow.
+ */
+router.post('/:workflowId/terminate', async (req, res) => {
+    try {
+        const resolved = await (0, resolve_1.resolveHandle)(req, res);
+        if (!resolved)
+            return;
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, req.params.workflowId);
+        await handle.interrupt();
+        res.json({ terminated: true, workflowId: req.params.workflowId });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/workflows/:workflowId/export
+ * Export workflow state. Convenience alias for /api/workflow-states/:workflowId.
+ */
+router.get('/:workflowId/export', async (req, res) => {
+    try {
+        const resolved = await (0, resolve_1.resolveHandle)(req, res);
+        if (!resolved)
+            return;
+        const exported = await exportService.exportWorkflow(req.params.workflowId, resolved.taskQueue, resolved.workflowName);
+        res.json(exported);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

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

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