import { BrowserCdpEndpointBlockedError } from "./errors.js";

import { resolveBrowserRateLimitMessage } from "./rate-limit-message.js";

import { withAllowedHostname } from "./ssrf-policy-helpers.js";

import { normalizeBrowserTimerDelayMs } from "./timer-delay.js";

export { isLoopbackHost };

export { parseBrowserHttpUrl, redactCdpUrl };

const pending = new Map<number, Pending>();

const commandTimeoutMs =

typeof opts?.commandTimeoutMs === "number" && Number.isFinite(opts.commandTimeoutMs)

? Math.max(1, Math.floor(opts.commandTimeoutMs))

? normalizeBrowserTimerDelayMs(opts.commandTimeoutMs)

: undefined;

const clearPendingTimer = (p: Pending) => {

ssrfPolicy?: SsrFPolicy,

): Promise<CdpFetchResult> {

const ctrl = new AbortController();

const t = setTimeout(ctrl.abort.bind(ctrl), timeoutMs);

const t = setTimeout(ctrl.abort.bind(ctrl), normalizeBrowserTimerDelayMs(timeoutMs));

let guardedRelease: (() => Promise<void>) | undefined;

let released = false;

const release = async () => {

expect(plan.timeoutMs).toBe(12345);

});

it("caps timeoutMs from the snapshot query string to Node's safe timer range", () => {

const plan = resolveSnapshotPlan({

profile: profile("openclaw"),

query: { timeoutMs: "3000000000" },

hasPlaywright: true,

});

expect(plan.timeoutMs).toBe(2_147_483_647);

});

it("ignores non-positive timeoutMs values", () => {

expect(

resolveSnapshotPlan({

shouldUsePlaywrightForAriaSnapshot,

shouldUsePlaywrightForScreenshot,

} from "../profile-capabilities.js";

import { normalizeBrowserTimerDelayMs } from "../timer-delay.js";

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

type BrowserSnapshotPlan = {

const timeoutMsRaw = toNumber(params.query.timeoutMs);

const timeoutMs =

timeoutMsRaw !== undefined && Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0

? Math.max(1, Math.floor(timeoutMsRaw))

? normalizeBrowserTimerDelayMs(timeoutMsRaw)

: undefined;

return {

requirePwAi: vi.fn(async () => null),

resolveProfileContext: vi.fn(() => profileContext),

withPlaywrightRouteContext: vi.fn(),

withRouteTabContext: vi.fn(),

withRouteTabContext: vi.fn(

async (params: {

run: (ctx: {

profileCtx: typeof profileContext;

tab: { targetId: string; url: string; wsUrl: string };

cdpUrl: string;

}) => Promise<void>;

}) =>

await params.run({

profileCtx: profileContext,

tab: {

targetId: "tab-1",

url: "https://example.com",

wsUrl: "ws://127.0.0.1:18800/devtools/page/tab-1",

},

cdpUrl: "http://127.0.0.1:18800",

}),

),

}));

const { registerBrowserAgentSnapshotRoutes } = await import("./agent.snapshot.js");

return handler;

}

function getScreenshotHandler() {

const { app, postHandlers } = createBrowserRouteApp();

registerBrowserAgentSnapshotRoutes(app, {

state: () => ({ resolved: { extraArgs: [] } }),

} as never);

const handler = postHandlers.get("/screenshot");

expect(handler).toBeTypeOf("function");

return handler;

}

describe("browser agent snapshot timeout routing", () => {

beforeEach(() => {

cdpMocks.captureScreenshot.mockClear();

}),

);

});

it("caps screenshot timeoutMs before dispatching to CDP", async () => {

cdpMocks.captureScreenshot.mockResolvedValueOnce(Buffer.from("png"));

const handler = getScreenshotHandler();

const response = createBrowserRouteResponse();

await handler?.(

{ params: {}, query: {}, body: { type: "png", timeoutMs: 3_000_000_000 } },

response.res,

);

expect(response.statusCode).toBe(200);

expect(cdpMocks.captureScreenshot).toHaveBeenCalledWith(

expect.objectContaining({

timeoutMs: 2_147_483_647,

}),

);

});

});

