firefox-devtools-mcp 0.7.4 → 0.8.1

package/README.md

@@ -43,6 +43,7 @@ claude mcp add firefox-devtools npx firefox-devtools-mcp@latest \
 Option B — Edit Claude Code settings JSON
 
 Add to your Claude Code config file:
+
 - macOS: `~/Library/Application Support/Claude/Code/mcp_settings.json`
 - Linux: `~/.config/claude/code/mcp_settings.json`
 - Windows: `%APPDATA%\Claude\Code\mcp_settings.json`
@@ -75,6 +76,7 @@ npx @modelcontextprotocol/inspector npx firefox-devtools-mcp@latest --start-url
 ```
 
 Then call tools like:
+
 - `list_pages`, `select_page`, `navigate_page`
 - `take_snapshot` then `click_by_uid` / `fill_by_uid`
 - `list_network_requests` (always‑on capture), `get_network_request`
@@ -91,6 +93,30 @@ You can pass flags or environment variables (names on the right):
 - `--firefox-arg` — extra Firefox arguments (repeatable)
 - `--start-url` — open this URL on start (`START_URL`)
 - `--accept-insecure-certs` — ignore TLS errors (`ACCEPT_INSECURE_CERTS=true`)
+- `--connect-existing` — attach to an already-running Firefox instead of launching a new one (`CONNECT_EXISTING=true`)
+- `--marionette-port` — Marionette port for connect-existing mode, default 2828 (`MARIONETTE_PORT`)
+
+### Connect to existing Firefox
+
+Use `--connect-existing` to automate your real browsing session — with cookies, logins, and open tabs intact:
+
+```bash
+# Start Firefox with Marionette enabled
+firefox --marionette
+
+# Run the MCP server
+npx firefox-devtools-mcp --connect-existing --marionette-port 2828
+```
+
+Or set `marionette.enabled` to `true` in `about:config` (or `user.js`) to enable Marionette on every launch.
+
+BiDi-dependent features (console events, network events) are not available in connect-existing mode; all other features work normally.
+
+> **Warning:** Do not leave Marionette enabled during normal browsing. It sets
+> `navigator.webdriver = true` and changes other browser fingerprint signals,
+> which can trigger bot detection on sites protected by Cloudflare, Akamai, etc.
+> Only enable Marionette when you need MCP automation, then restart Firefox
+> normally afterward.
 
 ## Tool overview
 
@@ -134,6 +160,7 @@ npm run inspector:dev
 - Stale UIDs after navigation: take a fresh snapshot (`take_snapshot`) before using UID tools.
 - Windows 10: Error during discovery for MCP server 'firefox-devtools': MCP error -32000: Connection closed
   - **Solution 1** Call using `cmd` (For more info https://github.com/modelcontextprotocol/servers/issues/1082#issuecomment-2791786310)
+
     ```json
     "mcpServers": {
       "firefox-devtools": {
@@ -141,10 +168,12 @@ npm run inspector:dev
         "args": ["/c", "npx", "-y", "firefox-devtools-mcp@latest"]
       }
     }
-    ``` 
+    ```
+
     > **The Key Change:** On Windows, running a Node.js package via `npx` often requires the `cmd /c` prefix to be executed correctly from within another process like VSCode's extension host. Therefore, `"command": "npx"` was replaced with `"command": "cmd"`, and the actual `npx` command was moved into the `"args"` array, preceded by `"/c"`. This fix allows Windows to interpret the command correctly and launch the server.
   
   - **Solution 2** Instead of another layer of shell you can write the absolute path to `npx`:
+
     ```json
     "mcpServers": {
       "firefox-devtools": {
@@ -153,6 +182,7 @@ npm run inspector:dev
       }
     }
     ```
+
     Note: The path above is an example. You must adjust it to match the actual location of `npx` on your machine. Depending on your setup, the file extension might be `.cmd`, `.bat`, or `.exe` rather than `.ps1`. Also, ensure you use double backslashes (`\\`) as path delimiters, as required by the JSON format.
 
 ## Versioning

package/dist/index.js

@@ -22056,6 +22056,16 @@ var init_cli = __esm({
         type: "string",
         description: "URL to open when Firefox starts (default: about:home)",
         default: process.env.START_URL ?? "about:home"
+      },
+      connectExisting: {
+        type: "boolean",
+        description: "Connect to an already-running Firefox instance via Marionette instead of launching a new one. Requires Firefox to be running with marionette.enabled=true (set in user.js or launched with --marionette).",
+        default: (process.env.CONNECT_EXISTING ?? "false") === "true"
+      },
+      marionettePort: {
+        type: "number",
+        description: "Marionette port to connect to when using --connect-existing (default: 2828)",
+        default: Number(process.env.MARIONETTE_PORT ?? "2828")
       }
     };
   }
