@esotech/contextuate 2.0.0 → 2.1.0

package/dist/monitor/server/fastify.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Fastify HTTP Server
+ *
+ * Serves the Vue UI and provides REST API endpoints
+ * for the monitor dashboard.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFastifyServer = createFastifyServer;
+const fastify_1 = __importDefault(require("fastify"));
+const static_1 = __importDefault(require("@fastify/static"));
+const cors_1 = __importDefault(require("@fastify/cors"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+async function createFastifyServer(options) {
+    const { host, port, broker, persistence } = options;
+    const app = (0, fastify_1.default)({
+        logger: {
+            level: 'warn',
+        },
+    });
+    // Enable CORS for development
+    await app.register(cors_1.default, {
+        origin: true,
+        credentials: true,
+    });
+    // Serve static UI files
+    // When running from dist/, __dirname is dist/monitor/server/
+    // UI is at dist/monitor/ui/
+    const uiDistPath = path.join(__dirname, '../ui');
+    // When running from src/ during dev, UI dist is at src/monitor/ui/dist/
+    const uiDevPath = path.join(__dirname, '../ui/dist');
+    let staticPath = null;
+    // Check for index.html to confirm it's the right directory
+    if (fs.existsSync(path.join(uiDistPath, 'index.html'))) {
+        staticPath = uiDistPath;
+    }
+    else if (fs.existsSync(path.join(uiDevPath, 'index.html'))) {
+        staticPath = uiDevPath;
+    }
+    if (!staticPath) {
+        console.warn('[HTTP] Warning: UI static files not found. Tried:', uiDistPath, uiDevPath);
+    }
+    if (staticPath) {
+        await app.register(static_1.default, {
+            root: staticPath,
+            prefix: '/',
+        });
+    }
+    // API Routes
+    /**
+     * GET /api/status
+     * Returns server status and configuration
+     */
+    app.get('/api/status', async () => {
+        const config = broker.getConfig();
+        return {
+            status: 'running',
+            mode: config.mode,
+            sessions: broker.getSessions().length,
+            activeSessions: broker.getSessions().filter(s => s.status === 'active').length,
+            uptime: process.uptime(),
+            version: '1.0.0',
+        };
+    });
+    /**
+     * GET /api/sessions
+     * Returns all sessions
+     */
+    app.get('/api/sessions', async () => {
+        return {
+            sessions: broker.getSessions(),
+        };
+    });
+    /**
+     * GET /api/sessions/:sessionId
+     * Returns a specific session
+     */
+    app.get('/api/sessions/:sessionId', async (request, reply) => {
+        const session = broker.getSession(request.params.sessionId);
+        if (!session) {
+            reply.code(404);
+            return { error: 'Session not found' };
+        }
+        return { session };
+    });
+    /**
+     * GET /api/sessions/:sessionId/events
+     * Returns events for a session
+     */
+    app.get('/api/sessions/:sessionId/events', async (request, reply) => {
+        if (!persistence) {
+            reply.code(503);
+            return { error: 'Persistence not configured' };
+        }
+        const { sessionId } = request.params;
+        const limit = request.query.limit ? parseInt(request.query.limit) : 100;
+        const before = request.query.before ? parseInt(request.query.before) : undefined;
+        const after = request.query.after ? parseInt(request.query.after) : undefined;
+        try {
+            const events = await persistence.getEvents(sessionId, { limit, before, after });
+            return { events };
+        }
+        catch (err) {
+            reply.code(500);
+            return { error: 'Failed to fetch events' };
+        }
+    });
+    /**
+     * GET /api/config
+     * Returns current configuration (sanitized)
+     */
+    app.get('/api/config', async () => {
+        const config = broker.getConfig();
+        return {
+            mode: config.mode,
+            server: {
+                host: config.server.host,
+                port: config.server.port,
+                wsPort: config.server.wsPort,
+            },
+            persistence: {
+                enabled: config.persistence.enabled,
+                type: config.persistence.type,
+            },
+        };
+    });
+    /**
+     * Health check endpoint
+     */
+    app.get('/health', async () => {
+        return { status: 'ok' };
+    });
+    // SPA fallback - serve index.html for all non-API routes
+    if (staticPath) {
+        app.setNotFoundHandler(async (request, reply) => {
+            if (!request.url.startsWith('/api/')) {
+                return reply.sendFile('index.html');
+            }
+            reply.code(404);
+            return { error: 'Not found' };
+        });
+    }
+    // Start the server
+    await app.listen({ host, port });
+    console.log(`[HTTP] Server listening on http://${host}:${port}`);
+    return app;
+}

package/dist/monitor/server/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Monitor Server
+ *
+ * Main entry point for the monitor server.
+ * Orchestrates all components: broker, HTTP server, WebSocket server, persistence.
+ */
+import type { FastifyInstance } from 'fastify';
+import type { MonitorConfig } from '../../types/monitor';
+import { EventBroker } from './broker';
+import { MonitorWebSocketServer } from './websocket';
+import { FileStore } from '../persistence/file-store';
+export interface MonitorServer {
+    broker: EventBroker;
+    http: FastifyInstance;
+    ws: MonitorWebSocketServer;
+    persistence: FileStore;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+}
+export interface CreateServerOptions {
+    config: MonitorConfig;
+    dataDir?: string;
+}
+/**
+ * Create and configure the monitor server
+ */
+export declare function createMonitorServer(options: CreateServerOptions): Promise<MonitorServer>;
+/**
+ * Default configuration
+ */
+export declare function getDefaultConfig(): MonitorConfig;
+export { EventBroker } from './broker';
+export { UnixSocketAdapter } from './adapters/unix-socket';
+export { RedisAdapter } from './adapters/redis';
+export { createFastifyServer } from './fastify';
+export { MonitorWebSocketServer } from './websocket';

package/dist/monitor/server/index.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Monitor Server
+ *
+ * Main entry point for the monitor server.
+ * Orchestrates all components: broker, HTTP server, WebSocket server, persistence.
+ */
+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.MonitorWebSocketServer = exports.createFastifyServer = exports.RedisAdapter = exports.UnixSocketAdapter = exports.EventBroker = void 0;
+exports.createMonitorServer = createMonitorServer;
+exports.getDefaultConfig = getDefaultConfig;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const broker_1 = require("./broker");
+const fastify_1 = require("./fastify");
+const websocket_1 = require("./websocket");
+const file_store_1 = require("../persistence/file-store");
+/**
+ * Create and configure the monitor server
+ */
+async function createMonitorServer(options) {
+    const { config } = options;
+    const dataDir = options.dataDir || path.join(os.homedir(), '.contextuate');
+    // Initialize persistence
+    const persistence = new file_store_1.FileStore({
+        baseDir: dataDir,
+    });
+    await persistence.init();
+    // Initialize broker
+    const broker = new broker_1.EventBroker(config);
+    broker.setPersistence(persistence);
+    // Initialize HTTP server
+    const http = await (0, fastify_1.createFastifyServer)({
+        host: config.server.host,
+        port: config.server.port,
+        broker,
+        persistence,
+    });
+    // Initialize WebSocket server
+    const ws = new websocket_1.MonitorWebSocketServer({
+        host: config.server.host,
+        port: config.server.wsPort,
+        broker,
+        persistence,
+    });
+    const server = {
+        broker,
+        http,
+        ws,
+        persistence,
+        async start() {
+            // Load existing sessions
+            await broker.loadSessions();
+            // Start the broker (IPC adapter)
+            await broker.start();
+            // Start WebSocket server
+            await ws.start();
+            console.log('');
+            console.log('='.repeat(50));
+            console.log('  Contextuate Monitor Server');
+            console.log('='.repeat(50));
+            console.log(`  Mode:        ${config.mode}`);
+            console.log(`  HTTP:        http://${config.server.host}:${config.server.port}`);
+            console.log(`  WebSocket:   ws://${config.server.host}:${config.server.wsPort}`);
+            console.log(`  Data:        ${dataDir}`);
+            if (config.mode === 'local') {
+                console.log(`  Socket:      ${config.socketPath}`);
+            }
+            else {
+                console.log(`  Redis:       ${config.redis.host}:${config.redis.port}`);
+            }
+            console.log('='.repeat(50));
+            console.log('');
+        },
+        async stop() {
+            console.log('[Server] Shutting down...');
+            await ws.stop();
+            await broker.stop();
+            await http.close();
+            await persistence.close();
+            console.log('[Server] Stopped');
+        },
+    };
+    return server;
+}
+/**
+ * Default configuration
+ */
+function getDefaultConfig() {
+    return {
+        mode: 'local',
+        server: {
+            host: '0.0.0.0',
+            port: 3847,
+            wsPort: 3848,
+        },
+        redis: {
+            host: 'localhost',
+            port: 6379,
+            password: null,
+            channel: 'contextuate:events',
+        },
+        persistence: {
+            enabled: true,
+            type: 'file',
+        },
+        socketPath: '/tmp/contextuate-monitor.sock',
+    };
+}
+// Export components
+var broker_2 = require("./broker");
+Object.defineProperty(exports, "EventBroker", { enumerable: true, get: function () { return broker_2.EventBroker; } });
+var unix_socket_1 = require("./adapters/unix-socket");
+Object.defineProperty(exports, "UnixSocketAdapter", { enumerable: true, get: function () { return unix_socket_1.UnixSocketAdapter; } });
+var redis_1 = require("./adapters/redis");
+Object.defineProperty(exports, "RedisAdapter", { enumerable: true, get: function () { return redis_1.RedisAdapter; } });
+var fastify_2 = require("./fastify");
+Object.defineProperty(exports, "createFastifyServer", { enumerable: true, get: function () { return fastify_2.createFastifyServer; } });
+var websocket_2 = require("./websocket");
+Object.defineProperty(exports, "MonitorWebSocketServer", { enumerable: true, get: function () { return websocket_2.MonitorWebSocketServer; } });

package/dist/monitor/server/websocket.d.ts

@@ -0,0 +1,80 @@
+/**
+ * WebSocket Server
+ *
+ * Provides real-time event streaming to connected UI clients.
+ * Uses the 'ws' library for WebSocket handling.
+ */
+import type { EventBroker } from './broker';
+import type { PersistenceStore } from '../../types/monitor';
+export interface WebSocketServerOptions {
+    port: number;
+    host?: string;
+    broker: EventBroker;
+    persistence?: PersistenceStore;
+}
+export declare class MonitorWebSocketServer {
+    private wss;
+    private clients;
+    private broker;
+    private persistence?;
+    private port;
+    private host;
+    private unsubscribeBroker?;
+    constructor(options: WebSocketServerOptions);
+    /**
+     * Start the WebSocket server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the WebSocket server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle new WebSocket connection
+     */
+    private handleConnection;
+    /**
+     * Handle message from client
+     */
+    private handleClientMessage;
+    /**
+     * Send historical events to a client
+     */
+    private sendHistoricalEvents;
+    /**
+     * Send all recent events across all sessions to a client
+     */
+    private sendAllRecentEvents;
+    /**
+     * Send event detail to a client
+     */
+    private sendEventDetail;
+    /**
+     * Handle events from the broker
+     */
+    private handleBrokerEvent;
+    /**
+     * Broadcast a message to all connected clients
+     */
+    private broadcastToAll;
+    /**
+     * Broadcast an event to subscribed clients
+     */
+    private broadcastEvent;
+    /**
+     * Broadcast a session update to all clients
+     */
+    private broadcastSessionUpdate;
+    /**
+     * Broadcast updated session list to all clients (for bulk operations)
+     */
+    private broadcastSessionsUpdate;
+    /**
+     * Check if a client is subscribed to events for a session
+     */
+    private isClientSubscribed;
+    /**
+     * Get the number of connected clients
+     */
+    getClientCount(): number;
+}