npm - aegis-bridge - Versions diffs - 2.6.2 → 2.6.4 - Mend

aegis-bridge 2.6.2 → 2.6.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dashboard/dist/assets/{index-Bfabq3q-.js → index-G8fziBeQ.js} +25 -25
package/dashboard/dist/index.html +1 -1
package/dist/dashboard/assets/{index-Bfabq3q-.js → index-G8fziBeQ.js} +25 -25
package/dist/dashboard/index.html +1 -1
package/dist/hook-settings.js +4 -0
package/dist/mcp-server.d.ts +72 -23
package/dist/monitor.d.ts +10 -0
package/dist/monitor.js +53 -31
package/dist/session.d.ts +3 -0
package/dist/session.js +16 -1
package/dist/transcript.js +16 -6
package/package.json +1 -1

package/dist/dashboard/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Aegis Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🛡️</text></svg>" />
-    <script type="module" crossorigin src="/dashboard/assets/index-Bfabq3q-.js"></script>
+    <script type="module" crossorigin src="/dashboard/assets/index-G8fziBeQ.js"></script>
     <link rel="stylesheet" crossorigin href="/dashboard/assets/index-9Hkkvm_I.css">
   </head>
   <body class="bg-[#0a0a0f] text-gray-200 antialiased">

package/dist/hook-settings.js CHANGED Viewed

@@ -135,6 +135,10 @@ export async function writeHookSettingsFile(baseUrl, sessionId, hookSecret, work
         mergedHooks[event] = [...(existingHooks[event] ?? []), ...entries];
     }
     const combined = { ...merged, hooks: mergedHooks };
+    // Issue #931: Always inject MCP_CONNECTION_NONBLOCKING so CC does not block
+    // on MCP server connections when launched via Aegis orchestration.
+    (combined.env = (combined.env || {}));
+    (combined.env || {})["MCP_CONNECTION_NONBLOCKING"] = "true";
     // Issue #648: Use unpredictable directory name and restrictive permissions
     // to prevent symlink attacks and information disclosure in /tmp.
     const suffix = randomBytes(4).toString('hex');

package/dist/mcp-server.d.ts CHANGED Viewed

@@ -12,6 +12,51 @@
  * Issue #48: https://github.com/OneStepAt4time/aegis/issues/48
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type SessionInfo } from './session.js';
+import { type SessionMetrics, type SessionLatency, type SessionLatencySummary } from './metrics.js';
+import { type PipelineState, type BatchResult } from './pipeline.js';
+interface ServerHealthResponse {
+    status: string;
+    version: string;
+    uptime: number;
+    sessions: {
+        active: number;
+        total: number;
+    };
+    tmux: {
+        healthy: boolean;
+        [key: string]: unknown;
+    };
+    timestamp: string;
+}
+interface CreateSessionResponse {
+    id: string;
+    windowName: string;
+    workDir: string;
+    status: string;
+    promptDelivery?: {
+        delivered: boolean;
+        attempts: number;
+    };
+    reused?: boolean;
+    [key: string]: unknown;
+}
+interface SendMessageResponse {
+    ok: boolean;
+    delivered: boolean;
+    attempts: number;
+}
+interface OkResponse {
+    ok: boolean;
+}
+interface CapturePaneResponse {
+    pane: string;
+}
+interface SessionLatencyResponse {
+    sessionId: string;
+    realtime: SessionLatency | null;
+    aggregated: SessionLatencySummary | null;
+}
 export declare class AegisClient {
     private baseUrl;
     private authToken?;
@@ -21,40 +66,44 @@ export declare class AegisClient {
     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>;
+    }): Promise<SessionInfo[]>;
+    getSession(id: string): Promise<Record<string, unknown>>;
+    getHealth(id: string): Promise<Record<string, unknown>>;
+    getTranscript(id: string): Promise<Record<string, unknown>>;
+    sendMessage(id: string, text: string): Promise<SendMessageResponse>;
     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>;