normalizeBrowserScreenshot,

} from "../screenshot.js";

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

import { normalizeBrowserTimerDelayMs } from "../timer-delay.js";

import {

getPwAiModule,

handleRouteError,

const timeoutMsRaw = toNumber(body.timeoutMs);

const timeoutMs =

timeoutMsRaw !== undefined

? Math.max(1, Math.floor(timeoutMsRaw))

? normalizeBrowserTimerDelayMs(timeoutMsRaw)

: DEFAULT_BROWSER_SCREENSHOT_TIMEOUT_MS;

if (fullPage && (ref || element)) {

import { describe, expect, it } from "vitest";

import { MAX_SAFE_TIMEOUT_DELAY_MS, normalizeBrowserTimerDelayMs } from "./timer-delay.js";

describe("normalizeBrowserTimerDelayMs", () => {

it("caps timers to Node's safe delay range", () => {

expect(normalizeBrowserTimerDelayMs(3_000_000_000)).toBe(MAX_SAFE_TIMEOUT_DELAY_MS);

});

it("preserves positive integer timers and applies the minimum", () => {

expect(normalizeBrowserTimerDelayMs(1234.9)).toBe(1234);

expect(normalizeBrowserTimerDelayMs(-5)).toBe(1);

expect(normalizeBrowserTimerDelayMs(0, { minMs: 0 })).toBe(0);

});

});

export const MAX_SAFE_TIMEOUT_DELAY_MS = 2_147_483_647;

export function normalizeBrowserTimerDelayMs(timeoutMs: number, opts?: { minMs?: number }): number {

const rawMinMs = opts?.minMs ?? 1;

const minMs = Math.min(

MAX_SAFE_TIMEOUT_DELAY_MS,

Math.max(0, Number.isFinite(rawMinMs) ? Math.floor(rawMinMs) : 1),

);

const candidateMs = Number.isFinite(timeoutMs) ? Math.floor(timeoutMs) : minMs;

return Math.min(MAX_SAFE_TIMEOUT_DELAY_MS, Math.max(minMs, candidateMs));

}

BROWSER_REQUEST_GATEWAY_METHOD,

BROWSER_REQUEST_GATEWAY_SCOPES,

} from "../browser-gateway-contract.js";

import { normalizeBrowserTimerDelayMs } from "../browser/timer-delay.js";

import { callGatewayFromCli, type GatewayRpcOpts } from "./core-api.js";

const MAX_SAFE_TIMEOUT_DELAY_MS = 2_147_483_647;

export type BrowserParentOpts = GatewayRpcOpts & {

json?: boolean;

browserProfile?: string;

return parsed;

}

function normalizeCliTimeoutMs(timeoutMs: number): number {

return Math.min(MAX_SAFE_TIMEOUT_DELAY_MS, Math.max(1, Math.floor(timeoutMs)));

}

export async function callBrowserRequest<T>(

opts: BrowserParentOpts,

params: BrowserRequestParams,

extra?: { timeoutMs?: number; progress?: boolean },

): Promise<T> {

const resolvedTimeoutMs =

typeof extra?.timeoutMs === "number" && Number.isFinite(extra.timeoutMs)

? normalizeCliTimeoutMs(extra.timeoutMs)

? normalizeBrowserTimerDelayMs(extra.timeoutMs)

: typeof opts.timeout === "string"

? normalizeCliTimeoutMs(parsePositiveInteger(opts.timeout, "--timeout"))

? normalizeBrowserTimerDelayMs(parsePositiveInteger(opts.timeout, "--timeout"))

: undefined;

const resolvedTimeout =

typeof resolvedTimeoutMs === "number" && Number.isFinite(resolvedTimeoutMs)