@esotech/contextuate 2.0.0 → 2.1.0

package/dist/monitor/persistence/file-store.d.ts

@@ -0,0 +1,88 @@
+/**
+ * File-based Persistence Store
+ *
+ * Stores session data and events in JSON files.
+ * Uses JSON Lines format for event logs (one JSON object per line).
+ */
+import type { PersistenceStore, MonitorEvent, SessionMeta, SessionStatus } from '../../types/monitor';
+export interface FileStoreOptions {
+    baseDir?: string;
+}
+export declare class FileStore implements PersistenceStore {
+    private paths;
+    private baseDir;
+    private sessionsDir;
+    private processedDir;
+    constructor(options?: FileStoreOptions);
+    /**
+     * Initialize the store - create directories if needed
+     */
+    init(): Promise<void>;
+    /**
+     * Close the store (no-op for file store)
+     */
+    close(): Promise<void>;
+    /**
+     * Save an event to the session's event log
+     */
+    saveEvent(event: MonitorEvent): Promise<void>;
+    /**
+     * Get events for a session
+     */
+    getEvents(sessionId: string, options?: {
+        limit?: number;
+        before?: number;
+        after?: number;
+    }): Promise<MonitorEvent[]>;
+    /**
+     * Get a single event by ID
+     */
+    getEventById(sessionId: string, eventId: string): Promise<MonitorEvent | null>;
+    /**
+     * Save session metadata
+     */
+    saveSession(session: SessionMeta): Promise<void>;
+    /**
+     * Get session metadata
+     */
+    getSession(sessionId: string): Promise<SessionMeta | null>;
+    /**
+     * Get all sessions
+     */
+    getSessions(options?: {
+        status?: SessionStatus;
+        limit?: number;
+    }): Promise<SessionMeta[]>;
+    /**
+     * Update session metadata
+     */
+    updateSession(sessionId: string, updates: Partial<SessionMeta>): Promise<void>;
+    /**
+     * Delete a session
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Delete all sessions
+     */
+    deleteAllSessions(): Promise<void>;
+    /**
+     * Get all recent events across all sessions
+     */
+    getAllRecentEvents(limit?: number): Promise<MonitorEvent[]>;
+    /**
+     * Delete old sessions
+     */
+    pruneOldSessions(olderThan: number): Promise<number>;
+    /**
+     * Get event count for a session
+     */
+    getEventCount(sessionId: string): Promise<number>;
+    /**
+     * Get the base directory path
+     */
+    getBaseDir(): string;
+    /**
+     * Get list of processed event files (for recovery)
+     */
+    getProcessedFiles(): Promise<string[]>;
+}

