@jagilber-org/index-server 1.22.0

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

@@ -0,0 +1,229 @@
+"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.renderPanelMarkdownHtml = renderPanelMarkdownHtml;
+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; } });
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function sanitizeDocUrl(rawUrl, allowDataImage = false) {
+    const url = rawUrl.trim();
+    if (!url)
+        return '#';
+    if (/^(https?:\/\/|\/|\.\/|\.\.\/|#)/i.test(url))
+        return url;
+    if (allowDataImage && /^data:image\//i.test(url))
+        return url;
+    return '#';
+}
+function renderPanelMarkdownHtml(name, markdown) {
+    const bodyHtml = escapeHtml(markdown)
+        .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, (_m, alt, url) => {
+        const safeUrl = sanitizeDocUrl(url, true);
+        const safeAlt = alt;
+        return `<img src="${safeUrl}" alt="${safeAlt}" style="max-width:100%;border-radius:8px;border:1px solid #1f2a3a;margin:12px 0;">`;
+    })
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, label, url) => {
+        const safeUrl = sanitizeDocUrl(url);
+        return `<a href="${safeUrl}" target="_blank" rel="noopener">${label}</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');
+    return `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0"><title>${escapeHtml(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>`;
+}
+/**
+ * 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}">`); // lgtm[js/bad-tag-filter] — nonce is crypto-generated
+            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 docsDir = path_1.default.resolve(__dirname, '..', '..', '..', '..', 'docs', 'panels');
+        const docPath = path_1.default.resolve(docsDir, `${name}.md`); // lgtm[js/path-injection] — startsWith guard on next line
+        // Security: verify resolved path stays inside the allowed docs directory
+        if (!docPath.startsWith(docsDir + path_1.default.sep) && docPath !== docsDir) {
+            res.status(400).send('Invalid doc name');
+            return;
+        }
+        try {
+            const md = await (0, promises_1.readFile)(docPath, 'utf-8');
+            res.type('html').send(renderPanelMarkdownHtml(name, md));
+        }
+        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.resolve(screenshotsDir, fileName);
+        // Security: verify resolved path stays inside the allowed screenshots directory
+        if (!filePath.startsWith(screenshotsDir + path_1.default.sep)) {
+            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, rateLimit: { windowMs: 60_000, max: 100 } }));
+    // 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) {
+            console.error('[API] Failed to list instances:', error);
+            res.status(500).json({
+                error: 'Failed to list instances',
+                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;

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

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * Instructions Management Routes
+ * Routes: GET /instructions, GET /instructions_search, GET /instructions_categories,
+ *         GET /instructions/:name, POST /instructions, PUT /instructions/:name,
+ *         DELETE /instructions/:name
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstructionsRoutes = createInstructionsRoutes;
+const node_path_1 = __importDefault(require("node:path"));
+const express_1 = require("express");
+const registry_js_1 = require("../../../server/registry.js");
+const indexContext_js_1 = require("../../../services/indexContext.js");
+const adminAuth_js_1 = require("./adminAuth.js");
+const handlers_search_js_1 = require("../../../services/handlers.search.js");
+/** Sanitize an instruction name with defense-in-depth path-traversal guard. */
+function safeName(name) {
+    const sanitized = String(name).replace(/[^a-zA-Z0-9-_]/g, '-');
+    // Defense-in-depth: verify the resolved path stays inside the instructions directory
+    const base = (0, indexContext_js_1.getInstructionsDir)();
+    const resolved = node_path_1.default.resolve(base, `${sanitized}.json`);
+    const normalized = node_path_1.default.normalize(resolved);
+    if (!normalized.startsWith(node_path_1.default.normalize(base) + node_path_1.default.sep) && normalized !== node_path_1.default.normalize(base)) {
+        throw new Error('Path traversal detected');
+    }
+    return sanitized;
+}
+function createInstructionsRoutes() {
+    const router = (0, express_1.Router)();
+    const buildSnippet = (parts, query) => {
+        const source = parts.filter((part) => typeof part === 'string' && part.trim().length > 0).join('\n');
+        if (!source)
+            return '';
+        const snippetWindow = 120;
+        const lowerSource = source.toLowerCase();
+        const lowerQuery = query.toLowerCase();
+        const matchIndex = lowerSource.indexOf(lowerQuery);
+        const start = matchIndex === -1 ? 0 : Math.max(0, matchIndex - snippetWindow);
+        const end = matchIndex === -1 ? Math.min(source.length, 240) : Math.min(source.length, matchIndex + lowerQuery.length + snippetWindow);
+        let snippet = source.slice(start, end).replace(/\s+/g, ' ').trim();
+        if (!snippet)
+            return '';
+        if (matchIndex !== -1) {
+            snippet = snippet.replace(new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'), match => `**${match}**`);
+        }
+        return snippet;
+    };
+    /**
+     * GET /api/instructions - list all instructions from the store
+     */
+    router.get('/instructions', (_req, res) => {
+        try {
+            const st = res.locals.indexState;
+            const instructions = st.list.map((entry) => {
+                const bodyStr = typeof entry.body === 'string' ? entry.body : '';
+                const bodySize = Buffer.byteLength(bodyStr, 'utf8');
+                const sizeCategory = bodySize < 1024 ? 'small' : (bodySize < 5 * 1024 ? 'medium' : 'large');
+                const cats = Array.isArray(entry.categories) ? entry.categories : [];
+                const primaryCategory = cats.length > 0 ? cats[0] : 'general';
+                let semanticSummary;
+                const desc = entry.description;
+                if (typeof desc === 'string' && desc.trim()) {
+                    semanticSummary = desc.trim();
+                }
+                else if (bodyStr.trim()) {
+                    const firstLine = bodyStr.split(/\r?\n/).map((l) => l.trim()).filter(Boolean)[0];
+                    if (firstLine)
+                        semanticSummary = firstLine;
+                }
+                if (semanticSummary && semanticSummary.length > 400)
+                    semanticSummary = semanticSummary.slice(0, 400) + '…';
+                return {
+                    name: entry.id,
+                    size: bodySize,
+                    mtime: entry.updatedAt ? new Date(entry.updatedAt).getTime() : Date.now(),
+                    category: primaryCategory,
+                    categories: cats.length ? cats : [primaryCategory],
+                    sizeCategory,
+                    semanticSummary,
+                };
+            });
+            res.json({ success: true, instructions, count: instructions.length, timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Failed to list instructions:', error);
+            res.status(500).json({ success: false, error: 'Failed to list instructions' });
+        }
+    });
+    /**
+     * GET /api/instructions_search?q=term&limit=20
+     */
+    router.get('/instructions_search', async (req, res) => {
+        try {
+            const qRaw = String(req.query.q || '').trim();
+            const query = qRaw.slice(0, 256);
+            const limitRaw = parseInt(String(req.query.limit || '20'), 10);
+            const limit = Math.min(100, Math.max(1, isNaN(limitRaw) ? 20 : limitRaw));
+            if (!query || query.length < 2) {
+                return res.json({ success: true, query, count: 0, results: [], note: 'query_too_short' });
+            }
+            const searchResult = await (0, handlers_search_js_1.handleInstructionsSearch)({
+                keywords: [query],
+                limit,
+                includeCategories: true,
+            });
+            const state = res.locals.indexState;
+            const results = [];
+            for (const match of searchResult.results) {
+                try {
+                    const entry = state.byId.get(match.instructionId);
+                    if (!entry)
+                        continue;
+                    const bodyStr = typeof entry.body === 'string' ? entry.body : '';
+                    const snippet = buildSnippet([
+                        entry.id,
+                        entry.title,
+                        entry.semanticSummary,
+                        entry.categories.join(' '),
+                        entry.body,
+                    ], query);
+                    results.push({
+                        name: entry.id,
+                        categories: entry.categories.slice(0, 10),
+                        size: Buffer.byteLength(bodyStr, 'utf8'),
+                        mtime: entry.updatedAt ? new Date(entry.updatedAt).getTime() : Date.now(),
+                        snippet,
+                    });
+                }
+                catch { /* skip file on error */ }
+            }
+            res.json({ success: true, query, count: results.length, results, timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] instructions search error:', error);
+            res.status(500).json({ success: false, error: 'search_failed' });
+        }
+    });
+    /**
+     * GET /api/instructions_categories - get dynamic categories from actual instructions
+     */
+    router.get('/instructions_categories', async (_req, res) => {
+        try {
+            const instructionHandler = (0, registry_js_1.getLocalHandler)('index_dispatch');
+            if (!instructionHandler) {
+                return res.status(500).json({ success: false, error: 'Instruction handler not available' });
+            }
+            const result = await instructionHandler({
+                action: 'categories'
+            });
+            res.json({
+                success: true,
+                categories: result?.categories || [],
+                count: result?.count || 0,
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            console.error('[API] Failed to get categories:', error);
+            res.status(500).json({
+                success: false,
+                error: 'Failed to get categories',
+            });
+        }
+    });
+    /**
+     * GET /api/instructions/:name - get single instruction content
+     */
+    router.get('/instructions/:name', (req, res) => {
+        try {
+            const id = safeName(req.params.name);
+            const st = res.locals.indexState;
+            const entry = st.byId.get(id);
+            if (!entry)
+                return res.status(404).json({ success: false, error: 'Not found' });
+            res.json({ success: true, content: entry, timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Failed to load instruction:', error);
+            res.status(500).json({ success: false, error: 'Failed to load instruction' });
+        }
+    });
+    /**
+     * POST /api/instructions - create new instruction
+     * body: { name, content }
+     */
+    router.post('/instructions', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const { name, content } = req.body || {};
+            if (!name || !content)
+                return res.status(400).json({ success: false, error: 'Missing name or content' });
+            const id = safeName(name);
+            const st = res.locals.indexState;
+            if (st.byId.has(id))
+                return res.status(409).json({ success: false, error: 'Instruction already exists' });
+            const entry = {
+                ...(typeof content === 'object' && content !== null ? content : {}),
+                id,
+                title: (content && typeof content === 'object' ? content.title : undefined) || id,
+                body: (content && typeof content === 'object' ? content.body : undefined) || (typeof content === 'string' ? content : ''),
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+            (0, indexContext_js_1.writeEntry)(entry); // lgtm[js/http-to-file-access] — writes to config-controlled instructions directory
+            (0, indexContext_js_1.touchIndexVersion)();
+            (0, indexContext_js_1.invalidate)();
+            (0, indexContext_js_1.ensureLoaded)();
+            res.json({ success: true, message: 'Instruction created', name: id, timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Failed to create instruction:', error);
+            res.status(500).json({ success: false, error: 'Failed to create instruction' });
+        }
+    });
+    /**
+     * PUT /api/instructions/:name - update existing instruction
+     */
+    router.put('/instructions/:name', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const { content } = req.body || {};
+            const id = safeName(req.params.name);
+            if (!content)
+                return res.status(400).json({ success: false, error: 'Missing content' });
+            const st = res.locals.indexState;
+            const existing = st.byId.get(id);
+            if (!existing)
+                return res.status(404).json({ success: false, error: 'Not found' });
+            const updated = {
+                ...existing,
+                ...(typeof content === 'object' && content !== null ? content : {}),
+                id, // preserve id
+                updatedAt: new Date().toISOString(),
+            };
+            (0, indexContext_js_1.writeEntry)(updated); // lgtm[js/http-to-file-access] — writes to config-controlled instructions directory
+            (0, indexContext_js_1.touchIndexVersion)();
+            (0, indexContext_js_1.invalidate)();
+            (0, indexContext_js_1.ensureLoaded)();
+            res.json({ success: true, message: 'Instruction updated', timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Failed to update instruction:', error);
+            res.status(500).json({ success: false, error: 'Failed to update instruction' });
+        }
+    });
+    /**
+     * DELETE /api/instructions/:name - delete instruction
+     */
+    router.delete('/instructions/:name', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const id = safeName(req.params.name);
+            const st = res.locals.indexState;
+            if (!st.byId.has(id))
+                return res.status(404).json({ success: false, error: 'Not found' });
+            (0, indexContext_js_1.removeEntry)(id);
+            (0, indexContext_js_1.touchIndexVersion)();
+            (0, indexContext_js_1.invalidate)();
+            (0, indexContext_js_1.ensureLoaded)();
+            res.json({ success: true, message: 'Instruction deleted', timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Failed to delete instruction:', error);
+            res.status(500).json({ success: false, error: 'Failed to delete instruction' });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Knowledge Store Routes
+ * Routes: POST /knowledge, GET /knowledge/search, GET /knowledge/:key
+ */
+import { Router } from 'express';
+export declare function createKnowledgeRoutes(): Router;

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

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Knowledge Store Routes
+ * Routes: POST /knowledge, GET /knowledge/search, GET /knowledge/:key
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnowledgeRoutes = createKnowledgeRoutes;
+const express_1 = require("express");
+const KnowledgeStore_js_1 = require("../KnowledgeStore.js");
+const adminAuth_js_1 = require("./adminAuth.js");
+function createKnowledgeRoutes() {
+    const router = (0, express_1.Router)();
+    /**
+     * POST /api/knowledge - Store or update a knowledge entry
+     * Body: { key: string, content: string, metadata?: Record<string, unknown> }
+     */
+    router.post('/knowledge', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const { key, content, metadata } = req.body;
+            if (!key || typeof key !== 'string') {
+                return res.status(400).json({ success: false, error: 'Missing required field: key (string)' });
+            }
+            if (!content || typeof content !== 'string') {
+                return res.status(400).json({ success: false, error: 'Missing required field: content (string)' });
+            }
+            const store = (0, KnowledgeStore_js_1.getKnowledgeStore)();
+            const entry = store.upsert(key, content, metadata || {});
+            res.json({ success: true, entry, timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Knowledge store error:', error);
+            res.status(500).json({
+                success: false,
+                error: 'Failed to store knowledge entry',
+            });
+        }
+    });
+    /**
+     * GET /api/knowledge/search?q=query&category=cat&limit=20
+     */
+    router.get('/knowledge/search', (req, res) => {
+        try {
+            const query = String(req.query.q || '').trim();
+            if (!query) {
+                return res.json({ success: true, query: '', results: [], count: 0, timestamp: Date.now() });
+            }
+            const category = req.query.category ? String(req.query.category) : undefined;
+            const limit = Math.min(100, Math.max(1, parseInt(String(req.query.limit || '20'), 10) || 20));
+            const store = (0, KnowledgeStore_js_1.getKnowledgeStore)();
+            const results = store.search(query, { category, limit });
+            res.json({
+                success: true, query, category: category || null,
+                results, count: results.length, totalEntries: store.count(), timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('[API] Knowledge search error:', error);
+            res.status(500).json({ success: false, error: 'Failed to search knowledge' });
+        }
+    });
+    /**
+     * GET /api/knowledge/:key - Get a specific knowledge entry
+     */
+    router.get('/knowledge/:key', (req, res) => {
+        try {
+            const key = decodeURIComponent(req.params.key);
+            const store = (0, KnowledgeStore_js_1.getKnowledgeStore)();
+            const entry = store.get(key);
+            if (!entry) {
+                return res.status(404).json({ success: false, error: `Knowledge entry not found: ${key}` });
+            }
+            res.json({ success: true, ...entry, timestamp: Date.now() });
+        }
+        catch (error) {
+            console.error('[API] Knowledge get error:', error);
+            res.status(500).json({ success: false, error: 'Failed to get knowledge entry' });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Logs Routes
+ * Routes: GET /logs, GET /logs/stream
+ */
+import { Router } from 'express';
+export declare function createLogsRoutes(): Router;