@esotech/contextuate 2.0.0 → 2.1.1

package/dist/monitor/daemon/state.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Daemon State Management
+ *
+ * Manages persistent state for the monitor daemon including:
+ * - Last processed timestamp (for crash recovery)
+ * - Pending subagent spawns (for parent-child correlation)
+ * - Active subagent stacks (for virtual session routing)
+ */
+/**
+ * Pending subagent spawn tracking (adjusted to match broker.ts usage)
+ */
+interface PendingSubagentSpawn {
+    parentSessionId: string;
+    workingDirectory: string;
+    timestamp: number;
+    agentType?: string;
+}
+/**
+ * Active subagent in the stack (adjusted to match broker.ts usage)
+ */
+interface ActiveSubagent {
+    virtualSessionId: string;
+    parentSessionId: string;
+    agentType?: string;
+    startTime: number;
+}
+export declare class StateManager {
+    private state;
+    private saveInterval;
+    constructor();
+    /**
+     * Load state from disk
+     */
+    load(): Promise<void>;
+    /**
+     * Save state to disk
+     */
+    save(): Promise<void>;
+    /**
+     * Start periodic state saving
+     */
+    startPeriodicSave(intervalMs?: number): void;
+    /**
+     * Stop periodic state saving
+     */
+    stopPeriodicSave(): void;
+    /**
+     * Get last processed timestamp
+     */
+    get lastProcessedTimestamp(): number;
+    /**
+     * Set last processed timestamp
+     */
+    set lastProcessedTimestamp(timestamp: number);
+    /**
+     * Get pending subagent spawns
+     */
+    get pendingSubagentSpawns(): PendingSubagentSpawn[];
+    /**
+     * Set pending subagent spawns
+     */
+    set pendingSubagentSpawns(spawns: PendingSubagentSpawn[]);
+    /**
+     * Get active subagent stack for a session
+     */
+    getActiveSubagentStack(sessionId: string): ActiveSubagent[];
+    /**
+     * Set active subagent stack for a session
+     */
+    setActiveSubagentStack(sessionId: string, stack: ActiveSubagent[]): void;
+    /**
+     * Push a new subagent onto the stack for a session
+     */
+    pushActiveSubagent(sessionId: string, subagent: ActiveSubagent): void;
+    /**
+     * Pop the top subagent from the stack for a session
+     */
+    popActiveSubagent(sessionId: string): ActiveSubagent | undefined;
+}
+export {};

package/dist/monitor/daemon/state.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Daemon State Management
+ *
+ * Manages persistent state for the monitor daemon including:
+ * - Last processed timestamp (for crash recovery)
+ * - Pending subagent spawns (for parent-child correlation)
+ * - Active subagent stacks (for virtual session routing)
+ */
+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.StateManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const monitor_js_1 = require("../../types/monitor.js");
+const PATHS = (0, monitor_js_1.getDefaultMonitorPaths)();
+class StateManager {
+    constructor() {
+        this.saveInterval = null;
+        this.state = {
+            lastProcessedTimestamp: 0,
+            pendingSubagentSpawns: [],
+            activeSubagentStacks: {},
+        };
+    }
+    /**
+     * Load state from disk
+     */
+    async load() {
+        try {
+            const data = await fs.promises.readFile(PATHS.daemonStateFile, 'utf8');
+            this.state = JSON.parse(data);
+            console.log(`[State] Loaded state, last processed: ${new Date(this.state.lastProcessedTimestamp).toISOString()}`);
+        }
+        catch (err) {
+            console.log('[State] No existing state file, starting fresh');
+        }
+    }
+    /**
+     * Save state to disk
+     */
+    async save() {
+        try {
+            await fs.promises.mkdir(path.dirname(PATHS.daemonStateFile), { recursive: true });
+            await fs.promises.writeFile(PATHS.daemonStateFile, JSON.stringify(this.state, null, 2));
+        }
+        catch (err) {
+            console.error('[State] Failed to save state:', err);
+        }
+    }
+    /**
+     * Start periodic state saving
+     */
+    startPeriodicSave(intervalMs = 30000) {
+        this.saveInterval = setInterval(() => this.save(), intervalMs);
+    }
+    /**
+     * Stop periodic state saving
+     */
+    stopPeriodicSave() {
+        if (this.saveInterval) {
+            clearInterval(this.saveInterval);
+            this.saveInterval = null;
+        }
+    }
+    /**
+     * Get last processed timestamp
+     */
+    get lastProcessedTimestamp() {
+        return this.state.lastProcessedTimestamp;
+    }
+    /**
+     * Set last processed timestamp
+     */
+    set lastProcessedTimestamp(timestamp) {
+        this.state.lastProcessedTimestamp = timestamp;
+    }
+    /**
+     * Get pending subagent spawns
+     */
+    get pendingSubagentSpawns() {
+        return this.state.pendingSubagentSpawns;
+    }
+    /**
+     * Set pending subagent spawns
+     */
+    set pendingSubagentSpawns(spawns) {
+        this.state.pendingSubagentSpawns = spawns;
+    }
+    /**
+     * Get active subagent stack for a session
+     */
+    getActiveSubagentStack(sessionId) {
+        return this.state.activeSubagentStacks[sessionId] || [];
+    }
+    /**
+     * Set active subagent stack for a session
+     */
+    setActiveSubagentStack(sessionId, stack) {
+        if (stack.length === 0) {
+            delete this.state.activeSubagentStacks[sessionId];
+        }
+        else {
+            this.state.activeSubagentStacks[sessionId] = stack;
+        }
+    }
+    /**
+     * Push a new subagent onto the stack for a session
+     */
+    pushActiveSubagent(sessionId, subagent) {
+        if (!this.state.activeSubagentStacks[sessionId]) {
+            this.state.activeSubagentStacks[sessionId] = [];
+        }
+        this.state.activeSubagentStacks[sessionId].push(subagent);
+    }
+    /**
+     * Pop the top subagent from the stack for a session
+     */
+    popActiveSubagent(sessionId) {
+        const stack = this.state.activeSubagentStacks[sessionId];
+        if (!stack || stack.length === 0)
+            return undefined;
+        const subagent = stack.pop();
+        if (stack.length === 0) {
+            delete this.state.activeSubagentStacks[sessionId];
+        }
+        return subagent;
+    }
+}
+exports.StateManager = StateManager;

