fix(extension): per-workspace idle timeout for browser sessions (jackwener#1064)

* fix(extension): per-workspace idle timeout for browser sessions (jackwener#1058)

The global 30s WINDOW_IDLE_TIMEOUT was too aggressive for interactive
`opencli browser` commands where users type manually between invocations.

- browser:*/operate:* workspaces now default to 10 min idle timeout
- Adapter workspaces keep the existing 30s timeout
- Support custom timeout via OPENCLI_BROWSER_TIMEOUT env var (seconds)
  or command-level idleTimeout parameter
- Surface sessionExpired warning when a new window is created after
  the previous session timed out
- Fix stale comment (said 120s, actual was 30s)

Closes jackwener#1058

* fix: resolve sessionExpired double-delete race and timeout override lifecycle

Addresses @codex-coder review blockers:

1. sessionExpired flag was never set because getAutomationWindow()
   consumed expiredWorkspaces before handleCommand() could check it.
   Fix: use .has() in getAutomationWindow, only .delete() in handleCommand.

2. workspaceTimeoutOverrides was never cleaned up — once set, it
   persisted until extension restart. Fix: clear override on idle
   timeout expiry, explicit close-window, and borrowed-session detach.

Adds 5 tests covering:
- browser:* uses 10min timeout (not 30s)
- sessionExpired flag is set and consumed correctly
- workspaceTimeoutOverrides cleared on idle expiry
- workspaceTimeoutOverrides cleared on explicit close
- idleTimeout from command applies to workspace override

* refactor: remove sessionExpired warning per product decision

@WAWQAQ decided session-expired warning is not needed.
Remove expiredWorkspaces tracking, sessionExpired flag from protocol,
and related CLI-side warning code. Keep per-workspace timeout and
override lifecycle cleanup.

* fix: clean up workspaceTimeoutOverrides on user-initiated window close

The windows.onRemoved listener was missing workspaceTimeoutOverrides
cleanup, causing stale overrides to persist across sessions when users
manually close the automation window.

Author: jackwener

extension/dist/background.js

@@ -332,4 +332,108 @@ describe('background tab isolation', () => {
     expect(chrome.windows.remove).toHaveBeenCalledWith(1);
     expect(mod.__test__.getSession('site:notebooklm')).toBeNull();
   });
+
+  it('uses 10-minute timeout for browser:* workspaces', async () => {
+    const { chrome } = createChromeMock();
+    vi.useFakeTimers();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('browser:default', 1);
+
+    mod.__test__.resetWindowIdleTimer('browser:default');
+    // After 30s (adapter timeout), session should still be alive
+    await vi.advanceTimersByTimeAsync(30001);
+    expect(mod.__test__.getSession('browser:default')).not.toBeNull();
+
+    // After 10 min total, session should be cleaned up
+    await vi.advanceTimersByTimeAsync(600000 - 30001);
+    expect(chrome.windows.remove).toHaveBeenCalledWith(1);
+    expect(mod.__test__.getSession('browser:default')).toBeNull();
+  });
+
+  it('clears workspaceTimeoutOverrides on idle expiry', async () => {
+    const { chrome } = createChromeMock();
+    vi.useFakeTimers();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('browser:test', 1);
+
+    // Set a custom timeout override
+    mod.__test__.workspaceTimeoutOverrides.set('browser:test', 120_000);
+    expect(mod.__test__.getIdleTimeout('browser:test')).toBe(120_000);
+
+    // Trigger idle timer with the custom timeout
+    mod.__test__.resetWindowIdleTimer('browser:test');
+    await vi.advanceTimersByTimeAsync(120001);
+
+    // Override should be cleaned up
+    expect(mod.__test__.workspaceTimeoutOverrides.has('browser:test')).toBe(false);
+    expect(mod.__test__.getSession('browser:test')).toBeNull();
+    // Should fall back to default interactive timeout
+    expect(mod.__test__.getIdleTimeout('browser:test')).toBe(600_000);
+  });
+
+  it('clears workspaceTimeoutOverrides on explicit close', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('browser:close-test', 1);
+    mod.__test__.workspaceTimeoutOverrides.set('browser:close-test', 300_000);
+
+    const result = await mod.__test__.handleCommand({
+      id: 'close-1',
+      action: 'close-window',
+      workspace: 'browser:close-test',
+    });
+
+    expect(result.ok).toBe(true);
+    expect(mod.__test__.workspaceTimeoutOverrides.has('browser:close-test')).toBe(false);
+  });
+
+  it('applies idleTimeout from command to workspace override', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('browser:custom', 1);
+
+    // Default for browser:* is 10 min
+    expect(mod.__test__.getIdleTimeout('browser:custom')).toBe(600_000);
+
+    // Send a command with custom idleTimeout (in seconds)
+    await mod.__test__.handleCommand({
+      id: 'custom-1',
+      action: 'sessions',
+      workspace: 'browser:custom',
+      idleTimeout: 120,
+    });
+
+    // Override should now be 120s = 120000ms
+    expect(mod.__test__.getIdleTimeout('browser:custom')).toBe(120_000);
+  });
+
+  it('clears workspaceTimeoutOverrides when user manually closes automation window', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+
+    // Set up a session with window ID 42 and a custom timeout override
+    mod.__test__.setAutomationWindowId('browser:manual', 42);
+    mod.__test__.workspaceTimeoutOverrides.set('browser:manual', 180_000);
+    expect(mod.__test__.getIdleTimeout('browser:manual')).toBe(180_000);
+
+    // Simulate user closing the window — invoke the onRemoved listener
+    const onRemovedListener = chrome.windows.onRemoved.addListener.mock.calls[0][0];
+    await onRemovedListener(42);
+
+    // Session and override should both be cleaned up
+    expect(mod.__test__.getSession('browser:manual')).toBeNull();
+    expect(mod.__test__.workspaceTimeoutOverrides.has('browser:manual')).toBe(false);
+    // Should fall back to default interactive timeout
+    expect(mod.__test__.getIdleTimeout('browser:manual')).toBe(600_000);
+  });
 });

