aegis-bridge 2.2.2

package/dist/jsonl-watcher.js

@@ -0,0 +1,159 @@
+/**
+ * jsonl-watcher.ts — fs.watch()-based JSONL file watcher.
+ *
+ * Replaces polling-based JSONL reading in the monitor with near-instant
+ * file change detection. Uses fs.watch() with debouncing to avoid
+ * duplicate events from rapid writes.
+ *
+ * Issue #84: Replace JSONL polling with fs.watch.
+ */
+import { watch } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { readNewEntries } from './transcript.js';
+const DEFAULT_CONFIG = {
+    debounceMs: 100,
+};
+/**
+ * Watches JSONL files for changes and emits parsed entries.
+ *
+ * Usage:
+ *   const watcher = new JsonlWatcher();
+ *   watcher.onEntries((event) => { ... });
+ *   watcher.watch('session-123', '/path/to/session.jsonl', 0);
+ *   watcher.unwatch('session-123');
+ *   watcher.destroy();
+ */
+export class JsonlWatcher {
+    entries = new Map();
+    listeners = new Array();
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /** Register a callback for new entries. */
+    onEntries(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const idx = this.listeners.indexOf(listener);
+            if (idx >= 0)
+                this.listeners.splice(idx, 1);
+        };
+    }
+    /** Start watching a JSONL file for a session.
+     *  @param initialOffset - byte offset to start reading from (usually 0 or current session.monitorOffset).
+     */
+    watch(sessionId, jsonlPath, initialOffset) {
+        // Don't double-watch
+        if (this.entries.has(sessionId)) {
+            this.unwatch(sessionId);
+        }
+        if (!existsSync(jsonlPath))
+            return;
+        const fsWatcher = watch(jsonlPath, (eventType) => {
+            // 'rename' can mean file was deleted or replaced — check if it still exists
+            if (eventType === 'rename') {
+                if (!existsSync(jsonlPath)) {
+                    // File deleted — session likely ended, stop watching
+                    this.unwatch(sessionId);
+                    return;
+                }
+                // File was replaced (e.g. rotated) — re-read from current offset
+                this.scheduleRead(sessionId);
+                return;
+            }
+            // 'change' — new data written
+            this.scheduleRead(sessionId);
+        });
+        fsWatcher.on('error', (err) => {
+            console.error(`JsonlWatcher: error watching ${jsonlPath}:`, err.message);
+            // Stop watching on persistent errors
+            this.unwatch(sessionId);
+        });
+        this.entries.set(sessionId, {
+            sessionId,
+            jsonlPath,
+            fsWatcher,
+            debounceTimer: null,
+            offset: initialOffset,
+        });
+    }
+    /** Stop watching a session's JSONL file. */
+    unwatch(sessionId) {
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return;
+        if (entry.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        entry.fsWatcher.close();
+        this.entries.delete(sessionId);
+    }
+    /** Update the offset for a session (e.g. after manual read during discovery). */
+    setOffset(sessionId, offset) {
+        const entry = this.entries.get(sessionId);
+        if (entry) {
+            entry.offset = offset;
+        }
+    }
+    /** Check if a session is being watched. */
+    isWatching(sessionId) {
+        return this.entries.has(sessionId);
+    }
+    /** Get the current offset for a watched session. */
+    getOffset(sessionId) {
+        return this.entries.get(sessionId)?.offset;
+    }
+    /** Stop all watchers and clean up. */
+    destroy() {
+        for (const sessionId of this.entries.keys()) {
+            this.unwatch(sessionId);
+        }
+        this.listeners.length = 0;
+    }
+    /** Schedule a debounced read for a session. */
+    scheduleRead(sessionId) {
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return;
+        if (entry.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        entry.debounceTimer = setTimeout(() => {
+            entry.debounceTimer = null;
+            void this.readAndEmit(entry);
+        }, this.config.debounceMs);
+    }
+    /** Read new bytes from the JSONL file and emit entries. */
+    async readAndEmit(entry) {
+        // Session may have been removed during debounce
+        if (!this.entries.has(entry.sessionId))
+            return;
+        if (!existsSync(entry.jsonlPath)) {
+            this.unwatch(entry.sessionId);
+            return;
+        }
+        try {
+            const previousOffset = entry.offset;
+            const result = await readNewEntries(entry.jsonlPath, previousOffset);
+            entry.offset = result.newOffset;
+            if (result.entries.length > 0 || result.newOffset < previousOffset) {
+                // Detect truncation: newOffset went backwards
+                const truncated = result.newOffset < previousOffset;
+                // Emit to all listeners
+                const event = {
+                    sessionId: entry.sessionId,
+                    messages: result.entries,
+                    newOffset: result.newOffset,
+                    truncated,
+                };
+                for (const listener of this.listeners) {
+                    listener(event);
+                }
+            }
+        }
+        catch {
+            // File may be temporarily unavailable — ignore
+        }
+    }
+}
+//# sourceMappingURL=jsonl-watcher.js.map

package/dist/mcp-server.d.ts

@@ -0,0 +1,60 @@
+/**
+ * mcp-server.ts — MCP server mode for Aegis.
+ *
+ * Exposes Aegis session orchestration as MCP tools via stdio transport.
+ * CC sessions can natively discover and communicate with sibling sessions.
+ *
+ * Usage:
+ *   aegis-bridge mcp                    # default port 9100
+ *   aegis-bridge mcp --port 3000        # custom port
+ *   claude mcp add --scope user aegis -- npx aegis-bridge mcp
+ *
+ * Issue #48: https://github.com/OneStepAt4time/aegis/issues/48
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare class AegisClient {
+    private baseUrl;
+    private authToken?;
+    constructor(baseUrl: string, authToken?: string | undefined);
+    private validateSessionId;
+    private request;
+    listSessions(filter?: {
+        status?: string;
+        workDir?: string;
+    }): Promise<any[]>;
+    getSession(id: string): Promise<any>;
+    getHealth(id: string): Promise<any>;
+    getTranscript(id: string): Promise<any>;
+    sendMessage(id: string, text: string): Promise<any>;
+    createSession(opts: {
+        workDir: string;
+        name?: string;
+        prompt?: string;
+    }): Promise<any>;
+    killSession(id: string): Promise<any>;
+    approvePermission(id: string): Promise<any>;
+    rejectPermission(id: string): Promise<any>;
+    getServerHealth(): Promise<any>;
+    escapeSession(id: string): Promise<any>;
+    interruptSession(id: string): Promise<any>;
+    capturePane(id: string): Promise<any>;
+    getSessionMetrics(id: string): Promise<any>;
+    getSessionSummary(id: string): Promise<any>;
+    sendBash(id: string, command: string): Promise<any>;
+    sendCommand(id: string, command: string): Promise<any>;
+    getSessionLatency(id: string): Promise<any>;
+    batchCreateSessions(sessions: Array<{
+        workDir: string;
+        name?: string;
+        prompt?: string;
+    }>): Promise<any>;
+    listPipelines(): Promise<any>;
+    createPipeline(config: {
+        name: string;
+        workDir: string;
+        steps: any[];
+    }): Promise<any>;
+    getSwarm(): Promise<any>;
+}
+export declare function createMcpServer(aegisPort: number, authToken?: string): McpServer;
+export declare function startMcpServer(port: number, authToken?: string): Promise<void>;