@mozilla/firefox-devtools-mcp 0.9.4 → 0.9.6

package/dist/index.js

@@ -128,8 +128,8 @@ var init_cli = __esm({
       },
       startUrl: {
         type: "string",
-        description: "URL to open when Firefox starts (default: about:home)",
-        default: process.env.START_URL ?? "about:home"
+        description: "URL to open when Firefox starts (default: about:blank)",
+        default: process.env.START_URL ?? "about:blank"
       },
       connectExisting: {
         type: "boolean",
@@ -164,9 +164,13 @@ 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"
       },
+      logFile: {
+        type: "string",
+        description: "Path to a file where MCP server logs will be written. Set DEBUG=* to also enable verbose debug logs."
+      },
       enableScript: {
         type: "boolean",
-        description: "Enable the evaluate_script tool, which allows executing arbitrary JavaScript in the page context.",
+        description: "Enable the script tools such as script evaluation and logpoints (Firefox 153+ required).",
         default: (process.env.ENABLE_SCRIPT ?? "false") === "true"
       },
       enablePrivilegedContext: {
@@ -17762,6 +17766,9 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -17954,27 +17961,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -17989,7 +18046,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -18003,7 +18060,10 @@ var require_utils = __commonJS({
     module.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -18227,12 +18287,12 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse3(serialize(uri, options), options);
@@ -18299,19 +18359,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -18336,12 +18386,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -18376,7 +18426,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -18387,6 +18446,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -18407,6 +18467,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -18445,14 +18510,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -18461,7 +18530,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse3(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -27137,12 +27228,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs, exportName) {
+    function addFormats(ajv, list, fs2, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs[f]);
+        ajv.addFormat(f, fs2[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -27991,27 +28082,76 @@ var init_constants = __esm({
 });
 
 // src/utils/logger.ts
-function log(message, ...args2) {
-  console.error(`[firefox-devtools-mcp] ${message}`, ...args2);
+import fs from "fs";
+function formatArgs(args2) {
+  if (args2.length === 0) {
+    return "";
+  }
+  return " " + args2.map((a) => {
+    if (typeof a === "string") {
+      return a;
+    }
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
 }
-function logError(message, error2) {
-  if (error2 instanceof Error) {
-    console.error(`[firefox-devtools-mcp] ERROR: ${message}`, error2.message);
-    if (error2.stack) {
-      console.error(error2.stack);
+function flushLogs(timeoutMs = 2e3) {
+  if (!logStream) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve4, reject) => {
+    const timeout = setTimeout(reject, timeoutMs);
+    logStream.end(() => {
+      clearTimeout(timeout);
+      resolve4();
+    });
+  });
+}
+function write(message, args2, body) {
+  if (logStream) {
+    logStream.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}${formatArgs(args2)}
+`);
+    if (body) {
+      logStream.write(`${body}
+`);
     }
   } else {
-    console.error(`[firefox-devtools-mcp] ERROR: ${message}`, error2);
+    console.error(message, ...args2);
+    if (body) {
+      console.error(body);
+    }
   }
 }
+function log(message, ...args2) {
+  write(`[firefox-devtools-mcp] ${message}`, args2);
+}
 function logDebug(message, ...args2) {
   if (process.env.DEBUG === "*" || process.env.DEBUG?.includes("firefox-devtools")) {
-    console.error(`[firefox-devtools-mcp] DEBUG: ${message}`, ...args2);
+    write(`[firefox-devtools-mcp] DEBUG: ${message}`, args2);
   }
 }
+function logError(message, error2) {
+  if (error2 instanceof Error) {
+    write(`[firefox-devtools-mcp] ERROR: ${message}`, [error2.message], error2.stack);
+  } else {
+    write(`[firefox-devtools-mcp] ERROR: ${message}`, [error2]);
+  }
+}
+function setupLogFile(filePath) {
+  logStream = fs.createWriteStream(filePath, { flags: "a" });
+  logStream.on("error", (error2) => {
+    console.error(`[firefox-devtools-mcp] Error writing to log file: ${error2.message}`);
+    logStream = null;
+  });
+}
+var logStream;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
+    logStream = null;
   }
 });
 
@@ -28123,11 +28263,12 @@ var init_core3 = __esm({
       constructor(options) {
         this.options = options;
       }
-      driver = null;
       currentContextId = null;
-      originalEnv = {};
-      logFilePath;
+      driver = null;
+      firefoxVersion = null;
       logFileFd;
+      logFilePath;
+      originalEnv = {};
       profileWarning = null;
       /**
        * Launch Firefox (or connect to an existing instance) and establish BiDi connection
@@ -28219,6 +28360,9 @@ var init_core3 = __esm({
             for (const [name, value] of Object.entries(this.options.prefs)) {
               firefoxOptions.setPreference(name, value);
             }
+            if (this.options.prefs["remote.prefs.recommended"] === false && !("app.update.disabledForTesting" in this.options.prefs)) {
+              firefoxOptions.setPreference("app.update.disabledForTesting", true);
+            }
           }
           let serviceBuilder;
           if (process.platform === "win32") {
@@ -28233,11 +28377,18 @@ var init_core3 = __esm({
             serviceBuilder.setStdio(["ignore", this.logFileFd, this.logFileFd]);
             log(`Capturing Firefox output to: ${this.logFilePath}`);
           }
+          const remoteLogLevel = this.options.prefs?.["remote.log.level"];
+          if (remoteLogLevel && typeof remoteLogLevel === "string") {
+            serviceBuilder.addArguments("--log", remoteLogLevel.toLowerCase());
+          }
           this.driver = await new Builder().forBrowser(Browser.FIREFOX).setFirefoxOptions(firefoxOptions).setFirefoxService(serviceBuilder).build();
         }
         log(
           this.options.connectExisting ? "Connected to existing Firefox" : "Firefox launched with BiDi"
         );
+        const driverCapabilities = await this.driver.getCapabilities();
+        this.firefoxVersion = driverCapabilities.get("browserVersion") ?? null;
+        logDebug(`Browser version: ${this.firefoxVersion}`);
         this.currentContextId = await this.driver.getWindowHandle();
         logDebug(`Browsing context ID: ${this.currentContextId}`);
         if (this.options.startUrl && !this.options.connectExisting) {
@@ -28271,24 +28422,6 @@ var init_core3 = __esm({
           return false;
         }
       }
-      /**
-       * Reset driver state (used when Firefox is detected as closed)
-       */
-      reset() {
-        if (this.driver) {
-          const d = this.driver;
-          if (d._bidiConnection) {
-            d._bidiConnection.close();
-            d._bidiConnection = void 0;
-          }
-          if ("quit" in this.driver) {
-            void this.driver.quit();
-          }
-        }
-        this.driver = null;
-        this.currentContextId = null;
-        logDebug("Driver state reset");
-      }
       /**
        * Get current browsing context ID
        */
@@ -28301,6 +28434,12 @@ var init_core3 = __esm({
       setCurrentContextId(contextId) {
         this.currentContextId = contextId;
       }
+      /**
+       * Get the current firefox version, as a string (eg "153.0a1")
+       */
+      getFirefoxVersion() {
+        return this.firefoxVersion;
+      }
       /**
        * Get log file path
        */
@@ -28386,20 +28525,47 @@ var init_core3 = __esm({
       }
       /**
        * Close driver and cleanup.
-       * When connected to an existing Firefox instance, only kills geckodriver
-       * without closing the browser.
+       * - Tries graceful quit() with a timeout; on timeout, force-kills via onQuit_().
+       * - Restores env vars, closes log fd, clears all state.
+       * - Never throws — callers can rely on cleanup completing.
        */
       async close() {
-        if (this.driver) {
-          const d = this.driver;
-          if (d._bidiConnection) {
-            d._bidiConnection.close();
-            d._bidiConnection = void 0;
+        if (!this.driver) {
+          return;
+        }
+        const webdriver = this.driver;
+        const webdriverQuitTimeout = 5e3;
+        this.driver = null;
+        this.currentContextId = null;
+        this.logFilePath = void 0;
+        this.profileWarning = null;
+        if (webdriver._bidiConnection) {
+          try {
+            webdriver._bidiConnection.close();
+          } catch {
+          } finally {
+            webdriver._bidiConnection = void 0;
           }
-          if ("quit" in this.driver) {
-            await this.driver.quit();
+        }
+        if ("quit" in webdriver) {
+          let timer;
+          try {
+            await Promise.race([
+              webdriver.quit(),
+              new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error("close timeout")), webdriverQuitTimeout);
+              })
+            ]);
+          } catch {
+            const webdriverHasOnQuit = typeof webdriver.onQuit_ === "function";
+            logDebug("WebDriver.quit() timed out or failed - force killing geckodriver");
+            if (webdriverHasOnQuit) {
+              void webdriver.onQuit_().catch(() => {
+              });
+            }
+          } finally {
+            clearTimeout(timer);
           }
-          this.driver = null;
         }
         if (this.logFileFd !== void 0) {
           try {
@@ -28789,12 +28955,135 @@ var init_network = __esm({
   }
 });
 
+// src/firefox/events/debugging.ts
+var MAX_LOGPOINT_RESULTS, DebuggingEvents;
+var init_debugging = __esm({
+  "src/firefox/events/debugging.ts"() {
+    "use strict";
+    init_logger();
+    MAX_LOGPOINT_RESULTS = 100;
+    DebuggingEvents = class {
+      constructor(driver, sendBiDiCommand) {
+        this.driver = driver;
+        this.sendBiDiCommand = sendBiDiCommand;
+      }
+      logpoints = /* @__PURE__ */ new Map();
+      subscribed = false;
+      /**
+       * Subscribe to moz:debugging events
+       */
+      async subscribe(contextId) {
+        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);
+        } 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: url2, line, column } = payload.params;
+              const logpointId = this.findLogpointByLocation(url2, line);
+              if (logpointId) {
+                void this.handleLogpointPause(context, logpointId);
+                return;
+              }
+              logDebug(`moz:Debugging paused in context: ${context} at ${url2}:${line}:${column}`);
+            }
+            if (payload?.method === "moz:debugging.resumed") {
+              logDebug(`moz:Debugging resumed in context: ${payload.params.context}`);
+            }
+          } catch {
+          }
+        });
+        this.subscribed = true;
+        logDebug("moz:debugging listener active");
+      }
+      addLogpoint(logpointId, url2, line, expression) {
+        this.logpoints.set(logpointId, {
+          location: { url: url2, line },
+          expression,
+          results: [],
+          capped: false
+        });
+      }
+      removeLogpoint(logpointId) {
+        this.logpoints.delete(logpointId);
+      }
+      getLogpointResults(logpointId) {
+        return this.logpoints.get(logpointId)?.results ?? null;
+      }
+      findLogpointByLocation(url2, line) {
+        for (const [logpointId, entry] of this.logpoints) {
+          if (entry.location.url === url2 && entry.location.line === line) {
+            return logpointId;
+          }
+        }
+        return null;
+      }
+      async handleLogpointPause(contextId, logpointId) {
+        const entry = this.logpoints.get(logpointId);
+        if (!entry) {
+          return;
+        }
+        logDebug(`Logpoint hit: ${logpointId} in context ${contextId}`);
+        try {
+          const result = await this.sendBiDiCommand("script.evaluate", {
+            expression: entry.expression,
+            target: { context: contextId },
+            awaitPromise: false
+          });
+          const evalResult = result;
+          if (evalResult.type === "exception") {
+            entry.results.push({
+              value: null,
+              error: evalResult.exceptionDetails?.text ?? "Unknown error",
+              timestamp: Date.now()
+            });
+          } else {
+            entry.results.push({
+              value: evalResult.result,
+              timestamp: Date.now()
+            });
+          }
+        } catch (error2) {
+          entry.results.push({
+            value: null,
+            error: String(error2),
+            timestamp: Date.now()
+          });
+        } finally {
+          if (entry.results.length > MAX_LOGPOINT_RESULTS) {
+            entry.results.splice(0, entry.results.length - MAX_LOGPOINT_RESULTS);
+            if (!entry.capped) {
+              entry.capped = true;
+              logDebug(`Logpoint ${logpointId}: result buffer capped at ${MAX_LOGPOINT_RESULTS}`);
+            }
+          }
+          await this.sendBiDiCommand("moz:debugging.resume", { context: contextId }).catch((err) => {
+            logDebug(`Failed to resume after logpoint: ${String(err)}`);
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/firefox/events/index.ts
 var init_events = __esm({
   "src/firefox/events/index.ts"() {
     "use strict";
     init_console();
     init_network();
+    init_debugging();
   }
 });
 
@@ -29706,6 +29995,7 @@ var init_firefox = __esm({
       core;
       consoleEvents = null;
       networkEvents = null;
+      debuggingEvents = null;
       dom = null;
       pages = null;
       snapshot = null;
@@ -29734,6 +30024,10 @@ var init_firefox = __esm({
             onNavigate,
             autoClearOnNavigate: false
           });
+          this.debuggingEvents = new DebuggingEvents(
+            driver,
+            (method, params) => this.core.sendBiDiCommand(method, params)
+          );
         }
         this.dom = new DomInteractions(
           driver,
@@ -29761,6 +30055,14 @@ var init_firefox = __esm({
             this.networkEvents = null;
           }
         }
+        if (this.debuggingEvents) {
+          try {
+            await this.debuggingEvents.subscribe();
+          } catch {
+            logDebug("Debugging events unavailable (BiDi not supported by this Firefox session)");
+            this.debuggingEvents = null;
+          }
+        }
       }
       // ============================================================================
       // DOM / Evaluate
@@ -30054,6 +30356,48 @@ var init_firefox = __esm({
       async isConnected() {
         return await this.core.isConnected();
       }
+      /**
+       * Get current browser version (eg "153.0a1").
+       * @internal
+       */
+      getFirefoxVersion() {
+        return this.core.getFirefoxVersion();
+      }
+      /**
+       * @internal
+       */
+      async setLogpoint(url2, line, expression) {
+        if (!this.debuggingEvents) {
+          throw new Error("Debugging events not available");
+        }
+        const result = await this.core.sendBiDiCommand("moz:debugging.setBreakpoint", {
+          location: { url: url2, line }
+        });
+        const logpointId = result.breakpoint;
+        this.debuggingEvents.addLogpoint(logpointId, url2, line, expression);
+        return logpointId;
+      }
+      /**
+       * @internal
+       */
+      async removeLogpoint(logpointId) {
+        if (!this.debuggingEvents) {
+          throw new Error("Debugging events not available");
+        }
+        await this.core.sendBiDiCommand("moz:debugging.removeBreakpoint", {
+          breakpoint: logpointId
+        });
+        this.debuggingEvents.removeLogpoint(logpointId);
+      }
+      /**
+       * @internal
+       */
+      getLogpointResults(logpointId) {
+        if (!this.debuggingEvents) {
+          return null;
+        }
+        return this.debuggingEvents.getLogpointResults(logpointId);
+      }
       /**
        * Get log file path (if logging is enabled)
        */
@@ -30073,23 +30417,22 @@ var init_firefox = __esm({
       getOptions() {
         return this.core.getOptions();
       }
-      /**
-       * Reset all internal state (used when Firefox is detected as closed)
-       */
-      reset() {
-        this.core.reset();
+      // ============================================================================
+      // Cleanup
+      // ============================================================================
+      async close() {
+        try {
+          await this.core.close();
+        } catch (error2) {
+          logDebug(`close() failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
         this.consoleEvents = null;
         this.networkEvents = null;
+        this.debuggingEvents = null;
         this.dom = null;
         this.pages = null;
         this.snapshot = null;
       }
-      // ============================================================================
-      // Cleanup
-      // ============================================================================
-      async close() {
-        await this.core.close();
-      }
     };
   }
 });
@@ -30371,7 +30714,68 @@ var init_pages2 = __esm({
   }
 });
 
-// src/tools/script.ts
+// 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") {
     throw new Error("function parameter is required and must be a string");
@@ -30395,6 +30799,15 @@ Valid examples:
     );
   }
 }
+var MAX_FUNCTION_SIZE;
+var init_js_validation = __esm({
+  "src/utils/js-validation.ts"() {
+    "use strict";
+    MAX_FUNCTION_SIZE = 16 * 1024;
+  }
+});
+
+// src/tools/script.ts
 async function handleEvaluateScript(args2) {
   try {
     const {
@@ -30405,17 +30818,13 @@ async function handleEvaluateScript(args2) {
     validateFunction(fnString);
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const firefox3 = await getFirefox2();
-    const driver = firefox3.getDriver();
-    if (!driver) {
-      throw new Error("WebDriver not available");
-    }
     const scriptTimeout = timeout ?? DEFAULT_TIMEOUT;
     const resolvedArgs = [];
     if (fnArgs && fnArgs.length > 0) {
       for (const arg of fnArgs) {
         try {
           const element = await firefox3.resolveUidToElement(arg.uid);
-          resolvedArgs.push(element);
+          resolvedArgs.push({ sharedId: await element.getId() });
         } catch (error2) {
           const errorMsg = error2.message;
           if (errorMsg.includes("stale") || errorMsg.includes("Snapshot") || errorMsg.includes("UID")) {
@@ -30430,40 +30839,55 @@ Please call take_snapshot to get fresh UIDs and try again.`
         }
       }
     }
-    const evalCode = `
-      const fn = ${fnString};
-      const args = Array.from(arguments);
-      const result = fn(...args);
-      return result instanceof Promise ? result : Promise.resolve(result);
-    `;
-    await driver.manage().setTimeouts({ script: scriptTimeout });
-    const result = await driver.executeScript(evalCode, ...resolvedArgs);
-    let output = "Script ran on page and returned:\n";
-    output += "```json\n";
-    output += JSON.stringify(result, null, 2);
-    output += "\n```";
-    return successResponse(output);
-  } catch (error2) {
-    const errorMsg = error2.message;
-    if (errorMsg.includes("timeout") || errorMsg.includes("Timeout")) {
-      const timeoutValue = args2?.timeout ?? DEFAULT_TIMEOUT;
+    const callFunctionPromise = firefox3.sendBiDiCommand("script.callFunction", {
+      functionDeclaration: fnString,
+      awaitPromise: true,
+      arguments: resolvedArgs,
+      target: { context: firefox3.getCurrentContextId() }
+    });
+    const result = await Promise.race([
+      new Promise((r) => setTimeout(() => r(TIMEOUT), scriptTimeout)),
+      callFunctionPromise
+    ]);
+    if (result === TIMEOUT) {
       return errorResponse(
         new Error(
-          `Script execution timed out (exceeded ${timeoutValue}ms).
+          `Script execution timed out (exceeded ${scriptTimeout}ms).
 
 The function may contain an infinite loop or be waiting for a slow operation.
 Try simplifying the script or increasing the timeout parameter.`
         )
       );
+    } else if (result.type === EvaluateResultType.Success) {
+      let output = "Script ran on page and returned:\n";
+      output += "```json\n";
+      output += JSON.stringify(remoteValueToNative(result.result), null, 2);
+      output += "\n```";
+      return successResponse(output);
+    } else if (result.type === EvaluateResultType.Exception) {
+      const exceptionDetails = result.exceptionDetails;
+      return errorResponse(
+        new Error(
+          `Script execution failed: ${exceptionDetails.text}
+
+\`\`\`json
+` + JSON.stringify(remoteValueToNative(exceptionDetails.exception), null, 2) + "\n```"
+        )
+      );
+    } else {
+      return errorResponse(`Unexpected script.callFunction result type: ${result.type}`);
     }
+  } catch (error2) {
     return errorResponse(error2);
   }
 }
-var evaluateScriptTool, MAX_FUNCTION_SIZE, DEFAULT_TIMEOUT;
+var evaluateScriptTool, DEFAULT_TIMEOUT, TIMEOUT, EvaluateResultType;
 var init_script = __esm({
   "src/tools/script.ts"() {
     "use strict";
     init_response_helpers();
+    init_remote_value();
+    init_js_validation();
     evaluateScriptTool = {
       name: "evaluate_script",
       description: "Execute JS function in page. Prefer UID tools for interactions.",
@@ -30496,8 +30920,12 @@ var init_script = __esm({
         required: ["function"]
       }
     };
-    MAX_FUNCTION_SIZE = 16 * 1024;
     DEFAULT_TIMEOUT = 5e3;
+    TIMEOUT = Symbol("Timeout");
+    EvaluateResultType = {
+      Exception: "exception",
+      Success: "success"
+    };
   }
 });
 
@@ -31710,10 +32138,12 @@ async function handleGetFirefoxInfo(_input) {
     const firefox3 = await getFirefox();
     const options = firefox3.getOptions();
     const logFilePath = firefox3.getLogFilePath();
+    const version3 = firefox3.getFirefoxVersion();
     const info = [];
     info.push("Firefox Instance Configuration");
     info.push("");
     info.push(`Binary: ${options.firefoxPath ?? "System Firefox (default)"}`);
+    info.push(`Firefox version: ${version3 ?? "(unknown)"}`);
     info.push(`Headless: ${options.headless ? "Yes" : "No"}`);
     if (options.viewport) {
       info.push(`Viewport: ${options.viewport.width}x${options.viewport.height}`);
@@ -31782,15 +32212,11 @@ async function handleRestartFirefox(input) {
         profilePath: profilePath ?? currentOptions.profilePath,
         env: newEnv !== void 0 ? newEnv : currentOptions.env,
         headless: headless !== void 0 ? headless : currentOptions.headless,
-        startUrl: startUrl ?? currentOptions.startUrl ?? "about:home",
+        startUrl: startUrl ?? currentOptions.startUrl ?? "about:blank",
         prefs: mergedPrefs
       };
       setNextLaunchOptions(newOptions);
-      try {
-        await currentFirefox.close();
-      } catch {
-      }
-      resetFirefox();
+      await resetFirefox();
       const changes = [];
       if (firefoxPath && firefoxPath !== currentOptions.firefoxPath) {
         changes.push(`Binary: ${firefoxPath}`);
@@ -31821,7 +32247,7 @@ ${changes.join("\n")}`
       );
     } else {
       if (currentFirefox) {
-        resetFirefox();
+        await resetFirefox();
       }
       const resolvedFirefoxPath = firefoxPath ?? args.firefoxPath ?? void 0;
       if (!resolvedFirefoxPath) {
@@ -31836,7 +32262,7 @@ ${changes.join("\n")}`
         profilePath: profilePath ?? args.profilePath ?? void 0,
         env: newEnv,
         headless: headless ?? false,
-        startUrl: startUrl ?? "about:home"
+        startUrl: startUrl ?? "about:blank"
       };
       setNextLaunchOptions(newOptions);
       const config2 = [`Binary: ${resolvedFirefoxPath}`];
@@ -31927,7 +32353,7 @@ var init_firefox_management = __esm({
           },
           startUrl: {
             type: "string",
-            description: "URL to navigate to after restart (optional, uses about:home if not specified)"
+            description: "URL to navigate to after restart (optional, uses about:blank if not specified)"
           },
           prefs: {
             type: "object",
@@ -31943,10 +32369,6 @@ var init_firefox_management = __esm({
 });
 
 // src/tools/privileged-context.ts
-function isLikelyStatement(input) {
-  const trimmed = input.trim();
-  return /^(const|let|var)\s/.test(trimmed);
-}
 function formatContextList(contexts) {
   if (contexts.length === 0) {
     return "No privileged contexts found";
@@ -32009,41 +32431,46 @@ async function handleSelectPrivilegedContext(args2) {
 }
 async function handleEvaluatePrivilegedScript(args2) {
   try {
-    const { expression } = args2;
-    if (!expression || typeof expression !== "string") {
-      throw new Error("expression parameter is required and must be a string");
-    }
-    if (isLikelyStatement(expression)) {
-      return errorResponse(
-        new Error(
-          `Cannot evaluate statement: "${expression.substring(0, 50)}${expression.length > 50 ? "..." : ""}". This tool expects an expression, not a statement (const/let/var declarations are statements). To use statements, wrap them in an IIFE: (function() { const x = 1; return x; })()`
-        )
-      );
-    }
+    const { function: fnString } = args2;
+    validateFunction(fnString);
     const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const firefox3 = await getFirefox2();
-    const driver = firefox3.getDriver();
-    try {
-      const result = await driver.executeScript(`return (${expression});`);
-      const resultText = typeof result === "string" ? result : result === null ? "null" : result === void 0 ? "undefined" : JSON.stringify(result, null, 2);
-      return successResponse(`Result:
-${resultText}`);
-    } catch (executeError) {
+    const result = await firefox3.sendBiDiCommand("script.callFunction", {
+      functionDeclaration: fnString,
+      awaitPromise: true,
+      arguments: [],
+      target: { context: firefox3.getCurrentContextId() }
+    });
+    if (result.type === EvaluateResultType2.Success) {
+      let output = "Script ran in chrome context and returned:\n";
+      output += "```json\n";
+      output += JSON.stringify(remoteValueToNative(result.result), null, 2);
+      output += "\n```";
+      return successResponse(output);
+    } else if (result.type === EvaluateResultType2.Exception) {
+      const exceptionDetails = result.exceptionDetails;
       return errorResponse(
         new Error(
-          `Script execution failed: ${executeError instanceof Error ? executeError.message : String(executeError)}`
+          `Script execution failed: ${exceptionDetails.text}
+
+\`\`\`json
+` + JSON.stringify(remoteValueToNative(exceptionDetails.exception), null, 2) + "\n```"
         )
       );
+    } else {
+      return errorResponse(`Unexpected script.callFunction result type: ${result.type}`);
     }
   } catch (error2) {
     return errorResponse(error2);
   }
 }
-var listPrivilegedContextsTool, selectPrivilegedContextTool, evaluatePrivilegedScriptTool;
+var listPrivilegedContextsTool, selectPrivilegedContextTool, evaluatePrivilegedScriptTool, EvaluateResultType2;
 var init_privileged_context = __esm({
   "src/tools/privileged-context.ts"() {
     "use strict";
     init_response_helpers();
+    init_js_validation();
+    init_remote_value();
     listPrivilegedContextsTool = {
       name: "list_privileged_contexts",
       description: "List privileged (privileged) browsing contexts. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var. Use restart_firefox with env parameter to enable.",
@@ -32068,18 +32495,22 @@ var init_privileged_context = __esm({
     };
     evaluatePrivilegedScriptTool = {
       name: "evaluate_privileged_script",
-      description: "Evaluate JavaScript in the current privileged context. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var. Returns the result of the expression. IMPORTANT: Only provide expressions, not statements. Do not use const, let, or var declarations as they will cause syntax errors. For complex logic, wrap in an IIFE: (function() { const x = 1; return x; })()",
+      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.",
       inputSchema: {
         type: "object",
         properties: {
-          expression: {
+          function: {
             type: "string",
-            description: "JavaScript expression to evaluate in the privileged context"
+            description: 'JS function string, e.g. () => Services.prefs.getBoolPref("foo")'
           }
         },
-        required: ["expression"]
+        required: ["function"]
       }
     };
+    EvaluateResultType2 = {
+      Exception: "exception",
+      Success: "success"
+    };
   }
 });
 
@@ -32554,6 +32985,354 @@ var init_webextension = __esm({
   }
 });
 
+// src/utils/version.ts
+function getMajorVersion(version3) {
+  const [major2, _rhs] = version3.split(".");
+  if (!major2) {
+    throw new Error(`Unable to parse Firefox version ${version3}`);
+  }
+  return Number.parseInt(major2, 10);
+}
+function compareVersions(versionA, versionB) {
+  const majorA = getMajorVersion(versionA);
+  const majorB = getMajorVersion(versionB);
+  if (majorA < majorB) {
+    return -1;
+  }
+  if (majorA > majorB) {
+    return 1;
+  }
+  return 0;
+}
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/debugging.ts
+function requireDebuggingSupport(firefox3) {
+  const version3 = firefox3.getFirefoxVersion();
+  if (version3 !== null && compareVersions(version3, MIN_VERSION) < 0) {
+    throw new Error(
+      `moz:debugging requires Firefox ${MIN_VERSION}+, current version is ${version3}`
+    );
+  }
+}
+function requireContext(contextId) {
+  if (!contextId) {
+    throw new Error("No active browsing context");
+  }
+  return contextId;
+}
+async function handleEnableDebugger(_args) {
+  try {
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    requireDebuggingSupport(firefox3);
+    await firefox3.sendBiDiCommand("moz:debugging.setDebuggerEnabled", { enabled: true });
+    return successResponse("Debugger enabled");
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleListScripts(_args) {
+  try {
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    requireDebuggingSupport(firefox3);
+    const contextId = requireContext(firefox3.getCurrentContextId());
+    const result = await firefox3.sendBiDiCommand("moz:debugging.listScripts", {
+      context: contextId
+    });
+    const scripts = result.scripts;
+    if (scripts.length === 0) {
+      return successResponse("No scripts found");
+    }
+    return successResponse(scripts.join("\n"));
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleGetScriptSource(args2) {
+  try {
+    const { scriptUrl } = args2;
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    requireDebuggingSupport(firefox3);
+    const contextId = requireContext(firefox3.getCurrentContextId());
+    const result = await firefox3.sendBiDiCommand("moz:debugging.getScriptSource", {
+      context: contextId,
+      scriptUrl
+    });
+    return successResponse(result.source);
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleSetLogpoint(args2) {
+  try {
+    const { url: url2, line, expression } = args2;
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    requireDebuggingSupport(firefox3);
+    const logpointId = await firefox3.setLogpoint(url2, line, expression);
+    return successResponse(`Logpoint set (id: ${logpointId})`);
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleRemoveLogpoint(args2) {
+  try {
+    const { logpoint } = args2;
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    requireDebuggingSupport(firefox3);
+    await firefox3.removeLogpoint(logpoint);
+    return successResponse("Logpoint removed");
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleGetLogpointResults(args2) {
+  try {
+    const { logpoint } = args2;
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    requireDebuggingSupport(firefox3);
+    const results = firefox3.getLogpointResults(logpoint);
+    if (results === null) {
+      return errorResponse(new Error(`Logpoint ${logpoint} not found`));
+    }
+    if (results.length === 0) {
+      return successResponse("No results collected yet");
+    }
+    const lines = results.map((r, i) => {
+      if (r.error) {
+        return `[${i + 1}] Error: ${r.error}`;
+      }
+      return `[${i + 1}] ${JSON.stringify(remoteValueToNative(r.value))}`;
+    });
+    return successResponse(lines.join("\n"));
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+var MIN_VERSION, enableDebuggerTool, listScriptsTool, getScriptSourceTool, setLogpointTool, removeLogpointTool, getLogpointResultsTool;
+var init_debugging2 = __esm({
+  "src/tools/debugging.ts"() {
+    "use strict";
+    init_response_helpers();
+    init_version();
+    init_remote_value();
+    MIN_VERSION = "153";
+    enableDebuggerTool = {
+      name: "enable_debugger",
+      description: "Enable the JS debugger for the current page. Required before set_logpoint works. Requires Firefox 153+.",
+      inputSchema: { type: "object", properties: {} }
+    };
+    listScriptsTool = {
+      name: "list_scripts",
+      description: "List all JavaScript files currently loaded in the page. Requires enable_debugger to have been called.",
+      inputSchema: { type: "object", properties: {} }
+    };
+    getScriptSourceTool = {
+      name: "get_script_source",
+      description: "Get the source code of a JavaScript file loaded in the page. Requires enable_debugger to have been called.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          scriptUrl: { type: "string", description: "URL of the script to retrieve." }
+        },
+        required: ["scriptUrl"]
+      }
+    };
+    setLogpointTool = {
+      name: "set_logpoint",
+      description: "Set a logpoint at a specific location. When execution reaches that line, the expression is evaluated and the result is stored without pausing. Use get_logpoint_results to retrieve collected values. Requires enable_debugger to have been called.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "URL of the script." },
+          line: { type: "number", description: "Line number (1-based)." },
+          expression: {
+            type: "string",
+            description: "JavaScript expression to evaluate each time the logpoint is hit."
+          }
+        },
+        required: ["url", "line", "expression"]
+      }
+    };
+    removeLogpointTool = {
+      name: "remove_logpoint",
+      description: "Remove a previously set logpoint.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          logpoint: { type: "string", description: "Logpoint id returned by set_logpoint." }
+        },
+        required: ["logpoint"]
+      }
+    };
+    getLogpointResultsTool = {
+      name: "get_logpoint_results",
+      description: "Get the results collected by a logpoint since it was set.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          logpoint: { type: "string", description: "Logpoint id returned by set_logpoint." }
+        },
+        required: ["logpoint"]
+      }
+    };
+  }
+});
+
+// src/tools/profiler.ts
+function checkProfilerSupported(firefox3) {
+  const version3 = firefox3.getFirefoxVersion();
+  if (version3 !== null && compareVersions(version3, MIN_FIREFOX_VERSION) < 0) {
+    throw new Error(
+      `moz:profiler requires Firefox ${MIN_FIREFOX_VERSION.split(".")[0]} or later (connected: ${version3})`
+    );
+  }
+}
+async function handleProfilerIsActive(_args) {
+  try {
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    checkProfilerSupported(firefox3);
+    const result = await firefox3.sendBiDiCommand("moz:profiler.isActive", {});
+    return successResponse(`Profiler is ${result.active ? "active" : "inactive"}`);
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleProfilerStart(args2) {
+  try {
+    const { preset, entries, interval, features, threads, activeContext } = args2;
+    const params = {};
+    if (preset !== void 0) {
+      params.preset = preset;
+    } else {
+      if (entries === void 0 || interval === void 0 || features === void 0 || threads === void 0) {
+        throw new Error(
+          "When no preset is given, entries, interval, features, and threads are all required."
+        );
+      }
+      params.entries = entries;
+      params.interval = interval;
+      params.features = features;
+      params.threads = threads;
+    }
+    if (activeContext !== void 0) {
+      params.activeContext = activeContext;
+    }
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    checkProfilerSupported(firefox3);
+    await firefox3.sendBiDiCommand("moz:profiler.start", params);
+    return successResponse("Profiler started");
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleProfilerStop(args2) {
+  try {
+    const { discard } = args2;
+    const params = {};
+    if (discard !== void 0) {
+      params.discard = discard;
+    }
+    const { getFirefox: getFirefox2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const firefox3 = await getFirefox2();
+    checkProfilerSupported(firefox3);
+    const result = await firefox3.sendBiDiCommand("moz:profiler.stop", params);
+    if (result.path) {
+      return successResponse(`Profile saved to: ${result.path}`);
+    }
+    return successResponse("Profiler stopped. No profile was saved.");
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+var MIN_FIREFOX_VERSION, VALID_PRESETS, profilerIsActiveTool, profilerStartTool, profilerStopTool;
+var init_profiler = __esm({
+  "src/tools/profiler.ts"() {
+    "use strict";
+    init_response_helpers();
+    init_version();
+    MIN_FIREFOX_VERSION = "154.0";
+    VALID_PRESETS = [
+      "web-developer",
+      "firefox-platform",
+      "graphics",
+      "media",
+      "ml",
+      "networking",
+      "power",
+      "debug"
+    ];
+    profilerIsActiveTool = {
+      name: "profiler_is_active",
+      description: "Check whether the Firefox profiler is currently recording.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    };
+    profilerStartTool = {
+      name: "profiler_start",
+      description: `Start the Firefox profiler. Provide either a preset name or explicit recording options (entries, interval, features, threads). Cannot combine both. Valid presets: ${VALID_PRESETS.join(", ")}.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          preset: {
+            type: "string",
+            enum: VALID_PRESETS,
+            description: "Profiler preset name. Cannot be combined with entries, interval, features, or threads."
+          },
+          entries: {
+            type: "integer",
+            description: "Number of entries to keep in the sampling buffer. Required when no preset is given."
+          },
+          interval: {
+            type: "number",
+            description: "Sampling interval in milliseconds. Required when no preset is given."
+          },
+          features: {
+            type: "array",
+            items: { type: "string" },
+            description: "Profiler features to enable. Required when no preset is given."
+          },
+          threads: {
+            type: "array",
+            items: { type: "string" },
+            description: "Thread names to profile. Required when no preset is given."
+          },
+          activeContext: {
+            type: "string",
+            description: "Id of the top-level navigable to mark as the active tab in the profile. Does not restrict profiling to that tab."
+          }
+        }
+      }
+    };
+    profilerStopTool = {
+      name: "profiler_stop",
+      description: "Stop the Firefox profiler and save the recorded profile to a file in the downloads directory. Returns the path to the saved file, or null when nothing was saved.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          discard: {
+            type: "boolean",
+            description: "If true, stop the profiler and discard the recording instead of saving it to disk. Defaults to false."
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/tools/index.ts
 var init_tools = __esm({
   "src/tools/index.ts"() {
@@ -32570,6 +33349,8 @@ var init_tools = __esm({
     init_privileged_context();
     init_firefox_prefs();
     init_webextension();
+    init_debugging2();
+    init_profiler();
   }
 });
 
@@ -32588,9 +33369,9 @@ import { version as version2 } from "process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { resolve as resolve3 } from "path";
 import { realpathSync } from "fs";
-function resetFirefox() {
+async function resetFirefox() {
   if (firefox2) {
-    firefox2.reset();
+    await firefox2.close();
     firefox2 = null;
   }
   pendingWarning = null;
@@ -32611,7 +33392,7 @@ async function getFirefox() {
     const isConnected = await firefox2.isConnected();
     if (!isConnected) {
       log("Firefox connection lost, reconnecting...");
-      resetFirefox();
+      await resetFirefox();
     } else {
       return firefox2;
     }
@@ -32659,8 +33440,7 @@ async function getFirefox() {
     pendingWarning = firefox2.getAndClearProfileWarning();
     return firefox2;
   } catch (error2) {
-    await firefox2.close().catch(() => {
-    });
+    await firefox2.close();
     firefox2 = null;
     throw error2;
   }
@@ -32680,6 +33460,9 @@ async function run(parseArgsFn, importMetaUrl) {
     return;
   }
   args = parseArgsFn(SERVER_VERSION);
+  if (args.logFile) {
+    setupLogFile(args.logFile);
+  }
   const toolHandlers = new Map([
     // Pages
     ["list_pages", handleListPages],
@@ -32719,8 +33502,21 @@ async function run(parseArgsFn, importMetaUrl) {
     // WebExtensions (install/uninstall use standard BiDi, no privileged context required)
     ["install_extension", handleInstallExtension],
     ["uninstall_extension", handleUninstallExtension],
+    // Profiler
+    ["profiler_is_active", handleProfilerIsActive],
+    ["profiler_start", handleProfilerStart],
+    ["profiler_stop", handleProfilerStop],
     // Script evaluation — requires --enable-script
     ...args.enableScript ? [["evaluate_script", handleEvaluateScript]] : [],
+    // Debugging tools — requires --enable-script
+    ...args.enableScript ? [
+      ["enable_debugger", handleEnableDebugger],
+      ["list_scripts", handleListScripts],
+      ["get_script_source", handleGetScriptSource],
+      ["set_logpoint", handleSetLogpoint],
+      ["remove_logpoint", handleRemoveLogpoint],
+      ["get_logpoint_results", handleGetLogpointResults]
+    ] : [],
     // Privileged context tools — requires --enable-privileged-context
     ...args.enablePrivilegedContext ? [
       ["list_privileged_contexts", handleListPrivilegedContexts],
@@ -32761,8 +33557,20 @@ async function run(parseArgsFn, importMetaUrl) {
     restartFirefoxTool,
     installExtensionTool,
     uninstallExtensionTool,
+    profilerIsActiveTool,
+    profilerStartTool,
+    profilerStopTool,
     // Script evaluation — requires --enable-script
     ...args.enableScript ? [evaluateScriptTool] : [],
+    // Debugging tools — requires --enable-script
+    ...args.enableScript ? [
+      enableDebuggerTool,
+      listScriptsTool,
+      getScriptSourceTool,
+      setLogpointTool,
+      removeLogpointTool,
+      getLogpointResultsTool
+    ] : [],
     // Privileged context tools — requires --enable-privileged-context
     ...args.enablePrivilegedContext ? [
       listPrivilegedContextsTool,
@@ -32835,13 +33643,10 @@ async function run(parseArgsFn, importMetaUrl) {
   log("Firefox DevTools MCP server running on stdio");
   log("Ready to accept tool requests");
   const cleanup = async () => {
-    if (firefox2) {
-      try {
-        await firefox2.close();
-      } catch {
-      }
-    }
+    await resetFirefox();
     await server.close();
+    await flushLogs().catch(() => {
+    });
     process.exit(0);
   };
   const onSignal = () => void cleanup();
@@ -32947,7 +33752,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports, module) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var path = __require("path");
     var os = __require("os");
     var crypto = __require("crypto");
@@ -33086,7 +33891,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs.existsSync(filepath)) {
+            if (fs2.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -33096,7 +33901,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
       }
-      if (fs.existsSync(possibleVaultPath)) {
+      if (fs2.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -33149,7 +33954,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path2 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+          const parsed = DotenvModule.parse(fs2.readFileSync(path2, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {