@jagilber-org/index-server 1.19.1

package/dist/dashboard/server/AdminPanelConfig.d.ts

@@ -0,0 +1,42 @@
+/**
+ * AdminPanelConfig — Configuration rendering and serialization logic.
+ *
+ * Owns the AdminConfig data structure and provides CRUD methods for
+ * reading and updating admin panel configuration.
+ */
+export interface AdminConfig {
+    serverSettings: {
+        maxConnections: number;
+        requestTimeout: number;
+        enableVerboseLogging: boolean;
+        enableMutation: boolean;
+        rateLimit: {
+            windowMs: number;
+            maxRequests: number;
+        };
+    };
+    indexSettings: {
+        autoRefreshInterval: number;
+        cacheSize: number;
+        enableVersioning: boolean;
+    };
+    securitySettings: {
+        enableCors: boolean;
+        allowedOrigins: string[];
+        enableAuthentication: boolean;
+        sessionTimeout: number;
+    };
+}
+export declare class AdminPanelConfig {
+    private config;
+    constructor();
+    private loadDefaultConfig;
+    getAdminConfig(): AdminConfig;
+    updateAdminConfig(updates: Partial<AdminConfig>): {
+        success: boolean;
+        message: string;
+    };
+    private applyConfigChanges;
+    /** Session timeout in milliseconds — consumed by state management. */
+    get sessionTimeout(): number;
+}