package/dist/monitor/daemon/watcher.d.ts

@@ -0,0 +1,47 @@
+/**
+ * File Watcher
+ *
+ * Watches the raw/ directory for new event files and processes them in order.
+ * Handles both existing unprocessed files and newly created files.
+ */
+import { MonitorEvent } from '../../types/monitor.js';
+export type EventHandler = (event: MonitorEvent, filepath: string) => Promise<void>;
+export declare class FileWatcher {
+    private watcher;
+    private processing;
+    private queue;
+    private handler;
+    private lastProcessedTimestamp;
+    /**
+     * Set the event handler callback
+     */
+    setHandler(handler: EventHandler): void;
+    /**
+     * Set the last processed timestamp for checkpoint recovery
+     */
+    setLastProcessedTimestamp(timestamp: number): void;
+    /**
+     * Start watching the raw directory
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching
+     */
+    stop(): Promise<void>;
+    /**
+     * Process existing files that may not have been processed yet
+     */
+    private processExistingFiles;
+    /**
+     * Add file to processing queue
+     */
+    private enqueue;
+    /**
+     * Process all files in the queue
+     */
+    private processQueue;
+    /**
+     * Process a single file
+     */
+    private processFile;
+}

package/dist/monitor/daemon/watcher.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * File Watcher
+ *
+ * Watches the raw/ directory for new event files and processes them in order.
+ * Handles both existing unprocessed files and newly created files.
+ */
+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.FileWatcher = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const monitor_js_1 = require("../../types/monitor.js");
+const PATHS = (0, monitor_js_1.getDefaultMonitorPaths)();
+class FileWatcher {
+    constructor() {
+        this.watcher = null;
+        this.processing = false;
+        this.queue = [];
+        this.handler = null;
+        this.lastProcessedTimestamp = 0;
+    }
+    /**
+     * Set the event handler callback
+     */
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    /**
+     * Set the last processed timestamp for checkpoint recovery
+     */
+    setLastProcessedTimestamp(timestamp) {
+        this.lastProcessedTimestamp = timestamp;
+    }
+    /**
+     * Start watching the raw directory
+     */
+    async start() {
+        // Ensure raw directory exists
+        await fs.promises.mkdir(PATHS.rawDir, { recursive: true });
+        // Process any existing unprocessed files first
+        await this.processExistingFiles();
+        // Start watching for new files
+        this.watcher = fs.watch(PATHS.rawDir, (eventType, filename) => {
+            if (eventType === 'rename' && filename && filename.endsWith('.json')) {
+                const filepath = path.join(PATHS.rawDir, filename);
+                this.enqueue(filepath);
+            }
+        });
+        console.log(`[Watcher] Watching ${PATHS.rawDir} for new events`);
+    }
+    /**
+     * Stop watching
+     */
+    async stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    /**
+     * Process existing files that may not have been processed yet
+     */
+    async processExistingFiles() {
+        try {
+            const files = await fs.promises.readdir(PATHS.rawDir);
+            const jsonFiles = files
+                .filter(f => f.endsWith('.json'))
+                .sort(); // Sort by timestamp (filename starts with timestamp)
+            let processedCount = 0;
+            for (const file of jsonFiles) {
+                const filepath = path.join(PATHS.rawDir, file);
+                // Extract timestamp from filename: {timestamp}-{sessionId}-{eventId}.json
+                const timestamp = parseInt(file.split('-')[0], 10);
+                // Skip if already processed (based on checkpoint)
+                if (timestamp <= this.lastProcessedTimestamp) {
+                    continue;
+                }
+                await this.processFile(filepath);
+                processedCount++;
+            }
+            if (processedCount > 0) {
+                console.log(`[Watcher] Processed ${processedCount} existing events`);
+            }
+        }
+        catch (err) {
+            console.error('[Watcher] Error processing existing files:', err);
+        }
+    }
+    /**
+     * Add file to processing queue
+     */
+    enqueue(filepath) {
+        this.queue.push(filepath);
+        this.processQueue();
+    }
+    /**
+     * Process all files in the queue
+     */
+    async processQueue() {
+        if (this.processing || this.queue.length === 0)
+            return;
+        this.processing = true;
+        while (this.queue.length > 0) {
+            const filepath = this.queue.shift();
+            try {
+                // Small delay to ensure file is fully written
+                await new Promise(resolve => setTimeout(resolve, 50));
+                await this.processFile(filepath);
+            }
+            catch (err) {
+                console.error(`[Watcher] Error processing ${filepath}:`, err);
+            }
+        }
+        this.processing = false;
+    }
+    /**
+     * Process a single file
+     */
+    async processFile(filepath) {
+        try {
+            // Check if file still exists (might have been processed already)
+            await fs.promises.access(filepath);
+            const content = await fs.promises.readFile(filepath, 'utf8');
+            const event = JSON.parse(content);
+            if (this.handler) {
+                await this.handler(event, filepath);
+            }
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                // File already processed/moved, skip
+                return;
+            }
+            throw err;
+        }
+    }
+}
+exports.FileWatcher = FileWatcher;

