@jagilber-org/index-server 1.19.1

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

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Graph Routes
+ * Routes: GET /graph/mermaid, GET /graph/categories, GET /graph/instructions, GET /graph/relations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphRoutes = createGraphRoutes;
+const express_1 = require("express");
+const handlers_graph_js_1 = require("../../../services/handlers.graph.js");
+const indexContext_js_1 = require("../../../services/indexContext.js");
+const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
+function createGraphRoutes() {
+    const router = (0, express_1.Router)();
+    /**
+     * GET /api/graph/mermaid - Returns mermaid representation of the instruction graph.
+     * Query params:
+     *   enrich=1        -> include enriched schema (v2) data generation path
+     *   categories=1    -> include explicit category nodes
+     *   usage=1         -> include usageCount when available
+     *   edgeTypes=a,b   -> restrict edge types (comma separated)
+     */
+    router.get('/graph/mermaid', (req, res) => {
+        try {
+            const { enrich, categories, usage, edgeTypes, selectedCategories, selectedIds } = req.query;
+            const includeEdgeTypes = edgeTypes ? edgeTypes.split(',').filter(Boolean) : undefined;
+            const t0 = Date.now();
+            try {
+                // eslint-disable-next-line no-console
+                console.debug('[graph/mermaid][start]', `enrich=${enrich}`, `categories=${categories}`, `usage=${usage}`, `edgeTypes=${edgeTypes || ''}`, `selCats=${selectedCategories || ''}`, `selIds=${selectedIds || ''}`);
+            }
+            catch { /* ignore diag logging errors */ }
+            const graph = (0, handlers_graph_js_1.buildGraph)({
+                enrich: enrich === '1' || enrich === 'true',
+                includeCategoryNodes: categories === '1' || categories === 'true',
+                includeUsage: usage === '1' || usage === 'true',
+                includeEdgeTypes,
+                format: 'mermaid'
+            });
+            if (!graph.mermaid) {
+                return res.status(500).json({ success: false, error: 'failed_to_generate_mermaid' });
+            }
+            let mermaidSource = graph.mermaid;
+            const catFilter = selectedCategories?.split(',').filter(Boolean) || [];
+            const idFilter = selectedIds?.split(',').filter(Boolean) || [];
+            let filteredNodeCount;
+            let filteredEdgeCount;
+            let scoped = false;
+            let keptIdsSize = 0;
+            if ((catFilter.length || idFilter.length) && mermaidSource) {
+                try {
+                    const keepIds = new Set();
+                    for (const id of idFilter)
+                        keepIds.add(id);
+                    const wantCategoryNodes = (categories === '1' || categories === 'true');
+                    if (catFilter.length) {
+                        const catSet = new Set(catFilter.map(c => c.toLowerCase()));
+                        if (wantCategoryNodes) {
+                            for (const c of catFilter) {
+                                keepIds.add(`category:${c}`);
+                            }
+                        }
+                        if (graph.meta.graphSchemaVersion === 2) {
+                            for (const nodeRaw of graph.nodes) {
+                                const nodeCats = nodeRaw.categories;
+                                if (Array.isArray(nodeCats) && nodeCats.some(c => catSet.has(c.toLowerCase()))) {
+                                    keepIds.add(nodeRaw.id);
+                                    if (wantCategoryNodes) {
+                                        for (const c of nodeCats) {
+                                            if (catSet.has(c.toLowerCase()))
+                                                keepIds.add(`category:${c}`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (keepIds.size) {
+                        let frontmatterBlock = '';
+                        let remainder = mermaidSource;
+                        if (remainder.startsWith('---\n')) {
+                            const fmMatch = /^---\n[\s\S]*?\n---\n/.exec(remainder);
+                            if (fmMatch) {
+                                frontmatterBlock = fmMatch[0];
+                                remainder = remainder.slice(fmMatch[0].length);
+                            }
+                        }
+                        const lines = remainder.split(/\r?\n/);
+                        const directiveIdx = lines.findIndex(l => /^\s*(flowchart|graph)\b/i.test(l));
+                        let directiveLine = '';
+                        if (directiveIdx >= 0) {
+                            directiveLine = lines[directiveIdx];
+                        }
+                        const nodeIdPattern = Array.from(keepIds).map(id => id.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')).join('|');
+                        const nodeRegex = new RegExp(`^(\\s*)(${nodeIdPattern})\\[`);
+                        const edgeRegex = new RegExp(`^(.*)(${nodeIdPattern})(.*)(${nodeIdPattern})(.*)$`);
+                        const filtered = [];
+                        const styleRegexes = [
+                            /^\s*classDef\s+/i,
+                            /^\s*style\s+[A-Za-z0-9:_-]+\s+/i,
+                            /^\s*class\s+[A-Za-z0-9:_-]+\s+/i,
+                            /^\s*linkStyle\s+\d+/i
+                        ];
+                        for (const ln of lines) {
+                            if (!ln)
+                                continue;
+                            if (directiveLine && ln === directiveLine) {
+                                continue;
+                            }
+                            const trimmed = ln.trim();
+                            if (trimmed.startsWith('%%')) {
+                                filtered.push(ln);
+                                continue;
+                            }
+                            if (styleRegexes.some(r => r.test(trimmed))) {
+                                filtered.push(ln);
+                                continue;
+                            }
+                            if (nodeRegex.test(ln) || edgeRegex.test(ln))
+                                filtered.push(ln);
+                        }
+                        const parts = [];
+                        if (frontmatterBlock)
+                            parts.push(frontmatterBlock.trimEnd());
+                        if (directiveLine)
+                            parts.push(directiveLine);
+                        parts.push(...filtered);
+                        mermaidSource = parts.join('\n');
+                        if ((0, runtimeConfig_js_1.getRuntimeConfig)().logging.verbose) {
+                            // eslint-disable-next-line no-console
+                            console.debug('[graph/mermaid][filter:new]', { selectedIds: idFilter.length, selectedCategories: catFilter.length, kept: keepIds.size, totalLines: lines.length, emittedLines: parts.length });
+                        }
+                        keptIdsSize = keepIds.size;
+                        scoped = true;
+                        try {
+                            const nodeLineRegex = /^(\s*)([A-Za-z0-9:_-]+)\[[^\]]*\]/;
+                            const edgeLineRegex = /-->|===|~~>|\|-/;
+                            let n = 0, eCnt = 0;
+                            for (const ln of filtered) {
+                                if (nodeLineRegex.test(ln))
+                                    n++;
+                                else if (edgeLineRegex.test(ln))
+                                    eCnt++;
+                            }
+                            filteredNodeCount = n;
+                            filteredEdgeCount = eCnt;
+                        }
+                        catch { /* ignore count derivation errors */ }
+                    }
+                }
+                catch (filterErr) {
+                    console.warn('[graph/mermaid][filter-failed]', filterErr);
+                }
+            }
+            try {
+                // eslint-disable-next-line no-console
+                console.debug('[graph/mermaid][ok]', { ms: Date.now() - t0, nodes: graph.meta?.nodeCount, edges: graph.meta?.edgeCount, bytes: mermaidSource.length });
+            }
+            catch { /* ignore diag logging errors */ }
+            let metaOut = graph.meta;
+            if (scoped && graph.meta) {
+                try {
+                    const base = { ...graph.meta };
+                    const augmented = base;
+                    if (typeof filteredNodeCount === 'number')
+                        augmented.nodeCount = filteredNodeCount;
+                    if (typeof filteredEdgeCount === 'number')
+                        augmented.edgeCount = filteredEdgeCount;
+                    augmented.scoped = true;
+                    augmented.keptIds = keptIdsSize;
+                    metaOut = augmented;
+                }
+                catch { /* ignore meta cloning issues */ }
+            }
+            res.json({ success: true, meta: metaOut, mermaid: mermaidSource });
+        }
+        catch (err) {
+            const e = err;
+            try {
+                // eslint-disable-next-line no-console
+                console.warn('[graph/mermaid][error]', e.message);
+            }
+            catch { /* ignore diag logging errors */ }
+            res.status(500).json({ success: false, error: String(e.message || e) });
+        }
+    });
+    /**
+     * GET /api/graph/categories
+     * Returns list of unique categories with instruction counts.
+     */
+    router.get('/graph/categories', (_req, res) => {
+        try {
+            const st = (0, indexContext_js_1.ensureLoaded)();
+            const map = new Map();
+            for (const inst of st.list) {
+                const cats = Array.isArray(inst.categories) ? inst.categories : [];
+                for (const c of cats) {
+                    map.set(c, (map.get(c) || 0) + 1);
+                }
+            }
+            const categories = [...map.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([id, count]) => ({ id, count }));
+            res.json({ success: true, categories, total: categories.length, timestamp: Date.now() });
+        }
+        catch (err) {
+            const e = err;
+            res.status(500).json({ success: false, error: e.message || String(e) });
+        }
+    });
+    /**
+     * GET /api/graph/instructions?categories=a,b&limit=100
+     * Returns lightweight instruction list filtered by categories (OR semantics).
+     */
+    router.get('/graph/instructions', (req, res) => {
+        try {
+            const st = (0, indexContext_js_1.ensureLoaded)();
+            const catsParam = req.query.categories || '';
+            const filterCats = catsParam ? catsParam.split(',').filter(Boolean) : [];
+            const limitRaw = parseInt(req.query.limit || '0', 10);
+            const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : 500;
+            let instructions = st.list.slice().sort((a, b) => a.id.localeCompare(b.id));
+            if (filterCats.length) {
+                const set = new Set(filterCats.map(c => c.toLowerCase()));
+                instructions = instructions.filter(i => (i.categories || []).some(c => set.has(c.toLowerCase())));
+            }
+            instructions = instructions.slice(0, limit);
+            const flat = instructions.map(i => ({ id: i.id, primaryCategory: i.primaryCategory || i.categories?.[0], categories: i.categories || [] }));
+            res.json({ success: true, instructions: flat, count: flat.length, filtered: !!filterCats.length, timestamp: Date.now() });
+        }
+        catch (err) {
+            const e = err;
+            res.status(500).json({ success: false, error: e.message || String(e) });
+        }
+    });
+    /**
+     * GET /api/graph/relations?instructions=id1,id2
+     * Returns minimal edges among the provided instruction ids plus category linkage.
+     */
+    router.get('/graph/relations', (req, res) => {
+        try {
+            const idsParam = req.query.instructions || '';
+            const ids = idsParam.split(',').filter(Boolean);
+            if (!ids.length) {
+                return res.json({ success: true, nodes: [], edges: [], categories: [], timestamp: Date.now() });
+            }
+            const graph = (0, handlers_graph_js_1.buildGraph)({ enrich: true, includeCategoryNodes: true, includeUsage: false });
+            const expand = (req.query.expand === '1' || req.query.expand === 'true');
+            const selectedSet = new Set(ids);
+            const workingSet = new Set(ids);
+            const firstEdges = graph.edges.filter(e => selectedSet.has(e.from) || selectedSet.has(e.to));
+            if (expand) {
+                const instructionNodeIds = new Set(graph.nodes.filter(n => n.nodeType === 'instruction').map(n => n.id));
+                for (const e of firstEdges) {
+                    if (instructionNodeIds.has(e.from) && !workingSet.has(e.from))
+                        workingSet.add(e.from);
+                    if (instructionNodeIds.has(e.to) && !workingSet.has(e.to))
+                        workingSet.add(e.to);
+                }
+            }
+            const nodesAll = graph.nodes.filter(n => workingSet.has(n.id) || n.nodeType === 'category');
+            const edges = graph.edges.filter(e => workingSet.has(e.from) && workingSet.has(e.to) && (selectedSet.has(e.from) || selectedSet.has(e.to)));
+            const categoryRefs = new Set();
+            for (const e of edges) {
+                if (e.type === 'belongs' || e.type === 'primary') {
+                    if (e.to.startsWith('category:'))
+                        categoryRefs.add(e.to);
+                    if (e.from.startsWith('category:'))
+                        categoryRefs.add(e.from);
+                }
+            }
+            const finalNodes = nodesAll.filter(n => !('nodeType' in n && n.nodeType === 'category') || categoryRefs.has(n.id));
+            const categories = [...categoryRefs].map(id => ({ id: id.replace(/^category:/, '') }));
+            const expandedCount = workingSet.size - selectedSet.size;
+            res.json({ success: true, nodes: finalNodes, edges, categories, expanded: expand ? expandedCount : 0, timestamp: Date.now() });
+        }
+        catch (err) {
+            const e = err;
+            res.status(500).json({ success: false, error: e.message || String(e) });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Route module index — re-exports all route factories and mounts dashboard routes.
+ */
+import { Express } from 'express';
+import { MetricsCollector } from '../MetricsCollector.js';
+export { createStatusRoutes } from './status.routes.js';
+export { createMetricsRoutes } from './metrics.routes.js';
+export { createAdminRoutes } from './admin.routes.js';
+export { createGraphRoutes } from './graph.routes.js';
+export { createInstructionsRoutes } from './instructions.routes.js';
+export { createKnowledgeRoutes } from './knowledge.routes.js';
+export { createAlertsRoutes } from './alerts.routes.js';
+export { createLogsRoutes } from './logs.routes.js';
+export { createSyntheticRoutes } from './synthetic.routes.js';
+export { createInstancesRoutes } from './instances.routes.js';
+export { createToolsRoutes } from './tools.routes.js';
+export { createEmbeddingsRoutes } from './embeddings.routes.js';
+export { createUsageRoutes } from './usage.routes.js';
+export { createScriptsRoutes } from './scripts.routes.js';
+export { createMessagingRoutes } from './messaging.routes.js';
+export { createSqliteRoutes } from './sqlite.routes.js';
+export interface DashboardRoutesContext {
+    metricsCollector: MetricsCollector;
+    enableWebSockets: boolean;
+    enableCors: boolean;
+    graphEnabled: boolean;
+    wsProtocol: 'wss' | 'ws';
+    getServerInfo: () => {
+        port: number;
+        host: string;
+        url: string;
+    } | null;
+}
+/**
+ * Registers all top-level dashboard routes on the given Express app.
+ * Called once during DashboardServer construction after middleware is set up.
+ */
+export declare function mountDashboardRoutes(app: Express, ctx: DashboardRoutesContext): void;

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

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Route module index — re-exports all route factories and mounts dashboard routes.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqliteRoutes = exports.createMessagingRoutes = exports.createScriptsRoutes = exports.createUsageRoutes = exports.createEmbeddingsRoutes = exports.createToolsRoutes = exports.createInstancesRoutes = exports.createSyntheticRoutes = exports.createLogsRoutes = exports.createAlertsRoutes = exports.createKnowledgeRoutes = exports.createInstructionsRoutes = exports.createGraphRoutes = exports.createAdminRoutes = exports.createMetricsRoutes = exports.createStatusRoutes = void 0;
+exports.mountDashboardRoutes = mountDashboardRoutes;
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const ApiRoutes_js_1 = require("../ApiRoutes.js");
+const legacyDashboardHtml_js_1 = require("../legacyDashboardHtml.js");
+const registry_js_1 = require("../../../server/registry.js");
+var status_routes_js_1 = require("./status.routes.js");
+Object.defineProperty(exports, "createStatusRoutes", { enumerable: true, get: function () { return status_routes_js_1.createStatusRoutes; } });
+var metrics_routes_js_1 = require("./metrics.routes.js");
+Object.defineProperty(exports, "createMetricsRoutes", { enumerable: true, get: function () { return metrics_routes_js_1.createMetricsRoutes; } });
+var admin_routes_js_1 = require("./admin.routes.js");
+Object.defineProperty(exports, "createAdminRoutes", { enumerable: true, get: function () { return admin_routes_js_1.createAdminRoutes; } });
+var graph_routes_js_1 = require("./graph.routes.js");
+Object.defineProperty(exports, "createGraphRoutes", { enumerable: true, get: function () { return graph_routes_js_1.createGraphRoutes; } });
+var instructions_routes_js_1 = require("./instructions.routes.js");
+Object.defineProperty(exports, "createInstructionsRoutes", { enumerable: true, get: function () { return instructions_routes_js_1.createInstructionsRoutes; } });
+var knowledge_routes_js_1 = require("./knowledge.routes.js");
+Object.defineProperty(exports, "createKnowledgeRoutes", { enumerable: true, get: function () { return knowledge_routes_js_1.createKnowledgeRoutes; } });
+var alerts_routes_js_1 = require("./alerts.routes.js");
+Object.defineProperty(exports, "createAlertsRoutes", { enumerable: true, get: function () { return alerts_routes_js_1.createAlertsRoutes; } });
+var logs_routes_js_1 = require("./logs.routes.js");
+Object.defineProperty(exports, "createLogsRoutes", { enumerable: true, get: function () { return logs_routes_js_1.createLogsRoutes; } });
+var synthetic_routes_js_1 = require("./synthetic.routes.js");
+Object.defineProperty(exports, "createSyntheticRoutes", { enumerable: true, get: function () { return synthetic_routes_js_1.createSyntheticRoutes; } });
+var instances_routes_js_1 = require("./instances.routes.js");
+Object.defineProperty(exports, "createInstancesRoutes", { enumerable: true, get: function () { return instances_routes_js_1.createInstancesRoutes; } });
+var tools_routes_js_1 = require("./tools.routes.js");
+Object.defineProperty(exports, "createToolsRoutes", { enumerable: true, get: function () { return tools_routes_js_1.createToolsRoutes; } });
+var embeddings_routes_js_1 = require("./embeddings.routes.js");
+Object.defineProperty(exports, "createEmbeddingsRoutes", { enumerable: true, get: function () { return embeddings_routes_js_1.createEmbeddingsRoutes; } });
+var usage_routes_js_1 = require("./usage.routes.js");
+Object.defineProperty(exports, "createUsageRoutes", { enumerable: true, get: function () { return usage_routes_js_1.createUsageRoutes; } });
+var scripts_routes_js_1 = require("./scripts.routes.js");
+Object.defineProperty(exports, "createScriptsRoutes", { enumerable: true, get: function () { return scripts_routes_js_1.createScriptsRoutes; } });
+var messaging_routes_js_1 = require("./messaging.routes.js");
+Object.defineProperty(exports, "createMessagingRoutes", { enumerable: true, get: function () { return messaging_routes_js_1.createMessagingRoutes; } });
+var sqlite_routes_js_1 = require("./sqlite.routes.js");
+Object.defineProperty(exports, "createSqliteRoutes", { enumerable: true, get: function () { return sqlite_routes_js_1.createSqliteRoutes; } });
+/**
+ * Registers all top-level dashboard routes on the given Express app.
+ * Called once during DashboardServer construction after middleware is set up.
+ */
+function mountDashboardRoutes(app, ctx) {
+    // Redirect root to admin panel (v2 dashboard)
+    app.get('/', (_req, res) => {
+        res.redirect('/admin');
+    });
+    // Legacy v1 dashboard (kept for backward compatibility)
+    app.get('/legacy', (_req, res) => {
+        const nonce = res.locals.cspNonce;
+        const snapshot = ctx.metricsCollector.getCurrentSnapshot();
+        const serverInfo = ctx.getServerInfo();
+        const webSocketUrl = ctx.enableWebSockets && serverInfo
+            ? `${ctx.wsProtocol}://${serverInfo.host}:${serverInfo.port}/ws`
+            : null;
+        res.send((0, legacyDashboardHtml_js_1.generateDashboardHtml)(nonce, snapshot, webSocketUrl));
+    });
+    // Admin Panel (v2 dashboard — primary UI)
+    app.get('/admin', async (_req, res) => {
+        try {
+            // __dirname here is src/dashboard/server/routes — step up two levels to reach client/
+            const adminHtmlPath = path_1.default.join(__dirname, '..', '..', 'client', 'admin.html');
+            let adminHtml = await (0, promises_1.readFile)(adminHtmlPath, 'utf-8');
+            if (!ctx.graphEnabled) {
+                adminHtml = (0, legacyDashboardHtml_js_1.stripGraphTab)(adminHtml);
+            }
+            const nonce = res.locals.cspNonce;
+            adminHtml = adminHtml.replace(/<script>/g, `<script nonce="${nonce}">`);
+            adminHtml = adminHtml.replace(/<script defer /g, `<script nonce="${nonce}" defer `);
+            res.type('html').send(adminHtml);
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('[Dashboard] Admin panel load error:', error);
+            res.status(500).send('<h1>500 - Admin Panel Error</h1><p>Failed to load admin panel</p>');
+        }
+    });
+    // Health check
+    app.get('/health', (_req, res) => {
+        const snapshot = ctx.metricsCollector.getCurrentSnapshot();
+        res.json({
+            status: 'healthy',
+            timestamp: Date.now(),
+            uptime: snapshot.server.uptime,
+            version: snapshot.server.version,
+        });
+    });
+    // Panel documentation — serves markdown rendered as styled HTML
+    app.get('/api/docs/:name', async (req, res) => {
+        const name = req.params.name.replace(/[^a-z0-9_-]/gi, '');
+        if (!name) {
+            res.status(400).send('Invalid doc name');
+            return;
+        }
+        const docPath = path_1.default.join(__dirname, '..', '..', '..', '..', 'docs', 'panels', `${name}.md`);
+        try {
+            const md = await (0, promises_1.readFile)(docPath, 'utf-8');
+            const bodyHtml = md
+                .replace(/^### (.+)$/gm, '<h3>$1</h3>')
+                .replace(/^## (.+)$/gm, '<h2>$1</h2>')
+                .replace(/^# (.+)$/gm, '<h1>$1</h1>')
+                .replace(/^---$/gm, '<hr>')
+                .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+                .replace(/`([^`]+)`/g, '<code>$1</code>')
+                .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" style="max-width:100%;border-radius:8px;border:1px solid #1f2a3a;margin:12px 0;">')
+                .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>')
+                .replace(/^\| (.+) \|$/gm, (_m, row) => {
+                const cells = row.split('|').map((c) => c.trim());
+                return '<tr>' + cells.map((c) => `<td>${c}</td>`).join('') + '</tr>';
+            })
+                .replace(/^\|[-| ]+\|$/gm, '')
+                .replace(/((?:<tr>.*<\/tr>\n?)+)/g, '<table>$1</table>')
+                .replace(/^- (.+)$/gm, '<li>$1</li>')
+                .replace(/((?:<li>.*<\/li>\n?)+)/g, '<ul>$1</ul>')
+                .replace(/\n{2,}/g, '\n<br>\n');
+            const html = `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0"><title>${name} - Panel Docs</title><style>body{background:#0b0f19;color:#e3ebf5;font-family:'Segoe UI',system-ui,sans-serif;padding:24px 32px;max-width:800px;margin:0 auto;line-height:1.6;}h1{color:#667eea;border-bottom:1px solid #1f2a3a;padding-bottom:8px;}h2{color:#9fb5cc;margin-top:24px;}h3{color:#b0c4de;}table{width:100%;border-collapse:collapse;margin:12px 0;}td{padding:6px 10px;border:1px solid #1f2a3a;font-size:13px;}tr:first-child td{background:#101726;font-weight:600;}code{background:#182234;padding:2px 6px;border-radius:4px;font-size:12px;}a{color:#667eea;}hr{border:none;border-top:1px solid #1f2a3a;margin:20px 0;}ul{padding-left:20px;}li{margin:4px 0;}</style></head><body>${bodyHtml}</body></html>`;
+            res.type('html').send(html);
+        }
+        catch {
+            res.status(404).send('<h1>404</h1><p>Panel documentation not found.</p><p><a href="/admin">Back to Admin</a></p>');
+        }
+    });
+    // Panel screenshot — serves PNG images from docs/screenshots/
+    app.get('/api/screenshots/:name', async (req, res) => {
+        const fileName = req.params.name.replace(/[^a-z0-9._-]/gi, '');
+        if (!fileName || !fileName.endsWith('.png')) {
+            res.status(400).send('Invalid');
+            return;
+        }
+        const screenshotsDir = path_1.default.resolve(__dirname, '..', '..', '..', '..', 'docs', 'screenshots');
+        const filePath = path_1.default.join(screenshotsDir, fileName);
+        if (!filePath.startsWith(screenshotsDir)) {
+            res.status(400).send('Invalid path');
+            return;
+        }
+        try {
+            const data = await (0, promises_1.readFile)(filePath);
+            res.setHeader('Content-Type', 'image/png');
+            res.setHeader('Cache-Control', 'public, max-age=3600');
+            res.send(data);
+        }
+        catch {
+            res.status(404).send('Screenshot not found');
+        }
+    });
+    // API sub-routes (mounted at /api)
+    app.use('/api', (0, ApiRoutes_js_1.createApiRoutes)({ enableCors: ctx.enableCors }));
+    // Back-compat: legacy tests expect /tools.json at dashboard root
+    app.get('/tools.json', (_req, res) => {
+        try {
+            const tools = (0, registry_js_1.listRegisteredMethods)();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const toolMetrics = ctx.metricsCollector.getToolMetrics();
+            const enrichedTools = tools.map(toolName => ({
+                name: toolName,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                metrics: toolMetrics[toolName] || {
+                    callCount: 0,
+                    successCount: 0,
+                    errorCount: 0,
+                    totalResponseTime: 0,
+                    errorTypes: {},
+                },
+            }));
+            res.json({ tools: enrichedTools, totalTools: tools.length, timestamp: Date.now(), legacy: true });
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('[Dashboard] /tools.json route error:', error);
+            res.status(500).json({ error: 'Failed to get tools list' });
+        }
+    });
+    // WebSocket connection info
+    app.get('/ws-info', (_req, res) => {
+        const serverInfo = ctx.getServerInfo();
+        res.json({
+            enabled: ctx.enableWebSockets,
+            url: serverInfo ? `${ctx.wsProtocol}://${serverInfo.host}:${serverInfo.port}/ws` : null,
+        });
+    });
+    // 404 fallback
+    app.use((_req, res) => {
+        res.status(404).send('<h1>404 - Page Not Found</h1><p>Return to <a href="/">Dashboard</a></p>');
+    });
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Instances Routes
+ * Routes: GET /instances
+ */
+import { Router } from 'express';
+export declare function createInstancesRoutes(): Router;

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

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Instances Routes
+ * Routes: GET /instances
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstancesRoutes = createInstancesRoutes;
+const express_1 = require("express");
+const InstanceManager_js_1 = require("../InstanceManager.js");
+function createInstancesRoutes() {
+    const router = (0, express_1.Router)();
+    /**
+     * GET /api/instances - List all active dashboard instances
+     */
+    router.get('/instances', (_req, res) => {
+        try {
+            const instances = (0, InstanceManager_js_1.getActiveInstances)();
+            const current = instances.find(i => i.current);
+            res.json({
+                current: current ? { pid: current.pid, port: current.port, host: current.host } : null,
+                instances,
+                count: instances.length,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: 'Failed to list instances',
+                message: error instanceof Error ? error.message : String(error),
+                timestamp: Date.now(),
+            });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Instructions Management Routes
+ * Routes: GET /instructions, GET /instructions_search, GET /instructions_categories,
+ *         GET /instructions/:name, POST /instructions, PUT /instructions/:name,
+ *         DELETE /instructions/:name
+ */
+import { Router } from 'express';
+export declare function createInstructionsRoutes(): Router;