Merge pull request #302 from LeoLin990405/fix/hidden-window-send

fix(browser): restore prompt submission when the Chrome window is hidden (#298)

Author: steipete

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## 0.15.3 — Unreleased
 
+### Fixed
+
+- Browser: keep hidden macOS Chrome windows rendered off-screen so trusted prompt submissions land without retaining drafts or leaking them into later runs. Fixes #298 and #312. Thanks @LeoLin990405!
+
 ## 0.15.2 — 2026-07-06
 
 ### Changed

src/browser/chromeLifecycle.ts

@@ -2,16 +2,12 @@ import { rm } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import os from "node:os";
 import net from "node:net";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import CDP from "chrome-remote-interface";
 import { launch, Launcher, type LaunchedChrome } from "chrome-launcher";
 import type { BrowserLogger, ResolvedBrowserConfig, ChromeClient } from "./types.js";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
 
-const execFileAsync = promisify(execFile);
-
 export async function launchChrome(
   config: ResolvedBrowserConfig,
   userDataDir: string,
@@ -20,7 +16,11 @@ export async function launchChrome(
   const connectHost = resolveRemoteDebugHost();
   const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
   const debugPort = config.debugPort ?? parseDebugPortEnv();
-  const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress);
+  const chromeFlags = buildChromeFlags(
+    config.headless ?? false,
+    debugBindAddress,
+    config.hideWindow ?? false,
+  );
   const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
   // copy-profile reuses a copied signed-in profile whose cookies are
   // Keychain-encrypted, so it must launch with the real Keychain (not mocked):
@@ -56,6 +56,27 @@ export async function launchChrome(
   };
 }
 
+export async function positionChromeWindowOffscreen(
+  client: ChromeClient,
+  logger: BrowserLogger,
+): Promise<void> {
+  if (process.platform !== "darwin") {
+    logger("Window hiding is only supported on macOS");
+    return;
+  }
+  try {
+    const { windowId } = await client.Browser.getWindowForTarget();
+    await client.Browser.setWindowBounds({
+      windowId,
+      bounds: { left: -32_000, top: -32_000, windowState: "normal" },
+    });
+    logger("Chrome window positioned off-screen");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger(`Failed to position Chrome window off-screen: ${message}`);
+  }
+}
+
 export function registerTerminationHooks(
   chrome: LaunchedChrome,
   userDataDir: string,
@@ -144,32 +165,6 @@ export function registerTerminationHooks(
   };
 }
 
-export async function hideChromeWindow(
-  chrome: LaunchedChrome,
-  logger: BrowserLogger,
-): Promise<void> {
-  if (process.platform !== "darwin") {
-    logger("Window hiding is only supported on macOS");
-    return;
-  }
-  if (!chrome.pid) {
-    logger("Unable to hide window: missing Chrome PID");
-    return;
-  }
-  const script = `tell application "System Events"
-    try
-      set visible of (first process whose unix id is ${chrome.pid}) to false
-    end try
-  end tell`;
-  try {
-    await execFileAsync("osascript", ["-e", script]);
-    logger("Chrome window hidden (Cmd-H)");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger(`Failed to hide Chrome window: ${message}`);
-  }
-}
-
 export async function connectToChrome(
   port: number,
   logger: BrowserLogger,
@@ -630,7 +625,11 @@ function isBlankPageTarget(target: { type?: string; url?: string }): boolean {
   return url === "about:blank" || url === "chrome://newtab/" || url === "chrome://new-tab-page/";
 }
 
-function buildChromeFlags(headless: boolean, debugBindAddress?: string | null): string[] {
+function buildChromeFlags(
+  headless: boolean,
+  debugBindAddress?: string | null,
+  hideWindow = false,
+): string[] {
   const flags = [
     "--disable-background-networking",
     "--disable-background-timer-throttling",
@@ -662,11 +661,24 @@ function buildChromeFlags(headless: boolean, debugBindAddress?: string | null):
 
   if (headless) {
     flags.push("--headless=new");
+  } else if (hideWindow && process.platform === "darwin") {
+    // Cmd-H stops macOS Chrome from compositing the page, which can swallow
+    // trusted CDP clicks and retain the prompt as a draft. Keeping the window
+    // off-screen avoids desktop disruption while preserving normal rendering.
+    flags.push("--window-position=-32000,-32000");
   }
 
   return flags;
 }
 
+export function buildChromeFlagsForTest(
+  headless: boolean,
+  debugBindAddress?: string | null,
+  hideWindow = false,
+): string[] {
+  return buildChromeFlags(headless, debugBindAddress, hideWindow);
+}
+
 function resolveChromeLaunchOptions(
   chromeFlags: string[],
   usingCopiedProfile: boolean,

src/browser/controlPlan.ts

@@ -74,15 +74,15 @@ export function describeBrowserControlPlan(config: BrowserControlConfig = {}): B
   }
 
   if (config.hideWindow) {
-    guidance.push("Chrome may briefly focus while launching before Oracle hides it.");
+    guidance.push("On macOS, Oracle launches Chrome off-screen while keeping the page rendered.");
     guidance.push(
       "For the calmest shared-desktop flow, prefer --browser-attach-running or --remote-chrome.",
     );
     return {
       mode: "hidden-window",
       launchesChrome: true,
       mayFocusWindow: true,
-      summary: "launch Chrome and hide the window after startup",
+      summary: "launch Chrome in hidden-window mode",
       guidance,
     };
   }

src/browser/index.ts

@@ -16,7 +16,7 @@ import type {
 import {
   launchChrome,
   registerTerminationHooks,
-  hideChromeWindow,
+  positionChromeWindowOffscreen,
   connectToRemoteChrome,
   connectWithNewTab,
   closeTab,
@@ -448,6 +448,29 @@ async function createAssistantTimeoutError(params: {
   return warningError;
 }
 
+/**
+ * Make the page behave like a focused foreground tab.
+ *
+ * The send button is activated with trusted CDP input events dispatched at
+ * viewport coordinates. Chrome delivers those only to a window that is being
+ * composited, so a hidden (`--browser-hide-window`), minimized, or occluded
+ * window swallows the click while the automation still believes it clicked.
+ * Soft-fails: focus emulation is an optimization, never a hard requirement.
+ */
+async function enableFocusEmulation(
+  client: ChromeClient,
+  logger: BrowserLogger,
+  label: string,
+): Promise<void> {
+  try {
+    await client.Emulation.setFocusEmulationEnabled({ enabled: true });
+    logger(`[browser] Focus emulation enabled for ${label}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger(`[browser] Focus emulation unavailable: ${message}`);
+  }
+}
+
 function listIgnoredRemoteChromeFlags(config: {
   attachRunning?: ResolvedBrowserConfig["attachRunning"];
   headless?: ResolvedBrowserConfig["headless"];
@@ -1144,15 +1167,18 @@ export async function runBrowserMode(options: BrowserRunOptions): Promise<Browse
       Promise.race([promise, disconnectPromise]);
     const { Network, Page, Runtime, Input, DOM, Target } = client;
 
-    if (!config.headless && config.hideWindow) {
-      await hideChromeWindow(chrome, logger);
-    }
-
     const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
     if (DOM && typeof DOM.enable === "function") {
       domainEnablers.push(DOM.enable());
     }
     await Promise.all(domainEnablers);
+    if (!config.headless && config.hideWindow) {
+      await positionChromeWindowOffscreen(client, logger);
+    }
+    // The send button is clicked with trusted CDP input events at viewport
+    // coordinates, which ChatGPT silently drops when the window is hidden or
+    // occluded. Emulate focus so the page behaves like a foreground tab.
+    await enableFocusEmulation(client, logger, "local target");
     removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
     if (!profileIsPreSigned) {
       await Network.clearBrowserCookies();
@@ -2836,13 +2862,7 @@ async function runRemoteBrowserMode(
     }
     await Promise.all(domainEnablers);
     removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
-    try {
-      await client.Emulation.setFocusEmulationEnabled({ enabled: true });
-      logger("[browser] Focus emulation enabled for remote target");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger(`[browser] Focus emulation unavailable: ${message}`);
-    }
+    await enableFocusEmulation(client, logger, "remote target");
 
     const activeConversationUrlMonitor = createConversationUrlMonitor({
       readUrl: async () => {

src/browser/projectSourcesRunner.ts

@@ -5,8 +5,8 @@ import type { LaunchedChrome } from "chrome-launcher";
 import {
   closeTab,
   connectWithNewTab,
-  hideChromeWindow,
   launchChrome,
+  positionChromeWindowOffscreen,
   registerTerminationHooks,
 } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
@@ -181,14 +181,14 @@ export async function runBrowserProjectSources(
       Promise.race([promise, disconnectPromise]);
 
     const { Network, Page, Runtime, Input, DOM, Target } = client;
-    if (!config.headless && config.hideWindow) {
-      await hideChromeWindow(chrome, logger);
-    }
     const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
     if (DOM && typeof DOM.enable === "function") {
       domainEnablers.push(DOM.enable());
     }
     await Promise.all(domainEnablers);
+    if (!config.headless && config.hideWindow) {
+      await positionChromeWindowOffscreen(client, logger);
+    }
     removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
     if (!manualLogin) {
       await Network.clearBrowserCookies();

src/browser/reattach.ts

@@ -15,7 +15,7 @@ import type { BrowserLogger, ChromeClient } from "./types.js";
 import {
   launchChrome,
   connectToChrome,
-  hideChromeWindow,
+  positionChromeWindowOffscreen,
   connectToRemoteChromeTarget,
   listRemoteChromeTargets,
 } from "./chromeLifecycle.js";
@@ -290,9 +290,8 @@ async function resumeBrowserSessionViaNewChrome(
     await DOM.enable();
   }
   if (!resolved.headless && resolved.hideWindow) {
-    await hideChromeWindow(chrome, logger);
+    await positionChromeWindowOffscreen(client, logger);
   }
-
   let appliedCookies = 0;
   if (!manualLogin && resolved.cookieSync) {
     appliedCookies = await syncCookies(Network, resolved.url, resolved.chromeProfile, logger, {

tests/browser/chromeLifecycle.test.ts

@@ -123,6 +123,47 @@ describe("copied-profile launch flags", () => {
   });
 });
 
+describe("hidden-window launch flags", () => {
+  test("keeps macOS Chrome rendered in an off-screen window", async () => {
+    const { buildChromeFlagsForTest } = await import("../../src/browser/chromeLifecycle.js");
+    const flags = buildChromeFlagsForTest(false, undefined, true);
+
+    if (process.platform === "darwin") {
+      expect(flags).toContain("--window-position=-32000,-32000");
+    } else {
+      expect(flags).not.toContain("--window-position=-32000,-32000");
+    }
+  });
+
+  test("does not add a window position to headless Chrome", async () => {
+    const { buildChromeFlagsForTest } = await import("../../src/browser/chromeLifecycle.js");
+
+    expect(buildChromeFlagsForTest(true, undefined, true)).not.toContain(
+      "--window-position=-32000,-32000",
+    );
+  });
+
+  test("moves a running macOS Chrome window without minimizing it", async () => {
+    const { positionChromeWindowOffscreen } = await import("../../src/browser/chromeLifecycle.js");
+    const browser = {
+      getWindowForTarget: vi.fn().mockResolvedValue({ windowId: 7 }),
+      setWindowBounds: vi.fn().mockResolvedValue(undefined),
+    };
+    const logger = vi.fn();
+
+    await positionChromeWindowOffscreen({ Browser: browser } as never, logger as never);
+
+    if (process.platform === "darwin") {
+      expect(browser.setWindowBounds).toHaveBeenCalledWith({
+        windowId: 7,
+        bounds: { left: -32_000, top: -32_000, windowState: "normal" },
+      });
+    } else {
+      expect(browser.setWindowBounds).not.toHaveBeenCalled();
+    }
+  });
+});
+
 describe("connectWithNewTab", () => {
   beforeEach(() => {
     cdpMock.mockReset();

tests/browser/controlPlan.test.ts

@@ -33,7 +33,9 @@ describe("browser control plan", () => {
   });
 
   test("describes hidden and remote modes distinctly", () => {
-    expect(describeBrowserControlPlan({ hideWindow: true }).mode).toBe("hidden-window");
+    const hidden = describeBrowserControlPlan({ hideWindow: true });
+    expect(hidden.mode).toBe("hidden-window");
+    expect(hidden.guidance.join(" ")).toContain("off-screen");
     expect(
       describeBrowserControlPlan({ remoteChrome: { host: "127.0.0.1", port: 9222 } }).mode,
     ).toBe("remote-chrome");

tests/browser/promptComposer.test.ts

@@ -25,7 +25,7 @@ describe("promptComposer", () => {
     );
   });
 
-  test("does not treat cleared composer + stop button as committed without a new turn", async () => {
+  test("does not treat historical assistant content as committed without a new turn", async () => {
     vi.useFakeTimers();
     try {
       const runtime = {
@@ -44,7 +44,7 @@ describe("promptComposer", () => {
                 lastMatched: false,
                 hasNewTurn: false,
                 stopVisible: true,
-                assistantVisible: false,
+                assistantVisible: true,
                 composerCleared: true,
                 inConversation: false,
               },
@@ -294,4 +294,34 @@ describe("promptComposer", () => {
 
     expect(onPromptSubmitted).toHaveBeenCalledTimes(1);
   });
+
+  test("waits for a delayed trusted click without issuing a second send", async () => {
+    vi.useFakeTimers();
+    try {
+      const evaluate = vi.fn().mockResolvedValue({
+        result: { value: { status: "point", x: 10, y: 20 } },
+      });
+      const input = {
+        dispatchMouseEvent: vi.fn(async ({ type }: { type: string }) => {
+          if (type === "mouseReleased") {
+            await new Promise((resolve) => setTimeout(resolve, 1_000));
+          }
+        }),
+      };
+
+      const result = promptComposer.attemptSendButton(
+        { evaluate } as never,
+        input as never,
+        undefined,
+        undefined,
+      );
+      await vi.advanceTimersByTimeAsync(1_000);
+
+      await expect(result).resolves.toBe(true);
+      expect(evaluate).toHaveBeenCalledTimes(1);
+      expect(input.dispatchMouseEvent).toHaveBeenCalledTimes(3);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });