@narumitw/pi-chrome-devtools 0.52.0 → 0.52.2

package/dist/index.ts

@@ -0,0 +1,762 @@
+// @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,
+  allChromeDevtoolsTools,
+  applyRuntimeBrowserSettings,
+  availableChromeDevtoolsTools,
+  buildCommandGuide,
+  buildQuickstartMessage,
+  buildToolStatusMessage,
+  configureLazyChromeDevtoolsTools,
+  createChromeDevtoolsLoadTool,
+  devToolsEndpoint,
+  ensureDevToolsEndpoint,
+  fetchDevToolsJson,
+  formatPageListItem,
+  initializeAvailableChromeDevtoolsTools,
+  launchHint,
+  loadSettings,
+  sanitizeChromeDevtoolsDisplay,
+  shutdownManagedBrowser,
+  state,
+  updateChromeDevtoolsTools,
+  waitForChromeDevtoolsSettings,
+  waitForSettingsWrites,
+  withEndpointRetry
+} from "./chunks/chunk-CC37WUUE.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";
+function renderToolCall(action) {
+  return () => new PiTextComponent(`Chrome DevTools: ${action}`);
+}
+function renderTextResult(result, options, theme) {
+  const output = formatCollapsibleOutput(textContent(result), options);
+  return new PiTextComponent(output.text, theme, output.color);
+}
+function renderScreenshotResult(result, options, theme) {
+  const output = formatCollapsibleOutput(screenshotTextContent(result), options);
+  return new PiTextComponent(output.text, theme, output.color);
+}
+function textContent(result) {
+  return result.content.flatMap((content) => content.type === "text" ? [content.text] : []).join("\n");
+}
+function screenshotTextContent(result) {
+  const text = textContent(result);
+  if (text.trim()) return text;
+  const details = result.details;
+  if (typeof details?.savedPath !== "string") return text;
+  const bytes = typeof details.bytes === "number" ? ` (${details.bytes} bytes)` : "";
+  return `Saved screenshot to ${details.savedPath}${bytes}`;
+}
+function formatCollapsibleOutput(text, options) {
+  if (options.isPartial) return { text: "Running...", color: "warning" };
+  if (options.expanded) return { text, color: "toolOutput" };
+  return { text: "" };
+}
+var PiTextComponent = class {
+  text;
+  theme;
+  color;
+  constructor(text = "", theme, color) {
+    this.text = text;
+    this.theme = theme;
+    this.color = color;
+  }
+  setText(text) {
+    this.text = text;
+  }
+  invalidate() {
+  }
+  render(width) {
+    if (!this.text.trim()) return [];
+    return this.text.replace(/\t/g, "   ").split(/\r?\n/).map((line) => {
+      const truncatedLine = truncateLine(line, Math.max(1, width));
+      return this.theme && this.color ? this.theme.fg(this.color, truncatedLine) : truncatedLine;
+    });
+  }
+};
+function truncateLine(line, maxWidth) {
+  return Array.from(line).slice(0, maxWidth).join("");
+}
+async function withStatus(ctx, status, callback) {
+  ctx.ui.setStatus(STATUS_KEY, status);
+  try {
+    return await callback();
+  } finally {
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+  }
+}
+
+// src/screenshot.ts
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+async function saveScreenshot(base64Png, savePath, cwd, signal) {
+  const resolvedPath = resolveScreenshotPath(savePath, cwd);
+  const pngBytes = Buffer.from(base64Png, "base64");
+  await withFileMutationQueue(resolvedPath.path, async () => {
+    throwIfAborted(signal);
+    await ensureSafeScreenshotParent(resolvedPath);
+    await assertSafeScreenshotTargetPath(resolvedPath);
+    await writeScreenshotFileSafely(resolvedPath, pngBytes, signal);
+  });
+  return {
+    savedPath: resolvedPath.path,
+    bytes: pngBytes.byteLength,
+    isDefaultPath: resolvedPath.isDefault
+  };
+}
+function resolveScreenshotPath(savePath, cwd) {
+  const cwdRoot = resolve(cwd);
+  const tempRoot = resolve(tmpdir());
+  if (savePath === void 0) {
+    return {
+      path: join(tempRoot, `pi-chrome-devtools-screenshot-${randomUUID()}.png`),
+      allowedRoots: [tempRoot],
+      isDefault: true
+    };
+  }
+  const normalizedPath = stripLeadingAtPath(savePath);
+  if (!normalizedPath.trim()) {
+    throw new Error("Screenshot savePath must not be empty.");
+  }
+  if (normalizedPath.includes("\0")) {
+    throw new Error("Screenshot savePath must not contain NUL bytes.");
+  }
+  if (hasParentPathSegment(normalizedPath)) {
+    throw new Error("Screenshot savePath must not contain '..' path segments.");
+  }
+  const isAbsolutePath = isAbsolute(normalizedPath);
+  const path = isAbsolutePath ? resolve(normalizedPath) : resolve(cwdRoot, normalizedPath);
+  const allowedRoots = isAbsolutePath ? unique([cwdRoot, tempRoot]) : [cwdRoot];
+  if (!allowedRoots.some((root) => isPathInsideRoot(path, root))) {
+    throw new Error(
+      "Screenshot savePath must be relative to the current working directory, or an absolute path inside the current working directory or OS temp directory."
+    );
+  }
+  return { path, allowedRoots, isDefault: false };
+}
+function stripLeadingAtPath(path) {
+  return path.startsWith("@") ? path.slice(1) : path;
+}
+function hasParentPathSegment(path) {
+  return path.split(/[\\/]+/).some((part) => part === "..");
+}
+async function ensureSafeScreenshotParent(resolvedPath) {
+  const parentPath = dirname(resolvedPath.path);
+  const rootPath = selectAllowedRoot(parentPath, resolvedPath.allowedRoots);
+  if (!rootPath) {
+    throw new Error(
+      "Screenshot savePath parent must stay inside the current working directory or OS temp directory."
+    );
+  }
+  const realRootPath = await realpath(rootPath);
+  let currentPath = rootPath;
+  const parentSegments = relative(rootPath, parentPath).split(/[\\/]+/).filter((part) => part.length > 0);
+  for (const segment of parentSegments) {
+    currentPath = join(currentPath, segment);
+    await ensureSafeDirectorySegment(currentPath, realRootPath);
+  }
+}
+function selectAllowedRoot(path, roots) {
+  const matchingRoots = roots.filter((root) => isPathInsideRoot(path, root));
+  matchingRoots.sort(
+    (left, right) => normalizePathForComparison(resolve(right)).length - normalizePathForComparison(resolve(left)).length
+  );
+  return matchingRoots[0];
+}
+async function ensureSafeDirectorySegment(path, realRootPath) {
+  const existingDirectory = await lstat(path).catch(async (error) => {
+    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+    await mkdir(path).catch((mkdirError) => {
+      if (!isNodeError(mkdirError) || mkdirError.code !== "EEXIST") throw mkdirError;
+    });
+    return lstat(path);
+  });
+  if (existingDirectory.isSymbolicLink()) {
+    throw new Error("Screenshot savePath parent directories must not contain symbolic links.");
+  }
+  if (!existingDirectory.isDirectory()) {
+    throw new Error("Screenshot savePath parent must be a directory.");
+  }
+  await assertPathWithinRealRoot(path, realRootPath);
+}
+async function assertSafeScreenshotTargetPath(resolvedPath) {
+  const existingTarget = await lstat(resolvedPath.path).catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (existingTarget?.isSymbolicLink()) {
+    throw new Error("Screenshot savePath must not point to a symbolic link.");
+  }
+  if (existingTarget?.isDirectory()) {
+    throw new Error("Screenshot savePath must point to a file, not a directory.");
+  }
+  if (existingTarget && !existingTarget.isFile()) {
+    throw new Error("Screenshot savePath may only replace regular files.");
+  }
+  const realAllowedRoots = await Promise.all(resolvedPath.allowedRoots.map(realpathOrResolvedPath));
+  const realParent = await realpath(dirname(resolvedPath.path));
+  const realTargetPath = join(realParent, basename(resolvedPath.path));
+  if (!realAllowedRoots.some((root) => isPathInsideRoot(realTargetPath, root))) {
+    throw new Error(
+      "Screenshot savePath resolves outside the current working directory or OS temp directory."
+    );
+  }
+}
+async function assertPathWithinRealRoot(path, realRootPath) {
+  const realPath = await realpath(path);
+  if (!isPathInsideRoot(realPath, realRootPath)) {
+    throw new Error(
+      "Screenshot savePath parent resolves outside the current working directory or OS temp directory."
+    );
+  }
+}
+async function writeScreenshotFileSafely(resolvedPath, pngBytes, signal) {
+  const tempFile = join(
+    dirname(resolvedPath.path),
+    `.${basename(resolvedPath.path)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(tempFile, pngBytes, { flag: "wx", signal });
+    throwIfAborted(signal);
+    await replaceScreenshotFile(resolvedPath, tempFile, signal);
+  } catch (error) {
+    await rm(tempFile, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function replaceScreenshotFile(resolvedPath, tempFile, signal) {
+  try {
+    await rename(tempFile, resolvedPath.path);
+    return;
+  } catch (error) {
+    if (!shouldRetryRenameAfterRemovingDestination(error)) throw error;
+  }
+  await assertSafeScreenshotTargetPath(resolvedPath);
+  throwIfAborted(signal);
+  await rm(resolvedPath.path, { force: true });
+  await rename(tempFile, resolvedPath.path);
+}
+function shouldRetryRenameAfterRemovingDestination(error) {
+  return process.platform === "win32" && isNodeError(error) && ["EACCES", "EEXIST", "EPERM"].includes(error.code ?? "");
+}
+async function realpathOrResolvedPath(path) {
+  return realpath(path).catch(() => resolve(path));
+}
+function isPathInsideRoot(path, root) {
+  const normalizedPath = normalizePathForComparison(resolve(path));
+  const normalizedRoot = normalizePathForComparison(resolve(root));
+  if (normalizedPath === normalizedRoot) return true;
+  const rootWithSeparator = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+  return normalizedPath.startsWith(rootWithSeparator);
+}
+function normalizePathForComparison(path) {
+  return process.platform === "win32" ? path.toLowerCase() : path;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new Error("Screenshot capture cancelled.");
+}
+function formatScreenshotText(page, screenshot) {
+  const pathLabel = screenshot.isDefaultPath ? "Saved to temp file" : "Saved to";
+  return [
+    `Captured PNG screenshot from ${page.title || page.url || page.id}.`,
+    `${pathLabel}: ${screenshot.savedPath}`,
+    `Bytes: ${screenshot.bytes}`,
+    `Use read({ path: ${JSON.stringify(screenshot.savedPath)} }) to inspect the saved screenshot if inline image content is not available.`
+  ].join("\n");
+}
+
+// src/tools.ts
+var listPagesTool = defineTool({
+  name: CHROME_DEVTOOLS_TOOL_NAMES[0],
+  label: "Chrome DevTools: List Pages",
+  description: "List Chrome tabs/pages from a running Chrome DevTools Protocol endpoint.",
+  parameters: Type.Object({}),
+  renderCall: renderToolCall("list pages"),
+  renderResult: renderTextResult,
+  async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+    return withStatus(ctx, "list pages", async () => {
+      const pages = await listPages();
+      return textResult(JSON.stringify(pages.map(formatPage), null, 2), { pages });
+    });
+  }
+});
+var selectPageTool = defineTool({
+  name: CHROME_DEVTOOLS_TOOL_NAMES[1],
+  label: "Chrome DevTools: Select Page",
+  description: "Select the active Chrome page for later chrome_devtools_* tool calls.",
+  parameters: Type.Object({
+    pageId: Type.String({ description: "Page id from chrome_devtools_list_pages." })
+  }),
+  renderCall: renderToolCall("select page"),
+  renderResult: renderTextResult,
+  async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    return withStatus(ctx, "select page", async () => {
+      const page = await getPage(params.pageId);
+      state.activePageId = page.id;
+      return textResult(`Selected page ${page.id}: ${page.title}
+${page.url}`, {
+        page: formatPage(page)
+      });
+    });
+  }
+});
+var navigateTool = defineTool({
+  name: CHROME_DEVTOOLS_TOOL_NAMES[2],
+  label: "Chrome DevTools: Navigate",
+  description: "Navigate a Chrome page to a URL through Chrome DevTools Protocol, creating a page first if none is available.",
+  parameters: Type.Object({
+    url: Type.String({ description: "URL to navigate to." }),
+    pageId: Type.Optional(
+      Type.String({ description: "Optional page id. Defaults to selected or first page." })
+    )
+  }),
+  renderCall: renderToolCall("navigate"),
+  renderResult: renderTextResult,
+  async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    return withStatus(ctx, "navigate", async () => {
+      const { created, page } = await resolvePageForNavigation(params.pageId);
+      const result = await withCdp(page, async (client) => {
+        await client.send("Page.enable");
+        return client.send("Page.navigate", { url: params.url });
+      });
+      state.activePageId = page.id;
+      const action = created ? "Created page and navigated" : "Navigated";
+      return textResult(`${action} ${page.id} to ${params.url}`, {
+        created,
+        page: formatPage(page),
+        result
+      });
+    });
+  }
+});
+var evaluateTool = defineTool({
+  name: CHROME_DEVTOOLS_TOOL_NAMES[3],
+  label: "Chrome DevTools: Evaluate",
+  description: "Evaluate JavaScript in a Chrome page through Chrome DevTools Protocol.",
+  parameters: Type.Object({
+    expression: Type.String({ description: "JavaScript expression to evaluate." }),
+    pageId: Type.Optional(
+      Type.String({ description: "Optional page id. Defaults to selected or first page." })
+    ),
+    awaitPromise: Type.Optional(
+      Type.Boolean({ description: "Whether to await a returned Promise. Defaults to true." })
+    )
+  }),
+  renderCall: renderToolCall("evaluate"),
+  renderResult: renderTextResult,
+  async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    return withStatus(ctx, "evaluate", async () => {
+      const page = await resolvePage(params.pageId);
+      const result = await withCdp(
+        page,
+        (client) => client.send("Runtime.evaluate", {
+          expression: params.expression,
+          awaitPromise: params.awaitPromise ?? true,
+          returnByValue: true
+        })
+      );
+      state.activePageId = page.id;
+      return textResult(JSON.stringify(result, null, 2), { page: formatPage(page), result });
+    });
+  }
+});
+var screenshotTool = defineTool({
+  name: CHROME_DEVTOOLS_TOOL_NAMES[4],
+  label: "Chrome DevTools: Screenshot",
+  description: "Capture a PNG screenshot from a Chrome page through Chrome DevTools Protocol.",
+  parameters: Type.Object({
+    pageId: Type.Optional(
+      Type.String({ description: "Optional page id. Defaults to selected or first page." })
+    ),
+    fullPage: Type.Optional(
+      Type.Boolean({ description: "Capture the full document, not just the viewport." })
+    ),
+    savePath: Type.Optional(
+      Type.String({
+        description: "Screenshot is always saved as a PNG file. Optional output path; omitted defaults to a unique temp file. Relative paths resolve from the current working directory. A single leading @ is stripped to match Pi file-mention paths. Existing regular files are replaced."
+      })
+    )
+  }),
+  renderCall: renderToolCall("screenshot"),
+  renderResult: renderScreenshotResult,
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    return withStatus(ctx, "screenshot", async () => {
+      const page = await resolvePage(params.pageId);
+      const result = await withCdp(page, async (client) => {
+        throwIfAborted(signal);
+        await client.send("Page.enable");
+        if (!params.fullPage) {
+          return client.send("Page.captureScreenshot", { format: "png" });
+        }
+        const metrics = await client.send("Page.getLayoutMetrics");
+        throwIfAborted(signal);
+        return client.send("Page.captureScreenshot", {
+          captureBeyondViewport: true,
+          format: "png",
+          clip: {
+            x: metrics.contentSize.x,
+            y: metrics.contentSize.y,
+            width: metrics.contentSize.width,
+            height: metrics.contentSize.height,
+            scale: 1
+          }
+        });
+      });
+      state.activePageId = page.id;
+      const savedScreenshot = await saveScreenshot(result.data, params.savePath, ctx.cwd, signal);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatScreenshotText(page, savedScreenshot)
+          },
+          { type: "image", data: result.data, mimeType: "image/png" }
+        ],
+        details: {
+          page: formatPage(page),
+          bytes: savedScreenshot.bytes,
+          savedPath: savedScreenshot.savedPath,
+          isDefaultPath: savedScreenshot.isDefaultPath
+        }
+      };
+    });
+  }
+});
+
+// src/chrome-devtools.ts
+var STATUS_KEY2 = "chrome-devtools";
+var COMMAND_COMPLETIONS = [
+  { value: "help", label: "help", description: "Show command usage" },
+  { value: "quickstart", label: "quickstart", description: "Show endpoint and launch help" },
+  { value: "status", label: "status", description: "Show tool and settings status" },
+  { value: "settings", label: "settings", description: "Edit browser connection settings" },
+  { value: "tools", label: "tools", description: "Choose lazy-loadable Chrome DevTools tools" },
+  { value: "toggle", label: "toggle", description: "Alias for tools" },
+  { value: "select", label: "select", description: "Compatibility alias for tools" },
+  { value: "enable", label: "enable", description: "Make all Chrome DevTools tools available" },
+  { value: "on", label: "on", description: "Compatibility alias for enable" },
+  { value: "disable", label: "disable", description: "Make all Chrome DevTools tools unavailable" },
+  { value: "off", label: "off", description: "Compatibility alias for disable" }
+];
+function chromeDevtools(pi) {
+  pi.registerTool(listPagesTool);
+  pi.registerTool(selectPageTool);
+  pi.registerTool(navigateTool);
+  pi.registerTool(evaluateTool);
+  pi.registerTool(screenshotTool);
+  pi.registerTool(createChromeDevtoolsLoadTool(pi));
+  pi.registerCommand("chrome-devtools", {
+    description: "Open Chrome DevTools help and tool controls",
+    getArgumentCompletions: (prefix) => commandCompletions(prefix),
+    handler: async (args, ctx) => {
+      initializeAvailableChromeDevtoolsTools(pi);
+      const generation = state.sessionGeneration;
+      await handleChromeDevtoolsCommand(pi, args, ctx, generation);
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    const generation = ++state.sessionGeneration;
+    initializeAvailableChromeDevtoolsTools(pi);
+    replaceSessionController("Chrome DevTools session replaced");
+    state.shuttingDown = false;
+    state.settingsNotice = void 0;
+    ctx.ui.setStatus(STATUS_KEY2, void 0);
+    await shutdownManagedBrowser();
+    if (generation !== state.sessionGeneration) return;
+    state.activePageId = void 0;
+    state.lastLaunchAttempt = void 0;
+    const projectTrusted = ctx.isProjectTrusted();
+    const settings = await loadSettings({ cwd: ctx.cwd, projectTrusted });
+    if (generation !== state.sessionGeneration) return;
+    applyRuntimeBrowserSettings(settings.effectiveBrowser, settings.paths, projectTrusted);
+    state.settingsNotice = settings.notice;
+    for (const warning of settings.warnings) {
+      ctx.ui.notify(sanitizeChromeDevtoolsDisplay(warning), "warning");
+    }
+    const availableTools = settings.kind === "loaded" && settings.settings.tools ? settings.settings.tools : availableChromeDevtoolsTools(pi);
+    configureLazyChromeDevtoolsTools(pi, availableTools);
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    state.sessionGeneration += 1;
+    replaceSessionController("Chrome DevTools session shut down");
+    ctx.ui.setStatus(STATUS_KEY2, void 0);
+    const browserShutdown = shutdownManagedBrowser(void 0, { cancelLaunch: true });
+    await waitForChromeDevtoolsSettings();
+    await waitForSettingsWrites();
+    await browserShutdown;
+  });
+}
+async function handleChromeDevtoolsCommand(pi, args, ctx, generation) {
+  const command = parseCommand(args);
+  switch (command) {
+    case "menu":
+      await showMenu(pi, ctx, generation);
+      return;
+    case "help":
+      requireObservableUi(ctx, "help");
+      ctx.ui.notify(buildCommandGuide(), "info");
+      return;
+    case "quickstart":
+      requireObservableUi(ctx, "quickstart");
+      ctx.ui.notify(buildQuickstartMessage(), "info");
+      return;
+    case "status": {
+      requireObservableUi(ctx, "status");
+      const status = await buildToolStatusMessage(pi);
+      if (generation !== state.sessionGeneration) return;
+      ctx.ui.notify(status, "info");
+      return;
+    }
+    case "settings": {
+      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-VI2I3TXI.js");
+      if (generation !== state.sessionGeneration) return;
+      await showChromeDevtoolsBrowserSettings(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-LLR455UX.js");
+      if (generation !== state.sessionGeneration) return;
+      await showChromeDevtoolsToolWorkflow(pi, ctx, generation);
+      return;
+    }
+    case "enable":
+      await updateChromeDevtoolsTools(pi, ctx, allChromeDevtoolsTools(), "made all available");
+      return;
+    case "disable":
+      await updateChromeDevtoolsTools(pi, ctx, [], "made all unavailable");
+      return;
+  }
+  if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
+    throw new Error(`Unknown /chrome-devtools command: ${args.trim()}`);
+  }
+  ctx.ui.notify(
+    `Unknown /chrome-devtools command: ${args.trim()}
+
+${buildCommandGuide()}`,
+    "warning"
+  );
+}
+function requireObservableUi(ctx, route) {
+  if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
+    throw new Error(`/chrome-devtools ${route} requires TUI or RPC mode`);
+  }
+}
+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-LLR455UX.js");
+  if (generation !== state.sessionGeneration) return;
+  await showChromeDevtoolsMenu(pi, ctx, generation);
+}
+function replaceSessionController(reason) {
+  state.sessionController.abort(new DOMException(reason, "AbortError"));
+  state.sessionController = new AbortController();
+}
+function parseCommand(args) {
+  const command = args.trim().toLowerCase();
+  if (!command) return "menu";
+  if (command === "help") return "help";
+  if (command === "quickstart") return "quickstart";
+  if (command === "status") return "status";
+  if (command === "settings") return "settings";
+  if (command === "tools" || command === "select" || command === "toggle") return "tools";
+  if (command === "enable" || command === "on") return "enable";
+  if (command === "disable" || command === "off") return "disable";
+  return "unknown";
+}
+function commandCompletions(prefix) {
+  const normalized = prefix.trimStart().toLowerCase();
+  if (/\s/.test(normalized)) return null;
+  const matches = COMMAND_COMPLETIONS.filter(
+    (completion) => completion.value.startsWith(normalized)
+  );
+  return matches.length > 0 ? matches : null;
+}
+export {
+  chromeDevtools as default
+};
+//# sourceMappingURL=index.ts.map