aegis-bridge 2.5.4 → 2.5.5

package/dist/pipeline.d.ts

@@ -61,6 +61,7 @@ export interface PipelineState {
 export declare class PipelineManager {
     private sessions;
     private eventBus?;
+    private static readonly PIPELINE_RETRY_MAX_ATTEMPTS;
     private pipelines;
     private pipelineConfigs;
     private pollInterval;

package/dist/pipeline.js

@@ -5,9 +5,12 @@
  * sequential pipelines with stage dependencies.
  */
 import { getErrorMessage } from './validation.js';
+import { shouldRetry } from './error-categories.js';
+import { retryWithJitter } from './retry.js';
 export class PipelineManager {
     sessions;
     eventBus;
+    static PIPELINE_RETRY_MAX_ATTEMPTS = 3;
     pipelines = new Map();
     pipelineConfigs = new Map(); // #219: preserve original stage config
     pollInterval = null;
@@ -127,14 +130,20 @@ export class PipelineManager {
             if (!stageConfig)
                 continue;
             try {
-                const session = await this.sessions.createSession({
+                const session = await retryWithJitter(async () => this.sessions.createSession({
                     workDir: stageConfig.workDir || config.workDir,
                     name: `pipeline-${config.name}-${stage.name}`,
                     permissionMode: stageConfig.permissionMode,
                     autoApprove: stageConfig.autoApprove,
+                }), {
+                    maxAttempts: PipelineManager.PIPELINE_RETRY_MAX_ATTEMPTS,
+                    shouldRetry: (error) => shouldRetry(error),
                 });
                 if (stageConfig.prompt) {
-                    await this.sessions.sendInitialPrompt(session.id, stageConfig.prompt);
+                    await retryWithJitter(async () => this.sessions.sendInitialPrompt(session.id, stageConfig.prompt), {
+                        maxAttempts: PipelineManager.PIPELINE_RETRY_MAX_ATTEMPTS,
+                        shouldRetry: (error) => shouldRetry(error),
+                    });
                 }
                 stage.sessionId = session.id;
                 stage.status = 'running';

package/dist/retry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * retry.ts — shared retry helper with bounded exponential backoff + jitter.
+ */
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
+}
+export declare function retryWithJitter<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,34 @@
+/**
+ * retry.ts — shared retry helper with bounded exponential backoff + jitter.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function computeDelayMs(attempt, baseDelayMs, maxDelayMs) {
+    const exponential = Math.min(baseDelayMs * (2 ** (attempt - 1)), maxDelayMs);
+    const jitterMultiplier = 0.5 + (Math.random() * 0.5);
+    return Math.round(exponential * jitterMultiplier);
+}
+export async function retryWithJitter(fn, options = {}) {
+    const maxAttempts = options.maxAttempts ?? 3;
+    const baseDelayMs = options.baseDelayMs ?? 250;
+    const maxDelayMs = options.maxDelayMs ?? 3_000;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            const isLastAttempt = attempt >= maxAttempts;
+            const canRetry = options.shouldRetry ? options.shouldRetry(error, attempt) : true;
+            if (isLastAttempt || !canRetry) {
+                throw error;
+            }
+            const delayMs = computeDelayMs(attempt, baseDelayMs, maxDelayMs);
+            options.onRetry?.(error, attempt, delayMs);
+            await sleep(delayMs);
+        }
+    }
+    throw lastError;
+}

package/dist/server.js

@@ -70,8 +70,10 @@ async function handleInbound(cmd) {
                 await sessions.escape(cmd.sessionId);
                 break;
             case 'kill':
-                await channels.sessionEnded(makePayload('session.ended', cmd.sessionId, 'killed'));
+                // #842: killSession first, then notify — avoids race where channels
+                // reference a session that is still being destroyed.
                 await sessions.killSession(cmd.sessionId);
+                await channels.sessionEnded(makePayload('session.ended', cmd.sessionId, 'killed'));
                 monitor.removeSession(cmd.sessionId);
                 metrics.cleanupSession(cmd.sessionId);
                 break;
@@ -678,9 +680,11 @@ async function killSessionHandler(req, reply) {
         return reply.status(404).send({ error: 'Session not found' });
     }
     try {
+        // #842: killSession first, then notify — avoids race where channels
+        // reference a session that is still being destroyed.
+        await sessions.killSession(req.params.id);
         eventBus.emitEnded(req.params.id, 'killed');
         await channels.sessionEnded(makePayload('session.ended', req.params.id, 'killed'));
-        await sessions.killSession(req.params.id);
         monitor.removeSession(req.params.id);
         metrics.cleanupSession(req.params.id);
         return { ok: true };
@@ -997,14 +1001,16 @@ async function reapStaleSessions(maxAgeMs) {
             const ageMin = Math.round(age / 60000);
             console.log(`Reaper: killing session ${session.windowName} (${session.id.slice(0, 8)}) — age ${ageMin}min`);
             try {
+                // #842: killSession first, then notify — avoids race where channels
+                // reference a session that is still being destroyed.
+                await sessions.killSession(session.id);
+                eventBus.cleanupSession(session.id);
                 await channels.sessionEnded({
                     event: 'session.ended',
                     timestamp: new Date().toISOString(),
                     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);
             }

package/dist/session.d.ts

@@ -65,7 +65,7 @@ export declare class SessionManager {
     private pendingQuestions;
     private static readonly MAX_CACHE_ENTRIES_PER_SESSION;
     private parsedEntriesCache;
-    private sessionAcquireMutex;
+    private readonly sessionAcquireMutex;
     constructor(tmux: TmuxManager, config: Config);
     /** Validate that parsed data looks like a valid SessionState. */
     private isValidState;
@@ -164,7 +164,7 @@ export declare class SessionManager {
      *  Returns the most recently active idle session, or null if none found.
      *  Used to resume existing sessions instead of creating duplicates.
      *  Issue #636: Verifies tmux window is still alive before returning.
-     *  Issue #840: Atomically acquires the session under a mutex to prevent TOCTOU race. */
+     *  Issue #840/#880: Atomically acquires the session under a mutex to prevent TOCTOU race. */
     findIdleSessionByWorkDir(workDir: string): Promise<SessionInfo | null>;
     /** Release a session claim after the reuse path completes (success or failure). */
     releaseSessionClaim(id: string): void;

package/dist/session.js

@@ -14,6 +14,7 @@ import { computeStallThreshold } from './config.js';
 import { neutralizeBypassPermissions, restoreSettings, cleanOrphanedBackup } from './permission-guard.js';
 import { persistedStateSchema, sessionMapSchema } from './validation.js';
 import { writeHookSettingsFile, cleanupHookSettingsFile } from './hook-settings.js';
+import { Mutex } from 'async-mutex';
 /** Convert parsed JSON arrays to Sets for activeSubagents (#668). */
 function hydrateSessions(raw) {
     const sessions = {};
@@ -62,8 +63,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 #840: Mutex to prevent TOCTOU race in findIdleSessionByWorkDir
-    sessionAcquireMutex = Promise.resolve();
+    // Issue #840/#880: Explicit mutex to prevent TOCTOU races in session acquisition.
+    sessionAcquireMutex = new Mutex();
     constructor(tmux, config) {
         this.tmux = tmux;
         this.config = config;
@@ -705,15 +706,9 @@ export class SessionManager {
      *  Returns the most recently active idle session, or null if none found.
      *  Used to resume existing sessions instead of creating duplicates.
      *  Issue #636: Verifies tmux window is still alive before returning.
-     *  Issue #840: Atomically acquires the session under a mutex to prevent TOCTOU race. */
+     *  Issue #840/#880: Atomically acquires the session under a mutex to prevent TOCTOU race. */
     async findIdleSessionByWorkDir(workDir) {
-        // Issue #840: Acquire mutex — chain onto the previous operation
-        let release;
-        const lock = new Promise((resolve) => { release = resolve; });
-        const previous = this.sessionAcquireMutex;
-        this.sessionAcquireMutex = lock;
-        await previous.catch(() => { }); // tolerate prior rejection
-        try {
+        return this.sessionAcquireMutex.runExclusive(async () => {
             const candidates = Object.values(this.state.sessions).filter((s) => s.workDir === workDir && s.status === 'idle');
             if (candidates.length === 0)
                 return null;
@@ -729,10 +724,7 @@ export class SessionManager {
                 }
             }
             return null;
-        }
-        finally {
-            release();
-        }
+        });
     }
     /** Release a session claim after the reuse path completes (success or failure). */
     releaseSessionClaim(id) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aegis-bridge",
-  "version": "2.5.4",
+  "version": "2.5.5",
   "type": "module",
   "description": "Orchestrate Claude Code sessions via API. Create, brief, monitor, refine, ship.",
   "main": "dist/server.js",
@@ -48,6 +48,7 @@
     "@fastify/static": "^9.0.0",
     "@fastify/websocket": "^11.2.0",
     "@modelcontextprotocol/sdk": "^1.28.0",
+    "async-mutex": "^0.5.0",
     "fastify": "^5.8.2",
     "zod": "^4.3.6"
   },