aegis-bridge 2.3.8 → 2.3.10

package/dist/pipeline.js

@@ -179,6 +179,11 @@ export class PipelineManager {
                 setTimeout(() => {
                     this.pipelines.delete(pipelineId);
                     this.pipelineConfigs.delete(pipelineId); // #219: clean up stored config
+                    // #578: Stop polling when no pipelines remain
+                    if (this.pipelines.size === 0 && this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
                 }, 30_000);
             }
         }

package/dist/server.js

@@ -34,6 +34,7 @@ import { MetricsCollector } from './metrics.js';
 import { registerHookRoutes } from './hooks.js';
 import { registerWsTerminalRoute } from './ws-terminal.js';
 import { SwarmMonitor } from './swarm-monitor.js';
+import { killAllSessions } from './signal-cleanup-helper.js';
 import { execFileSync } from 'node:child_process';
 import { authKeySchema, sendMessageSchema, commandSchema, bashSchema, screenshotSchema, permissionHookSchema, stopHookSchema, batchSessionSchema, pipelineSchema, parseIntSafe, isValidUUID, } from './validation.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -1503,6 +1504,13 @@ async function main() {
         clearInterval(metricsSaveInterval);
         clearInterval(ipPruneInterval);
         clearInterval(authSweepInterval);
+        // Issue #569: Kill all CC sessions and tmux windows before exit
+        try {
+            await killAllSessions(sessions, tmux);
+        }
+        catch (e) {
+            console.error('Error killing sessions:', e);
+        }
         // 3. Destroy channels (awaits Telegram poll loop)
         try {
             await channels.destroy();

package/dist/signal-cleanup-helper.d.ts

@@ -0,0 +1,48 @@
+/**
+ * signal-cleanup-helper.ts — Signal handler cleanup logic for Issue #569.
+ *
+ * Provides killAllSessions() and createSignalHandler() for graceful shutdown.
+ * Separated from server.ts for testability.
+ */
+import type { SessionManager } from './session.js';
+import type { TmuxManager } from './tmux.js';
+/** Result of killAllSessions operation. */
+export interface KillAllResult {
+    /** Number of sessions successfully killed. */
+    killed: number;
+    /** Number of sessions that failed to kill. */
+    errors: number;
+}
+/** Result of killAllSessionsWithTimeout operation. */
+export interface KillAllWithTimeoutResult extends KillAllResult {
+    /** Whether any session kill timed out. */
+    timedOut: boolean;
+}
+/**
+ * Kill all active CC sessions and the tmux session.
+ * Best-effort: continues even if individual session kills fail.
+ *
+ * @param sessions - SessionManager instance
+ * @param tmux - TmuxManager instance
+ * @returns Number of sessions killed and errors encountered
+ */
+export declare function killAllSessions(sessions: SessionManager, tmux: TmuxManager): Promise<KillAllResult>;
+/**
+ * Kill all sessions with per-session timeout protection.
+ * If a session kill hangs beyond the timeout, it is skipped.
+ *
+ * @param sessions - SessionManager instance
+ * @param tmux - TmuxManager instance
+ * @param perSessionTimeoutMs - Maximum time to wait per session kill (default 5000ms)
+ * @returns Result including timeout status
+ */
+export declare function killAllSessionsWithTimeout(sessions: SessionManager, tmux: TmuxManager, perSessionTimeoutMs?: number): Promise<KillAllWithTimeoutResult>;
+/**
+ * Create a signal handler that kills all sessions on SIGTERM/SIGINT.
+ * Includes reentrance guard to prevent double cleanup on rapid signals.
+ *
+ * @param sessions - SessionManager instance
+ * @param tmux - TmuxManager instance
+ * @returns Signal handler function
+ */
+export declare function createSignalHandler(sessions: SessionManager, tmux: TmuxManager): (signal: string) => void;

package/dist/signal-cleanup-helper.js

@@ -0,0 +1,118 @@
+/**
+ * signal-cleanup-helper.ts — Signal handler cleanup logic for Issue #569.
+ *
+ * Provides killAllSessions() and createSignalHandler() for graceful shutdown.
+ * Separated from server.ts for testability.
+ */
+/**
+ * Kill all active CC sessions and the tmux session.
+ * Best-effort: continues even if individual session kills fail.
+ *
+ * @param sessions - SessionManager instance
+ * @param tmux - TmuxManager instance
+ * @returns Number of sessions killed and errors encountered
+ */
+export async function killAllSessions(sessions, tmux) {
+    const allSessions = sessions.listSessions();
+    let killed = 0;
+    let errors = 0;
+    // Kill each session individually (restores settings, cleans up temp files)
+    for (const session of allSessions) {
+        try {
+            await sessions.killSession(session.id);
+            killed++;
+        }
+        catch (e) {
+            errors++;
+            console.error(`Signal cleanup: failed to kill session ${session.windowName} (${session.id.slice(0, 8)}): ${e.message}`);
+        }
+    }
+    // Final fallback: kill the entire tmux session to ensure nothing is left
+    try {
+        await tmux.killSession();
+    }
+    catch (e) {
+        console.error(`Signal cleanup: failed to kill tmux session: ${e.message}`);
+    }
+    console.log(`Signal cleanup: killed ${killed} sessions (${errors} errors)`);
+    return { killed, errors };
+}
+/**
+ * Kill all sessions with per-session timeout protection.
+ * If a session kill hangs beyond the timeout, it is skipped.
+ *
+ * @param sessions - SessionManager instance
+ * @param tmux - TmuxManager instance
+ * @param perSessionTimeoutMs - Maximum time to wait per session kill (default 5000ms)
+ * @returns Result including timeout status
+ */
+export async function killAllSessionsWithTimeout(sessions, tmux, perSessionTimeoutMs = 5_000) {
+    const allSessions = sessions.listSessions();
+    let killed = 0;
+    let errors = 0;
+    let timedOut = false;
+    for (const session of allSessions) {
+        try {
+            await withTimeout(sessions.killSession(session.id), perSessionTimeoutMs, `Session kill timeout for ${session.windowName}`);
+            killed++;
+        }
+        catch (e) {
+            if (e instanceof TimeoutError) {
+                timedOut = true;
+                console.error(`Signal cleanup: TIMED OUT killing session ${session.windowName}`);
+            }
+            else {
+                console.error(`Signal cleanup: failed to kill session ${session.windowName}: ${e.message}`);
+            }
+            errors++;
+        }
+    }
+    // Final fallback: kill entire tmux session
+    try {
+        await tmux.killSession();
+    }
+    catch (e) {
+        console.error(`Signal cleanup: failed to kill tmux session: ${e.message}`);
+    }
+    console.log(`Signal cleanup: killed ${killed}/${allSessions.length} sessions (${errors} errors, ${timedOut ? 'some timed out' : 'no timeouts'})`);
+    return { killed, errors, timedOut };
+}
+/** Error thrown when an operation exceeds its timeout. */
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+/** Wrap a promise with a timeout. */
+function withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new TimeoutError(message)), ms);
+        promise.then((val) => { clearTimeout(timer); resolve(val); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}
+/**
+ * Create a signal handler that kills all sessions on SIGTERM/SIGINT.
+ * Includes reentrance guard to prevent double cleanup on rapid signals.
+ *
+ * @param sessions - SessionManager instance
+ * @param tmux - TmuxManager instance
+ * @returns Signal handler function
+ */
+export function createSignalHandler(sessions, tmux) {
+    let shuttingDown = false;
+    return (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log(`${signal} received — cleaning up ${sessions.listSessions().length} active sessions...`);
+        void killAllSessions(sessions, tmux)
+            .then((result) => {
+            console.log(`${signal} cleanup complete: ${result.killed} sessions killed`);
+        })
+            .catch((e) => {
+            console.error(`${signal} cleanup error:`, e);
+        });
+    };
+}
+//# sourceMappingURL=signal-cleanup-helper.js.map

package/dist/transcript.js

@@ -179,12 +179,19 @@ export async function readNewEntries(filePath, fromOffset) {
         finally {
             await fd.close();
         }
+        let foundNewline = false;
         for (let i = scanBuf.length - 1; i >= 0; i--) {
             if (scanBuf[i] === 0x0a) { // '\n'
                 effectiveOffset = scanStart + i + 1;
+                foundNewline = true;
                 break;
             }
         }
+        // Issue #579: If no newline found and we didn't scan from byte 0,
+        // fall back to offset 0 to avoid starting mid-line.
+        if (!foundNewline && scanStart > 0) {
+            effectiveOffset = 0;
+        }
     }
     const slicedContent = await new Promise((resolve, reject) => {
         const chunks = [];

package/package.json

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