Files
reverse-engineering-anything/tests/boundary/browser/cdpWebMcpTransientIdentity.test.ts
T
morluto da5ff5e7a7 test(webmcp): consolidate passive discovery coverage
Exercise exact replay ownership, malformed declarations and frame scope, transient recovery, and canonical schema evidence through shared CDP captures. Remove unused fake modes.
2026-11-18 08:43:07 -05:00

654 lines
20 KiB
TypeScript

import { expect, it } from "vitest";
import type { CdpEvent } from "../../../src/browser/CdpConnection.js";
import { CdpBrowserProvider } from "../../../src/browser/CdpBrowserProvider.js";
import { inspectWebPageInputSchema } from "../../../src/domain/browserObservation.js";
import { discoverWebMcpToolsInputSchema } from "../../../src/domain/webMcpDiscovery.js";
import { compareWebCaptures } from "../../../src/domain/webCaptureDiff.js";
import { compareWebCapturesInputSchema } from "../../../src/domain/webCaptureDiffSchemas.js";
import { startFakeCdpBrowser } from "../../fixtures/fakeCdpBrowser.js";
import { trackBrowser } from "./cdpBrowserProvider.support.js";
const transientChildren = [
{ id: "blank-inline", location: { url: "about:blank#details" } },
{
id: "blank-split",
location: { url: "about:blank", urlFragment: "#details" },
},
{ id: "srcdoc-inline", location: { url: "about:srcdoc#details" } },
{
id: "srcdoc-split",
location: { url: "about:srcdoc", urlFragment: "#details" },
},
];
it.each([
{ phase: "initial", recover: false },
{ phase: "initial", recover: true },
{ phase: "event", recover: false },
{ phase: "event", recover: true },
] as const)(
"keeps temporary document policy independent of URL encoding: $phase/$recover",
async ({ phase, recover }) => {
let document = phase === "initial" ? "transient" : "old";
const frames = (origin: string) =>
transientChildren.map(({ id, location }) => ({
id,
parentId: "frame-main",
loaderId: `${id}-${document}`,
...(document === "transient"
? location
: {
url: `${origin}/${id}`,
urlFragment: document === "fresh" ? "#current" : "#old",
}),
}));
const registrations = (description: string) =>
transientChildren.map(({ id }) => ({
name: `read-${id}`,
description,
frameId: id,
inputSchema: {},
annotations: {
readOnly: true,
untrustedContent: true,
consequential: false,
autosubmit: false,
},
}));
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["WebMCP.enable"],
commandResult: ({ method }, origin) =>
method === "Page.getFrameTree"
? {
frameTree: {
frame: {
id: "frame-main",
loaderId: "loader-frame-main",
url: origin + "/app",
},
childFrames: frames(origin).map((frame) => ({ frame })),
},
}
: undefined,
commandEvents: ({ method, sessionId }, origin) => {
if (method !== "WebMCP.enable") return undefined;
const navigationEvents = () =>
frames(origin).map((frame) => ({
method: "Page.frameNavigated",
sessionId,
params: { frame },
}));
const events: CdpEvent[] = [
{
method: "WebMCP.toolsAdded",
sessionId,
params: { tools: registrations("Stale registration") },
},
];
document = "transient";
if (phase === "event") events.push(...navigationEvents());
if (recover) {
document = "fresh";
events.push(...navigationEvents(), {
method: "WebMCP.toolsAdded",
sessionId,
params: { tools: registrations("Current registration") },
});
}
return events;
},
});
trackBrowser(browser);
const provider = new CdpBrowserProvider();
const input = {
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
};
const result = await provider.discoverWebMcpTools(
discoverWebMcpToolsInputSchema.parse(input),
);
if (!result.ok) throw result.error;
expect(
result.value.tools.items.toSorted((left, right) =>
left.name.localeCompare(right.name),
),
).toMatchObject(
recover
? transientChildren.map(({ id }) => ({
name: `read-${id}`,
frame_id: id,
frame_url: `${browser.allowedOrigin}/${id}#current`,
description: "Current registration",
}))
: [],
);
expect(result.value.completeness.policy_filtered_sections).not.toContain(
"webmcp_tools",
);
const complete = recover && phase === "initial";
expect(
result.value.completeness.attach_limited_sections.includes(
"webmcp_tools",
),
).toBe(!complete);
const inspection = await provider.inspectPage(
inspectWebPageInputSchema.parse(input),
);
if (!inspection.ok) throw inspection.error;
const snapshot = { inspection: inspection.value, webmcp: result.value };
const compared = compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: snapshot,
after: snapshot,
}),
);
expect(compared.dimensions.webmcp).toMatchObject({
status: complete ? "unchanged" : "unknown",
total_changes: 0,
changes: [],
});
},
);
it("keeps near-miss temporary URLs outside the approved frame inventory", async () => {
const rejectedUrls = [
"about:blanker#details",
"about:srcdoc-other#details",
"about:blank?policy=1#details",
"https://foreign.invalid/child#about:blank",
];
const childIds = rejectedUrls.map((_, index) => `excluded-${index}`);
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["WebMCP.enable"],
commandResult: ({ method }, origin) =>
method === "Page.getFrameTree"
? {
frameTree: {
frame: {
id: "frame-main",
loaderId: "loader-frame-main",
url: origin + "/app",
},
childFrames: [...rejectedUrls, origin + "/child#about:blank"].map(
(url, index) => ({
frame: {
id: childIds[index] ?? "allowed",
loaderId: `loader-${index}`,
parentId: "frame-main",
url,
},
}),
),
},
}
: undefined,
commandEvents: ({ method, sessionId }) =>
method === "WebMCP.enable"
? [
{
method: "WebMCP.toolsAdded",
sessionId,
params: {
tools: [...childIds, "allowed"].map((id) => ({
name: `read-${id}`,
frameId: id,
})),
},
},
]
: undefined,
});
trackBrowser(browser);
const result = await new CdpBrowserProvider().discoverWebMcpTools(
discoverWebMcpToolsInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!result.ok) throw result.error;
expect(result.value.tools.items).toMatchObject([
{
name: "read-allowed",
frame_id: "allowed",
frame_url: browser.allowedOrigin + "/child#about:blank",
},
]);
expect(result.value.completeness.policy_filtered_sections).toContain(
"webmcp_tools",
);
expect(result.value.completeness.attach_limited_sections).toContain(
"webmcp_tools",
);
expect(result.value.completeness.excluded).toEqual([
{ section: "webmcp_tools", reason: "out_of_target_scope", count: 8 },
]);
});
const discoverWithChildEvents = async (
childIds: readonly string[],
events: (origin: string, sessionId: string | undefined) => CdpEvent[],
) => {
const browser = await startFakeCdpBrowser({
eventsBeforeReply: ["WebMCP.enable"],
commandResult: ({ method }, origin) =>
method === "Page.getFrameTree"
? {
frameTree: {
frame: {
id: "frame-main",
loaderId: "loader-frame-main",
url: origin + "/app",
},
childFrames: childIds.map((id) => ({
frame: {
id,
parentId: "frame-main",
loaderId: "loader-A",
url: `${origin}/${id}`,
},
})),
},
}
: undefined,
commandEvents: ({ method, sessionId }, origin) =>
method === "WebMCP.enable" ? events(origin, sessionId) : undefined,
});
trackBrowser(browser);
const result = await new CdpBrowserProvider().discoverWebMcpTools(
discoverWebMcpToolsInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
return { result, origin: browser.allowedOrigin };
};
it("invalidates only registrations attributable to malformed committed frame facts", async () => {
const cases = [
{ id: "missing-id", fields: { frameId: "missing-id" } },
{ id: "numeric-id", fields: { id: 7, frameId: "numeric-id" } },
{ id: "empty-id", fields: { id: "", frameId: "empty-id" } },
{ id: "numeric-parent", fields: { id: "numeric-parent", parentId: 7 } },
{ id: "empty-parent", fields: { id: "empty-parent", parentId: "" } },
{ id: "null-parent", fields: { id: "null-parent", parentId: null } },
{
id: "numeric-loader",
fields: { id: "numeric-loader", parentId: "frame-main", loaderId: 7 },
},
{ id: "unaffected", fields: undefined },
];
const { result } = await discoverWithChildEvents(
cases.map(({ id }) => id),
(origin, sessionId) => [
{
method: "WebMCP.toolsAdded",
sessionId,
params: {
tools: cases.map(({ id }) => ({
name: id,
frameId: id,
inputSchema: {},
})),
},
},
...cases.flatMap(({ id, fields }) =>
fields === undefined
? []
: [
{
method: "Page.frameNavigated",
sessionId,
params: { frame: { ...fields, url: `${origin}/${id}` } },
},
],
),
],
);
if (!result.ok) throw result.error;
expect(
result.value.tools.items
.map(({ name, frame_id }) => [name, frame_id])
.sort(),
).toEqual([
["empty-id", "empty-id"],
["missing-id", "missing-id"],
["numeric-id", "numeric-id"],
["unaffected", "unaffected"],
]);
expect(result.value.completeness.excluded).toEqual([
{ section: "webmcp_tools", reason: "invalid_protocol_value", count: 7 },
]);
});
it("rejects discovery when a child commits as a new root", async () => {
const { result } = await discoverWithChildEvents(
["child"],
(origin, sessionId) => [
{
method: "Page.frameNavigated",
sessionId,
params: { frame: { id: "child", url: origin + "/child" } },
},
],
);
expect(result).toMatchObject({
ok: false,
error: { reason: "target_changed" },
});
});
it("retains the child ancestry on same-document navigation so a parent detach removes its tools", async () => {
const { result } = await discoverWithChildEvents(
["child"],
(origin, sessionId) => [
{
method: "WebMCP.toolsAdded",
sessionId,
params: {
tools: [{ name: "current", frameId: "child", inputSchema: {} }],
},
},
{
method: "Page.navigatedWithinDocument",
sessionId,
params: { frameId: "child", url: origin + "/child" },
},
{
method: "Page.frameDetached",
sessionId,
params: { frameId: "frame-main" },
},
],
);
if (!result.ok) throw result.error;
expect(result.value.tools.items).toEqual([]);
expect(result.value.completeness.excluded).toEqual([]);
});
it("retains the committed loader through same-document updates before a replacement", async () => {
const browser = await startFakeCdpBrowser({
webMcpTools: true,
eventsBeforeReply: ["WebMCP.enable"],
commandResult: ({ method }, origin) =>
method === "Page.getFrameTree"
? {
frameTree: {
frame: {
id: "frame-main",
loaderId: "loader-frame-main",
url: origin + "/app",
},
childFrames: [
{
frame: {
id: "child",
parentId: "frame-main",
loaderId: "loader-A",
url: origin + "/child",
},
},
],
},
}
: undefined,
commandEvents: ({ method, sessionId }, origin) => {
if (method !== "WebMCP.enable") return undefined;
const scope = sessionId === undefined ? {} : { sessionId };
return [
{
method: "WebMCP.toolsAdded",
...scope,
params: {
tools: [{ name: "old", frameId: "child", inputSchema: {} }],
},
},
{
method: "Page.navigatedWithinDocument",
...scope,
params: { frameId: "child", url: origin + "/child#updated" },
},
{
method: "Page.frameNavigated",
...scope,
params: {
frame: {
id: "child",
parentId: "frame-main",
loaderId: "loader-B",
url: origin + "/child#updated",
},
},
},
];
},
});
trackBrowser(browser);
const result = await new CdpBrowserProvider().discoverWebMcpTools(
discoverWebMcpToolsInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!result.ok) throw result.error;
expect(result.value.tools.items).toEqual([]);
expect(result.value.completeness.excluded).not.toContainEqual(
expect.objectContaining({
section: "webmcp_tools",
reason: "invalid_protocol_value",
}),
);
});
it("retains, removes, or marks registrations unverified according to each committed loader", async () => {
const cases = [
{ id: "new-loader", loaderId: "loader-B" },
{ id: "same-loader", loaderId: "loader-A" },
{ id: "same-new-url", loaderId: "loader-A", path: "/other-same" },
{ id: "missing-loader" },
{ id: "empty-loader", loaderId: "" },
{ id: "missing-new-url", path: "/other-missing" },
{ id: "updated", loaderId: "loader-A", path: "/other-update" },
{ id: "removed", loaderId: "loader-A", path: "/other-remove" },
];
const { result, origin } = await discoverWithChildEvents(
cases.map(({ id }) => id),
(origin, sessionId) => [
{
method: "WebMCP.toolsAdded",
sessionId,
params: {
tools: cases.map(({ id }) => ({
name: "read",
frameId: id,
description: "Original",
inputSchema: {},
})),
},
},
...cases.map(({ id, loaderId, path }) => ({
method: "Page.frameNavigated",
sessionId,
params: {
frame: {
id,
parentId: "frame-main",
loaderId,
url: origin + (path ?? `/${id}`),
},
},
})),
{
method: "WebMCP.toolsAdded",
sessionId,
params: {
tools: [
{
name: "read",
frameId: "updated",
description: "Updated",
inputSchema: {},
},
],
},
},
{
method: "WebMCP.toolsRemoved",
sessionId,
params: { tools: [{ name: "read", frameId: "removed" }] },
},
],
);
if (!result.ok) throw result.error;
expect(
result.value.tools.items.toSorted((left, right) =>
left.frame_id.localeCompare(right.frame_id),
),
).toMatchObject([
{
name: "read",
frame_id: "empty-loader",
frame_url: `${origin}/empty-loader`,
description: "Original",
},
{
name: "read",
frame_id: "missing-loader",
frame_url: `${origin}/missing-loader`,
description: "Original",
},
{
name: "read",
frame_id: "missing-new-url",
frame_url: `${origin}/missing-new-url`,
description: "Original",
},
{
name: "read",
frame_id: "same-loader",
frame_url: `${origin}/same-loader`,
description: "Original",
},
{
name: "read",
frame_id: "same-new-url",
frame_url: `${origin}/same-new-url`,
description: "Original",
},
{
name: "read",
frame_id: "updated",
frame_url: `${origin}/other-update`,
description: "Updated",
},
]);
expect(result.value.completeness.attach_limited_sections).toContain(
"webmcp_tools",
);
expect(
result.value.limitations.filter((text) =>
text.startsWith("Document identity could not be established"),
),
).toEqual([
expect.stringContaining(
"frames empty-loader, missing-loader, missing-new-url:",
),
]);
});
// Without a subframe in the initial tree, discovery starts with full
// coverage, so only the unverified navigation can mark it limited. A frame
// first seen through a same-document navigation has no known loader, so a
// later commit cannot prove its tools belong to the new document.
it.each([
["no loader", {}, true, "committed"],
["a known loader", { loaderId: "loader-A" }, false, "committed"],
[
"a known loader after a first same-document event",
{ loaderId: "loader-B" },
true,
"within_document",
],
] as const)(
"limits coverage for a live subframe's tools after a navigation with %s",
async (_label, loader, limited, first) => {
const browser = await startFakeCdpBrowser({
webMcpTools: true,
eventsBeforeReply: ["WebMCP.enable"],
commandResult: ({ method }, origin) =>
method === "Page.getFrameTree"
? {
frameTree: {
frame: {
id: "frame-main",
loaderId: "loader-frame-main",
url: origin + "/app",
},
},
}
: undefined,
commandEvents: ({ method, sessionId }, origin) => {
if (method !== "WebMCP.enable") return undefined;
const scope = sessionId === undefined ? {} : { sessionId };
const child = (extra: Record<string, unknown>) => ({
method: "Page.frameNavigated",
...scope,
params: {
frame: {
id: "child",
parentId: "frame-main",
url: origin + "/child",
...extra,
},
},
});
return [
first === "committed"
? child({ loaderId: "loader-A" })
: {
method: "Page.navigatedWithinDocument",
...scope,
params: { frameId: "child", url: origin + "/child" },
},
{
method: "WebMCP.toolsAdded",
...scope,
params: {
tools: [{ name: "live", frameId: "child", inputSchema: {} }],
},
},
child(loader),
];
},
});
trackBrowser(browser);
const result = await new CdpBrowserProvider().discoverWebMcpTools(
discoverWebMcpToolsInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!result.ok) throw result.error;
expect(result.value.tools.items.map((tool) => tool.name)).toEqual(["live"]);
expect(
result.value.completeness.attach_limited_sections.includes(
"webmcp_tools",
),
).toBe(limited);
expect(
result.value.limitations.filter((limitation) =>
limitation.startsWith("Document identity could not be established"),
),
).toEqual(limited ? [expect.stringContaining("frames child:")] : []);
},
);