@esotech/contextuate 2.0.0 → 2.1.1

package/dist/monitor/server/adapters/unix-socket.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Unix Socket Adapter
+ *
+ * Listens for events from hook scripts via a Unix domain socket.
+ * This is the default local mode for single-machine setups.
+ */
+import type { IPCAdapter, EventHandler, MonitorEvent } from '../../../types/monitor';
+export interface UnixSocketAdapterOptions {
+    socketPath: string;
+}
+export declare class UnixSocketAdapter implements IPCAdapter {
+    private server;
+    private handlers;
+    private running;
+    private socketPath;
+    constructor(options: UnixSocketAdapterOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private cleanup;
+    onEvent(handler: EventHandler): void;
+    offEvent(handler: EventHandler): void;
+    isRunning(): boolean;
+    private emitEvent;
+    /**
+     * Get the socket path for client connections
+     */
+    getSocketPath(): string;
+}
+/**
+ * Create a client to send events to the Unix socket
+ * This is used by the hook script
+ */
+export declare function sendEventToSocket(socketPath: string, event: MonitorEvent): Promise<void>;

package/dist/monitor/server/adapters/unix-socket.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Unix Socket Adapter
+ *
+ * Listens for events from hook scripts via a Unix domain socket.
+ * This is the default local mode for single-machine setups.
+ */
+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.UnixSocketAdapter = void 0;
+exports.sendEventToSocket = sendEventToSocket;
+const net = __importStar(require("net"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class UnixSocketAdapter {
+    constructor(options) {
+        this.server = null;
+        this.handlers = new Set();
+        this.running = false;
+        this.socketPath = options.socketPath;
+    }
+    async start() {
+        if (this.running) {
+            return;
+        }
+        // Clean up existing socket file if it exists
+        await this.cleanup();
+        // Ensure directory exists
+        const socketDir = path.dirname(this.socketPath);
+        if (!fs.existsSync(socketDir)) {
+            fs.mkdirSync(socketDir, { recursive: true });
+        }
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                let buffer = '';
+                socket.on('data', (data) => {
+                    buffer += data.toString();
+                    // Process complete JSON messages (newline-delimited)
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                    for (const line of lines) {
+                        if (line.trim()) {
+                            try {
+                                const event = JSON.parse(line);
+                                this.emitEvent(event);
+                            }
+                            catch (err) {
+                                console.error('[UnixSocket] Failed to parse event:', err);
+                            }
+                        }
+                    }
+                });
+                socket.on('error', (err) => {
+                    console.error('[UnixSocket] Socket error:', err);
+                });
+            });
+            this.server.on('error', (err) => {
+                console.error('[UnixSocket] Server error:', err);
+                reject(err);
+            });
+            this.server.listen(this.socketPath, () => {
+                this.running = true;
+                // Set permissions so any user can write to the socket
+                fs.chmodSync(this.socketPath, 0o777);
+                console.log(`[UnixSocket] Listening on ${this.socketPath}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.running = false;
+                    this.cleanup().then(resolve);
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async cleanup() {
+        try {
+            if (fs.existsSync(this.socketPath)) {
+                fs.unlinkSync(this.socketPath);
+            }
+        }
+        catch (err) {
+            // Ignore cleanup errors
+        }
+    }
+    onEvent(handler) {
+        this.handlers.add(handler);
+    }
+    offEvent(handler) {
+        this.handlers.delete(handler);
+    }
+    isRunning() {
+        return this.running;
+    }
+    emitEvent(event) {
+        for (const handler of this.handlers) {
+            try {
+                const result = handler(event);
+                if (result instanceof Promise) {
+                    result.catch((err) => {
+                        console.error('[UnixSocket] Event handler error:', err);
+                    });
+                }
+            }
+            catch (err) {
+                console.error('[UnixSocket] Event handler error:', err);
+            }
+        }
+    }
+    /**
+     * Get the socket path for client connections
+     */
+    getSocketPath() {
+        return this.socketPath;
+    }
+}
+exports.UnixSocketAdapter = UnixSocketAdapter;
+/**
+ * Create a client to send events to the Unix socket
+ * This is used by the hook script
+ */
+function sendEventToSocket(socketPath, event) {
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath, () => {
+            const data = JSON.stringify(event) + '\n';
+            client.write(data, () => {
+                client.end();
+                resolve();
+            });
+        });
+        client.on('error', (err) => {
+            reject(err);
+        });
+        // Timeout after 5 seconds
+        client.setTimeout(5000, () => {
+            client.destroy();
+            reject(new Error('Connection timeout'));
+        });
+    });
+}

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

@@ -0,0 +1,135 @@
+/**
+ * Event Broker
+ *
+ * Session management and WebSocket broadcast layer for the 3-layer architecture.
+ *
+ * Role:
+ * - Load sessions from disk on startup
+ * - Connect to daemon to receive processed events and session updates
+ * - Handle session management actions (rename, pin, hide, delete, set parent)
+ * - Broadcast updates to WebSocket clients
+ * - Subscribe to Redis for multi-machine UI aggregation (optional)
+ *
+ * Note: Event processing (correlation, parent linking, etc.) is handled by the daemon.
+ */
+import type { MonitorEvent, SessionMeta, PersistenceStore, MonitorConfig } from '../../types/monitor';
+export type BrokerEventType = 'event' | 'session_created' | 'session_updated' | 'session_ended' | 'wrapper_connected' | 'wrapper_disconnected' | 'wrapper_state' | 'wrapper_output' | 'wrapper_spawned' | 'wrappers_list';
+export interface WrapperEventData {
+    wrapperId?: string;
+    state?: string;
+    claudeSessionId?: string;
+    exitCode?: number;
+    data?: string;
+    timestamp?: number;
+    success?: boolean;
+    error?: string;
+    wrappers?: Array<{
+        wrapperId: string;
+        state: string;
+        claudeSessionId: string | null;
+    }>;
+}
+export type BrokerHandler = (type: BrokerEventType, data: MonitorEvent | SessionMeta | WrapperEventData) => void | Promise<void>;
+export declare class EventBroker {
+    private daemonSocket;
+    private persistence;
+    private handlers;
+    private sessions;
+    private config;
+    private reconnectTimeout;
+    private stopping;
+    private connectionAttempts;
+    constructor(config: MonitorConfig);
+    /**
+     * Start the event broker
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the event broker
+     */
+    stop(): Promise<void>;
+    /**
+     * Connect to daemon socket to receive processed events
+     */
+    private connectToDaemon;
+    /**
+     * Schedule reconnection to daemon
+     */
+    private scheduleDaemonReconnect;
+    /**
+     * Handle message from daemon
+     */
+    private handleDaemonMessage;
+    /**
+     * Send a message to the daemon
+     */
+    sendToDaemon(message: any): void;
+    /**
+     * Set the persistence store
+     */
+    setPersistence(store: PersistenceStore): void;
+    /**
+     * Register an event handler
+     */
+    onEvent(handler: BrokerHandler): () => void;
+    /**
+     * Get all active sessions
+     */
+    getSessions(includeHidden?: boolean): SessionMeta[];
+    /**
+     * Get a specific session
+     */
+    getSession(sessionId: string): SessionMeta | undefined;
+    /**
+     * Persist session to storage
+     */
+    private persistSession;
+    /**
+     * Emit event to all handlers
+     */
+    private emit;
+    /**
+     * Load existing sessions from persistence (disk)
+     */
+    loadSessions(): Promise<void>;
+    /**
+     * Get configuration
+     */
+    getConfig(): MonitorConfig;
+    /**
+     * Hide a session (soft-hide, preserves data)
+     */
+    hideSession(sessionId: string): Promise<void>;
+    /**
+     * Unhide a session
+     */
+    unhideSession(sessionId: string): Promise<void>;
+    /**
+     * Delete a session (permanent removal)
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Hide all sessions
+     */
+    hideAllSessions(): Promise<void>;
+    /**
+     * Delete all sessions
+     */
+    deleteAllSessions(): Promise<void>;
+    /**
+     * Manually set parent session (user override for grouping)
+     */
+    setParentSession(sessionId: string, parentSessionId: string | null): Promise<void>;
+    /**
+     * Toggle session pinned state
+     */
+    togglePin(sessionId: string): Promise<void>;
+    /**
+     * Set whether a session is user-initiated
+     */
+    setUserInitiated(sessionId: string, isUserInitiated: boolean): Promise<void>;
+    /**
+     * Rename a session (set custom label)
+     */
+    renameSession(sessionId: string, label: string): Promise<void>;
+}