package/dist/dashboard/server/AdminPanelConfig.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * AdminPanelConfig — Configuration rendering and serialization logic.
+ *
+ * Owns the AdminConfig data structure and provides CRUD methods for
+ * reading and updating admin panel configuration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminPanelConfig = void 0;
+const runtimeConfig_1 = require("../../config/runtimeConfig");
+class AdminPanelConfig {
+    config;
+    constructor() {
+        this.config = this.loadDefaultConfig();
+    }
+    loadDefaultConfig() {
+        const runtimeConfig = (0, runtimeConfig_1.getRuntimeConfig)();
+        const serverHttp = runtimeConfig.dashboard.http;
+        return {
+            serverSettings: {
+                maxConnections: serverHttp?.maxConnections ?? 100,
+                requestTimeout: serverHttp?.requestTimeoutMs ?? 30000,
+                enableVerboseLogging: !!serverHttp?.verboseLogging,
+                enableMutation: runtimeConfig.mutation.enabled,
+                rateLimit: {
+                    windowMs: 60000,
+                    maxRequests: 100
+                }
+            },
+            indexSettings: {
+                autoRefreshInterval: 300000,
+                cacheSize: 1000,
+                enableVersioning: true
+            },
+            securitySettings: {
+                enableCors: false,
+                allowedOrigins: ['http://localhost', 'http://127.0.0.1', 'https://localhost', 'https://127.0.0.1'],
+                enableAuthentication: false,
+                sessionTimeout: 3600000
+            }
+        };
+    }
+    getAdminConfig() {
+        return JSON.parse(JSON.stringify(this.config));
+    }
+    updateAdminConfig(updates) {
+        try {
+            this.config = { ...this.config, ...updates };
+            this.applyConfigChanges(updates);
+            return { success: true, message: 'Configuration updated successfully' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to update configuration: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    applyConfigChanges(updates) {
+        if (updates.serverSettings) {
+            let runtimeReloadNeeded = false;
+            if (updates.serverSettings.enableVerboseLogging !== undefined) {
+                process.env.INDEX_SERVER_VERBOSE_LOGGING = updates.serverSettings.enableVerboseLogging ? '1' : '0';
+                runtimeReloadNeeded = true;
+            }
+            if (updates.serverSettings.enableMutation !== undefined) {
+                process.env.INDEX_SERVER_MUTATION = updates.serverSettings.enableMutation ? '1' : '0';
+                runtimeReloadNeeded = true;
+            }
+            if (runtimeReloadNeeded) {
+                (0, runtimeConfig_1.reloadRuntimeConfig)();
+            }
+        }
+    }
+    /** Session timeout in milliseconds — consumed by state management. */
+    get sessionTimeout() {
+        return this.config.securitySettings.sessionTimeout;
+    }
+}
+exports.AdminPanelConfig = AdminPanelConfig;

package/dist/dashboard/server/AdminPanelState.d.ts

@@ -0,0 +1,47 @@
+/**
+ * AdminPanelState — Session state management logic.
+ *
+ * Manages active admin sessions and session history, including
+ * persistence, creation, termination, and cleanup of expired sessions.
+ */
+export interface AdminSession {
+    id: string;
+    userId: string;
+    startTime: Date;
+    lastActivity: Date;
+    ipAddress: string;
+    userAgent: string;
+    permissions: string[];
+}
+export interface AdminSessionHistoryEntry {
+    id: string;
+    userId: string;
+    startTime: Date;
+    endTime?: Date;
+    ipAddress: string;
+    userAgent: string;
+    terminated?: boolean;
+    terminationReason?: string;
+}
+export declare class AdminPanelState {
+    readonly activeSessions: Map<string, AdminSession>;
+    private sessionHistory;
+    private sessionHistoryIndex;
+    private persistenceManager;
+    private get maxSessionHistory();
+    constructor();
+    initializePersistence(): Promise<void>;
+    persistSessionState(): Promise<void>;
+    getActiveSessions(sessionTimeout: number): AdminSession[];
+    createAdminSession(userId: string, ipAddress: string, userAgent: string): AdminSession;
+    terminateSession(sessionId: string): boolean;
+    cleanupExpiredSessions(sessionTimeout: number): void;
+    generateSessionId(): string;
+    getSessionHistory(limit?: number): AdminSessionHistoryEntry[];
+    clearSessionHistory(): Promise<{
+        success: boolean;
+        message: string;
+        clearedCount: number;
+    }>;
+    updateSessionActivity(sessionId: string): boolean;
+}

package/dist/dashboard/server/AdminPanelState.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * AdminPanelState — Session state management logic.
+ *
+ * Manages active admin sessions and session history, including
+ * persistence, creation, termination, and cleanup of expired sessions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminPanelState = void 0;
+const runtimeConfig_1 = require("../../config/runtimeConfig");
+const SessionPersistenceManager_1 = require("./SessionPersistenceManager");
+class AdminPanelState {
+    activeSessions = new Map();
+    sessionHistory = [];
+    sessionHistoryIndex = new Map();
+    persistenceManager;
+    get maxSessionHistory() {
+        const value = (0, runtimeConfig_1.getRuntimeConfig)().dashboard.admin.maxSessionHistory;
+        return Number.isFinite(value) ? value : 200;
+    }
+    constructor() {
+        this.persistenceManager = new SessionPersistenceManager_1.SessionPersistenceManager();
+        this.initializePersistence();
+    }
+    async initializePersistence() {
+        try {
+            const persistedData = await this.persistenceManager.loadData();
+            if (persistedData) {
+                this.activeSessions.clear();
+                persistedData.adminSessions.forEach(persistedSession => {
+                    const adminSession = {
+                        id: persistedSession.id,
+                        userId: persistedSession.userId,
+                        startTime: new Date(persistedSession.startTime),
+                        lastActivity: new Date(persistedSession.lastActivity),
+                        ipAddress: persistedSession.ipAddress,
+                        userAgent: persistedSession.userAgent,
+                        permissions: persistedSession.permissions
+                    };
+                    this.activeSessions.set(adminSession.id, adminSession);
+                });
+                this.sessionHistory = [];
+                this.sessionHistoryIndex.clear();
+                persistedData.sessionHistory.forEach(persistedEntry => {
+                    const historyEntry = {
+                        id: persistedEntry.id,
+                        userId: persistedEntry.userId,
+                        startTime: new Date(persistedEntry.startTime),
+                        endTime: persistedEntry.endTime ? new Date(persistedEntry.endTime) : undefined,
+                        ipAddress: persistedEntry.ipAddress,
+                        userAgent: persistedEntry.userAgent,
+                        terminated: persistedEntry.terminated,
+                        terminationReason: persistedEntry.terminationReason
+                    };
+                    this.sessionHistory.push(historyEntry);
+                    this.sessionHistoryIndex.set(historyEntry.id, historyEntry);
+                });
+                console.log(`Loaded ${this.activeSessions.size} active sessions and ${this.sessionHistory.length} history entries from persistence`);
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize session persistence:', error);
+        }
+    }
+    async persistSessionState() {
+        try {
+            const adminSessions = Array.from(this.activeSessions.values()).map(session => ({
+                id: session.id,
+                userId: session.userId,
+                startTime: session.startTime.toISOString(),
+                lastActivity: session.lastActivity.toISOString(),
+                ipAddress: session.ipAddress,
+                userAgent: session.userAgent,
+                permissions: session.permissions,
+                persistedAt: new Date().toISOString(),
+                version: 1
+            }));
+            const sessionHistory = this.sessionHistory.map(entry => ({
+                id: entry.id,
+                userId: entry.userId,
+                startTime: entry.startTime.toISOString(),
+                endTime: entry.endTime?.toISOString(),
+                ipAddress: entry.ipAddress,
+                userAgent: entry.userAgent,
+                terminated: entry.terminated,
+                terminationReason: entry.terminationReason,
+                persistedAt: new Date().toISOString(),
+                version: 1
+            }));
+            const persistedData = {
+                adminSessions,
+                webSocketConnections: [],
+                sessionHistory,
+                metadata: {
+                    lastPersisted: new Date().toISOString(),
+                    version: 1,
+                    totalSessions: adminSessions.length,
+                    totalConnections: 0,
+                    totalHistoryEntries: sessionHistory.length,
+                    checksums: { sessions: '', connections: '', history: '' }
+                }
+            };
+            await this.persistenceManager.persistData(persistedData);
+        }
+        catch (error) {
+            console.error('Failed to persist session state:', error);
+        }
+    }
+    getActiveSessions(sessionTimeout) {
+        this.cleanupExpiredSessions(sessionTimeout);
+        return Array.from(this.activeSessions.values());
+    }
+    createAdminSession(userId, ipAddress, userAgent) {
+        const session = {
+            id: this.generateSessionId(),
+            userId,
+            startTime: new Date(),
+            lastActivity: new Date(),
+            ipAddress,
+            userAgent,
+            permissions: ['read', 'write', 'admin']
+        };
+        this.activeSessions.set(session.id, session);
+        const hist = {
+            id: session.id,
+            userId: session.userId,
+            startTime: session.startTime,
+            ipAddress: session.ipAddress,
+            userAgent: session.userAgent
+        };
+        this.sessionHistory.unshift(hist);
+        this.sessionHistoryIndex.set(hist.id, hist);
+        if (this.sessionHistory.length > this.maxSessionHistory) {
+            const removed = this.sessionHistory.pop();
+            if (removed)
+                this.sessionHistoryIndex.delete(removed.id);
+        }
+        this.persistSessionState().catch(error => {
+            console.error('Failed to persist session state after creation:', error);
+        });
+        return session;
+    }
+    terminateSession(sessionId) {
+        const existed = this.activeSessions.delete(sessionId);
+        if (existed) {
+            const hist = this.sessionHistoryIndex.get(sessionId);
+            if (hist && !hist.terminated) {
+                hist.endTime = new Date();
+                hist.terminated = true;
+                hist.terminationReason = 'manual';
+            }
+            this.persistSessionState().catch(error => {
+                console.error('Failed to persist session state after termination:', error);
+            });
+        }
+        return existed;
+    }
+    cleanupExpiredSessions(sessionTimeout) {
+        const now = new Date();
+        let hasChanges = false;
+        for (const [id, session] of this.activeSessions.entries()) {
+            if (now.getTime() - session.lastActivity.getTime() > sessionTimeout) {
+                this.activeSessions.delete(id);
+                const hist = this.sessionHistoryIndex.get(id);
+                if (hist && !hist.terminated) {
+                    hist.endTime = new Date();
+                    hist.terminated = true;
+                    hist.terminationReason = 'expired';
+                }
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            this.persistSessionState().catch(error => {
+                console.error('Failed to persist session state after cleanup:', error);
+            });
+        }
+    }
+    generateSessionId() {
+        return `admin_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    getSessionHistory(limit) {
+        const slice = typeof limit === 'number' ? this.sessionHistory.slice(0, Math.max(0, limit)) : this.sessionHistory;
+        return slice.map(h => ({ ...h }));
+    }
+    async clearSessionHistory() {
+        try {
+            const clearedCount = this.sessionHistory.length;
+            this.sessionHistory = [];
+            this.sessionHistoryIndex.clear();
+            await this.persistSessionState();
+            return { success: true, message: `Successfully cleared ${clearedCount} session history entries`, clearedCount };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to clear session history: ${error instanceof Error ? error.message : String(error)}`,
+                clearedCount: 0
+            };
+        }
+    }
+    updateSessionActivity(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (session) {
+            session.lastActivity = new Date();
+            this.persistSessionState().catch(error => {
+                console.error('Failed to persist session activity update:', error);
+            });
+            return true;
+        }
+        return false;
+    }
+}
+exports.AdminPanelState = AdminPanelState;

package/dist/dashboard/server/ApiRoutes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ApiRoutes - Dashboard REST API Orchestrator
+ *
+ * Thin composition layer that mounts route modules from ./routes/ and applies
+ * shared middleware (CORS, JSON parsing, HTTP metrics instrumentation, error
+ * handling). Individual route handlers live in their own focused modules.
+ */
+import { Router } from 'express';
+export interface ApiRoutesOptions {
+    enableCors?: boolean;
+    rateLimit?: {
+        windowMs: number;
+        max: number;
+    };
+}
+export declare function createApiRoutes(options?: ApiRoutesOptions): Router;
+export default createApiRoutes;

package/dist/dashboard/server/ApiRoutes.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * ApiRoutes - Dashboard REST API Orchestrator
+ *
+ * Thin composition layer that mounts route modules from ./routes/ and applies
+ * shared middleware (CORS, JSON parsing, HTTP metrics instrumentation, error
+ * handling). Individual route handlers live in their own focused modules.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiRoutes = createApiRoutes;
+const express_1 = __importStar(require("express"));
+const MetricsCollector_js_1 = require("./MetricsCollector.js");
+const auditLog_1 = require("../../services/auditLog");
+const runtimeConfig_js_1 = require("../../config/runtimeConfig.js");
+const index_js_1 = require("./routes/index.js");
+function createApiRoutes(options = {}) {
+    const router = (0, express_1.Router)();
+    const metricsCollector = (0, MetricsCollector_js_1.getMetricsCollector)();
+    // CORS middleware (if enabled)
+    if (options.enableCors) {
+        router.use((req, res, next) => {
+            const origin = req.headers.origin;
+            if (origin && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+                res.header('Access-Control-Allow-Origin', origin);
+            }
+            res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            next();
+        });
+    }
+    // JSON middleware
+    router.use(express_1.default.json());
+    // --- HTTP Metrics Instrumentation ---------------------------------------
+    try {
+        const enableHttpMetrics = (0, runtimeConfig_js_1.getRuntimeConfig)().dashboard.http.enableHttpMetrics;
+        if (enableHttpMetrics) {
+            const normalizeRoute = (req) => {
+                if (req.route?.path)
+                    return req.route.path;
+                return req.path
+                    .replace(/\/[0-9a-f]{8,}/gi, '/:id')
+                    .replace(/\/\d+/g, '/:id');
+            };
+            router.use((req, res, next) => {
+                const startNs = typeof process.hrtime === 'function' ? process.hrtime.bigint() : BigInt(Date.now()) * 1000000n;
+                res.on('finish', () => {
+                    try {
+                        const endNs = typeof process.hrtime === 'function' ? process.hrtime.bigint() : BigInt(Date.now()) * 1000000n;
+                        const ms = Number(endNs - startNs) / 1_000_000;
+                        const success = res.statusCode < 500;
+                        const route = normalizeRoute(req);
+                        const toolId = `http/${req.method} ${route}`;
+                        metricsCollector.recordToolCall(toolId, success, ms, success ? undefined : `http_${res.statusCode}`);
+                    }
+                    catch { /* never block response path */ }
+                });
+                next();
+            });
+        }
+    }
+    catch { /* ignore instrumentation failures */ }
+    // -------------------------------------------------------------------------
+    // --- HTTP Audit Logging -------------------------------------------------
+    // Logs every HTTP request to the audit trail with client IP, method, route,
+    // status code, and duration. Fires on response finish (non-blocking).
+    router.use((req, res, next) => {
+        const startNs = typeof process.hrtime === 'function' ? process.hrtime.bigint() : BigInt(Date.now()) * 1000000n;
+        res.on('finish', () => {
+            try {
+                const endNs = typeof process.hrtime === 'function' ? process.hrtime.bigint() : BigInt(Date.now()) * 1000000n;
+                const ms = Number(endNs - startNs) / 1_000_000;
+                const route = req.route?.path ?? req.path;
+                const clientIp = req.ip || req.socket?.remoteAddress;
+                const userAgent = req.get('user-agent');
+                (0, auditLog_1.logHttpAudit)(req.method, route, res.statusCode, ms, clientIp, userAgent);
+            }
+            catch { /* never block response path */ }
+        });
+        next();
+    });
+    // Cache-control: API responses should not be cached (pen test I2 fix)
+    router.use((_req, res, next) => {
+        res.header('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+        res.header('Pragma', 'no-cache');
+        next();
+    });
+    // -------------------------------------------------------------------------
+    // Mount route modules
+    router.use((0, index_js_1.createStatusRoutes)(metricsCollector));
+    router.use((0, index_js_1.createMetricsRoutes)(metricsCollector));
+    router.use((0, index_js_1.createAdminRoutes)(metricsCollector));
+    router.use((0, index_js_1.createGraphRoutes)());
+    router.use((0, index_js_1.createInstructionsRoutes)());
+    router.use((0, index_js_1.createKnowledgeRoutes)());
+    router.use((0, index_js_1.createAlertsRoutes)(metricsCollector));
+    router.use((0, index_js_1.createLogsRoutes)());
+    router.use((0, index_js_1.createSyntheticRoutes)(metricsCollector));
+    router.use((0, index_js_1.createInstancesRoutes)());
+    router.use((0, index_js_1.createToolsRoutes)());
+    router.use((0, index_js_1.createEmbeddingsRoutes)());
+    router.use((0, index_js_1.createUsageRoutes)());
+    router.use((0, index_js_1.createScriptsRoutes)());
+    router.use((0, index_js_1.createMessagingRoutes)());
+    router.use((0, index_js_1.createSqliteRoutes)());
+    // Error handling middleware
+    router.use((error, _req, res, _next) => {
+        console.error('[API] Unhandled error:', error);
+        res.status(500).json({
+            error: 'Internal server error',
+            message: error.message,
+            timestamp: Date.now(),
+        });
+    });
+    return router;
+}
+exports.default = createApiRoutes;

package/dist/dashboard/server/DashboardServer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * DashboardServer - Enhanced Phase 2 Dashboard with Real-time Features
+ *
+ * Coordinator class that wires together:
+ *  - Express middleware and routes (via mountDashboardRoutes)
+ *  - HTTP/HTTPS server lifecycle (via httpLifecycle)
+ *  - WebSocket initialization and metrics broadcast (via wsInit)
+ */
+import { TlsOptions } from './httpLifecycle.js';
+export interface DashboardServerOptions {
+    host?: string;
+    port?: number;
+    maxPortTries?: number;
+    enableWebSockets?: boolean;
+    enableCors?: boolean;
+    /** Interval (ms) for broadcasting metrics_update messages over WebSocket (default 5000). */
+    metricsBroadcastIntervalMs?: number;
+    /** TLS certificate and key for HTTPS. When provided the dashboard serves over HTTPS/WSS. */
+    tls?: TlsOptions;
+    /** Enable the Graph visualization tab (loads ~4.5MB of mermaid+elkjs). Default false. */
+    graphEnabled?: boolean;
+}
+interface ServerInfo {
+    port: number;
+    host: string;
+    url: string;
+}
+export declare class DashboardServer {
+    private app;
+    private server;
+    private metricsCollector;
+    private webSocketManager;
+    private metricsBroadcastTimer;
+    private options;
+    private get tlsEnabled();
+    private get httpProtocol();
+    private get wsProtocol();
+    constructor(options?: DashboardServerOptions);
+    start(): Promise<{
+        url: string;
+        port: number;
+        close: () => void;
+    }>;
+    stop(): Promise<void>;
+    getServerInfo(): ServerInfo | null;
+    private setupMiddleware;
+}
+export declare function createDashboardServer(options?: DashboardServerOptions): DashboardServer;
+export default createDashboardServer;