package/dist/monitor/daemon/wrapper-manager.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Wrapper Manager
+ *
+ * Manages Claude wrapper sessions with PTY.
+ * Spawns and manages Claude processes, handles input/output streaming,
+ * persists session state, and cleans up on exit.
+ */
+import * as pty from 'node-pty';
+export interface WrapperSession {
+    wrapperId: string;
+    ptyProcess: pty.IPty;
+    pid: number;
+    claudeSessionId: string | null;
+    state: 'starting' | 'processing' | 'waiting_input' | 'ended';
+    cwd: string;
+    args: string[];
+    startTime: number;
+    cols: number;
+    rows: number;
+}
+export interface PersistedWrapper {
+    wrapperId: string;
+    pid: number;
+    claudeSessionId: string | null;
+    state: string;
+    cwd: string;
+    args: string[];
+    startTime: number;
+    cols: number;
+    rows: number;
+}
+export type WrapperEventCallback = (event: {
+    type: 'output' | 'state_changed' | 'started' | 'ended';
+    wrapperId: string;
+    data?: string;
+    state?: string;
+    claudeSessionId?: string;
+    exitCode?: number;
+}) => void;
+export declare class WrapperManager {
+    private wrappers;
+    private persistPath;
+    private onEvent;
+    constructor(persistPath: string, onEvent: WrapperEventCallback);
+    /**
+     * Initialize - load persisted wrappers and clean up dead ones
+     */
+    initialize(): Promise<void>;
+    /**
+     * Load persisted wrappers and clean up any that are no longer running
+     */
+    private loadAndCleanup;
+    /**
+     * Check if a process is still running
+     */
+    private isProcessRunning;
+    /**
+     * Spawn a new Claude wrapper session
+     */
+    spawn(options?: {
+        cwd?: string;
+        args?: string[];
+        cols?: number;
+        rows?: number;
+    }): Promise<string>;
+    /**
+     * Write input to a wrapper's PTY
+     */
+    writeInput(wrapperId: string, input: string): boolean;
+    /**
+     * Resize a wrapper's PTY
+     */
+    resize(wrapperId: string, cols: number, rows: number): boolean;
+    /**
+     * Kill a wrapper session
+     */
+    kill(wrapperId: string): boolean;
+    /**
+     * Get all active wrappers
+     */
+    getAll(): WrapperSession[];
+    /**
+     * Get a specific wrapper
+     */
+    get(wrapperId: string): WrapperSession | undefined;
+    /**
+     * Update wrapper state (e.g., from hook events)
+     */
+    updateState(wrapperId: string, state: 'starting' | 'processing' | 'waiting_input' | 'ended', claudeSessionId?: string): void;
+    /**
+     * Shutdown all wrappers
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Persist wrapper state to disk
+     */
+    private persist;
+    /**
+     * Detect if output indicates Claude is waiting for input
+     */
+    private detectInputPrompt;
+    /**
+     * Find the Claude executable
+     */
+    private findClaudeExecutable;
+}