Files
reverse-engineering-anything/src/browser/CdpConnection.ts
T
morluto abd36dd250 refactor(browser): parse Runtime and Debugger events once by registered schemas (#10742)
* refactor(browser): parse frame lifecycle events once by a registered event schema

CdpConnection admits each event through protocol/CdpEvents.ts, which parses
the five Page frame lifecycle events once into identity facts plus a frame
URL observation, like a frame-tree node. Screenshot, page capture, the
observation timeline, WebMCP, Electron inspection and the execution window
read those facts instead of re-parsing the raw payload; CdpFrameFacts no
longer carries the raw source record. Playwright CDP session subscriptions
name an event from Playwright's protocol table, and an architecture guard
counts the remaining raw event payload reads so they can only shrink.

* refactor(browser): parse Runtime and Debugger events once by registered schemas

Register Debugger.scriptParsed, Debugger.scriptFailedToParse,
Runtime.executionContextCreated, Runtime.executionContextDestroyed and
Runtime.consoleAPICalled. Script and context payloads carry both the
tolerant facts passive capture uses and the active runtime's strict
declaration, derived from one parse, plus the declaration's byte size for
the runtime retention budget. Page capture, Electron script capture, the
V8 Inspector provider and the runtime source inventory now read the
registered payload. The cdp-raw-event-params baseline drops from 20 to 7.

* refactor(browser): admit transport events through the registered-event owner

Remove the unused cdpFrameUrl wrapper; its fragment cases now exercise
observeCdpFrameUrl. Add a connection-level test that two subscribers share
one parsed payload and the raw params.

* fix(browser): report an unserializable event declaration's size instead of throwing

JSON.stringify can throw on a declaration JSON.parse accepted (nesting
deeper than the serializer's stack). The registry sized script and context
declarations inside the connection's WebSocket callback, so such an event
escaped as an uncaught exception. The size is now a Result; the runtime
source inventory raises the failure inside its own catch, as before.

* refactor(browser): parse Network events once by registered schemas (#10743)

* refactor(browser): parse Network events once by registered schemas

Register Network.requestWillBeSent, responseReceived, loadingFinished,
loadingFailed, webSocketCreated and webSocketFrameSent/Received. The
request payload carries the tolerant facts page capture and the timeline
read plus the active runtime's strict declaration. Page capture's network
and WebSocket handlers, the timeline's request tracking and the runtime
request inventory now read the registered payload. The
cdp-raw-event-params baseline drops from 7 to 5.

* refactor(browser): drop payload helpers the capture handlers no longer use

* refactor(browser): read every CDP event payload through the registry (#10745)

* refactor(browser): read every CDP event payload through the registry

Register Target.attachedToTarget, Target.detachedFromTarget,
Page.lifecycleEvent and WebMCP.toolsAdded/toolsRemoved, and carry a
requested navigation's reason and a commit's transition type in the
frame-event payload. The timeline no longer threads raw params into its
entries: each entry receives its timestamp, frame and loader identity
explicitly. WebMCP discovery, the service-worker policy blocker and the
target-event matcher read the registered payload. With no raw reads left,
the cdp-raw-event-params guard is enforced at zero instead of counted.

* refactor(browser): drop raw payload helpers the timeline and worker blocker no longer use

* refactor(browser): type Playwright CDP session events by the registry (#10751)

PlaywrightCdpSession.on subscribes only to registered events and hands
the listener the payload parsed by its registered schema, returning the
unsubscribe function. Private storage seeding reads registered payloads,
including the events of non-flat child sessions, and applies its strict
seeding policy to the parsed facts. Its local attach, detach, nested
message and pause schemas and the storage-only script/context schemas are
removed; Debugger.paused, Runtime.executionContextsCleared and
Target.receivedMessageFromTarget join the registry.

* test(browser): admit fake policy events through the event registry

The service-worker policy now reads event.registered, but the PlaywrightScenarioSession fake connection delivered raw events, so three detached-target tests never reached the policy. The fake now admits each event with receiveCdpEvent as CdpConnection does.

* fix(browser): fail the CDP session closed when an event listener throws (#10758)

* fix(browser): fail the CDP session closed when an event listener throws

An exception from a CDP event subscriber escaped CdpTransportCore's socket message callback uncaught (for example the service-worker blocker's protocol_error on a Target event without a sessionId). The transport now stops delivery, fails the connection as a protocol error whose cause is the listener's exception, rejects pending and later commands with it, and notifies protocol-failure subscribers. The Playwright CDP session relay applies the same rule to its event listeners.

* fix(browser): report a failed service-worker policy connection at the next policy check

The policy's event listener rejects a malformed Target event, which now fails its connection. With no policy command pending, nothing reported it and later iframe targets went unprotected. The policy records its connection's protocol failure and assertBlocked, run before each scenario step, rethrows it.

* fix(browser): keep cleanup commands available after a listener failure

A listener failure no longer marks the wire as broken. The transport still rejects pending commands, notifies protocol-failure subscribers, stops delivering events and refuses reuse, but it keeps reading replies and admits commands sent in cleanup grace. The service-worker policy can then remove its init scripts, restore the main realm, detach and release its socket. Wire-level protocol errors still refuse every later command. The PlaywrightScenarioSession policy fake gains onProtocolFailure, which the policy now subscribes to.

* refactor(browser): keep raw CDP event payloads out of the received event (#10764)

* refactor(browser): keep raw CDP event payloads out of the received event

CdpReceivedEvent and CdpTransportEvent no longer carry params: receiveCdpEvent hands the raw payload only to the registered schema, so a subscriber cannot read it by property access, destructuring or computed keys. This supersedes the event.params text guard in architecture-guards, which is removed.

* refactor(browser): read registered event payloads in the JavaScript verifiers

The runtime, storage and URL-userinfo verifiers subscribe to CdpConnection, which no longer hands subscribers raw params. They now read event.registered. A test scans every scripts/ onEvent callback for raw payload reads, since the TypeScript check does not cover them. The storage verifier's pause trace records a malformed pause instead of the unregistered reason member.

* refactor(browser): track the timeline's main frame with the document tracker (#10779)

TimelineCapture kept its own mutable main frame id and replaced it on a root replacement. It now holds the CdpDocumentTracker that CdpTargetSession owns and observes the replacement document through it; every main-frame check (lifecycle, navigation, document request, redirect) reads the tracker's current frame. A characterization test pins that the replaced root's lifecycle events are no longer recorded.

* refactor(browser): select CDP events only by their registered name (#10829)

CdpReceivedEvent carried the wire method as a plain string, so a subscriber
could compare it with a misspelt or unregistered name and the check compiled
but never matched. Three owners selected Inspector.targetCrashed, an
unregistered event, that way.

Register Inspector.targetCrashed and drop the wire method from the received
event. Subscribers select events by registered.method, whose type is the
registered event names. The capture coverage start keeps reading the
wire domain, now the event's domain field.

* fix(browser): retire a policy child session that CDP reports gone

After a listener failure the connection stops delivering events, so an
iframe's Target.detachedFromTarget never retires its policy target. Cleanup
then sent Page.removeScriptToEvaluateOnNewDocument to the dead session,
kept the stale child, and every retry failed before detaching the root.

The service-worker policy owner now treats CDP's session-not-found
rejection as proof that the child is gone and retires it. The classifier
moves from CdpTargetSession to CdpCommandRejection, its owner, and the
target-session detach path uses the same one.

* refactor(browser): route target events through one session owner (#10835)

* refactor(browser): route target events through one session owner

Page capture, WebMCP discovery, screenshot capture and the runtime sources
each compared the envelope session ID themselves, while the observation
window and execution collection used cdpTargetEventMatches, which also
routes the root Target.detachedFromTarget that names the target's session.

onCdpTargetEvent in CdpTargetEvents.ts now subscribes every target consumer
with that one rule; the matcher is private and the per-subscriber
comparisons are removed. Electron inspection keeps its own filter while
its capture isolation awaits a maintainer decision.

* fix(browser): report WebMCP subframe tools whose document is unverified (#10839)

* fix(browser): report WebMCP subframe tools whose document is unverified

A committed subframe navigation kept the frame's tools silently when CDP
reported no loader at the same URL, and removed them on any URL change even
when the loader proved the same document.

Each frame now carries a CdpDocumentTracker, the session's document
identity owner. Only a proven change removes the frame's tools. An unknown
comparison keeps them visible, marks webmcp_tools attach-limited and names
the frames whose document identity could not be established.

* test(browser): prove an unverified live subframe limits WebMCP coverage

* fix(browser): key a WebMCP registration by its frame and tool name

A subframe tool kept across a committed navigation that changed the URL
but not the loader was stored under a key built from the old URL, so a
later toolsAdded for the same frame and name added a second entry.
Registrations are now keyed by frame and name; tool_key still records the
registering frame URL.

* test(browser): deliver fake CDP events through the transport's admission (#10840)

Event fakes each rebuilt the received event: CdpAgentHints typed its
listeners as raw wire events behind an unknown cast, and the Electron,
scenario-session and routing tests each wrapped receiveCdpEvent by hand.

fakeCdpEvents (tests/fixtures) is a CdpConnection.onEvent fake whose emit
admits each raw event with receiveCdpEvent and the wire byte count, so a
change to the received event shape fails at the fake instead of silently
not exercising subscribers.

* refactor(browser): own the selected page generation in one target document tracker (#10860)

* refactor(browser): own the selected page generation in one target document tracker

Page capture, screenshot, the observation window, the runtime session and
the execution window each built a document tracker or rule of their own
from root-frame navigation events. CdpTargetDocument now follows the target
session's root-frame events and the frame-tree replies its consumers read,
classifies root identity once, and reports each navigation to consumers
that decide only what it means for their evidence.

* fix(browser): report a lost scenario policy connection before the next step (#10864)

* fix(browser): report a lost scenario policy connection before the next step

The service-worker policy recorded only protocol failures. When its CDP
socket closed or its page session detached, later documents lost the
blocking script, but the scenario learned of it only when a frame check
found an unprotected realm. The owner now records the disconnect or
detach when CDP reports it; the next policy check and the next step's
action report it first.

* fix(browser): refuse an unregistered CDP command before it reaches the browser (#10868)

JavaScript verifiers can name any command, and the send owners refused an
unregistered one only when its reply arrived, after the browser had acted
on it. CdpConnection and the Playwright session now refuse the name before
sending, and the Playwright session refuses an unregistered event name
instead of subscribing to events no listener receives. The verifier text
scan stays as an early warning and documents what it cannot see.

* fix(browser): keep a proven root change and the loaderless selection's uncertainty

Two review findings on the target document owner. A root event naming
another frame with a malformed loader set `changed` but was announced as
unidentified, so the execution window failed with protocol_error and
dropped what it had collected; the owner now announces it as the proven
change it is. The runtime session compared each frame-tree reply with the
tracker's current document, which can learn a loader from an event, so a
loaderless selection followed by an event and a reply with that loader
compared as same; it now compares the reply with the selected document
through the owner, and reports target_changed as before.

* test(browser): refuse the next scenario step after the policy session detaches

* refactor(browser): read WebMCP document identity from the target document owner (#10884)

* refactor(browser): read WebMCP document identity from the target document owner

WebMCP discovery compared the first and last frame-tree roots itself and
kept a document tracker per subframe. CdpTargetDocument now follows the
selected root and each committed subframe for it: the final frame tree
feeds the owner, a root change proven by a navigation event during
discovery is target_changed as in page capture, and a subframe whose
committed document changed loses its tools. A subframe navigation without
a loader still keeps the tools and reports them as unverified.

* fix(browser): start a subframe first seen within its document with an unknown loader

A subframe absent from the initial frame tree and first seen through Page.navigatedWithinDocument had no document tracker, so a later commit started a fresh one and the tools it registered meanwhile lost the unverified-document limitation. The owner now starts such a subframe with an unknown loader.

* fix(browser): refuse a verifier's unregistered CDP event name at subscription (#10885)

JavaScript verifiers subscribed to every event with CdpConnection.onEvent
and compared registered.method with a string literal. A misspelt or
unregistered name never matched and the verifier waited until its timeout.
CdpConnection.onRegisteredEvent now takes one event name, refuses an
unregistered one before subscribing (the same registry check the Playwright
session applies), and hands the listener only that event's registered
parse. The verifiers subscribe only through it, and the evaluation test
rejects a raw onEvent subscription in scripts.

* fix(browser): keep subframe documents by frame and loader without their URLs
2026-11-15 19:54:17 +08:00

790 lines
26 KiB
TypeScript

import { MAX_NODE_TIMER_DELAY_MS } from "../domain/analysisResourceLimits.js";
import WebSocket, { type RawData } from "ws";
import { isUtf8 } from "node:buffer";
import { cancelledBy, carriedReason } from "../domain/analysisErrorCore.js";
import { AnalysisError } from "../domain/analysisErrorBase.js";
import { BrowserObservationError } from "../domain/browserObservationError.js";
import { CdpCommandRejection } from "./CdpCommandRejection.js";
import {
admitCdpReply,
assertCdpCommand,
type CdpCommand,
type CdpCommandParams,
type CdpCommandResult,
} from "./protocol/CdpCommands.js";
import {
assertCdpEvent,
registeredCdpEvent,
type CdpEventName,
type CdpRegisteredEvent,
type CdpRegisteredEventOf,
} from "./protocol/CdpEvents.js";
import type { BrowserObservationOperation } from "../domain/browserObservationErrors.js";
import {
cdpCleanupGraceExpired,
cdpCommandDeadlineRecovery,
cdpCommandTimeoutIsSelectable,
cdpCommandTimeoutUnrelatedControl,
DEFAULT_CDP_COMMAND_TIMEOUT_MS,
noRuntimeOverrideSentence,
} from "../domain/browserDeadline.js";
import { safeParseJson } from "../domain/safeJson.js";
import { WEB_RUNTIME_LIMITS } from "../domain/webRuntime.js";
import { isRecord } from "../domain/isRecord.js";
// ws currently stores maxPayload as a signed 32-bit integer. Larger values can
// wrap to a negative number, which disables its limit check.
const MAX_WEBSOCKET_PAYLOAD_BYTES = 0x7fff_ffff;
/** One event message as the producer sent it. */
export interface CdpEvent {
readonly method: string;
readonly params: unknown;
readonly sessionId?: string | undefined;
}
/**
* An event as subscribers receive it. Neither the raw payload nor the wire
* method name is part of this type or object: subscribers select events by
* `registered.method`, whose type is the registered event names, so a
* misspelt or unregistered name does not compile, and malformed members
* cannot be reinterpreted, dropped or defaulted by each subscriber.
*/
export interface CdpReceivedEvent {
/** The protocol domain of the wire method (`"Network"` for `Network.dataReceived`), registered or not. */
readonly domain: string;
readonly sessionId?: string | undefined;
/** The payload parsed once by its registered schema; undefined for an unregistered event. */
readonly registered: CdpRegisteredEvent | undefined;
}
/** Admit one event message: parse its payload once by its registered schema. */
export const receiveCdpEvent = ({
method,
params,
sessionId,
}: CdpEvent): CdpReceivedEvent => ({
domain: method.split(".", 1)[0] ?? method,
...(sessionId === undefined ? {} : { sessionId }),
registered: registeredCdpEvent(method, params),
});
export interface CdpTransportEvent extends CdpReceivedEvent {
/** Original WebSocket message payload size, before JSON parsing. */
readonly wireBytes: number;
}
interface PendingCommand {
readonly method: string;
readonly operation: BrowserObservationOperation;
readonly sessionId?: string;
readonly resolve: (value: unknown) => void;
readonly reject: (error: AnalysisError) => void;
readonly dispose: () => void;
readonly reschedule: (timeoutMs: number) => void;
}
class CdpTransportCore {
readonly #pending = new Map<number, PendingCommand>();
readonly #listeners = new Set<(event: CdpTransportEvent) => void>();
readonly #disconnectListeners = new Set<
(reason: "disconnected" | "payload_limit") => void
>();
readonly #protocolFailureListeners = new Set<() => void>();
#nextId = 1;
#closed = false;
#closePromise: Promise<void> | undefined;
/** The wire itself broke its protocol; no later message is trusted. */
#protocolFailed = false;
/**
* A subscriber threw while handling an event. The wire is still sound, so
* only cleanup-grace commands (owners restoring what they changed) may run.
*/
#listenerFailed = false;
/** What that subscriber threw; the protocol failure's cause. */
#listenerFailure: unknown;
#transportFailure: "disconnected" | "payload_limit" = "disconnected";
root!: CdpConnection;
constructor(
private readonly socket: WebSocket,
private readonly maxPayloadBytes: number,
) {
socket.on("message", (data) => this.#receive(data));
socket.on("close", () => this.#disconnect());
socket.on("error", (cause) =>
this.#disconnect(
isRecord(cause) && cause.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
? "payload_limit"
: "disconnected",
),
);
}
isReusable(): boolean {
return (
!this.#closed &&
this.#closePromise === undefined &&
!this.#protocolFailed &&
!this.#listenerFailed &&
this.socket.readyState === WebSocket.OPEN
);
}
onEvent(listener: (event: CdpTransportEvent) => void): () => void {
this.#listeners.add(listener);
return () => this.#listeners.delete(listener);
}
onDisconnect(
operation: BrowserObservationOperation,
listener: (error: BrowserObservationError) => void,
): () => void {
if (this.#closed) {
listener(this.transportError(this.#transportFailure, operation));
return () => undefined;
}
const wrapped = (reason: "disconnected" | "payload_limit"): void => {
listener(this.transportError(reason, operation));
};
this.#disconnectListeners.add(wrapped);
return () => this.#disconnectListeners.delete(wrapped);
}
onProtocolFailure(
operation: BrowserObservationOperation,
listener: (error: BrowserObservationError) => void,
): () => void {
if (this.#protocolFailed || this.#listenerFailed) {
listener(this.transportError("protocol_error", operation));
return () => undefined;
}
const wrapped = (): void => {
listener(this.transportError("protocol_error", operation));
};
this.#protocolFailureListeners.add(wrapped);
return () => this.#protocolFailureListeners.delete(wrapped);
}
reschedulePending(ids: ReadonlySet<number>, timeoutMs: number): void {
for (const id of ids) this.#pending.get(id)?.reschedule(timeoutMs);
}
async send(
method: string,
params: Readonly<Record<string, unknown>>,
sessionId: string | undefined,
signal: AbortSignal | undefined,
context: {
readonly operation: BrowserObservationOperation;
readonly commandTimeoutMs: () => number;
readonly deadlineKind: () => "command" | "cleanup";
readonly scopedIds: Set<number>;
},
): Promise<unknown> {
const { operation } = context;
if (
this.#protocolFailed ||
(this.#listenerFailed && context.deadlineKind() !== "cleanup")
)
throw this.transportError("protocol_error", operation);
if (this.#closed || this.socket.readyState !== WebSocket.OPEN)
throw this.transportError(this.#transportFailure, operation);
if (signal?.aborted === true) throw cancelledBy(operation, signal);
const id = this.#nextId;
this.#nextId += 1;
const message = JSON.stringify({
id,
method,
params,
...(sessionId === undefined ? {} : { sessionId }),
});
return await new Promise((resolve, reject) => {
const onAbort = (): void => {
const pending = this.#pending.get(id);
if (pending === undefined) return;
this.#complete(id, pending);
reject(cancelledBy(operation, carriedReason(signal?.reason)));
};
const failTimeout = (): void => {
const pending = this.#pending.get(id);
if (pending === undefined) return;
this.#complete(id, pending);
if (context.deadlineKind() === "cleanup") {
const detail = cdpCleanupGraceExpired();
reject(
new BrowserObservationError(operation, "timeout", {
detail,
remediationAction: detail,
}),
);
return;
}
const timeoutMs = context.commandTimeoutMs();
const recovery = cdpCommandDeadlineRecovery(
timeoutMs,
"command",
method,
cdpCommandTimeoutIsSelectable(operation),
);
reject(
new BrowserObservationError(operation, "timeout", {
detail: recovery.userMessage,
remediationAction: recovery.remediationAction,
}),
);
};
let timer = setTimeout(failTimeout, context.commandTimeoutMs());
signal?.addEventListener("abort", onAbort, { once: true });
context.scopedIds.add(id);
this.#pending.set(id, {
method,
operation,
...(sessionId === undefined ? {} : { sessionId }),
resolve,
reject,
reschedule: (timeoutMs: number): void => {
clearTimeout(timer);
timer = setTimeout(failTimeout, timeoutMs);
},
dispose: () => {
context.scopedIds.delete(id);
clearTimeout(timer);
signal?.removeEventListener("abort", onAbort);
},
});
this.socket.send(message, (error) => {
if (error === undefined || error === null) return;
const pending = this.#pending.get(id);
if (pending === undefined) return;
this.#complete(id, pending);
reject(
new BrowserObservationError(operation, "disconnected", {
cause: error,
}),
);
});
});
}
close(operation: BrowserObservationOperation): Promise<void> {
this.#closePromise ??= this.#closeTransport(operation).catch(
(cause: unknown) => {
this.#closePromise = undefined;
throw cause;
},
);
return this.#closePromise;
}
async #closeTransport(operation: BrowserObservationOperation): Promise<void> {
this.#disconnect("disconnected");
if (socketIsClosed(this.socket)) return;
await new Promise<void>((resolve, reject) => {
let settled = false;
let fallbackStarted = false;
let fallbackTimer: ReturnType<typeof setTimeout> | undefined;
const finish = (cause?: unknown): void => {
if (settled) return;
settled = true;
clearTimeout(timer);
if (fallbackTimer !== undefined) clearTimeout(fallbackTimer);
this.socket.off("close", onClose);
if (cause === undefined) resolve();
else reject(cause);
};
const onClose = (): void => finish();
const forceClose = (gracefulFailure?: unknown): void => {
if (settled || fallbackStarted) return;
fallbackStarted = true;
clearTimeout(timer);
if (socketIsClosed(this.socket)) {
finish();
return;
}
try {
this.socket.terminate();
} catch (cause: unknown) {
gracefulFailure =
gracefulFailure === undefined
? cause
: new AggregateError(
[gracefulFailure, cause],
"Graceful and forced CDP WebSocket close both failed.",
{ cause: gracefulFailure },
);
}
if (socketIsClosed(this.socket)) finish();
else {
fallbackTimer = setTimeout(() => {
if (socketIsClosed(this.socket)) {
finish();
return;
}
finish(
gracefulFailure ??
new BrowserObservationError(operation, "cleanup_failed", {
detail: "REA could not confirm release of its CDP WebSocket.",
}),
);
}, 1_000);
}
};
const timer = setTimeout(() => forceClose(), 1_000);
this.socket.once("close", onClose);
try {
this.socket.close();
} catch (closeCause: unknown) {
forceClose(closeCause);
}
});
}
#receive(data: RawData): void {
if (this.#closed || this.#protocolFailed) return;
const bytes = rawBytes(data);
// Binary WebSocket messages bypass ws's text-frame UTF-8 validation.
// Never replacement-decode protocol facts into a different accepted value.
if (!isUtf8(bytes)) {
this.#failPending("protocol_error");
return;
}
const parsed = safeParseJson(bytes.toString("utf8"));
if (!parsed.ok) {
this.#failPending("protocol_error");
return;
}
const message: unknown = parsed.value;
if (!isRecord(message)) {
this.#failPending("protocol_error");
return;
}
if ("id" in message) {
if (
typeof message.id !== "number" ||
!Number.isSafeInteger(message.id) ||
message.id < 1
) {
this.#failPending("protocol_error");
return;
}
this.#receiveResponse(message, message.id);
return;
}
if (
typeof message.method !== "string" ||
message.method.length === 0 ||
("params" in message && !isRecord(message.params)) ||
("sessionId" in message && typeof message.sessionId !== "string")
) {
this.#failPending("protocol_error");
return;
}
const event: CdpTransportEvent = {
...receiveCdpEvent({
method: message.method,
params: "params" in message ? message.params : {},
...(typeof message.sessionId === "string"
? { sessionId: message.sessionId }
: {}),
}),
wireBytes: bytes.byteLength,
};
if (this.#listenerFailed) return;
for (const listener of this.#listeners) {
try {
listener(event);
} catch (cause: unknown) {
// A subscriber that cannot consume an event leaves its session's view
// of the target incomplete. Fail the connection's sessions with that
// cause instead of letting it escape the socket callback.
this.#failListener(cause);
return;
}
}
}
/**
* Reject pending commands and notify protocol-failure subscribers, but keep
* reading replies: owners still restore what they changed in cleanup grace.
*/
#failListener(cause: unknown): void {
this.#listenerFailed = true;
this.#listenerFailure = cause;
for (const [id, pending] of this.#pending) {
this.#complete(id, pending);
pending.reject(this.transportError("protocol_error", pending.operation));
}
this.#notifyProtocolFailure();
}
#notifyProtocolFailure(): void {
const listeners = [...this.#protocolFailureListeners];
this.#protocolFailureListeners.clear();
for (const listener of listeners) listener();
}
#receiveResponse(message: Record<string, unknown>, id: number): void {
const pending = this.#pending.get(id);
if (pending === undefined) return;
const hasResult = "result" in message;
const hasError = "error" in message;
// Chromium cannot route a rejection through a flat session after that
// session disappears. Its browser-level reply omits sessionId, but the
// connection-global command id still binds this exact terminal error.
const detachedSessionError =
pending.sessionId !== undefined &&
!("sessionId" in message) &&
hasError &&
isRecord(message.error) &&
message.error.code === -32_001 &&
message.error.message === "Session with given id not found.";
if (
(pending.sessionId === undefined
? "sessionId" in message
: message.sessionId !== pending.sessionId && !detachedSessionError) ||
hasResult === hasError
) {
this.#failPending("protocol_error");
return;
}
if (hasResult) {
if (!isRecord(message.result)) {
this.#failPending("protocol_error");
return;
}
this.#complete(id, pending);
pending.resolve(message.result);
return;
}
const reported = message.error;
if (
!isRecord(reported) ||
typeof reported.code !== "number" ||
!Number.isSafeInteger(reported.code) ||
typeof reported.message !== "string"
) {
this.#failPending("protocol_error");
return;
}
this.#complete(id, pending);
pending.reject(
new CdpCommandRejection(
pending.operation,
pending.method,
reported.code,
reported.message,
),
);
}
#complete(id: number, pending: PendingCommand): void {
pending.dispose();
this.#pending.delete(id);
}
#failPending(
reason: "disconnected" | "protocol_error" | "payload_limit",
): void {
if (reason !== "protocol_error") this.#closed = true;
else this.#protocolFailed = true;
for (const [id, pending] of this.#pending) {
this.#complete(id, pending);
pending.reject(this.transportError(reason, pending.operation));
}
if (reason === "protocol_error") this.#notifyProtocolFailure();
}
#disconnect(reason: "disconnected" | "payload_limit" = "disconnected"): void {
const wasClosed = this.#closed;
if (!wasClosed) this.#transportFailure = reason;
this.#failPending(reason);
if (wasClosed) return;
for (const listener of this.#disconnectListeners) listener(reason);
this.#disconnectListeners.clear();
}
transportError(
reason: "disconnected" | "protocol_error" | "payload_limit",
operation: BrowserObservationOperation,
): BrowserObservationError {
if (reason === "payload_limit")
return new BrowserObservationError(operation, reason, {
detail: noRuntimeOverrideSentence(
`CDP message exceeded the ${String(this.maxPayloadBytes)} byte protocol budget.`,
cdpCommandTimeoutUnrelatedControl(operation),
),
});
return new BrowserObservationError(
operation,
reason,
reason === "protocol_error" && this.#listenerFailed
? { cause: this.#listenerFailure }
: undefined,
);
}
}
/** Correlated JSON-RPC transport for one CDP target operation. */
export class CdpConnection {
readonly #scopedPendingIds = new Set<number>();
#commandTimeoutMs: number;
#deadlineKind: "command" | "cleanup" = "command";
private constructor(
private readonly core: CdpTransportCore,
private readonly operation: BrowserObservationOperation,
commandTimeoutMs: number,
) {
this.#commandTimeoutMs = commandTimeoutMs;
}
/** Canonical connection identity registered with `CdpTargetSessionOwner`. */
get transportRoot(): CdpConnection {
return this.core.root;
}
/** True while the underlying WebSocket remains open, unpoisoned, and outside cleanup grace. */
isReusable(): boolean {
return this.#deadlineKind === "command" && this.core.isReusable();
}
/** Bind an isolated operation and command-deadline view over this shared WebSocket. */
withOperation(
operation: BrowserObservationOperation,
commandTimeoutMs: number,
): CdpConnection {
return new CdpConnection(this.core, operation, commandTimeoutMs);
}
/** Connect to one already-validated loopback CDP WebSocket. */
static async connect(
url: string,
operation: BrowserObservationOperation,
signal?: AbortSignal,
limits?: {
readonly maxPayloadBytes?: number;
readonly commandTimeoutMs?: number;
/** Handshake budget. Discovery passes its own deadline so a short command budget cannot start first. */
readonly handshakeTimeoutMs?: number;
},
onConnected?: (connection: CdpConnection) => void,
): Promise<CdpConnection> {
if (signal?.aborted === true) throw cancelledBy(operation, signal);
const maxPayloadBytes =
limits?.maxPayloadBytes ?? WEB_RUNTIME_LIMITS.protocolBytes;
const commandTimeoutMs =
limits?.commandTimeoutMs ?? DEFAULT_CDP_COMMAND_TIMEOUT_MS;
const handshakeTimeoutMs = limits?.handshakeTimeoutMs ?? commandTimeoutMs;
if (
!Number.isSafeInteger(maxPayloadBytes) ||
maxPayloadBytes <= 0 ||
maxPayloadBytes > MAX_WEBSOCKET_PAYLOAD_BYTES
)
throw new RangeError(
`CDP maxPayloadBytes must be a positive safe integer no greater than ${String(MAX_WEBSOCKET_PAYLOAD_BYTES)}.`,
);
const socket = new WebSocket(url, {
// waitForOpen owns the deadline and typed handshake failures; the
// connection owner registers this socket before waiting for open.
handshakeTimeout: 0,
maxPayload: maxPayloadBytes,
perMessageDeflate: false,
});
const core = new CdpTransportCore(socket, maxPayloadBytes);
const connection = new CdpConnection(core, operation, commandTimeoutMs);
core.root = connection;
try {
onConnected?.(connection);
} catch (cause: unknown) {
await connection.close();
throw cause;
}
try {
await waitForOpen(socket, operation, signal, handshakeTimeoutMs);
} catch (cause: unknown) {
if (onConnected === undefined) {
try {
await connection.close();
} catch (cleanupCause: unknown) {
throw new AggregateError(
[cause, cleanupCause],
"CDP WebSocket handshake failed and its transport cleanup is incomplete.",
{ cause },
);
}
}
throw cause;
}
return connection;
}
/** Subscribe to validated CDP event envelopes. */
onEvent(listener: (event: CdpTransportEvent) => void): () => void {
return this.core.onEvent(listener);
}
/**
* Subscribe to one registered event. An unregistered name is refused here,
* before subscribing, because no event of that name could reach the
* listener: JavaScript verifiers name events the compiler cannot check.
*/
onRegisteredEvent<E extends CdpEventName>(
method: E,
listener: (
registered: CdpRegisteredEventOf<E>,
event: CdpTransportEvent,
) => void,
): () => void {
assertCdpEvent(method, this.operation);
return this.core.onEvent((event) => {
if (event.registered?.method === method)
listener(event.registered as CdpRegisteredEventOf<E>, event);
});
}
/** Subscribe to an unexpected transport loss while an operation is active. */
onDisconnect(listener: (error: BrowserObservationError) => void): () => void {
return this.core.onDisconnect(this.operation, listener);
}
/** Notify fatal wire parsing failure even when no command is outstanding. */
onProtocolFailure(
listener: (error: BrowserObservationError) => void,
): () => void {
return this.core.onProtocolFailure(this.operation, listener);
}
/** Apply the post-discovery command deadline to commands that have not started. */
selectCommandTimeout(timeoutMs: number): void {
if (this.#deadlineKind === "cleanup") return;
this.#commandTimeoutMs = timeoutMs;
}
/**
* Restoration uses the fixed cleanup grace. Commands already waiting are
* rescheduled from now so a raised command deadline cannot extend them.
*/
beginCleanupGrace(timeoutMs: number): void {
this.#deadlineKind = "cleanup";
this.#commandTimeoutMs = timeoutMs;
this.core.reschedulePending(this.#scopedPendingIds, timeoutMs);
}
/**
* Bound each response separately from the caller-selected observation
* window. A registered command's reply is parsed by its result schema; a
* mismatch rejects that command with `CdpMalformedReply`.
*/
async send<M extends CdpCommand>(
method: M,
params?: CdpCommandParams<M>,
sessionId?: string,
signal?: AbortSignal,
): Promise<CdpCommandResult<M>> {
assertCdpCommand(method, this.operation);
const reply = await this.core.send(
method,
params ?? {},
sessionId,
signal,
{
operation: this.operation,
commandTimeoutMs: () => this.#commandTimeoutMs,
deadlineKind: () => this.#deadlineKind,
scopedIds: this.#scopedPendingIds,
},
);
return admitCdpReply(method, reply, this.operation);
}
/** Close only REA's socket; never close the browser or selected page. */
close(): Promise<void> {
return this.core.close(this.operation);
}
}
const socketIsClosed = (socket: WebSocket): boolean =>
socket.readyState === WebSocket.CLOSED;
const rawBytes = (data: RawData): Buffer =>
Array.isArray(data)
? Buffer.concat(data)
: Buffer.isBuffer(data)
? data
: Buffer.from(data);
const waitForOpen = async (
socket: WebSocket,
operation: BrowserObservationOperation,
signal: AbortSignal | undefined,
handshakeTimeoutMs: number,
): Promise<void> =>
await new Promise((resolve, reject) => {
const onOpen = (): void => {
cleanup();
resolve();
};
const onFailure = (cause: unknown): void => {
cleanup();
reject(
new BrowserObservationError(operation, "endpoint_unreachable", {
cause,
}),
);
};
const onClose = (code: number, reason: Buffer): void => {
onFailure(
new Error(
`CDP WebSocket closed before opening (${code}: ${reason.toString("utf8")})`,
),
);
};
const onAbort = (): void => {
cleanup();
terminateSocket(socket);
reject(cancelledBy(operation, carriedReason(signal?.reason)));
};
const cleanup = (): void => {
clearTimeout(timer);
socket.off("open", onOpen);
socket.off("error", onFailure);
socket.off("close", onClose);
signal?.removeEventListener("abort", onAbort);
};
const boundedTimeoutMs = Math.min(
MAX_NODE_TIMER_DELAY_MS,
handshakeTimeoutMs,
);
const timer = setTimeout(() => {
terminateSocket(socket);
cleanup();
const recovery = cdpCommandDeadlineRecovery(
boundedTimeoutMs,
"handshake",
undefined,
cdpCommandTimeoutIsSelectable(operation),
);
reject(
new BrowserObservationError(operation, "timeout", {
detail: recovery.userMessage,
remediationAction: recovery.remediationAction,
}),
);
}, boundedTimeoutMs);
socket.once("open", onOpen);
socket.once("error", onFailure);
socket.once("close", onClose);
signal?.addEventListener("abort", onAbort, { once: true });
if (signal?.aborted === true) onAbort();
});
const terminateSocket = (socket: WebSocket): void => {
try {
socket.terminate();
} catch {
// The owning connection remains registered and will retry bounded close.
}
};