mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 11:43:20 +00:00
* refactor(browser): send only CDP commands with registered result schemas * refactor(browser): open Playwright CDP sessions only through the registered-command owner * fix(browser): keep the restore obligation for an applied override with a malformed reply A schema-rejected success reply means the browser applied the Emulation override, so the attached environment owner records the reset obligation before reporting the protocol error. Only a rejected or unanswered command leaves no obligation. * refactor(browser): open verifier-script CDP sessions through the registered-command owner (#10710) * fix(browser): register the CDP commands JavaScript verifiers send The verifier scripts send Browser.close, Page.createIsolatedWorld, Page.navigate, Page.reload, Target.activateTarget, Target.closeTarget and Target.createTarget through CdpConnection, which now admits every reply through its command's result schema. Register those schemas, refuse an unregistered run-time name as a typed malformed reply instead of a TypeError, and check script send literals against the registry. * fix(browser): keep Target.closeTarget's success member for the verifiers * test(browser): characterize target_changed rules per consumer * refactor(browser): decide target_changed from one document identity owner * fix(browser): compare the selected document on every authorization read Final-capture retries and the pre-capture frame-tree read now observe each reply through the selected document tracker before scope, and a screenshot command failure after a proven document change reports target_changed with the failure as its cause.
508 lines
18 KiB
TypeScript
508 lines
18 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import { CdpBrowserProvider } from "../../../src/browser/CdpBrowserProvider.js";
|
|
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
|
import {
|
|
inspectWebPageInputSchema,
|
|
listBrowserTargetsInputSchema,
|
|
} from "../../../src/domain/browserObservation.js";
|
|
import { observeWebSessionInputSchema } from "../../../src/domain/browserSession.js";
|
|
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
|
import { discoverWebMcpToolsInputSchema } from "../../../src/domain/webMcpDiscovery.js";
|
|
import { captureWebScreenshotInputSchema } from "../../../src/domain/webScreenshot.js";
|
|
import {
|
|
startFakeCdpBrowser,
|
|
type FakeOptions,
|
|
} from "../../fixtures/fakeCdpBrowser.js";
|
|
import { frameNavigated, trackBrowser } from "./cdpBrowserProvider.support.js";
|
|
|
|
const inspectWithNetworkEvents = async (
|
|
commandEvents: NonNullable<FakeOptions["commandEvents"]>,
|
|
) => {
|
|
const browser = await startFakeCdpBrowser({
|
|
eventsBeforeReply: ["Network.enable"],
|
|
commandEvents,
|
|
});
|
|
trackBrowser(browser);
|
|
const result = await new CdpBrowserProvider().inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
target_id: "allowed-page",
|
|
observation_ms: 1,
|
|
}),
|
|
);
|
|
return { browser, result };
|
|
};
|
|
|
|
describe("CdpBrowserProvider: discovery authorization 1", () => {
|
|
it("discovers pages and captures a selected target without an origin list", async () => {
|
|
const browser = await startFakeCdpBrowser();
|
|
trackBrowser(browser);
|
|
const provider = new CdpBrowserProvider();
|
|
const listed = await provider.listTargets(
|
|
listBrowserTargetsInputSchema.parse({ cdp_endpoint: browser.endpoint }),
|
|
);
|
|
|
|
if (!listed.ok) throw listed.error;
|
|
expect(listed.value.targets.map(({ target_id }) => target_id)).toContain(
|
|
"allowed-page",
|
|
);
|
|
expect(listed.value.excluded.disallowed_origin).toBe(0);
|
|
|
|
const inspected = await provider.inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
target_id: "allowed-page",
|
|
observation_ms: 0,
|
|
}),
|
|
);
|
|
if (!inspected.ok) throw inspected.error;
|
|
expect(inspected.value.target.origin).toBe(browser.allowedOrigin);
|
|
});
|
|
|
|
it("filters by exact origin and preserves local URL details", async () => {
|
|
const browser = await startFakeCdpBrowser();
|
|
trackBrowser(browser);
|
|
const provider = new CdpBrowserProvider();
|
|
const result = await provider.listTargets(
|
|
listBrowserTargetsInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
}),
|
|
);
|
|
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.targets).toEqual([
|
|
expect.objectContaining({
|
|
target_id: "allowed-page",
|
|
origin: browser.allowedOrigin,
|
|
url: `${browser.allowedOrigin}/app?token=page-secret#fragment`,
|
|
}),
|
|
]);
|
|
expect(result.value.excluded).toEqual({
|
|
disallowed_origin: 1,
|
|
unsupported_url: 1,
|
|
non_page: 1,
|
|
});
|
|
expect(JSON.stringify(result.value)).not.toContain("forbidden");
|
|
expect(JSON.stringify(result.value)).toContain("page-secret#fragment");
|
|
});
|
|
|
|
it.each([
|
|
["absolute", true, ""],
|
|
["host/path", "host-path", ""],
|
|
["root-relative", "root-relative", ""],
|
|
["prefixed host/path", "prefixed", "Loading "],
|
|
] as const)(
|
|
"preserves URL-shaped %s target titles",
|
|
async (_label, urlShapedAllowedTitle, prefix) => {
|
|
const browser = await startFakeCdpBrowser({ urlShapedAllowedTitle });
|
|
trackBrowser(browser);
|
|
const provider = new CdpBrowserProvider();
|
|
const listInput = {
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
};
|
|
const input = {
|
|
...listInput,
|
|
target_id: "allowed-page",
|
|
};
|
|
const authority = browser.allowedOrigin.replace(/^https?:\/\//u, "");
|
|
const expected =
|
|
_label === "absolute"
|
|
? `${browser.allowedOrigin}/app?startup=title-secret#fragment`
|
|
: _label === "root-relative"
|
|
? "/app?startup=title-secret#fragment"
|
|
: `${prefix}${authority}/app?startup=title-secret#fragment`;
|
|
const listed = await provider.listTargets(
|
|
listBrowserTargetsInputSchema.parse(listInput),
|
|
);
|
|
if (!listed.ok) throw listed.error;
|
|
expect(listed.value.targets[0]?.title).toBe(expected);
|
|
|
|
const inspected = await provider.inspectPage(
|
|
inspectWebPageInputSchema.parse({ ...input, observation_ms: 0 }),
|
|
);
|
|
if (!inspected.ok) throw inspected.error;
|
|
expect(inspected.value.target.title).toBe(expected);
|
|
expect(JSON.stringify({ listed, inspected })).toContain("title-secret");
|
|
},
|
|
);
|
|
|
|
it("uses page-scoped discovery sockets as direct target transports", async () => {
|
|
const browser = await startFakeCdpBrowser({
|
|
pageScopedVersionWebSocket: true,
|
|
omitTargetWebSocket: true,
|
|
additionalPageWithWebSocket: true,
|
|
additionalPageWithoutWebSocket: true,
|
|
});
|
|
trackBrowser(browser);
|
|
const provider = new CdpBrowserProvider();
|
|
const listed = await provider.listTargets(
|
|
listBrowserTargetsInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
}),
|
|
);
|
|
if (!listed.ok) throw listed.error;
|
|
expect(listed.value.targets.map(({ target_id }) => target_id)).toEqual([
|
|
"allowed-page",
|
|
"allowed-page-with-socket",
|
|
]);
|
|
expect(listed.value.limitations).toContain(
|
|
"1 otherwise allowed page target(s) lacked a validated direct CDP WebSocket and were excluded.",
|
|
);
|
|
|
|
const inspected = await provider.inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
target_id: "allowed-page",
|
|
observation_ms: 0,
|
|
}),
|
|
);
|
|
if (!inspected.ok) throw inspected.error;
|
|
expect(inspected.value.target.target_id).toBe("allowed-page");
|
|
expect(inspected.value.network.requests).toHaveLength(1);
|
|
|
|
const second = await provider.inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
target_id: "allowed-page-with-socket",
|
|
observation_ms: 0,
|
|
}),
|
|
);
|
|
if (!second.ok) throw second.error;
|
|
expect(second.value.target.target_id).toBe("allowed-page-with-socket");
|
|
const methods = browser.commands.map(({ method }) => method);
|
|
expect(methods).not.toContain("Target.attachToTarget");
|
|
expect(methods).not.toContain("Target.detachFromTarget");
|
|
expect(
|
|
browser.commands.every(({ sessionId }) => sessionId === undefined),
|
|
).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("CdpBrowserProvider: listing coverage", () => {
|
|
it.each([
|
|
{ filtered: false, missingSocket: false },
|
|
{ filtered: false, missingSocket: true },
|
|
{ filtered: true, missingSocket: false },
|
|
{ filtered: true, missingSocket: true },
|
|
])(
|
|
"qualifies listing coverage by transport admission (origin filter: $filtered, missing socket: $missingSocket)",
|
|
async ({ filtered, missingSocket }) => {
|
|
const browser = await startFakeCdpBrowser({
|
|
pageScopedVersionWebSocket: true,
|
|
additionalPageWithWebSocket: true,
|
|
additionalPageWithoutWebSocket: missingSocket,
|
|
});
|
|
trackBrowser(browser);
|
|
const listed = await new CdpBrowserProvider().listTargets(
|
|
listBrowserTargetsInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: filtered ? [browser.allowedOrigin] : [],
|
|
}),
|
|
);
|
|
if (!listed.ok) throw listed.error;
|
|
expect(listed.value.targets.map(({ target_id }) => target_id)).toEqual([
|
|
"allowed-page",
|
|
"allowed-page-with-socket",
|
|
]);
|
|
expect(listed.value.excluded).toEqual({
|
|
disallowed_origin: filtered ? 1 : 0,
|
|
unsupported_url: 1,
|
|
non_page: 1,
|
|
});
|
|
expect(listed.value.limitations).toContain(
|
|
filtered
|
|
? "Only page targets with a validated CDP transport whose current URL matches an explicitly requested exact origin are listed."
|
|
: "All page targets with supported HTTP(S) URLs and a validated CDP transport are listed.",
|
|
);
|
|
const excluded = (filtered ? 0 : 1) + (missingSocket ? 1 : 0);
|
|
expect(
|
|
listed.value.limitations.filter((message) =>
|
|
message.includes("lacked a validated direct CDP WebSocket"),
|
|
),
|
|
).toEqual(
|
|
excluded === 0
|
|
? []
|
|
: [
|
|
`${String(excluded)} otherwise allowed page target(s) lacked a validated direct CDP WebSocket and were excluded.`,
|
|
],
|
|
);
|
|
expect(browser.commands).toEqual([]);
|
|
},
|
|
);
|
|
});
|
|
|
|
it("fails with a protocol error after an unidentifiable frame event and detaches", async () => {
|
|
const { browser, result } = await inspectWithNetworkEvents((command) =>
|
|
command.method === "Network.enable"
|
|
? [
|
|
{
|
|
method: "Page.frameNavigated",
|
|
...(command.sessionId === undefined
|
|
? {}
|
|
: { sessionId: command.sessionId }),
|
|
params: undefined,
|
|
},
|
|
]
|
|
: undefined,
|
|
);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "BrowserObservationError", reason: "protocol_error" },
|
|
});
|
|
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
|
|
});
|
|
|
|
it("retains malformed child-frame identity as frame coverage while completing capture", async () => {
|
|
const { browser, result } = await inspectWithNetworkEvents((command) =>
|
|
command.method === "Network.enable"
|
|
? [
|
|
frameNavigated(command, {
|
|
id: 3,
|
|
parentId: "frame-main",
|
|
url: "https://outside.invalid/child",
|
|
}),
|
|
]
|
|
: undefined,
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.completeness.unavailable_sections).toContain("frames");
|
|
expect(result.value.target.url).toBe(
|
|
`${browser.allowedOrigin}/app?token=frame-secret`,
|
|
);
|
|
});
|
|
|
|
it("fails capture on a contradictory self-parented frame instead of accepting it as a child", async () => {
|
|
const { browser, result } = await inspectWithNetworkEvents(
|
|
(command, origin) =>
|
|
command.method === "Network.enable"
|
|
? [
|
|
frameNavigated(command, {
|
|
id: "candidate-root",
|
|
parentId: "candidate-root",
|
|
url: `${origin}/app?token=frame-secret`,
|
|
}),
|
|
]
|
|
: undefined,
|
|
);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { reason: "protocol_error" },
|
|
});
|
|
await expect.poll(() => browser.activeConnectionCount()).toBe(0);
|
|
});
|
|
|
|
it("tracks a known root replacement through later frame-scope events", async () => {
|
|
const { result } = await inspectWithNetworkEvents((command, origin) =>
|
|
command.method === "Network.enable"
|
|
? [
|
|
frameNavigated(command, {
|
|
id: "replacement-main",
|
|
loaderId: "replacement-loader",
|
|
url: `${origin}/app?token=frame-secret`,
|
|
}),
|
|
frameNavigated(command, {
|
|
id: "replacement-main",
|
|
loaderId: "outside-loader",
|
|
url: "https://outside.invalid/path",
|
|
}),
|
|
]
|
|
: undefined,
|
|
);
|
|
// Both events select the replacement main frame; the document change is
|
|
// reported before the later document's scope.
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "BrowserObservationError", reason: "target_changed" },
|
|
});
|
|
});
|
|
|
|
it("treats a same-URL and same-loader root frame ID change as a capture change", async () => {
|
|
const { result } = await inspectWithNetworkEvents((command, origin) =>
|
|
command.method === "Network.enable"
|
|
? [
|
|
frameNavigated(command, {
|
|
id: "replacement-main",
|
|
loaderId: "loader-main",
|
|
url: `${origin}/app?token=frame-secret`,
|
|
}),
|
|
]
|
|
: undefined,
|
|
);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "BrowserObservationError", reason: "target_changed" },
|
|
});
|
|
});
|
|
|
|
describe("CdpBrowserProvider: discovery authorization 2", () => {
|
|
it("rejects empty browser attachment session identifiers", async () => {
|
|
const browser = await startFakeCdpBrowser({ invalidAttachedSession: true });
|
|
trackBrowser(browser);
|
|
const result = await new CdpBrowserProvider().inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
target_id: "allowed-page",
|
|
observation_ms: 0,
|
|
}),
|
|
);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "BrowserObservationError", reason: "protocol_error" },
|
|
});
|
|
expect(browser.commands.map(({ method }) => method)).toEqual([
|
|
"Target.attachToTarget",
|
|
]);
|
|
});
|
|
|
|
it("rejects missing and disallowed page targets before attaching", async () => {
|
|
const browser = await startFakeCdpBrowser();
|
|
trackBrowser(browser);
|
|
const provider = new CdpBrowserProvider();
|
|
for (const targetId of ["missing", "disallowed-page"]) {
|
|
const result = await provider.inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
target_id: targetId,
|
|
observation_ms: 0,
|
|
}),
|
|
);
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok)
|
|
expect(result.error).toMatchObject({
|
|
_tag: "BrowserObservationError",
|
|
reason:
|
|
targetId === "missing" ? "target_not_found" : "target_not_allowed",
|
|
});
|
|
}
|
|
expect(browser.commands).toHaveLength(0);
|
|
});
|
|
|
|
it("returns typed errors for malformed discovery and disconnects", async () => {
|
|
const malformed = await startFakeCdpBrowser({ malformedDiscovery: true });
|
|
trackBrowser(malformed);
|
|
const malformedResult = await new CdpBrowserProvider().listTargets(
|
|
listBrowserTargetsInputSchema.parse({
|
|
cdp_endpoint: malformed.endpoint,
|
|
allowed_origins: [malformed.allowedOrigin],
|
|
}),
|
|
);
|
|
expect(malformedResult).toMatchObject({
|
|
ok: false,
|
|
error: {
|
|
_tag: "BrowserObservationError",
|
|
reason: "invalid_endpoint_response",
|
|
},
|
|
});
|
|
|
|
const disconnecting = await startFakeCdpBrowser({
|
|
closeOnMethod: "Page.getFrameTree",
|
|
});
|
|
trackBrowser(disconnecting);
|
|
const disconnectedResult = await new CdpBrowserProvider().inspectPage(
|
|
inspectWebPageInputSchema.parse({
|
|
cdp_endpoint: disconnecting.endpoint,
|
|
allowed_origins: [disconnecting.allowedOrigin],
|
|
target_id: "allowed-page",
|
|
observation_ms: 0,
|
|
}),
|
|
);
|
|
expect(disconnectedResult).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "BrowserObservationError", reason: "disconnected" },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("CdpBrowserProvider: target selection detail", () => {
|
|
it("keeps target selection detail for every target operation", async () => {
|
|
const browser = await startFakeCdpBrowser();
|
|
trackBrowser(browser);
|
|
const provider = new CdpBrowserProvider();
|
|
const operations = [
|
|
[
|
|
"inspect_web_page",
|
|
(input) =>
|
|
provider.inspectPage(
|
|
inspectWebPageInputSchema.parse({ ...input, observation_ms: 0 }),
|
|
),
|
|
],
|
|
[
|
|
"analyze_web_bundle",
|
|
(input) =>
|
|
provider.analyzeBundle(
|
|
analyzeWebBundleInputSchema.parse({ ...input, observation_ms: 0 }),
|
|
),
|
|
],
|
|
[
|
|
"observe_web_session",
|
|
(input) =>
|
|
provider.observeSession(observeWebSessionInputSchema.parse(input)),
|
|
],
|
|
[
|
|
"discover_webmcp_tools",
|
|
(input) =>
|
|
provider.discoverWebMcpTools(
|
|
discoverWebMcpToolsInputSchema.parse(input),
|
|
),
|
|
],
|
|
[
|
|
"capture_web_screenshot",
|
|
(input) =>
|
|
provider.captureScreenshot(
|
|
captureWebScreenshotInputSchema.parse(input),
|
|
),
|
|
],
|
|
] as const satisfies readonly (readonly [
|
|
string,
|
|
(input: Record<string, unknown>) => Promise<{ readonly ok: boolean }>,
|
|
])[];
|
|
const selections = [
|
|
[
|
|
"missing",
|
|
"target_not_found",
|
|
"Target missing was not found at the selected endpoint.",
|
|
"Refresh target discovery for that endpoint and retry with a returned target ID.",
|
|
],
|
|
[
|
|
"disallowed-page",
|
|
"target_not_allowed",
|
|
"Target disallowed-page must be an HTTP(S) page in the selected origin scope.",
|
|
"Target disallowed-page must be an HTTP(S) page in the selected origin scope.",
|
|
],
|
|
] as const;
|
|
const inspected = new Map<string, unknown>();
|
|
for (const [operation, run] of operations)
|
|
for (const [targetId, reason, detail, remediation] of selections) {
|
|
const result = await run({
|
|
cdp_endpoint: browser.endpoint,
|
|
allowed_origins: [browser.allowedOrigin],
|
|
target_id: targetId,
|
|
});
|
|
if (result.ok) throw new Error(`${operation} accepted ${targetId}`);
|
|
expect(result.error).toMatchObject({ operation, reason });
|
|
const { details, ...projected } = projectAnalysisError(result.error);
|
|
expect(details).toEqual({ operation, reason });
|
|
expect(projected).toMatchObject({
|
|
code: "target_unavailable",
|
|
message: detail,
|
|
remediation: { action: remediation },
|
|
});
|
|
// Only the attributed operation differs from the inspect projection.
|
|
if (operation === "inspect_web_page")
|
|
inspected.set(targetId, projected);
|
|
else expect(projected).toEqual(inspected.get(targetId));
|
|
}
|
|
expect(browser.commands).toHaveLength(0);
|
|
expect(browser.openedConnectionCount()).toBe(0);
|
|
});
|
|
});
|