aegis-bridge 2.5.2 → 2.5.4

package/dist/tmux.js

@@ -217,6 +217,15 @@ export class TmuxManager {
                 if (lastError) {
                     throw new Error(`Failed to create tmux window after ${MAX_RETRIES} attempts: ${name} — ${lastError.message}`);
                 }
+                // #837: Set env vars INSIDE the serialize block to prevent race.
+                // Previously setEnvSecure ran after serialize() returned, so concurrent
+                // createWindow calls could interleave send-keys between window creation
+                // and env injection, corrupting the environment.
+                // Uses setEnvSecureDirect (sendKeysDirectInternal) to avoid re-entering
+                // serialize from within an active serialize callback.
+                if (opts.env && Object.keys(opts.env).length > 0) {
+                    await this.setEnvSecureDirect(id, opts.env);
+                }
                 return { windowId: id, windowName: name };
             });
             windowId = creationResult.windowId;
@@ -225,31 +234,6 @@ export class TmuxManager {
         finally {
             this._creatingCount--;
         }
-        // Set env vars if provided.
-        // Issue #89 L29: Recommended Claude Code environment variables.
-        // These are merged in SessionManager.createSession() from config.defaultSessionEnv
-        // and per-session opts.env (user vars override defaults).
-        //
-        // Key env vars CC recognizes:
-        //   ANTHROPIC_API_KEY         — Required for Anthropic API direct access
-        //   ANTHROPIC_BASE_URL        — Custom API endpoint (e.g. proxy/bedrock)
-        //   ANTHROPIC_MODEL           — Override default model selection
-        //   DISABLE_AUTOUPDATER=1     — Suppress CC's auto-update check
-        //   CLAUDE_CODE_SKIP_EULA=1   — Skip EULA prompt on first launch
-        //   CLAUDE_CODE_USE_BEDROCK=1 — Use AWS Bedrock backend
-        //   MCP_TIMEOUT_MS            — Timeout for MCP server communication
-        //   NO_COLOR=1                — Disable color output (useful for parsing)
-        //   HOME                      — User home directory (usually inherited)
-        //   PATH                      — Binary search path (usually inherited)
-        //
-        // Note: The --settings flag already handles proxy config (z.ai) and
-        // workspace trust, so ANTHROPIC_BASE_URL via env is a fallback.
-        //
-        // Issue #23: Use temp file + source instead of send-keys export to prevent
-        // env var values (tokens, secrets) from appearing in tmux pane history.
-        if (opts.env && Object.keys(opts.env).length > 0) {
-            await this.setEnvSecure(windowId, opts.env);
-        }
         // Ensure Claude starts a fresh session.
         // Two-layer defense against CC auto-resuming stale sessions:
         //
@@ -417,6 +401,38 @@ export class TmuxManager {
         }
         catch { /* already deleted by shell */ }
     }
