@hotmeshio/long-tail 0.1.0

package/build/routes/escalations/resolve.js

@@ -0,0 +1,240 @@
+"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.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 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");
+function registerResolveRoutes(router) {
+    /**
+     * POST /api/escalations/:id/resolve
+     * Start a new workflow with resolver data to re-run the failed step.
+     * The interceptor in the new workflow resolves the escalation record
+     * and signals back to the orchestrator (if any) on success.
+     * 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 });
+        }
+    });
+}

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

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

package/build/routes/escalations/single.js

@@ -0,0 +1,195 @@
+"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.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");
+function registerSingleRoutes(router) {
+    /**
+     * PATCH /api/escalations/:id/escalate
+     * Reassign an escalation to a different role.
+     * 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 });
+        }
+    });
+    /**
+     * 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 });
+        }
+    });
+    // -- Parameterized routes (must come after literal paths) --
+    /**
+     * GET /api/escalations/:id
+     * Get a single escalation by ID.
+     * 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 });
+        }
+    });
+    /**
+     * POST /api/escalations/:id/claim
+     * Claim an escalation. userId comes from auth token.
+     * 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 });
+        }
+    });
+    /**
+     * POST /api/escalations/:id/release
+     * Release a claimed escalation back to the available pool.
+     * 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 });
+        }
+    });
+}

package/build/routes/exports.d.ts

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

package/build/routes/exports.js

@@ -0,0 +1,163 @@
+"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 exportService = __importStar(require("../services/export"));
+const resolve_1 = require("./resolve");
+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 });
+    }
+});
+/**
+ * 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 });
+    }
+});
+/**
+ * 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,
+        });
+    }
+});
+/**
+ * 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,
+        });
+    }
+});
+/**
+ * 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,
+        });
+    }
+});
+exports.default = router;

package/build/routes/files.d.ts

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

package/build/routes/files.js

@@ -0,0 +1,47 @@
+"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 path_1 = __importDefault(require("path"));
+const storage_1 = require("../services/storage");
+const router = (0, express_1.Router)();
+const MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.json': 'application/json',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.csv': 'text/csv',
+    '.xml': 'application/xml',
+};
+/**
+ * GET /api/files/*
+ * Serve files from managed file storage.
+ */
+router.get('/{*filePath}', async (req, res) => {
+    const raw = req.params.filePath;
+    const filePath = Array.isArray(raw) ? raw.join('/') : raw;
+    if (!filePath) {
+        res.status(400).json({ error: 'File path required' });
+        return;
+    }
+    try {
+        const stream = await (0, storage_1.getStorageBackend)().createReadStream(filePath);
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+        res.setHeader('Content-Type', contentType);
+        res.setHeader('Cache-Control', 'public, max-age=300');
+        stream.pipe(res);
+    }
+    catch {
+        res.status(404).json({ error: 'File not found' });
+    }
+});
+exports.default = router;

package/build/routes/index.d.ts

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