firefox-devtools-mcp 0.8.0 → 0.9.0

package/dist/index.js

@@ -16821,10 +16821,10 @@ var require_validate = __commonJS({
           return;
         }
       }
-      validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
+      validateFunction2(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
     }
     exports.validateFunctionCode = validateFunctionCode;
-    function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
+    function validateFunction2({ gen, validateName, schema, schemaEnv, opts }, body) {
       if (opts.code.es5) {
         gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
           gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
@@ -16857,7 +16857,7 @@ var require_validate = __commonJS({
     }
     function topSchemaObjCode(it) {
       const { schema, opts, gen } = it;
-      validateFunction(it, () => {
+      validateFunction2(it, () => {
         if (opts.$comment && schema.$comment)
           commentKeyword(it);
         checkNoDefault(it);
@@ -21995,6 +21995,32 @@ var init_logger = __esm({
 // src/cli.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+function parsePrefs(prefs) {
+  const result = {};
+  if (!prefs || prefs.length === 0) {
+    return result;
+  }
+  for (const pref of prefs) {
+    const eqIndex = pref.indexOf("=");
+    if (eqIndex === -1) {
+      continue;
+    }
+    const name = pref.slice(0, eqIndex);
+    const rawValue = pref.slice(eqIndex + 1);
+    let value;
+    if (rawValue === "true") {
+      value = true;
+    } else if (rawValue === "false") {
+      value = false;
+    } else if (/^-?\d+$/.test(rawValue)) {
+      value = parseInt(rawValue, 10);
+    } else {
+      value = rawValue;
+    }
+    result[name] = value;
+  }
+  return result;
+}
 function parseArguments(version3, argv = process.argv) {
   const yargsInstance = yargs(hideBin(argv)).scriptName("npx firefox-devtools-mcp@latest").options(cliOptions).example([
     [
@@ -22066,6 +22092,30 @@ var init_cli = __esm({
         type: "number",
         description: "Marionette port to connect to when using --connect-existing (default: 2828)",
         default: Number(process.env.MARIONETTE_PORT ?? "2828")
+      },
+      env: {
+        type: "array",
+        description: "Environment variables for Firefox in KEY=VALUE format. Can be specified multiple times. Example: --env MOZ_LOG=HTMLMediaElement:4"
+      },
+      outputFile: {
+        type: "string",
+        description: "Path to file where Firefox output (stdout/stderr) will be written. If not specified, output is written to ~/.firefox-devtools-mcp/output/"
+      },
+      pref: {
+        type: "array",
+        string: true,
+        description: "Set Firefox preference at startup via moz:firefoxOptions (format: name=value). Can be specified multiple times.",
+        alias: "p"
+      },
+      enableScript: {
+        type: "boolean",
+        description: "Enable the evaluate_script tool, which allows executing arbitrary JavaScript in the page context.",
+        default: (process.env.ENABLE_SCRIPT ?? "false") === "true"
+      },
+      enablePrivilegedContext: {
+        type: "boolean",
+        description: "Enable privileged context tools: list/select privileged contexts, evaluate privileged scripts, get/set Firefox prefs, and list extensions. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1.",
+        default: (process.env.ENABLE_PRIVILEGED_CONTEXT ?? "false") === "true"
       }
     };
   }
@@ -22075,6 +22125,9 @@ var init_cli = __esm({
 import { Builder, Browser } from "selenium-webdriver";
 import firefox from "selenium-webdriver/firefox.js";
 import { spawn } from "child_process";
+import { mkdirSync, openSync, closeSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 function findGeckodriverInCache(fs, path, cacheBase) {
   const ext = process.platform === "win32" ? ".exe" : "";
   const binaryName = `geckodriver${ext}`;
@@ -22387,6 +22440,9 @@ var init_core3 = __esm({
       kill() {
         this.gdProcess.kill();
       }
+      getBidi() {
+        throw new Error("BiDi not available in connect-existing mode");
+      }
     };
     FirefoxCore = class {
       constructor(options) {
@@ -22394,6 +22450,9 @@ var init_core3 = __esm({
       }
       driver = null;
       currentContextId = null;
+      originalEnv = {};
+      logFilePath;
+      logFileFd;
       /**
        * Launch Firefox (or connect to an existing instance) and establish BiDi connection
        */
@@ -22407,6 +22466,24 @@ var init_core3 = __esm({
           const port = this.options.marionettePort ?? 2828;
           this.driver = await GeckodriverHttpDriver.connect(port);
         } else {
+          if (this.options.logFile) {
+            this.logFilePath = this.options.logFile;
+          } else if (this.options.env && Object.keys(this.options.env).length > 0) {
+            const outputDir = join(homedir(), ".firefox-devtools-mcp", "output");
+            mkdirSync(outputDir, { recursive: true });
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+            this.logFilePath = join(outputDir, `firefox-${timestamp}.log`);
+          }
+          if (this.options.env) {
+            for (const [key, value] of Object.entries(this.options.env)) {
+              this.originalEnv[key] = process.env[key];
+              process.env[key] = value;
+              logDebug(`Set env ${key}=${value}`);
+            }
+            if (this.options.env.MOZ_LOG_FILE) {
+              logDebug("Note: MOZ_LOG_FILE in env will be used, but may be blocked by sandbox");
+            }
+          }
           const firefoxOptions = new firefox.Options();
           firefoxOptions.enableBidi();
           if (this.options.headless) {
@@ -22425,12 +22502,24 @@ var init_core3 = __esm({
             firefoxOptions.addArguments(...this.options.args);
           }
           if (this.options.profilePath) {
-            firefoxOptions.setProfile(this.options.profilePath);
+            firefoxOptions.addArguments("--profile", this.options.profilePath);
+            log(`\u{1F4C1} Using Firefox profile: ${this.options.profilePath}`);
           }
           if (this.options.acceptInsecureCerts) {
             firefoxOptions.setAcceptInsecureCerts(true);
           }
-          this.driver = await new Builder().forBrowser(Browser.FIREFOX).setFirefoxOptions(firefoxOptions).build();
+          if (this.options.prefs) {
+            for (const [name, value] of Object.entries(this.options.prefs)) {
+              firefoxOptions.setPreference(name, value);
+            }
+          }
+          const serviceBuilder = new firefox.ServiceBuilder();
+          if (this.logFilePath) {
+            this.logFileFd = openSync(this.logFilePath, "a");
+            serviceBuilder.setStdio(["ignore", this.logFileFd, this.logFileFd]);
+            log(`\u{1F4DD} Capturing Firefox output to: ${this.logFilePath}`);
+          }
+          this.driver = await new Builder().forBrowser(Browser.FIREFOX).setFirefoxOptions(firefoxOptions).setFirefoxService(serviceBuilder).build();
         }
         log(
           this.options.connectExisting ? "\u2705 Connected to existing Firefox" : "\u2705 Firefox launched with BiDi"
@@ -22491,6 +22580,80 @@ var init_core3 = __esm({
       setCurrentContextId(contextId) {
         this.currentContextId = contextId;
       }
+      /**
+       * Get log file path
+       */
+      getLogFilePath() {
+        return this.logFilePath;
+      }
+      /**
+       * Get current launch options
+       */
+      getOptions() {
+        return this.options;
+      }
+      /**
+       * Wait for WebSocket to be in OPEN state
+       */
+      async waitForWebSocketOpen(ws, timeout = 5e3) {
+        if (ws.readyState === 1) {
+          return;
+        }
+        if (ws.readyState === 0) {
+          return new Promise((resolve4, reject) => {
+            const timeoutId = setTimeout(() => {
+              ws.off("open", onOpen);
+              reject(new Error("Timeout waiting for WebSocket to open"));
+            }, timeout);
+            const onOpen = () => {
+              clearTimeout(timeoutId);
+              ws.off("open", onOpen);
+              resolve4();
+            };
+            ws.on("open", onOpen);
+          });
+        }
+        throw new Error(`WebSocket is not open: readyState ${ws.readyState}`);
+      }
+      /**
+       * Send raw BiDi command and get response
+       */
+      async sendBiDiCommand(method, params = {}) {
+        if (!this.driver) {
+          throw new Error("Driver not connected");
+        }
+        const bidi = await this.driver.getBidi();
+        const ws = bidi.socket;
+        await this.waitForWebSocketOpen(ws);
+        const id = Math.floor(Math.random() * 1e6);
+        return new Promise((resolve4, reject) => {
+          const messageHandler = (data) => {
+            try {
+              const payload = JSON.parse(data.toString());
+              if (payload.id === id) {
+                ws.off("message", messageHandler);
+                if (payload.error) {
+                  reject(new Error(`BiDi error: ${JSON.stringify(payload.error)}`));
+                } else {
+                  resolve4(payload.result);
+                }
+              }
+            } catch (err) {
+            }
+          };
+          ws.on("message", messageHandler);
+          const command = {
+            id,
+            method,
+            params
+          };
+          ws.send(JSON.stringify(command));
+          setTimeout(() => {
+            ws.off("message", messageHandler);
+            reject(new Error(`BiDi command timeout: ${method}`));
+          }, 1e4);
+        });
+      }
       /**
        * Close driver and cleanup.
        * When connected to an existing Firefox instance, only kills geckodriver
@@ -22505,6 +22668,25 @@ var init_core3 = __esm({
           }
           this.driver = null;
         }
+        if (this.logFileFd !== void 0) {
+          try {
+            closeSync(this.logFileFd);
+            logDebug("Log file closed");
+          } catch (error2) {
+            logDebug(
+              `Error closing log file: ${error2 instanceof Error ? error2.message : String(error2)}`
+            );
+          }
+          this.logFileFd = void 0;
+        }
+        for (const [key, value] of Object.entries(this.originalEnv)) {
+          if (value === void 0) {
+            delete process.env[key];
+          } else {
+            process.env[key] = value;
+          }
+        }
+        this.originalEnv = {};
         log("\u2705 Firefox DevTools closed");
       }
     };
@@ -24060,6 +24242,13 @@ var init_firefox = __esm({
       // ============================================================================
       // Internal / Advanced
       // ============================================================================
+      /**
+       * Send raw BiDi command (for advanced operations)
+       * @internal
+       */
+      async sendBiDiCommand(method, params = {}) {
+        return await this.core.sendBiDiCommand(method, params);
+      }
       /**
        * Get WebDriver instance (for advanced operations)
        * @internal
@@ -24067,6 +24256,13 @@ var init_firefox = __esm({
       getDriver() {
         return this.core.getDriver();
       }
+      /**
+       * Get current browsing context ID (for advanced operations)
+       * @internal
+       */
+      getCurrentContextId() {
+        return this.core.getCurrentContextId();
+      }
       /**
        * Check if Firefox is still connected and responsive
        * Returns false if Firefox was closed or connection is broken
@@ -24074,6 +24270,18 @@ var init_firefox = __esm({
       async isConnected() {
         return await this.core.isConnected();
       }
+      /**
+       * Get log file path (if logging is enabled)
+       */
+      getLogFilePath() {
+        return this.core.getLogFilePath();
+      }
+      /**
+       * Get current launch options
+       */
+      getOptions() {
+        return this.core.getOptions();
+      }
       /**
        * Reset all internal state (used when Firefox is detected as closed)
        */
@@ -24372,6 +24580,136 @@ var init_pages2 = __esm({
   }
 });
 
+// src/tools/script.ts
+function validateFunction(fnString) {
+  if (!fnString || typeof fnString !== "string") {
+    throw new Error("function parameter is required and must be a string");
+  }
+  if (fnString.length > MAX_FUNCTION_SIZE) {
+    throw new Error(
+      `Function too large (${fnString.length} bytes, max ${MAX_FUNCTION_SIZE} bytes). This tool is not designed for massive scripts.`
+    );
+  }
+  const trimmed = fnString.trim();
+  const isFunctionLike = trimmed.startsWith("function") || trimmed.startsWith("async function") || trimmed.startsWith("(") || trimmed.startsWith("async (");
+  if (!isFunctionLike) {
+    throw new Error(
+      `Invalid function format. Expected a function or arrow function, got: "${trimmed.substring(0, 50)}...".
+
+Valid examples:
+  () => document.title
+  async () => { return await fetch("/api") }
+  (el) => el.innerText
+  function() { return window.location.href }`
+    );
+  }
+}
+async function handleEvaluateScript(args2) {
+  try {
+    const {
+      function: fnString,
+      args: fnArgs,
+      timeout
+    } = args2;
+    validateFunction(fnString);
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_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);
+        } catch (error2) {
+          const errorMsg = error2.message;
+          if (errorMsg.includes("stale") || errorMsg.includes("Snapshot") || errorMsg.includes("UID")) {
+            throw new Error(
+              `UID "${arg.uid}" is invalid or from an old snapshot.
+
+The page may have changed since the snapshot was taken.
+Please call take_snapshot to get fresh UIDs and try again.`
+            );
+          }
+          throw new Error(`Failed to resolve UID "${arg.uid}": ${errorMsg}`);
+        }
+      }
+    }
+    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;
+      return errorResponse(
+        new Error(
+          `Script execution timed out (exceeded ${timeoutValue}ms).
+
+The function may contain an infinite loop or be waiting for a slow operation.
+Try simplifying the script or increasing the timeout parameter.`
+        )
+      );
+    }
+    return errorResponse(error2);
+  }
+}
+var evaluateScriptTool, MAX_FUNCTION_SIZE, DEFAULT_TIMEOUT;
+var init_script = __esm({
+  "src/tools/script.ts"() {
+    "use strict";
+    init_response_helpers();
+    evaluateScriptTool = {
+      name: "evaluate_script",
+      description: "Execute JS function in page. Prefer UID tools for interactions.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          function: {
+            type: "string",
+            description: "JS function string, e.g. () => document.title"
+          },
+          args: {
+            type: "array",
+            description: "UIDs to pass as function arguments",
+            items: {
+              type: "object",
+              properties: {
+                uid: {
+                  type: "string",
+                  description: "Element UID from snapshot"
+                }
+              },
+              required: ["uid"]
+            }
+          },
+          timeout: {
+            type: "number",
+            description: "Timeout in ms (default: 5000)"
+          }
+        },
+        required: ["function"]
+      }
+    };
+    MAX_FUNCTION_SIZE = 16 * 1024;
+    DEFAULT_TIMEOUT = 5e3;
+  }
+});
+
 // src/tools/console.ts
 async function handleListConsoleMessages(args2) {
   try {
@@ -25533,17 +25871,909 @@ var init_utilities = __esm({
   }
 });
 
+// src/tools/firefox-management.ts
+import { readFileSync as readFileSync2, existsSync, statSync } from "fs";
+async function handleGetFirefoxLogs(input) {
+  try {
+    const {
+      lines = 100,
+      grep,
+      since
+    } = input;
+    const firefox3 = await getFirefox();
+    const logFilePath = firefox3.getLogFilePath();
+    if (!logFilePath) {
+      return successResponse(
+        "No output capture configured. Use --env to set environment variables or --output-file to enable output capture."
+      );
+    }
+    if (!existsSync(logFilePath)) {
+      return successResponse(`Output file not found: ${logFilePath}`);
+    }
+    if (since !== void 0) {
+      const stats = statSync(logFilePath);
+      const ageSeconds = (Date.now() - stats.mtimeMs) / 1e3;
+      if (ageSeconds > since) {
+        return successResponse(
+          `Output file is ${Math.floor(ageSeconds)}s old, but only output from last ${since}s was requested. File may not have recent entries.`
+        );
+      }
+    }
+    const content = readFileSync2(logFilePath, "utf-8");
+    let allLines = content.split("\n").filter((line) => line.trim().length > 0);
+    if (grep) {
+      const grepLower = grep.toLowerCase();
+      allLines = allLines.filter((line) => line.toLowerCase().includes(grepLower));
+    }
+    const maxLines = Math.min(lines, 1e4);
+    const recentLines = allLines.slice(-maxLines);
+    const result = [
+      `\u{1F4CB} Firefox Output File: ${logFilePath}`,
+      `Total lines in file: ${allLines.length}`,
+      grep ? `Lines matching "${grep}": ${allLines.length}` : "",
+      `Showing last ${recentLines.length} lines:`,
+      "",
+      "\u2500".repeat(80),
+      recentLines.join("\n")
+    ].filter(Boolean).join("\n");
+    return successResponse(result);
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleGetFirefoxInfo(_input) {
+  try {
+    const firefox3 = await getFirefox();
+    const options = firefox3.getOptions();
+    const logFilePath = firefox3.getLogFilePath();
+    const info = [];
+    info.push("\u{1F98A} Firefox Instance Configuration");
+    info.push("");
+    info.push(`Binary: ${options.firefoxPath ?? "System Firefox (default)"}`);
+    info.push(`Headless: ${options.headless ? "Yes" : "No"}`);
+    if (options.viewport) {
+      info.push(`Viewport: ${options.viewport.width}x${options.viewport.height}`);
+    }
+    if (options.profilePath) {
+      info.push(`Profile: ${options.profilePath}`);
+    }
+    if (options.startUrl) {
+      info.push(`Start URL: ${options.startUrl}`);
+    }
+    if (options.args && options.args.length > 0) {
+      info.push(`Arguments: ${options.args.join(" ")}`);
+    }
+    if (options.env && Object.keys(options.env).length > 0) {
+      info.push("");
+      info.push("Environment Variables:");
+      for (const [key, value] of Object.entries(options.env)) {
+        info.push(`  ${key}=${value}`);
+      }
+    }
+    if (options.prefs && Object.keys(options.prefs).length > 0) {
+      info.push("");
+      info.push("Preferences:");
+      for (const [key, value] of Object.entries(options.prefs)) {
+        info.push(`  ${key} = ${JSON.stringify(value)}`);
+      }
+    }
+    if (logFilePath) {
+      info.push("");
+      info.push(`Output File: ${logFilePath}`);
+      if (existsSync(logFilePath)) {
+        const stats = statSync(logFilePath);
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+        info.push(`  Size: ${sizeMB} MB`);
+        info.push(`  Last Modified: ${stats.mtime.toISOString()}`);
+      } else {
+        info.push("  (file not created yet)");
+      }
+    }
+    return successResponse(info.join("\n"));
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleRestartFirefox(input) {
+  try {
+    const { firefoxPath, profilePath, env, headless, startUrl, prefs } = input;
+    let newEnv;
+    if (env && Array.isArray(env) && env.length > 0) {
+      newEnv = {};
+      for (const envStr of env) {
+        const [key, ...valueParts] = envStr.split("=");
+        if (key && valueParts.length > 0) {
+          newEnv[key] = valueParts.join("=");
+        }
+      }
+    }
+    const currentFirefox = getFirefoxIfRunning();
+    const isConnected = currentFirefox ? await currentFirefox.isConnected() : false;
+    if (currentFirefox && isConnected) {
+      const currentOptions = currentFirefox.getOptions();
+      const mergedPrefs = prefs !== void 0 ? { ...currentOptions.prefs || {}, ...prefs } : currentOptions.prefs;
+      const newOptions = {
+        ...currentOptions,
+        firefoxPath: firefoxPath ?? currentOptions.firefoxPath,
+        profilePath: profilePath ?? currentOptions.profilePath,
+        env: newEnv !== void 0 ? newEnv : currentOptions.env,
+        headless: headless !== void 0 ? headless : currentOptions.headless,
+        startUrl: startUrl ?? currentOptions.startUrl ?? "about:home",
+        prefs: mergedPrefs
+      };
+      setNextLaunchOptions(newOptions);
+      try {
+        await currentFirefox.close();
+      } catch (error2) {
+      }
+      resetFirefox();
+      const changes = [];
+      if (firefoxPath && firefoxPath !== currentOptions.firefoxPath) {
+        changes.push(`Binary: ${firefoxPath}`);
+      }
+      if (profilePath && profilePath !== currentOptions.profilePath) {
+        changes.push(`Profile: ${profilePath}`);
+      }
+      if (newEnv !== void 0 && JSON.stringify(newEnv) !== JSON.stringify(currentOptions.env)) {
+        changes.push(`Environment variables updated:`);
+        for (const [key, value] of Object.entries(newEnv)) {
+          changes.push(`  ${key}=${value}`);
+        }
+      }
+      if (headless !== void 0 && headless !== currentOptions.headless) {
+        changes.push(`Headless: ${headless ? "enabled" : "disabled"}`);
+      }
+      if (startUrl && startUrl !== currentOptions.startUrl) {
+        changes.push(`Start URL: ${startUrl}`);
+      }
+      if (changes.length === 0) {
+        return successResponse(
+          "\u2705 Firefox closed. Will restart with same configuration on next tool call."
+        );
+      }
+      return successResponse(
+        `\u2705 Firefox closed. Will restart with new configuration on next tool call:
+${changes.join("\n")}`
+      );
+    } else {
+      if (currentFirefox) {
+        resetFirefox();
+      }
+      const resolvedFirefoxPath = firefoxPath ?? args.firefoxPath ?? void 0;
+      if (!resolvedFirefoxPath) {
+        return errorResponse(
+          new Error(
+            "Firefox is not running and no firefoxPath provided. Please specify firefoxPath to start Firefox."
+          )
+        );
+      }
+      const newOptions = {
+        firefoxPath: resolvedFirefoxPath,
+        profilePath: profilePath ?? args.profilePath ?? void 0,
+        env: newEnv,
+        headless: headless ?? false,
+        startUrl: startUrl ?? "about:home"
+      };
+      setNextLaunchOptions(newOptions);
+      const config2 = [`Binary: ${resolvedFirefoxPath}`];
+      const resolvedProfilePath = profilePath ?? args.profilePath;
+      if (resolvedProfilePath) {
+        config2.push(`Profile: ${resolvedProfilePath}`);
+      }
+      if (newEnv) {
+        config2.push("Environment variables:");
+        for (const [key, value] of Object.entries(newEnv)) {
+          config2.push(`  ${key}=${value}`);
+        }
+      }
+      if (headless) {
+        config2.push("Headless: enabled");
+      }
+      if (startUrl) {
+        config2.push(`Start URL: ${startUrl}`);
+      }
+      return successResponse(
+        `\u2705 Firefox configured. Will start on next tool call:
+${config2.join("\n")}`
+      );
+    }
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+var getFirefoxLogsTool, getFirefoxInfoTool, restartFirefoxTool;
+var init_firefox_management = __esm({
+  async "src/tools/firefox-management.ts"() {
+    "use strict";
+    await init_index();
+    init_response_helpers();
+    getFirefoxLogsTool = {
+      name: "get_firefox_output",
+      description: "Retrieve Firefox output (stdout/stderr including MOZ_LOG, warnings, crashes, stack traces). Returns recent output from the capture file. Use filters to focus on specific content.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          lines: {
+            type: "number",
+            description: "Number of recent log lines to return (default: 100, max: 10000)"
+          },
+          grep: {
+            type: "string",
+            description: "Filter log lines containing this string (case-insensitive)"
+          },
+          since: {
+            type: "number",
+            description: "Only show logs written in the last N seconds"
+          }
+        }
+      }
+    };
+    getFirefoxInfoTool = {
+      name: "get_firefox_info",
+      description: "Get information about the current Firefox instance configuration, including binary path, environment variables, and output file location.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    };
+    restartFirefoxTool = {
+      name: "restart_firefox",
+      description: "Restart Firefox with different configuration. Allows changing binary path, environment variables, and other options. All current tabs will be closed.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          firefoxPath: {
+            type: "string",
+            description: "New Firefox binary path (optional, keeps current if not specified)"
+          },
+          profilePath: {
+            type: "string",
+            description: "Firefox profile path (optional, keeps current if not specified)"
+          },
+          env: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            description: 'New environment variables in KEY=VALUE format (optional, e.g., ["MOZ_LOG=HTMLMediaElement:5", "MOZ_LOG_FILE=/tmp/ff.log"])'
+          },
+          headless: {
+            type: "boolean",
+            description: "Run in headless mode (optional, keeps current if not specified)"
+          },
+          startUrl: {
+            type: "string",
+            description: "URL to navigate to after restart (optional, uses about:home if not specified)"
+          },
+          prefs: {
+            type: "object",
+            description: "Firefox preferences to set at startup. Values are auto-typed: true/false become booleans, integers become numbers, everything else is a string. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1.",
+            additionalProperties: {
+              oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }]
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/tools/privileged-context.ts
+function formatContextList(contexts) {
+  if (contexts.length === 0) {
+    return "\u{1F527} No privileged contexts found";
+  }
+  const lines = [`\u{1F527} ${contexts.length} privileged contexts`];
+  for (const ctx of contexts) {
+    const id = ctx.context;
+    const url2 = ctx.url || "(no url)";
+    const children = ctx.children ? ` [${ctx.children.length} children]` : "";
+    lines.push(`  ${id}: ${url2}${children}`);
+  }
+  return lines.join("\n");
+}
+async function handleListPrivilegedContexts(_args) {
+  try {
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    const result = await firefox3.sendBiDiCommand("browsingContext.getTree", {
+      "moz:scope": "chrome"
+    });
+    const contexts = result.contexts || [];
+    return successResponse(formatContextList(contexts));
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message.includes("UnsupportedOperationError")) {
+      return errorResponse(
+        new Error(
+          "Privileged context access not enabled. Set MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 environment variable and restart Firefox."
+        )
+      );
+    }
+    return errorResponse(error2);
+  }
+}
+async function handleSelectPrivilegedContext(args2) {
+  try {
+    const { contextId } = args2;
+    if (!contextId || typeof contextId !== "string") {
+      throw new Error("contextId parameter is required and must be a string");
+    }
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    const driver = firefox3.getDriver();
+    await driver.switchTo().window(contextId);
+    try {
+      await driver.setContext("chrome");
+    } catch (contextError) {
+      return errorResponse(
+        new Error(
+          `Switched to context ${contextId} but failed to set Marionette privileged context. Your Firefox build may not support privileged context or MOZ_REMOTE_ALLOW_SYSTEM_ACCESS is not set.`
+        )
+      );
+    }
+    return successResponse(
+      `\u2705 Switched to privileged context: ${contextId} (Marionette context set to privileged)`
+    );
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+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");
+    }
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_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(`\u{1F527} Result:
+${resultText}`);
+    } catch (executeError) {
+      return errorResponse(
+        new Error(
+          `Script execution failed: ${executeError instanceof Error ? executeError.message : String(executeError)}`
+        )
+      );
+    }
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+var listPrivilegedContextsTool, selectPrivilegedContextTool, evaluatePrivilegedScriptTool;
+var init_privileged_context = __esm({
+  "src/tools/privileged-context.ts"() {
+    "use strict";
+    init_response_helpers();
+    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.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    };
+    selectPrivilegedContextTool = {
+      name: "select_privileged_context",
+      description: 'Select a privileged browsing context by ID and set WebDriver Classic context to "chrome" . Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          contextId: {
+            type: "string",
+            description: "Privileged browsing context ID from list_privileged_contexts"
+          }
+        },
+        required: ["contextId"]
+      }
+    };
+    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.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          expression: {
+            type: "string",
+            description: "JavaScript expression to evaluate in the privileged context"
+          }
+        },
+        required: ["expression"]
+      }
+    };
+  }
+});
+
+// src/firefox/pref-utils.ts
+function generatePrefScript(name, value) {
+  const escapedName = JSON.stringify(name);
+  if (typeof value === "boolean") {
+    return `Services.prefs.setBoolPref(${escapedName}, ${value})`;
+  } else if (typeof value === "number") {
+    return `Services.prefs.setIntPref(${escapedName}, ${value})`;
+  } else {
+    return `Services.prefs.setStringPref(${escapedName}, ${JSON.stringify(value)})`;
+  }
+}
+var init_pref_utils = __esm({
+  "src/firefox/pref-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/firefox-prefs.ts
+async function handleSetFirefoxPrefs(args2) {
+  try {
+    const { prefs } = args2;
+    if (!prefs || typeof prefs !== "object") {
+      throw new Error("prefs parameter is required and must be an object");
+    }
+    const prefEntries = Object.entries(prefs);
+    if (prefEntries.length === 0) {
+      return successResponse("No preferences to set");
+    }
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    const result = await firefox3.sendBiDiCommand("browsingContext.getTree", {
+      "moz:scope": "chrome"
+    });
+    const contexts = result.contexts || [];
+    if (contexts.length === 0) {
+      throw new Error(
+        "No privileged contexts available. Ensure MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 is set."
+      );
+    }
+    const driver = firefox3.getDriver();
+    const chromeContextId = contexts[0].context;
+    const originalContextId = firefox3.getCurrentContextId();
+    try {
+      await driver.switchTo().window(chromeContextId);
+      await driver.setContext("chrome");
+      const results = [];
+      const errors = [];
+      for (const [name, value] of prefEntries) {
+        try {
+          const script = generatePrefScript(name, value);
+          await driver.executeScript(script);
+          results.push(`  ${name} = ${JSON.stringify(value)}`);
+        } catch (error2) {
+          errors.push(`  ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      }
+      const output = [];
+      if (results.length > 0) {
+        output.push(`\u2705 Set ${results.length} preference(s):`);
+        output.push(...results);
+      }
+      if (errors.length > 0) {
+        output.push(`
+\u26A0\uFE0F Failed to set ${errors.length} preference(s):`);
+        output.push(...errors);
+      }
+      return successResponse(output.join("\n"));
+    } finally {
+      try {
+        await driver.setContext("content");
+        if (originalContextId) {
+          await driver.switchTo().window(originalContextId);
+        }
+      } catch {
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message.includes("UnsupportedOperationError")) {
+      return errorResponse(
+        new Error(
+          "Chrome context access not enabled. Set MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 environment variable and restart Firefox."
+        )
+      );
+    }
+    return errorResponse(error2);
+  }
+}
+async function handleGetFirefoxPrefs(args2) {
+  try {
+    const { names } = args2;
+    if (!names || !Array.isArray(names) || names.length === 0) {
+      throw new Error("names parameter is required and must be a non-empty array");
+    }
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    const result = await firefox3.sendBiDiCommand("browsingContext.getTree", {
+      "moz:scope": "chrome"
+    });
+    const contexts = result.contexts || [];
+    if (contexts.length === 0) {
+      throw new Error(
+        "No privileged contexts available. Ensure MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 is set."
+      );
+    }
+    const driver = firefox3.getDriver();
+    const chromeContextId = contexts[0].context;
+    const originalContextId = firefox3.getCurrentContextId();
+    try {
+      await driver.switchTo().window(chromeContextId);
+      await driver.setContext("chrome");
+      const results = [];
+      const errors = [];
+      for (const name of names) {
+        try {
+          const script = `
+            (function() {
+              const type = Services.prefs.getPrefType(${JSON.stringify(name)});
+              if (type === Services.prefs.PREF_INVALID) {
+                return { exists: false };
+              } else if (type === Services.prefs.PREF_BOOL) {
+                return { exists: true, value: Services.prefs.getBoolPref(${JSON.stringify(name)}) };
+              } else if (type === Services.prefs.PREF_INT) {
+                return { exists: true, value: Services.prefs.getIntPref(${JSON.stringify(name)}) };
+              } else {
+                return { exists: true, value: Services.prefs.getStringPref(${JSON.stringify(name)}) };
+              }
+            })()
+          `;
+          const prefResult = await driver.executeScript(`return ${script}`);
+          if (prefResult.exists) {
+            results.push(`  ${name} = ${JSON.stringify(prefResult.value)}`);
+          } else {
+            results.push(`  ${name} = (not set)`);
+          }
+        } catch (error2) {
+          errors.push(`  ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      }
+      const output = [];
+      if (results.length > 0) {
+        output.push(`\u{1F4CB} Firefox Preferences:`);
+        output.push(...results);
+      }
+      if (errors.length > 0) {
+        output.push(`
+\u26A0\uFE0F Failed to read ${errors.length} preference(s):`);
+        output.push(...errors);
+      }
+      return successResponse(output.join("\n"));
+    } finally {
+      try {
+        await driver.setContext("content");
+        if (originalContextId) {
+          await driver.switchTo().window(originalContextId);
+        }
+      } catch {
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message.includes("UnsupportedOperationError")) {
+      return errorResponse(
+        new Error(
+          "Chrome context access not enabled. Set MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 environment variable and restart Firefox."
+        )
+      );
+    }
+    return errorResponse(error2);
+  }
+}
+var setFirefoxPrefsTool, getFirefoxPrefsTool;
+var init_firefox_prefs = __esm({
+  "src/tools/firefox-prefs.ts"() {
+    "use strict";
+    init_response_helpers();
+    init_pref_utils();
+    setFirefoxPrefsTool = {
+      name: "set_firefox_prefs",
+      description: "Set Firefox preferences at runtime a privileged API. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prefs: {
+            type: "object",
+            description: "Object mapping preference names to values. Values are auto-typed: true/false become booleans, integers become numbers, everything else is a string.",
+            additionalProperties: {
+              oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }]
+            }
+          }
+        },
+        required: ["prefs"]
+      }
+    };
+    getFirefoxPrefsTool = {
+      name: "get_firefox_prefs",
+      description: "Get Firefox preference values via a privileged API. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          names: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of preference names to read"
+          }
+        },
+        required: ["names"]
+      }
+    };
+  }
+});
+
+// src/tools/webextension.ts
+async function handleInstallExtension(args2) {
+  try {
+    const { type, path, value, permanent } = args2;
+    if (!type) {
+      throw new Error("type parameter is required");
+    }
+    if ((type === "archivePath" || type === "path") && !path) {
+      throw new Error(`path parameter is required for type "${type}"`);
+    }
+    if (type === "base64" && !value) {
+      throw new Error('value parameter is required for type "base64"');
+    }
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    const extensionData = { type };
+    if (path) {
+      extensionData.path = path;
+    }
+    if (value) {
+      extensionData.value = value;
+    }
+    const params = { extensionData };
+    if (permanent !== void 0) {
+      params["moz:permanent"] = permanent;
+    }
+    const result = await firefox3.sendBiDiCommand("webExtension.install", params);
+    const extensionId = result?.extension || "unknown";
+    const installType = permanent ? "permanent" : "temporary";
+    return successResponse(
+      `\u2705 Extension installed (${installType}):
+  ID: ${extensionId}
+  Type: ${type}${path ? `
+  Path: ${path}` : ""}`
+    );
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+async function handleUninstallExtension(args2) {
+  try {
+    const { id } = args2;
+    if (!id || typeof id !== "string") {
+      throw new Error("id parameter is required and must be a string");
+    }
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    await firefox3.sendBiDiCommand("webExtension.uninstall", { extension: id });
+    return successResponse(`\u2705 Extension uninstalled:
+  ID: ${id}`);
+  } catch (error2) {
+    return errorResponse(error2);
+  }
+}
+function formatExtensionList(extensions, filterId) {
+  if (extensions.length === 0) {
+    return filterId ? `\u{1F50D} Extension not found: ${filterId}` : "\u{1F4E6} No extensions installed";
+  }
+  const lines = [
+    `\u{1F4E6} ${extensions.length} extension(s)${filterId ? ` (filtered by: ${filterId})` : ""}`
+  ];
+  for (const ext of extensions) {
+    lines.push("");
+    lines.push(`  \u{1F4CC} ${ext.name} (v${ext.version})`);
+    lines.push(`     ID: ${ext.id}`);
+    lines.push(`     Type: ${ext.isSystem ? "\u{1F527} System/Built-in" : "\u{1F464} User-installed"}`);
+    lines.push(`     UUID: ${ext.uuid}`);
+    lines.push(`     Base URL: ${ext.baseURL}`);
+    lines.push(`     Manifest: v${ext.manifestVersion || "unknown"}`);
+    lines.push(`     Active: ${ext.isActive ? "\u2705" : "\u274C"}`);
+    if (ext.backgroundScripts.length > 0) {
+      lines.push(`     Background scripts:`);
+      for (const script of ext.backgroundScripts) {
+        const scriptName = script.split("/").pop();
+        lines.push(`       \u2022 ${scriptName}`);
+      }
+    } else {
+      lines.push(`     Background scripts: (none)`);
+    }
+  }
+  return lines.join("\n");
+}
+async function handleListExtensions(args2) {
+  try {
+    const { ids, name, isActive, isSystem } = args2 || {};
+    const { getFirefox: getFirefox2 } = await init_index().then(() => index_exports);
+    const firefox3 = await getFirefox2();
+    const result = await firefox3.sendBiDiCommand("browsingContext.getTree", {
+      "moz:scope": "chrome"
+    });
+    const contexts = result.contexts || [];
+    if (contexts.length === 0) {
+      throw new Error(
+        "No privileged contexts available. Ensure MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 is set."
+      );
+    }
+    const driver = firefox3.getDriver();
+    const chromeContextId = contexts[0].context;
+    const originalContextId = firefox3.getCurrentContextId();
+    try {
+      await driver.switchTo().window(chromeContextId);
+      await driver.setContext("chrome");
+      const filterParams = { ids, name, isActive, isSystem };
+      const script = `
+        const callback = arguments[arguments.length - 1];
+        const filter = ${JSON.stringify(filterParams)};
+        (async () => {
+          try {
+            const { AddonManager } = ChromeUtils.importESModule("resource://gre/modules/AddonManager.sys.mjs");
+            let addons = await AddonManager.getAllAddons();
+
+            // Filter to only extensions (not themes, plugins, etc.)
+            addons = addons.filter(addon => addon.type === "extension");
+
+            // Apply filters
+            if (filter.ids && filter.ids.length > 0) {
+              addons = addons.filter(addon => filter.ids.includes(addon.id));
+            }
+            if (filter.name) {
+              const search = filter.name.toLowerCase();
+              addons = addons.filter(addon => addon.name.toLowerCase().includes(search));
+            }
+            if (typeof filter.isActive === 'boolean') {
+              addons = addons.filter(addon => addon.isActive === filter.isActive);
+            }
+            if (typeof filter.isSystem === 'boolean') {
+              addons = addons.filter(addon => addon.isSystem === filter.isSystem);
+            }
+
+            const extensions = [];
+            for (const addon of addons) {
+              const policy = WebExtensionPolicy.getByID(addon.id);
+              if (!policy) continue; // Skip if no policy (addon not loaded)
+
+              extensions.push({
+                id: addon.id,
+                name: addon.name,
+                version: addon.version,
+                isActive: addon.isActive,
+                isSystem: addon.isSystem,
+                uuid: policy.mozExtensionHostname,
+                baseURL: policy.baseURL,
+                backgroundScripts: policy.extension?.backgroundScripts || [],
+                manifestVersion: policy.extension?.manifest?.manifest_version || null
+              });
+            }
+
+            callback(extensions);
+          } catch (error) {
+            callback([]);
+          }
+        })();
+      `;
+      const extensions = await driver.executeAsyncScript(script);
+      const filterDesc = [
+        ids && ids.length > 0 ? `ids: [${ids.join(", ")}]` : null,
+        name ? `name: "${name}"` : null,
+        typeof isActive === "boolean" ? `active: ${isActive}` : null,
+        typeof isSystem === "boolean" ? `system: ${isSystem}` : null
+      ].filter(Boolean).join(", ");
+      return successResponse(formatExtensionList(extensions, filterDesc || void 0));
+    } finally {
+      try {
+        await driver.setContext("content");
+        if (originalContextId) {
+          await driver.switchTo().window(originalContextId);
+        }
+      } catch {
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message.includes("UnsupportedOperationError")) {
+      return errorResponse(
+        new Error(
+          "Chrome context access not enabled. Set MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 environment variable and restart Firefox."
+        )
+      );
+    }
+    return errorResponse(error2);
+  }
+}
+var installExtensionTool, uninstallExtensionTool, listExtensionsTool;
+var init_webextension = __esm({
+  "src/tools/webextension.ts"() {
+    "use strict";
+    init_response_helpers();
+    installExtensionTool = {
+      name: "install_extension",
+      description: "Install a Firefox extension using WebDriver BiDi webExtension.install command. Supports installing from archive (.xpi/.zip), base64-encoded data, or unpacked directory.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["archivePath", "base64", "path"],
+            description: 'Extension data type: "archivePath" for .xpi/.zip, "base64" for encoded data, "path" for unpacked directory'
+          },
+          path: {
+            type: "string",
+            description: "File path (for archivePath or path types)"
+          },
+          value: {
+            type: "string",
+            description: "Base64-encoded extension data (for base64 type)"
+          },
+          permanent: {
+            type: "boolean",
+            description: "Firefox-specific: Install permanently (requires signed extension). Default: false (temporary install)"
+          }
+        },
+        required: ["type"]
+      }
+    };
+    uninstallExtensionTool = {
+      name: "uninstall_extension",
+      description: "Uninstall a Firefox extension using WebDriver BiDi webExtension.uninstall command. Requires the extension ID returned by install_extension or obtained from list_extensions.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Extension ID (e.g., "addon@example.com")'
+          }
+        },
+        required: ["id"]
+      }
+    };
+    listExtensionsTool = {
+      name: "list_extensions",
+      description: (
+        // MOZ_REMOTE_ALLOW_SYSTEM_ACCESS is required because the tool relies on the
+        // privileged AddonManager API as a workaround for the currently missing
+        // webExtension.getExtensions WebDriver BiDi command.
+        "List installed Firefox extensions with UUIDs and background scripts. Requires MOZ_REMOTE_ALLOW_SYSTEM_ACCESS=1 env var."
+      ),
+      inputSchema: {
+        type: "object",
+        properties: {
+          ids: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Optional: Filter by exact extension IDs (e.g., ["addon@example.com"])'
+          },
+          name: {
+            type: "string",
+            description: 'Optional: Filter by partial name match (case-insensitive, e.g., "shopify")'
+          },
+          isActive: {
+            type: "boolean",
+            description: "Optional: Filter by enabled (true) or disabled (false) status"
+          },
+          isSystem: {
+            type: "boolean",
+            description: "Optional: Filter by system/built-in (true) or user-installed (false) extensions"
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/tools/index.ts
 var init_tools = __esm({
-  "src/tools/index.ts"() {
+  async "src/tools/index.ts"() {
     "use strict";
     init_pages2();
+    init_script();
     init_console2();
     init_network2();
     init_snapshot2();
     init_input();
     init_screenshot();
     init_utilities();
+    await init_firefox_management();
+    init_privileged_context();
+    init_firefox_prefs();
+    init_webextension();
   }
 });
 
@@ -25565,7 +26795,7 @@ var init_errors4 = __esm({
     FirefoxDisconnectedError = class extends Error {
       constructor(reason) {
         const baseMessage = "Firefox browser is not connected";
-        const instruction = "The Firefox browser window was closed by the user. To continue browser automation, ask the user to restart the firefox-devtools-mcp server (they need to restart Claude Code or the MCP connection). This will launch a new Firefox instance.";
+        const instruction = 'The Firefox browser window was closed. Use the restart_firefox tool with firefoxPath parameter to start a new Firefox instance. Example: restart_firefox with firefoxPath="/usr/bin/firefox"';
         const fullMessage = reason ? `${baseMessage}: ${reason}. ${instruction}` : `${baseMessage}. ${instruction}`;
         super(fullMessage);
         this.name = "FirefoxDisconnectedError";
@@ -25979,8 +27209,11 @@ __export(index_exports, {
   FirefoxDisconnectedError: () => FirefoxDisconnectedError,
   args: () => args,
   getFirefox: () => getFirefox,
+  getFirefoxIfRunning: () => getFirefoxIfRunning,
   isDisconnectionError: () => isDisconnectionError,
-  resetFirefox: () => resetFirefox
+  isFirefoxRunning: () => isFirefoxRunning,
+  resetFirefox: () => resetFirefox,
+  setNextLaunchOptions: () => setNextLaunchOptions
 });
 import { version as version2 } from "process";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -25993,6 +27226,16 @@ function resetFirefox() {
   }
   log("Firefox instance reset - will reconnect on next tool call");
 }
+function setNextLaunchOptions(options) {
+  nextLaunchOptions = options;
+  log("Next launch options updated");
+}
+function isFirefoxRunning() {
+  return firefox2 !== null;
+}
+function getFirefoxIfRunning() {
+  return firefox2;
+}
 async function getFirefox() {
   if (firefox2) {
     const isConnected = await firefox2.isConnected();
@@ -26004,21 +27247,48 @@ async function getFirefox() {
     return firefox2;
   }
   log("Initializing Firefox DevTools connection...");
-  const options = {
-    firefoxPath: args.firefoxPath ?? void 0,
-    headless: args.headless,
-    profilePath: args.profilePath ?? void 0,
-    viewport: args.viewport ?? void 0,
-    args: args.firefoxArg ?? void 0,
-    startUrl: args.startUrl ?? void 0,
-    acceptInsecureCerts: args.acceptInsecureCerts,
-    connectExisting: args.connectExisting,
-    marionettePort: args.marionettePort
-  };
+  let options;
+  if (nextLaunchOptions) {
+    options = nextLaunchOptions;
+    nextLaunchOptions = null;
+    log("Using custom launch options from restart_firefox");
+  } else {
+    let envVars;
+    if (args.env && Array.isArray(args.env) && args.env.length > 0) {
+      envVars = {};
+      for (const envStr of args.env) {
+        const [key, ...valueParts] = envStr.split("=");
+        if (key && valueParts.length > 0) {
+          envVars[key] = valueParts.join("=");
+        }
+      }
+    }
+    const prefValues = parsePrefs(args.pref);
+    const prefs = Object.keys(prefValues).length > 0 ? prefValues : void 0;
+    options = {
+      firefoxPath: args.firefoxPath ?? void 0,
+      headless: args.headless,
+      profilePath: args.profilePath ?? void 0,
+      viewport: args.viewport ?? void 0,
+      args: args.firefoxArg ?? void 0,
+      startUrl: args.startUrl ?? void 0,
+      acceptInsecureCerts: args.acceptInsecureCerts,
+      connectExisting: args.connectExisting,
+      marionettePort: args.marionettePort,
+      env: envVars,
+      logFile: args.outputFile ?? void 0,
+      prefs
+    };
+  }
   firefox2 = new FirefoxClient(options);
-  await firefox2.connect();
-  log("Firefox DevTools connection established");
-  return firefox2;
+  try {
+    await firefox2.connect();
+    log("Firefox DevTools connection established");
+    return firefox2;
+  } catch (error2) {
+    firefox2 = null;
+    throw error2;
+  }
 }
 async function main() {
   log(`Starting ${SERVER_NAME} v${SERVER_VERSION}`);
@@ -26074,7 +27344,7 @@ async function main() {
   log("Firefox DevTools MCP server running on stdio");
   log("Ready to accept tool requests");
 }
-var major, args, firefox2, toolHandlers, allTools, modulePath, scriptPath, isMainModule;
+var major, args, firefox2, nextLaunchOptions, toolHandlers, allTools, modulePath, scriptPath, isMainModule;
 var init_index = __esm({
   async "src/index.ts"() {
     init_server2();
@@ -26084,7 +27354,7 @@ var init_index = __esm({
     init_logger();
     init_cli();
     init_firefox();
-    init_tools();
+    await init_tools();
     init_errors4();
     init_firefox();
     init_errors4();
@@ -26105,15 +27375,14 @@ var init_index = __esm({
     }
     args = parseArguments(SERVER_VERSION);
     firefox2 = null;
-    toolHandlers = /* @__PURE__ */ new Map([
+    nextLaunchOptions = null;
+    toolHandlers = new Map([
       // Pages
       ["list_pages", handleListPages],
       ["new_page", handleNewPage],
       ["navigate_page", handleNavigatePage],
       ["select_page", handleSelectPage],
       ["close_page", handleClosePage],
-      // Script evaluation - DISABLED (see docs/future-features.md)
-      // ['evaluate_script', tools.handleEvaluateScript],
       // Console
       ["list_console_messages", handleListConsoleMessages],
       ["clear_console_messages", handleClearConsoleMessages],
@@ -26138,7 +27407,25 @@ var init_index = __esm({
       ["accept_dialog", handleAcceptDialog],
       ["dismiss_dialog", handleDismissDialog],
       ["navigate_history", handleNavigateHistory],
-      ["set_viewport_size", handleSetViewportSize]
+      ["set_viewport_size", handleSetViewportSize],
+      // Firefox Management
+      ["get_firefox_output", handleGetFirefoxLogs],
+      ["get_firefox_info", handleGetFirefoxInfo],
+      ["restart_firefox", handleRestartFirefox],
+      // WebExtensions (install/uninstall use standard BiDi, no privileged context required)
+      ["install_extension", handleInstallExtension],
+      ["uninstall_extension", handleUninstallExtension],
+      // Script evaluation — requires --enable-script
+      ...args.enableScript ? [["evaluate_script", handleEvaluateScript]] : [],
+      // Privileged context tools — requires --enable-privileged-context
+      ...args.enablePrivilegedContext ? [
+        ["list_privileged_contexts", handleListPrivilegedContexts],
+        ["select_privileged_context", handleSelectPrivilegedContext],
+        ["evaluate_privileged_script", handleEvaluatePrivilegedScript],
+        ["set_firefox_prefs", handleSetFirefoxPrefs],
+        ["get_firefox_prefs", handleGetFirefoxPrefs],
+        ["list_extensions", handleListExtensions]
+      ] : []
     ]);
     allTools = [
       listPagesTool,
@@ -26164,7 +27451,23 @@ var init_index = __esm({
       acceptDialogTool,
       dismissDialogTool,
       navigateHistoryTool,
-      setViewportSizeTool
+      setViewportSizeTool,
+      getFirefoxLogsTool,
+      getFirefoxInfoTool,
+      restartFirefoxTool,
+      installExtensionTool,
+      uninstallExtensionTool,
+      // Script evaluation — requires --enable-script
+      ...args.enableScript ? [evaluateScriptTool] : [],
+      // Privileged context tools — requires --enable-privileged-context
+      ...args.enablePrivilegedContext ? [
+        listPrivilegedContextsTool,
+        selectPrivilegedContextTool,
+        evaluatePrivilegedScriptTool,
+        setFirefoxPrefsTool,
+        getFirefoxPrefsTool,
+        listExtensionsTool
+      ] : []
     ];
     modulePath = fileURLToPath2(import.meta.url);
     scriptPath = process.argv[1] ? resolve3(process.argv[1]) : "";
@@ -26190,6 +27493,9 @@ export {
   FirefoxDisconnectedError,
   args,
   getFirefox,
+  getFirefoxIfRunning,
   isDisconnectionError,
-  resetFirefox
+  isFirefoxRunning,
+  resetFirefox,
+  setNextLaunchOptions
 };