extension/src/background.test.ts

@@ -118,7 +118,9 @@ function scheduleReconnect(): void {
 // ─── Automation window isolation ─────────────────────────────────────
 // All opencli operations happen in a dedicated Chrome window so the
 // user's active browsing session is never touched.
-// The window auto-closes after 120s of idle (no commands).
+// The window auto-closes after a period of idle (no commands).
+// Interactive workspaces (browser:*, operate:*) get a longer timeout (10 min)
+// since users type commands manually; adapter workspaces keep a short 30s timeout.
 
 type AutomationSession = {
   windowId: number;
@@ -129,7 +131,21 @@ type AutomationSession = {
 };
 
 const automationSessions = new Map<string, AutomationSession>();
-const WINDOW_IDLE_TIMEOUT = 30000; // 30s — quick cleanup after command finishes
+const IDLE_TIMEOUT_DEFAULT = 30_000;      // 30s — adapter-driven automation
+const IDLE_TIMEOUT_INTERACTIVE = 600_000; // 10min — human-paced browser:* / operate:*
+
+/** Per-workspace custom timeout overrides set via command.idleTimeout */
+const workspaceTimeoutOverrides = new Map<string, number>();
+
+function getIdleTimeout(workspace: string): number {
+  const override = workspaceTimeoutOverrides.get(workspace);
+  if (override !== undefined) return override;
+  if (workspace.startsWith('browser:') || workspace.startsWith('operate:')) {
+    return IDLE_TIMEOUT_INTERACTIVE;
+  }
+  return IDLE_TIMEOUT_DEFAULT;
+}
+
 let windowFocused = false; // set per-command from daemon's OPENCLI_WINDOW_FOCUSED
 
 function getWorkspaceKey(workspace?: string): string {
@@ -140,23 +156,26 @@ function resetWindowIdleTimer(workspace: string): void {
   const session = automationSessions.get(workspace);
   if (!session) return;
   if (session.idleTimer) clearTimeout(session.idleTimer);
-  session.idleDeadlineAt = Date.now() + WINDOW_IDLE_TIMEOUT;
+  const timeout = getIdleTimeout(workspace);
+  session.idleDeadlineAt = Date.now() + timeout;
   session.idleTimer = setTimeout(async () => {
     const current = automationSessions.get(workspace);
     if (!current) return;
     if (!current.owned) {
       console.log(`[opencli] Borrowed workspace ${workspace} detached from window ${current.windowId} (idle timeout)`);
+      workspaceTimeoutOverrides.delete(workspace);
       automationSessions.delete(workspace);
       return;
     }
     try {
       await chrome.windows.remove(current.windowId);
-      console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout)`);
+      console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout, ${timeout / 1000}s)`);
     } catch {
       // Already gone
     }
+    workspaceTimeoutOverrides.delete(workspace);
     automationSessions.delete(workspace);
-  }, WINDOW_IDLE_TIMEOUT);
+  }, timeout);
 }
 
 /** Get or create the dedicated automation window.
@@ -191,7 +210,7 @@ async function getAutomationWindow(workspace: string, initialUrl?: string): Prom
   const session: AutomationSession = {
     windowId: win.id!,
     idleTimer: null,
-    idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+    idleDeadlineAt: Date.now() + getIdleTimeout(workspace),
     owned: true,
     preferredTabId: null,
   };
@@ -229,6 +248,7 @@ chrome.windows.onRemoved.addListener(async (windowId) => {
       console.log(`[opencli] Automation window closed (${workspace})`);
       if (session.idleTimer) clearTimeout(session.idleTimer);
       automationSessions.delete(workspace);
+      workspaceTimeoutOverrides.delete(workspace);
     }
   }
 });
@@ -280,6 +300,10 @@ chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
 async function handleCommand(cmd: Command): Promise<Result> {
   const workspace = getWorkspaceKey(cmd.workspace);
   windowFocused = cmd.windowFocused === true;
+  // Apply custom idle timeout if specified in the command
+  if (cmd.idleTimeout != null && cmd.idleTimeout > 0) {
+    workspaceTimeoutOverrides.set(workspace, cmd.idleTimeout * 1000);
+  }
   // Reset idle timer on every command (window stays alive while active)
   resetWindowIdleTimer(workspace);
   try {
@@ -387,7 +411,7 @@ function setWorkspaceSession(workspace: string, session: Omit<AutomationSession,
   automationSessions.set(workspace, {
     ...session,
     idleTimer: null,
-    idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+    idleDeadlineAt: Date.now() + getIdleTimeout(workspace),
   });
 }
 
@@ -781,6 +805,7 @@ async function handleCloseWindow(cmd: Command, workspace: string): Promise<Resul
       }
     }
     if (session.idleTimer) clearTimeout(session.idleTimer);
+    workspaceTimeoutOverrides.delete(workspace);
     automationSessions.delete(workspace);
   }
   return { id: cmd.id, ok: true, data: { closed: true } };
@@ -886,6 +911,9 @@ export const __test__ = {
   handleBindCurrent,
   resolveTabId,
   resetWindowIdleTimer,
+  handleCommand,
+  getIdleTimeout,
+  workspaceTimeoutOverrides,
   getSession: (workspace: string = 'default') => automationSessions.get(workspace) ?? null,
   getAutomationWindowId: (workspace: string = 'default') => automationSessions.get(workspace)?.windowId ?? null,
   setAutomationWindowId: (workspace: string, windowId: number | null) => {

extension/src/background.ts

@@ -65,6 +65,8 @@ export interface Command {
   cdpParams?: Record<string, unknown>;
   /** When true, automation windows are created in the foreground (focused) */
   windowFocused?: boolean;
