import { formatErrorMessage } from "../../infra/errors.js";

import { getBrowserProfileCapabilities } from "../profile-capabilities.js";

import type { BrowserRouteContext } from "../server-context.js";

import {

import { EXISTING_SESSION_LIMITS } from "./existing-session-limits.js";

import { ensureOutputRootDir, resolveWritableOutputPathOrRespond } from "./output-paths.js";

import { DEFAULT_DOWNLOAD_DIR } from "./path-output.js";

import { readRoutePositiveInteger } from "./route-numeric.js";

import type { BrowserRouteRegistrar } from "./types.js";

import { asyncBrowserRoute, jsonError, toNumber, toStringOrEmpty } from "./utils.js";

import { asyncBrowserRoute, jsonError, toStringOrEmpty } from "./utils.js";

function buildDownloadRequestBase(cdpUrl: string, targetId: string, timeoutMs: number | undefined) {

return {

const body = readBody(req);

const targetId = resolveTargetIdFromBody(body);

const out = toStringOrEmpty(body.path) || "";

const timeoutMs = toNumber(body.timeoutMs);

let timeoutMs: number | undefined;

try {

timeoutMs = readRoutePositiveInteger(body.timeoutMs, "timeoutMs");

} catch (err) {

return jsonError(res, 400, formatErrorMessage(err));

}

await withRouteTabContext({

req,

const targetId = resolveTargetIdFromBody(body);

const ref = toStringOrEmpty(body.ref);

const out = toStringOrEmpty(body.path);

const timeoutMs = toNumber(body.timeoutMs);

let timeoutMs: number | undefined;

try {

timeoutMs = readRoutePositiveInteger(body.timeoutMs, "timeoutMs");

} catch (err) {

return jsonError(res, 400, formatErrorMessage(err));

}

if (!ref) {

return jsonError(res, 400, "ref is required");

}

import { formatErrorMessage } from "../../infra/errors.js";

import { evaluateChromeMcpScript, uploadChromeMcpFile } from "../chrome-mcp.js";

import { getBrowserProfileCapabilities } from "../profile-capabilities.js";

import type { BrowserRouteContext } from "../server-context.js";

} from "./agent.shared.js";

import { EXISTING_SESSION_LIMITS } from "./existing-session-limits.js";

import { DEFAULT_UPLOAD_DIR, pathScope } from "./path-output.js";

import { readRoutePositiveInteger } from "./route-numeric.js";

import type { BrowserRouteRegistrar } from "./types.js";

import {

asyncBrowserRoute,

jsonError,

toBoolean,

toNumber,

toStringArray,

toStringOrEmpty,

} from "./utils.js";

const inputRef = toStringOrEmpty(body.inputRef) || undefined;

const element = toStringOrEmpty(body.element) || undefined;

const paths = toStringArray(body.paths) ?? [];

const timeoutMs = toNumber(body.timeoutMs);

let timeoutMs: number | undefined;

try {

timeoutMs = readRoutePositiveInteger(body.timeoutMs, "timeoutMs");

} catch (err) {

return jsonError(res, 400, formatErrorMessage(err));

}

if (!paths.length) {

return jsonError(res, 400, "paths are required");

}

const targetId = resolveTargetIdFromBody(body);

const accept = toBoolean(body.accept);

const promptText = toStringOrEmpty(body.promptText) || undefined;

const timeoutMs = toNumber(body.timeoutMs);

let timeoutMs: number | undefined;

try {

timeoutMs = readRoutePositiveInteger(body.timeoutMs, "timeoutMs");

} catch (err) {

return jsonError(res, 400, formatErrorMessage(err));

}

const dialogId = toStringOrEmpty(body.dialogId) || undefined;

if (accept === undefined) {

return jsonError(res, 400, "accept is required");

import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";

import { formatErrorMessage } from "../../infra/errors.js";

import {

clickChromeMcpElement,

} from "./agent.shared.js";

import { resolveTargetIdAfterNavigate } from "./agent.snapshot-target.js";

import { EXISTING_SESSION_LIMITS } from "./existing-session-limits.js";

import { readRoutePositiveInteger } from "./route-numeric.js";

import type { BrowserRouteRegistrar } from "./types.js";

import { asyncBrowserRoute, jsonError, toStringOrEmpty } from "./utils.js";

throw new Error("Unsupported browser act kind");

}

function readRoutePositiveInteger(value: unknown, fieldName: string): number | undefined {

const parsed = parseStrictPositiveInteger(value);

if (parsed === undefined && value != null) {

throw new Error(`${fieldName} must be a positive integer.`);

}

return parsed;

}

export function registerBrowserAgentActRoutes(

app: BrowserRouteRegistrar,

ctx: BrowserRouteContext,

import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";

export function readRoutePositiveInteger(value: unknown, fieldName: string): number | undefined {

const parsed = parseStrictPositiveInteger(value);

if (parsed === undefined && value != null) {

throw new Error(`${fieldName} must be a positive integer.`);

}

return parsed;

}

expect(pwMocks.responseBodyViaPlaywright).toHaveBeenCalledTimes(beforeCalls);

});

it("rejects loose hook and download timeout options before dispatch", async () => {

const base = await startServerAndBase();

const uploadCalls = pwMocks.armFileUploadViaPlaywright.mock.calls.length;

const dialogCalls = pwMocks.armDialogViaPlaywright.mock.calls.length;

const waitCalls = pwMocks.waitForDownloadViaPlaywright.mock.calls.length;

const downloadCalls = pwMocks.downloadViaPlaywright.mock.calls.length;

const uploadRes = await postJson<{ error?: string }>(`${base}/hooks/file-chooser`, {

paths: ["a.txt"],

timeoutMs: "1e3",

});

expect(uploadRes.error).toContain("timeoutMs must be a positive integer.");

const dialogRes = await postJson<{ error?: string }>(`${base}/hooks/dialog`, {

accept: true,

timeoutMs: "0x10",

});

expect(dialogRes.error).toContain("timeoutMs must be a positive integer.");

const waitRes = await postJson<{ error?: string }>(`${base}/wait/download`, {

path: "report.pdf",

timeoutMs: "1000ms",

});

expect(waitRes.error).toContain("timeoutMs must be a positive integer.");

const downloadRes = await postJson<{ error?: string }>(`${base}/download`, {

ref: "e12",

path: "report.pdf",

timeoutMs: "1.5",

});

expect(downloadRes.error).toContain("timeoutMs must be a positive integer.");

expect(pwMocks.armFileUploadViaPlaywright).toHaveBeenCalledTimes(uploadCalls);

expect(pwMocks.armDialogViaPlaywright).toHaveBeenCalledTimes(dialogCalls);

expect(pwMocks.waitForDownloadViaPlaywright).toHaveBeenCalledTimes(waitCalls);

expect(pwMocks.downloadViaPlaywright).toHaveBeenCalledTimes(downloadCalls);

});

it("agent contract: hooks + response + downloads + screenshot", async () => {

const base = await startServerAndBase();