@mozilla/firefox-devtools-mcp 0.9.15 → 0.10.1

package/dist/index.js

@@ -51,6 +51,13 @@ function previewExcerpt(text, preview) {
   }
   return truncateText(text, Math.min(preview, TOKEN_LIMITS.MAX_RESPONSE_CHARS), "...");
 }
+function truncationFooter(hiddenCount, unit, hints) {
+  if (hiddenCount <= 0) {
+    return "";
+  }
+  const head = `[+${hiddenCount} ${unit} hidden`;
+  return hints.length > 0 ? `${head}; ${hints.join(", ")}]` : `${head}]`;
+}
 function truncateHeaders(headers) {
   if (!headers) {
     return null;
@@ -124,21 +131,6 @@ var init_response_helpers = __esm({
   }
 });
 
-// src/tools/module.ts
-function defineModule(config2) {
-  return {
-    name: config2.name,
-    description: config2.description,
-    ...config2.privileged ? { privileged: true } : {},
-    tools: config2.tools.map(([definition, handler]) => ({ definition, handler }))
-  };
-}
-var init_module = __esm({
-  "src/tools/module.ts"() {
-    "use strict";
-  }
-});
-
 // node_modules/zod/v4/core/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer3, params) {
@@ -14849,7 +14841,7 @@ var init_constants = __esm({
   "src/config/constants.ts"() {
     "use strict";
     SERVER_NAME = true ? "@mozilla/firefox-devtools-mcp" : "firefox-devtools";
-    SERVER_VERSION = true ? "0.9.15" : "dev";
+    SERVER_VERSION = true ? "0.10.1" : "dev";
   }
 });
 
@@ -14970,7 +14962,16 @@ var init_profile = __esm({
 // src/firefox/core.ts
 import { Builder, Browser, Capabilities } from "selenium-webdriver";
 import firefox from "selenium-webdriver/firefox.js";
-import { mkdirSync as mkdirSync2, openSync, closeSync, existsSync as existsSync2, readdirSync, statSync } from "fs";
+import {
+  mkdirSync as mkdirSync2,
+  openSync,
+  closeSync,
+  existsSync as existsSync2,
+  readdirSync,
+  statSync,
+  readFileSync
+} from "fs";
+import { connect as netConnect } from "net";
 import { homedir } from "os";
 import { join as join2, delimiter } from "path";
 function findGeckodriverInPath(binaryName) {
@@ -15016,6 +15017,57 @@ async function findGeckodriverInNpmPackage() {
     return null;
   }
 }
+function lookupMarionettePort() {
+  const instancesDir = join2(homedir(), ".firefox-devtools-mcp", "instances");
+  if (!existsSync2(instancesDir)) {
+    logDebug(`Failed to lookup Marionette port: ${instancesDir} doesn't exist.`);
+    return;
+  }
+  const files = readdirSync(instancesDir);
+  const portFiles = files.filter((f) => /^\d+\.port$/.test(f));
+  const mostRecent = portFiles.map((f) => ({
+    name: f,
+    path: join2(instancesDir, f),
+    mtime: statSync(join2(instancesDir, f)).mtimeMs
+  })).sort((a, b) => b.mtime - a.mtime)[0];
+  if (mostRecent) {
+    const pid = Number(mostRecent.name.substring(0, mostRecent.name.length - 5));
+    if (!checkProcess(pid)) {
+      logDebug(`Failed to lookup Marionette port: No process with PID ${pid} is running.`);
+      return;
+    }
+    logDebug(`Reading Marionette port from ${mostRecent.path}`);
+    const content = readFileSync(mostRecent.path, "utf-8").trim();
+    if (/^\d+$/.test(content)) {
+      return Number(content);
+    } else {
+      logDebug(`Failed to lookup Marionette port: "${content}" is not a number.`);
+    }
+  } else {
+    logDebug(`Failed to lookup Marionette port: No port file found in ${instancesDir}.`);
+  }
+}
+function checkProcess(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPort(port, timeoutMs = 1e3) {
+  return new Promise((resolve4) => {
+    const socket = netConnect({ host: "127.0.0.1", port });
+    const done = (reason) => {
+      socket.destroy();
+      resolve4(reason);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => done(null));
+    socket.once("timeout", () => done(`connection to 127.0.0.1:${port} timed out`));
+    socket.once("error", (error2) => done(error2.message));
+  });
+}
 async function findGeckodriver() {
   const ext = process.platform === "win32" ? ".exe" : "";
   const binaryName = `geckodriver${ext}`;
@@ -15047,8 +15099,15 @@ var init_core3 = __esm({
        */
       async connect() {
         const isAndroid = this.options.androidDevice !== void 0;
+        const androidPackage = this.options.androidPackage ?? "org.mozilla.firefox";
+        if (isAndroid && !this.options.androidWipeAppData) {
+          throw new Error(
+            `Firefox for Android mode wipes all data of ${androidPackage} on the device: tabs, history, bookmarks, passwords, cookies and settings are all lost, because geckodriver clears the app data before every session and cannot be configured to skip it. Pass --android-wipe-app-data (or ANDROID_WIPE_APP_DATA=true) to confirm. Prefer a build dedicated to automation, for instance --android-package org.mozilla.fenix for Nightly.`
+          );
+        }
         if (isAndroid) {
           log("Launching Firefox for Android via ADB...");
+          log(`Wiping all data of ${androidPackage} on the device`);
         } else if (this.options.connectExisting) {
           log("Connecting to existing Firefox via Marionette...");
         } else {
@@ -15057,8 +15116,7 @@ var init_core3 = __esm({
         if (isAndroid) {
           const geckodriverPath = await findGeckodriver();
           logDebug(`Using geckodriver: ${geckodriverPath}`);
-          const pkg = this.options.androidPackage ?? "org.mozilla.firefox";
-          const mozOptions = { androidPackage: pkg };
+          const mozOptions = { androidPackage };
           const deviceSerial = this.options.androidDevice;
           if (deviceSerial && deviceSerial !== "auto") {
             mozOptions.androidDeviceSerial = deviceSerial;
@@ -15075,7 +15133,31 @@ var init_core3 = __esm({
           const serviceBuilder = new firefox.ServiceBuilder(geckodriverPath);
           this.driver = firefox.Driver.createSession(caps, serviceBuilder.build());
         } else if (this.options.connectExisting) {
-          const port = this.options.marionettePort ?? 2828;
+          let port = this.options.marionettePort ?? 2828;
+          if (this.options.lookupMarionettePort) {
+            logDebug("Looking up Marionette port");
+            const lookedUpPort = lookupMarionettePort();
+            if (lookedUpPort !== void 0) {
+              port = lookedUpPort;
+            } else {
+              throw new Error(
+                "Marionette port not found: please enable Firefox remote control for AI tooling using the AI assistant companion button."
+              );
+            }
+          }
+          logDebug(`Using Marionette port ${port}`);
+          const failure = await checkPort(port);
+          if (failure) {
+            if (this.options.lookupMarionettePort) {
+              throw new Error(
+                `No Marionette listener on 127.0.0.1:${port} (${failure}). Please enable Firefox remote control for AI tooling using the AI assistant companion button.`
+              );
+            } else {
+              throw new Error(
+                `No Marionette listener on 127.0.0.1:${port} (${failure}). Start Firefox with both flags: firefox --marionette --remote-debugging-port, or pass the port it is actually using via --marionette-port.`
+              );
+            }
+          }
           const geckodriverPath = await findGeckodriver();
           logDebug(`Using geckodriver: ${geckodriverPath}`);
           const serviceBuilder = new firefox.ServiceBuilder(geckodriverPath);
@@ -15266,68 +15348,6 @@ var init_core3 = __esm({
       getOptions() {
         return this.options;
       }
-      /**
-       * Wait for WebSocket to be in OPEN state
-       */
-      async waitForWebSocketOpen(ws, timeout = 5e3) {
-        if (ws.readyState === 1) {
-          return;
-        }
-        if (ws.readyState === 0) {
-          return new Promise((resolve4, reject) => {
-            const timeoutId = setTimeout(() => {
-              ws.off("open", onOpen);
-              reject(new Error("Timeout waiting for WebSocket to open"));
-            }, timeout);
-            const onOpen = () => {
-              clearTimeout(timeoutId);
-              ws.off("open", onOpen);
-              resolve4();
-            };
-            ws.on("open", onOpen);
-          });
-        }
-        throw new Error(`WebSocket is not open: readyState ${ws.readyState}`);
-      }
-      /**
-       * Send raw BiDi command and get response
-       */
-      async sendBiDiCommand(method, params = {}) {
-        if (!this.driver) {
-          throw new Error("Driver not connected");
-        }
-        const bidi = await this.driver.getBidi();
-        const ws = bidi.socket;
-        await this.waitForWebSocketOpen(ws);
-        const id = Math.floor(Math.random() * 1e6);
-        return new Promise((resolve4, reject) => {
-          const messageHandler = (data) => {
-            try {
-              const payload = JSON.parse(data.toString());
-              if (payload.id === id) {
-                ws.off("message", messageHandler);
-                if (payload.error) {
-                  reject(new Error(`BiDi error: ${JSON.stringify(payload.error)}`));
-                } else {
-                  resolve4(payload.result);
-                }
-              }
-            } catch {
-            }
-          };
-          ws.on("message", messageHandler);
-          const command = {
-            id,
-            method,
-            params
-          };
-          ws.send(JSON.stringify(command));
-          setTimeout(() => {
-            ws.off("message", messageHandler);
-            reject(new Error(`BiDi command timeout: ${method}`));
-          }, 1e4);
-        });
-      }
       /**
        * Close driver and cleanup.
        * - Tries graceful quit() with a timeout; on timeout, force-kills via onQuit_().
@@ -15397,6 +15417,168 @@ var init_core3 = __esm({
   }
 });
 
+// src/firefox/bidi.ts
+import EventEmitter from "events";
+var BiDiFacade;
+var init_bidi = __esm({
+  "src/firefox/bidi.ts"() {
+    "use strict";
+    init_logger();
+    BiDiFacade = class extends EventEmitter {
+      constructor(driver) {
+        super();
+        this.driver = driver;
+      }
+      listening = false;
+      nextCommandId = 1;
+      async subscribe(events) {
+        const bidi = await this.driver.getBidi();
+        if (!this.listening) {
+          this.listenForEvents(bidi.socket);
+          this.listening = true;
+        }
+        await bidi.subscribe(events);
+      }
+      async sendCommand(method, params = {}) {
+        const bidi = await this.driver.getBidi();
+        const ws = bidi.socket;
+        await this.waitForWebSocketOpen(ws);
+        const id = this.nextCommandId++;
+        return new Promise((resolve4, reject) => {
+          const messageHandler = (data) => {
+            try {
+              const payload = JSON.parse(data.toString());
+              if (payload.id === id) {
+                ws.off("message", messageHandler);
+                if (payload.error) {
+                  reject(new Error(`BiDi error: ${JSON.stringify(payload.error)}`));
+                } else {
+                  resolve4(payload.result);
+                }
+              }
+            } catch {
+            }
+          };
+          ws.on("message", messageHandler);
+          const command = {
+            id,
+            method,
+            params
+          };
+          ws.send(JSON.stringify(command));
+          setTimeout(() => {
+            ws.off("message", messageHandler);
+            reject(new Error(`BiDi command timeout: ${method}`));
+          }, 1e4);
+        });
+      }
+      listenForEvents(ws) {
+        ws.on("message", (data) => {
+          let payload;
+          try {
+            payload = JSON.parse(data.toString());
+          } catch {
+            return;
+          }
+          if (payload?.type === "event" && payload.method) {
+            try {
+              this.emit(payload.method, payload.params);
+            } catch (error2) {
+              logDebug(
+                `Error emitting ${payload.method} event: ${error2 instanceof Error ? error2.message : String(error2)}`
+              );
+            }
+          }
+        });
+      }
+      /**
+       * Wait for WebSocket to be in OPEN state
+       */
+      async waitForWebSocketOpen(ws, timeout = 5e3) {
+        if (ws.readyState === 1) {
+          return;
+        }
+        if (ws.readyState === 0) {
+          return new Promise((resolve4, reject) => {
+            const timeoutId = setTimeout(() => {
+              ws.off("open", onOpen);
+              reject(new Error("Timeout waiting for WebSocket to open"));
+            }, timeout);
+            const onOpen = () => {
+              clearTimeout(timeoutId);
+              ws.off("open", onOpen);
+              resolve4();
+            };
+            ws.on("open", onOpen);
+          });
+        }
+        throw new Error(`WebSocket is not open: readyState ${ws.readyState}`);
+      }
+    };
+  }
+});
+
+// src/utils/remote-value.ts
+function remoteValueToNative(rv) {
+  if (!rv || typeof rv !== "object") {
+    return rv;
+  }
+  const { type, value } = rv;
+  switch (type) {
+    case "undefined":
+      return void 0;
+    case "null":
+      return null;
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      if (value === "NaN") {
+        return "NaN";
+      }
+      if (value === "Infinity") {
+        return "Infinity";
+      }
+      if (value === "-Infinity") {
+        return "-Infinity";
+      }
+      if (value === "-0") {
+        return "-0";
+      }
+      return value;
+    case "bigint":
+      return `${value}n`;
+    case "array":
+      return value.map(remoteValueToNative);
+    case "object":
+      return Object.fromEntries(
+        value.map(([k, v]) => [k, remoteValueToNative(v)])
+      );
+    case "map":
+      return Object.fromEntries(
+        value.map(([k, v]) => [
+          typeof k === "object" ? JSON.stringify(remoteValueToNative(k)) : String(k),
+          remoteValueToNative(v)
+        ])
+      );
+    case "set":
+      return value.map(remoteValueToNative);
+    case "regexp": {
+      const { pattern, flags } = value;
+      return `/${pattern}/${flags ?? ""}`;
+    }
+    case "date":
+      return value;
+    default:
+      return `[${type}]`;
+  }
+}
+var init_remote_value = __esm({
+  "src/utils/remote-value.ts"() {
+    "use strict";
+  }
+});
+
 // src/firefox/events/console.ts
 var MAX_CONSOLE_MESSAGES, CONSOLE_TTL_MS, ConsoleEvents;
 var init_console = __esm({
@@ -15406,8 +15588,8 @@ var init_console = __esm({
     MAX_CONSOLE_MESSAGES = 1e3;
     CONSOLE_TTL_MS = 5 * 60 * 1e3;
     ConsoleEvents = class {
-      constructor(driver, options = {}) {
-        this.driver = driver;
+      constructor(bidi, options = {}) {
+        this.bidi = bidi;
         this.options = {
           autoClearOnNavigate: false,
           // Changed default to false to preserve logs across tabs
@@ -15420,47 +15602,27 @@ var init_console = __esm({
       /**
        * Subscribe to BiDi console events and navigation lifecycle
        */
-      async subscribe(contextId) {
+      async subscribe() {
         if (this.subscribed) {
           return;
         }
-        const bidi = await this.driver.getBidi();
-        await bidi.subscribe("log.entryAdded", contextId ? [contextId] : void 0);
-        try {
-          await bidi.subscribe("browsingContext.load", contextId ? [contextId] : void 0);
-          await bidi.subscribe("browsingContext.domContentLoaded", contextId ? [contextId] : void 0);
-        } catch {
-          logDebug(
-            "Navigation events subscription skipped (may not be available in this Firefox version)"
-          );
-        }
-        const ws = bidi.socket;
-        ws.on("message", (data) => {
-          try {
-            const payload = JSON.parse(data.toString());
-            if (payload?.method === "log.entryAdded") {
-              const entry = payload.params;
-              const message = {
-                level: entry.level || "info",
-                text: entry.text || (entry.args ? JSON.stringify(entry.args) : ""),
-                timestamp: entry.timestamp || Date.now(),
-                source: entry.source?.realm,
-                args: entry.args
-              };
-              this.consoleMessages.push(message);
-              logDebug(`Console [${message.level}]: ${message.text}`);
-            }
-            if (payload?.method === "browsingContext.load" || payload?.method === "browsingContext.domContentLoaded") {
-              if (this.options.autoClearOnNavigate) {
-                this.clearMessages();
-              }
-              if (this.options.onNavigate) {
-                this.options.onNavigate();
-              }
-            }
-          } catch {
-          }
+        await this.bidi.subscribe("log.entryAdded");
+        await this.bidi.subscribe(["browsingContext.load", "browsingContext.domContentLoaded"]);
+        this.bidi.on("log.entryAdded", (entry) => {
+          const message = {
+            level: entry.level || "info",
+            text: entry.text || (entry.args ? JSON.stringify(entry.args) : ""),
+            timestamp: entry.timestamp || Date.now(),
+            source: entry.source?.realm,
+            args: entry.args
+          };
+          this.consoleMessages.push(message);
+          logDebug(`Console [${message.level}]: ${message.text}`);
         });
+        if (this.options.autoClearOnNavigate) {
+          this.bidi.on("browsingContext.load", () => this.clearMessages());
+          this.bidi.on("browsingContext.domContentLoaded", () => this.clearMessages());
+        }
         this.subscribed = true;
         logDebug("Console listener active with lifecycle hooks");
       }
@@ -15499,16 +15661,17 @@ var init_console = __esm({
 });
 
 // src/firefox/events/network.ts
-var MAX_NETWORK_REQUESTS, NETWORK_TTL_MS, NetworkEvents;
+var MAX_NETWORK_REQUESTS, NETWORK_TTL_MS, MAX_ENCODED_DATA_SIZE, NetworkEvents;
 var init_network = __esm({
   "src/firefox/events/network.ts"() {
     "use strict";
     init_logger();
     MAX_NETWORK_REQUESTS = 1e3;
     NETWORK_TTL_MS = 5 * 60 * 1e3;
+    MAX_ENCODED_DATA_SIZE = 10 * 1e3 * 1e3;
     NetworkEvents = class {
-      constructor(driver, options = {}) {
-        this.driver = driver;
+      constructor(bidi, options = {}) {
+        this.bidi = bidi;
         this.options = {
           autoClearOnNavigate: true,
           ...options
@@ -15519,102 +15682,155 @@ var init_network = __esm({
       enabled = false;
       requestStartTimes = /* @__PURE__ */ new Map();
       options;
+      collectorId = null;
       /**
        * Subscribe to BiDi network events and navigation lifecycle
        * Enables monitoring by default (always-on capture)
        */
-      async subscribe(contextId) {
+      async subscribe() {
         if (this.subscribed) {
           return;
         }
-        const bidi = await this.driver.getBidi();
-        await bidi.subscribe("network.beforeRequestSent", contextId ? [contextId] : void 0);
-        await bidi.subscribe("network.responseStarted", contextId ? [contextId] : void 0);
-        await bidi.subscribe("network.responseCompleted", contextId ? [contextId] : void 0);
-        try {
-          await bidi.subscribe("browsingContext.load", contextId ? [contextId] : void 0);
-          await bidi.subscribe("browsingContext.domContentLoaded", contextId ? [contextId] : void 0);
-        } catch {
-          logDebug(
-            "Navigation events subscription skipped (may not be available in this Firefox version)"
-          );
-        }
-        const ws = bidi.socket;
-        ws.on("message", (data) => {
-          try {
-            const payload = JSON.parse(data.toString());
-            if (payload?.method === "browsingContext.load" || payload?.method === "browsingContext.domContentLoaded") {
-              if (this.enabled && this.options.autoClearOnNavigate) {
-                this.clearRequests();
-              }
-              if (this.options.onNavigate) {
-                this.options.onNavigate();
-              }
-              return;
-            }
-            if (!this.enabled) {
-              return;
-            }
-            if (payload?.method === "network.beforeRequestSent") {
-              const req = payload.params;
-              const requestId = req.request?.request || req.requestId;
-              if (!requestId) {
-                return;
-              }
-              this.requestStartTimes.set(requestId, Date.now());
-              const record2 = {
-                id: requestId,
-                url: req.request?.url || "",
-                method: req.request?.method || "GET",
-                timestamp: Date.now(),
-                resourceType: this.guessResourceType(req.request?.url || ""),
-                isXHR: req.initiator?.type === "xmlhttprequest" || req.initiator?.type === "fetch",
-                requestHeaders: this.parseHeaders(req.request?.headers || []),
-                timings: {
-                  requestTime: Date.now()
-                }
-              };
-              this.networkRecords.set(requestId, record2);
-              logDebug(`Network request [${record2.method}]: ${record2.url}`);
-            }
-            if (payload?.method === "network.responseStarted") {
-              const resp = payload.params;
-              const requestId = resp.request?.request || resp.requestId;
-              if (!requestId) {
-                return;
-              }
-              const existing = this.networkRecords.get(requestId);
-              if (existing) {
-                existing.status = resp.response?.status;
-                existing.statusText = resp.response?.statusText || "";
-                existing.responseHeaders = this.parseHeaders(resp.response?.headers || []);
-              }
+        await this.bidi.subscribe([
+          "network.beforeRequestSent",
+          "network.responseStarted",
+          "network.responseCompleted"
+        ]);
+        await this.bidi.subscribe(["browsingContext.load", "browsingContext.domContentLoaded"]);
+        const onLoadEvent = () => {
+          if (this.enabled && this.options.autoClearOnNavigate) {
+            this.clearRequests();
+          }
+        };
+        this.bidi.on("browsingContext.domContentLoaded", onLoadEvent);
+        this.bidi.on("browsingContext.load", onLoadEvent);
+        this.bidi.on("network.beforeRequestSent", (req) => {
+          if (!this.enabled) {
+            return;
+          }
+          const requestId = req.request?.request || req.requestId;
+          if (!requestId) {
+            return;
+          }
+          this.requestStartTimes.set(requestId, Date.now());
+          const record2 = {
+            id: requestId,
+            url: req.request?.url || "",
+            method: req.request?.method || "GET",
+            timestamp: Date.now(),
+            resourceType: this.guessResourceType(req.request?.url || ""),
+            isXHR: req.initiator?.type === "xmlhttprequest" || req.initiator?.type === "fetch",
+            requestHeaders: this.parseHeaders(req.request?.headers || []),
+            timings: {
+              requestTime: Date.now()
             }
-            if (payload?.method === "network.responseCompleted") {
-              const resp = payload.params;
-              const requestId = resp.request?.request || resp.requestId;
-              if (!requestId) {
-                return;
-              }
-              const existing = this.networkRecords.get(requestId);
-              const startTime = this.requestStartTimes.get(requestId);
-              if (existing && startTime) {
-                existing.timings.responseTime = Date.now();
-                existing.timings.duration = Date.now() - startTime;
-                if (!existing.status && resp.response?.status) {
-                  existing.status = resp.response.status;
-                  existing.statusText = resp.response.statusText || "";
-                }
-              }
-              this.requestStartTimes.delete(requestId);
+          };
+          this.networkRecords.set(requestId, record2);
+          logDebug(`Network request [${record2.method}]: ${record2.url}`);
+        });
+        this.bidi.on("network.responseStarted", (resp) => {
+          if (!this.enabled) {
+            return;
+          }
+          const requestId = resp.request?.request || resp.requestId;
+          if (!requestId) {
+            return;
+          }
+          const existing = this.networkRecords.get(requestId);
+          if (existing) {
+            existing.status = resp.response?.status;
+            existing.statusText = resp.response?.statusText || "";
+            existing.responseHeaders = this.parseHeaders(resp.response?.headers || []);
+          }
+        });
+        this.bidi.on("network.responseCompleted", (resp) => {
+          if (!this.enabled) {
+            return;
+          }
+          const requestId = resp.request?.request || resp.requestId;
+          if (!requestId) {
+            return;
+          }
+          const existing = this.networkRecords.get(requestId);
+          const startTime = this.requestStartTimes.get(requestId);
+          if (existing && startTime) {
+            existing.timings.responseTime = Date.now();
+            existing.timings.duration = Date.now() - startTime;
+            if (!existing.status && resp.response?.status) {
+              existing.status = resp.response.status;
+              existing.statusText = resp.response.statusText || "";
             }
-          } catch {
           }
+          this.requestStartTimes.delete(requestId);
         });
+        await this.registerDataCollector();
         this.subscribed = true;
         this.enabled = true;
         logDebug("Network listener ready with lifecycle hooks (monitoring enabled by default)");
       }
+      /**
+       * Register a BiDi network data collector for request and response bodies.
+       * Failures are non-fatal and simply leave body capture disabled.
+       */
+      async registerDataCollector() {
+        if (this.options.captureBodies === false) {
+          logDebug("Network body capture disabled, skipping data collector registration");
+          return;
+        }
+        try {
+          const result = await this.bidi.sendCommand("network.addDataCollector", {
+            dataTypes: ["request", "response"],
+            maxEncodedDataSize: MAX_ENCODED_DATA_SIZE
+          });
+          this.collectorId = result?.collector ?? null;
+          if (this.collectorId) {
+            logDebug(`Network data collector registered (${this.collectorId})`);
+          }
+        } catch (error2) {
+          logDebug(
+            `Network data collector unavailable, response bodies will not be captured: ${error2 instanceof Error ? error2.message : String(error2)}`
+          );
+        }
+      }
+      /**
+       * Fetch a captured request or response body via network.getData.
+       * Returns a structured result so callers can render an appropriate marker
+       * when the body was never collected, evicted, or the browser lacks support.
+       */
+      async fetchBody(requestId, dataType) {
+        if (!this.collectorId) {
+          return { ok: false, reason: "unsupported" };
+        }
+        try {
+          const result = await this.bidi.sendCommand("network.getData", {
+            request: requestId,
+            dataType
+          });
+          const bytes = result?.bytes;
+          if (!bytes || typeof bytes.value !== "string") {
+            return { ok: false, reason: "not-collected" };
+          }
+          return {
+            ok: true,
+            type: bytes.type === "base64" ? "base64" : "string",
+            value: bytes.value
+          };
+        } catch (error2) {
+          const message = (error2 instanceof Error ? error2.message : String(error2)).toLowerCase();
+          if (message.includes("no such network data")) {
+            return { ok: false, reason: "not-collected" };
+          }
+          if (message.includes("unavailable network data")) {
+            if (message.includes("evicted")) {
+              return { ok: false, reason: "evicted" };
+            }
+            if (message.includes("aborted")) {
+              return { ok: false, reason: "aborted" };
+            }
+          }
+          return { ok: false, reason: "error" };
+        }
+      }
       /**
        * Start collecting network requests
        */
@@ -15768,46 +15984,35 @@ var init_debugging = __esm({
     init_logger();
     MAX_LOGPOINT_RESULTS = 100;
     DebuggingEvents = class {
-      constructor(driver, sendBiDiCommand) {
-        this.driver = driver;
-        this.sendBiDiCommand = sendBiDiCommand;
+      constructor(bidi) {
+        this.bidi = bidi;
       }
       logpoints = /* @__PURE__ */ new Map();
       subscribed = false;
       /**
        * Subscribe to moz:debugging events
        */
-      async subscribe(contextId) {
+      async subscribe() {
         if (this.subscribed) {
           return;
         }
-        const bidi = await this.driver.getBidi();
         try {
-          await bidi.subscribe("moz:debugging.paused", contextId ? [contextId] : void 0);
-          await bidi.subscribe("moz:debugging.resumed", contextId ? [contextId] : void 0);
+          await this.bidi.subscribe(["moz:debugging.paused", "moz:debugging.resumed"]);
         } catch {
           logDebug(
             "Debugging events subscription skipped (may not be available in this Firefox version)"
           );
         }
-        const ws = bidi.socket;
-        ws.on("message", (data) => {
-          try {
-            const payload = JSON.parse(data.toString());
-            if (payload?.method === "moz:debugging.paused") {
-              const { context, url, line, column } = payload.params;
-              const logpointId = this.findLogpointByLocation(url, line);
-              if (logpointId) {
-                void this.handleLogpointPause(context, logpointId);
-                return;
-              }
-              logDebug(`moz:Debugging paused in context: ${context} at ${url}:${line}:${column}`);
-            }
-            if (payload?.method === "moz:debugging.resumed") {
-              logDebug(`moz:Debugging resumed in context: ${payload.params.context}`);
-            }
-          } catch {
+        this.bidi.on("moz:debugging.paused", ({ context, url, line, column }) => {
+          const logpointId = this.findLogpointByLocation(url, line);
+          if (logpointId) {
+            void this.handleLogpointPause(context, logpointId);
+            return;
           }
+          logDebug(`moz:Debugging paused in context: ${context} at ${url}:${line}:${column}`);
+        });
+        this.bidi.on("moz:debugging.resumed", (entry) => {
+          logDebug(`moz:Debugging resumed in context: ${entry.context}`);
         });
         this.subscribed = true;
         logDebug("moz:debugging listener active");
@@ -15841,7 +16046,7 @@ var init_debugging = __esm({
         }
         logDebug(`Logpoint hit: ${logpointId} in context ${contextId}`);
         try {
-          const result = await this.sendBiDiCommand("script.evaluate", {
+          const result = await this.bidi.sendCommand("script.evaluate", {
             expression: entry.expression,
             target: { context: contextId },
             awaitPromise: false
@@ -15873,7 +16078,7 @@ var init_debugging = __esm({
               logDebug(`Logpoint ${logpointId}: result buffer capped at ${MAX_LOGPOINT_RESULTS}`);
             }
           }
-          await this.sendBiDiCommand("moz:debugging.resume", { context: contextId }).catch((err) => {
+          await this.bidi.sendCommand("moz:debugging.resume", { context: contextId }).catch((err) => {
             logDebug(`Failed to resume after logpoint: ${String(err)}`);
           });
         }
@@ -15891,8 +16096,8 @@ var init_downloads = __esm({
     MAX_DOWNLOADS = 500;
     DOWNLOAD_TTL_MS = 30 * 60 * 1e3;
     DownloadEvents = class {
-      constructor(driver) {
-        this.driver = driver;
+      constructor(bidi) {
+        this.bidi = bidi;
       }
       downloads = /* @__PURE__ */ new Map();
       subscribed = false;
@@ -15904,65 +16109,53 @@ var init_downloads = __esm({
       /**
        * Subscribe to BiDi download events.
        */
-      async subscribe(contextId) {
+      async subscribe() {
         if (this.subscribed) {
           return;
         }
-        const bidi = await this.driver.getBidi();
-        const contexts = contextId ? [contextId] : void 0;
-        await bidi.subscribe("browsingContext.downloadWillBegin", contexts);
-        await bidi.subscribe("browsingContext.downloadEnd", contexts);
-        const ws = bidi.socket;
-        ws.on("message", (data) => {
-          try {
-            const payload = JSON.parse(data.toString());
-            if (payload?.method === "browsingContext.downloadWillBegin") {
-              const p = payload.params;
-              let key = p.download ?? p.navigation;
-              if (!key) {
-                key = `download-${this.fallbackCounter++}`;
-                this.pendingFallbackKey = key;
-              }
-              this.downloads.set(key, {
-                id: key,
-                context: p.context,
-                navigation: p.navigation ?? null,
-                url: p.url || "",
-                suggestedFilename: p.suggestedFilename || "",
-                status: "in_progress",
-                startTimestamp: p.timestamp ?? Date.now()
-              });
-              logDebug(`Download started: filename=${p.suggestedFilename}, url=${p.url}, id=${key}`);
-            }
-            if (payload?.method === "browsingContext.downloadEnd") {
-              const p = payload.params;
-              let key = p?.download ?? p?.navigation;
-              if (!key) {
-                key = this.pendingFallbackKey ?? `download-${this.fallbackCounter++}`;
-                this.pendingFallbackKey = null;
-              }
-              const existing = this.downloads.get(key) ?? {
-                id: key,
-                context: p.context,
-                navigation: p.navigation ?? null,
-                url: p.url || "",
-                suggestedFilename: "",
-                status: "in_progress",
-                startTimestamp: p.timestamp ?? Date.now()
-              };
-              existing.status = p.status;
-              existing.endTimestamp = p.timestamp ?? Date.now();
-              existing.durationMs = existing.endTimestamp - existing.startTimestamp;
-              if (p.status === "complete" && p.filepath) {
-                existing.filepath = p.filepath;
-              }
-              this.downloads.set(key, existing);
-              logDebug(
-                `Download ${p.status}: filepath=${existing.filepath}, url=${existing.url}, id=${key}`
-              );
-            }
-          } catch {
+        await this.bidi.subscribe(["browsingContext.downloadWillBegin", "browsingContext.downloadEnd"]);
+        this.bidi.on("browsingContext.downloadWillBegin", (p) => {
+          let key = p.download ?? p.navigation;
+          if (!key) {
+            key = `download-${this.fallbackCounter++}`;
+            this.pendingFallbackKey = key;
+          }
+          this.downloads.set(key, {
+            id: key,
+            context: p.context,
+            navigation: p.navigation ?? null,
+            url: p.url || "",
+            suggestedFilename: p.suggestedFilename || "",
+            status: "in_progress",
+            startTimestamp: p.timestamp ?? Date.now()
+          });
+          logDebug(`Download started: filename=${p.suggestedFilename}, url=${p.url}, id=${key}`);
+        });
+        this.bidi.on("browsingContext.downloadEnd", (p) => {
+          let key = p?.download ?? p?.navigation;
+          if (!key) {
+            key = this.pendingFallbackKey ?? `download-${this.fallbackCounter++}`;
+            this.pendingFallbackKey = null;
+          }
+          const existing = this.downloads.get(key) ?? {
+            id: key,
+            context: p.context,
+            navigation: p.navigation ?? null,
+            url: p.url || "",
+            suggestedFilename: "",
+            status: "in_progress",
+            startTimestamp: p.timestamp ?? Date.now()
+          };
+          existing.status = p.status;
+          existing.endTimestamp = p.timestamp ?? Date.now();
+          existing.durationMs = existing.endTimestamp - existing.startTimestamp;
+          if (p.status === "complete" && p.filepath) {
+            existing.filepath = p.filepath;
           }
+          this.downloads.set(key, existing);
+          logDebug(
+            `Download ${p.status}: filepath=${existing.filepath}, url=${existing.url}, id=${key}`
+          );
         });
         this.subscribed = true;
         logDebug("Download listener ready");
@@ -16033,19 +16226,6 @@ var init_dom = __esm({
         this.driver = driver;
         this.resolveUid = resolveUid;
       }
-      /**
-       * Evaluate JavaScript - direct passthrough to executeScript
-       */
-      async evaluate(script) {
-        return await this.driver.executeScript(script);
-      }
-      /**
-       * Get page HTML content
-       */
-      async getContent() {
-        const html = await this.evaluate("return document.documentElement.outerHTML");
-        return String(html);
-      }
       // ============================================================================
       // Element polling helpers
       // ============================================================================
@@ -16509,7 +16689,12 @@ __export(formatter_exports, {
   formatSnapshotTree: () => formatSnapshotTree
 });
 function formatSnapshotTree(node, depth = 0, options = {}) {
-  const { includeAttributes = true, includeText = true, maxDepth } = options;
+  const {
+    includeAttributes = true,
+    includeText = true,
+    maxDepth,
+    maxAttrLength = MAX_ATTR_LENGTH
+  } = options;
   if (maxDepth !== void 0 && depth >= maxDepth) {
     return "";
   }
@@ -16519,22 +16704,22 @@ function formatSnapshotTree(node, depth = 0, options = {}) {
   const role = node.role || node.tag;
   attrs.push(role);
   if (node.name) {
-    attrs.push(`"${truncate(node.name, MAX_ATTR_LENGTH)}"`);
+    attrs.push(`"${truncate(node.name, maxAttrLength)}"`);
   }
   if (node.role && node.role !== node.tag) {
     attrs.push(`tag=${node.tag}`);
   }
   if (node.value) {
-    attrs.push(`value="${truncate(node.value, MAX_ATTR_LENGTH)}"`);
+    attrs.push(`value="${truncate(node.value, maxAttrLength)}"`);
   }
   if (node.href) {
-    attrs.push(`href="${truncate(node.href, MAX_ATTR_LENGTH)}"`);
+    attrs.push(`href="${truncate(node.href, maxAttrLength)}"`);
   }
   if (node.src) {
-    attrs.push(`src="${truncate(node.src, MAX_ATTR_LENGTH)}"`);
+    attrs.push(`src="${truncate(node.src, maxAttrLength)}"`);
   }
   if (includeText && node.text) {
-    attrs.push(`text="${truncate(node.text, MAX_ATTR_LENGTH)}"`);
+    attrs.push(`text="${truncate(node.text, maxAttrLength)}"`);
   }
   if (includeAttributes && node.aria) {
     if (node.aria.disabled) {
@@ -16593,7 +16778,7 @@ function formatSnapshotTree(node, depth = 0, options = {}) {
   if (node.isIframe) {
     attrs.push("[iframe");
     if (node.frameSrc) {
-      attrs.push(`src="${truncate(node.frameSrc, MAX_ATTR_LENGTH)}"`);
+      attrs.push(`src="${truncate(node.frameSrc, maxAttrLength)}"`);
     }
     if (node.crossOrigin) {
       attrs.push("cross-origin");
@@ -16621,140 +16806,60 @@ var init_formatter = __esm({
 });
 
 // src/firefox/snapshot/resolver.ts
-import { By as By2 } from "selenium-webdriver";
-var UidResolver;
+function notFoundMessage(uid) {
+  return `UID not found: ${uid}. The element is gone from the page, or the page was reloaded. Take a fresh snapshot first.`;
+}
+var RESOLVE_SCRIPT, SELECTOR_SCRIPT, CLEAR_SCRIPT, UidResolver;
 var init_resolver = __esm({
   "src/firefox/snapshot/resolver.ts"() {
     "use strict";
     init_logger();
+    RESOLVE_SCRIPT = "return window.__resolveUid ? window.__resolveUid(arguments[0]) : null;";
+    SELECTOR_SCRIPT = "return window.__uidToSelector ? window.__uidToSelector(arguments[0]) : null;";
+    CLEAR_SCRIPT = "if (window.__clearUidRegistry) { window.__clearUidRegistry(); }";
     UidResolver = class {
       constructor(driver) {
         this.driver = driver;
       }
-      uidToEntry = /* @__PURE__ */ new Map();
-      elementCache = /* @__PURE__ */ new Map();
-      currentSnapshotId = 0;
-      /**
-       * Update current snapshot ID
-       */
-      setSnapshotId(snapshotId) {
-        this.currentSnapshotId = snapshotId;
-      }
       /**
-       * Get current snapshot ID
+       * Forget all UID associations in the page, making existing UIDs unresolvable.
+       * Best effort: the registry dies with the page anyway.
        */
-      getSnapshotId() {
-        return this.currentSnapshotId;
-      }
-      /**
-       * Store UID mappings from snapshot result
-       */
-      storeUidMappings(uidMap) {
-        this.uidToEntry.clear();
-        for (const entry of uidMap) {
-          this.uidToEntry.set(entry.uid, entry);
-        }
-      }
-      /**
-       * Clear all UID mappings and cache
-       */
-      clear() {
-        this.uidToEntry.clear();
-        this.elementCache.clear();
-        logDebug("Snapshot UIDs cleared");
-      }
-      /**
-       * Validate UID (staleness check)
-       */
-      validateUid(uid) {
-        const parts = uid.split("_");
-        if (parts.length < 2 || !parts[0]) {
-          throw new Error(`Invalid UID format: ${uid}`);
-        }
-        const uidSnapshotId = parseInt(parts[0], 10);
-        if (isNaN(uidSnapshotId)) {
-          throw new Error(`Invalid UID format: ${uid}`);
-        }
-        if (uidSnapshotId !== this.currentSnapshotId) {
-          throw new Error(
-            `This uid is from a stale snapshot (snapshot ${uidSnapshotId}, current ${this.currentSnapshotId}). Take a fresh snapshot.`
-          );
+      async clear() {
+        try {
+          await this.driver.executeScript(CLEAR_SCRIPT);
+          logDebug("Snapshot UIDs cleared");
+        } catch {
+          logDebug("Unable to clear snapshot UIDs (page may be navigating)");
         }
       }
       /**
-       * Resolve UID to CSS selector (with staleness check)
+       * Resolve UID to a CSS selector, generated on demand from the element it points at
        */
-      resolveUidToSelector(uid) {
-        this.validateUid(uid);
-        const entry = this.uidToEntry.get(uid);
-        if (!entry) {
-          throw new Error(`UID not found: ${uid}. Take a fresh snapshot first.`);
+      async resolveUidToSelector(uid) {
+        const selector = await this.driver.executeScript(SELECTOR_SCRIPT, uid);
+        if (!selector) {
+          throw new Error(notFoundMessage(uid));
         }
-        return entry.css;
+        return selector;
       }
       /**
-       * Resolve UID to element (with staleness check and caching)
-       * Tries CSS first, falls back to XPath
+       * Resolve UID to the element it was assigned to during the snapshot
        */
       async resolveUidToElement(uid) {
-        this.validateUid(uid);
-        const entry = this.uidToEntry.get(uid);
-        if (!entry) {
-          throw new Error(`UID not found: ${uid}. Take a fresh snapshot first.`);
-        }
-        const cached2 = this.elementCache.get(uid);
-        if (cached2?.cachedElement) {
-          try {
-            await cached2.cachedElement.isDisplayed();
-            logDebug(`Using cached element for UID: ${uid}`);
-            return cached2.cachedElement;
-          } catch {
-            logDebug(`Cached element stale for UID: ${uid}, re-finding...`);
-          }
-        }
-        try {
-          const element = await this.driver.findElement(By2.css(entry.css));
-          this.elementCache.set(uid, {
-            selector: entry.css,
-            ...entry.xpath && { xpath: entry.xpath },
-            cachedElement: element,
-            snapshotId: this.currentSnapshotId,
-            timestamp: Date.now()
-          });
-          logDebug(`Found element by CSS for UID: ${uid}`);
-          return element;
-        } catch {
-          logDebug(`CSS selector failed for UID: ${uid}, trying XPath fallback...`);
-          const xpathSelector = entry.xpath;
-          if (xpathSelector) {
-            try {
-              const element = await this.driver.findElement(By2.xpath(xpathSelector));
-              this.elementCache.set(uid, {
-                selector: entry.css,
-                ...xpathSelector && { xpath: xpathSelector },
-                cachedElement: element,
-                snapshotId: this.currentSnapshotId,
-                timestamp: Date.now()
-              });
-              logDebug(`Found element by XPath for UID: ${uid}`);
-              return element;
-            } catch {
-              throw new Error(
-                `Element not found for UID: ${uid}. The element may have changed. Take a fresh snapshot.`
-              );
-            }
-          }
-          throw new Error(
-            `Element not found for UID: ${uid}. The element may have changed. Take a fresh snapshot.`
-          );
+        const element = await this.driver.executeScript(RESOLVE_SCRIPT, uid);
+        if (!element) {
+          throw new Error(notFoundMessage(uid));
         }
+        logDebug(`Resolved element for UID: ${uid}`);
+        return element;
       }
     };
   }
 });
 
 // src/firefox/snapshot/manager.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 var SnapshotManager;
@@ -16768,7 +16873,8 @@ var init_manager = __esm({
       driver;
       resolver;
       injectedScript = null;
-      currentSnapshotId = 0;
+      /** Counter handed to the injected script so UIDs stay unique across snapshots */
+      nextElementId = 0;
       constructor(driver) {
         this.driver = driver;
         this.resolver = new UidResolver(driver);
@@ -16796,7 +16902,7 @@ var init_manager = __esm({
           for (const path of possiblePaths) {
             attemptedPaths.push(path);
             try {
-              this.injectedScript = readFileSync(path, "utf-8");
+              this.injectedScript = readFileSync2(path, "utf-8");
               const sizeKB = (this.injectedScript.length / 1024).toFixed(1);
               logDebug(`\u2713 Loaded snapshot bundle: ${path.split("/").pop()} (${sizeKB} KB)`);
               return this.injectedScript;
@@ -16815,14 +16921,25 @@ ${attemptedPaths.map((p) => `  - ${p}`).join("\n")}`
       }
       /**
        * Take a snapshot of the current page
-       * Returns text and JSON with snapshotId, no DOM mutations
+       * Returns text and JSON, no DOM mutations
        */
       async takeSnapshot(options) {
-        const snapshotId = ++this.currentSnapshotId;
-        this.resolver.setSnapshotId(snapshotId);
-        this.resolver.clear();
-        logDebug(`Taking snapshot (ID: ${snapshotId})...`);
-        const result = await this.executeInjectedScript(snapshotId, options);
+        if (options?.selector || options?.includeAll) {
+          const optionsOutput = [];
+          if (options.selector) {
+            optionsOutput.push(`selector: ${options.selector}`);
+          }
+          if (options.includeAll) {
+            optionsOutput.push("include all");
+          }
+          logDebug(`Taking snapshot (${optionsOutput.join(", ")})...`);
+        } else {
+          logDebug("Taking snapshot...");
+        }
+        const result = await this.executeInjectedScript(this.nextElementId, options);
+        if (typeof result?.nextElementId === "number") {
+          this.nextElementId = result.nextElementId;
+        }
         logDebug(
           `Snapshot executeScript result: hasResult=${!!result}, hasTree=${!!result?.tree}, truncated=${result?.truncated || false}`
         );
@@ -16844,60 +16961,60 @@ ${attemptedPaths.map((p) => `  - ${p}`).join("\n")}`
           logDebug(`Snapshot generation failed: ${errorMsg}`);
           throw new Error(`Failed to generate snapshot: ${errorMsg}`);
         }
-        this.resolver.storeUidMappings(result.uidMap);
         const snapshotJson = {
           root: result.tree,
-          snapshotId,
           timestamp: Date.now(),
-          truncated: result.truncated || false,
-          uidMap: result.uidMap
+          truncated: result.truncated || false
         };
         const snapshot = {
           text: formatSnapshotTree(result.tree),
           json: snapshotJson
         };
         logDebug(
-          `Snapshot created: ${result.uidMap.length} elements with UIDs${result.truncated ? " (truncated)" : ""}`
+          `Snapshot created: ${result.nodeCount} elements with UIDs${result.truncated ? " (truncated)" : ""}`
         );
         return snapshot;
       }
       /**
-       * Resolve UID to CSS selector (with staleness check)
+       * Resolve UID to a CSS selector generated on demand
        */
-      resolveUidToSelector(uid) {
-        return this.resolver.resolveUidToSelector(uid);
+      async resolveUidToSelector(uid) {
+        return await this.resolver.resolveUidToSelector(uid);
       }
       /**
-       * Resolve UID to WebElement (with staleness check and caching)
+       * Resolve UID to the WebElement it was assigned to
        */
       async resolveUidToElement(uid) {
         return await this.resolver.resolveUidToElement(uid);
       }
       /**
-       * Clear snapshot (called on navigation)
+       * Clear snapshot UIDs
        */
-      clear() {
-        this.resolver.clear();
+      async clear() {
+        await this.resolver.clear();
       }
       /**
        * Execute bundled injected snapshot script
        */
-      async executeInjectedScript(snapshotId, options) {
+      async executeInjectedScript(nextElementId, options) {
         const scriptSource = this.getInjectedScript();
         const result = await this.driver.executeScript(
           `
       // Only inject the bundle if not already present
       if (typeof window.__createSnapshot === 'undefined') {
         ${scriptSource}
-        // Register the createSnapshot function globally
+        // Register the snapshot and UID resolution functions globally
         if (typeof __SnapshotInjected !== 'undefined' && __SnapshotInjected.createSnapshot) {
           window.__createSnapshot = __SnapshotInjected.createSnapshot;
+          window.__resolveUid = __SnapshotInjected.resolveUid;
+          window.__uidToSelector = __SnapshotInjected.uidToSelector;
+          window.__clearUidRegistry = __SnapshotInjected.clearUidRegistry;
         }
       }
       // Call it with options
       return window.__createSnapshot(arguments[0], arguments[1]);
       `,
-          snapshotId,
+          nextElementId,
           options || {}
         );
         return result;
@@ -16921,13 +17038,16 @@ var init_firefox = __esm({
   "src/firefox/index.ts"() {
     "use strict";
     init_core3();
+    init_bidi();
     init_logger();
+    init_remote_value();
     init_events();
     init_dom();
     init_pages();
     init_snapshot();
     FirefoxClient = class {
       core;
+      bidi = null;
       consoleEvents = null;
       networkEvents = null;
       debuggingEvents = null;
@@ -16938,33 +17058,52 @@ var init_firefox = __esm({
       constructor(options) {
         this.core = new FirefoxCore(options);
       }
+      getBidi() {
+        if (!this.bidi) {
+          throw new Error("Not connected");
+        }
+        return this.bidi;
+      }
       /**
        * Connect and initialize all modules
        */
       async connect() {
         await this.core.connect();
         const driver = this.core.getDriver();
+        this.bidi = new BiDiFacade(driver);
         this.snapshot = new SnapshotManager(driver);
-        const onNavigate = () => {
-          if (this.snapshot) {
-            this.snapshot.clear();
-          }
-        };
-        const hasBidi = "getBidi" in driver && typeof driver.getBidi === "function";
-        if (hasBidi) {
-          this.consoleEvents = new ConsoleEvents(driver, {
-            onNavigate,
-            autoClearOnNavigate: false
-          });
-          this.networkEvents = new NetworkEvents(driver, {
-            onNavigate,
-            autoClearOnNavigate: false
-          });
-          this.debuggingEvents = new DebuggingEvents(
-            driver,
-            (method, params) => this.core.sendBiDiCommand(method, params)
-          );
-          this.downloadEvents = new DownloadEvents(driver);
+        this.consoleEvents = new ConsoleEvents(this.bidi, {
+          autoClearOnNavigate: false
+        });
+        try {
+          await this.consoleEvents.subscribe();
+        } catch {
+          logDebug("Unable to subscribe to console events");
+          this.consoleEvents = null;
+        }
+        this.networkEvents = new NetworkEvents(this.bidi, {
+          autoClearOnNavigate: false,
+          captureBodies: this.core.getOptions().captureNetworkBodies !== false
+        });
+        try {
+          await this.networkEvents.subscribe();
+        } catch {
+          logDebug("Unable to subscribe to network events");
+          this.networkEvents = null;
+        }
+        this.debuggingEvents = new DebuggingEvents(this.bidi);
+        try {
+          await this.debuggingEvents.subscribe();
+        } catch {
+          logDebug("Unable to subscribe to debugging events");
+          this.debuggingEvents = null;
+        }
+        this.downloadEvents = new DownloadEvents(this.bidi);
+        try {
+          await this.downloadEvents.subscribe();
+        } catch {
+          logDebug("Unable to subscribe to download events");
+          this.downloadEvents = null;
         }
         this.dom = new DomInteractions(
           driver,
@@ -16974,55 +17113,30 @@ var init_firefox = __esm({
           driver,
           () => this.core.getCurrentContextId(),
           (id) => this.core.setCurrentContextId(id),
-          (method, params) => this.core.sendBiDiCommand(method, params)
+          (method, params) => this.getBidi().sendCommand(method, params)
         );
-        if (this.consoleEvents) {
-          try {
-            await this.consoleEvents.subscribe(void 0);
-          } catch {
-            logDebug("Unable to subscribe to console events");
-            this.consoleEvents = null;
-          }
-        }
-        if (this.networkEvents) {
-          try {
-            await this.networkEvents.subscribe(void 0);
-          } catch {
-            logDebug("Unable to subscribe to network events");
-            this.networkEvents = null;
-          }
-        }
-        if (this.debuggingEvents) {
-          try {
-            await this.debuggingEvents.subscribe();
-          } catch {
-            logDebug("Unable to subscribe to debugging events");
-            this.debuggingEvents = null;
-          }
-        }
-        if (this.downloadEvents) {
-          try {
-            await this.downloadEvents.subscribe(void 0);
-          } catch {
-            logDebug("Unable to subscribe to download events");
-            this.downloadEvents = null;
-          }
-        }
       }
       // ============================================================================
       // DOM / Evaluate
       // ============================================================================
-      async evaluate(script) {
-        if (!this.dom) {
-          throw new Error("Not connected");
-        }
-        return await this.dom.evaluate(script);
-      }
-      async getContent() {
-        if (!this.dom) {
-          throw new Error("Not connected");
+      /**
+       * Evaluate a JavaScript expression in the current browsing context over
+       * WebDriver BiDi (script.evaluate), so reads target the BiDi-tracked context
+       * rather than Selenium's classic window handle. Returns the result as a
+       * native value; throws on a script exception.
+       */
+      async evaluate(expression) {
+        const result = await this.getBidi().sendCommand("script.evaluate", {
+          expression,
+          awaitPromise: true,
+          target: { context: this.core.getCurrentContextId() }
+        });
+        if (result.type === "success") {
+          return remoteValueToNative(result.result);
         }
-        return await this.dom.getContent();
+        throw new Error(
+          `Script evaluation failed: ${result.exceptionDetails?.text ?? "unknown error"}`
+        );
       }
       async clickBySelector(selector) {
         if (!this.dom) {
@@ -17118,7 +17232,6 @@ var init_firefox = __esm({
           throw new Error("Not connected");
         }
         await this.pages.navigate(url);
-        this.clearSnapshot();
       }
       async navigateBack() {
         if (!this.pages) {
@@ -17221,6 +17334,18 @@ var init_firefox = __esm({
         }
         this.networkEvents.clearRequests();
       }
+      /**
+       * Fetch a captured request or response body for a given request id.
+       * Returns a structured result describing the body or why it is unavailable.
+       */
+      async getNetworkRequestBody(requestId, dataType) {
+        if (!this.networkEvents) {
+          throw new Error(
+            "Network events not available (Firefox Remote Agent not running \u2014 start Firefox with --remote-debugging-port to enable BiDi)"
+          );
+        }
+        return this.networkEvents.fetchBody(requestId, dataType);
+      }
       // ============================================================================
       // Downloads
       // ============================================================================
@@ -17246,7 +17371,7 @@ var init_firefox = __esm({
        */
       async setDownloadBehavior(behavior) {
         const downloadBehavior = behavior === "default" ? null : behavior === "allowed" ? { type: "allowed" } : { type: "denied" };
-        await this.core.sendBiDiCommand("browser.setDownloadBehavior", { downloadBehavior });
+        await this.getBidi().sendCommand("browser.setDownloadBehavior", { downloadBehavior });
       }
       // ============================================================================
       // Snapshot
@@ -17257,11 +17382,11 @@ var init_firefox = __esm({
         }
         return await this.snapshot.takeSnapshot(options);
       }
-      resolveUidToSelector(uid) {
+      async resolveUidToSelector(uid) {
         if (!this.snapshot) {
           throw new Error("Not connected");
         }
-        return this.snapshot.resolveUidToSelector(uid);
+        return await this.snapshot.resolveUidToSelector(uid);
       }
       async resolveUidToElement(uid) {
         if (!this.snapshot) {
@@ -17269,11 +17394,11 @@ var init_firefox = __esm({
         }
         return await this.snapshot.resolveUidToElement(uid);
       }
-      clearSnapshot() {
+      async clearSnapshot() {
         if (!this.snapshot) {
           throw new Error("Not connected");
         }
-        this.snapshot.clear();
+        await this.snapshot.clear();
       }
       // ============================================================================
       // Screenshot
@@ -17298,7 +17423,7 @@ var init_firefox = __esm({
        * @internal
        */
       async sendBiDiCommand(method, params = {}) {
-        return await this.core.sendBiDiCommand(method, params);
+        return await this.getBidi().sendCommand(method, params);
       }
       /**
        * Get WebDriver instance (for advanced operations)
@@ -17343,7 +17468,7 @@ var init_firefox = __esm({
         if (!this.debuggingEvents) {
           throw new Error("Debugging events not available");
         }
-        const result = await this.core.sendBiDiCommand("moz:debugging.setBreakpoint", {
+        const result = await this.getBidi().sendCommand("moz:debugging.setBreakpoint", {
           location: { url, line }
         });
         const logpointId = result.breakpoint;
@@ -17357,7 +17482,7 @@ var init_firefox = __esm({
         if (!this.debuggingEvents) {
           throw new Error("Debugging events not available");
         }
-        await this.core.sendBiDiCommand("moz:debugging.removeBreakpoint", {
+        await this.getBidi().sendCommand("moz:debugging.removeBreakpoint", {
           breakpoint: logpointId
         });
         this.debuggingEvents.removeLogpoint(logpointId);
@@ -17411,11 +17536,56 @@ var init_firefox = __esm({
   }
 });
 
+// src/tools/instructions.ts
+function buildInstructions(moduleNames, toolNames) {
+  const byName = new Map(MODULES.map((m) => [m.name, m]));
+  const capabilities = moduleNames.flatMap((name) => {
+    const module17 = byName.get(name);
+    return module17 ? [`- ${module17.name}: ${module17.description}`] : [];
+  });
+  const sections = [INSTRUCTIONS_INTRO, ["Enabled capabilities:", ...capabilities].join("\n")];
+  const core = CORE_TOOLS.filter((name) => toolNames.has(name));
+  if (core.length > 0) {
+    const groups = TASK_TOOLS.flatMap(({ purpose, tools }) => {
+      const available = tools.filter((name) => toolNames.has(name));
+      return available.length > 0 ? [`${available.join(" / ")} for ${purpose}`] : [];
+    });
+    const extra = groups.length > 0 ? ` Add task-specific tools to the same search: ${groups.join(", ")}.` : "";
+    sections.push(
+      `When these tools are deferred, load the core set in one search rather than one at a time: ${core.join(", ")}.${extra}`
+    );
+  }
+  return sections.join("\n\n");
+}
+var INSTRUCTIONS_INTRO, CORE_TOOLS, TASK_TOOLS;
+var init_instructions = __esm({
+  "src/tools/instructions.ts"() {
+    "use strict";
+    init_tools();
+    INSTRUCTIONS_INTRO = [
+      "Browse and debug the web with Firefox.",
+      "Use this for any browser or web page task: opening a URL, automating a web flow,",
+      "or debugging a page (console errors, network requests, DOM state).",
+      "The task does not need to name Firefox, reach for these tools unless another",
+      "browser is explicitly requested.",
+      "Chrome-only browser tools do not control Firefox, do not assume they cover this."
+    ].join(" ");
+    CORE_TOOLS = ["list_pages", "new_page", "navigate_page", "take_snapshot", "get_page_text"];
+    TASK_TOOLS = [
+      { purpose: "interaction", tools: ["click_by_uid", "fill_by_uid", "hover_by_uid"] },
+      { purpose: "debugging", tools: ["list_console_messages", "list_network_requests"] },
+      { purpose: "visuals", tools: ["screenshot_page", "screenshot_by_uid"] },
+      { purpose: "one-off JS", tools: ["evaluate_script"] }
+    ];
+  }
+});
+
 // src/tools/registry.ts
 function buildToolset(options) {
   const { moduleNames, warnings } = selectModules(options);
   const { toolDefinitions, handlers } = collectTools(moduleNames);
-  return { moduleNames, warnings, toolDefinitions, handlers };
+  const instructions = buildInstructions(moduleNames, new Set(handlers.keys()));
+  return { moduleNames, warnings, toolDefinitions, handlers, instructions };
 }
 function selectModules(options) {
   const { tools: requested, preset, enableScript, enablePrivilegedContext } = options;
@@ -17503,6 +17673,7 @@ var init_registry = __esm({
   "src/tools/registry.ts"() {
     "use strict";
     init_tools();
+    init_instructions();
     privilegedModuleNames = new Set(MODULES.filter((m) => m.privileged).map((m) => m.name));
   }
 });
@@ -17579,11 +17750,14 @@ async function getFirefox() {
       acceptInsecureCerts: args.acceptInsecureCerts,
       connectExisting: args.connectExisting,
       marionettePort: args.marionettePort,
+      lookupMarionettePort: args.lookupMarionettePort,
       env: envVars,
       logFile: args.outputFile ?? void 0,
       prefs,
       androidDevice: args.androidDevice ?? void 0,
-      androidPackage: args.androidPackage ?? void 0
+      androidPackage: args.androidPackage ?? void 0,
+      androidWipeAppData: args.androidWipeAppData,
+      captureNetworkBodies: !args.disableNetworkBodyCollection
     };
   }
   firefox2 = new FirefoxClient(options);
@@ -17620,7 +17794,8 @@ async function run(parseArgsFn, importMetaUrl, allowPrivileged = false) {
     moduleNames,
     warnings,
     toolDefinitions: allTools,
-    handlers: toolHandlers
+    handlers: toolHandlers,
+    instructions
   } = buildToolset({
     tools: args.tools,
     preset: args.toolPreset,
@@ -17649,9 +17824,9 @@ async function run(parseArgsFn, importMetaUrl, allowPrivileged = false) {
     },
     {
       capabilities: {
-        resources: {},
         tools: {}
-      }
+      },
+      instructions
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -17683,12 +17858,6 @@ async function run(parseArgsFn, importMetaUrl, allowPrivileged = false) {
       throw error2;
     }
   });
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return { resources: [] };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async () => {
-    throw new Error("Resource reading not implemented");
-  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
   log("Firefox DevTools MCP server running on stdio");
@@ -17700,48 +17869,123 @@ async function run(parseArgsFn, importMetaUrl, allowPrivileged = false) {
     });
     process.exit(0);
   };
-  const onSignal = () => void cleanup();
-  process.on("SIGTERM", onSignal);
-  process.on("SIGINT", onSignal);
-  process.stdin.on("end", onSignal);
-  process.stdin.on("close", onSignal);
+  const onSignal = () => void cleanup();
+  process.on("SIGTERM", onSignal);
+  process.on("SIGINT", onSignal);
+  process.stdin.on("end", onSignal);
+  process.stdin.on("close", onSignal);
+}
+var major, args, firefox2, nextLaunchOptions, pendingWarning;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_server2();
+    init_stdio2();
+    init_types();
+    init_constants();
+    init_logger();
+    init_cli();
+    init_firefox();
+    init_registry();
+    init_response_helpers();
+    [major] = version2.substring(1).split(".").map(Number);
+    if (!major || major < 20) {
+      console.error(`Node ${version2} is not supported. Please use Node.js >=20.`);
+      process.exit(1);
+    }
+    args = {};
+    firefox2 = null;
+    nextLaunchOptions = null;
+    pendingWarning = null;
+  }
+});
+
+// src/utils/save-output.ts
+import { mkdir, rename, stat, unlink, writeFile } from "fs/promises";
+import { randomBytes } from "crypto";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, isAbsolute, join as join3, resolve as resolve3, sep } from "path";
+function homeRoot() {
+  return join3(homedir2(), ".firefox-devtools-mcp");
+}
+function generatedName(baseName, extension) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${baseName}-${timestamp}.${extension}`;
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function assertAllowedPath(saveTo, resolvedPath) {
+  const { args: args2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  if (args2?.unrestrictedSavePaths) {
+    return;
+  }
+  const root = isAbsolute(saveTo) ? homeRoot() : process.cwd();
+  if (resolvedPath !== root && !resolvedPath.startsWith(root + sep)) {
+    throw new Error(
+      `saveTo "${saveTo}" resolves outside the allowed location (${resolvedPath}). Relative paths must stay within the current working directory and absolute paths within ${homeRoot()}. Start the server with --unrestricted-save-paths to write to arbitrary locations.`
+    );
+  }
+}
+async function saveOutput(content, saveTo, baseName, extension = "json") {
+  let resolvedPath;
+  if (saveTo) {
+    resolvedPath = resolve3(saveTo);
+    if (await isDirectory(resolvedPath)) {
+      resolvedPath = join3(resolvedPath, generatedName(baseName, extension));
+    }
+    await assertAllowedPath(saveTo, resolvedPath);
+  } else {
+    resolvedPath = join3(homeRoot(), "output", generatedName(baseName, extension));
+  }
+  await mkdir(dirname2(resolvedPath), { recursive: true });
+  const tmpPath = `${resolvedPath}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmpPath, content);
+    await rename(tmpPath, resolvedPath);
+  } catch (error2) {
+    await unlink(tmpPath).catch(() => void 0);
+    throw error2;
+  }
+  return { path: resolvedPath, bytes: Buffer.byteLength(content) };
+}
+var init_save_output = __esm({
+  "src/utils/save-output.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/module.ts
+function defineModule(config2) {
+  return {
+    name: config2.name,
+    description: config2.description,
+    ...config2.privileged ? { privileged: true } : {},
+    tools: config2.tools.map(([definition, handler]) => ({ definition, handler }))
+  };
 }
-var major, args, firefox2, nextLaunchOptions, pendingWarning;
-var init_src = __esm({
-  "src/index.ts"() {
+var init_module = __esm({
+  "src/tools/module.ts"() {
     "use strict";
-    init_server2();
-    init_stdio2();
-    init_types();
-    init_constants();
-    init_logger();
-    init_cli();
-    init_firefox();
-    init_registry();
-    init_response_helpers();
-    [major] = version2.substring(1).split(".").map(Number);
-    if (!major || major < 20) {
-      console.error(`Node ${version2} is not supported. Please use Node.js >=20.`);
-      process.exit(1);
-    }
-    args = {};
-    firefox2 = null;
-    nextLaunchOptions = null;
-    pendingWarning = null;
   }
 });
 
 // src/tools/pages.ts
 function formatPageList(tabs, selectedIdx) {
   if (tabs.length === 0) {
-    return "\u{1F4C4} No pages";
+    return "No pages";
   }
-  const lines = [`\u{1F4C4} ${tabs.length} pages (selected: ${selectedIdx})`];
+  const lines = [`${tabs.length} pages (selected: ${selectedIdx})`];
   for (const tab of tabs) {
     const idx = tabs.indexOf(tab);
     const marker = idx === selectedIdx ? ">" : " ";
     const title = (tab.title || "Untitled").substring(0, 40);
-    lines.push(`${marker}[${idx}] ${title}`);
+    const url = (tab.url || "URL unavailable").substring(0, 200);
+    lines.push(`${marker}[${idx}] ${title} (${url})`);
   }
   return lines.join("\n");
 }
@@ -17848,12 +18092,57 @@ async function handleClosePage(args2) {
     return errorResponse(error2);
   }
 }
-var listPagesTool, newPageTool, navigatePageTool, selectPageTool, closePageTool, module;
+async function respondWithContent(content, args2, baseName, extension) {
+  const {
+    maxLength = DEFAULT_MAX_CONTENT_CHARS,
+    saveTo,
+    preview
+  } = args2 || {};
+  if (saveTo) {
+    const saved = await saveOutput(
+      content,
+      saveTo === true ? void 0 : saveTo,
+      baseName,
+      extension
+    );
+    let output = `${baseName} saved to: ${saved.path} (${(saved.bytes / 1024).toFixed(1)}KB)`;
+    const excerpt = previewExcerpt(content, preview);
+    if (excerpt) {
+      output += "\nPreview:\n" + excerpt;
+    }
+    return successResponse(output);
+  }
+  if (content.length <= maxLength) {
+    return successResponse(content + `
+
+[full content, ${content.length} chars]`);
+  }
+  const footer = truncationFooter(content.length - maxLength, "chars", [
+    "maxLength to show more",
+    "saveTo to save the full content to a file"
+  ]);
+  return successResponse(content.slice(0, maxLength) + "\n\n" + footer);
+}
+async function handleGetPageText(args2) {
+  try {
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    const text = await firefox3.evaluate(
+      "document.body ? document.body.innerText : document.documentElement.innerText"
+    );
+    return respondWithContent(text ?? "", args2, "page-text", "txt");
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+var DEFAULT_MAX_CONTENT_CHARS, listPagesTool, newPageTool, navigatePageTool, selectPageTool, closePageTool, getPageTextTool, module;
 var init_pages2 = __esm({
   "src/tools/pages.ts"() {
     "use strict";
     init_response_helpers();
+    init_save_output();
     init_module();
+    DEFAULT_MAX_CONTENT_CHARS = 2e4;
     listPagesTool = {
       name: "list_pages",
       description: "List open tabs (index, title, URL). Selected tab is marked.",
@@ -17941,6 +18230,30 @@ var init_pages2 = __esm({
         required: ["pageIdx"]
       }
     };
+    getPageTextTool = {
+      name: "get_page_text",
+      description: "Get the visible text of the page (document.body.innerText). Caps at maxLength (default 20000 chars); saveTo saves the full text to a file.",
+      annotations: {
+        readOnlyHint: true
+      },
+      inputSchema: {
+        type: "object",
+        properties: {
+          maxLength: {
+            type: "number",
+            description: "Max characters to return inline (default: 20000). Ignored when saveTo is used."
+          },
+          saveTo: {
+            type: ["boolean", "string"],
+            description: "Save the full untruncated text to a file instead of returning it inline. Pass a file path, an existing directory (generated file inside), or true (generated file under ~/.firefox-devtools-mcp/output/). Relative paths resolve against the current working directory."
+          },
+          preview: {
+            type: "number",
+            description: "Number of characters of the saved text to return inline as a preview when saveTo is used. Omit for no preview."
+          }
+        }
+      }
+    };
     module = defineModule({
       name: "pages",
       description: "Open, navigate, select, and close pages.",
@@ -17949,7 +18262,8 @@ var init_pages2 = __esm({
         [newPageTool, handleNewPage],
         [navigatePageTool, handleNavigatePage],
         [selectPageTool, handleSelectPage],
-        [closePageTool, handleClosePage]
+        [closePageTool, handleClosePage],
+        [getPageTextTool, handleGetPageText]
       ]
     });
   }
@@ -17969,65 +18283,6 @@ var init_uid_helpers = __esm({
   }
 });
 
-// src/utils/save-output.ts
-import { mkdir, rename, stat, unlink, writeFile } from "fs/promises";
-import { randomBytes } from "crypto";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, isAbsolute, join as join3, resolve as resolve3, sep } from "path";
-function homeRoot() {
-  return join3(homedir2(), ".firefox-devtools-mcp");
-}
-function generatedName(baseName, extension) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return `${baseName}-${timestamp}.${extension}`;
-}
-async function isDirectory(path) {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function assertAllowedPath(saveTo, resolvedPath) {
-  const { args: args2 } = await Promise.resolve().then(() => (init_src(), src_exports));
-  if (args2?.unrestrictedSavePaths) {
-    return;
-  }
-  const root = isAbsolute(saveTo) ? homeRoot() : process.cwd();
-  if (resolvedPath !== root && !resolvedPath.startsWith(root + sep)) {
-    throw new Error(
-      `saveTo "${saveTo}" resolves outside the allowed location (${resolvedPath}). Relative paths must stay within the current working directory and absolute paths within ${homeRoot()}. Start the server with --unrestricted-save-paths to write to arbitrary locations.`
-    );
-  }
-}
-async function saveOutput(content, saveTo, baseName, extension = "json") {
-  let resolvedPath;
-  if (saveTo) {
-    resolvedPath = resolve3(saveTo);
-    if (await isDirectory(resolvedPath)) {
-      resolvedPath = join3(resolvedPath, generatedName(baseName, extension));
-    }
-    await assertAllowedPath(saveTo, resolvedPath);
-  } else {
-    resolvedPath = join3(homeRoot(), "output", generatedName(baseName, extension));
-  }
-  await mkdir(dirname2(resolvedPath), { recursive: true });
-  const tmpPath = `${resolvedPath}.${randomBytes(6).toString("hex")}.tmp`;
-  try {
-    await writeFile(tmpPath, content);
-    await rename(tmpPath, resolvedPath);
-  } catch (error2) {
-    await unlink(tmpPath).catch(() => void 0);
-    throw error2;
-  }
-  return { path: resolvedPath, bytes: Buffer.byteLength(content) };
-}
-var init_save_output = __esm({
-  "src/utils/save-output.ts"() {
-    "use strict";
-  }
-});
-
 // src/tools/snapshot.ts
 async function handleTakeSnapshot(args2) {
   try {
@@ -18063,6 +18318,9 @@ async function handleTakeSnapshot(args2) {
     if (maxDepth !== void 0) {
       options.maxDepth = maxDepth;
     }
+    if (saveTo) {
+      options.maxAttrLength = Infinity;
+    }
     const formattedText = formatSnapshotTree2(snapshot.json.root, 0, options);
     if (saveTo) {
       const saved = await saveOutput(
@@ -18071,7 +18329,7 @@ async function handleTakeSnapshot(args2) {
         "snapshot",
         "txt"
       );
-      let output2 = `Snapshot (id=${snapshot.json.snapshotId}) saved to: ${saved.path} (${(saved.bytes / 1024).toFixed(1)}KB)`;
+      let output2 = `Snapshot saved to: ${saved.path} (${(saved.bytes / 1024).toFixed(1)}KB)`;
       if (snapshot.json.truncated) {
         output2 += " [DOM truncated]";
       }
@@ -18084,7 +18342,7 @@ async function handleTakeSnapshot(args2) {
     const lines = formattedText.split("\n");
     const truncated = lines.length > maxLines;
     const displayLines = truncated ? lines.slice(0, maxLines) : lines;
-    let output = `\u{1F4F8} Snapshot (id=${snapshot.json.snapshotId})`;
+    let output = "Snapshot";
     if (selector) {
       output += ` [selector: ${selector}]`;
     }
@@ -18100,9 +18358,11 @@ async function handleTakeSnapshot(args2) {
     output += "\n\n";
     output += displayLines.join("\n");
     if (truncated) {
-      output += `
-
-[+${lines.length - maxLines} lines, use maxLines to see more]`;
+      output += "\n\n" + truncationFooter(lines.length - maxLines, "lines", [
+        "maxLines to show more",
+        "selector to scope",
+        "saveTo to dump the full tree to a file"
+      ]);
     }
     return successResponse(output);
   } catch (error2) {
@@ -18124,7 +18384,7 @@ async function handleResolveUidToSelector(args2) {
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const firefox3 = await getFirefox2();
     try {
-      const selector = firefox3.resolveUidToSelector(uid);
+      const selector = await firefox3.resolveUidToSelector(uid);
       return successResponse(`${uid} \u2192 ${selector}`);
     } catch (error2) {
       throw handleUidError(error2, uid);
@@ -18137,7 +18397,7 @@ async function handleClearSnapshot(_args) {
   try {
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const firefox3 = await getFirefox2();
-    firefox3.clearSnapshot();
+    await firefox3.clearSnapshot();
     return successResponse("\u{1F9F9} Snapshot cleared");
   } catch (error2) {
     return errorResponse(error2);
@@ -18154,7 +18414,7 @@ var init_snapshot2 = __esm({
     DEFAULT_SNAPSHOT_LINES = 100;
     takeSnapshotTool = {
       name: "take_snapshot",
-      description: "Capture DOM snapshot with stable UIDs. Retake after navigation.",
+      description: "Capture DOM snapshot with stable UIDs. A UID stays valid across snapshots until its element is removed or the page navigates. Output caps at maxLines (default 100); scope with selector or dump the full tree with saveTo.",
       annotations: {
         readOnlyHint: true
       },
@@ -18198,7 +18458,7 @@ var init_snapshot2 = __esm({
     };
     resolveUidToSelectorTool = {
       name: "resolve_uid_to_selector",
-      description: "Resolve UID to CSS selector. Fails if stale.",
+      description: "Resolve UID to CSS selector. Fails if the element is gone.",
       annotations: {
         readOnlyHint: true
       },
@@ -18215,7 +18475,7 @@ var init_snapshot2 = __esm({
     };
     clearSnapshotTool = {
       name: "clear_snapshot",
-      description: "Clear snapshot cache. Usually not needed.",
+      description: "Clear snapshot UIDs. Usually not needed.",
       annotations: {
         readOnlyHint: false
       },
@@ -18535,6 +18795,55 @@ var init_input = __esm({
 });
 
 // src/tools/network.ts
+async function safeFetchBody(firefox3, id, dataType) {
+  if (typeof firefox3.getNetworkRequestBody !== "function") {
+    return { ok: false, reason: "unsupported" };
+  }
+  try {
+    return await firefox3.getNetworkRequestBody(id, dataType);
+  } catch {
+    return { ok: false, reason: "error" };
+  }
+}
+function bodyUnavailableMarker(reason) {
+  switch (reason) {
+    case "unsupported":
+      return "<not captured: body collection not supported by this Firefox>";
+    case "not-collected":
+      return "<not captured>";
+    case "evicted":
+      return "<not available: evicted from the capture buffer>";
+    case "aborted":
+      return "<not available: collection aborted>";
+    default:
+      return "<not available>";
+  }
+}
+function hasRequestBody(result) {
+  return result.ok || result.reason === "evicted" || result.reason === "aborted";
+}
+function renderBodyInline(result) {
+  if (!result.ok) {
+    return { body: bodyUnavailableMarker(result.reason) };
+  }
+  if (result.type === "base64") {
+    const approxKb = (result.value.length * 3 / 4 / 1024).toFixed(1);
+    return {
+      body: `<binary data (~${approxKb}KB); use saveTo to retrieve the full body>`,
+      encoding: "base64"
+    };
+  }
+  return { body: truncateText(result.value, TOKEN_LIMITS.MAX_RESPONSE_CHARS) };
+}
+function renderBodyForFile(result) {
+  if (!result.ok) {
+    return { body: null, encoding: null, unavailable: result.reason };
+  }
+  return {
+    body: result.value,
+    encoding: result.type === "base64" ? "base64" : "utf-8"
+  };
+}
 async function handleListNetworkRequests(args2) {
   try {
     const {
@@ -18643,6 +18952,11 @@ async function handleListNetworkRequests(args2) {
     const effectiveDetail = detail ?? "summary";
     const limitedRequests = requests.slice(0, effectiveLimit);
     const hasMore = requests.length > effectiveLimit;
+    const moreFooter = hasMore ? "\n" + truncationFooter(requests.length - limitedRequests.length, "requests", [
+      "limit to show more",
+      "urlContains/method/status to filter",
+      "saveTo to save all to a file"
+    ]) : "";
     if (format === "json") {
       const responseData = {
         total: requests.length,
@@ -18684,7 +18998,7 @@ async function handleListNetworkRequests(args2) {
       });
       const header = `[network] ${requests.length} requests${hasMore ? ` (limit ${effectiveLimit})` : ""}
 `;
-      return successResponse(header + formattedRequests.join("\n"));
+      return successResponse(header + formattedRequests.join("\n") + moreFooter);
     } else if (effectiveDetail === "min") {
       const minData = limitedRequests.map((req) => ({
         id: req.id,
@@ -18698,7 +19012,7 @@ async function handleListNetworkRequests(args2) {
       }));
       return successResponse(
         `[network] ${requests.length} requests${hasMore ? ` (limit ${effectiveLimit})` : ""}
-` + JSON.stringify(minData, null, 2)
+` + JSON.stringify(minData, null, 2) + moreFooter
       );
     } else {
       const fullData = limitedRequests.map((req) => ({
@@ -18715,7 +19029,7 @@ async function handleListNetworkRequests(args2) {
       }));
       return successResponse(
         `[network] ${requests.length} requests${hasMore ? ` (limit ${effectiveLimit})` : ""}
-` + JSON.stringify(fullData, null, 2)
+` + JSON.stringify(fullData, null, 2) + moreFooter
       );
     }
   } catch (error2) {
@@ -18764,8 +19078,29 @@ async function handleGetNetworkRequest(args2) {
       requestHeaders: request.requestHeaders ?? null,
       responseHeaders: request.responseHeaders ?? null
     };
+    const [responseBodyResult, requestBodyResult] = await Promise.all([
+      safeFetchBody(firefox3, request.id, "response"),
+      safeFetchBody(firefox3, request.id, "request")
+    ]);
     if (saveTo) {
-      const fileBody = JSON.stringify(fullDetails, null, 2);
+      const responseFile = renderBodyForFile(responseBodyResult);
+      const fileObject = {
+        ...fullDetails,
+        responseBody: responseFile.body,
+        responseBodyEncoding: responseFile.encoding
+      };
+      if (responseFile.unavailable) {
+        fileObject.responseBodyUnavailable = responseFile.unavailable;
+      }
+      if (hasRequestBody(requestBodyResult)) {
+        const requestFile = renderBodyForFile(requestBodyResult);
+        fileObject.requestBody = requestFile.body;
+        fileObject.requestBodyEncoding = requestFile.encoding;
+        if (requestFile.unavailable) {
+          fileObject.requestBodyUnavailable = requestFile.unavailable;
+        }
+      }
+      const fileBody = JSON.stringify(fileObject, null, 2);
       const saved = await saveOutput(
         fileBody,
         saveTo === true ? void 0 : saveTo,
@@ -18778,11 +19113,23 @@ async function handleGetNetworkRequest(args2) {
       }
       return successResponse(output);
     }
+    const responseInline = renderBodyInline(responseBodyResult);
     const details = {
       ...fullDetails,
       requestHeaders: truncateHeaders(request.requestHeaders),
-      responseHeaders: truncateHeaders(request.responseHeaders)
+      responseHeaders: truncateHeaders(request.responseHeaders),
+      responseBody: responseInline.body
     };
+    if (responseInline.encoding) {
+      details.responseBodyEncoding = responseInline.encoding;
+    }
+    if (hasRequestBody(requestBodyResult)) {
+      const requestInline = renderBodyInline(requestBodyResult);
+      details.requestBody = requestInline.body;
+      if (requestInline.encoding) {
+        details.requestBodyEncoding = requestInline.encoding;
+      }
+    }
     if (format === "json") {
       return jsonResponse(details);
     }
@@ -18800,7 +19147,7 @@ var init_network2 = __esm({
     init_module();
     listNetworkRequestsTool = {
       name: "list_network_requests",
-      description: "List network requests. Returns IDs for get_network_request.",
+      description: "List network requests, returning IDs for get_network_request. Filter by url/method/status; caps at limit (default 50); saveTo saves all matches to a file.",
       annotations: {
         readOnlyHint: true
       },
@@ -18871,7 +19218,7 @@ var init_network2 = __esm({
     };
     getNetworkRequestTool = {
       name: "get_network_request",
-      description: "Get request details by ID. URL lookup as fallback.",
+      description: "Get request details by ID, including the response body (and request body when present). Large text bodies are truncated inline; binary bodies are summarized. URL lookup as fallback.",
       annotations: {
         readOnlyHint: true
       },
@@ -18893,7 +19240,7 @@ var init_network2 = __esm({
           },
           saveTo: {
             type: ["boolean", "string"],
-            description: "Save the request details with full untruncated headers to a file as JSON instead of returning them inline. Pass a file path, an existing directory (generated file inside), or true (generated file under ~/.firefox-devtools-mcp/output/). Relative paths resolve against the current working directory."
+            description: "Save the request details with full untruncated headers and bodies to a file as JSON instead of returning them inline (binary bodies are stored base64-encoded). Pass a file path, an existing directory (generated file inside), or true (generated file under ~/.firefox-devtools-mcp/output/). Relative paths resolve against the current working directory."
           },
           preview: {
             type: "number",
@@ -19072,8 +19419,11 @@ Total messages: ${totalCount}${filterInfo.length > 0 ? `, Filters: ${filterInfo.
 `;
     }
     if (truncated) {
-      output += `
-[+${filteredCount - messages.length} more]`;
+      output += "\n" + truncationFooter(filteredCount - messages.length, "messages", [
+        "limit to show more",
+        "level/textContains/source to filter",
+        "saveTo to save all to a file"
+      ]);
     }
     return successResponse(output);
   } catch (error2) {
@@ -19100,7 +19450,7 @@ var init_console2 = __esm({
     init_module();
     listConsoleMessagesTool = {
       name: "list_console_messages",
-      description: "List console messages. Supports filtering by level, time, text, source.",
+      description: "List console messages, filterable by level, time, text, source. Caps at limit (default 50); saveTo saves all matches to a file.",
       annotations: {
         readOnlyHint: true
       },
@@ -19570,7 +19920,7 @@ var init_utilities = __esm({
 });
 
 // src/tools/firefox-management.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3, statSync as statSync2 } from "fs";
 async function handleGetFirefoxLogs(input) {
   try {
     const {
@@ -19598,7 +19948,7 @@ async function handleGetFirefoxLogs(input) {
         );
       }
     }
-    const content = readFileSync2(logFilePath, "utf-8");
+    const content = readFileSync3(logFilePath, "utf-8");
     let allLines = content.split("\n").filter((line) => line.trim().length > 0);
     if (grep) {
       const grepLower = grep.toLowerCase();
@@ -20488,67 +20838,6 @@ var init_screencast = __esm({
   }
 });
 
-// src/utils/remote-value.ts
-function remoteValueToNative(rv) {
-  if (!rv || typeof rv !== "object") {
-    return rv;
-  }
-  const { type, value } = rv;
-  switch (type) {
-    case "undefined":
-      return void 0;
-    case "null":
-      return null;
-    case "string":
-    case "boolean":
-      return value;
-    case "number":
-      if (value === "NaN") {
-        return "NaN";
-      }
-      if (value === "Infinity") {
-        return "Infinity";
-      }
-      if (value === "-Infinity") {
-        return "-Infinity";
-      }
-      if (value === "-0") {
-        return "-0";
-      }
-      return value;
-    case "bigint":
-      return `${value}n`;
-    case "array":
-      return value.map(remoteValueToNative);
-    case "object":
-      return Object.fromEntries(
-        value.map(([k, v]) => [k, remoteValueToNative(v)])
-      );
-    case "map":
-      return Object.fromEntries(
-        value.map(([k, v]) => [
-          typeof k === "object" ? JSON.stringify(remoteValueToNative(k)) : String(k),
-          remoteValueToNative(v)
-        ])
-      );
-    case "set":
-      return value.map(remoteValueToNative);
-    case "regexp": {
-      const { pattern, flags } = value;
-      return `/${pattern}/${flags ?? ""}`;
-    }
-    case "date":
-      return value;
-    default:
-      return `[${type}]`;
-  }
-}
-var init_remote_value = __esm({
-  "src/utils/remote-value.ts"() {
-    "use strict";
-  }
-});
-
 // src/utils/js-validation.ts
 function validateFunction(fnString) {
   if (!fnString || typeof fnString !== "string") {
@@ -20588,6 +20877,7 @@ async function handleEvaluateScript(args2) {
       function: fnString,
       args: fnArgs,
       timeout,
+      sandbox,
       saveTo,
       preview
     } = args2;
@@ -20619,7 +20909,7 @@ Please call take_snapshot to get fresh UIDs and try again.`
       functionDeclaration: fnString,
       awaitPromise: true,
       arguments: resolvedArgs,
-      target: { context: firefox3.getCurrentContextId() }
+      target: { context: firefox3.getCurrentContextId(), ...sandbox !== void 0 && { sandbox } }
     });
     const result = await Promise.race([
       new Promise((r) => setTimeout(() => r(TIMEOUT), scriptTimeout)),
@@ -20678,7 +20968,7 @@ var init_script = __esm({
     init_module();
     evaluateScriptTool = {
       name: "evaluate_script",
-      description: "Execute JS function in page. Prefer UID tools for interactions.",
+      description: "Run a JS function in the page and return its result. Prefer this for targeted reads (a value, text, computed style, whether an element exists) instead of a full take_snapshot. Use the UID interaction tools for clicking, typing, and filling.",
       annotations: {
         readOnlyHint: false
       },
@@ -20707,6 +20997,10 @@ var init_script = __esm({
             type: "number",
             description: "Timeout in ms (default: 5000)"
           },
+          sandbox: {
+            type: "string",
+            description: "Evaluate in an isolated sandbox realm with this name instead of the page realm. The sandbox shares the page DOM and keeps the native built-ins even where the page overrode them. Page-defined globals and expandos are invisible from the sandbox, and vice-versa. The same name reuses the same sandbox across calls; omit to evaluate in the page realm."
+          },
           saveTo: {
             type: ["boolean", "string"],
             description: "Save the result to a file as JSON instead of returning it inline. Pass a file path, an existing directory (generated file inside), or true (generated file under ~/.firefox-devtools-mcp/output/). Relative paths resolve against the current working directory."
@@ -21182,6 +21476,25 @@ function formatContextList(contexts) {
   }
   return lines.join("\n");
 }
+async function assertPrivilegedContext(firefox3, contextId) {
+  let result;
+  try {
+    result = await firefox3.sendBiDiCommand("browsingContext.getTree", {
+      "moz:scope": "chrome"
+    });
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message.includes("UnsupportedOperationError")) {
+      throw new Error(SYSTEM_ACCESS_ERROR);
+    }
+    throw error2;
+  }
+  const contexts = result.contexts || [];
+  if (!contexts.some((ctx) => ctx.context === contextId)) {
+    throw new Error(
+      `${contextId} is not a privileged context. Use list_privileged_contexts to see valid ids.`
+    );
+  }
+}
 async function handleListPrivilegedContexts(_args) {
   try {
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -21193,11 +21506,7 @@ async function handleListPrivilegedContexts(_args) {
     return successResponse(formatContextList(contexts));
   } catch (error2) {
     if (error2 instanceof Error && error2.message.includes("UnsupportedOperationError")) {
-      return errorResponse(
-        new Error(
-          "Privileged context access not enabled. Set MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 environment variable and restart Firefox."
-        )
-      );
+      return errorResponse(new Error(SYSTEM_ACCESS_ERROR));
     }
     return errorResponse(error2);
   }
@@ -21210,6 +21519,7 @@ async function handleSelectPrivilegedContext(args2) {
     }
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const firefox3 = await getFirefox2();
+    await assertPrivilegedContext(firefox3, contextId);
     const driver = firefox3.getDriver();
     await driver.switchTo().window(contextId);
     try {
@@ -21233,17 +21543,22 @@ async function handleEvaluatePrivilegedScript(args2) {
   try {
     const {
       function: fnString,
+      context,
       saveTo,
       preview
     } = args2;
     validateFunction(fnString);
+    if (!context || typeof context !== "string") {
+      throw new Error("context parameter is required and must be a string");
+    }
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const firefox3 = await getFirefox2();
+    await assertPrivilegedContext(firefox3, context);
     const result = await firefox3.sendBiDiCommand("script.callFunction", {
       functionDeclaration: fnString,
       awaitPromise: true,
       arguments: [],
-      target: { context: firefox3.getCurrentContextId() }
+      target: { context }
     });
     if (result.type === EvaluateResultType2.Success) {
       const json = JSON.stringify(remoteValueToNative(result.result), null, 2) ?? "undefined";
@@ -21280,7 +21595,7 @@ async function handleEvaluatePrivilegedScript(args2) {
     return errorResponse(error2);
   }
 }
-var listPrivilegedContextsTool, selectPrivilegedContextTool, evaluatePrivilegedScriptTool, EvaluateResultType2, module16;
+var listPrivilegedContextsTool, selectPrivilegedContextTool, evaluatePrivilegedScriptTool, SYSTEM_ACCESS_ERROR, EvaluateResultType2, module16;
 var init_privileged_context = __esm({
   "src/tools/privileged-context.ts"() {
     "use strict";
@@ -21320,7 +21635,7 @@ var init_privileged_context = __esm({
     };
     evaluatePrivilegedScriptTool = {
       name: "evaluate_privileged_script",
-      description: "Execute JS function in the current privileged context. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var. Use select_privileged_context first to target a chrome context.",
+      description: "Execute JS function in a privileged (chrome) browsing context. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var. Get context ids from list_privileged_contexts.",
       annotations: {
         readOnlyHint: false
       },
@@ -21331,6 +21646,10 @@ var init_privileged_context = __esm({
             type: "string",
             description: 'JS function string, e.g. () => Services.prefs.getBoolPref("foo")'
           },
+          context: {
+            type: "string",
+            description: "Privileged browsing context ID from list_privileged_contexts"
+          },
           saveTo: {
             type: ["boolean", "string"],
             description: "Save the result to a file as JSON instead of returning it inline. Pass a file path, an existing directory (generated file inside), or true (generated file under ~/.firefox-devtools-mcp/output/). Relative paths resolve against the current working directory."
@@ -21340,9 +21659,10 @@ var init_privileged_context = __esm({
             description: "Number of characters of the saved result to return inline as a preview when saveTo is used. Omit for no preview."
           }
         },
-        required: ["function"]
+        required: ["function", "context"]
       }
     };
+    SYSTEM_ACCESS_ERROR = "Privileged context access not enabled. Set MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 environment variable and restart Firefox.";
     EvaluateResultType2 = {
       Exception: "exception",
       Success: "success"
@@ -21547,6 +21867,12 @@ var init_cli = __esm({
         description: "Marionette port to connect to when using --connect-existing (default: 2828)",
         default: Number(process.env.MARIONETTE_PORT ?? "2828")
       },
+      lookupMarionettePort: {
+        type: "boolean",
+        hidden: true,
+        description: "Lookup the port of a Marionette instance started by Firefox's AI assistant companion, instead of using --marionette-port. Only applies when --connect-existing is set.",
+        default: (process.env.LOOKUP_MARIONETTE_PORT ?? "false") === "true"
+      },
       env: {
         type: "array",
         description: "Environment variables for Firefox in KEY=VALUE format. Can be specified multiple times. Example: --env MOZ_LOG=HTMLMediaElement:4"
@@ -21570,6 +21896,11 @@ var init_cli = __esm({
         description: "Android app package name (default: org.mozilla.firefox). Use org.mozilla.fenix for Nightly.",
         default: process.env.ANDROID_PACKAGE ?? "org.mozilla.firefox"
       },
+      androidWipeAppData: {
+        type: "boolean",
+        description: "Confirm that connecting to Firefox for Android wipes all data of the target app (tabs, history, bookmarks, passwords, settings). Required with --android-device.",
+        default: (process.env.ANDROID_WIPE_APP_DATA ?? "false") === "true"
+      },
       logFile: {
         type: "string",
         description: "Path to a file where MCP server logs will be written. Set DEBUG=* to also enable verbose debug logs."
@@ -21604,6 +21935,12 @@ var init_cli = __esm({
         type: "boolean",
         description: "Allow tools that save files (e.g. screenshots, snapshots, network/console output) to write to arbitrary locations. By default, relative save paths resolve against the current working directory and absolute save paths are restricted to ~/.firefox-devtools-mcp; this flag lifts both restrictions. Use with caution.",
         default: (process.env.UNRESTRICTED_SAVE_PATHS ?? "false") === "true"
+      },
+      disableNetworkBodyCollection: {
+        type: "boolean",
+        hidden: true,
+        description: "Disable capturing network request/response bodies via BiDi data collectors. get_network_request will still return metadata and headers but no bodies. Reduces browser memory and stream-cloning overhead.",
+        default: (process.env.DISABLE_NETWORK_BODY_COLLECTION ?? "false") === "true"
       }
     };
   }