+  /** Custom idle timeout in seconds for this workspace session. Overrides the default. */
+  idleTimeout?: number;
 }
 
 export interface Result {

extension/src/protocol.ts

@@ -30,7 +30,7 @@ export class BrowserBridge implements IBrowserFactory {
     return this._state;
   }
 
-  async connect(opts: { timeout?: number; workspace?: string } = {}): Promise<IPage> {
+  async connect(opts: { timeout?: number; workspace?: string; idleTimeout?: number } = {}): Promise<IPage> {
     if (this._state === 'connected' && this._page) return this._page;
     if (this._state === 'connecting') throw new Error('Already connecting');
     if (this._state === 'closing') throw new Error('Session is closing');
@@ -40,7 +40,7 @@ export class BrowserBridge implements IBrowserFactory {
 
     try {
       await this._ensureDaemon(opts.timeout);
-      this._page = new Page(opts.workspace);
+      this._page = new Page(opts.workspace, opts.idleTimeout);
       this._state = 'connected';
       return this._page;
     } catch (err) {

src/browser/bridge.ts

@@ -50,6 +50,8 @@ export interface DaemonCommand {
   cdpParams?: Record<string, unknown>;
   /** When true, automation windows are created in the foreground */
   windowFocused?: boolean;
+  /** Custom idle timeout in seconds for this workspace session. Overrides the default. */
+  idleTimeout?: number;
 }
 
 export interface DaemonResult {

src/browser/daemon-client.ts

@@ -30,8 +30,11 @@ function isUnsupportedNetworkCaptureError(err: unknown): boolean {
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export class Page extends BasePage {
-  constructor(private readonly workspace: string = 'default') {
+  private readonly _idleTimeout: number | undefined;
+
+  constructor(private readonly workspace: string = 'default', idleTimeout?: number) {
     super();
+    this._idleTimeout = idleTimeout;
   }
 
   /** Active page identity (targetId), set after navigate and used in all subsequent commands */
@@ -40,15 +43,16 @@ export class Page extends BasePage {
   private _networkCaptureWarned = false;
 
   /** Helper: spread workspace into command params */
-  private _wsOpt(): { workspace: string } {
-    return { workspace: this.workspace };
+  private _wsOpt(): { workspace: string; idleTimeout?: number } {
+    return { workspace: this.workspace, ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }) };
   }
 
   /** Helper: spread workspace + page identity into command params */
   private _cmdOpts(): Record<string, unknown> {
     return {
       workspace: this.workspace,
       ...(this._page !== undefined && { page: this._page }),
+      ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
     };
   }
 

src/browser/page.ts

@@ -31,7 +31,13 @@ const CLI_FILE = fileURLToPath(import.meta.url);
 async function getBrowserPage(): Promise<import('./types.js').IPage> {
   const { BrowserBridge } = await import('./browser/index.js');
   const bridge = new BrowserBridge();
-  return bridge.connect({ timeout: 30, workspace: 'browser:default' });
+  const envTimeout = process.env.OPENCLI_BROWSER_TIMEOUT;
+  const idleTimeout = envTimeout ? parseInt(envTimeout, 10) : undefined;
+  return bridge.connect({
+    timeout: 30,
+    workspace: 'browser:default',
+    ...(idleTimeout && idleTimeout > 0 && { idleTimeout }),
+  });
 }
 
 function parsePositiveIntOption(val: string | undefined, label: string, fallback: number): number {