aegis-bridge 2.2.2 → 2.3.0

package/dist/auth.d.ts

@@ -53,6 +53,8 @@ export declare class AuthManager {
     };
     /** Hash a key with SHA-256. */
     static hashKey(key: string): string;
+    /** #398: Sweep stale rate limit buckets. Prune entries with expired windows. */
+    sweepStaleRateLimits(): void;
     /** Check if auth is enabled (master token or any keys). */
     get authEnabled(): boolean;
     /**

package/dist/auth.js

@@ -127,6 +127,16 @@ export class AuthManager {
     static hashKey(key) {
         return createHash('sha256').update(key).digest('hex');
     }
+    /** #398: Sweep stale rate limit buckets. Prune entries with expired windows. */
+    sweepStaleRateLimits() {
+        const now = Date.now();
+        const windowMs = 60_000; // 1 minute
+        for (const [keyId, bucket] of this.rateLimits) {
+            if (now - bucket.windowStart > windowMs) {
+                this.rateLimits.delete(keyId);
+            }
+        }
+    }
     /** Check if auth is enabled (master token or any keys). */
     get authEnabled() {
         return !!this.masterToken || this.store.keys.length > 0;

package/dist/events.d.ts

@@ -81,6 +81,8 @@ export declare class SessionEventBus {
         id: number;
         event: GlobalSSEEvent;
     }>;
+    /** #398: Clean up per-session state (call when session is killed). */
+    cleanupSession(sessionId: string): void;
     /** Clean up all emitters. */
     destroy(): void;
 }

package/dist/events.js

@@ -243,6 +243,15 @@ export class SessionEventBus {
     getGlobalEventsSince(lastEventId) {
         return this.globalEventBuffer.filter(e => e.id > lastEventId);
     }
+    /** #398: Clean up per-session state (call when session is killed). */
+    cleanupSession(sessionId) {
+        this.eventBuffers.delete(sessionId);
+        const emitter = this.emitters.get(sessionId);
+        if (emitter) {
+            emitter.removeAllListeners();
+            this.emitters.delete(sessionId);
+        }
+    }
     /** Clean up all emitters. */
     destroy() {
         for (const emitter of this.emitters.values()) {

package/dist/mcp-server.js

@@ -36,8 +36,9 @@ export class AegisClient {
         }
     }
     async request(path, opts) {
+        const hasBody = opts?.body !== undefined;
         const headers = {
-            'Content-Type': 'application/json',
+            ...(hasBody ? { 'Content-Type': 'application/json' } : {}),
             ...(this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}),
         };
         let res;

package/dist/monitor.js

@@ -256,6 +256,23 @@ export class SessionMonitor {
                     }
                 }
             }
