@mozilla/firefox-devtools-mcp 0.9.15 → 0.10.0

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.0" : "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);
@@ -15397,6 +15479,67 @@ var init_core3 = __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/firefox/events/console.ts
 var MAX_CONSOLE_MESSAGES, CONSOLE_TTL_MS, ConsoleEvents;
 var init_console = __esm({
@@ -15454,9 +15597,6 @@ var init_console = __esm({
               if (this.options.autoClearOnNavigate) {
                 this.clearMessages();
               }
-              if (this.options.onNavigate) {
-                this.options.onNavigate();
-              }
             }
           } catch {
           }
@@ -15499,16 +15639,18 @@ 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 = {}) {
+      constructor(driver, options = {}, sendCommand) {
         this.driver = driver;
+        this.sendCommand = sendCommand;
         this.options = {
           autoClearOnNavigate: true,
           ...options
@@ -15519,6 +15661,7 @@ 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)
@@ -15547,9 +15690,6 @@ var init_network = __esm({
               if (this.enabled && this.options.autoClearOnNavigate) {
                 this.clearRequests();
               }
-              if (this.options.onNavigate) {
-                this.options.onNavigate();
-              }
               return;
             }
             if (!this.enabled) {
@@ -15611,10 +15751,77 @@ var init_network = __esm({
           } catch {
           }
         });
+        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;
+        }
+        if (!this.sendCommand) {
+          return;
+        }
+        try {
+          const result = await this.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.sendCommand || !this.collectorId) {
+          return { ok: false, reason: "unsupported" };
+        }
+        try {
+          const result = await this.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
        */
@@ -16033,19 +16240,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 +16703,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 +16718,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 +16792,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 +16820,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
-       */
-      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)
+       * Forget all UID associations in the page, making existing UIDs unresolvable.
+       * Best effort: the registry dies with the page anyway.
        */
-      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 +16887,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 +16916,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 +16935,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 +16975,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;
@@ -16922,6 +17053,7 @@ var init_firefox = __esm({
     "use strict";
     init_core3();
     init_logger();
+    init_remote_value();
     init_events();
     init_dom();
     init_pages();
@@ -16945,21 +17077,19 @@ var init_firefox = __esm({
         await this.core.connect();
         const driver = this.core.getDriver();
         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.networkEvents = new NetworkEvents(
+            driver,
+            {
+              autoClearOnNavigate: false,
+              captureBodies: this.core.getOptions().captureNetworkBodies !== false
+            },
+            (method, params) => this.core.sendBiDiCommand(method, params ?? {})
+          );
           this.debuggingEvents = new DebuggingEvents(
             driver,
             (method, params) => this.core.sendBiDiCommand(method, params)
@@ -17012,17 +17142,24 @@ var init_firefox = __esm({
       // ============================================================================
       // 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.core.sendBiDiCommand("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 +17255,6 @@ var init_firefox = __esm({
           throw new Error("Not connected");
         }
         await this.pages.navigate(url);
-        this.clearSnapshot();
       }
       async navigateBack() {
         if (!this.pages) {
@@ -17221,6 +17357,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
       // ============================================================================
@@ -17257,11 +17405,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 +17417,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
@@ -17579,11 +17727,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);
@@ -17649,7 +17800,6 @@ async function run(parseArgsFn, importMetaUrl, allowPrivileged = false) {
     },
     {
       capabilities: {
-        resources: {},
         tools: {}
       }
     }
@@ -17683,12 +17833,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");
@@ -17731,26 +17875,101 @@ var init_src = __esm({
   }
 });
 
-// src/tools/pages.ts
-function formatPageList(tabs, selectedIdx) {
-  if (tabs.length === 0) {
-    return "\u{1F4C4} No pages";
-  }
-  const lines = [`\u{1F4C4} ${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}`);
-  }
-  return lines.join("\n");
+// 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");
 }
-async function handleListPages(_args) {
+function generatedName(baseName, extension) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${baseName}-${timestamp}.${extension}`;
+}
+async function isDirectory(path) {
   try {
-    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
-    const firefox3 = await getFirefox2();
-    await firefox3.refreshTabs();
-    const tabs = firefox3.getTabs();
+    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 init_module = __esm({
+  "src/tools/module.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/pages.ts
+function formatPageList(tabs, selectedIdx) {
+  if (tabs.length === 0) {
+    return "No pages";
+  }
+  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);
+    const url = (tab.url || "URL unavailable").substring(0, 200);
+    lines.push(`${marker}[${idx}] ${title} (${url})`);
+  }
+  return lines.join("\n");
+}
+async function handleListPages(_args) {
+  try {
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    await firefox3.refreshTabs();
+    const tabs = firefox3.getTabs();
     const selectedIdx = firefox3.getSelectedTabIdx();
     return successResponse(formatPageList(tabs, selectedIdx));
   } catch (error2) {
@@ -17848,12 +18067,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 +18205,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 +18237,8 @@ var init_pages2 = __esm({
         [newPageTool, handleNewPage],
         [navigatePageTool, handleNavigatePage],
         [selectPageTool, handleSelectPage],
-        [closePageTool, handleClosePage]
+        [closePageTool, handleClosePage],
+        [getPageTextTool, handleGetPageText]
       ]
     });
   }
@@ -17969,65 +18258,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 +18293,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 +18304,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 +18317,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 +18333,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 +18359,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 +18372,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 +18389,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 +18433,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 +18450,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 +18770,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 +18927,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 +18973,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 +18987,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 +19004,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 +19053,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 +19088,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 +19122,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 +19193,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 +19215,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 +19394,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 +19425,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 +19895,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 +19923,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 +20813,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 +20852,7 @@ async function handleEvaluateScript(args2) {
       function: fnString,
       args: fnArgs,
       timeout,
+      sandbox,
       saveTo,
       preview
     } = args2;
@@ -20619,7 +20884,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 +20943,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 +20972,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 +21451,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 +21481,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 +21494,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 +21518,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 +21570,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 +21610,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 +21621,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 +21634,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 +21842,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 +21871,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 +21910,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"
       }
     };
   }