package/dist/monitor/persistence/file-store.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * File-based Persistence Store
+ *
+ * Stores session data and events in JSON files.
+ * Uses JSON Lines format for event logs (one JSON object per line).
+ */
+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.FileStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const monitor_js_1 = require("../../types/monitor.js");
+class FileStore {
+    constructor(options) {
+        this.paths = (0, monitor_js_1.getDefaultMonitorPaths)();
+        this.baseDir = options?.baseDir || this.paths.baseDir;
+        this.sessionsDir = path.join(this.baseDir, 'sessions');
+        this.processedDir = path.join(this.baseDir, 'processed');
+    }
+    /**
+     * Initialize the store - create directories if needed
+     */
+    async init() {
+        await fs.promises.mkdir(this.sessionsDir, { recursive: true });
+        await fs.promises.mkdir(this.processedDir, { recursive: true });
+        console.log(`[FileStore] Initialized at ${this.baseDir}`);
+    }
+    /**
+     * Close the store (no-op for file store)
+     */
+    async close() {
+        // Nothing to clean up
+    }
+    /**
+     * Save an event to the session's event log
+     */
+    async saveEvent(event) {
+        const sessionDir = path.join(this.sessionsDir, event.sessionId);
+        await fs.promises.mkdir(sessionDir, { recursive: true });
+        const eventsFile = path.join(sessionDir, 'events.jsonl');
+        const line = JSON.stringify(event) + '\n';
+        await fs.promises.appendFile(eventsFile, line);
+    }
+    /**
+     * Get events for a session
+     */
+    async getEvents(sessionId, options) {
+        const eventsFile = path.join(this.sessionsDir, sessionId, 'events.jsonl');
+        if (!fs.existsSync(eventsFile)) {
+            return [];
+        }
+        const events = [];
+        const limit = options?.limit || 1000;
+        const fileStream = fs.createReadStream(eventsFile);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                // Apply filters
+                if (options?.before && event.timestamp >= options.before)
+                    continue;
+                if (options?.after && event.timestamp <= options.after)
+                    continue;
+                events.push(event);
+            }
+            catch (err) {
+                console.error('[FileStore] Failed to parse event line:', err);
+            }
+        }
+        // Sort by timestamp and limit
+        events.sort((a, b) => a.timestamp - b.timestamp);
+        if (events.length > limit) {
+            return events.slice(-limit);
+        }
+        return events;
+    }
+    /**
+     * Get a single event by ID
+     */
+    async getEventById(sessionId, eventId) {
+        const eventsFile = path.join(this.sessionsDir, sessionId, 'events.jsonl');
+        if (!fs.existsSync(eventsFile)) {
+            return null;
+        }
+        const content = await fs.promises.readFile(eventsFile, 'utf8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event.id === eventId) {
+                    return event;
+                }
+            }
+            catch (err) {
+                // Skip malformed lines
+            }
+        }
+        return null;
+    }
+    /**
+     * Save session metadata
+     */
+    async saveSession(session) {
+        const sessionDir = path.join(this.sessionsDir, session.sessionId);
+        await fs.promises.mkdir(sessionDir, { recursive: true });
+        const metaFile = path.join(sessionDir, 'meta.json');
+        await fs.promises.writeFile(metaFile, JSON.stringify(session, null, 2));
+    }
+    /**
+     * Get session metadata
+     */
+    async getSession(sessionId) {
+        const metaFile = path.join(this.sessionsDir, sessionId, 'meta.json');
+        if (!fs.existsSync(metaFile)) {
+            return null;
+        }
+        try {
+            const content = await fs.promises.readFile(metaFile, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            console.error('[FileStore] Failed to read session:', err);
+            return null;
+        }
+    }
+    /**
+     * Get all sessions
+     */
+    async getSessions(options) {
+        if (!fs.existsSync(this.sessionsDir)) {
+            return [];
+        }
+        const sessions = [];
+        const entries = await fs.promises.readdir(this.sessionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const session = await this.getSession(entry.name);
+            if (!session)
+                continue;
+            // Apply status filter
+            if (options?.status && session.status !== options.status)
+                continue;
+            sessions.push(session);
+        }
+        // Sort by start time (newest first)
+        sessions.sort((a, b) => b.startTime - a.startTime);
+        // Apply limit
+        if (options?.limit && sessions.length > options.limit) {
+            return sessions.slice(0, options.limit);
+        }
+        return sessions;
+    }
+    /**
+     * Update session metadata
+     */
+    async updateSession(sessionId, updates) {
+        const session = await this.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const updated = { ...session, ...updates };
+        await this.saveSession(updated);
+    }
+    /**
+     * Delete a session
+     */
+    async deleteSession(sessionId) {
+        const sessionDir = path.join(this.sessionsDir, sessionId);
+        if (!fs.existsSync(sessionDir)) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        try {
+            await fs.promises.rm(sessionDir, { recursive: true });
+            console.log(`[FileStore] Deleted session: ${sessionId}`);
+        }
+        catch (err) {
+            console.error(`[FileStore] Failed to delete session ${sessionId}:`, err);
+            throw err;
+        }
+    }
+    /**
+     * Delete all sessions
+     */
+    async deleteAllSessions() {
+        if (!fs.existsSync(this.sessionsDir)) {
+            return;
+        }
+        try {
+            const entries = await fs.promises.readdir(this.sessionsDir, { withFileTypes: true });
+            let deleted = 0;
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const sessionDir = path.join(this.sessionsDir, entry.name);
+                try {
+                    await fs.promises.rm(sessionDir, { recursive: true });
+                    deleted++;
+                }
+                catch (err) {
+                    console.error(`[FileStore] Failed to delete session ${entry.name}:`, err);
+                }
+            }
+            console.log(`[FileStore] Deleted all sessions (${deleted} total)`);
+        }
+        catch (err) {
+            console.error('[FileStore] Failed to delete all sessions:', err);
+            throw err;
+        }
+    }
+    /**
+     * Get all recent events across all sessions
+     */
+    async getAllRecentEvents(limit = 200) {
+        if (!fs.existsSync(this.sessionsDir)) {
+            return [];
+        }
+        const allEvents = [];
+        const entries = await fs.promises.readdir(this.sessionsDir, { withFileTypes: true });
+        // Read events from all sessions
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const sessionEvents = await this.getEvents(entry.name, { limit: 100 });
+            allEvents.push(...sessionEvents);
+        }
+        // Sort by timestamp (newest first) and limit
+        allEvents.sort((a, b) => b.timestamp - a.timestamp);
+        return allEvents.slice(0, limit);
+    }
+    /**
+     * Delete old sessions
+     */
+    async pruneOldSessions(olderThan) {
+        const sessions = await this.getSessions();
+        let pruned = 0;
+        for (const session of sessions) {
+            const endTime = session.endTime || session.startTime;
+            if (endTime < olderThan) {
+                const sessionDir = path.join(this.sessionsDir, session.sessionId);
+                try {
+                    await fs.promises.rm(sessionDir, { recursive: true });
+                    pruned++;
+                }
+                catch (err) {
+                    console.error(`[FileStore] Failed to prune session ${session.sessionId}:`, err);
+                }
+            }
+        }
+        if (pruned > 0) {
+            console.log(`[FileStore] Pruned ${pruned} old sessions`);
+        }
+        return pruned;
+    }
+    /**
+     * Get event count for a session
+     */
+    async getEventCount(sessionId) {
+        const eventsFile = path.join(this.sessionsDir, sessionId, 'events.jsonl');
+        if (!fs.existsSync(eventsFile)) {
+            return 0;
+        }
+        let count = 0;
+        const fileStream = fs.createReadStream(eventsFile);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (line.trim())
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Get the base directory path
+     */
+    getBaseDir() {
+        return this.baseDir;
+    }
+    /**
+     * Get list of processed event files (for recovery)
+     */
+    async getProcessedFiles() {
+        try {
+            const files = await fs.promises.readdir(this.processedDir);
+            return files.filter(f => f.endsWith('.json')).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.FileStore = FileStore;

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

@@ -0,0 +1,7 @@
+/**
+ * Persistence Module
+ *
+ * Exports persistence store implementations.
+ */
+export { FileStore, type FileStoreOptions } from './file-store';
+export type { PersistenceStore } from '../../types/monitor';

package/dist/monitor/persistence/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Persistence Module
+ *
+ * Exports persistence store implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStore = void 0;
+var file_store_1 = require("./file-store");
+Object.defineProperty(exports, "FileStore", { enumerable: true, get: function () { return file_store_1.FileStore; } });

package/dist/monitor/server/adapters/redis.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Redis Adapter
+ *
+ * Uses Redis pub/sub for distributed event handling.
+ * Allows multiple monitor instances and remote hook scripts.
+ */
+import type { IPCAdapter, EventHandler, MonitorEvent, RedisConfig } from '../../../types/monitor';
+export interface RedisAdapterOptions {
+    config: RedisConfig;
+}
+export declare class RedisAdapter implements IPCAdapter {
+    private subscriber;
+    private publisher;
+    private handlers;
+    private running;
+    private config;
+    constructor(options: RedisAdapterOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    onEvent(handler: EventHandler): void;
+    offEvent(handler: EventHandler): void;
+    isRunning(): boolean;
+    private emitEvent;
+    /**
+     * Publish an event to the Redis channel
+     * This is used by hook scripts in Redis mode
+     */
+    publishEvent(event: MonitorEvent): Promise<void>;
+    /**
+     * Get the Redis configuration for clients
+     */
+    getConfig(): RedisConfig;
+}
+/**
+ * Create a standalone publisher for hook scripts
+ * This doesn't subscribe, just publishes events
+ */
+export declare function publishEventToRedis(config: RedisConfig, event: MonitorEvent): Promise<void>;

package/dist/monitor/server/adapters/redis.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Redis Adapter
+ *
+ * Uses Redis pub/sub for distributed event handling.
+ * Allows multiple monitor instances and remote hook scripts.
+ */
+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.RedisAdapter = void 0;
+exports.publishEventToRedis = publishEventToRedis;
+// Dynamic import for ioredis to make it optional
+let Redis;
+class RedisAdapter {
+    constructor(options) {
+        this.subscriber = null;
+        this.publisher = null;
+        this.handlers = new Set();
+        this.running = false;
+        this.config = options.config;
+    }
+    async start() {
+        if (this.running) {
+            return;
+        }
+        // Dynamically import ioredis
+        try {
+            const ioredis = await Promise.resolve().then(() => __importStar(require('ioredis')));
+            Redis = ioredis.default;
+        }
+        catch (err) {
+            throw new Error('Redis adapter requires ioredis package. Install with: npm install ioredis');
+        }
+        const redisOptions = {
+            host: this.config.host,
+            port: this.config.port,
+            password: this.config.password || undefined,
+            retryStrategy: (times) => {
+                const delay = Math.min(times * 100, 3000);
+                console.log(`[Redis] Reconnecting in ${delay}ms (attempt ${times}/10)...`);
+                if (times > 10) {
+                    console.error('[Redis] Max reconnection attempts reached');
+                    return null; // Stop retrying
+                }
+                return delay;
+            },
+            lazyConnect: true, // Don't auto-connect, we'll do it manually
+        };
+        // Create subscriber connection
+        this.subscriber = new Redis(redisOptions);
+        this.publisher = new Redis(redisOptions);
+        // Set up error handlers before connecting
+        this.subscriber.on('error', (err) => {
+            console.error('[Redis Subscriber] Connection error:', err.message);
+        });
+        this.publisher.on('error', (err) => {
+            console.error('[Redis Publisher] Connection error:', err.message);
+        });
+        this.subscriber.on('reconnecting', () => {
+            console.log('[Redis Subscriber] Reconnecting...');
+        });
+        this.publisher.on('reconnecting', () => {
+            console.log('[Redis Publisher] Reconnecting...');
+        });
+        // Connect both clients
+        try {
+            await Promise.all([
+                this.subscriber.connect(),
+                this.publisher.connect(),
+            ]);
+        }
+        catch (err) {
+            // Clean up on connection failure
+            this.subscriber.disconnect();
+            this.publisher.disconnect();
+            throw new Error(`Failed to connect to Redis: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // Subscribe to the channel
+        await this.subscriber.subscribe(this.config.channel);
+        // Handle incoming messages
+        this.subscriber.on('message', (channel, message) => {
+            if (channel === this.config.channel) {
+                try {
+                    const event = JSON.parse(message);
+                    console.log(`[Redis] Received event from ${event.machineId}/${event.sessionId}: ${event.eventType}`);
+                    this.emitEvent(event);
+                }
+                catch (err) {
+                    console.error('[Redis] Failed to parse event:', err);
+                }
+            }
+        });
+        this.running = true;
+        console.log(`[Redis] Connected to ${this.config.host}:${this.config.port}, channel: ${this.config.channel}`);
+        console.log('[Redis] Listening for events from multiple sources...');
+    }
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        if (this.subscriber) {
+            await this.subscriber.unsubscribe(this.config.channel);
+            this.subscriber.disconnect();
+            this.subscriber = null;
+        }
+        if (this.publisher) {
+            this.publisher.disconnect();
+            this.publisher = null;
+        }
+        this.running = false;
+        console.log('[Redis] Disconnected');
+    }
+    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('[Redis] Event handler error:', err);
+                    });
+                }
+            }
+            catch (err) {
+                console.error('[Redis] Event handler error:', err);
+            }
+        }
+    }
+    /**
+     * Publish an event to the Redis channel
+     * This is used by hook scripts in Redis mode
+     */
+    async publishEvent(event) {
+        if (!this.publisher) {
+            throw new Error('Redis adapter not started');
+        }
+        const message = JSON.stringify(event);
+        const subscriberCount = await this.publisher.publish(this.config.channel, message);
+        console.log(`[Redis] Published event ${event.eventType} from ${event.machineId}/${event.sessionId} (${subscriberCount} subscribers)`);
+    }
+    /**
+     * Get the Redis configuration for clients
+     */
+    getConfig() {
+        return this.config;
+    }
+}
+exports.RedisAdapter = RedisAdapter;
+/**
+ * Create a standalone publisher for hook scripts
+ * This doesn't subscribe, just publishes events
+ */
+async function publishEventToRedis(config, event) {
+    let RedisClient;
+    try {
+        const ioredis = await Promise.resolve().then(() => __importStar(require('ioredis')));
+        RedisClient = ioredis.default;
+    }
+    catch (err) {
+        throw new Error('Redis requires ioredis package');
+    }
+    const client = new RedisClient({
+        host: config.host,
+        port: config.port,
+        password: config.password || undefined,
+    });
+    try {
+        await client.publish(config.channel, JSON.stringify(event));
+    }
+    finally {
+        client.disconnect();
+    }
+}