@jagilber-org/index-server 1.22.0

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

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Logs Routes
+ * Routes: GET /logs, GET /logs/stream
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogsRoutes = createLogsRoutes;
+const express_1 = require("express");
+const fs_1 = __importDefault(require("fs"));
+const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
+function createLogsRoutes() {
+    const router = (0, express_1.Router)();
+    /**
+     * GET /api/logs - Get server logs with optional tail functionality
+     */
+    router.get('/logs', (req, res) => {
+        try {
+            const loggingConfig = (0, runtimeConfig_js_1.getRuntimeConfig)().logging;
+            const logFile = loggingConfig.file;
+            const lines = req.query.lines ? parseInt(req.query.lines, 10) : 100;
+            const follow = req.query.follow === 'true';
+            const raw = req.query.raw === '1' || req.query.raw === 'true';
+            if (!logFile || !fs_1.default.existsSync(logFile)) {
+                return res.json({
+                    logs: [],
+                    message: 'No log file configured or file not found. Set INDEX_SERVER_LOG_FILE environment variable or update runtime logging configuration.',
+                    timestamp: Date.now(),
+                    totalLines: 0
+                });
+            }
+            // Read log file
+            const logContent = fs_1.default.readFileSync(logFile, 'utf8');
+            const allLines = logContent.split('\n').filter(line => line.trim());
+            // Get last N lines (tail functionality)
+            const tailLines = lines > 0 ? allLines.slice(-lines) : allLines;
+            if (raw) {
+                // Plain text response for simpler clients (backwards-compatible option)
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                res.send(tailLines.join('\n'));
+                return;
+            }
+            res.json({
+                logs: tailLines,
+                timestamp: Date.now(),
+                totalLines: allLines.length,
+                showing: tailLines.length,
+                file: loggingConfig.rawFileValue ?? logFile,
+                follow: follow,
+                mode: raw ? 'text' : 'json'
+            });
+        }
+        catch (error) {
+            console.error('[API] Logs error:', error);
+            res.status(500).json({
+                error: 'Failed to read logs',
+                timestamp: Date.now()
+            });
+        }
+    });
+    /**
+     * GET /api/logs/stream - Server-Sent Events stream for real-time log tailing
+     */
+    router.get('/logs/stream', (req, res) => {
+        const loggingConfig = (0, runtimeConfig_js_1.getRuntimeConfig)().logging;
+        const logFile = loggingConfig.file;
+        if (!logFile || !fs_1.default.existsSync(logFile)) {
+            return res.status(404).json({
+                error: 'Log file not available',
+                message: 'No log file configured or file not found. Set INDEX_SERVER_LOG_FILE environment variable or update runtime logging configuration.'
+            });
+        }
+        // Set up Server-Sent Events
+        const origin = req.headers.origin;
+        const corsOrigin = (origin && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) ? origin : '';
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}),
+        });
+        let lastSize = 0;
+        let watchInterval = null;
+        try {
+            // Get initial file size
+            const initialStats = fs_1.default.statSync(logFile);
+            lastSize = initialStats.size;
+            // Send initial connection message
+            res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: Date.now() })}\n\n`);
+            // Poll for file changes (more reliable than fs.watchFile)
+            watchInterval = setInterval(() => {
+                try {
+                    const currentStats = fs_1.default.statSync(logFile);
+                    if (currentStats.size > lastSize) {
+                        // File has grown, read new content
+                        const stream = fs_1.default.createReadStream(logFile, {
+                            start: lastSize,
+                            end: currentStats.size - 1,
+                            encoding: 'utf8'
+                        });
+                        let buffer = '';
+                        stream.on('data', (chunk) => {
+                            const chunkStr = chunk.toString();
+                            buffer += chunkStr;
+                            const lineArr = buffer.split('\n');
+                            buffer = lineArr.pop() || ''; // Keep incomplete line in buffer
+                            lineArr.forEach(line => {
+                                if (line.trim()) {
+                                    res.write(`data: ${JSON.stringify({
+                                        type: 'log',
+                                        line: line.trim(),
+                                        timestamp: Date.now()
+                                    })}\n\n`);
+                                }
+                            });
+                        });
+                        stream.on('end', () => {
+                            lastSize = currentStats.size;
+                        });
+                        stream.on('error', (error) => {
+                            console.error('[Logs] Stream read error:', error);
+                            res.write(`data: ${JSON.stringify({
+                                type: 'error',
+                                message: 'Failed to read log stream',
+                                timestamp: Date.now()
+                            })}\n\n`);
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('[Logs] Stream poll error:', error);
+                    res.write(`data: ${JSON.stringify({
+                        type: 'error',
+                        message: 'Failed to poll log file',
+                        timestamp: Date.now()
+                    })}\n\n`);
+                }
+            }, 1000);
+            // Cleanup on client disconnect
+            req.on('close', () => {
+                if (watchInterval) {
+                    clearInterval(watchInterval);
+                    watchInterval = null;
+                }
+            });
+            // Keep connection alive
+            const heartbeat = setInterval(() => {
+                res.write(`data: ${JSON.stringify({ type: 'heartbeat', timestamp: Date.now() })}\n\n`);
+            }, 30000);
+            req.on('close', () => {
+                clearInterval(heartbeat);
+            });
+        }
+        catch (error) {
+            console.error('[Logs] Failed to start log streaming:', error);
+            res.write(`data: ${JSON.stringify({
+                type: 'error',
+                message: 'Failed to start log streaming',
+                timestamp: Date.now()
+            })}\n\n`);
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * 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)
+ */
+import { Router } from 'express';
+export declare function createMessagingRoutes(): Router;

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

@@ -0,0 +1,307 @@
+"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");
+const adminAuth_js_1 = require("./adminAuth.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', adminAuth_js_1.dashboardAdminAuth, (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 => {
+                console.error('[Messaging] Send failed:', err);
+                res.status(500).json({ success: false, error: 'Send failed' });
+            });
+        }
+        catch (error) {
+            console.error('[Messaging] Failed to send message:', error);
+            res.status(500).json({ success: false, error: 'Failed to send message' });
+        }
+    });
+    // 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) {
+            console.error('[Messaging] Failed to list channels:', error);
+            res.status(500).json({ success: false, error: 'Failed to list channels' });
+        }
+    });
+    // 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) {
+            console.error('[Messaging] Failed to get stats:', error);
+            res.status(500).json({ success: false, error: 'Failed to get stats' });
+        }
+    });
+    // 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) {
+            console.error('[Messaging] Failed to get message:', error);
+            res.status(500).json({ success: false, error: 'Failed to get message' });
+        }
+    });
+    // PUT /api/messages/by-id/:id — update message
+    router.put('/messages/by-id/:id', adminAuth_js_1.dashboardAdminAuth, (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) {
+            console.error('[Messaging] Failed to update message:', error);
+            res.status(500).json({ success: false, error: 'Failed to update message' });
+        }
+    });
+    // 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) {
+            console.error('[Messaging] Failed to get thread:', error);
+            res.status(500).json({ success: false, error: 'Failed to get thread' });
+        }
+    });
+    // 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) {
+            console.error('[Messaging] Failed to read messages:', error);
+            res.status(500).json({ success: false, error: 'Failed to read messages' });
+        }
+    });
+    // POST /api/messages/ack — acknowledge messages
+    router.post('/messages/ack', adminAuth_js_1.dashboardAdminAuth, (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) {
+            console.error('[Messaging] Failed to acknowledge messages:', error);
+            res.status(500).json({ success: false, error: 'Failed to acknowledge messages' });
+        }
+    });
+    // DELETE /api/messages — purge messages
+    router.delete('/messages', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const mailbox = getMailbox();
+            let removed;
+            let action = 'purge_all';
+            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) {
+            console.error('[Messaging] Failed to purge messages:', error);
+            res.status(500).json({ success: false, error: 'Failed to purge messages' });
+        }
+    });
+    // POST /api/messages/inbound — receive message from peer instance
+    router.post('/messages/inbound', adminAuth_js_1.dashboardAdminAuth, (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 => {
+                console.error('[Messaging] Inbound failed:', err);
+                res.status(500).json({ success: false, error: 'Inbound failed' });
+            });
+        }
+        catch (error) {
+            console.error('[Messaging] Failed to process inbound message:', error);
+            res.status(500).json({ success: false, error: 'Failed to process inbound message' });
+        }
+    });
+    // POST /api/messages/reply — reply to a message
+    router.post('/messages/reply', adminAuth_js_1.dashboardAdminAuth, 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) {
+            console.error('[Messaging] Failed to reply to message:', error);
+            const isNotFound = error instanceof Error && error.message.includes('not found');
+            const status = isNotFound ? 404 : 500;
+            res.status(status).json({ success: false, error: isNotFound ? 'Parent message not found' : 'Failed to reply to message' });
+        }
+    });
+    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;