@jagilber-org/index-server 1.19.1

package/dist/dashboard/server/routes/messaging.routes.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * Messaging Routes — Dashboard REST API for inter-agent messaging.
+ *
+ * Routes:
+ *   POST   /api/messages           — send a message
+ *   GET    /api/messages/channels   — list channels
+ *   GET    /api/messages/stats      — reader stats
+ *   GET    /api/messages/:channel   — read messages from channel
+ *   POST   /api/messages/ack        — acknowledge messages
+ *   GET    /api/messages/by-id/:id  — get message by ID
+ *   PUT    /api/messages/by-id/:id  — update message
+ *   DELETE /api/messages            — purge messages
+ *   POST   /api/messages/inbound    — peer inbound (cross-instance)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessagingRoutes = createMessagingRoutes;
+const express_1 = require("express");
+const agentMailbox_js_1 = require("../../../services/messaging/agentMailbox.js");
+const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
+const messagingTypes_js_1 = require("../../../services/messaging/messagingTypes.js");
+const WebSocketManager_js_1 = require("../WebSocketManager.js");
+let _mailbox = null;
+function getMailbox() {
+    if (!_mailbox) {
+        _mailbox = new agentMailbox_js_1.AgentMailbox((0, runtimeConfig_js_1.getRuntimeConfig)().messaging);
+    }
+    return _mailbox;
+}
+/** Format Zod issues with field paths for actionable error messages. */
+function formatZodIssues(issues) {
+    return issues.map(i => {
+        const field = i.path.length ? i.path.join('.') : 'body';
+        return `${field}: ${i.message}`;
+    });
+}
+const SEND_SCHEMA_HINT = {
+    required: { channel: 'string', sender: 'string', recipients: 'string[]', body: 'string' },
+    optional: { priority: 'low|normal|high|critical', ttlSeconds: 'number (1-86400)', persistent: 'boolean', payload: 'object', parentId: 'string', tags: 'string[]', requiresAck: 'boolean', ackBySeconds: 'number' },
+};
+function createMessagingRoutes() {
+    const router = (0, express_1.Router)();
+    // POST /api/messages — send a message
+    router.post('/messages', (req, res) => {
+        try {
+            const parsed = messagingTypes_js_1.SendMessageOptionsSchema.safeParse(req.body);
+            if (!parsed.success) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Invalid message payload',
+                    issues: formatZodIssues(parsed.error.issues),
+                    hint: 'POST /api/messages expects a JSON body with required fields: channel, sender, recipients, body',
+                    schema: SEND_SCHEMA_HINT,
+                });
+                return;
+            }
+            const mailbox = getMailbox();
+            mailbox.send(parsed.data).then(messageId => {
+                try {
+                    (0, WebSocketManager_js_1.getWebSocketManager)().broadcast({ type: 'message_received', timestamp: Date.now(), data: { messageId, channel: parsed.data.channel } });
+                }
+                catch { /* ws optional */ }
+                res.status(201).json({
+                    success: true,
+                    messageId,
+                    channel: parsed.data.channel,
+                    status: 'sent',
+                });
+            }).catch(err => {
+                res.status(500).json({ success: false, error: err instanceof Error ? err.message : 'Send failed' });
+            });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // GET /api/messages/channels — list all channels
+    router.get('/messages/channels', (_req, res) => {
+        try {
+            const mailbox = getMailbox();
+            const channels = mailbox.listChannels();
+            res.json({ success: true, count: channels.length, channels });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // GET /api/messages/stats — reader stats
+    router.get('/messages/stats', (req, res) => {
+        try {
+            const reader = req.query.reader || '*';
+            const mailbox = getMailbox();
+            const stats = mailbox.getStats(reader);
+            res.json({ success: true, reader, ...stats });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // GET /api/messages/by-id/:id — get message by ID
+    router.get('/messages/by-id/:id', (req, res) => {
+        try {
+            const mailbox = getMailbox();
+            const message = mailbox.getMessage(req.params.id);
+            if (!message) {
+                res.status(404).json({ success: false, error: `Message not found: ${req.params.id}`, hint: 'Use GET /api/messages/channels to list channels, then GET /api/messages/:channel to browse messages' });
+                return;
+            }
+            res.json({ success: true, message });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // PUT /api/messages/by-id/:id — update message
+    router.put('/messages/by-id/:id', (req, res) => {
+        try {
+            const mailbox = getMailbox();
+            const updated = mailbox.updateMessage(req.params.id, {
+                body: req.body.body,
+                recipients: req.body.recipients,
+                payload: req.body.payload,
+                persistent: req.body.persistent,
+            });
+            if (!updated) {
+                res.status(404).json({ success: false, error: `Message not found: ${req.params.id}`, hint: 'Use GET /api/messages/by-id/:id to verify the message exists before updating' });
+                return;
+            }
+            try {
+                (0, WebSocketManager_js_1.getWebSocketManager)().broadcast({ type: 'message_received', timestamp: Date.now(), data: { messageId: req.params.id } });
+            }
+            catch { /* ws optional */ }
+            res.json({ success: true, message: updated });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // GET /api/messages/thread/:parentId — get full thread
+    router.get('/messages/thread/:parentId', (req, res) => {
+        try {
+            const parentId = decodeURIComponent(req.params.parentId);
+            const mailbox = getMailbox();
+            const thread = mailbox.getThread(parentId);
+            if (!thread || thread.length === 0) {
+                res.status(404).json({ success: false, error: `No thread found for parentId: ${parentId}` });
+                return;
+            }
+            res.json({ success: true, parentId, count: thread.length, messages: thread });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // GET /api/messages/:channel — read messages from channel
+    router.get('/messages/:channel', (req, res) => {
+        try {
+            const channel = decodeURIComponent(req.params.channel);
+            const reader = req.query.reader || '*';
+            const unreadOnly = req.query.unreadOnly === 'true';
+            const limit = req.query.limit ? parseInt(req.query.limit, 10) : undefined;
+            const markRead = req.query.markRead === 'true';
+            const tags = req.query.tags ? req.query.tags.split(',').map(t => t.trim()).filter(Boolean) : undefined;
+            const sender = req.query.sender || undefined;
+            const mailbox = getMailbox();
+            const messages = mailbox.read({ channel, reader, unreadOnly, limit, markRead, tags, sender });
+            res.json({ success: true, channel, reader, count: messages.length, messages });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // POST /api/messages/ack — acknowledge messages
+    router.post('/messages/ack', (req, res) => {
+        try {
+            const { messageIds, reader } = req.body;
+            if (!Array.isArray(messageIds) || !reader) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Invalid ack request',
+                    issues: [
+                        ...(!Array.isArray(messageIds) ? ['messageIds: must be a non-empty array of message ID strings'] : []),
+                        ...(!reader ? ['reader: must be a non-empty string identifying the acknowledging agent'] : []),
+                    ],
+                    hint: 'POST /api/messages/ack expects { "messageIds": ["msg-..."], "reader": "agent-name" }',
+                });
+                return;
+            }
+            const mailbox = getMailbox();
+            const acknowledged = mailbox.ack(messageIds, reader);
+            res.json({ success: true, acknowledged, reader });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // DELETE /api/messages — purge messages
+    router.delete('/messages', (req, res) => {
+        try {
+            const mailbox = getMailbox();
+            let removed = 0;
+            let action = 'none';
+            if (req.body?.messageIds?.length) {
+                removed = mailbox.deleteMessages(req.body.messageIds);
+                action = 'delete_by_ids';
+            }
+            else if (req.body?.channel) {
+                removed = mailbox.purgeChannel(req.body.channel);
+                action = 'purge_channel';
+            }
+            else {
+                removed = mailbox.purgeAll();
+                action = 'purge_all';
+            }
+            try {
+                (0, WebSocketManager_js_1.getWebSocketManager)().broadcast({ type: 'message_purged', timestamp: Date.now(), data: { count: removed } });
+            }
+            catch { /* ws optional */ }
+            res.json({ success: true, action, purged: removed });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // POST /api/messages/inbound — receive message from peer instance
+    router.post('/messages/inbound', (req, res) => {
+        try {
+            if (!req.body || !req.body.id || !req.body.channel) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Invalid inbound message',
+                    issues: [
+                        ...(!req.body?.id ? ['id: required — unique message identifier'] : []),
+                        ...(!req.body?.channel ? ['channel: required — target channel name'] : []),
+                    ],
+                    hint: 'POST /api/messages/inbound expects { "id": "...", "channel": "...", "sender": "...", "body": "..." }',
+                });
+                return;
+            }
+            const mailbox = getMailbox();
+            mailbox.send({
+                channel: req.body.channel,
+                sender: req.body.sender || 'peer',
+                recipients: req.body.recipients || ['*'],
+                body: req.body.body || '',
+                ttlSeconds: req.body.ttlSeconds,
+                persistent: req.body.persistent,
+                payload: req.body.payload,
+                priority: req.body.priority,
+                parentId: req.body.parentId,
+                tags: req.body.tags,
+            }).then(() => {
+                try {
+                    (0, WebSocketManager_js_1.getWebSocketManager)().broadcast({ type: 'message_received', timestamp: Date.now(), data: { channel: req.body.channel } });
+                }
+                catch { /* ws optional */ }
+                res.json({ success: true, status: 'received' });
+            }).catch(err => {
+                res.status(500).json({ success: false, error: err instanceof Error ? err.message : 'Inbound failed' });
+            });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    // POST /api/messages/reply — reply to a message
+    router.post('/messages/reply', async (req, res) => {
+        try {
+            const { parentId, sender, body, replyAll, recipients, priority, tags, persistent, payload } = req.body || {};
+            if (!parentId || !sender || !body) {
+                res.status(400).json({
+                    success: false,
+                    error: 'Missing required fields: parentId, sender, body',
+                    hint: 'POST /api/messages/reply expects { "parentId": "...", "sender": "...", "body": "...", "replyAll": false }',
+                });
+                return;
+            }
+            const mailbox = getMailbox();
+            const result = await mailbox.reply(parentId, sender, body, { replyAll, recipients, priority, tags, persistent, payload });
+            try {
+                (0, WebSocketManager_js_1.getWebSocketManager)().broadcast({ type: 'message_received', timestamp: Date.now(), data: { channel: result.channel } });
+            }
+            catch { /* ws optional */ }
+            res.json({ success: true, message: result });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            const status = msg.includes('not found') ? 404 : 500;
+            res.status(status).json({ success: false, error: msg });
+        }
+    });
+    return router;
+}

package/dist/dashboard/server/routes/metrics.routes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Metrics & Analytics Routes
+ * Routes: GET /metrics, GET /metrics/history, GET /tools, GET /tools/:toolName,
+ *         GET /performance, GET /performance/detailed, GET /realtime,
+ *         GET /streaming/data, GET /charts/tool-usage, GET /charts/performance,
+ *         GET /charts/timerange, GET /charts/export, GET /analytics/advanced
+ */
+import { Router } from 'express';
+import { MetricsCollector } from '../MetricsCollector.js';
+export declare function createMetricsRoutes(metricsCollector: MetricsCollector): Router;

package/dist/dashboard/server/routes/metrics.routes.js

@@ -0,0 +1,346 @@
+"use strict";
+/**
+ * Metrics & Analytics Routes
+ * Routes: GET /metrics, GET /metrics/history, GET /tools, GET /tools/:toolName,
+ *         GET /performance, GET /performance/detailed, GET /realtime,
+ *         GET /streaming/data, GET /charts/tool-usage, GET /charts/performance,
+ *         GET /charts/timerange, GET /charts/export, GET /analytics/advanced
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetricsRoutes = createMetricsRoutes;
+const express_1 = require("express");
+const registry_js_1 = require("../../../server/registry.js");
+function createMetricsRoutes(metricsCollector) {
+    const router = (0, express_1.Router)();
+    /**
+     * GET /api/tools - List all registered tools
+     */
+    router.get('/tools', (_req, res) => {
+        try {
+            const tools = (0, registry_js_1.listRegisteredMethods)();
+            const toolMetrics = metricsCollector.getToolMetrics();
+            const enrichedTools = tools.map(toolName => ({
+                name: toolName,
+                metrics: toolMetrics[toolName] || {
+                    callCount: 0,
+                    successCount: 0,
+                    errorCount: 0,
+                    totalResponseTime: 0,
+                    errorTypes: {},
+                },
+            }));
+            res.json({
+                tools: enrichedTools,
+                totalTools: tools.length,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Tools error:', error);
+            res.status(500).json({
+                error: 'Failed to get tools list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/metrics - Current metrics snapshot
+     */
+    router.get('/metrics', (_req, res) => {
+        try {
+            const snapshot = metricsCollector.getCurrentSnapshot();
+            res.json(snapshot);
+        }
+        catch (error) {
+            console.error('[API] Metrics error:', error);
+            res.status(500).json({
+                error: 'Failed to get metrics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/metrics/history - Historical metrics snapshots
+     */
+    router.get('/metrics/history', (req, res) => {
+        try {
+            const count = req.query.count ? parseInt(req.query.count, 10) : undefined;
+            const snapshots = metricsCollector.getSnapshots(count);
+            res.json({
+                snapshots,
+                count: snapshots.length,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Metrics history error:', error);
+            res.status(500).json({
+                error: 'Failed to get metrics history',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/tools/:toolName - Specific tool metrics
+     */
+    router.get('/tools/:toolName', (req, res) => {
+        try {
+            const { toolName } = req.params;
+            const metrics = metricsCollector.getToolMetrics(toolName);
+            if (!metrics) {
+                return res.status(404).json({
+                    error: 'Tool not found',
+                    toolName,
+                });
+            }
+            res.json({
+                toolName,
+                metrics,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Tool metrics error:', error);
+            res.status(500).json({
+                error: 'Failed to get tool metrics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/performance - Performance summary
+     */
+    router.get('/performance', (_req, res) => {
+        try {
+            const snapshot = metricsCollector.getCurrentSnapshot();
+            res.json({
+                performance: snapshot.performance,
+                server: {
+                    uptime: snapshot.server.uptime,
+                    memoryUsage: snapshot.server.memoryUsage,
+                    cpuUsage: snapshot.server.cpuUsage,
+                },
+                connections: snapshot.connections,
+                timestamp: snapshot.timestamp,
+            });
+        }
+        catch (error) {
+            console.error('[API] Performance error:', error);
+            res.status(500).json({
+                error: 'Failed to get performance metrics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/realtime - Real-time metrics for dashboard widgets
+     */
+    router.get('/realtime', (_req, res) => {
+        try {
+            const realtimeMetrics = metricsCollector.getRealtimeMetrics();
+            res.json({
+                success: true,
+                data: realtimeMetrics,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Realtime metrics error:', error);
+            res.status(500).json({
+                error: 'Failed to get realtime metrics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/streaming/data - Real-time streaming data for Phase 4
+     */
+    router.get('/streaming/data', (_req, res) => {
+        try {
+            const streamingData = metricsCollector.getRealtimeStreamingData();
+            res.json({
+                success: true,
+                data: streamingData,
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            console.error('[API] Streaming data error:', error);
+            res.status(500).json({
+                error: 'Failed to get streaming data',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/charts/tool-usage - Tool usage chart data
+     * Query params: minutes (default: 60)
+     */
+    router.get('/charts/tool-usage', (req, res) => {
+        try {
+            const minutes = parseInt(req.query.minutes) || 60;
+            const chartData = metricsCollector.getToolUsageChartData(minutes);
+            res.json({
+                success: true,
+                data: chartData,
+                timeRange: `${minutes} minutes`,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Tool usage chart error:', error);
+            res.status(500).json({
+                error: 'Failed to get tool usage chart data',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/charts/performance - Performance metrics chart data
+     * Query params: minutes (default: 60)
+     */
+    router.get('/charts/performance', (req, res) => {
+        try {
+            const minutes = parseInt(req.query.minutes) || 60;
+            const chartData = metricsCollector.getPerformanceChartData(minutes);
+            res.json({
+                success: true,
+                data: chartData,
+                timeRange: `${minutes} minutes`,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Performance chart error:', error);
+            res.status(500).json({
+                error: 'Failed to get performance chart data',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/charts/timerange - Metrics for specific time ranges
+     * Query params: range (1h, 6h, 24h, 7d, 30d)
+     */
+    router.get('/charts/timerange', (req, res) => {
+        try {
+            const range = req.query.range || '1h';
+            const validRanges = ['1h', '6h', '24h', '7d', '30d'];
+            if (!validRanges.includes(range)) {
+                return res.status(400).json({
+                    error: 'Invalid time range',
+                    message: `Range must be one of: ${validRanges.join(', ')}`,
+                    validRanges,
+                });
+            }
+            const timeRangeData = metricsCollector.getTimeRangeMetrics(range);
+            res.json({
+                success: true,
+                data: timeRangeData,
+                range,
+                count: timeRangeData.length,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Time range chart error:', error);
+            res.status(500).json({
+                error: 'Failed to get time range data',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/charts/export - Export chart data for reports
+     * Query params: format (json, csv), range (1h, 6h, 24h, 7d, 30d)
+     */
+    router.get('/charts/export', (req, res) => {
+        try {
+            const format = req.query.format || 'json';
+            const range = req.query.range || '1h';
+            if (!['json', 'csv'].includes(format)) {
+                return res.status(400).json({
+                    error: 'Invalid export format',
+                    message: 'Format must be either json or csv',
+                });
+            }
+            const data = metricsCollector.getTimeRangeMetrics(range);
+            if (format === 'csv') {
+                // Convert to CSV format
+                const csvHeaders = 'timestamp,activeConnections,requestsPerMinute,successRate,errorRate,avgResponseTime\n';
+                const csvRows = data.map(snapshot => `${snapshot.timestamp},${snapshot.connections.activeConnections},${snapshot.performance.requestsPerMinute},${snapshot.performance.successRate},${snapshot.performance.errorRate},${snapshot.performance.avgResponseTime}`).join('\n');
+                res.setHeader('Content-Type', 'text/csv');
+                res.setHeader('Content-Disposition', `attachment; filename="metrics-${range}-${Date.now()}.csv"`);
+                res.send(csvHeaders + csvRows);
+            }
+            else {
+                res.json({
+                    success: true,
+                    data,
+                    range,
+                    exportedAt: Date.now(),
+                    format: 'json',
+                });
+            }
+        }
+        catch (error) {
+            console.error('[API] Chart export error:', error);
+            res.status(500).json({
+                error: 'Failed to export chart data',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/performance/detailed - Extended performance metrics (UI convenience endpoint)
+     * Supplies the fields the dashboard Monitoring panel expects without the client
+     * needing to stitch multiple endpoints. P95/P99 are approximations until full
+     * latency histogram support is implemented.
+     */
+    router.get('/performance/detailed', (_req, res) => {
+        try {
+            const snap = metricsCollector.getCurrentSnapshot();
+            // Approximate p95 by avgResponseTime + (errorRate factor) as a placeholder; real implementation would use distribution.
+            const avg = snap.performance.avgResponseTime;
+            const p95 = avg ? Math.round(avg * 1.35) : 0;
+            res.json({
+                success: true,
+                data: {
+                    requestThroughput: snap.performance.requestsPerMinute,
+                    averageResponseTime: avg,
+                    p95ResponseTime: p95,
+                    errorRate: snap.performance.errorRate,
+                    concurrentConnections: snap.connections.activeConnections,
+                    successRate: snap.performance.successRate ?? (100 - snap.performance.errorRate),
+                    activeSyntheticRequests: 0
+                },
+                timestamp: Date.now()
+            });
+        }
+        catch (err) {
+            res.status(500).json({ success: false, error: 'Failed to compute performance metrics', message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    /**
+     * GET /api/analytics/advanced - Advanced analytics data
+     */
+    router.get('/analytics/advanced', (req, res) => {
+        try {
+            const timeRange = req.query.timeRange || '1h';
+            const analytics = metricsCollector.getAdvancedAnalytics(timeRange);
+            res.json({
+                success: true,
+                data: analytics,
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            console.error('[API] Advanced analytics error:', error);
+            res.status(500).json({
+                error: 'Failed to get advanced analytics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    return router;
+}

package/dist/dashboard/server/routes/scripts.routes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Scripts Routes — Serve client scripts for download
+ * Routes: GET /scripts, GET /scripts/:name
+ *
+ * Provides downloadable REST client scripts for agents and users
+ * that lack MCP tool access and need to interact via HTTP.
+ */
+import { Router } from 'express';
+export declare function createScriptsRoutes(): Router;