feat(bsk): fix upload function that cannot bypass layout

apps/extension/src/tools/__tests__/dispatcher.test.ts

@@ -232,6 +232,94 @@ describe("ToolDispatcher", () => {
     });
   });
 
+  it("bypasses and restores the control overlay for an upload trigger click", async () => {
+    const sendMessage = vi.fn(async () => undefined);
+    vi.stubGlobal("chrome", {
+      tabs: {
+        get: vi.fn(async () => ({ id: 7, windowId: 4242, active: true })),
+        query: vi.fn(async () => [{ id: 7, windowId: 4242, active: true }]),
+        sendMessage,
+      },
+    });
+    const { transport, sent, deliver } = fakeTransport();
+    const sessions = new SessionManager({
+      agentWindow: {
+        create: vi.fn(async () => 4242),
+        remove: vi.fn(async () => {}),
+        ensureActiveTab: vi.fn(async () => {}),
+      },
+    });
+    const ctx = await sessions.start("aa11");
+    ctx.refStore.set("e1", 123, { tabId: 7 });
+    const send = vi.fn(async <T>(_tabId: number, method: string, params?: object) => {
+      if (method === "Page.getLayoutMetrics") {
+        return { cssLayoutViewport: { clientWidth: 1280, clientHeight: 720 } } as T;
+      }
+      if (method === "DOM.getContentQuads") {
+        return { quads: [[0, 0, 20, 0, 20, 20, 0, 20]] } as T;
+      }
+      if (method === "DOM.describeNode") return { node: { backendNodeId: 456 } } as T;
+      if (method === "Runtime.evaluate") {
+        const expression = (params as { expression?: string }).expression ?? "";
+        if (expression.includes("overlayDetails")) {
+          return { result: { value: { hitIndex: 0 } } } as T;
+        }
+        if (expression.includes("overlayHostPresent")) {
+          return {
+            result: {
+              value: { overlayHostPresent: true, overlayHostConnected: true },
+            },
+          } as T;
+        }
+        if (expression.includes("count:")) {
+          return { result: { value: { count: 1, multiple: false } } } as T;
+        }
+        if (expression.includes("?.inputs[0]")) {
+          return { result: { objectId: "input-object" } } as T;
+        }
+        return { result: { value: true } } as T;
+      }
+      return {} as T;
+    });
+    const cdp = {
+      send,
+      detachSession: vi.fn(async () => {}),
+      ensureNetworkCapture: vi.fn(async () => {}),
+      networkEntriesSince: vi.fn(() => ({
+        tab_id: 7,
+        entries: [],
+        next_since: 0,
+        truncated: false,
+      })),
+      setDeviceMetricsOverride: vi.fn(async () => {}),
+      clearDeviceMetricsOverride: vi.fn(async () => {}),
+      setUserAgentOverride: vi.fn(async () => {}),
+      setTouchEmulationEnabled: vi.fn(async () => {}),
+    };
+    const dispatcher = new ToolDispatcher({ transport, sessions, cdp: cdp as TestDispatcherCdp });
+    dispatcher.start();
+
+    deliver(
+      makeRequest("tool.upload", {
+        session_id: "aa11",
+        ref: "@e1",
+        files: [{ transfer_id: "tr_1", name: "test.png", staged_path: "/stage/test.png" }],
+      }),
+    );
+    await flushMicrotasks();
+    await vi.waitFor(() => expect(sent).toHaveLength(1));
+
+    expect(sent[0]).toMatchObject({ result: { tab_id: 7, file_names: ["test.png"] } });
+    expect(sendMessage).toHaveBeenNthCalledWith(1, 7, {
+      type: "bh-automation-bypass",
+      enabled: true,
+    });
+    expect(sendMessage).toHaveBeenNthCalledWith(2, 7, {
+      type: "bh-automation-bypass",
+      enabled: false,
+    });
+  });
+
   it("detaches CDP state before stopping a session", async () => {
     const { transport, sent, deliver } = fakeTransport();
     const sessions = new SessionManager({

apps/extension/src/tools/__tests__/file-transfer.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
 import { SessionManager } from "@/session-manager/manager";
 import { type DownloadsApi, handleDownload } from "../download";
-import { uploadThroughFileChooser } from "../file-chooser";
+import { captureBrowserDownload } from "../download-capture";
+import { uploadThroughActivatedFileInput } from "../file-input-transaction";
 import type { CdpRunner } from "../shared";
 import { handleUpload } from "../upload";
 
@@ -24,49 +25,57 @@ function tabsApi() {
   };
 }
 
-function fakeEvent<T extends (...args: never[]) => void>() {
+function fakeEvent<T extends (...args: never[]) => unknown>() {
   const listeners = new Set<T>();
   return {
     addListener: (listener: T) => listeners.add(listener),
     removeListener: (listener: T) => listeners.delete(listener),
-    hasListener: (listener: T) => listeners.has(listener),
-    hasListeners: () => listeners.size > 0,
     emit: (...args: Parameters<T>) => {
       for (const listener of listeners) listener(...args);
     },
   };
 }
 
+function uploadCdp(options: { inputCount?: number; multiple?: boolean; pickerCall?: string } = {}) {
+  const calls: Array<{ method: string; params?: object }> = [];
+  const send = vi.fn(async (_tabId: number, method: string, params?: object) => {
+    calls.push({ method, params });
+    if (method === "Page.getLayoutMetrics")
+      return { cssLayoutViewport: { clientWidth: 1280, clientHeight: 720 } };
+    if (method === "DOM.getContentQuads") return { quads: [[0, 0, 20, 0, 20, 20, 0, 20]] };
+    if (method === "Runtime.evaluate") {
+      const expression = (params as { expression?: string }).expression ?? "";
+      if (expression.includes("count:")) {
+        return {
+          result: {
+            value: {
+              count: options.inputCount ?? 1,
+              multiple: options.multiple ?? true,
+              pickerCall: options.pickerCall,
+            },
+          },
+        };
+      }
+      if (expression.includes("?.inputs[0]")) {
+        return { result: { objectId: "input-object" } };
+      }
+      return { result: { value: true } };
+    }
+    if (method === "DOM.describeNode") return { node: { backendNodeId: 456 } };
+    return {};
+  });
+  return {
+    calls,
+    cdp: { send: send as unknown as CdpRunner["send"] } satisfies CdpRunner,
+  };
+}
+
 describe("file transfer tools", () => {
-  it("enables chooser observation before clicking and injects only staged paths", async () => {
+  it("captures the file input activated by the requested click and injects only staged paths", async () => {
     const manager = sessions();
     const ctx = await manager.start("s1");
     ctx.refStore.set("e3", 123, { tabId: 4 });
-    let eventHandler: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
-    const calls: Array<{ method: string; params?: object }> = [];
-    const send = vi.fn(async (_tabId: number, method: string, params?: object) => {
-      calls.push({ method, params });
-      if (method === "Page.getLayoutMetrics")
-        return { cssLayoutViewport: { clientWidth: 1280, clientHeight: 720 } };
-      if (method === "DOM.getContentQuads") return { quads: [[0, 0, 20, 0, 20, 20, 0, 20]] };
-      if (
-        method === "Input.dispatchMouseEvent" &&
-        (params as { type?: string }).type === "mousePressed"
-      ) {
-        eventHandler?.({ tabId: 4 }, "Page.fileChooserOpened", {
-          backendNodeId: 456,
-          mode: "selectMultiple",
-        });
-      }
-      return {};
-    });
-    const cdp: CdpRunner = {
-      onEvent: (handler) => {
-        eventHandler = handler;
-        return { dispose: vi.fn() };
-      },
-      send: send as unknown as CdpRunner["send"],
-    };
+    const { cdp, calls } = uploadCdp();
 
     const result = await handleUpload(
       manager,
@@ -82,61 +91,60 @@ describe("file transfer tools", () => {
     );
 
     expect(result).toMatchObject({ tab_id: 4, file_names: ["one.png", "two.png"] });
-    expect(calls[0]).toMatchObject({
-      method: "Page.enable",
-      params: { enableFileChooserOpenedEvent: true },
-    });
+    const armCall = calls.find(
+      (call) =>
+        call.method === "Runtime.evaluate" &&
+        (call.params as { expression?: string }).expression?.includes("showOpenFilePicker"),
+    );
+    expect(armCall).toBeDefined();
+    expect((armCall?.params as { expression?: string }).expression).toContain(
+      "event.preventDefault()",
+    );
     expect(calls).toContainEqual({
       method: "DOM.setFileInputFiles",
       params: { files: ["/private/stage/one", "/private/stage/two"], backendNodeId: 456 },
     });
-    expect(calls.at(-1)).toEqual({
-      method: "Page.enable",
-      params: { enableFileChooserOpenedEvent: false },
-    });
   });
 
-  it("reports File System Access pickers as an explicit manual fallback", async () => {
-    let eventHandler: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
-    const cdp: CdpRunner = {
-      onEvent: (handler) => {
-        eventHandler = handler;
-        return { dispose: vi.fn() };
-      },
-      send: vi.fn(async () => ({})) as unknown as CdpRunner["send"],
-    };
-
-    const result = await uploadThroughFileChooser({
+  it("fails immediately when the trigger does not activate a file input", async () => {
+    const { cdp } = uploadCdp({ inputCount: 0 });
+    const result = await uploadThroughActivatedFileInput({
       cdp,
       target: { tabId: 4 },
       files: ["/private/stage/one"],
       timeoutMs: 100,
-      trigger: async () => {
-        eventHandler?.({ tabId: 4 }, "Page.fileChooserOpened", { mode: "selectSingle" });
-        return { tab_id: 4, x: 10, y: 10 };
-      },
+      trigger: async () => ({ tab_id: 4, x: 10, y: 10 }),
     });
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       code: "unsupported",
-      message: "this file chooser is not backed by an input element",
-      data: {
-        reason: "unsupported_file_chooser",
-        chooser_kind: "non_input",
-        manual_fallback_available: true,
-      },
+      data: { reason: "file_input_not_activated", phase: "resolve_input" },
     });
   });
 
-  it("bounds a stuck chooser-control command and resets uncertain CDP state", async () => {
-    const detach = vi.fn(async () => {});
+  it("reports a File System Access picker without waiting for a timeout", async () => {
+    const { cdp } = uploadCdp({ inputCount: 0, pickerCall: "showOpenFilePicker" });
+    const result = await uploadThroughActivatedFileInput({
+      cdp,
+      target: { tabId: 4 },
+      files: ["/private/stage/one"],
+      timeoutMs: 100,
+      trigger: async () => ({ tab_id: 4, x: 10, y: 10 }),
+    });
+
+    expect(result).toMatchObject({
+      code: "unsupported",
+      message: "upload trigger invoked showOpenFilePicker instead of an input[type=file]",
+      data: { reason: "file_input_not_activated", phase: "resolve_input" },
+    });
+  });
+
+  it("bounds a stuck file-input probe", async () => {
     const cdp: CdpRunner = {
-      onEvent: () => ({ dispose: vi.fn() }),
       send: vi.fn(() => new Promise<never>(() => {})) as unknown as CdpRunner["send"],
-      detach,
     };
 
-    const result = await uploadThroughFileChooser({
+    const result = await uploadThroughActivatedFileInput({
       cdp,
       target: { tabId: 4 },
       files: ["/private/stage/one"],
@@ -146,95 +154,49 @@ describe("file transfer tools", () => {
 
     expect(result).toMatchObject({
       code: "timeout",
-      data: { reason: "file_chooser_control_failed", phase: "enable_events" },
-    });
-    expect(detach).toHaveBeenCalledWith(4);
-  });
-
-  it("distinguishes a completed click that did not open a chooser", async () => {
-    const send = vi.fn(async () => ({})) as unknown as CdpRunner["send"];
-    const cdp: CdpRunner = {
-      onEvent: () => ({ dispose: vi.fn() }),
-      send,
-    };
-
-    const result = await uploadThroughFileChooser({
-      cdp,
-      target: { tabId: 4 },
-      files: ["/private/stage/one"],
-      timeoutMs: 5,
-      trigger: async () => ({ tab_id: 4, x: 10, y: 10 }),
-    });
-
-    expect(result).toMatchObject({
-      code: "timeout",
-      data: { reason: "file_chooser_not_opened", phase: "await_event" },
-    });
-    expect(send).toHaveBeenLastCalledWith(4, "Page.enable", {
-      enableFileChooserOpenedEvent: false,
+      data: { reason: "file_input_probe_failed", phase: "arm_input_probe" },
     });
   });
 
-  it("accepts chooser events only from the exact CDP target", async () => {
-    let eventHandler: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
-    const setFiles = vi.fn();
-    const cdp: CdpRunner = {
-      onEvent: (handler) => {
-        eventHandler = handler;
-        return { dispose: vi.fn() };
-      },
-      send: vi.fn(async () => ({})) as unknown as CdpRunner["send"],
-      sendToTarget: vi.fn(async (_target, method, params) => {
-        if (method === "DOM.setFileInputFiles") setFiles(params);
-        return {};
-      }) as unknown as NonNullable<CdpRunner["sendToTarget"]>,
-    };
-
-    const result = await uploadThroughFileChooser({
-      cdp,
-      target: { tabId: 4, sessionId: "child-a" },
-      files: ["/private/stage/one"],
-      timeoutMs: 100,
-      trigger: async () => {
-        eventHandler?.({ tabId: 4, sessionId: "child-b" }, "Page.fileChooserOpened", {
-          backendNodeId: 111,
-        });
-        eventHandler?.({ tabId: 4, sessionId: "child-a" }, "Page.fileChooserOpened", {
-          backendNodeId: 222,
-        });
-        return { tab_id: 4, x: 10, y: 10 };
-      },
-    });
-
-    expect(result).toMatchObject({ click: { tab_id: 4 } });
-    expect(setFiles).toHaveBeenCalledOnce();
-    expect(setFiles).toHaveBeenCalledWith({
-      files: ["/private/stage/one"],
-      backendNodeId: 222,
-    });
-  });
-
-  it("captures the one download created under daemon staging", async () => {
+  it("routes one exact-target download through a browser-relative capability", async () => {
     const manager = sessions();
     const ctx = await manager.start("s1");
     ctx.refStore.set("e3", 123, { tabId: 4 });
     const onCreated = fakeEvent<(item: chrome.downloads.DownloadItem) => void>();
     const onChanged = fakeEvent<(delta: chrome.downloads.DownloadDelta) => void>();
-    const item = {
+    const onDeterminingFilename =
+      fakeEvent<
+        (
+          item: chrome.downloads.DownloadItem,
+          suggest: (suggestion?: chrome.downloads.DownloadFilenameSuggestion) => void,
+        ) => void | true
+      >();
+    const initial = {
       id: 9,
-      filename: "/private/stage/tr_1/result.zip",
-      state: "complete",
-      fileSize: 12,
+      url: "https://example.test/result.zip",
+      finalUrl: "https://example.test/result.zip",
+      filename: "result.zip",
+      state: "in_progress",
+      fileSize: -1,
       totalBytes: 12,
       mime: "application/zip",
       danger: "safe",
     } as chrome.downloads.DownloadItem;
+    const completed = {
+      ...initial,
+      filename: "/profile/Downloads/BrowserSkill/tr_1/result.zip",
+      state: "complete",
+      fileSize: 12,
+    } as chrome.downloads.DownloadItem;
     const downloads: DownloadsApi = {
-      onCreated: onCreated as unknown as DownloadsApi["onCreated"],
-      onChanged: onChanged as unknown as DownloadsApi["onChanged"],
-      search: vi.fn(async () => [item]),
+      onCreated,
+      onChanged,
+      onDeterminingFilename,
+      search: vi.fn(async () => [completed]),
       cancel: vi.fn(async () => {}),
     };
+    let cdpEvent: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
+    let suggested: chrome.downloads.DownloadFilenameSuggestion | undefined;
     const send = vi.fn(async (_tabId: number, method: string, params?: object) => {
       if (method === "Page.getLayoutMetrics")
         return { cssLayoutViewport: { clientWidth: 1280, clientHeight: 720 } };
@@ -243,25 +205,103 @@ describe("file transfer tools", () => {
         method === "Input.dispatchMouseEvent" &&
         (params as { type?: string }).type === "mousePressed"
       ) {
-        onCreated.emit(item);
+        cdpEvent?.({ tabId: 4 }, "Page.downloadWillBegin", {
+          url: initial.url,
+          suggestedFilename: "result.zip",
+        });
+        await new Promise<void>((resolve) => {
+          onDeterminingFilename.emit(initial, (value) => {
+            suggested = value;
+            resolve();
+          });
+        });
+        onCreated.emit(completed);
       }
       return {};
     });
     const cdp: CdpRunner = {
       send: send as unknown as CdpRunner["send"],
+      onEvent: (handler) => {
+        cdpEvent = handler;
+        return { dispose: vi.fn() };
+      },
     };
 
     const result = await handleDownload(
       manager,
-      { session_id: "s1", ref: "@e3", staging_path: "/private/stage/tr_1" },
+      { session_id: "s1", ref: "@e3", browser_relative_dir: "BrowserSkill/tr_1" },
       { cdp, tabsApi: tabsApi(), downloads },
     );
 
+    expect(suggested).toEqual({
+      filename: "BrowserSkill/tr_1/result.zip",
+      conflictAction: "overwrite",
+    });
     expect(result).toMatchObject({
       tab_id: 4,
       suggested_filename: "result.zip",
       byte_size: 12,
-      staged_path: item.filename,
+      browser_path: completed.filename,
+    });
+  });
+
+  it("does not claim a download without an intent from the exact target", async () => {
+    const onCreated = fakeEvent<(item: chrome.downloads.DownloadItem) => void>();
+    const onChanged = fakeEvent<(delta: chrome.downloads.DownloadDelta) => void>();
+    const onDeterminingFilename =
+      fakeEvent<
+        (
+          item: chrome.downloads.DownloadItem,
+          suggest: (suggestion?: chrome.downloads.DownloadFilenameSuggestion) => void,
+        ) => void | true
+      >();
+    const downloads: DownloadsApi = {
+      onCreated,
+      onChanged,
+      onDeterminingFilename,
+      search: vi.fn(async () => []),
+      cancel: vi.fn(async () => {}),
+    };
+    let cdpEvent: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
+    const cdp: CdpRunner = {
+      send: vi.fn(async () => ({})) as unknown as CdpRunner["send"],
+      onEvent: (handler) => {
+        cdpEvent = handler;
+        return { dispose: vi.fn() };
+      },
+    };
+    const unrelated = {
+      id: 17,
+      url: "https://example.test/unrelated.zip",
+      finalUrl: "https://example.test/unrelated.zip",
+      filename: "unrelated.zip",
+      state: "in_progress",
+    } as chrome.downloads.DownloadItem;
+    let defaultSuggestionCalled = false;
+
+    const result = await captureBrowserDownload({
+      cdp,
+      target: { tabId: 4, sessionId: "expected-child" },
+      downloads,
+      browserRelativeDir: "BrowserSkill/tr_1",
+      timeoutMs: 5,
+      trigger: async () => {
+        cdpEvent?.({ tabId: 4, sessionId: "other-child" }, "Page.downloadWillBegin", {
+          url: unrelated.url,
+          suggestedFilename: unrelated.filename,
+        });
+        onDeterminingFilename.emit(unrelated, (suggestion) => {
+          defaultSuggestionCalled = suggestion === undefined;
+        });
+        return { tab_id: 4, x: 10, y: 10 };
+      },
+    });
+
+    expect(defaultSuggestionCalled).toBe(true);
+    expect(downloads.cancel).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      code: "cdp_failed",
+      data: { reason: "download_capture_failed" },
     });
   });
 });