+    }): Promise<CreateSessionResponse>;
+    killSession(id: string): Promise<OkResponse>;
+    approvePermission(id: string): Promise<OkResponse>;
+    rejectPermission(id: string): Promise<OkResponse>;
+    getServerHealth(): Promise<ServerHealthResponse>;
+    escapeSession(id: string): Promise<OkResponse>;
+    interruptSession(id: string): Promise<OkResponse>;
+    capturePane(id: string): Promise<CapturePaneResponse>;
+    getSessionMetrics(id: string): Promise<SessionMetrics>;
+    getSessionSummary(id: string): Promise<Record<string, unknown>>;
+    sendBash(id: string, command: string): Promise<OkResponse>;
+    sendCommand(id: string, command: string): Promise<OkResponse>;
+    getSessionLatency(id: string): Promise<SessionLatencyResponse>;
     batchCreateSessions(sessions: Array<{
         workDir: string;
         name?: string;
         prompt?: string;
-    }>): Promise<any>;
-    listPipelines(): Promise<any>;
+    }>): Promise<BatchResult>;
+    listPipelines(): Promise<PipelineState[]>;
     createPipeline(config: {
         name: string;
         workDir: string;
-        steps: any[];
-    }): Promise<any>;
-    getSwarm(): Promise<any>;
+        steps: Array<{
+            name?: string;
+            prompt: string;
+        }>;
+    }): Promise<PipelineState>;
+    getSwarm(): Promise<Record<string, unknown>>;
 }
 export declare function createMcpServer(aegisPort: number, authToken?: string): McpServer;
 export declare function startMcpServer(port: number, authToken?: string): Promise<void>;
+export {};

package/dist/monitor.d.ts CHANGED Viewed

