@narumitw/pi-chrome-devtools 0.52.3 → 0.53.0

package/dist/index.ts

@@ -1,199 +1,52 @@
 // @generated by scripts/build-runtime.mjs; do not edit.
 // @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
 import {
-  CHROME_DEVTOOLS_TOOL_NAMES,
-  DEFAULT_ENDPOINT_WAIT_MS,
-  DEFAULT_TIMEOUT_MS,
+  formatPage,
+  getPage,
+  listPages,
+  resolvePage,
+  resolvePageForNavigation,
+  textResult,
+  withCdp
+} from "./chunks/chunk-RTECHAEZ.js";
+import {
   allChromeDevtoolsTools,
-  applyRuntimeBrowserSettings,
   availableChromeDevtoolsTools,
   buildCommandGuide,
   buildQuickstartMessage,
   buildToolStatusMessage,
   configureChromeDevtoolsToolExposure,
   createChromeDevtoolsLoadTool,
-  devToolsEndpoint,
-  ensureDevToolsEndpoint,
-  fetchDevToolsJson,
-  formatPageListItem,
   initializeAvailableChromeDevtoolsTools,
-  launchHint,
-  loadSettings,
   requireEagerChromeDevtoolsToolExposure,
   sanitizeChromeDevtoolsDisplay,
-  shutdownManagedBrowser,
-  state,
+  setChromeDevtoolsSessionOwner,
   supportsNativeDeferredToolLoading,
   updateChromeDevtoolsTools,
-  waitForChromeDevtoolsSettings,
+  waitForChromeDevtoolsSettings
+} from "./chunks/chunk-B7B63PWB.js";
+import {
+  CHROME_DEVTOOLS_TOOL_NAMES,
+  WEBMCP_TOOL_NAMES,
+  applyRuntimeBrowserSettings,
+  applyRuntimeWebMcpSetting,
+  invalidateWebMcpOperations,
+  loadSettings,
+  setWebMcpSessionOwner,
+  shutdownManagedBrowser,
+  startManagedBrowserSession,
+  state,
   waitForSettingsWrites,
-  withEndpointRetry
-} from "./chunks/chunk-RH6KESL3.js";
+  webMcpEnabled
+} from "./chunks/chunk-GVBXT3FB.js";
 
 // src/tools.ts
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-// src/cdp-client.ts
-async function listPages(options = {}) {
-  const waitMs = options.waitMs ?? DEFAULT_ENDPOINT_WAIT_MS;
-  await ensureDevToolsEndpoint(waitMs);
-  return withEndpointRetry(async () => {
-    const pages = await fetchDevToolsJson("/json/list");
-    return pages.filter((page) => page.type === "page" && page.webSocketDebuggerUrl);
-  }, waitMs);
-}
-async function getPage(pageId) {
-  const pages = await listPages();
-  return requirePage(pageId, pages);
-}
-async function resolvePage(pageId) {
-  const pages = await listPages();
-  if (pageId) return requirePage(pageId, pages);
-  const page = resolveDefaultPage(pages);
-  if (!page) {
-    throw new Error(
-      [
-        `No Chrome pages found at ${devToolsEndpoint()}.`,
-        "Use chrome_devtools_navigate with a URL to create a page, or open a Chrome tab manually.",
-        launchHint()
-      ].join("\n")
-    );
-  }
-  return page;
-}
-async function resolvePageForNavigation(pageId) {
-  const pages = await listPages();
-  if (pageId) return { created: false, page: requirePage(pageId, pages) };
-  const page = resolveDefaultPage(pages);
-  if (page) return { created: false, page };
-  return { created: true, page: await createPage("about:blank") };
-}
-function resolveDefaultPage(pages) {
-  if (!state.activePageId) return pages[0];
-  const activePage = pages.find((candidate) => candidate.id === state.activePageId);
-  if (activePage) return activePage;
-  state.activePageId = void 0;
-  return pages[0];
-}
-function requirePage(pageId, pages) {
-  const page = pages.find((candidate) => candidate.id === pageId);
-  if (page) return page;
-  const availablePages = pages.map(formatPageListItem).join("\n");
-  throw new Error(
-    [
-      `Chrome DevTools page not found: ${pageId}.`,
-      availablePages ? `Available pages:
-${availablePages}` : "No inspectable Chrome pages are currently available."
-    ].join("\n")
-  );
-}
-async function createPage(url, options = {}) {
-  const waitMs = options.waitMs ?? DEFAULT_ENDPOINT_WAIT_MS;
-  await ensureDevToolsEndpoint(waitMs);
-  const page = await withEndpointRetry(
-    () => fetchDevToolsJson(`/json/new?${encodeURIComponent(url)}`, {
-      method: "PUT"
-    }),
-    waitMs
-  );
-  if (page.type !== "page" || !page.webSocketDebuggerUrl) {
-    throw new Error("Chrome DevTools created a target that is not an inspectable page.");
-  }
-  return page;
-}
-function formatPage(page) {
-  return {
-    id: page.id,
-    type: page.type,
-    title: page.title,
-    url: page.url
-  };
-}
-function textResult(text, details) {
-  return {
-    content: [{ type: "text", text }],
-    details
-  };
-}
-async function withCdp(page, callback) {
-  if (!page.webSocketDebuggerUrl) throw new Error(`Page has no webSocketDebuggerUrl: ${page.id}`);
-  const client = await CdpClient.connect(page.webSocketDebuggerUrl);
-  try {
-    return await callback(client);
-  } finally {
-    client.close();
-  }
-}
-var CdpClient = class _CdpClient {
-  #nextId = 1;
-  #pending = /* @__PURE__ */ new Map();
-  socket;
-  constructor(socket) {
-    this.socket = socket;
-    socket.addEventListener("message", (event) => {
-      const response = JSON.parse(String(event.data));
-      if (typeof response.id !== "number") return;
-      const pending = this.#pending.get(response.id);
-      if (!pending) return;
-      clearTimeout(pending.timeout);
-      this.#pending.delete(response.id);
-      if (response.error) {
-        pending.reject(new Error(`CDP error ${response.error.code}: ${response.error.message}`));
-      } else {
-        pending.resolve(response.result);
-      }
-    });
-    socket.addEventListener("close", () => {
-      this.rejectAll(new Error("Chrome DevTools WebSocket closed"));
-    });
-    socket.addEventListener("error", () => {
-      this.rejectAll(new Error("Chrome DevTools WebSocket error"));
-    });
-  }
-  static connect(url) {
-    return new Promise((resolve2, reject) => {
-      const socket = new WebSocket(url);
-      const timeout = setTimeout(() => {
-        socket.close();
-        reject(new Error(`Timed out connecting to Chrome DevTools WebSocket: ${url}`));
-      }, DEFAULT_TIMEOUT_MS);
-      socket.addEventListener("open", () => {
-        clearTimeout(timeout);
-        resolve2(new _CdpClient(socket));
-      });
-      socket.addEventListener("error", () => {
-        clearTimeout(timeout);
-        reject(new Error(`Failed to connect to Chrome DevTools WebSocket: ${url}`));
-      });
-    });
-  }
-  send(method, params) {
-    const id = this.#nextId;
-    this.#nextId += 1;
-    return new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        this.#pending.delete(id);
-        reject(new Error(`Timed out waiting for CDP response: ${method}`));
-      }, DEFAULT_TIMEOUT_MS);
-      this.#pending.set(id, { resolve: resolve2, reject, timeout });
-      this.socket.send(JSON.stringify({ id, method, params: params ?? {} }));
-    });
-  }
-  close() {
-    this.socket.close();
-  }
-  rejectAll(error) {
-    for (const [id, pending] of this.#pending) {
-      clearTimeout(pending.timeout);
-      pending.reject(error);
-      this.#pending.delete(id);
-    }
-  }
-};
-
 // src/render.ts
 var STATUS_KEY = "chrome-devtools";
