@narumitw/pi-chrome-devtools 0.52.3 → 0.53.1

package/dist/chunks/tools-6P7EUX37.js

@@ -0,0 +1,964 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
+import {
+  CdpClient,
+  getPage,
+  resolvePage,
+  textResult
+} from "./chunk-GTTYS5GT.js";
+import {
+  DEFAULT_TIMEOUT_MS,
+  beginWebMcpOperation,
+  currentWebMcpGeneration,
+  fetchDevToolsJson,
+  managedBrowserForOwner,
+  webMcpEnabled,
+  webMcpOperationIsCurrent,
+  webMcpSessionSignal
+} from "./chunk-SRT3UUIP.js";
+
+// src/webmcp/policy.ts
+import { createHash } from "node:crypto";
+import { stripVTControlCharacters } from "node:util";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  formatSize,
+  truncateHead
+} from "@earendil-works/pi-coding-agent";
+import { Check } from "typebox/value";
+var MAX_WEBMCP_TOOLS = 100;
+var MAX_SCHEMA_BYTES = 64 * 1024;
+var MAX_INPUT_BYTES = 64 * 1024;
+var MAX_OUTPUT_BYTES = 1024 * 1024;
+var MAX_JSON_DEPTH = 32;
+var MAX_JSON_NODES = 1e4;
+var MAX_OUTPUT_NODES = 1e5;
+var MAX_SCHEMA_VALIDATION_BRANCHES = 128;
+function normalizeWebMcpTool(tool, context) {
+  const name = boundedString(tool.name, "tool name", 512, { nonEmpty: true });
+  const description = boundedString(tool.description, "tool description", 16 * 1024);
+  const title = tool.title === void 0 ? void 0 : boundedString(tool.title, "tool title", 1024);
+  const documentId = boundedString(context.documentId, "document loader ID", 512, {
+    nonEmpty: true
+  });
+  const frameId = boundedString(tool.frameId, "frame ID", 512, { nonEmpty: true });
+  const frameOrigin2 = boundedString(context.frameOrigin, "frame origin", 2048, {
+    nonEmpty: true
+  });
+  const pageId = boundedString(context.pageId, "page ID", 512, { nonEmpty: true });
+  const pageUrl = boundedString(context.pageUrl, "page URL", 8192);
+  const inputSchema = tool.inputSchema ?? { type: "object", additionalProperties: true };
+  rejectRegexBearingSchema(inputSchema);
+  const canonicalSchema = canonicalJsonObject(inputSchema, {
+    label: "WebMCP input schema",
+    maxBytes: MAX_SCHEMA_BYTES,
+    maxDepth: MAX_JSON_DEPTH,
+    maxNodes: MAX_JSON_NODES
+  });
+  rejectExpensiveValidationSchema(canonicalSchema);
+  const annotations = canonicalAnnotations(tool.annotations);
+  const schemaDigest = createHash("sha256").update(canonicalStringify({ inputSchema: canonicalSchema, annotations })).digest("hex");
+  return {
+    annotations,
+    description,
+    documentId,
+    frameId,
+    frameOrigin: frameOrigin2,
+    inputSchema: canonicalSchema,
+    name,
+    pageId,
+    pageUrl,
+    schemaDigest,
+    sessionGeneration: context.sessionGeneration,
+    ...title === void 0 ? {} : { title }
+  };
+}
+function webMcpIdentity(tool) {
+  return {
+    sessionGeneration: tool.sessionGeneration,
+    pageId: tool.pageId,
+    documentId: tool.documentId,
+    frameId: tool.frameId,
+    frameOrigin: tool.frameOrigin,
+    name: tool.name,
+    schemaDigest: tool.schemaDigest
+  };
+}
+function requireMatchingWebMcpTool(tools, expected) {
+  const candidates = tools.filter(
+    (tool) => tool.frameId === expected.frameId && tool.name === expected.name
+  );
+  if (candidates.length === 0) throw new Error("The selected WebMCP tool is no longer available.");
+  if (candidates.length > 1) {
+    throw new Error("The selected WebMCP tool identity is ambiguous in its frame.");
+  }
+  const current = candidates[0];
+  if (!current) throw new Error("The selected WebMCP tool is no longer available.");
+  const mismatches = [
+    ["session generation", current.sessionGeneration, expected.sessionGeneration],
+    ["page", current.pageId, expected.pageId],
+    ["document", current.documentId, expected.documentId],
+    ["frame", current.frameId, expected.frameId],
+    ["frame origin", current.frameOrigin, expected.frameOrigin],
+    ["schema or annotations", current.schemaDigest, expected.schemaDigest]
+  ].flatMap(([label, actual, wanted]) => actual === wanted ? [] : [label]);
+  if (mismatches.length > 0) {
+    throw new Error(`The selected WebMCP tool became stale: ${mismatches.join(", ")} changed.`);
+  }
+  return current;
+}
+function normalizeWebMcpInput(input) {
+  return canonicalJsonObject(input, {
+    label: "WebMCP tool input",
+    maxBytes: MAX_INPUT_BYTES,
+    maxDepth: MAX_JSON_DEPTH,
+    maxNodes: MAX_JSON_NODES
+  });
+}
+function validateWebMcpInput(schema, input) {
+  const normalized = normalizeWebMcpInput(input);
+  let valid;
+  try {
+    valid = Check(schema, normalized);
+  } catch (error) {
+    throw new Error(
+      `The page provided a WebMCP input schema that cannot be validated: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!valid) throw new Error("WebMCP tool input does not match the current page-provided schema.");
+  return normalized;
+}
+function normalizeWebMcpOutput(output) {
+  return canonicalJsonValue(output, {
+    label: "WebMCP tool output",
+    maxBytes: MAX_OUTPUT_BYTES,
+    maxDepth: MAX_JSON_DEPTH * 2,
+    maxNodes: MAX_OUTPUT_NODES
+  });
+}
+function boundedWebMcpDiscovery(page, tools) {
+  const included = [];
+  for (const tool of tools) {
+    const candidate = [...included, tool];
+    const publication2 = boundedWebMcpJson({
+      page,
+      tools: candidate,
+      totalToolCount: tools.length,
+      truncated: candidate.length < tools.length
+    });
+    if (publication2.truncated) break;
+    included.push(tool);
+  }
+  const truncated = included.length < tools.length;
+  const publication = boundedWebMcpJson({
+    page,
+    tools: included,
+    totalToolCount: tools.length,
+    truncated
+  });
+  if (publication.truncated) {
+    throw new Error("WebMCP discovery metadata cannot fit within Pi's output limit.");
+  }
+  return { ...publication, included, truncated };
+}
+function boundedWebMcpJson(value) {
+  const serialized = sanitizeWebMcpDisplay(JSON.stringify(value, null, 2), Number.MAX_SAFE_INTEGER);
+  const result = truncateHead(serialized, {
+    maxBytes: Math.max(1, DEFAULT_MAX_BYTES - 256),
+    maxLines: Math.max(1, DEFAULT_MAX_LINES - 2)
+  });
+  if (!result.truncated) return { text: result.content, truncated: false };
+  const notice = `
+[WebMCP output truncated: ${result.outputLines}/${result.totalLines} lines, ${formatSize(result.outputBytes)}/${formatSize(result.totalBytes)}.]`;
+  return { text: `${result.content}${notice}`, truncated: true };
+}
+function webMcpConfirmationMessage(tool, input, managedProfile) {
+  const inputSummary = sanitizeWebMcpDisplay(JSON.stringify(input, null, 2), 2e3);
+  return [
+    managedProfile ? "This call uses the isolated browser profile managed by Pi." : "Warning: this call uses an attached browser profile that may contain everyday authenticated sessions and sensitive state.",
+    `Page: ${sanitizeWebMcpDisplay(tool.pageUrl, 4096)}`,
+    `Frame origin: ${sanitizeWebMcpDisplay(tool.frameOrigin, 2048)}`,
+    `Tool: ${sanitizeWebMcpDisplay(tool.name, 512)}`,
+    "Page annotations are untrusted and do not bypass this confirmation.",
+    "Input:",
+    inputSummary
+  ].join("\n");
+}
+function sanitizeWebMcpDisplay(value, maxCharacters = 5e4) {
+  const withoutBidi = stripVTControlCharacters(value).replace(
+    /[\u202a-\u202e\u2066-\u2069]/gu,
+    "\uFFFD"
+  );
+  const sanitized = Array.from(withoutBidi, (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const unsafeControl = codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+    return unsafeControl ? "\uFFFD" : character;
+  }).join("");
+  if (sanitized.length <= maxCharacters) return sanitized;
+  return `${sanitized.slice(0, Math.max(0, maxCharacters - 1))}\u2026`;
+}
+function webMcpErrorMessage(error) {
+  return sanitizeWebMcpDisplay(error instanceof Error ? error.message : String(error), 8192);
+}
+function canonicalAnnotations(value) {
+  if (!value) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter((entry) => typeof entry[1] === "boolean").sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function rejectRegexBearingSchema(schema) {
+  if (Array.isArray(schema)) {
+    for (const child of schema) rejectRegexBearingSchema(child);
+    return;
+  }
+  if (!isRecord(schema)) return;
+  if (schema.pattern !== void 0 || schema.patternProperties !== void 0) {
+    throw new Error(
+      "WebMCP input schemas with pattern or patternProperties are unsupported because page-controlled regular expressions cannot be evaluated safely."
+    );
+  }
+  for (const keyword of [
+    "additionalItems",
+    "additionalProperties",
+    "contains",
+    "else",
+    "if",
+    "items",
+    "not",
+    "propertyNames",
+    "then",
+    "unevaluatedItems",
+    "unevaluatedProperties"
+  ]) {
+    rejectRegexBearingSchema(schema[keyword]);
+  }
+  for (const keyword of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
+    if (Array.isArray(schema[keyword])) {
+      for (const child of schema[keyword]) rejectRegexBearingSchema(child);
+    }
+  }
+  for (const keyword of [
+    "$defs",
+    "definitions",
+    "dependencies",
+    "dependentSchemas",
+    "properties"
+  ]) {
+    if (!isRecord(schema[keyword])) continue;
+    for (const child of Object.values(schema[keyword])) rejectRegexBearingSchema(child);
+  }
+}
+function rejectExpensiveValidationSchema(schema) {
+  let branches = 0;
+  const countBranches = (count) => {
+    branches += count;
+    if (branches > MAX_SCHEMA_VALIDATION_BRANCHES) {
+      throw new Error(
+        `WebMCP input schema exceeds the validation branch limit of ${MAX_SCHEMA_VALIDATION_BRANCHES}.`
+      );
+    }
+  };
+  const visit = (candidate) => {
+    if (Array.isArray(candidate)) {
+      for (const child of candidate) visit(child);
+      return;
+    }
+    if (!isRecord(candidate)) return;
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+      const alternatives = candidate[keyword];
+      if (Array.isArray(alternatives)) countBranches(alternatives.length);
+    }
+    for (const keyword of ["dependencies", "dependentSchemas"]) {
+      const dependencies = candidate[keyword];
+      if (!isRecord(dependencies)) continue;
+      countBranches(Object.values(dependencies).filter(isRecord).length);
+    }
+    for (const child of Object.values(candidate)) visit(child);
+  };
+  visit(schema);
+}
+function canonicalJsonObject(value, limits) {
+  const canonical = canonicalJsonValue(value, limits);
+  if (!isRecord(canonical)) throw new Error(`${limits.label} must be a JSON object.`);
+  return canonical;
+}
+function canonicalJsonValue(value, limits) {
+  let nodes = 0;
+  const visit = (candidate, depth) => {
+    nodes += 1;
+    if (nodes > limits.maxNodes) {
+      throw new Error(`${limits.label} exceeds the ${limits.maxNodes} value limit.`);
+    }
+    if (depth > limits.maxDepth) {
+      throw new Error(`${limits.label} exceeds the depth limit of ${limits.maxDepth}.`);
+    }
+    if (candidate === null || typeof candidate === "string" || typeof candidate === "boolean") {
+      return candidate;
+    }
+    if (typeof candidate === "number") {
+      if (!Number.isFinite(candidate))
+        throw new Error(`${limits.label} contains a non-finite number.`);
+      return candidate;
+    }
+    if (Array.isArray(candidate)) return candidate.map((entry) => visit(entry, depth + 1));
+    if (isRecord(candidate)) {
+      return Object.fromEntries(
+        Object.keys(candidate).sort().map((key) => [key, visit(candidate[key], depth + 1)])
+      );
+    }
+    throw new Error(`${limits.label} contains a value that is not JSON-compatible.`);
+  };
+  const canonical = visit(value, 0);
+  const serialized = canonicalStringify(canonical);
+  const bytes = Buffer.byteLength(serialized, "utf8");
+  if (bytes > limits.maxBytes) {
+    throw new Error(
+      `${limits.label} exceeds ${formatSize(limits.maxBytes)} (${formatSize(bytes)}).`
+    );
+  }
+  return canonical;
+}
+function canonicalStringify(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) throw new Error("Value is not JSON-compatible.");
+  return serialized;
+}
+function boundedString(value, label, maxBytes, options = {}) {
+  if (options.nonEmpty && value.length === 0) throw new Error(`WebMCP ${label} must not be empty.`);
+  const bytes = Buffer.byteLength(value, "utf8");
+  if (bytes > maxBytes) throw new Error(`WebMCP ${label} exceeds ${formatSize(maxBytes)}.`);
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/webmcp/protocol.ts
+var REQUIRED_COMMANDS = ["enable", "disable", "invokeTool", "cancelInvocation"];
+var REQUIRED_EVENTS = ["toolsAdded", "toolsRemoved", "toolInvoked", "toolResponded"];
+var IDENTITY_WATCH_TIMEOUT_MS = DEFAULT_TIMEOUT_MS * 4;
+async function requireWebMcpDomain(signal, owner) {
+  signal.throwIfAborted();
+  const protocol = await fetchDevToolsJson(
+    "/json/protocol",
+    { signal },
+    owner
+  );
+  signal.throwIfAborted();
+  const domain = findDomain(protocol.domains, "WebMCP");
+  if (!domain || !hasNamedEntries(domain.commands, REQUIRED_COMMANDS) || !hasNamedEntries(domain.events, REQUIRED_EVENTS)) {
+    throw new Error(
+      "This browser does not expose the experimental Chrome DevTools WebMCP domain. Use a compatible Chrome build and enable the website's required Origin Trial or WebMCP testing feature."
+    );
+  }
+}
+async function connectWebMcpPage(page, signal) {
+  if (!page.webSocketDebuggerUrl) throw new Error(`Page has no webSocketDebuggerUrl: ${page.id}`);
+  return CdpClient.connect(page.webSocketDebuggerUrl, {
+    signal: withDeadline(signal)
+  });
+}
+async function cancelWebMcpInvocation(page, invocationId) {
+  const cleanupSignal = AbortSignal.timeout(1e3);
+  const client = await connectWebMcpPage(page, cleanupSignal);
+  try {
+    await client.send("WebMCP.cancelInvocation", { invocationId }, { signal: cleanupSignal });
+  } finally {
+    client.close();
+  }
+}
+async function enableWebMcpIdentityTracking(client, signal) {
+  await client.send("Page.enable", {}, { signal, timeoutMs: DEFAULT_TIMEOUT_MS });
+}
+async function enableWebMcp(client, signal) {
+  const eventController = new AbortController();
+  const eventSignal = AbortSignal.any([signal, eventController.signal]);
+  const toolsAdded = client.waitForEvent(
+    "WebMCP.toolsAdded",
+    (value) => {
+      const parsed = parseToolsAdded(value);
+      if (!parsed) throw new Error("Chrome sent a malformed WebMCP.toolsAdded event");
+      return true;
+    },
+    { signal: eventSignal, timeoutMs: DEFAULT_TIMEOUT_MS }
+  ).then(
+    (value) => ({ ok: true, value }),
+    (error) => ({ error, ok: false })
+  );
+  try {
+    await client.send("WebMCP.enable", {}, { signal, timeoutMs: DEFAULT_TIMEOUT_MS });
+  } catch (error) {
+    eventController.abort();
+    await toolsAdded;
+    throw error;
+  }
+  try {
+    const result = await toolsAdded;
+    if (!result.ok) throw result.error;
+    const parsed = parseToolsAdded(result.value);
+    if (!parsed) throw new Error("Chrome sent a malformed WebMCP.toolsAdded event");
+    return parsed.tools;
+  } finally {
+    eventController.abort();
+  }
+}
+async function disableWebMcp(client) {
+  try {
+    await client.send("WebMCP.disable", {}, { timeoutMs: 1e3 });
+  } catch {
+  }
+}
+async function readWebMcpFrames(client, signal) {
+  const result = await client.send(
+    "Page.getFrameTree",
+    {},
+    {
+      signal,
+      timeoutMs: DEFAULT_TIMEOUT_MS
+    }
+  );
+  const frames = parseFrameTree(result);
+  if (!frames) throw new Error("Chrome sent a malformed Page.getFrameTree response");
+  return frames;
+}
+function watchWebMcpIdentity(client, expected, signal) {
+  const stopController = new AbortController();
+  const staleController = new AbortController();
+  const watchSignal = AbortSignal.any([signal, stopController.signal]);
+  const options = { signal: watchSignal, timeoutMs: IDENTITY_WATCH_TIMEOUT_MS };
+  const settleWatch = (create) => {
+    let watch;
+    try {
+      watch = create();
+    } catch (error) {
+      watch = Promise.reject(error);
+    }
+    return watch.then(
+      () => {
+        if (staleController.signal.aborted) return;
+        staleController.abort(
+          new DOMException(
+            "The selected WebMCP document or tool changed before Chrome completed the invocation boundary.",
+            "AbortError"
+          )
+        );
+      },
+      (error) => {
+        if (stopController.signal.aborted || signal.aborted || staleController.signal.aborted) {
+          return;
+        }
+        staleController.abort(error);
+      }
+    );
+  };
+  const settledWatches = [
+    settleWatch(
+      () => client.waitForEvent(
+        "Page.frameNavigated",
+        (value) => frameNavigationChangesIdentity(value, expected.frameId, expected.documentId),
+        options
+      )
+    ),
+    settleWatch(
+      () => client.waitForEvent(
+        "WebMCP.toolsAdded",
+        (value) => toolChangeMatchesIdentity(value, expected),
+        options
+      )
+    ),
+    settleWatch(
+      () => client.waitForEvent(
+        "WebMCP.toolsRemoved",
+        (value) => toolChangeMatchesIdentity(value, expected),
+        options
+      )
+    )
+  ];
+  return {
+    signal: AbortSignal.any([signal, staleController.signal]),
+    async dispose() {
+      stopController.abort();
+      await Promise.allSettled(settledWatches);
+    }
+  };
+}
+async function invokeWebMcpTool(client, request, signal, fallbackCancel) {
+  signal.throwIfAborted();
+  let invocationId;
+  let cancellation;
+  const cancel = () => {
+    if (!invocationId || cancellation) return;
+    const invocationToCancel = invocationId;
+    const recoverCancellation = () => fallbackCancel ? fallbackCancel(invocationToCancel).catch(() => void 0) : Promise.resolve();
+    try {
+      cancellation = client.send("WebMCP.cancelInvocation", { invocationId }, { timeoutMs: 1e3 }).catch(recoverCancellation);
+    } catch {
+      cancellation = recoverCancellation();
+    }
+  };
+  const onAbort = () => cancel();
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    let response;
+    try {
+      response = await client.send(
+        "WebMCP.invokeTool",
+        { frameId: request.frameId, toolName: request.toolName, input: request.input },
+        { timeoutMs: DEFAULT_TIMEOUT_MS }
+      );
+    } catch (error) {
+      if (signal.aborted) throw signal.reason;
+      throw error;
+    }
+    invocationId = parseInvocationId(response);
+    if (!invocationId) throw new Error("Chrome sent a malformed WebMCP.invokeTool response");
+    if (signal.aborted) cancel();
+    let event;
+    try {
+      event = await client.waitForEvent(
+        "WebMCP.toolResponded",
+        (value) => {
+          const parsed = parseToolResponded(value);
+          if (!parsed) throw new Error("Chrome sent a malformed WebMCP.toolResponded event");
+          return parsed.invocationId === invocationId;
+        },
+        { timeoutMs: DEFAULT_TIMEOUT_MS }
+      );
+    } catch (error) {
+      cancel();
+      await cancellation;
+      if (signal.aborted) throw signal.reason;
+      throw error;
+    }
+    if (signal.aborted) throw signal.reason;
+    return event;
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    await cancellation;
+  }
+}
+function findDomain(value, name) {
+  if (!Array.isArray(value)) return void 0;
+  return value.find(
+    (candidate) => isRecord2(candidate) && candidate.domain === name
+  );
+}
+function hasNamedEntries(value, required) {
+  if (!Array.isArray(value)) return false;
+  const names = new Set(
+    value.flatMap(
+      (candidate) => isRecord2(candidate) && typeof candidate.name === "string" ? [candidate.name] : []
+    )
+  );
+  return required.every((name) => names.has(name));
+}
+function parseToolsAdded(value) {
+  if (!isRecord2(value) || !Array.isArray(value.tools)) return void 0;
+  const tools = [];
+  for (const candidate of value.tools) {
+    const tool = parseTool(candidate);
+    if (!tool) return void 0;
+    tools.push(tool);
+  }
+  return { tools };
+}
+function parseTool(value) {
+  if (!isRecord2(value) || typeof value.name !== "string" || typeof value.description !== "string" || typeof value.frameId !== "string" || value.inputSchema !== void 0 && !isRecord2(value.inputSchema) || value.title !== void 0 && typeof value.title !== "string" || value.backendNodeId !== void 0 && typeof value.backendNodeId !== "number") {
+    return void 0;
+  }
+  const annotations = parseAnnotations(value.annotations);
+  if (value.annotations !== void 0 && !annotations) return void 0;
+  return {
+    name: value.name,
+    description: value.description,
+    frameId: value.frameId,
+    ...value.title === void 0 ? {} : { title: value.title },
+    ...value.inputSchema === void 0 ? {} : { inputSchema: value.inputSchema },
+    ...annotations ? { annotations } : {},
+    ...value.backendNodeId === void 0 ? {} : { backendNodeId: value.backendNodeId }
+  };
+}
+function parseAnnotations(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord2(value)) return void 0;
+  const annotations = {};
+  for (const key of ["autosubmit", "consequential", "readOnly", "untrustedContent"]) {
+    if (value[key] === void 0) continue;
+    if (typeof value[key] !== "boolean") return void 0;
+    annotations[key] = value[key];
+  }
+  return annotations;
+}
+function parseFrameTree(value) {
+  if (!isRecord2(value) || !isRecord2(value.frameTree)) return void 0;
+  const frames = [];
+  const visit = (tree) => {
+    if (!isRecord2(tree) || !isRecord2(tree.frame)) return false;
+    const frame = tree.frame;
+    if (typeof frame.id !== "string" || typeof frame.loaderId !== "string" || typeof frame.url !== "string" || frame.securityOrigin !== void 0 && typeof frame.securityOrigin !== "string") {
+      return false;
+    }
+    frames.push({
+      id: frame.id,
+      loaderId: frame.loaderId,
+      url: frame.url,
+      ...frame.securityOrigin === void 0 ? {} : { securityOrigin: frame.securityOrigin }
+    });
+    if (tree.childFrames === void 0) return true;
+    return Array.isArray(tree.childFrames) && tree.childFrames.every(visit);
+  };
+  return visit(value.frameTree) ? frames : void 0;
+}
+function frameNavigationChangesIdentity(value, frameId, documentId) {
+  if (!isRecord2(value) || !isRecord2(value.frame)) {
+    throw new Error("Chrome sent a malformed Page.frameNavigated event");
+  }
+  if (typeof value.frame.id !== "string" || typeof value.frame.loaderId !== "string") {
+    throw new Error("Chrome sent a malformed Page.frameNavigated event");
+  }
+  return value.frame.id === frameId && value.frame.loaderId !== documentId;
+}
+function toolChangeMatchesIdentity(value, expected) {
+  if (!isRecord2(value) || !Array.isArray(value.tools)) {
+    throw new Error("Chrome sent a malformed WebMCP tool-change event");
+  }
+  return value.tools.some((tool) => {
+    if (!isRecord2(tool) || typeof tool.frameId !== "string" || typeof tool.name !== "string") {
+      throw new Error("Chrome sent a malformed WebMCP tool-change event");
+    }
+    return tool.frameId === expected.frameId && tool.name === expected.toolName;
+  });
+}
+function parseInvocationId(value) {
+  return isRecord2(value) && typeof value.invocationId === "string" ? value.invocationId : void 0;
+}
+function parseToolResponded(value) {
+  if (!isRecord2(value) || typeof value.invocationId !== "string" || !["Canceled", "Completed", "Error"].includes(value.status) || value.errorText !== void 0 && typeof value.errorText !== "string") {
+    return void 0;
+  }
+  return {
+    invocationId: value.invocationId,
+    status: value.status,
+    ...value.output === void 0 ? {} : { output: value.output },
+    ...value.errorText === void 0 ? {} : { errorText: value.errorText },
+    ...value.exception === void 0 ? {} : { exception: value.exception }
+  };
+}
+function withDeadline(signal) {
+  return AbortSignal.any([signal, AbortSignal.timeout(DEFAULT_TIMEOUT_MS)]);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/webmcp/discovery.ts
+async function discoverWebMcpTools(page, operation) {
+  assertOperationCurrent(operation);
+  await requireWebMcpDomain(operation.signal, operation.owner);
+  assertOperationCurrent(operation);
+  const client = await connectWebMcpPage(page, operation.signal);
+  try {
+    const tools = await readInventory(client, page, operation);
+    await requireStablePage(client, page, tools, operation);
+    return tools;
+  } finally {
+    await disableWebMcp(client);
+    client.close();
+  }
+}
+async function invokeDiscoveredWebMcpTool(page, expected, input, operation) {
+  assertOperationCurrent(operation);
+  await requireWebMcpDomain(operation.signal, operation.owner);
+  assertOperationCurrent(operation);
+  const client = await connectWebMcpPage(page, operation.signal);
+  try {
+    await enableWebMcpIdentityTracking(client, operation.signal);
+    assertOperationCurrent(operation);
+    const tools = await readInventory(client, page, operation);
+    const tool = requireMatchingWebMcpTool(tools, expected);
+    const identityWatch = watchWebMcpIdentity(
+      client,
+      { documentId: tool.documentId, frameId: tool.frameId, toolName: tool.name },
+      operation.signal
+    );
+    const guardedOperation = { ...operation, signal: identityWatch.signal };
+    try {
+      await requireStablePage(client, page, [tool], guardedOperation);
+      assertOperationCurrent(guardedOperation);
+      const response = await invokeWebMcpTool(
+        client,
+        { frameId: tool.frameId, toolName: tool.name, input },
+        guardedOperation.signal,
+        (invocationId) => cancelWebMcpInvocation(page, invocationId)
+      );
+      assertOperationCurrent(guardedOperation);
+      if (response.status === "Canceled") {
+        throw new DOMException("Chrome canceled the WebMCP tool invocation.", "AbortError");
+      }
+      if (response.status === "Error") {
+        throw new Error(
+          `WebMCP tool failed: ${webMcpErrorMessage(response.errorText ?? remoteExceptionText(response.exception))}`
+        );
+      }
+      return {
+        invocationId: response.invocationId,
+        output: normalizeWebMcpOutput(response.output ?? null),
+        tool
+      };
+    } finally {
+      await identityWatch.dispose();
+    }
+  } finally {
+    await disableWebMcp(client);
+    client.close();
+  }
+}
+async function readInventory(client, page, operation) {
+  const framesBefore = await readWebMcpFrames(client, operation.signal);
+  assertOperationCurrent(operation);
+  const protocolTools = await enableWebMcp(client, operation.signal);
+  assertOperationCurrent(operation);
+  if (protocolTools.length > MAX_WEBMCP_TOOLS) {
+    throw new Error(`WebMCP page exposes more than ${MAX_WEBMCP_TOOLS} tools.`);
+  }
+  const framesAfter = await readWebMcpFrames(client, operation.signal);
+  assertOperationCurrent(operation);
+  requireStableInventoryDocuments(protocolTools, framesBefore, framesAfter);
+  return normalizeInventory(protocolTools, framesAfter, page, operation);
+}
+function requireStableInventoryDocuments(tools, before, after) {
+  const beforeLoaders = new Map(before.map((frame) => [frame.id, frame.loaderId]));
+  const afterLoaders = new Map(after.map((frame) => [frame.id, frame.loaderId]));
+  for (const frameId of new Set(tools.map((tool) => tool.frameId))) {
+    const beforeLoader = beforeLoaders.get(frameId);
+    const afterLoader = afterLoaders.get(frameId);
+    if (!beforeLoader || !afterLoader || beforeLoader !== afterLoader) {
+      throw new Error(
+        "A WebMCP frame document changed while Chrome was publishing its tool inventory."
+      );
+    }
+  }
+}
+function normalizeInventory(protocolTools, frames, page, operation) {
+  const frameDocuments = new Map(
+    frames.map((frame) => [frame.id, { documentId: frame.loaderId, origin: frameOrigin(frame) }])
+  );
+  const tools = protocolTools.map((tool) => {
+    const frame = frameDocuments.get(tool.frameId);
+    if (!frame) {
+      throw new Error(`WebMCP tool ${webMcpErrorMessage(tool.name)} belongs to an unknown frame.`);
+    }
+    return normalizeWebMcpTool(tool, {
+      documentId: frame.documentId,
+      frameOrigin: frame.origin,
+      pageId: page.id,
+      pageUrl: page.url,
+      sessionGeneration: generationToken(operation)
+    });
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    const key = `${tool.frameId}\0${tool.name}`;
+    if (identities.has(key)) {
+      throw new Error(
+        `WebMCP tool identity is duplicated: ${webMcpErrorMessage(tool.name)} in frame ${webMcpErrorMessage(tool.frameId)}.`
+      );
+    }
+    identities.add(key);
+  }
+  return tools;
+}
+async function requireStablePage(client, page, tools, operation) {
+  const current = await getPage(page.id, {
+    sessionOwner: operation.owner,
+    signal: operation.signal
+  });
+  assertOperationCurrent(operation);
+  if (current.url !== page.url || current.webSocketDebuggerUrl !== page.webSocketDebuggerUrl || current.type !== page.type) {
+    throw new Error("The Chrome page navigated or was replaced during the WebMCP operation.");
+  }
+  const finalFrames = await readWebMcpFrames(client, operation.signal);
+  assertOperationCurrent(operation);
+  const finalDocuments = new Map(finalFrames.map((frame) => [frame.id, frame.loaderId]));
+  for (const tool of tools) {
+    if (finalDocuments.get(tool.frameId) !== tool.documentId) {
+      throw new Error("A WebMCP frame document changed during the final page identity check.");
+    }
+  }
+}
+function assertOperationCurrent(operation) {
+  operation.signal.throwIfAborted();
+  if (!webMcpOperationIsCurrent(operation)) {
+    throw new DOMException("The WebMCP operation became stale.", "AbortError");
+  }
+}
+function generationToken(operation) {
+  return `${operation.sessionGeneration}:${operation.webMcpGeneration}`;
+}
+function frameOrigin(frame) {
+  if (frame.securityOrigin && frame.securityOrigin !== "://") return frame.securityOrigin;
+  try {
+    return new URL(frame.url).origin;
+  } catch {
+    throw new Error(
+      `Chrome returned an invalid WebMCP frame URL: ${webMcpErrorMessage(frame.url)}`
+    );
+  }
+}
+function remoteExceptionText(value) {
+  if (typeof value === "object" && value !== null) {
+    const exception = value;
+    if (typeof exception.description === "string") return exception.description;
+    if (typeof exception.value === "string") return exception.value;
+  }
+  return "The page reported an unknown tool error.";
+}
+
+// src/webmcp/tools.ts
+async function executeWebMcpListTool(params, toolSignal, ctx) {
+  try {
+    requireWebMcpEnabled(ctx.sessionManager);
+    const preflightGeneration = currentWebMcpGeneration(ctx.sessionManager);
+    const preflightSignal = combinedSignal(ctx.sessionManager, toolSignal);
+    preflightSignal.throwIfAborted();
+    const page = await resolvePage(params.pageId, {
+      sessionOwner: ctx.sessionManager,
+      signal: preflightSignal
+    });
+    preflightSignal.throwIfAborted();
+    requireCurrentPreflight(ctx.sessionManager, preflightGeneration);
+    const operation = beginWebMcpOperation(ctx.sessionManager, toolSignal);
+    try {
+      const tools = await discoverWebMcpTools(page, operation);
+      assertCurrent(operation);
+      const published = boundedWebMcpDiscovery(
+        { id: page.id, title: page.title, url: page.url },
+        tools
+      );
+      return textResult(published.text, {
+        page: { id: page.id, url: page.url },
+        toolCount: tools.length,
+        publishedToolCount: published.included.length,
+        truncated: published.truncated,
+        identities: published.included.map(webMcpIdentity)
+      });
+    } finally {
+      operation.dispose();
+    }
+  } catch (error) {
+    throw safeToolError(error);
+  }
+}
+async function executeWebMcpCallTool(params, toolSignal, ctx) {
+  try {
+    requireWebMcpEnabled(ctx.sessionManager);
+    if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
+      throw new Error(
+        "chrome_devtools_webmcp_call_tool requires observable confirmation in TUI or RPC mode and is unavailable in print or JSON mode."
+      );
+    }
+    const input = normalizeWebMcpInput(params.input);
+    const expected = expectedIdentity(params);
+    const preflightGeneration = currentWebMcpGeneration(ctx.sessionManager);
+    const preflightSignal = combinedSignal(ctx.sessionManager, toolSignal);
+    preflightSignal.throwIfAborted();
+    const page = await getPage(params.pageId, {
+      sessionOwner: ctx.sessionManager,
+      signal: preflightSignal
+    });
+    preflightSignal.throwIfAborted();
+    requireCurrentPreflight(ctx.sessionManager, preflightGeneration);
+    const operation = beginWebMcpOperation(ctx.sessionManager, toolSignal);
+    try {
+      const discovered = await discoverWebMcpTools(page, operation);
+      const current = requireMatchingWebMcpTool(discovered, expected);
+      const validatedInput = validateWebMcpInput(current.inputSchema, input);
+      assertCurrent(operation);
+      const confirmed = await ctx.ui.confirm(
+        `Allow WebMCP tool: ${sanitizeWebMcpDisplay(current.name, 256)}`,
+        webMcpConfirmationMessage(current, validatedInput, usesManagedProfile(ctx.sessionManager)),
+        { signal: operation.signal }
+      );
+      assertCurrent(operation);
+      if (!confirmed) {
+        throw new DOMException("WebMCP tool call cancelled by the user.", "AbortError");
+      }
+      const invocation = await invokeDiscoveredWebMcpTool(
+        page,
+        expected,
+        validatedInput,
+        operation
+      );
+      assertCurrent(operation);
+      const published = boundedWebMcpJson({
+        status: "completed",
+        tool: webMcpIdentity(invocation.tool),
+        output: invocation.output
+      });
+      return textResult(published.text, {
+        invocationId: invocation.invocationId,
+        tool: webMcpIdentity(invocation.tool),
+        truncated: published.truncated,
+        output: published.text
+      });
+    } finally {
+      operation.dispose();
+    }
+  } catch (error) {
+    throw safeToolError(error);
+  }
+}
+function requireWebMcpEnabled(owner) {
+  if (!webMcpEnabled(owner)) {
+    throw new Error(
+      "WebMCP is disabled. Enable the experimental user setting in /chrome-devtools settings, then make the WebMCP gateway tools available."
+    );
+  }
+}
+function combinedSignal(owner, toolSignal) {
+  const sessionSignal = webMcpSessionSignal(owner);
+  return toolSignal ? AbortSignal.any([toolSignal, sessionSignal]) : sessionSignal;
+}
+function requireCurrentPreflight(owner, generation) {
+  requireWebMcpEnabled(owner);
+  if (generation !== currentWebMcpGeneration(owner)) {
+    throw new DOMException(
+      "The WebMCP operation became stale during page resolution.",
+      "AbortError"
+    );
+  }
+}
+function expectedIdentity(params) {
+  return {
+    sessionGeneration: params.sessionGeneration,
+    pageId: params.pageId,
+    documentId: params.documentId,
+    frameId: params.frameId,
+    frameOrigin: params.frameOrigin,
+    name: params.toolName,
+    schemaDigest: params.schemaDigest
+  };
+}
+function assertCurrent(operation) {
+  operation.signal.throwIfAborted();
+  if (!webMcpOperationIsCurrent(operation)) {
+    throw new DOMException("The WebMCP operation became stale.", "AbortError");
+  }
+}
+function usesManagedProfile(owner) {
+  const managedBrowser = managedBrowserForOwner(owner);
+  return Boolean(managedBrowser?.ready && !managedBrowser.exited);
+}
+function safeToolError(error) {
+  const message = webMcpErrorMessage(error);
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return new DOMException(message, "AbortError");
+  }
+  return new Error(message);
+}
+export {
+  executeWebMcpCallTool,
+  executeWebMcpListTool
+};
+//# sourceMappingURL=tools-6P7EUX37.js.map