+            // --- Type 5: Extended working stall (working too long regardless of byte changes, ---
+            // Catches CC stuck in "Misting" state where internal loop detection
+            if (currentStatus === 'working') {
+                const entry = this.stateSince.get(session.id);
+                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`);
+                        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`;
+                        this.eventBus?.emitStall(session.id, 'extended_working', detail);
+                        await this.channels.statusChange(this.makePayload('status.stall', session, detail));
+                    }
+                }
+            }
             // Clean up stall notifications on state transitions (using prevStallStatus)
             if (prevStallStatus && prevStallStatus !== currentStatus) {
                 const exitedPermission = prevStallStatus === 'permission_prompt' || prevStallStatus === 'bash_approval';
@@ -361,12 +378,20 @@ export class SessionMonitor {
             // Update last activity
             session.lastActivity = Date.now();
         }
-        // Update JSONL stall tracking — always initialize on watcher events
+        // Update JSONL stall tracking — only reset stall timer when real messages arrive
+        // When no messages, only update bytes tracking (keep timestamp)
         const now = Date.now();
         const prev = this.lastBytesSeen.get(event.sessionId);
         if (event.newOffset > (prev?.bytes ?? -1)) {
-            this.lastBytesSeen.set(event.sessionId, { bytes: event.newOffset, at: now });
-            this.stallNotified.delete(`${event.sessionId}:stall:jsonl`);
+            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`);
+            }
+            else {
+                // File grew but no messages — only update bytes, keep timestamp
+                this.lastBytesSeen.set(event.sessionId, { bytes: event.newOffset, at: prev?.at ?? now });
+            }
         }
     }
     async checkSession(session) {
@@ -407,6 +432,9 @@ export class SessionMonitor {
             const latestResult = { statusText: result.statusText, interactiveContent: result.interactiveContent };
             this.statusChangeDebounce.set(session.id, setTimeout(() => {
                 this.statusChangeDebounce.delete(session.id);
+                // #511: Skip broadcast if session was killed while debounce was pending
+                if (!this.lastStatus.has(session.id))
+                    return;
                 void this.broadcastStatusChange(session, latestStatus, latestPrevStatus, latestResult)
                     .catch(e => console.error(`Monitor: broadcastStatusChange failed for ${session.id}:`, e));
             }, STATUS_CHANGE_DEBOUNCE_MS));

package/dist/server.js

@@ -35,7 +35,7 @@ import { registerHookRoutes } from './hooks.js';
 import { registerWsTerminalRoute } from './ws-terminal.js';
 import { SwarmMonitor } from './swarm-monitor.js';
 import { execSync } from 'node:child_process';
-import { authKeySchema, sendMessageSchema, commandSchema, bashSchema, screenshotSchema, permissionHookSchema, stopHookSchema, batchSessionSchema, pipelineSchema, parseIntSafe, } from './validation.js';
+import { authKeySchema, sendMessageSchema, commandSchema, bashSchema, screenshotSchema, permissionHookSchema, stopHookSchema, batchSessionSchema, pipelineSchema, parseIntSafe, isValidUUID, } from './validation.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // ── Configuration ────────────────────────────────────────────────────
@@ -211,6 +211,13 @@ function setupAuth(authManager) {
     });
 }
 // ── v1 API Routes ───────────────────────────────────────────────────
+// #412: Reject non-UUID session IDs at the routing layer
+app.addHook('onRequest', async (req, reply) => {
+    const id = req.params.id;
+    if (id !== undefined && !isValidUUID(id)) {
+        return reply.status(400).send({ error: 'Invalid session ID — must be a UUID' });
+    }
+});
 // #226: Zod schema for session creation
 const createSessionSchema = z.object({
     workDir: z.string().min(1),
@@ -510,13 +517,13 @@ app.get('/v1/sessions/:id', async (req, reply) => {
     const session = sessions.getSession(req.params.id);
     if (!session)
         return reply.status(404).send({ error: 'Session not found' });
-    return addActionHints(session);
+    return addActionHints(session, sessions);
 });
 app.get('/sessions/:id', async (req, reply) => {
     const session = sessions.getSession(req.params.id);
     if (!session)
         return reply.status(404).send({ error: 'Session not found' });
-    return addActionHints(session);
+    return addActionHints(session, sessions);
 });
 // #128: Bulk health check — returns health for all sessions in one request
 app.get('/v1/sessions/health', async () => {
@@ -1103,6 +1110,7 @@ async function reapStaleSessions(maxAgeMs) {
                     session: { id: session.id, name: session.windowName, workDir: session.workDir },
                     detail: `Auto-killed: exceeded ${maxAgeMs / 3600000}h time limit`,
                 });
+                eventBus.cleanupSession(session.id);
                 await sessions.killSession(session.id);
                 monitor.removeSession(session.id);
                 metrics.cleanupSession(session.id);
@@ -1132,6 +1140,7 @@ async function reapZombieSessions() {
         console.log(`Reaper: removing zombie session ${session.windowName} (${session.id.slice(0, 8)})`);
         try {
             monitor.removeSession(session.id);
+            eventBus.cleanupSession(session.id);
             await sessions.killSession(session.id);
             metrics.cleanupSession(session.id);
             await channels.sessionEnded({
@@ -1148,7 +1157,7 @@ async function reapZombieSessions() {
 }
 // ── Helpers ──────────────────────────────────────────────────────────
 /** Issue #20: Add actionHints to session response for interactive states. */
-function addActionHints(session) {
+function addActionHints(session, sessions) {
     // #357: Convert Set to array for JSON serialization
     const result = {
         ...session,
@@ -1160,8 +1169,33 @@ function addActionHints(session) {
             reject: { method: 'POST', url: `/v1/sessions/${session.id}/reject`, description: 'Reject the pending permission' },
         };
     }
+    // #599: Expose pending question data for MCP/REST callers
+    if (session.status === 'ask_question' && sessions) {
+        const info = sessions.getPendingQuestionInfo(session.id);
+        if (info) {
+            result.pendingQuestion = {
+                toolUseId: info.toolUseId,
+                content: info.question,
+                options: extractQuestionOptions(info.question),
+                since: info.timestamp,
+            };
+        }
+    }
     return result;
 }
+/** #599: Extract selectable options from AskUserQuestion text. */
+function extractQuestionOptions(text) {
+    // Numbered options: "1. Foo\n2. Bar"
+    const numberedRegex = /^\s*(\d+)\.\s+(.+)$/gm;
+    const options = [];
+    let m;
+    while ((m = numberedRegex.exec(text)) !== null) {
+        options.push(m[2].trim());
+    }
+    if (options.length >= 2)
+        return options.slice(0, 4);
+    return null;
+}
 function makePayload(event, sessionId, detail, meta) {
     const session = sessions.getSession(sessionId);
     return {
@@ -1378,7 +1412,11 @@ async function main() {
     await app.register(fastifyWebsocket);
     registerWsTerminalRoute(app, sessions, tmux, auth);
     // #217: CORS configuration — restrictive by default
+    // #413: Reject wildcard CORS_ORIGIN — * is insecure and allows any origin
     const corsOrigin = process.env.CORS_ORIGIN;
+    if (corsOrigin === '*') {
+        throw new Error('CORS_ORIGIN=* wildcard is not allowed. Specify explicit origins (comma-separated) or leave unset to disable CORS.');
+    }
     await app.register(fastifyCors, {
         origin: corsOrigin ? corsOrigin.split(',').map(s => s.trim()) : false,
     });
@@ -1411,6 +1449,8 @@ async function main() {
     const metricsSaveInterval = setInterval(() => { void metrics.save(); }, 5 * 60 * 1000);
     // #357: Prune stale IP rate-limit entries every minute
     const ipPruneInterval = setInterval(pruneIpRateLimits, 60_000);
+    // #398: Sweep stale API key rate limit buckets every 5 minutes
+    const authSweepInterval = setInterval(() => auth.sweepStaleRateLimits(), 5 * 60_000);
     // Issue #361: Graceful shutdown handler
     // Issue #415: Reentrance guard at handler level prevents double execution on rapid SIGINT
     let shuttingDown = false;
@@ -1430,6 +1470,7 @@ async function main() {
         clearInterval(zombieReaperInterval);
         clearInterval(metricsSaveInterval);
         clearInterval(ipPruneInterval);
+        clearInterval(authSweepInterval);
         // 3. Destroy channels (awaits Telegram poll loop)
         try {
             await channels.destroy();

package/dist/session.d.ts

@@ -61,6 +61,7 @@ export declare class SessionManager {
     private static readonly SAVE_DEBOUNCE_MS;
     private pendingPermissions;
     private pendingQuestions;
+    private static readonly MAX_CACHE_ENTRIES_PER_SESSION;
     private parsedEntriesCache;
     constructor(tmux: TmuxManager, config: Config);
     /** Validate that parsed data looks like a valid SessionState. */
@@ -99,6 +100,12 @@ export declare class SessionManager {
     }>;
     /** Wait for CC idle prompt, then send. Single attempt. */
     private waitForReadyAndSend;
+    /**
+     * Issue #561: After sending an initial prompt, verify CC actually accepted it
+     * by polling for a state transition away from idle/unknown.
+     * Returns true if CC transitions to a recognized active state within the timeout.
+     */
+    private verifyPromptAccepted;
     createSession(opts: {
         workDir: string;
         name?: string;
@@ -221,6 +228,7 @@ export declare class SessionManager {
     getPendingQuestionInfo(sessionId: string): {
         toolUseId: string;
         question: string;
+        timestamp: number;
     } | null;
     /** Issue #336: Clean up any pending question for a session. */
     cleanupPendingQuestion(sessionId: string): void;

package/dist/session.js

@@ -43,6 +43,8 @@ export class SessionManager {
     pendingPermissions = new Map();
     pendingQuestions = new Map();
     // #357: Cache of all parsed JSONL entries per session to avoid re-reading from offset 0
+    // #424: Evict oldest entries when cache exceeds max to prevent unbounded growth
+    static MAX_CACHE_ENTRIES_PER_SESSION = 10_000;
     parsedEntriesCache = new Map();
     constructor(tmux, config) {
         this.tmux = tmux;
@@ -293,16 +295,52 @@ export class SessionManager {
             // At session creation, no other code is writing to this pane,
             // so queue serialization is unnecessary and adds latency.
             const paneText = await this.tmux.capturePaneDirect(session.windowId);
-            // CC shows ❯ (U+276F) when ready for input. Avoid checking for plain >
-            // which appears frequently in tool output, diffs, and prompts.
-            if (paneText && paneText.includes('❯')) {
-                return this.sendMessageDirect(sessionId, prompt);
+            // Issue #561: Use detectUIState for robust readiness detection.
+            // Requires both ❯ prompt AND chrome separators (─────) to confirm idle.
+            // Naive includes('❯') matched splash/startup output, causing premature sends.
+            if (paneText && detectUIState(paneText) === 'idle') {
+                const result = await this.sendMessageDirect(sessionId, prompt);
+                if (!result.delivered)
+                    return result;
+                // Issue #561: Post-send verification. Wait for CC to transition to a
+                // recognized active state. If CC stays in idle/unknown, the prompt was
+                // swallowed — report as undelivered so the retry loop can re-attempt.
+                const verified = await this.verifyPromptAccepted(session.windowId);
+                return verified
+                    ? result
+                    : { delivered: false, attempts: result.attempts };
             }
             await new Promise(r => setTimeout(r, pollInterval));
             pollInterval = Math.min(pollInterval * 2, MAX_POLL_MS);
         }
         return { delivered: false, attempts: 0 };
     }
+    /**
+     * Issue #561: After sending an initial prompt, verify CC actually accepted it
+     * by polling for a state transition away from idle/unknown.
+     * Returns true if CC transitions to a recognized active state within the timeout.
+     */
+    async verifyPromptAccepted(windowId) {
+        const VERIFY_TIMEOUT_MS = 5_000;
+        const VERIFY_POLL_MS = 500;
+        const verifyStart = Date.now();
+        while (Date.now() - verifyStart < VERIFY_TIMEOUT_MS) {
+            const paneText = await this.tmux.capturePaneDirect(windowId);
+            const state = detectUIState(paneText);
+            // Active states mean CC received and is processing the prompt.
+            // waiting_for_input = CC accepted prompt, awaiting follow-up (no chrome yet).
+            if (state === 'working' || state === 'permission_prompt' ||
+                state === 'bash_approval' || state === 'plan_mode' ||
+                state === 'ask_question' || state === 'compacting' ||
+                state === 'context_warning' || state === 'waiting_for_input') {
+                return true;
+            }
+            // idle or unknown — keep polling
+            await new Promise(r => setTimeout(r, VERIFY_POLL_MS));
+        }
+        console.warn(`verifyPromptAccepted: CC did not transition from idle/unknown within ${VERIFY_TIMEOUT_MS}ms`);
+        return false;
+    }
     async createSession(opts) {
         const id = crypto.randomUUID();
         const windowName = opts.name || `cc-${id.slice(0, 8)}`;
@@ -772,7 +810,7 @@ export class SessionManager {
                 console.log(`Hooks: AskUserQuestion timeout for session ${sessionId} — allowing without answer`);
                 resolve(null);
             }, timeoutMs);
-            this.pendingQuestions.set(sessionId, { resolve, timer, toolUseId, question });
+            this.pendingQuestions.set(sessionId, { resolve, timer, toolUseId, question, timestamp: Date.now() });
         });
     }
     /** Issue #336: Submit an answer to a pending question. Returns true if resolved. */
@@ -794,7 +832,7 @@ export class SessionManager {
     /** Issue #336: Get info about a pending question. */
     getPendingQuestionInfo(sessionId) {
         const pending = this.pendingQuestions.get(sessionId);
-        return pending ? { toolUseId: pending.toolUseId, question: pending.question } : null;
+        return pending ? { toolUseId: pending.toolUseId, question: pending.question, timestamp: pending.timestamp } : null;
     }
     /** Issue #336: Clean up any pending question for a session. */
     cleanupPendingQuestion(sessionId) {
@@ -910,6 +948,10 @@ export class SessionManager {
             if (cached) {
                 cached.entries.push(...result.entries);
                 cached.offset = result.newOffset;
+                // #424: Evict oldest entries when cache exceeds per-session cap
+                if (cached.entries.length > SessionManager.MAX_CACHE_ENTRIES_PER_SESSION) {
+                    cached.entries.splice(0, cached.entries.length - SessionManager.MAX_CACHE_ENTRIES_PER_SESSION);
+                }
                 return cached.entries;
             }
             // First read — cache it

package/dist/validation.d.ts

@@ -12,6 +12,8 @@ export declare const authKeySchema: z.ZodObject<{
     name: z.ZodString;
     rateLimit: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+/** Maximum length for user-supplied prompts/commands (Issue #411). */
+export declare const MAX_INPUT_LENGTH = 10000;
 /** POST /v1/sessions/:id/send */
 export declare const sendMessageSchema: z.ZodObject<{
     text: z.ZodString;

package/dist/validation.js

@@ -15,17 +15,19 @@ export const authKeySchema = z.object({
     name: z.string().min(1),
     rateLimit: z.number().int().positive().optional(),
 }).strict();
+/** Maximum length for user-supplied prompts/commands (Issue #411). */
+export const MAX_INPUT_LENGTH = 10_000;
 /** POST /v1/sessions/:id/send */
 export const sendMessageSchema = z.object({
-    text: z.string().min(1),
+    text: z.string().min(1).max(MAX_INPUT_LENGTH),
 }).strict();
 /** POST /v1/sessions/:id/command */
 export const commandSchema = z.object({
-    command: z.string().min(1),
+    command: z.string().min(1).max(MAX_INPUT_LENGTH),
 }).strict();
 /** POST /v1/sessions/:id/bash */
 export const bashSchema = z.object({
-    command: z.string().min(1),
+    command: z.string().min(1).max(MAX_INPUT_LENGTH),
 }).strict();
 /** POST /v1/sessions/:id/screenshot */
 export const screenshotSchema = z.object({
@@ -70,7 +72,7 @@ export const batchSessionSchema = z.object({
 const pipelineStageSchema = z.object({
     name: z.string().min(1),
     workDir: z.string().min(1).optional(),
-    prompt: z.string().min(1),
+    prompt: z.string().min(1).max(MAX_INPUT_LENGTH),
     dependsOn: z.array(z.string()).optional(),
     permissionMode: z.enum(['default', 'bypassPermissions', 'plan']).optional(),
     autoApprove: z.boolean().optional(),

package/dist/ws-terminal.js

@@ -19,7 +19,7 @@
  *   - Shared tmux capture polls (one per session, not per connection)
  *   - Ping/pong keep-alive with dead connection detection
  */
-import { clamp, wsInboundMessageSchema } from './validation.js';
+import { clamp, wsInboundMessageSchema, isValidUUID } from './validation.js';
 const POLL_INTERVAL_MS = 500;
 const KEEPALIVE_INTERVAL_TICKS = 60; // 30s at 500ms intervals
 const KEEPALIVE_TIMEOUT_MS = 35_000; // 30s interval + 5s grace
@@ -69,6 +69,12 @@ export function registerWsTerminalRoute(app, sessions, tmux, auth) {
         },
     }, (socket, req) => {
         const sessionId = req.params.id;
+        // #412: Validate session ID is a UUID before lookup
+        if (!isValidUUID(sessionId)) {
+            sendError(socket, 'Invalid session ID — must be a UUID');
+            socket.close();
+            return;
+        }
         const session = sessions.getSession(sessionId);
         if (!session) {
             sendError(socket, 'Session not found');

package/package.json

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