+    /** #837: Direct variant of setEnvSecure that uses sendKeysDirectInternal instead of
+     *  sendKeys, safe to call from inside a serialize() callback without deadlocking.
+     *  Identical logic otherwise. */
+    async setEnvSecureDirect(windowId, env) {
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        for (const key of Object.keys(env)) {
+            if (!ENV_KEY_RE.test(key)) {
+                throw new Error(`Invalid env var key: '${key}' — must match ${ENV_KEY_RE.source}`);
+            }
+        }
+        const tmpFile = path.join(tmpdir(), `.aegis-env-${randomBytes(16).toString('hex')}`);
+        const lines = Object.entries(env).map(([key, val]) => {
+            const escaped = val.replace(/'/g, "'\\''");
+            return `export ${key}='${escaped}'`;
+        });
+        await fs.writeFile(tmpFile, lines.join('\n') + '\n', { mode: 0o600 });
+        // Use sendKeysDirectInternal to avoid re-entering serialize()
+        const cmd = `source ${shellEscape(tmpFile)} && rm -f ${shellEscape(tmpFile)}`;
+        await this.sendKeysDirectInternal(windowId, cmd, true);
+        await this.pollUntil(async () => { try {
+            await stat(tmpFile);
+            return false;
+        }
+        catch {
+            return true;
+        } }, 50, 500);
+        try {
+            await fs.unlink(tmpFile);
+        }
+        catch { /* already deleted by shell */ }
+    }
     /** P1 fix: Check if a window exists. Returns true if window is in the session.
      *  #357: Uses a short-lived cache to avoid repeated tmux CLI calls. */
     async windowExists(windowId) {
@@ -620,19 +636,13 @@ export class TmuxManager {
         const raw = await this.tmux('capture-pane', '-t', target, '-p');
         return raw.replace(/\x1bP[\s\S]*?\x1b\\/g, '');
     }
-    /** Capture pane content WITHOUT going through the serialize queue.
-     *  Used for critical-path operations (e.g., sendInitialPrompt) that should
-     *  not be delayed by monitor polls. The queue is for preventing race conditions
-     *  in monitor/concurrent reads, but sendInitialPrompt is the ONLY writer at
-     *  session creation time.
-     *  #403: During window creation (_creatingCount > 0), queues behind serialize
-     *  to avoid racing with the creation sequence.
+    /** Capture pane content through the serialize queue.
+     *  #824: Always serialize to prevent race conditions with concurrent reads
+     *  from monitor polls and ! command mode. The previous _creatingCount guard
+     *  only queued during window creation, leaving a race window at other times.
      */
     async capturePaneDirect(windowId) {
-        if (this._creatingCount > 0) {
-            return this.serialize(() => this.capturePaneDirectInternal(windowId));
-        }
-        return this.capturePaneDirectInternal(windowId);
+        return this.serialize(() => this.capturePaneDirectInternal(windowId));
     }
     async capturePaneDirectInternal(windowId) {
         const target = `${this.sessionName}:${windowId}`;
@@ -647,6 +657,11 @@ export class TmuxManager {
             if (e && typeof e === 'object' && 'killed' in e && e.killed) {
                 throw new TmuxTimeoutError(['capture-pane', '-t', target, '-p'], TMUX_DEFAULT_TIMEOUT_MS);
             }
+            // Issue #845: Handle tmux server crash (ECONNREFUSED) gracefully.
+            // Return empty string instead of crashing the request handler.
+            if (e && typeof e === 'object' && 'code' in e && e.code === 'ECONNREFUSED') {
+                return '';
+            }
             throw e;
         }
     }

package/dist/transcript.js

@@ -12,15 +12,20 @@ import { readdir } from 'node:fs/promises';
 import { sessionsIndexSchema } from './validation.js';
 /** Default Claude projects directory */
 const DEFAULT_CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
-/** Parse a single JSONL line. Returns null if not parseable. */
+/** Parse a single JSONL line. Returns null if not parseable.
+ *  Issue #823: Logs at error level when a non-empty line is dropped. */
 function parseLine(line) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed[0] !== '{')
+    if (!trimmed || trimmed[0] !== '{') {
+        // Lines that are blank or don't start with '{' are expected (separators, comments)
         return null;
+    }
     try {
         return JSON.parse(trimmed);
     }
-    catch { /* malformed JSON — skip line */
+    catch (err) {
+        // Issue #823: Log malformed JSON lines so data loss is visible
+        console.error(`parseLine: dropping malformed JSONL line (${err.message}): ${trimmed.slice(0, 200)}`);
         return null;
     }
 }
@@ -184,11 +189,10 @@ export async function readNewEntries(filePath, fromOffset) {
                     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;
-            }
+            // Issue #836: If no newline found in the scan window, the line is
+            // longer than scanSize. Keep effectiveOffset as-is (fromOffset) —
+            // starting mid-line is handled by JSON.parse rejecting partial lines.
+            // Never fall back to offset 0, which causes O(n) re-reads.
         }
         const slicedContent = await new Promise((resolve, reject) => {
             const chunks = [];

package/dist/validation.d.ts

@@ -128,10 +128,14 @@ export declare const persistedStateSchema: z.ZodRecord<z.ZodString, z.ZodObject<
     byteOffset: z.ZodNumber;
     monitorOffset: z.ZodNumber;
     status: z.ZodEnum<{
+        error: "error";
         unknown: "unknown";
         permission_prompt: "permission_prompt";
         idle: "idle";
         working: "working";
+        compacting: "compacting";
+        context_warning: "context_warning";
+        waiting_for_input: "waiting_for_input";
         bash_approval: "bash_approval";
         plan_mode: "plan_mode";
         ask_question: "ask_question";

package/dist/validation.js

@@ -121,8 +121,9 @@ export function isValidUUID(id) {
 }
 // ── JSON.parse boundary validation (Issue #410) ──────────────────
 const UIStateEnum = z.enum([
-    'idle', 'working', 'permission_prompt', 'bash_approval',
-    'plan_mode', 'ask_question', 'settings', 'unknown',
+    'idle', 'working', 'compacting', 'context_warning', 'waiting_for_input',
+    'permission_prompt', 'bash_approval', 'plan_mode', 'ask_question',
+    'settings', 'error', 'unknown',
 ]);
 /** Schema for persisted SessionState (sessions: { [id]: SessionInfo }). */
 export const persistedStateSchema = z.record(z.string(), z.object({

package/package.json

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