@mozilla/firefox-devtools-mcp 0.9.5 → 0.9.7

package/dist/index.js

@@ -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: {
@@ -27224,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 });
@@ -28078,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;
   }
 });
 
@@ -28210,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
@@ -28306,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") {
@@ -28320,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) {
@@ -28358,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
        */
@@ -28388,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
        */
@@ -28473,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 {
@@ -28876,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();
   }
 });
 
@@ -29793,6 +29995,7 @@ var init_firefox = __esm({
       core;
       consoleEvents = null;
       networkEvents = null;
+      debuggingEvents = null;
       dom = null;
       pages = null;
       snapshot = null;
@@ -29821,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,
@@ -29848,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
@@ -30141,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)
        */
@@ -30160,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();
-      }
     };
   }
 });
@@ -30458,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");
@@ -30482,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 {
@@ -30492,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")) {
@@ -30517,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.",
@@ -30583,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"
+    };
   }
 });
 
@@ -31797,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}`);
@@ -31873,11 +32216,7 @@ async function handleRestartFirefox(input) {
         prefs: mergedPrefs
       };
       setNextLaunchOptions(newOptions);
-      try {
-        await currentFirefox.close();
-      } catch {
-      }
-      resetFirefox();
+      await resetFirefox();
       const changes = [];
       if (firefoxPath && firefoxPath !== currentOptions.firefoxPath) {
         changes.push(`Binary: ${firefoxPath}`);
@@ -31908,7 +32247,7 @@ ${changes.join("\n")}`
       );
     } else {
       if (currentFirefox) {
-        resetFirefox();
+        await resetFirefox();
       }
       const resolvedFirefoxPath = firefoxPath ?? args.firefoxPath ?? void 0;
       if (!resolvedFirefoxPath) {
@@ -32030,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";
@@ -32096,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.",
@@ -32155,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"
+    };
   }
 });
 
@@ -32641,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"() {
@@ -32657,6 +33349,8 @@ var init_tools = __esm({
     init_privileged_context();
     init_firefox_prefs();
     init_webextension();
+    init_debugging2();
+    init_profiler();
   }
 });
 
@@ -32675,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;
@@ -32698,7 +33392,7 @@ async function getFirefox() {
     const isConnected = await firefox2.isConnected();
     if (!isConnected) {
       log("Firefox connection lost, reconnecting...");
-      resetFirefox();
+      await resetFirefox();
     } else {
       return firefox2;
     }
@@ -32746,8 +33440,7 @@ async function getFirefox() {
     pendingWarning = firefox2.getAndClearProfileWarning();
     return firefox2;
   } catch (error2) {
-    await firefox2.close().catch(() => {
-    });
+    await firefox2.close();
     firefox2 = null;
     throw error2;
   }
@@ -32767,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],
@@ -32806,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],
@@ -32848,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,
@@ -32922,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();
@@ -33034,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");
@@ -33173,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`;
             }
           }
@@ -33183,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;
@@ -33236,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) {