@jagilber-org/index-server 1.22.0

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

@@ -0,0 +1,335 @@
+"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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    /**
+     * 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) {
+            console.error('[API] Performance detailed error:', err);
+            res.status(500).json({ success: false, error: 'Failed to compute performance metrics' });
+        }
+    });
+    /**
+     * 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',
+            });
+        }
+    });
+    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;

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

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScriptsRoutes = createScriptsRoutes;
+const express_1 = require("express");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+/** Allowed script files with metadata */
+const AVAILABLE_SCRIPTS = {
+    'index-server-client.ps1': {
+        file: 'index-server-client.ps1',
+        contentType: 'application/octet-stream',
+        description: 'PowerShell REST client for Index Server (agents without MCP)',
+    },
+    'index-server-client.sh': {
+        file: 'index-server-client.sh',
+        contentType: 'application/octet-stream',
+        description: 'Bash REST client for Index Server (agents without MCP)',
+    },
+};
+function createScriptsRoutes() {
+    const router = (0, express_1.Router)();
+    /**
+     * GET /api/scripts — List available client scripts with download URLs
+     */
+    router.get('/scripts', (_req, res) => {
+        const scripts = Object.entries(AVAILABLE_SCRIPTS).map(([name, meta]) => ({
+            name,
+            description: meta.description,
+            downloadUrl: `/api/scripts/${name}`,
+        }));
+        res.setHeader('Cache-Control', 'no-store');
+        res.json({ scripts });
+    });
+    /**
+     * GET /api/scripts/:name — Download a specific client script
+     */
+    router.get('/scripts/:name', async (req, res) => {
+        const name = req.params.name;
+        // Validate against allowlist (no path traversal)
+        const meta = AVAILABLE_SCRIPTS[name];
+        if (!meta) {
+            res.status(404).json({
+                error: `Script not found: ${name}`,
+                available: Object.keys(AVAILABLE_SCRIPTS),
+            });
+            return;
+        }
+        try {
+            const scriptsDir = path_1.default.join(process.cwd(), 'scripts');
+            const filePath = path_1.default.join(scriptsDir, meta.file); // nosemgrep: javascript.express.security.audit.express-path-join-resolve-traversal.express-path-join-resolve-traversal -- path validated below via startsWith check
+            // Verify resolved path is within scripts directory (defense in depth)
+            const resolved = path_1.default.resolve(filePath); // nosemgrep: javascript.express.security.audit.express-path-join-resolve-traversal.express-path-join-resolve-traversal -- resolved path checked against scriptsDir on next line
+            if (!resolved.startsWith(path_1.default.resolve(scriptsDir))) {
+                res.status(400).json({ error: 'Invalid script path' });
+                return;
+            }
+            const content = await (0, promises_1.readFile)(resolved, 'utf-8');
+            res.setHeader('Content-Type', meta.contentType);
+            res.setHeader('Content-Disposition', `attachment; filename="${meta.file}"`);
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+            res.send(content); // nosemgrep: javascript.express.security.audit.xss.direct-response-write.direct-response-write -- content served with Content-Type, Content-Disposition attachment, and X-Content-Type-Options: nosniff headers
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes('ENOENT')) {
+                res.status(404).json({ error: `Script file not found on disk: ${name}` });
+            }
+            else {
+                res.status(500).json({ error: `Failed to read script: ${message}` });
+            }
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * SQLite dashboard routes — DB info, ad-hoc query, maintenance,
+ * backup/restore, WAL management, grooming, migration & export.
+ *
+ * Only active when INDEX_SERVER_STORAGE_BACKEND=sqlite.
+ * All routes prefixed with /sqlite/.
+ */
+import { Router } from 'express';
+export declare function createSqliteRoutes(): Router;