@@ -22064,11 +22074,320 @@ var init_cli = __esm({
 // src/firefox/core.ts
 import { Builder, Browser } from "selenium-webdriver";
 import firefox from "selenium-webdriver/firefox.js";
-var FirefoxCore;
+import { spawn } from "child_process";
+function findGeckodriverInCache(fs, path, cacheBase) {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const binaryName = `geckodriver${ext}`;
+  try {
+    if (!fs.existsSync(cacheBase)) {
+      return "";
+    }
+    for (const platformDir of fs.readdirSync(cacheBase)) {
+      const platformPath = path.join(cacheBase, platformDir);
+      if (!fs.statSync(platformPath).isDirectory()) {
+        continue;
+      }
+      const versionDirs = fs.readdirSync(platformPath).sort().reverse();
+      for (const versionDir of versionDirs) {
+        const candidate = path.join(platformPath, versionDir, binaryName);
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  } catch {
+  }
+  return "";
+}
+var GeckodriverElement, GeckodriverHttpDriver, FirefoxCore;
 var init_core3 = __esm({
   "src/firefox/core.ts"() {
     "use strict";
     init_logger();
+    GeckodriverElement = class {
+      constructor(cmd, elementId) {
+        this.cmd = cmd;
+        this.elementId = elementId;
+      }
+      async click() {
+        await this.cmd("POST", `/element/${this.elementId}/click`, {});
+      }
+      async clear() {
+        await this.cmd("POST", `/element/${this.elementId}/clear`, {});
+      }
+      async sendKeys(...args2) {
+        const text = args2.join("");
+        await this.cmd("POST", `/element/${this.elementId}/value`, { text });
+      }
+      async isDisplayed() {
+        return await this.cmd("GET", `/element/${this.elementId}/displayed`);
+      }
+      async takeScreenshot() {
+        return await this.cmd("GET", `/element/${this.elementId}/screenshot`);
+      }
+    };
+    GeckodriverHttpDriver = class _GeckodriverHttpDriver {
+      baseUrl;
+      sessionId;
+      gdProcess;
+      constructor(baseUrl, sessionId, gdProcess) {
+        this.baseUrl = baseUrl;
+        this.sessionId = sessionId;
+        this.gdProcess = gdProcess;
+      }
+      static async connect(marionettePort) {
+        const path = await import("path");
+        const { execFileSync } = await import("child_process");
+        let geckodriverPath;
+        try {
+          const { createRequire } = await import("module");
+          const require2 = createRequire(import.meta.url);
+          const swPkg = require2.resolve("selenium-webdriver/package.json");
+          const swDir = path.dirname(swPkg);
+          const platform = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux";
+          const ext = process.platform === "win32" ? ".exe" : "";
+          const smBin = path.join(swDir, "bin", platform, `selenium-manager${ext}`);
+          const result = JSON.parse(
+            execFileSync(smBin, ["--browser", "firefox", "--output", "json"], { encoding: "utf-8" })
+          );
+          geckodriverPath = result.result.driver_path;
+        } catch {
+          const os = await import("os");
+          const fs = await import("fs");
+          const cacheBase = path.join(os.homedir(), ".cache/selenium/geckodriver");
+          geckodriverPath = findGeckodriverInCache(fs, path, cacheBase);
+          if (!geckodriverPath) {
+            throw new Error("Cannot find geckodriver binary. Ensure selenium-webdriver is installed.");
+          }
+        }
+        logDebug(`Using geckodriver: ${geckodriverPath}`);
+        const gd = spawn(
+          geckodriverPath,
+          ["--connect-existing", "--marionette-port", String(marionettePort), "--port", "0"],
+          { stdio: ["ignore", "pipe", "pipe"] }
+        );
+        const port = await new Promise((resolve4, reject) => {
+          const timeout = setTimeout(() => reject(new Error("Geckodriver startup timeout")), 1e4);
+          const onData = (data) => {
+            const msg = data.toString();
+            logDebug(`[geckodriver] ${msg.trim()}`);
+            const match = msg.match(/Listening on\s+\S+:(\d+)/);
+            if (match?.[1]) {
+              clearTimeout(timeout);
+              resolve4(parseInt(match[1], 10));
+            }
+          };
+          gd.stdout?.on("data", onData);
+          gd.stderr?.on("data", onData);
+          gd.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+          gd.on("exit", (code) => {
+            clearTimeout(timeout);
+            reject(new Error(`Geckodriver exited with code ${code}`));
+          });
+        });
+        const baseUrl = `http://127.0.0.1:${port}`;
+        const resp = await fetch(`${baseUrl}/session`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ capabilities: { alwaysMatch: {} } })
+        });
+        const json2 = await resp.json();
+        if (!json2.value?.sessionId) {
+          throw new Error(`Failed to create session: ${JSON.stringify(json2)}`);
+        }
+        return new _GeckodriverHttpDriver(baseUrl, json2.value.sessionId, gd);
+      }
+      async cmd(method, path, body) {
+        const url2 = `${this.baseUrl}/session/${this.sessionId}${path}`;
+        const opts = {
+          method,
+          headers: { "Content-Type": "application/json" }
+        };
+        if (body !== void 0) {
+          opts.body = JSON.stringify(body);
+        }
+        const resp = await fetch(url2, opts);
+        const json2 = await resp.json();
+        if (json2.value && typeof json2.value === "object" && "error" in json2.value) {
+          const err = json2.value;
+          throw new Error(`${err.error}: ${err.message}`);
+        }
+        return json2.value;
+      }
+      // WebDriver-compatible methods used by the rest of the codebase
+      async getTitle() {
+        return await this.cmd("GET", "/title");
+      }
+      async getCurrentUrl() {
+        return await this.cmd("GET", "/url");
+      }
+      async getWindowHandle() {
+        return await this.cmd("GET", "/window");
+      }
+      async getAllWindowHandles() {
+        return await this.cmd("GET", "/window/handles");
+      }
+      async get(url2) {
+        await this.cmd("POST", "/url", { url: url2 });
+      }
+      async getPageSource() {
+        return await this.cmd("GET", "/source");
+      }
+      async executeScript(script, ...args2) {
+        return await this.cmd("POST", "/execute/sync", { script, args: args2 });
+      }
+      async executeAsyncScript(script, ...args2) {
+        return await this.cmd("POST", "/execute/async", { script, args: args2 });
+      }
+      async takeScreenshot() {
+        return await this.cmd("GET", "/screenshot");
+      }
+      async close() {
+        await this.cmd("DELETE", "/window");
+      }
+      async getSession() {
+        return { getId: () => this.sessionId };
+      }
+      // Element finding
+      async findElement(locator) {
+        const loc = locator;
+        const using = loc.using ?? "css selector";
+        const value = loc.value ?? "";
+        const result = await this.cmd("POST", "/element", { using, value });
+        const elementId = Object.values(result)[0];
+        return new GeckodriverElement(this.cmd.bind(this), elementId);
+      }
+      async findElements(locator) {
+        const loc = locator;
+        const using = loc.using ?? "css selector";
+        const value = loc.value ?? "";
+        const results = await this.cmd("POST", "/elements", { using, value });
+        return results.map((r) => new GeckodriverElement(this.cmd.bind(this), Object.values(r)[0]));
+      }
+      // Polling wait — compatible with selenium's Condition objects and plain functions.
+      // Used by dom.ts helpers for element location and visibility polling.
+      async wait(condition, timeout = 5e3) {
+        const fn = typeof condition === "function" ? condition : condition.fn;
+        const deadline = Date.now() + timeout;
+        let lastError;
+        while (Date.now() < deadline) {
+          try {
+            const result = await fn(this);
+            if (result) {
+              return result;
+            }
+          } catch (e) {
+            lastError = e instanceof Error ? e : new Error(String(e));
+          }
+          await new Promise((r) => setTimeout(r, 100));
+        }
+        throw lastError ?? new Error(`wait() timed out after ${timeout}ms`);
+      }
+      switchTo() {
+        return {
+          window: async (handle) => {
+            await this.cmd("POST", "/window", { handle });
+          },
+          newWindow: async (type) => {
+            return await this.cmd("POST", "/window/new", { type });
+          },
+          alert: async () => {
+            return {
+              accept: async () => {
+                await this.cmd("POST", "/alert/accept");
+              },
+              dismiss: async () => {
+                await this.cmd("POST", "/alert/dismiss");
+              },
+              getText: async () => {
+                return await this.cmd("GET", "/alert/text");
+              },
+              sendKeys: async (text) => {
+                await this.cmd("POST", "/alert/text", { text });
+              }
+            };
+          }
+        };
+      }
+      navigate() {
+        return {
+          back: async () => {
+            await this.cmd("POST", "/back");
+          },
+          forward: async () => {
+            await this.cmd("POST", "/forward");
+          },
+          refresh: async () => {
+            await this.cmd("POST", "/refresh");
+          }
+        };
+      }
+      manage() {
+        return {
+          window: () => {
+            return {
+              setRect: async (rect) => {
+                await this.cmd("POST", "/window/rect", rect);
+              }
+            };
+          }
+        };
+      }
+      actions(_opts) {
+        const actionSequences = [];
+        const builder = {
+          move: (opts) => {
+            actionSequences.push({
+              type: "pointer",
+              id: "mouse",
+              parameters: { pointerType: "mouse" },
+              actions: [{ type: "pointerMove", ...opts }]
+            });
+            return builder;
+          },
+          click: () => {
+            const last = actionSequences[actionSequences.length - 1];
+            if (last) {
+              last.actions.push({ type: "pointerDown", button: 0 }, { type: "pointerUp", button: 0 });
+            }
+            return builder;
+          },
+          doubleClick: (_el) => {
+            const last = actionSequences[actionSequences.length - 1];
+            if (last) {
+              last.actions.push(
+                { type: "pointerDown", button: 0 },
+                { type: "pointerUp", button: 0 },
+                { type: "pointerDown", button: 0 },
+                { type: "pointerUp", button: 0 }
+              );
+            }
+            return builder;
+          },
+          perform: async () => {
+            await this.cmd("POST", "/actions", { actions: actionSequences });
+          },
+          clear: async () => {
+            await this.cmd("DELETE", "/actions");
+          }
+        };
+        return builder;
+      }
+      async quit() {
+        try {
+          await this.cmd("DELETE", "");
+        } catch {
+        }
+        this.gdProcess.kill();
+      }
+      /** Kill the geckodriver process without closing Firefox */
+      kill() {
+        this.gdProcess.kill();
+      }
+    };
     FirefoxCore = class {
       constructor(options) {
         this.options = options;
@@ -22076,45 +22395,56 @@ var init_core3 = __esm({
       driver = null;
       currentContextId = null;
       /**
-       * Launch Firefox and establish BiDi connection
+       * Launch Firefox (or connect to an existing instance) and establish BiDi connection
        */
       async connect() {
-        log("\u{1F680} Launching Firefox via Selenium WebDriver BiDi...");
-        const firefoxOptions = new firefox.Options();
-        firefoxOptions.enableBidi();
-        if (this.options.headless) {
-          firefoxOptions.addArguments("-headless");
-        }
-        if (this.options.viewport) {
-          firefoxOptions.windowSize({
-            width: this.options.viewport.width,
-            height: this.options.viewport.height
-          });
-        }
-        if (this.options.firefoxPath) {
-          firefoxOptions.setBinary(this.options.firefoxPath);
-        }
-        if (this.options.args && this.options.args.length > 0) {
-          firefoxOptions.addArguments(...this.options.args);
-        }
-        if (this.options.profilePath) {
-          firefoxOptions.setProfile(this.options.profilePath);
+        if (this.options.connectExisting) {
+          log("\u{1F517} Connecting to existing Firefox via Marionette...");
+        } else {
+          log("\u{1F680} Launching Firefox via Selenium WebDriver BiDi...");
         }
-        if (this.options.acceptInsecureCerts) {
-          firefoxOptions.setAcceptInsecureCerts(true);
+        if (this.options.connectExisting) {
+          const port = this.options.marionettePort ?? 2828;
+          this.driver = await GeckodriverHttpDriver.connect(port);
+        } else {
+          const firefoxOptions = new firefox.Options();
+          firefoxOptions.enableBidi();
+          if (this.options.headless) {
+            firefoxOptions.addArguments("-headless");
+          }
+          if (this.options.viewport) {
+            firefoxOptions.windowSize({
+              width: this.options.viewport.width,
+              height: this.options.viewport.height
+            });
+          }
+          if (this.options.firefoxPath) {
+            firefoxOptions.setBinary(this.options.firefoxPath);
+          }
+          if (this.options.args && this.options.args.length > 0) {
+            firefoxOptions.addArguments(...this.options.args);
+          }
+          if (this.options.profilePath) {
+            firefoxOptions.setProfile(this.options.profilePath);
+          }
+          if (this.options.acceptInsecureCerts) {
+            firefoxOptions.setAcceptInsecureCerts(true);
+          }
+          this.driver = await new Builder().forBrowser(Browser.FIREFOX).setFirefoxOptions(firefoxOptions).build();
         }
-        this.driver = await new Builder().forBrowser(Browser.FIREFOX).setFirefoxOptions(firefoxOptions).build();
-        log("\u2705 Firefox launched with BiDi");
+        log(
+          this.options.connectExisting ? "\u2705 Connected to existing Firefox" : "\u2705 Firefox launched with BiDi"
+        );
         this.currentContextId = await this.driver.getWindowHandle();
         logDebug(`Browsing context ID: ${this.currentContextId}`);
-        if (this.options.startUrl) {
+        if (this.options.startUrl && !this.options.connectExisting) {
           await this.driver.get(this.options.startUrl);
           logDebug(`Navigated to: ${this.options.startUrl}`);
         }
         log("\u2705 Firefox DevTools ready");
       }
       /**
-       * Get WebDriver instance (throw if not connected)
+       * Get driver instance (throw if not connected)
        */
       getDriver() {
         if (!this.driver) {
@@ -22142,6 +22472,9 @@ var init_core3 = __esm({
        * Reset driver state (used when Firefox is detected as closed)
        */
       reset() {
+        if (this.driver && this.options.connectExisting && "kill" in this.driver) {
+          this.driver.kill();
+        }
         this.driver = null;
         this.currentContextId = null;
         logDebug("Driver state reset");
@@ -22159,11 +22492,17 @@ var init_core3 = __esm({
         this.currentContextId = contextId;
       }
       /**
-       * Close driver and cleanup
+       * Close driver and cleanup.
+       * When connected to an existing Firefox instance, only kills geckodriver
+       * without closing the browser.
        */
       async close() {
         if (this.driver) {
-          await this.driver.quit();
+          if (this.options.connectExisting && "kill" in this.driver) {
+            this.driver.kill();
+          } else if ("quit" in this.driver) {
+            await this.driver.quit();
+          }
           this.driver = null;
         }
         log("\u2705 Firefox DevTools closed");
@@ -22545,7 +22884,7 @@ var init_events = __esm({
 });
 
 // src/firefox/dom.ts
-import { By, Key, until } from "selenium-webdriver";
+import { Key } from "selenium-webdriver";
 var DomInteractions;
 var init_dom = __esm({
   "src/firefox/dom.ts"() {
@@ -22568,27 +22907,63 @@ var init_dom = __esm({
         const html = await this.evaluate("return document.documentElement.outerHTML");
         return String(html);
       }
+      // ============================================================================
+      // Element polling helpers (work with both WebDriver and GeckodriverHttpDriver)
+      // ============================================================================
+      /**
+       * Poll for an element matching a CSS selector until found or timeout.
+       */
+      async waitForElement(selector, timeout = 5e3) {
+        const deadline = Date.now() + timeout;
+        let lastError;
+        while (Date.now() < deadline) {
+          try {
+            return await this.driver.findElement({ using: "css selector", value: selector });
+          } catch (e) {
+            lastError = e instanceof Error ? e : new Error(String(e));
+          }
+          await new Promise((r) => setTimeout(r, 100));
+        }
+        throw lastError ?? new Error(`Element not found: ${selector}`);
+      }
+      /**
+       * Wait until an element reports isDisplayed(), ignoring failures.
+       */
+      async waitForVisible(el, timeout = 5e3) {
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+          try {
+            if (await el.isDisplayed()) {
+              return;
+            }
+          } catch {
+          }
+          await new Promise((r) => setTimeout(r, 100));
+        }
+      }
+      // ============================================================================
+      // Selector-based input methods
+      // ============================================================================
       /**
        * Click element by CSS selector
        */
       async clickBySelector(selector) {
-        const el = await this.driver.wait(until.elementLocated(By.css(selector)), 5e3);
-        await this.driver.wait(until.elementIsVisible(el), 5e3).catch(() => {
-        });
+        const el = await this.waitForElement(selector, 5e3);
+        await this.waitForVisible(el, 5e3);
         await el.click();
       }
       /**
        * Hover over element by CSS selector
        */
       async hoverBySelector(selector) {
-        const el = await this.driver.wait(until.elementLocated(By.css(selector)), 5e3);
+        const el = await this.waitForElement(selector, 5e3);
         await this.driver.actions({ async: true }).move({ origin: el }).perform();
       }
       /**
        * Fill input field by CSS selector
        */
       async fillBySelector(selector, text) {
-        const el = await this.driver.wait(until.elementLocated(By.css(selector)), 5e3);
+        const el = await this.waitForElement(selector, 5e3);
         try {
           await el.clear();
         } catch {
@@ -22602,27 +22977,22 @@ var init_dom = __esm({
        */
       async dragAndDropBySelectors(sourceSelector, targetSelector) {
         await this.driver.executeScript(
-          (srcSel, tgtSel) => {
-            const src = document.querySelector(srcSel);
-            const tgt = document.querySelector(tgtSel);
-            if (!src || !tgt) {
-              throw new Error("dragAndDrop: element not found");
-            }
-            function dispatch(type, target, dataTransfer) {
-              const evt = new DragEvent(type, {
-                bubbles: true,
-                cancelable: true,
-                dataTransfer
-              });
-              return target.dispatchEvent(evt);
-            }
-            const dt = typeof DataTransfer !== "undefined" ? new DataTransfer() : void 0;
-            dispatch("dragstart", src, dt);
-            dispatch("dragenter", tgt, dt);
-            dispatch("dragover", tgt, dt);
-            dispatch("drop", tgt, dt);
-            dispatch("dragend", src, dt);
-          },
+          `
+      var srcSel = arguments[0], tgtSel = arguments[1];
+      var src = document.querySelector(srcSel);
+      var tgt = document.querySelector(tgtSel);
+      if (!src || !tgt) throw new Error('dragAndDrop: element not found');
+      function dispatch(type, target, dt) {
+        var evt = new DragEvent(type, { bubbles: true, cancelable: true, dataTransfer: dt });
+        return target.dispatchEvent(evt);
+      }
+      var dt = typeof DataTransfer !== 'undefined' ? new DataTransfer() : undefined;
+      dispatch('dragstart', src, dt);
+      dispatch('dragenter', tgt, dt);
+      dispatch('dragover', tgt, dt);
+      dispatch('drop', tgt, dt);
+      dispatch('dragend', src, dt);
+    `,
           sourceSelector,
           targetSelector
         );
@@ -22631,27 +23001,24 @@ var init_dom = __esm({
        * File upload: unhide if needed, then send local path to <input type=file>.
        */
       async uploadFileBySelector(selector, filePath) {
-        const el = await this.driver.wait(until.elementLocated(By.css(selector)), 5e3);
-        await this.driver.executeScript((sel) => {
-          const e = document.querySelector(sel);
-          if (!e) {
-            throw new Error("uploadFile: element not found");
-          }
-          if (e.tagName !== "INPUT" || e.type !== "file") {
-            throw new Error("uploadFile: selector must target <input type=file>");
-          }
-          const style = window.getComputedStyle(e);
-          if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
-            const s = e.style;
-            s.display = "block";
-            s.visibility = "visible";
-            s.opacity = "1";
-            s.position = "fixed";
-            s.left = "0px";
-            s.top = "0px";
-            s.zIndex = "2147483647";
-          }
-        }, selector);
+        const el = await this.waitForElement(selector, 5e3);
+        await this.driver.executeScript(
+          `
+      var sel = arguments[0];
+      var e = document.querySelector(sel);
+      if (!e) throw new Error('uploadFile: element not found');
+      if (e.tagName !== 'INPUT' || e.type !== 'file')
+        throw new Error('uploadFile: selector must target <input type=file>');
+      var style = window.getComputedStyle(e);
+      if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
+        var s = e.style;
+        s.display = 'block'; s.visibility = 'visible'; s.opacity = '1';
+        s.position = 'fixed'; s.left = '0px'; s.top = '0px';
+        s.zIndex = '2147483647';
+      }
+    `,
+          selector
+        );
         await el.sendKeys(filePath);
       }
       // ============================================================================
@@ -22666,8 +23033,7 @@ var init_dom = __esm({
           throw new Error("clickByUid: resolveUid callback not set. Ensure snapshot is initialized.");
         }
         const el = await this.resolveUid(uid);
-        await this.driver.wait(until.elementIsVisible(el), 5e3).catch(() => {
-        });
+        await this.waitForVisible(el, 5e3);
         if (dblClick) {
           await this.driver.actions({ async: true }).doubleClick(el).perform();
         } else {
@@ -22715,25 +23081,20 @@ var init_dom = __esm({
         const fromEl = await this.resolveUid(fromUid);
         const toEl = await this.resolveUid(toUid);
         await this.driver.executeScript(
-          (srcEl, tgtEl) => {
-            if (!srcEl || !tgtEl) {
-              throw new Error("dragAndDrop: element not found");
-            }
-            function dispatch(type, target, dataTransfer) {
-              const evt = new DragEvent(type, {
-                bubbles: true,
-                cancelable: true,
-                dataTransfer
-              });
-              return target.dispatchEvent(evt);
-            }
-            const dt = typeof DataTransfer !== "undefined" ? new DataTransfer() : void 0;
-            dispatch("dragstart", srcEl, dt);
-            dispatch("dragenter", tgtEl, dt);
-            dispatch("dragover", tgtEl, dt);
-            dispatch("drop", tgtEl, dt);
-            dispatch("dragend", srcEl, dt);
-          },
+          `
+      var srcEl = arguments[0], tgtEl = arguments[1];
+      if (!srcEl || !tgtEl) throw new Error('dragAndDrop: element not found');
+      function dispatch(type, target, dt) {
+        var evt = new DragEvent(type, { bubbles: true, cancelable: true, dataTransfer: dt });
+        return target.dispatchEvent(evt);
+      }
+      var dt = typeof DataTransfer !== 'undefined' ? new DataTransfer() : undefined;
+      dispatch('dragstart', srcEl, dt);
+      dispatch('dragenter', tgtEl, dt);
+      dispatch('dragover', tgtEl, dt);
+      dispatch('drop', tgtEl, dt);
+      dispatch('dragend', srcEl, dt);
+    `,
           fromEl,
           toEl
         );
@@ -22763,25 +23124,22 @@ var init_dom = __esm({
           );
         }
         const el = await this.resolveUid(uid);
-        await this.driver.executeScript((element) => {
-          if (!element) {
-            throw new Error("uploadFile: element not found");
-          }
-          if (element.tagName !== "INPUT" || element.type !== "file") {
-            throw new Error("uploadFile: element must be <input type=file>");
-          }
-          const style = window.getComputedStyle(element);
-          if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
-            const s = element.style;
-            s.display = "block";
-            s.visibility = "visible";
-            s.opacity = "1";
-            s.position = "fixed";
-            s.left = "0px";
-            s.top = "0px";
-            s.zIndex = "2147483647";
-          }
-        }, el);
+        await this.driver.executeScript(
+          `
+      var element = arguments[0];
+      if (!element) throw new Error('uploadFile: element not found');
+      if (element.tagName !== 'INPUT' || element.type !== 'file')
+        throw new Error('uploadFile: element must be <input type=file>');
+      var style = window.getComputedStyle(element);
+      if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
+        var s = element.style;
+        s.display = 'block'; s.visibility = 'visible'; s.opacity = '1';
+        s.position = 'fixed'; s.left = '0px'; s.top = '0px';
+        s.zIndex = '2147483647';
+      }
+    `,
+          el
+        );
         await el.sendKeys(filePath);
         await this.waitForEventsAfterAction();
       }
@@ -23105,7 +23463,6 @@ var init_formatter = __esm({
 });
 
 // src/firefox/snapshot/resolver.ts
-import { By as By2 } from "selenium-webdriver";
 var UidResolver;
 var init_resolver = __esm({
   "src/firefox/snapshot/resolver.ts"() {
@@ -23177,7 +23534,7 @@ var init_resolver = __esm({
         return entry.css;
       }
       /**
-       * Resolve UID to WebElement (with staleness check and caching)
+       * Resolve UID to element (with staleness check and caching)
        * Tries CSS first, falls back to XPath
        */
       async resolveUidToElement(uid) {
@@ -23192,12 +23549,12 @@ var init_resolver = __esm({
             await cached2.cachedElement.isDisplayed();
             logDebug(`Using cached element for UID: ${uid}`);
             return cached2.cachedElement;
-          } catch (e) {
+          } catch {
             logDebug(`Cached element stale for UID: ${uid}, re-finding...`);
           }
         }
         try {
-          const element = await this.driver.findElement(By2.css(entry.css));
+          const element = await this.driver.findElement({ using: "css selector", value: entry.css });
           this.elementCache.set(uid, {
             selector: entry.css,
             ...entry.xpath && { xpath: entry.xpath },
@@ -23207,12 +23564,12 @@ var init_resolver = __esm({
           });
           logDebug(`Found element by CSS for UID: ${uid}`);
           return element;
-        } catch (cssError) {
+        } catch {
           logDebug(`CSS selector failed for UID: ${uid}, trying XPath fallback...`);
           const xpathSelector = entry.xpath;
           if (xpathSelector) {
             try {
-              const element = await this.driver.findElement(By2.xpath(xpathSelector));
+              const element = await this.driver.findElement({ using: "xpath", value: xpathSelector });
               this.elementCache.set(uid, {
                 selector: entry.css,
                 ...xpathSelector && { xpath: xpathSelector },
@@ -23222,7 +23579,7 @@ var init_resolver = __esm({
               });
               logDebug(`Found element by XPath for UID: ${uid}`);
               return element;
-            } catch (xpathError) {
+            } catch {
               throw new Error(
                 `Element not found for UID: ${uid}. The element may have changed. Take a fresh snapshot.`
               );
@@ -23431,14 +23788,17 @@ var init_firefox = __esm({
             this.snapshot.clear();
           }
         };
-        this.consoleEvents = new ConsoleEvents(driver, {
-          onNavigate,
-          autoClearOnNavigate: false
-        });
-        this.networkEvents = new NetworkEvents(driver, {
-          onNavigate,
-          autoClearOnNavigate: false
-        });
+        const hasBidi = "getBidi" in driver && typeof driver.getBidi === "function";
+        if (hasBidi) {
+          this.consoleEvents = new ConsoleEvents(driver, {
+            onNavigate,
+            autoClearOnNavigate: false
+          });
+          this.networkEvents = new NetworkEvents(driver, {
+            onNavigate,
+            autoClearOnNavigate: false
+          });
+        }
         this.dom = new DomInteractions(
           driver,
           (uid) => this.snapshot.resolveUidToElement(uid)
@@ -23448,8 +23808,12 @@ var init_firefox = __esm({
           () => this.core.getCurrentContextId(),
           (id) => this.core.setCurrentContextId(id)
         );
-        await this.consoleEvents.subscribe(void 0);
-        await this.networkEvents.subscribe(void 0);
+        if (this.consoleEvents) {
+          await this.consoleEvents.subscribe(void 0);
+        }
+        if (this.networkEvents) {
+          await this.networkEvents.subscribe(void 0);
+        }
       }
       // ============================================================================
       // DOM / Evaluate
@@ -23538,13 +23902,13 @@ var init_firefox = __esm({
       // ============================================================================
       async getConsoleMessages() {
         if (!this.consoleEvents) {
-          throw new Error("Not connected");
+          throw new Error("Console events not available in connect-existing mode (requires BiDi)");
         }
         return this.consoleEvents.getMessages();
       }
       clearConsoleMessages() {
         if (!this.consoleEvents) {
-          throw new Error("Not connected");
+          throw new Error("Console events not available in connect-existing mode (requires BiDi)");
         }
         this.consoleEvents.clearMessages();
       }
@@ -23629,25 +23993,25 @@ var init_firefox = __esm({
       // ============================================================================
       async startNetworkMonitoring() {
         if (!this.networkEvents) {
-          throw new Error("Not connected");
+          throw new Error("Network events not available in connect-existing mode (requires BiDi)");
         }
         this.networkEvents.startMonitoring();
       }
       async stopNetworkMonitoring() {
         if (!this.networkEvents) {
-          throw new Error("Not connected");
+          throw new Error("Network events not available in connect-existing mode (requires BiDi)");
         }
         this.networkEvents.stopMonitoring();
       }
       async getNetworkRequests() {
         if (!this.networkEvents) {
-          throw new Error("Not connected");
+          throw new Error("Network events not available in connect-existing mode (requires BiDi)");
         }
         return this.networkEvents.getRequests();
       }
       clearNetworkRequests() {
         if (!this.networkEvents) {
-          throw new Error("Not connected");
+          throw new Error("Network events not available in connect-existing mode (requires BiDi)");
         }
         this.networkEvents.clearRequests();
       }
@@ -25647,7 +26011,9 @@ async function getFirefox() {
     viewport: args.viewport ?? void 0,
     args: args.firefoxArg ?? void 0,
     startUrl: args.startUrl ?? void 0,
-    acceptInsecureCerts: args.acceptInsecureCerts
+    acceptInsecureCerts: args.acceptInsecureCerts,
+    connectExisting: args.connectExisting,
+    marionettePort: args.marionettePort
   };
   firefox2 = new FirefoxClient(options);
   await firefox2.connect();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firefox-devtools-mcp",
-  "version": "0.7.4",
+  "version": "0.8.1",
   "description": "Model Context Protocol (MCP) server for Firefox DevTools automation",
   "author": "freema",
   "license": "MIT",