@jagilber-org/index-server 1.19.1

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

@@ -0,0 +1,336 @@
+"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 express_1 = require("express");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
+const registry_js_1 = require("../../../server/registry.js");
+const indexContext_js_1 = require("../../../services/indexContext.js");
+const handlers_search_js_1 = require("../../../services/handlers.search.js");
+function resolveInstructionsDir() {
+    const config = (0, runtimeConfig_js_1.getRuntimeConfig)();
+    const configured = config.dashboard.admin.instructionsDir || config.index.baseDir;
+    return configured && configured.trim().length ? configured : path_1.default.join(process.cwd(), 'instructions');
+}
+function ensureInstructionsDir() {
+    const instructionsDir = resolveInstructionsDir();
+    try {
+        if (!fs_1.default.existsSync(instructionsDir))
+            fs_1.default.mkdirSync(instructionsDir, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    return instructionsDir;
+}
+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 instruction JSON files
+     */
+    router.get('/instructions', (_req, res) => {
+        try {
+            const instructionsDir = ensureInstructionsDir();
+            const classify = (basename) => {
+                const lower = basename.toLowerCase();
+                let category = 'general';
+                if (lower.startsWith('alpha'))
+                    category = 'alpha';
+                else if (lower.startsWith('beta'))
+                    category = 'beta';
+                else if (lower.includes('seed'))
+                    category = 'seed';
+                else if (lower.includes('enterprise'))
+                    category = 'enterprise';
+                else if (lower.includes('dispatcher'))
+                    category = 'dispatcher';
+                return { category, sizeCategory: 'small' };
+            };
+            const files = fs_1.default.readdirSync(instructionsDir)
+                .filter(f => f.toLowerCase().endsWith('.json'))
+                .map(f => {
+                const abs = path_1.default.join(instructionsDir, f);
+                const stat = fs_1.default.statSync(abs);
+                const base = f.replace(/\.json$/i, '');
+                const meta = classify(base);
+                const sizeCategory = stat.size < 1024 ? 'small' : (stat.size < 5 * 1024 ? 'medium' : 'large');
+                let primaryCategory = meta.category;
+                let categories = [];
+                let semanticSummary;
+                try {
+                    const raw = fs_1.default.readFileSync(abs, 'utf8');
+                    if (raw.length < 1_000_000) {
+                        const json = JSON.parse(raw);
+                        const getProp = (obj, key) => {
+                            if (obj && typeof obj === 'object' && key in obj) {
+                                return obj[key];
+                            }
+                            return undefined;
+                        };
+                        const rawCats = getProp(json, 'categories');
+                        if (Array.isArray(rawCats)) {
+                            categories = rawCats
+                                .filter((c) => typeof c === 'string')
+                                .map(c => c.trim())
+                                .filter(c => !!c);
+                        }
+                        const rawPrimary = getProp(json, 'category');
+                        if (typeof rawPrimary === 'string') {
+                            const c = rawPrimary.trim();
+                            if (c)
+                                primaryCategory = c;
+                            if (c && !categories.includes(c))
+                                categories.push(c);
+                        }
+                        const fileMeta = getProp(json, 'meta');
+                        if (fileMeta && typeof fileMeta === 'object') {
+                            const metaPrimary = getProp(fileMeta, 'category');
+                            if (typeof metaPrimary === 'string') {
+                                const c = metaPrimary.trim();
+                                if (c)
+                                    primaryCategory = c;
+                                if (c && !categories.includes(c))
+                                    categories.push(c);
+                            }
+                            const metaCats = getProp(fileMeta, 'categories');
+                            if (Array.isArray(metaCats)) {
+                                for (const c of metaCats) {
+                                    if (typeof c === 'string') {
+                                        const norm = c.trim();
+                                        if (norm && !categories.includes(norm))
+                                            categories.push(norm);
+                                    }
+                                }
+                            }
+                            const metaSummary = getProp(fileMeta, 'semanticSummary');
+                            if (typeof metaSummary === 'string' && metaSummary.trim())
+                                semanticSummary = metaSummary.trim();
+                        }
+                        if (!semanticSummary) {
+                            const topSummary = getProp(json, 'semanticSummary');
+                            if (typeof topSummary === 'string' && topSummary.trim())
+                                semanticSummary = topSummary.trim();
+                        }
+                        if (!semanticSummary) {
+                            const desc = getProp(json, 'description');
+                            if (typeof desc === 'string' && desc.trim())
+                                semanticSummary = desc.trim();
+                        }
+                        if (!semanticSummary) {
+                            const body = getProp(json, 'body');
+                            if (typeof body === 'string' && body.trim()) {
+                                const firstLine = body.split(/\r?\n/).map(l => l.trim()).filter(Boolean)[0];
+                                if (firstLine)
+                                    semanticSummary = firstLine;
+                            }
+                        }
+                        if (semanticSummary) {
+                            if (semanticSummary.length > 400)
+                                semanticSummary = semanticSummary.slice(0, 400) + '…';
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors; fall back to heuristic classification only
+                }
+                if (!categories.length && primaryCategory)
+                    categories = [primaryCategory];
+                categories = Array.from(new Set(categories));
+                return {
+                    name: base,
+                    size: stat.size,
+                    mtime: stat.mtimeMs,
+                    category: primaryCategory,
+                    categories,
+                    sizeCategory,
+                    semanticSummary,
+                };
+            });
+            res.json({ success: true, instructions: files, count: files.length, timestamp: Date.now() });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: 'Failed to list instructions', message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    /**
+     * GET /api/instructions_search?q=term&limit=20
+     */
+    router.get('/instructions_search', async (req, res) => {
+        try {
+            const instructionsDir = ensureInstructionsDir();
+            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],
+                mode: 'keyword',
+                limit,
+                includeCategories: true,
+            });
+            const state = (0, indexContext_js_1.ensureLoaded)();
+            const results = [];
+            for (const match of searchResult.results) {
+                try {
+                    const entry = state.byId.get(match.instructionId);
+                    if (!entry)
+                        continue;
+                    const abs = path_1.default.join(instructionsDir, `${entry.id}.json`);
+                    const stat = fs_1.default.existsSync(abs) ? fs_1.default.statSync(abs) : undefined;
+                    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: stat?.size ?? Buffer.byteLength(JSON.stringify(entry), 'utf8'),
+                        mtime: stat?.mtimeMs ?? 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', message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    /**
+     * 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) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to get categories',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    /**
+     * GET /api/instructions/:name - get single instruction content
+     */
+    router.get('/instructions/:name', (req, res) => {
+        try {
+            const instructionsDir = ensureInstructionsDir();
+            const file = path_1.default.join(instructionsDir, req.params.name + '.json');
+            if (!fs_1.default.existsSync(file))
+                return res.status(404).json({ success: false, error: 'Not found' });
+            const content = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+            res.json({ success: true, content, timestamp: Date.now() });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: 'Failed to load instruction', message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    /**
+     * POST /api/instructions - create new instruction
+     * body: { name, content }
+     */
+    router.post('/instructions', (req, res) => {
+        try {
+            const instructionsDir = ensureInstructionsDir();
+            const { name, content } = req.body || {};
+            if (!name || !content)
+                return res.status(400).json({ success: false, error: 'Missing name or content' });
+            const safeName = String(name).replace(/[^a-zA-Z0-9-_]/g, '-');
+            const file = path_1.default.join(instructionsDir, safeName + '.json');
+            if (fs_1.default.existsSync(file))
+                return res.status(409).json({ success: false, error: 'Instruction already exists' });
+            fs_1.default.writeFileSync(file, JSON.stringify(content, null, 2));
+            res.json({ success: true, message: 'Instruction created', name: safeName, timestamp: Date.now() });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: 'Failed to create instruction', message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    /**
+     * PUT /api/instructions/:name - update existing instruction
+     */
+    router.put('/instructions/:name', (req, res) => {
+        try {
+            const instructionsDir = ensureInstructionsDir();
+            const { content } = req.body || {};
+            const name = req.params.name;
+            if (!content)
+                return res.status(400).json({ success: false, error: 'Missing content' });
+            const file = path_1.default.join(instructionsDir, name + '.json');
+            if (!fs_1.default.existsSync(file))
+                return res.status(404).json({ success: false, error: 'Not found' });
+            fs_1.default.writeFileSync(file, JSON.stringify(content, null, 2));
+            res.json({ success: true, message: 'Instruction updated', timestamp: Date.now() });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: 'Failed to update instruction', message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    /**
+     * DELETE /api/instructions/:name - delete instruction
+     */
+    router.delete('/instructions/:name', (req, res) => {
+        try {
+            const instructionsDir = ensureInstructionsDir();
+            const file = path_1.default.join(instructionsDir, req.params.name + '.json');
+            if (!fs_1.default.existsSync(file))
+                return res.status(404).json({ success: false, error: 'Not found' });
+            fs_1.default.unlinkSync(file);
+            res.json({ success: true, message: 'Instruction deleted', timestamp: Date.now() });
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: 'Failed to delete instruction', message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    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,82 @@
+"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");
+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', (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',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * 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',
+                message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    /**
+     * 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',
+                message: error instanceof Error ? error.message : 'Unknown error' });
+        }
+    });
+    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;

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

@@ -0,0 +1,164 @@
+"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',
+                message: error instanceof Error ? error.message : 'Unknown error',
+                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) => {
+                            res.write(`data: ${JSON.stringify({
+                                type: 'error',
+                                message: error.message,
+                                timestamp: Date.now()
+                            })}\n\n`);
+                        });
+                    }
+                }
+                catch (error) {
+                    res.write(`data: ${JSON.stringify({
+                        type: 'error',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                        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) {
+            res.write(`data: ${JSON.stringify({
+                type: 'error',
+                message: error instanceof Error ? 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;