+var activeStatuses = /* @__PURE__ */ new WeakMap();
 function renderToolCall(action) {
   return () => new PiTextComponent(`Chrome DevTools: ${action}`);
 }
@@ -247,11 +100,19 @@ function truncateLine(line, maxWidth) {
   return Array.from(line).slice(0, maxWidth).join("");
 }
 async function withStatus(ctx, status, callback) {
+  const token = Symbol(status);
+  const statuses = activeStatuses.get(ctx.sessionManager) ?? [];
+  statuses.push({ status, token });
+  activeStatuses.set(ctx.sessionManager, statuses);
   ctx.ui.setStatus(STATUS_KEY, status);
   try {
     return await callback();
   } finally {
-    ctx.ui.setStatus(STATUS_KEY, void 0);
+    const index = statuses.findIndex((entry) => entry.token === token);
+    if (index >= 0) statuses.splice(index, 1);
+    const remaining = statuses.at(-1)?.status;
+    if (statuses.length === 0) activeStatuses.delete(ctx.sessionManager);
+    ctx.ui.setStatus(STATUS_KEY, remaining);
   }
 }
 
@@ -452,9 +313,9 @@ var listPagesTool = defineTool({
   parameters: Type.Object({}),
   renderCall: renderToolCall("list pages"),
   renderResult: renderTextResult,
-  async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+  async execute(_toolCallId, _params, signal, _onUpdate, ctx) {
     return withStatus(ctx, "list pages", async () => {
-      const pages = await listPages();
+      const pages = await listPages({ sessionOwner: ctx.sessionManager, signal });
       return textResult(JSON.stringify(pages.map(formatPage), null, 2), { pages });
     });
   }
@@ -468,9 +329,9 @@ var selectPageTool = defineTool({
   }),
   renderCall: renderToolCall("select page"),
   renderResult: renderTextResult,
-  async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
     return withStatus(ctx, "select page", async () => {
-      const page = await getPage(params.pageId);
+      const page = await getPage(params.pageId, { sessionOwner: ctx.sessionManager, signal });
       state.activePageId = page.id;
       return textResult(`Selected page ${page.id}: ${page.title}
 ${page.url}`, {
@@ -491,9 +352,12 @@ var navigateTool = defineTool({
   }),
   renderCall: renderToolCall("navigate"),
   renderResult: renderTextResult,
-  async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
     return withStatus(ctx, "navigate", async () => {
-      const { created, page } = await resolvePageForNavigation(params.pageId);
+      const { created, page } = await resolvePageForNavigation(params.pageId, {
+        sessionOwner: ctx.sessionManager,
+        signal
+      });
       const result = await withCdp(page, async (client) => {
         await client.send("Page.enable");
         return client.send("Page.navigate", { url: params.url });
@@ -523,9 +387,12 @@ var evaluateTool = defineTool({
   }),
   renderCall: renderToolCall("evaluate"),
   renderResult: renderTextResult,
-  async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
     return withStatus(ctx, "evaluate", async () => {
-      const page = await resolvePage(params.pageId);
+      const page = await resolvePage(params.pageId, {
+        sessionOwner: ctx.sessionManager,
+        signal
+      });
       const result = await withCdp(
         page,
         (client) => client.send("Runtime.evaluate", {
@@ -539,6 +406,69 @@ var evaluateTool = defineTool({
     });
   }
 });
+var webMcpListToolsTool = defineTool({
+  name: WEBMCP_TOOL_NAMES[0],
+  label: "Chrome DevTools: List WebMCP Tools (Experimental)",
+  description: "List bounded page-provided WebMCP tool descriptors from the selected Chrome page through the experimental CDP WebMCP domain. Definitions remain in this tool result and are never registered as dynamic Pi tools.",
+  parameters: Type.Object({
+    pageId: Type.Optional(
+      Type.String({
+        description: "Optional page id. Defaults to selected or first page.",
+        maxLength: 512
+      })
+    )
+  }),
+  renderCall: renderToolCall("list WebMCP tools"),
+  renderResult: renderTextResult,
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    return withStatus(ctx, "list WebMCP tools", async () => {
+      const implementation = await import("./chunks/tools-V7OR5KJ3.js");
+      return implementation.executeWebMcpListTool(params, signal, ctx);
+    });
+  }
+});
+var webMcpCallTool = defineTool({
+  name: WEBMCP_TOOL_NAMES[1],
+  label: "Chrome DevTools: Call WebMCP Tool (Experimental)",
+  description: "Call one previously listed page-provided WebMCP tool after exact page, document, frame, origin, schema, annotation, and session revalidation. Every call requires observable user confirmation and output is bounded to Pi's 50 KB or 2,000-line limit.",
+  parameters: Type.Object({
+    sessionGeneration: Type.String({
+      description: "Session generation token returned by chrome_devtools_webmcp_list_tools.",
+      maxLength: 100
+    }),
+    pageId: Type.String({ description: "Page id returned by the list tool.", maxLength: 512 }),
+    documentId: Type.String({
+      description: "Document loader id returned by the list tool.",
+      maxLength: 512
+    }),
+    frameId: Type.String({ description: "Frame id returned by the list tool.", maxLength: 512 }),
+    frameOrigin: Type.String({
+      description: "Exact frame origin returned by the list tool.",
+      maxLength: 2048
+    }),
+    toolName: Type.String({
+      description: "Exact tool name returned by the list tool.",
+      maxLength: 512
+    }),
+    schemaDigest: Type.String({
+      description: "Schema and annotation digest returned by the list tool.",
+      minLength: 64,
+      maxLength: 64,
+      pattern: "^[a-f0-9]{64}$"
+    }),
+    input: Type.Record(Type.String(), Type.Unknown(), {
+      description: "JSON object matching the page-provided input schema."
+    })
+  }),
+  renderCall: renderToolCall("call WebMCP tool"),
+  renderResult: renderTextResult,
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    return withStatus(ctx, "call WebMCP tool", async () => {
+      const implementation = await import("./chunks/tools-V7OR5KJ3.js");
+      return implementation.executeWebMcpCallTool(params, signal, ctx);
+    });
+  }
+});
 var screenshotTool = defineTool({
   name: CHROME_DEVTOOLS_TOOL_NAMES[4],
   label: "Chrome DevTools: Screenshot",
@@ -560,7 +490,10 @@ var screenshotTool = defineTool({
   renderResult: renderScreenshotResult,
   async execute(_toolCallId, params, signal, _onUpdate, ctx) {
     return withStatus(ctx, "screenshot", async () => {
-      const page = await resolvePage(params.pageId);
+      const page = await resolvePage(params.pageId, {
+        sessionOwner: ctx.sessionManager,
+        signal
+      });
       const result = await withCdp(page, async (client) => {
         throwIfAborted(signal);
         await client.send("Page.enable");
@@ -623,11 +556,14 @@ function chromeDevtools(pi) {
   pi.registerTool(navigateTool);
   pi.registerTool(evaluateTool);
   pi.registerTool(screenshotTool);
+  pi.registerTool(webMcpListToolsTool);
+  pi.registerTool(webMcpCallTool);
   pi.registerTool(createChromeDevtoolsLoadTool(pi));
   pi.registerCommand("chrome-devtools", {
     description: "Open Chrome DevTools help and tool controls",
     getArgumentCompletions: (prefix) => commandCompletions(prefix),
     handler: async (args, ctx) => {
+      setChromeDevtoolsSessionOwner(pi, ctx.sessionManager);
       initializeAvailableChromeDevtoolsTools(pi);
       const generation = state.sessionGeneration;
       await handleChromeDevtoolsCommand(pi, args, ctx, generation);
@@ -635,12 +571,19 @@ function chromeDevtools(pi) {
   });
   pi.on("session_start", async (_event, ctx) => {
     const generation = ++state.sessionGeneration;
+    setChromeDevtoolsSessionOwner(pi, ctx.sessionManager);
     initializeAvailableChromeDevtoolsTools(pi);
+    setWebMcpSessionOwner(ctx.sessionManager);
     replaceSessionController("Chrome DevTools session replaced");
+    invalidateWebMcpOperations(ctx.sessionManager, "Chrome DevTools session replaced");
     state.shuttingDown = false;
     state.settingsNotice = void 0;
     ctx.ui.setStatus(STATUS_KEY2, void 0);
-    await shutdownManagedBrowser();
+    await shutdownManagedBrowser(void 0, {
+      cancelLaunch: true,
+      owner: ctx.sessionManager
+    });
+    startManagedBrowserSession(ctx.sessionManager);
     if (generation !== state.sessionGeneration) return;
     state.activePageId = void 0;
     state.lastLaunchAttempt = void 0;
@@ -648,14 +591,25 @@ function chromeDevtools(pi) {
     const settings = await loadSettings({ cwd: ctx.cwd, projectTrusted });
     if (generation !== state.sessionGeneration) return;
     applyRuntimeBrowserSettings(settings.effectiveBrowser, settings.paths, projectTrusted);
+    applyRuntimeWebMcpSetting(settings.effectiveWebMcpEnabled, ctx.sessionManager);
     state.settingsNotice = settings.notice;
     for (const warning of settings.warnings) {
       ctx.ui.notify(sanitizeChromeDevtoolsDisplay(warning), "warning");
     }
+    if (webMcpEnabled(ctx.sessionManager)) {
+      ctx.ui.notify(
+        "Experimental WebMCP is enabled. Page-provided tools use the visible browser session and require confirmation for every call.",
+        "warning"
+      );
+    }
     const availableTools = settings.kind === "loaded" && settings.settings.tools ? settings.settings.tools : availableChromeDevtoolsTools(pi);
     configureChromeDevtoolsToolExposure(pi, availableTools, ctx.model);
   });
-  pi.on("model_select", (event) => {
+  pi.on("model_select", (event, ctx) => {
+    invalidateWebMcpOperations(
+      ctx.sessionManager,
+      "Chrome DevTools model and tool exposure changed"
+    );
     if (!supportsNativeDeferredToolLoading(event.model)) {
       requireEagerChromeDevtoolsToolExposure(pi);
     }
@@ -663,8 +617,12 @@ function chromeDevtools(pi) {
   pi.on("session_shutdown", async (_event, ctx) => {
     state.sessionGeneration += 1;
     replaceSessionController("Chrome DevTools session shut down");
+    invalidateWebMcpOperations(ctx.sessionManager, "Chrome DevTools session shut down");
     ctx.ui.setStatus(STATUS_KEY2, void 0);
-    const browserShutdown = shutdownManagedBrowser(void 0, { cancelLaunch: true });
+    const browserShutdown = shutdownManagedBrowser(void 0, {
+      cancelLaunch: true,
+      owner: ctx.sessionManager
+    });
     await waitForChromeDevtoolsSettings();
     await waitForSettingsWrites();
     await browserShutdown;
@@ -678,15 +636,15 @@ async function handleChromeDevtoolsCommand(pi, args, ctx, generation) {
       return;
     case "help":
       requireObservableUi(ctx, "help");
-      ctx.ui.notify(buildCommandGuide(), "info");
+      ctx.ui.notify(buildCommandGuide(ctx.sessionManager), "info");
       return;
     case "quickstart":
       requireObservableUi(ctx, "quickstart");
-      ctx.ui.notify(buildQuickstartMessage(), "info");
+      ctx.ui.notify(buildQuickstartMessage(ctx.sessionManager), "info");
       return;
     case "status": {
       requireObservableUi(ctx, "status");
-      const status = await buildToolStatusMessage(pi);
+      const status = await buildToolStatusMessage(pi, ctx.sessionManager);
       if (generation !== state.sessionGeneration) return;
       ctx.ui.notify(status, "info");
       return;
@@ -695,22 +653,27 @@ async function handleChromeDevtoolsCommand(pi, args, ctx, generation) {
       if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
         throw new Error("/chrome-devtools settings requires TUI or RPC mode");
       }
-      const { showChromeDevtoolsBrowserSettings } = await import("./chunks/browser-settings-menu-VWCNG4HB.js");
+      const { showChromeDevtoolsBrowserSettings } = await import("./chunks/browser-settings-menu-N5O65I7S.js");
       if (generation !== state.sessionGeneration) return;
-      await showChromeDevtoolsBrowserSettings(ctx, generation);
+      await showChromeDevtoolsBrowserSettings(pi, ctx, generation);
       return;
     }
     case "tools": {
       if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
         throw new Error("/chrome-devtools tools requires TUI or RPC mode");
       }
-      const { showChromeDevtoolsToolWorkflow } = await import("./chunks/menu-PLD3S3EO.js");
+      const { showChromeDevtoolsToolWorkflow } = await import("./chunks/menu-UBHW6UP2.js");
       if (generation !== state.sessionGeneration) return;
       await showChromeDevtoolsToolWorkflow(pi, ctx, generation);
       return;
     }
     case "enable":
-      await updateChromeDevtoolsTools(pi, ctx, allChromeDevtoolsTools(), "made all available");
+      await updateChromeDevtoolsTools(
+        pi,
+        ctx,
+        allChromeDevtoolsTools(ctx.sessionManager),
+        "made all available"
+      );
       return;
     case "disable":
       await updateChromeDevtoolsTools(pi, ctx, [], "made all unavailable");
@@ -722,7 +685,7 @@ async function handleChromeDevtoolsCommand(pi, args, ctx, generation) {
   ctx.ui.notify(
     `Unknown /chrome-devtools command: ${args.trim()}
 
-${buildCommandGuide()}`,
+${buildCommandGuide(ctx.sessionManager)}`,
     "warning"
   );
 }
@@ -735,7 +698,7 @@ async function showMenu(pi, ctx, generation) {
   if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
     throw new Error("/chrome-devtools menu requires TUI or RPC mode; use a direct subcommand");
   }
-  const { showChromeDevtoolsMenu } = await import("./chunks/menu-PLD3S3EO.js");
+  const { showChromeDevtoolsMenu } = await import("./chunks/menu-UBHW6UP2.js");
   if (generation !== state.sessionGeneration) return;
   await showChromeDevtoolsMenu(pi, ctx, generation);
 }