@@ -31,6 +31,16 @@ export declare class SessionMonitor {
     private lastStatus;
     private lastBytesSeen;
     private stallNotified;
+    /** Issue #663: O(1) stall notification check. */
+    private stallHas;
+    /** Issue #663: O(1) stall notification add. */
+    private stallAdd;
+    /** Issue #663: O(1) stall notification delete. */
+    private stallDelete;
+    /** Issue #663: Delete all stall notifications for a session. */
+    private stallDeleteAll;
+    /** Issue #663: Delete specific stall types for a session. */
+    private stallDeleteTypes;
     private lastStallCheck;
     private lastDeadCheck;
     private idleNotified;

package/dist/monitor.js CHANGED Viewed

@@ -34,7 +34,38 @@ export class SessionMonitor {
     running = false;
     lastStatus = new Map();
     lastBytesSeen = new Map();
-    stallNotified = new Set(); // don't spam stall events
+    // Issue #663: Nested Map for O(1) per-session stall lookup (was Set with O(n) prefix scan)
+    stallNotified = new Map(); // sessionId → Set<stallType>
+    /** Issue #663: O(1) stall notification check. */
+    stallHas(sessionId, stallType) {
+        return this.stallNotified.get(sessionId)?.has(stallType) ?? false;
+    }
+    /** Issue #663: O(1) stall notification add. */
+    stallAdd(sessionId, stallType) {
+        const set = this.stallNotified.get(sessionId);
+        if (set) {
+            set.add(stallType);
+        }
+        else {
+            this.stallNotified.set(sessionId, new Set([stallType]));
+        }
+    }
+    /** Issue #663: O(1) stall notification delete. */
+    stallDelete(sessionId, stallType) {
+        this.stallNotified.get(sessionId)?.delete(stallType);
+    }
+    /** Issue #663: Delete all stall notifications for a session. */
+    stallDeleteAll(sessionId) {
+        this.stallNotified.delete(sessionId);
+    }
+    /** Issue #663: Delete specific stall types for a session. */
+    stallDeleteTypes(sessionId, types) {
+        const set = this.stallNotified.get(sessionId);
+        if (!set)
+            return;
+        for (const t of types)
+            set.delete(t);
+    }
     lastStallCheck = 0;
     lastDeadCheck = 0;
     idleNotified = new Set(); // prevent idle spam
@@ -196,13 +227,13 @@ export class SessionMonitor {
                 }
                 if (currentBytes > prev.bytes) {
                     this.lastBytesSeen.set(session.id, { bytes: currentBytes, at: now });
-                    this.stallNotified.delete(`${session.id}:stall:jsonl`);
+                    this.stallDelete(session.id, 'jsonl');
                 }
                 else {
                     const stallDuration = now - prev.at;
                     const threshold = session.stallThresholdMs || this.config.stallThresholdMs;
-                    if (stallDuration >= threshold && !this.stallNotified.has(`${session.id}:stall:jsonl`)) {
-                        this.stallNotified.add(`${session.id}:stall:jsonl`);
+                    if (stallDuration >= threshold && !this.stallHas(session.id, 'jsonl')) {
+                        this.stallAdd(session.id, 'jsonl');
                         const minutes = Math.round(stallDuration / 60000);
                         const detail = `Session stalled: "working" for ${minutes}min with no new output. ` +
                             `Last activity: ${new Date(session.lastActivity).toISOString()}`;
@@ -213,15 +244,15 @@ export class SessionMonitor {
             }
             else {
                 // Reset JSONL stall tracking when not working
-                this.stallNotified.delete(`${session.id}:stall:jsonl`);
+                this.stallDelete(session.id, 'jsonl');
             }
             // --- Type 2: Permission stall (waiting for approval too long) ---
             if (currentStatus === 'permission_prompt' || currentStatus === 'bash_approval') {
                 const entry = this.stateSince.get(session.id);
                 const permDuration = entry ? now - entry.since : 0;
                 if (permDuration >= this.config.permissionStallMs) {
-                    if (!this.stallNotified.has(`${session.id}:stall:permission`)) {
-                        this.stallNotified.add(`${session.id}:stall:permission`);
+                    if (!this.stallHas(session.id, 'permission')) {
+                        this.stallAdd(session.id, 'permission');
                         const minutes = Math.round(permDuration / 60000);
                         const detail = `Session stalled: waiting for permission approval for ${minutes}min. ` +
                             `Auto-approve this session or POST /v1/sessions/${session.id}/approve`;
@@ -231,8 +262,8 @@ export class SessionMonitor {
                 }
                 // L9: Auto-reject permission after timeout
                 if (permDuration >= this.config.permissionTimeoutMs) {
-                    if (!this.stallNotified.has(`${session.id}:stall:permission_timeout`)) {
-                        this.stallNotified.add(`${session.id}:stall:permission_timeout`);
+                    if (!this.stallHas(session.id, 'permission_timeout')) {
+                        this.stallAdd(session.id, 'permission_timeout');
                         const minutes = Math.round(permDuration / 60000);
                         logger.warn({
                             component: 'monitor',
@@ -264,8 +295,8 @@ export class SessionMonitor {
                 const entry = this.stateSince.get(session.id);
                 const unkDuration = entry ? now - entry.since : 0;
                 if (unkDuration >= this.config.unknownStallMs) {
-                    if (!this.stallNotified.has(`${session.id}:stall:unknown`)) {
-                        this.stallNotified.add(`${session.id}:stall:unknown`);
+                    if (!this.stallHas(session.id, 'unknown')) {
+                        this.stallAdd(session.id, 'unknown');
                         const minutes = Math.round(unkDuration / 60000);
                         const detail = `Session stalled: in "unknown" state for ${minutes}min. ` +
                             `CC may be stuck. Try: POST /v1/sessions/${session.id}/interrupt or /kill`;
@@ -280,8 +311,8 @@ export class SessionMonitor {
                 const stateDuration = entry ? now - entry.since : 0;
                 const extendedThreshold = this.config.stallThresholdMs * 2;
                 if (stateDuration >= extendedThreshold) {
-                    if (!this.stallNotified.has(`${session.id}:stall:extended`)) {
-                        this.stallNotified.add(`${session.id}:stall:extended`);
+                    if (!this.stallHas(session.id, 'extended')) {
+                        this.stallAdd(session.id, 'extended');
                         const minutes = Math.round(stateDuration / 60000);
                         const detail = `Session stalled: "${currentStatus}" state for ${minutes}min. ` +
                             `May need intervention: /interrupt, /approve, or /kill`;
@@ -297,8 +328,8 @@ export class SessionMonitor {
                 if (entry && entry.state === 'working') {
                     const workingDuration = now - entry.since;
                     const maxWorkingMs = this.config.stallThresholdMs * 3; // 15 min default
-                    if (workingDuration >= maxWorkingMs && !this.stallNotified.has(`${session.id}:stall:extended_working`)) {
-                        this.stallNotified.add(`${session.id}:stall:extended_working`);
+                    if (workingDuration >= maxWorkingMs && !this.stallHas(session.id, 'extended_working')) {
+                        this.stallAdd(session.id, 'extended_working');
                         const minutes = Math.round(workingDuration / 60000);
                         const detail = `Session stalled: in "working" state for ${minutes}min. ` +
                             `CC may be stuck in an internal loop (e.g., Misting). Consider: POST /v1/sessions/${session.id}/interrupt or /kill`;
@@ -312,23 +343,18 @@ export class SessionMonitor {
                 const exitedPermission = prevStallStatus === 'permission_prompt' || prevStallStatus === 'bash_approval';
                 const exitedUnknown = prevStallStatus === 'unknown';
                 if (exitedPermission) {
-                    this.stallNotified.delete(`${session.id}:stall:permission`);
-                    this.stallNotified.delete(`${session.id}:stall:permission_timeout`);
+                    this.stallDeleteTypes(session.id, ['permission', 'permission_timeout']);
                 }
                 if (exitedUnknown) {
-                    this.stallNotified.delete(`${session.id}:stall:unknown`);
+                    this.stallDelete(session.id, 'unknown');
                 }
             }
             // Clean up all state tracking when idle (catch-all)
             if (currentStatus === 'idle') {
                 this.rateLimitedSessions.delete(session.id);
                 this.stateSince.delete(session.id);
-                // Clean stall notifications (session recovered)
-                for (const key of this.stallNotified) {
-                    if (key.startsWith(session.id)) {
-                        this.stallNotified.delete(key);
-                    }
-                }
+                // Clean stall notifications (session recovered) — O(1) with Map
+                this.stallDeleteAll(session.id);
             }
             // Update prevStatusForStall for next cycle
             if (currentStatus) {
@@ -432,7 +458,7 @@ export class SessionMonitor {
             if (event.messages.length > 0) {
                 // Real output — reset stall timer
                 this.lastBytesSeen.set(event.sessionId, { bytes: event.newOffset, at: now });
-                this.stallNotified.delete(`${event.sessionId}:stall:jsonl`);
+                this.stallDelete(event.sessionId, 'jsonl');
             }
             else {
                 // File grew but no messages — only update bytes, keep timestamp
@@ -666,12 +692,8 @@ export class SessionMonitor {
             clearTimeout(pending);
             this.statusChangeDebounce.delete(sessionId);
         }
-        // Clean all stall notifications for this session
-        for (const key of this.stallNotified) {
-            if (key.startsWith(sessionId)) {
-                this.stallNotified.delete(key);
-            }
-        }
+        // Clean all stall notifications for this session — O(1) with Map
+        this.stallDeleteAll(sessionId);
         this.idleNotified.delete(sessionId);
         this.idleSince.delete(sessionId);
         this.stateSince.delete(sessionId);

package/dist/session.d.ts CHANGED Viewed

@@ -66,6 +66,7 @@ export declare class SessionManager {
     private pendingQuestions;
     private static readonly MAX_CACHE_ENTRIES_PER_SESSION;
     private parsedEntriesCache;
+    private sessionsListCache;
     private readonly sessionAcquireMutex;
     constructor(tmux: TmuxManager, config: Config);
     /**
@@ -165,6 +166,8 @@ export declare class SessionManager {
      *  so the current pane PID is the shell (alive). Checking ccPid catches
      *  the crash within seconds instead of waiting for the 5-min stall timer. */
     isWindowAlive(id: string): Promise<boolean>;
+    /** Issue #657: Invalidate the sessions list cache. Call on any mutation. */
+    private invalidateSessionsListCache;
     /** List all sessions. */
     listSessions(): SessionInfo[];
     /** Issue #607: Find an idle session for the given workDir.

package/dist/session.js CHANGED Viewed

@@ -67,6 +67,8 @@ export class SessionManager {
     // #424: Evict oldest entries when cache exceeds max to prevent unbounded growth
     static MAX_CACHE_ENTRIES_PER_SESSION = 10_000;
     parsedEntriesCache = new Map();
+    // Issue #657: Cached session list to avoid allocating a new array per call
+    sessionsListCache = null;
     // Issue #840/#880: Explicit mutex to prevent TOCTOU races in session acquisition.
     sessionAcquireMutex = new Mutex();
     constructor(tmux, config) {
@@ -168,6 +170,8 @@ export class SessionManager {
             await writeFile(`${this.stateFile}.bak`, JSON.stringify(this.state, null, 2));
         }
         catch { /* non-critical */ }
+        // Issue #657: Invalidate sessions list cache after loading state
+        this.invalidateSessionsListCache();
         // Reconcile: verify tmux windows still exist, clean up dead sessions
         await this.reconcile();
     }
@@ -190,6 +194,7 @@ export class SessionManager {
                     await cleanOrphanedBackup(session.workDir);
                 }
                 delete this.state.sessions[id];
+                this.invalidateSessionsListCache();
                 changed = true;
             }
             else if (!windowIdAlive && windowNameAlive) {
@@ -245,6 +250,7 @@ export class SessionManager {
                 permissionMode: 'default',
             };
             this.state.sessions[id] = session;
+            this.invalidateSessionsListCache();
             console.log(`Reconcile: adopted orphaned window ${win.windowName} (${win.windowId}) as ${id.slice(0, 8)}`);
             this.startSessionIdDiscovery(id);
             this.startFilesystemDiscovery(id, session.workDir);
@@ -545,6 +551,7 @@ export class SessionManager {
             hookSecret,
         };
         this.state.sessions[id] = session;
+        this.invalidateSessionsListCache();
         await this.save();
         // Issue #353: Fetch CC process PID for swarm parent matching.
         // Fire-and-forget — PID is not needed synchronously.
@@ -744,9 +751,16 @@ export class SessionManager {
             return false;
         }
     }
+    /** Issue #657: Invalidate the sessions list cache. Call on any mutation. */
+    invalidateSessionsListCache() {
+        this.sessionsListCache = null;
+    }
     /** List all sessions. */
     listSessions() {
-        return Object.values(this.state.sessions);
+        if (!this.sessionsListCache) {
+            this.sessionsListCache = Object.values(this.state.sessions);
+        }
+        return this.sessionsListCache;
     }
     /** Issue #607: Find an idle session for the given workDir.
      *  Returns the most recently active idle session, or null if none found.
@@ -1320,6 +1334,7 @@ export class SessionManager {
         // #405: Clean up all tracking maps (pollTimers, pendingPermissions, pendingQuestions, parsedEntriesCache)
         this.cleanupSession(id);
         delete this.state.sessions[id];
+        this.invalidateSessionsListCache();
         // #357: Cancel any pending debounced save before doing an immediate save
         if (this.saveDebounceTimer !== null) {
             clearTimeout(this.saveDebounceTimer);

package/dist/transcript.js CHANGED Viewed

@@ -4,8 +4,8 @@
  * Port of CCBot's transcript_parser.py.
  * Reads CC session JSONL files and extracts structured messages.
  */
-import { readFile, open } from 'node:fs/promises';
-import { createReadStream, existsSync } from 'node:fs';
+import { readFile, open, access } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { readdir } from 'node:fs/promises';
@@ -218,10 +218,20 @@ export async function readNewEntries(filePath, fromOffset) {
         await fd.close();
     }
 }
+/** Check if a path exists (async). Issue #658: replaces sync existsSync. */
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** Find the JSONL file for a session ID. */
 export async function findSessionFile(sessionId, claudeProjectsDir = DEFAULT_CLAUDE_PROJECTS_DIR) {
     const projectsDir = claudeProjectsDir;
-    if (!existsSync(projectsDir))
+    if (!(await pathExists(projectsDir)))
         return null;
     // Strategy 1: Direct glob across all project dirs
     const dirs = await readdir(projectsDir, { withFileTypes: true });
@@ -229,7 +239,7 @@ export async function findSessionFile(sessionId, claudeProjectsDir = DEFAULT_CLA
         if (!dir.isDirectory())
             continue;
         const jsonlPath = join(projectsDir, dir.name, `${sessionId}.jsonl`);
-        if (existsSync(jsonlPath))
+        if (await pathExists(jsonlPath))
             return jsonlPath;
     }
     // Strategy 2: Check sessions-index.json files
@@ -237,7 +247,7 @@ export async function findSessionFile(sessionId, claudeProjectsDir = DEFAULT_CLA
         if (!dir.isDirectory())
             continue;
         const indexPath = join(projectsDir, dir.name, 'sessions-index.json');
-        if (existsSync(indexPath)) {
+        if (await pathExists(indexPath)) {
             try {
                 const indexRaw = await readFile(indexPath, 'utf-8');
                 const indexParsed = sessionsIndexSchema.safeParse(JSON.parse(indexRaw));
@@ -245,7 +255,7 @@ export async function findSessionFile(sessionId, claudeProjectsDir = DEFAULT_CLA
                     continue;
                 const entries = indexParsed.data.entries || [];
                 for (const entry of entries) {
-                    if (entry.sessionId === sessionId && entry.fullPath && existsSync(entry.fullPath)) {
+                    if (entry.sessionId === sessionId && entry.fullPath && (await pathExists(entry.fullPath))) {
                         return entry.fullPath;
                     }
                 }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "aegis-bridge",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "type": "module",
   "description": "Orchestrate Claude Code sessions via API. Create, brief, monitor, refine, ship.",
   "main": "dist/server.js",