@elvatis_com/openclaw-cli-bridge-elvatis 2.4.0 → 2.6.0

package/src/session-manager.ts

@@ -16,6 +16,11 @@ import { join } from "node:path";
 import { execSync } from "node:child_process";
 import { formatPrompt, type ChatMessage } from "./cli-runner.js";
 import { createIsolatedWorkdir, cleanupWorkdir, sweepOrphanedWorkdirs } from "./workdir.js";
+import {
+  SESSION_TTL_MS,
+  CLEANUP_INTERVAL_MS,
+  SESSION_KILL_GRACE_MS,
+} from "./config.js";
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Types
@@ -92,9 +97,7 @@ function buildMinimalEnv(): Record<string, string> {
 // Session Manager
 // ──────────────────────────────────────────────────────────────────────────────
 
-/** Auto-cleanup interval: 30 minutes. */
-const SESSION_TTL_MS = 30 * 60 * 1000;
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+// SESSION_TTL_MS, CLEANUP_INTERVAL_MS, SESSION_KILL_GRACE_MS imported from config.ts
 
 export class SessionManager {
   private sessions = new Map<string, SessionEntry>();
@@ -213,12 +216,19 @@ export class SessionManager {
     }
   }
 
-  /** Send SIGTERM to the session process. */
+  /**
+   * Gracefully terminate a session: SIGTERM first, then SIGKILL after grace period.
+   * This prevents the ambiguous "exit 143 (no output)" pattern.
+   */
   kill(sessionId: string): boolean {
     const entry = this.sessions.get(sessionId);
     if (!entry || entry.status !== "running") return false;
     entry.status = "killed";
     entry.proc.kill("SIGTERM");
+    // If the process doesn't exit within the grace period, force-kill it
+    setTimeout(() => {
+      try { if (!entry.proc.killed) entry.proc.kill("SIGKILL"); } catch { /* already dead */ }
+    }, SESSION_KILL_GRACE_MS);
     return true;
   }
 
@@ -238,7 +248,7 @@ export class SessionManager {
     return result;
   }
 
-  /** Remove sessions older than SESSION_TTL_MS. Kill running ones first. Clean up isolated workdirs. */
+  /** Remove sessions older than SESSION_TTL_MS. Kill running ones with graceful SIGTERM→SIGKILL. */
   cleanup(): void {
     const now = Date.now();
     for (const [sessionId, entry] of this.sessions) {
@@ -246,6 +256,10 @@ export class SessionManager {
         if (entry.status === "running") {
           entry.proc.kill("SIGTERM");
           entry.status = "killed";
+          // Escalate to SIGKILL after grace period
+          setTimeout(() => {
+            try { if (!entry.proc.killed) entry.proc.kill("SIGKILL"); } catch { /* already dead */ }
+          }, SESSION_KILL_GRACE_MS);
         }
         // Clean up isolated workdir if it wasn't cleaned on exit
         if (entry.isolatedWorkdir) {
@@ -258,17 +272,20 @@ export class SessionManager {
     sweepOrphanedWorkdirs();
   }
 
-  /** Stop the cleanup timer (for graceful shutdown). */
+  /** Stop the cleanup timer (for graceful shutdown). SIGTERM all sessions, SIGKILL after grace. */
   stop(): void {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
     }
-    // Kill all running sessions and clean up their workdirs
+    // Kill all running sessions with graceful SIGTERM → SIGKILL escalation
     for (const [, entry] of this.sessions) {
       if (entry.status === "running") {
         entry.proc.kill("SIGTERM");
         entry.status = "killed";
+        setTimeout(() => {
+          try { if (!entry.proc.killed) entry.proc.kill("SIGKILL"); } catch { /* already dead */ }
+        }, SESSION_KILL_GRACE_MS);
       }
       if (entry.isolatedWorkdir) {
         cleanupWorkdir(entry.isolatedWorkdir);

package/test/cli-runner-extended.test.ts

@@ -265,3 +265,75 @@ describe("Codex auto-git-init via routeToCliRunner", () => {
     expect(mockExecSync).toHaveBeenCalledWith("git init", expect.objectContaining({ cwd: "/no-git-dir" }));
   });
 });
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Timeout handling: graceful SIGTERM → SIGKILL and exit 143 annotation
+// ──────────────────────────────────────────────────────────────────────────────
+
+import { runCli, annotateExitError } from "../src/cli-runner.js";
+
+describe("runCli() timeout handling", () => {
+  it("does NOT pass timeout to spawn options (manual timer instead)", async () => {
+    mockSpawn.mockImplementation(() => makeFakeProc("ok", 0));
+    await runCli("echo", [], "hello", 60_000);
+    const spawnOpts = mockSpawn.mock.calls[0][2];
+    expect(spawnOpts.timeout).toBeUndefined();
+  });
+
+  it("sends SIGTERM after timeout fires", async () => {
+    vi.useFakeTimers();
+    const proc = new EventEmitter() as any;
+    proc.stdout = new EventEmitter();
+    proc.stderr = new EventEmitter();
+    proc.stdin = { write: vi.fn((_d: string, _e: string, cb?: () => void) => { cb?.(); }), end: vi.fn() };
+    proc.kill = vi.fn(() => { proc.emit("close", 143); });
+    proc.killed = false;
+    mockSpawn.mockImplementation(() => proc);
+
+    const logMessages: string[] = [];
+    const promise = runCli("claude", [], "prompt", 100, { log: (m) => logMessages.push(m) });
+
+    // Advance past the timeout
+    vi.advanceTimersByTime(101);
+
+    const result = await promise;
+    expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
+    expect(result.timedOut).toBe(true);
+    expect(result.exitCode).toBe(143);
+    expect(logMessages.some(m => m.includes("timeout") && m.includes("SIGTERM"))).toBe(true);
+    vi.useRealTimers();
+  });
+
+  it("sets timedOut=false for normal exits", async () => {
+    mockSpawn.mockImplementation(() => makeFakeProc("output", 0));
+    const result = await runCli("echo", [], "hello", 60_000);
+    expect(result.timedOut).toBe(false);
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+describe("annotateExitError()", () => {
+  it("annotates exit 143 as timeout", () => {
+    const msg = annotateExitError(143, "(no output)", false, "cli-claude/claude-sonnet-4-6");
+    expect(msg).toContain("timeout");
+    expect(msg).toContain("supervisor");
+    expect(msg).toContain("cli-claude/claude-sonnet-4-6");
+  });
+
+  it("annotates when timedOut is true regardless of exit code", () => {
+    const msg = annotateExitError(1, "some error", true, "cli-claude/claude-sonnet-4-6");
+    expect(msg).toContain("timeout");
+    expect(msg).toContain("supervisor");
+  });
+
+  it("returns plain error when not a timeout", () => {
+    const msg = annotateExitError(1, "auth error", false, "cli-claude/claude-sonnet-4-6");
+    expect(msg).toBe("auth error");
+    expect(msg).not.toContain("timeout");
+  });
+
+  it("returns (no output) placeholder when stderr is empty and not a timeout", () => {
+    const msg = annotateExitError(1, "", false, "cli-claude/claude-sonnet-4-6");
+    expect(msg).toBe("(no output)");
+  });
+});

package/test/config.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Tests for the centralized config module.
+ * No mocks — tests the real exported values.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  DEFAULT_PROXY_PORT,
+  DEFAULT_PROXY_API_KEY,
+  DEFAULT_PROXY_TIMEOUT_MS,
+  DEFAULT_CLI_TIMEOUT_MS,
+  TIMEOUT_GRACE_MS,
+  MAX_MESSAGES,
+  MAX_MSG_CHARS,
+  SESSION_TTL_MS,
+  CLEANUP_INTERVAL_MS,
+  SESSION_KILL_GRACE_MS,
+  DEFAULT_MODEL_TIMEOUTS,
+  DEFAULT_MODEL_FALLBACKS,
+  OPENCLAW_DIR,
+  CLI_TEST_DEFAULT_MODEL,
+  MAX_EFFECTIVE_TIMEOUT_MS,
+  TIMEOUT_PER_EXTRA_MSG_MS,
+  TIMEOUT_PER_TOOL_MS,
+  PROVIDER_SESSION_TTL_MS,
+  MEDIA_TMP_DIR,
+  PROFILE_DIRS,
+  STATE_FILE,
+  PENDING_FILE,
+  PROVIDER_SESSIONS_FILE,
+  DEFAULT_BITNET_SERVER_URL,
+  BITNET_MAX_MESSAGES,
+  BITNET_SYSTEM_PROMPT,
+} from "../src/config.js";
+
+describe("config.ts exports", () => {
+  it("exports sensible timeout defaults", () => {
+    expect(DEFAULT_PROXY_TIMEOUT_MS).toBe(300_000);
+    expect(DEFAULT_CLI_TIMEOUT_MS).toBe(120_000);
+    expect(TIMEOUT_GRACE_MS).toBe(5_000);
+    expect(MAX_EFFECTIVE_TIMEOUT_MS).toBe(600_000);
+    expect(SESSION_TTL_MS).toBe(30 * 60 * 1000);
+    expect(CLEANUP_INTERVAL_MS).toBe(5 * 60 * 1000);
+    expect(SESSION_KILL_GRACE_MS).toBe(5_000);
+    expect(PROVIDER_SESSION_TTL_MS).toBe(2 * 60 * 60 * 1000);
+  });
+
+  it("exports dynamic timeout scaling factors", () => {
+    expect(TIMEOUT_PER_EXTRA_MSG_MS).toBe(2_000);
+    expect(TIMEOUT_PER_TOOL_MS).toBe(5_000);
+  });
+
+  it("exports message limits", () => {
+    expect(MAX_MESSAGES).toBe(20);
+    expect(MAX_MSG_CHARS).toBe(4_000);
+  });
+
+  it("exports proxy defaults", () => {
+    expect(DEFAULT_PROXY_PORT).toBe(31337);
+    expect(DEFAULT_PROXY_API_KEY).toBe("cli-bridge");
+  });
+
+  it("exports per-model timeouts for all major models", () => {
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-opus-4-6"]).toBe(300_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-sonnet-4-6"]).toBe(180_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-haiku-4-5"]).toBe(90_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-pro"]).toBe(180_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-flash"]).toBe(90_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["openai-codex/gpt-5.4"]).toBe(300_000);
+  });
+
+  it("exports model fallback chains", () => {
+    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-sonnet-4-6"]).toBe("cli-claude/claude-haiku-4-5");
+    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-opus-4-6"]).toBe("cli-claude/claude-sonnet-4-6");
+    expect(DEFAULT_MODEL_FALLBACKS["cli-gemini/gemini-2.5-pro"]).toBe("cli-gemini/gemini-2.5-flash");
+  });
+
+  it("exports path constants rooted in ~/.openclaw", () => {
+    expect(OPENCLAW_DIR).toContain(".openclaw");
+    expect(STATE_FILE).toContain("cli-bridge-state.json");
+    expect(PENDING_FILE).toContain("cli-bridge-pending.json");
+    expect(PROVIDER_SESSIONS_FILE).toContain("sessions.json");
+    expect(MEDIA_TMP_DIR).toContain("cli-bridge-media");
+  });
+
+  it("exports browser profile directories", () => {
+    expect(PROFILE_DIRS.grok).toContain("grok-profile");
+    expect(PROFILE_DIRS.gemini).toContain("gemini-profile");
+    expect(PROFILE_DIRS.claude).toContain("claude-profile");
+    expect(PROFILE_DIRS.chatgpt).toContain("chatgpt-profile");
+  });
+
+  it("exports BitNet defaults", () => {
+    expect(DEFAULT_BITNET_SERVER_URL).toBe("http://127.0.0.1:8082");
+    expect(BITNET_MAX_MESSAGES).toBe(6);
+    expect(BITNET_SYSTEM_PROMPT).toContain("Akido");
+  });
+
+  it("exports CLI test default model", () => {
+    expect(CLI_TEST_DEFAULT_MODEL).toBe("cli-claude/claude-sonnet-4-6");
+  });
+});

package/test/provider-sessions.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Unit tests for ProviderSessionRegistry.
+ *
+ * Mocks the filesystem to prevent real file I/O.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock config module — provide constants used by provider-sessions.ts
+vi.mock("../src/config.js", async () => {
+  return {
+    PROVIDER_SESSIONS_FILE: "/tmp/test-sessions.json",
+    PROVIDER_SESSION_TTL_MS: 2 * 60 * 60 * 1000, // 2 hours
+    PROVIDER_SESSION_SWEEP_MS: 10 * 60 * 1000,
+  };
+});
+
+// Mock fs to prevent real file operations
+const { mockReadFileSync, mockWriteFileSync, mockMkdirSync } = vi.hoisted(() => ({
+  mockReadFileSync: vi.fn(() => { throw new Error("ENOENT"); }),
+  mockWriteFileSync: vi.fn(),
+  mockMkdirSync: vi.fn(),
+}));
+
+vi.mock("node:fs", async (importOriginal) => {
+  const orig = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...orig,
+    readFileSync: mockReadFileSync,
+    writeFileSync: mockWriteFileSync,
+    mkdirSync: mockMkdirSync,
+  };
+});
+
+import { ProviderSessionRegistry } from "../src/provider-sessions.js";
+
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("ProviderSessionRegistry", () => {
+  let registry: ProviderSessionRegistry;
+
+  beforeEach(() => {
+    mockReadFileSync.mockImplementation(() => { throw new Error("ENOENT"); });
+    mockWriteFileSync.mockClear();
+    mockMkdirSync.mockClear();
+    registry = new ProviderSessionRegistry();
+  });
+
+  afterEach(() => {
+    registry.stop();
+  });
+
+  // ── createSession ──────────────────────────────────────────────────────
+
+  describe("createSession()", () => {
+    it("creates a session with correct fields", () => {
+      const session = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(session.id).toMatch(/^claude:session-[a-f0-9]+$/);
+      expect(session.provider).toBe("claude");
+      expect(session.modelAlias).toBe("cli-claude/claude-sonnet-4-6");
+      expect(session.state).toBe("active");
+      expect(session.runCount).toBe(0);
+      expect(session.timeoutCount).toBe(0);
+      expect(session.createdAt).toBeGreaterThan(0);
+      expect(session.updatedAt).toBe(session.createdAt);
+    });
+
+    it("creates unique session IDs", () => {
+      const s1 = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      const s2 = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(s1.id).not.toBe(s2.id);
+    });
+
+    it("accepts optional metadata", () => {
+      const session = registry.createSession("claude", "cli-claude/claude-sonnet-4-6", {
+        meta: { profilePath: "/tmp/test" },
+      });
+      expect(session.meta.profilePath).toBe("/tmp/test");
+    });
+
+    it("flushes to disk after creation", () => {
+      registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(mockWriteFileSync).toHaveBeenCalled();
+    });
+  });
+
+  // ── getSession ─────────────────────────────────────────────────────────
+
+  describe("getSession()", () => {
+    it("returns the session by ID", () => {
+      const created = registry.createSession("gemini", "cli-gemini/gemini-2.5-pro");
+      const found = registry.getSession(created.id);
+      expect(found).toBe(created);
+    });
+
+    it("returns undefined for unknown ID", () => {
+      expect(registry.getSession("nonexistent")).toBeUndefined();
+    });
+  });
+
+  // ── findSession ────────────────────────────────────────────────────────
+
+  describe("findSession()", () => {
+    it("finds most recently updated matching session", () => {
+      const s1 = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      const s2 = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      // Force s2 to be newer so the comparison is deterministic
+      s2.updatedAt = s1.updatedAt + 1000;
+      const found = registry.findSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(found?.id).toBe(s2.id);
+    });
+
+    it("returns undefined when no match", () => {
+      registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(registry.findSession("gemini", "cli-gemini/gemini-2.5-pro")).toBeUndefined();
+    });
+
+    it("skips expired sessions", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      s.state = "expired";
+      expect(registry.findSession("claude", "cli-claude/claude-sonnet-4-6")).toBeUndefined();
+    });
+  });
+
+  // ── ensureSession ──────────────────────────────────────────────────────
+
+  describe("ensureSession()", () => {
+    it("reuses existing active session", () => {
+      const s1 = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      const s2 = registry.ensureSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(s2.id).toBe(s1.id);
+    });
+
+    it("creates new session when none exists", () => {
+      const s = registry.ensureSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(s.id).toMatch(/^claude:session-/);
+    });
+
+    it("touches the existing session", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      const originalUpdated = s.updatedAt;
+      // Small delay to ensure timestamp changes
+      s.updatedAt = originalUpdated - 1000;
+      registry.ensureSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(s.updatedAt).toBeGreaterThan(originalUpdated - 1000);
+    });
+  });
+
+  // ── touchSession ───────────────────────────────────────────────────────
+
+  describe("touchSession()", () => {
+    it("updates the timestamp", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      const before = s.updatedAt;
+      s.updatedAt = before - 5000;
+      registry.touchSession(s.id);
+      expect(s.updatedAt).toBeGreaterThanOrEqual(before);
+    });
+
+    it("returns false for unknown session", () => {
+      expect(registry.touchSession("nonexistent")).toBe(false);
+    });
+
+    it("reactivates idle sessions", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      s.state = "idle";
+      registry.touchSession(s.id);
+      expect(s.state).toBe("active");
+    });
+  });
+
+  // ── recordRun ──────────────────────────────────────────────────────────
+
+  describe("recordRun()", () => {
+    it("increments run count", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      registry.recordRun(s.id, false);
+      expect(s.runCount).toBe(1);
+      expect(s.timeoutCount).toBe(0);
+      expect(s.state).toBe("idle");
+    });
+
+    it("increments timeout count when timedOut is true", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      registry.recordRun(s.id, true);
+      expect(s.runCount).toBe(1);
+      expect(s.timeoutCount).toBe(1);
+    });
+
+    it("sets state to idle after run", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(s.state).toBe("active");
+      registry.recordRun(s.id, false);
+      expect(s.state).toBe("idle");
+    });
+  });
+
+  // ── deleteSession ──────────────────────────────────────────────────────
+
+  describe("deleteSession()", () => {
+    it("removes the session", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      expect(registry.deleteSession(s.id)).toBe(true);
+      expect(registry.getSession(s.id)).toBeUndefined();
+    });
+
+    it("returns false for unknown ID", () => {
+      expect(registry.deleteSession("nonexistent")).toBe(false);
+    });
+  });
+
+  // ── stats ──────────────────────────────────────────────────────────────
+
+  describe("stats()", () => {
+    it("returns correct counts", () => {
+      const s1 = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      const s2 = registry.createSession("gemini", "cli-gemini/gemini-2.5-pro");
+      registry.recordRun(s2.id, false); // s2 → idle
+      const stats = registry.stats();
+      expect(stats.total).toBe(2);
+      expect(stats.active).toBe(1);
+      expect(stats.idle).toBe(1);
+      expect(stats.expired).toBe(0);
+    });
+  });
+
+  // ── sweep ──────────────────────────────────────────────────────────────
+
+  describe("sweep()", () => {
+    it("removes stale sessions", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      // Make the session very old
+      s.updatedAt = Date.now() - 3 * 60 * 60 * 1000; // 3 hours ago
+      registry.sweep();
+      expect(registry.getSession(s.id)).toBeUndefined();
+    });
+
+    it("keeps recent sessions", () => {
+      const s = registry.createSession("claude", "cli-claude/claude-sonnet-4-6");
+      registry.sweep();
+      expect(registry.getSession(s.id)).toBeDefined();
+    });
+  });
+
+  // ── persistence ────────────────────────────────────────────────────────
+
+  describe("persistence", () => {
+    it("loads sessions from disk on construction", () => {
+      const stored = {
+        version: 1,
+        sessions: [{
+          id: "claude:session-abc123",
+          provider: "claude",
+          modelAlias: "cli-claude/claude-sonnet-4-6",
+          createdAt: Date.now() - 1000,
+          updatedAt: Date.now() - 500,
+          state: "idle" as const,
+          runCount: 3,
+          timeoutCount: 1,
+          meta: {},
+        }],
+      };
+      mockReadFileSync.mockReturnValue(JSON.stringify(stored));
+      const freshRegistry = new ProviderSessionRegistry();
+      const loaded = freshRegistry.getSession("claude:session-abc123");
+      expect(loaded).toBeDefined();
+      expect(loaded!.runCount).toBe(3);
+      freshRegistry.stop();
+    });
+
+    it("skips expired sessions on load", () => {
+      const stored = {
+        version: 1,
+        sessions: [{
+          id: "claude:session-old",
+          provider: "claude",
+          modelAlias: "cli-claude/claude-sonnet-4-6",
+          createdAt: Date.now() - 5 * 60 * 60 * 1000,
+          updatedAt: Date.now() - 5 * 60 * 60 * 1000, // 5 hours ago
+          state: "idle" as const,
+          runCount: 1,
+          timeoutCount: 0,
+          meta: {},
+        }],
+      };
+      mockReadFileSync.mockReturnValue(JSON.stringify(stored));
+      const freshRegistry = new ProviderSessionRegistry();
+      expect(freshRegistry.getSession("claude:session-old")).toBeUndefined();
+      freshRegistry.stop();
+    });
+  });
+});
+
+// Config module tests are in a separate file (config.test.ts) without mocks.

package/test/session-manager.test.ts

@@ -62,6 +62,20 @@ vi.mock("../src/workdir.js", () => ({
   sweepOrphanedWorkdirs: mockSweepOrphanedWorkdirs,
 }));
 
+// Mock config module — provide all constants needed by session-manager.ts and cli-runner.ts
+vi.mock("../src/config.js", async () => {
+  return {
+    SESSION_TTL_MS: 30 * 60 * 1000,
+    CLEANUP_INTERVAL_MS: 5 * 60 * 1000,
+    SESSION_KILL_GRACE_MS: 5_000,
+    DEFAULT_CLI_TIMEOUT_MS: 120_000,
+    TIMEOUT_GRACE_MS: 5_000,
+    MAX_MESSAGES: 20,
+    MAX_MSG_CHARS: 4_000,
+    MEDIA_TMP_DIR: "/tmp/cli-bridge-media",
+  };
+});
+
 // Now import SessionManager (uses the mocked spawn)
 import { SessionManager } from "../src/session-manager.js";