mirror of
https://github.com/Tencent/BrowserSkill.git
synced 2026-09-10 13:01:23 +08:00
556 lines
18 KiB
TypeScript
556 lines
18 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
import { SessionManager } from "@/session-manager/manager";
|
|
import { type DownloadsApi, handleDownload } from "../download";
|
|
import { captureBrowserDownload } from "../download-capture";
|
|
import { uploadThroughActivatedFileInput } from "../file-input-transaction";
|
|
import type { ResolvedActionTarget } from "../interaction";
|
|
import type { CdpRunner } from "../shared";
|
|
import { handleUpload } from "../upload";
|
|
|
|
function sessions() {
|
|
return new SessionManager({
|
|
agentWindow: {
|
|
create: vi.fn(async () => 100),
|
|
remove: vi.fn(async () => {}),
|
|
ensureActiveTab: vi.fn(async () => {}),
|
|
},
|
|
});
|
|
}
|
|
|
|
function tabsApi() {
|
|
return {
|
|
get: vi.fn(
|
|
async (tabId: number) => ({ id: tabId, windowId: 100, active: true }) as chrome.tabs.Tab,
|
|
),
|
|
query: vi.fn(async () => [{ id: 4, windowId: 100, active: true } as chrome.tabs.Tab]),
|
|
};
|
|
}
|
|
|
|
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),
|
|
emit: (...args: Parameters<T>) => {
|
|
for (const listener of listeners) listener(...args);
|
|
},
|
|
};
|
|
}
|
|
|
|
function actionTarget(frameId?: string): ResolvedActionTarget {
|
|
return {
|
|
tab: { tabId: 4, windowId: 100, active: true },
|
|
backendNodeId: 123,
|
|
cdpTarget: { tabId: 4 },
|
|
...(frameId ? { frameId } : {}),
|
|
usedRef: "e3",
|
|
};
|
|
}
|
|
|
|
function uploadCdp(
|
|
options: {
|
|
inputCount?: number;
|
|
multiple?: boolean;
|
|
chooser?: { frameId?: string; backendNodeId?: number; mode?: string };
|
|
pendingResolve?: boolean;
|
|
} = {},
|
|
) {
|
|
const calls: Array<{ method: string; params?: object }> = [];
|
|
let cdpEvent: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
|
|
const send = vi.fn(async (_tabId: number, method: string, params?: object) => {
|
|
calls.push({ method, params });
|
|
if (method === "Page.setInterceptFileChooserDialog") return {};
|
|
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 === "DOM.resolveNode") {
|
|
if (options.pendingResolve) return new Promise<never>(() => {});
|
|
return { object: { objectId: "trigger-object" } };
|
|
}
|
|
if (method === "Runtime.callFunctionOn") {
|
|
const declaration = (params as { functionDeclaration?: string }).functionDeclaration ?? "";
|
|
if (declaration.includes("Object.defineProperty")) return { result: { value: true } };
|
|
if (declaration.includes("count: state.inputs.length")) {
|
|
return {
|
|
result: {
|
|
value: {
|
|
count: options.inputCount ?? 1,
|
|
multiple: options.multiple ?? true,
|
|
},
|
|
},
|
|
};
|
|
}
|
|
if (declaration.includes("inputs[0]")) {
|
|
return { result: { objectId: "input-object" } };
|
|
}
|
|
return { result: { value: true } };
|
|
}
|
|
if (method === "DOM.describeNode") return { node: { backendNodeId: 456 } };
|
|
if (
|
|
method === "Input.dispatchMouseEvent" &&
|
|
(params as { type?: string }).type === "mousePressed" &&
|
|
options.chooser
|
|
) {
|
|
cdpEvent?.({ tabId: 4 }, "Page.fileChooserOpened", options.chooser);
|
|
}
|
|
return {};
|
|
});
|
|
const cdp: CdpRunner = {
|
|
send: send as unknown as CdpRunner["send"],
|
|
onEvent: (handler) => {
|
|
cdpEvent = handler;
|
|
return { dispose: vi.fn() };
|
|
},
|
|
};
|
|
return {
|
|
calls,
|
|
emitChooser: (event: { frameId?: string; backendNodeId?: number; mode?: string }) =>
|
|
cdpEvent?.({ tabId: 4 }, "Page.fileChooserOpened", event),
|
|
cdp,
|
|
};
|
|
}
|
|
|
|
describe("file transfer tools", () => {
|
|
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 });
|
|
const { cdp, calls } = uploadCdp();
|
|
|
|
const result = await handleUpload(
|
|
manager,
|
|
{
|
|
session_id: "s1",
|
|
ref: "@e3",
|
|
files: [
|
|
{ transfer_id: "tr_1", name: "one.png", staged_path: "/private/stage/one" },
|
|
{ transfer_id: "tr_2", name: "two.png", staged_path: "/private/stage/two" },
|
|
],
|
|
},
|
|
{ cdp, tabsApi: tabsApi() },
|
|
);
|
|
|
|
expect(result).toMatchObject({ tab_id: 4, file_names: ["one.png", "two.png"] });
|
|
expect(calls[0]).toEqual({
|
|
method: "Page.setInterceptFileChooserDialog",
|
|
params: { enabled: true },
|
|
});
|
|
expect(calls).toContainEqual({
|
|
method: "Page.setInterceptFileChooserDialog",
|
|
params: { enabled: false, cancel: true },
|
|
});
|
|
expect(calls).toContainEqual({
|
|
method: "DOM.setFileInputFiles",
|
|
params: { files: ["/private/stage/one", "/private/stage/two"], backendNodeId: 456 },
|
|
});
|
|
});
|
|
|
|
it("fails immediately when the trigger does not activate a file input", async () => {
|
|
const { cdp } = uploadCdp({ inputCount: 0 });
|
|
const result = await uploadThroughActivatedFileInput({
|
|
cdp,
|
|
actionTarget: actionTarget(),
|
|
files: ["/private/stage/one"],
|
|
timeoutMs: 100,
|
|
trigger: async () => ({ tab_id: 4, x: 10, y: 10 }),
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "unsupported",
|
|
data: { reason: "file_input_not_activated", phase: "resolve_input" },
|
|
});
|
|
});
|
|
|
|
it("fails before clicking when chooser interception is unavailable", async () => {
|
|
const trigger = vi.fn(async () => ({ tab_id: 4, x: 10, y: 10 }));
|
|
const cdp: CdpRunner = {
|
|
send: vi.fn(async (_tabId: number, method: string) => {
|
|
if (method === "Page.setInterceptFileChooserDialog") {
|
|
throw new Error("method unavailable");
|
|
}
|
|
return {};
|
|
}) as CdpRunner["send"],
|
|
};
|
|
|
|
const result = await uploadThroughActivatedFileInput({
|
|
cdp,
|
|
actionTarget: actionTarget(),
|
|
files: ["/private/stage/one"],
|
|
timeoutMs: 100,
|
|
trigger,
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "cdp_failed",
|
|
data: { effect_state: "none", phase: "arm_interception" },
|
|
});
|
|
expect(trigger).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("uses an exact chooser event as an independent input-location signal", async () => {
|
|
const { cdp, calls, emitChooser } = uploadCdp({ inputCount: 0 });
|
|
const result = await uploadThroughActivatedFileInput({
|
|
cdp,
|
|
actionTarget: actionTarget("f1"),
|
|
files: ["/private/stage/one"],
|
|
timeoutMs: 100,
|
|
trigger: async () => {
|
|
emitChooser({ frameId: "f1", backendNodeId: 789, mode: "selectSingle" });
|
|
return { tab_id: 4, x: 10, y: 10 };
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({ multiple: false });
|
|
expect(calls).toContainEqual({
|
|
method: "DOM.setFileInputFiles",
|
|
params: { files: ["/private/stage/one"], backendNodeId: 789 },
|
|
});
|
|
});
|
|
|
|
it("reports a File System Access picker without waiting for a timeout", async () => {
|
|
const { cdp, emitChooser } = uploadCdp({
|
|
inputCount: 0,
|
|
});
|
|
const result = await uploadThroughActivatedFileInput({
|
|
cdp,
|
|
actionTarget: actionTarget("f1"),
|
|
files: ["/private/stage/one"],
|
|
timeoutMs: 100,
|
|
trigger: async () => {
|
|
emitChooser({ frameId: "f1", mode: "selectSingle" });
|
|
return { tab_id: 4, x: 10, y: 10 };
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "unsupported",
|
|
message: "upload trigger invoked a non-input file picker",
|
|
data: { reason: "file_input_not_activated", phase: "resolve_input" },
|
|
});
|
|
});
|
|
|
|
it("bounds a stuck file-input probe", async () => {
|
|
const { cdp } = uploadCdp({ pendingResolve: true });
|
|
|
|
const result = await uploadThroughActivatedFileInput({
|
|
cdp,
|
|
actionTarget: actionTarget(),
|
|
files: ["/private/stage/one"],
|
|
timeoutMs: 5,
|
|
trigger: vi.fn(),
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "timeout",
|
|
data: { reason: "file_input_probe_failed", phase: "arm_input_probe" },
|
|
});
|
|
});
|
|
|
|
it("marks a timed-out file assignment unknown and detaches browser state", async () => {
|
|
const fixture = uploadCdp();
|
|
const originalSend = fixture.cdp.send;
|
|
const detach = vi.fn(async () => {});
|
|
fixture.cdp.detach = detach;
|
|
fixture.cdp.send = vi.fn((tabId: number, method: string, params?: object) => {
|
|
if (method === "DOM.setFileInputFiles") return new Promise<never>(() => {});
|
|
return originalSend(tabId, method, params);
|
|
}) as CdpRunner["send"];
|
|
|
|
const result = await uploadThroughActivatedFileInput({
|
|
cdp: fixture.cdp,
|
|
actionTarget: actionTarget(),
|
|
files: ["/private/stage/one"],
|
|
timeoutMs: 10,
|
|
trigger: async () => ({ tab_id: 4, x: 10, y: 10 }),
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "timeout",
|
|
data: { effect_state: "unknown", phase: "set_files" },
|
|
});
|
|
expect(detach).toHaveBeenCalledWith(4);
|
|
});
|
|
|
|
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 onDeterminingFilename =
|
|
fakeEvent<
|
|
(
|
|
item: chrome.downloads.DownloadItem,
|
|
suggest: (suggestion?: chrome.downloads.DownloadFilenameSuggestion) => void,
|
|
) => void | true
|
|
>();
|
|
const initial = {
|
|
id: 9,
|
|
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,
|
|
onChanged,
|
|
onDeterminingFilename,
|
|
search: vi.fn(async () => [completed]),
|
|
cancel: vi.fn(async () => {}),
|
|
removeFile: 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 } };
|
|
if (method === "DOM.getContentQuads") return { quads: [[0, 0, 20, 0, 20, 20, 0, 20]] };
|
|
if (
|
|
method === "Input.dispatchMouseEvent" &&
|
|
(params as { type?: string }).type === "mousePressed"
|
|
) {
|
|
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", 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,
|
|
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 () => {}),
|
|
removeFile: 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" },
|
|
});
|
|
});
|
|
|
|
it("correlates a filename candidate that arrives before the CDP intent", 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 initial = {
|
|
id: 21,
|
|
url: "https://example.test/candidate-first.bin",
|
|
finalUrl: "https://example.test/candidate-first.bin",
|
|
filename: "candidate-first.bin",
|
|
state: "in_progress",
|
|
fileSize: -1,
|
|
totalBytes: 4,
|
|
bytesReceived: 0,
|
|
} as chrome.downloads.DownloadItem;
|
|
const complete = { ...initial, state: "complete", fileSize: 4 } as chrome.downloads.DownloadItem;
|
|
const downloads: DownloadsApi = {
|
|
onCreated,
|
|
onChanged,
|
|
onDeterminingFilename,
|
|
search: vi.fn(async () => [complete]),
|
|
cancel: vi.fn(async () => {}),
|
|
removeFile: vi.fn(async () => {}),
|
|
};
|
|
let cdpEvent: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
|
|
const cdp: CdpRunner = {
|
|
send: vi.fn(async () => ({})) as CdpRunner["send"],
|
|
onEvent: (handler) => {
|
|
cdpEvent = handler;
|
|
return { dispose: vi.fn() };
|
|
},
|
|
};
|
|
let suggestion: chrome.downloads.DownloadFilenameSuggestion | undefined;
|
|
|
|
const result = await captureBrowserDownload({
|
|
cdp,
|
|
target: { tabId: 4 },
|
|
downloads,
|
|
browserRelativeDir: "BrowserSkill/tr_21",
|
|
timeoutMs: 1_000,
|
|
trigger: async () => {
|
|
const suggested = new Promise<void>((resolve) => {
|
|
onDeterminingFilename.emit(initial, (value) => {
|
|
suggestion = value;
|
|
resolve();
|
|
});
|
|
});
|
|
cdpEvent?.({ tabId: 4 }, "Page.downloadWillBegin", {
|
|
url: initial.url,
|
|
suggestedFilename: initial.filename,
|
|
});
|
|
await suggested;
|
|
onCreated.emit(complete);
|
|
return { tab_id: 4, x: 10, y: 10 };
|
|
},
|
|
});
|
|
|
|
expect(suggestion).toEqual({
|
|
filename: "BrowserSkill/tr_21/candidate-first.bin",
|
|
conflictAction: "overwrite",
|
|
});
|
|
expect(result).toMatchObject({ item: { id: 21, state: "complete" } });
|
|
});
|
|
|
|
it("rejects ambiguous attribution without cancelling either unclaimed download", 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 () => {}),
|
|
removeFile: vi.fn(async () => {}),
|
|
};
|
|
let cdpEvent: Parameters<NonNullable<CdpRunner["onEvent"]>>[0] | undefined;
|
|
const cdp: CdpRunner = {
|
|
send: vi.fn(async () => ({})) as CdpRunner["send"],
|
|
onEvent: (handler) => {
|
|
cdpEvent = handler;
|
|
return { dispose: vi.fn() };
|
|
},
|
|
};
|
|
const defaults: number[] = [];
|
|
const candidate = (id: number) =>
|
|
({
|
|
id,
|
|
url: "https://example.test/same.bin",
|
|
finalUrl: "https://example.test/same.bin",
|
|
filename: "same.bin",
|
|
state: "in_progress",
|
|
}) as chrome.downloads.DownloadItem;
|
|
|
|
const result = await captureBrowserDownload({
|
|
cdp,
|
|
target: { tabId: 4 },
|
|
downloads,
|
|
browserRelativeDir: "BrowserSkill/tr_ambiguous",
|
|
timeoutMs: 100,
|
|
trigger: async () => {
|
|
cdpEvent?.({ tabId: 4 }, "Page.downloadWillBegin", {
|
|
url: "https://example.test/same.bin",
|
|
suggestedFilename: "same.bin",
|
|
});
|
|
for (const id of [31, 32]) {
|
|
onDeterminingFilename.emit(candidate(id), (value) => {
|
|
if (value === undefined) defaults.push(id);
|
|
});
|
|
}
|
|
return { tab_id: 4, x: 10, y: 10 };
|
|
},
|
|
});
|
|
|
|
expect(defaults.sort()).toEqual([31, 32]);
|
|
expect(downloads.cancel).not.toHaveBeenCalled();
|
|
expect(result).toMatchObject({
|
|
code: "cdp_failed",
|
|
data: { effect_state: "unknown", phase: "attribution" },
|
|
});
|
|
});
|
|
});
|