@mehmoodqureshi/chrome-mcp 0.9.10 → 0.9.12

package/dist/shared/fill-form.d.ts

@@ -29,6 +29,14 @@ export interface FillFormHooks {
         code: FillFormError['code'];
         message: string;
     };
+    /**
+     * Epoch ms after which no further field is started — the moment the server
+     * stops waiting for this command. Without it a timed-out batch kept typing
+     * into the page after the caller had already been told it failed.
+     */
+    deadline?: number;
+    /** Clock, injectable for tests. */
+    now?: () => number;
 }
 type FillFormError = NonNullable<FillFormWireResult['error']>;
 /**

package/dist/shared/fill-form.js

@@ -27,7 +27,16 @@ const policy_1 = require("./policy");
  */
 async function runFillFields(ops, hooks) {
     const res = { filled: 0 };
+    const now = hooks.now ?? Date.now;
     for (const op of ops) {
+        if (hooks.deadline !== undefined && now() >= hooks.deadline) {
+            res.error = {
+                selector: op.selector,
+                code: 'TIMEOUT',
+                message: `fill_form ran out of time after ${res.filled} of ${ops.length} fields; the rest were not written`,
+            };
+            return res;
+        }
         try {
             // Fails CLOSED, exactly as the router does: no policy means nothing runs.
             const policy = hooks.policy();

package/dist/shared/protocol.d.ts

@@ -52,6 +52,19 @@ export interface FillFieldOp {
     /** A string is value-set (cleared first); a boolean toggles via a click. */
     value: string | boolean;
 }
+/** Floor for a batched `fill_form` — the old flat budget, so small forms keep it. */
+export declare const FILL_FORM_MIN_TIMEOUT_MS = 60000;
+/** Per-field allowance: the extension's 5 s element wait plus headroom for the write. */
+export declare const FILL_FORM_PER_FIELD_MS = 6000;
+/** Ceiling, so a runaway field count can't hold the tab for longer than this. */
+export declare const FILL_FORM_MAX_TIMEOUT_MS = 600000;
+/**
+ * Wire timeout for a `fill_form` of `fields` fields. One flat 60 s used to cover
+ * the whole batch, so a long form whose fields each waited for their element
+ * timed out server-side while the extension was still typing. The budget now
+ * grows with the field count (10 s base + 6 s per field), clamped to 60 s..10 min.
+ */
+export declare function fillFormTimeoutMs(fields: number): number;
 /**
  * `fill_form` result. Ops run in order and stop at the first failure, so
  * `filled` counts the fields that landed and `error` names the one that did not.

package/dist/shared/protocol.js

@@ -15,7 +15,8 @@
  * in one round-trip; capability-gated, see `WIRE_CAP_FILL_FORM`).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WIRE_METHODS = exports.WIRE_CAP_FILL_FORM = exports.WIRE_CAP_TAB_URL = exports.CLOSE_SUPERSEDED = exports.CLOSE_UNAUTHORIZED = exports.BRIDGE_HOST = exports.DEFAULT_WS_PORT = exports.PROTOCOL_VERSION = void 0;
+exports.WIRE_METHODS = exports.FILL_FORM_MAX_TIMEOUT_MS = exports.FILL_FORM_PER_FIELD_MS = exports.FILL_FORM_MIN_TIMEOUT_MS = exports.WIRE_CAP_FILL_FORM = exports.WIRE_CAP_TAB_URL = exports.CLOSE_SUPERSEDED = exports.CLOSE_UNAUTHORIZED = exports.BRIDGE_HOST = exports.DEFAULT_WS_PORT = exports.PROTOCOL_VERSION = void 0;
+exports.fillFormTimeoutMs = fillFormTimeoutMs;
 /** Bumped on any breaking change to the frames below. */
 exports.PROTOCOL_VERSION = 1;
 /**
@@ -48,6 +49,22 @@ exports.WIRE_CAP_TAB_URL = 'tab-url';
  * field over `type`/`click`, which every extension build understands.
  */
 exports.WIRE_CAP_FILL_FORM = 'fill-form';
+/** Floor for a batched `fill_form` — the old flat budget, so small forms keep it. */
+exports.FILL_FORM_MIN_TIMEOUT_MS = 60_000;
+/** Per-field allowance: the extension's 5 s element wait plus headroom for the write. */
+exports.FILL_FORM_PER_FIELD_MS = 6_000;
+/** Ceiling, so a runaway field count can't hold the tab for longer than this. */
+exports.FILL_FORM_MAX_TIMEOUT_MS = 600_000;
+/**
+ * Wire timeout for a `fill_form` of `fields` fields. One flat 60 s used to cover
+ * the whole batch, so a long form whose fields each waited for their element
+ * timed out server-side while the extension was still typing. The budget now
+ * grows with the field count (10 s base + 6 s per field), clamped to 60 s..10 min.
+ */
+function fillFormTimeoutMs(fields) {
+    const n = Number.isFinite(fields) && fields > 0 ? Math.floor(fields) : 0;
+    return Math.min(exports.FILL_FORM_MAX_TIMEOUT_MS, Math.max(exports.FILL_FORM_MIN_TIMEOUT_MS, 10_000 + n * exports.FILL_FORM_PER_FIELD_MS));
+}
 /** Runtime list of every WireMethod, for boot-time drift assertions on both ends. */
 exports.WIRE_METHODS = [
     'tabs_list',

package/dist/src/bridge/auth.d.ts

@@ -56,6 +56,18 @@ export declare const BUNDLED_PAIRING_FILE = "pairing.json";
  * still works without it.
  */
 export declare function writeBundledPairing(extDir: string, fields: WriteHandshakeFields): string | null;
+/** The port an existing `<extDir>/pairing.json` points at, or null when absent/unreadable. */
+export declare function readBundledPairingPort(extDir: string): number | null;
+/** True when something is accepting TCP connections on 127.0.0.1:`port`. */
+export declare function portIsListening(port: number, timeoutMs?: number): Promise<boolean>;
+/**
+ * Should a hub on `port` leave `<extDir>/pairing.json` alone? Yes when the file
+ * already points the extension at a DIFFERENT port that is still live: another
+ * chrome-mcp (e.g. one started with its own CHROME_MCP_DATA / --ws-port) owns
+ * that pairing, and overwriting it would silently steal the user's extension.
+ * A file naming our own port, a dead port, or no file at all is fair game.
+ */
+export declare function bundledPairingHeldByOther(extDir: string, port: number): Promise<boolean>;
 /**
  * Atomically write the handshake at 0600 and verify the mode. Throws (fail
  * closed) if the file ends up group/other-readable — the token is the entire

package/dist/src/bridge/auth.js

@@ -22,6 +22,9 @@ exports.writePersistedToken = writePersistedToken;
 exports.resolveToken = resolveToken;
 exports.tokensMatch = tokensMatch;
 exports.writeBundledPairing = writeBundledPairing;
+exports.readBundledPairingPort = readBundledPairingPort;
+exports.portIsListening = portIsListening;
+exports.bundledPairingHeldByOther = bundledPairingHeldByOther;
 exports.writeHandshake = writeHandshake;
 exports.readHandshake = readHandshake;
 exports.removeHandshake = removeHandshake;
@@ -29,6 +32,7 @@ exports.redactToken = redactToken;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_crypto_1 = require("node:crypto");
+const node_net_1 = require("node:net");
 const protocol_1 = require("../../shared/protocol");
 const datadir_1 = require("./datadir");
 /** A fresh 256-bit token, base64url. Generated once per server boot. */
@@ -146,6 +150,42 @@ function writeBundledPairing(extDir, fields) {
         return null;
     }
 }
+/** The port an existing `<extDir>/pairing.json` points at, or null when absent/unreadable. */
+function readBundledPairingPort(extDir) {
+    try {
+        const raw = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(extDir, exports.BUNDLED_PAIRING_FILE), 'utf8'));
+        return typeof raw.port === 'number' && Number.isInteger(raw.port) && raw.port > 0 ? raw.port : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when something is accepting TCP connections on 127.0.0.1:`port`. */
+function portIsListening(port, timeoutMs = 500) {
+    return new Promise((resolve) => {
+        const sock = (0, node_net_1.connect)({ host: '127.0.0.1', port });
+        const done = (live) => {
+            sock.destroy();
+            resolve(live);
+        };
+        sock.setTimeout(timeoutMs, () => done(false));
+        sock.once('connect', () => done(true));
+        sock.once('error', () => done(false));
+    });
+}
+/**
+ * Should a hub on `port` leave `<extDir>/pairing.json` alone? Yes when the file
+ * already points the extension at a DIFFERENT port that is still live: another
+ * chrome-mcp (e.g. one started with its own CHROME_MCP_DATA / --ws-port) owns
+ * that pairing, and overwriting it would silently steal the user's extension.
+ * A file naming our own port, a dead port, or no file at all is fair game.
+ */
+async function bundledPairingHeldByOther(extDir, port) {
+    const current = readBundledPairingPort(extDir);
+    if (current === null || current === port)
+        return false;
+    return portIsListening(current);
+}
 /**
  * Atomically write the handshake at 0600 and verify the mode. Throws (fail
  * closed) if the file ends up group/other-readable — the token is the entire

package/dist/src/cli.js

@@ -223,12 +223,22 @@ async function main() {
         },
     });
     const publishPairing = (port, pairToken) => {
+        // Synchronous so a handshake that can't be made private still fails closed.
         const path = (0, auth_1.writeHandshake)(dataDir, { port, token: pairToken });
         (0, server_2.logErr)(`pairing handshake written to ${path} (mode 0600; token not logged)`);
+        publishBundledPairing(port, pairToken).catch((err) => (0, server_2.logDebug)(`auto-pairing file not written: ${err instanceof Error ? err.message : String(err)}`));
+    };
+    const publishBundledPairing = async (port, pairToken) => {
         // Drop the same port + token into the bundled extension folder so a Load
         // unpacked from there pairs itself. Best-effort: a read-only install just
-        // falls back to the Options-page paste.
+        // falls back to the Options-page paste. Never take over a pairing file that
+        // a different, still-running chrome-mcp published (a second server with its
+        // own data dir or port would otherwise re-point the user's extension).
         const extDir = installExtension();
+        if (await (0, auth_1.bundledPairingHeldByOther)(extDir, port)) {
+            (0, server_2.logErr)(`auto-pairing file at ${extDir} belongs to another running chrome-mcp — left as is; pair this server from the extension Options page if you want it`);
+            return;
+        }
         const bundled = (0, auth_1.writeBundledPairing)(extDir, { port, token: pairToken });
         if (bundled) {
             (0, server_2.logErr)(`auto-pairing file written to ${bundled} — Load unpacked from ${extDir} needs no token paste`);
@@ -238,8 +248,10 @@ async function main() {
         }
         // Anyone who loaded the extension straight from the package folder (0.8.0
         // docs) keeps pairing too.
-        if (extDir !== (0, extension_install_1.bundledExtensionDir)())
-            (0, auth_1.writeBundledPairing)((0, extension_install_1.bundledExtensionDir)(), { port, token: pairToken });
+        const pkgDir = (0, extension_install_1.bundledExtensionDir)();
+        if (extDir !== pkgDir && !(await (0, auth_1.bundledPairingHeldByOther)(pkgDir, port))) {
+            (0, auth_1.writeBundledPairing)(pkgDir, { port, token: pairToken });
+        }
     };
     const port = await bridge.start();
     (0, tools_1.setProfileBridge)(bridge);

package/dist/src/executor/extension-executor.js

@@ -149,7 +149,7 @@ class ExtensionExecutor {
         // An extension that predates the op never advertised it: let the caller go field by field.
         if (!this.bridge.hasCap(this.activeProfile(), protocol_1.WIRE_CAP_FILL_FORM))
             return null;
-        const res = (await this.send('fill_form', { ops: fields, ...frameParams(opts) }, { tabId: opts?.tabId }));
+        const res = (await this.send('fill_form', { ops: fields, ...frameParams(opts) }, { tabId: opts?.tabId, timeoutMs: (0, protocol_1.fillFormTimeoutMs)(fields.length) }));
         if (res.error) {
             // Say how far the batch got: the fields before this one DID land, and a
             // blind retry of the whole form would write them a second time.

package/extension-dist/background.js

@@ -242,7 +242,16 @@
   // shared/fill-form.ts
   async function runFillFields(ops, hooks) {
     const res = { filled: 0 };
+    const now = hooks.now ?? Date.now;
     for (const op of ops) {
+      if (hooks.deadline !== void 0 && now() >= hooks.deadline) {
+        res.error = {
+          selector: op.selector,
+          code: "TIMEOUT",
+          message: `fill_form ran out of time after ${res.filled} of ${ops.length} fields; the rest were not written`
+        };
+        return res;
+      }
       try {
         const policy = hooks.policy();
         if (!policy) throw new PolicyStop("no policy is in force; refusing to fill");
@@ -1527,7 +1536,9 @@
             selector: String(f.selector ?? ""),
             value: typeof f.value === "boolean" ? f.value : String(f.value ?? "")
           }));
+          const deadline = typeof cmd.timeoutMs === "number" && cmd.timeoutMs > 0 ? Date.now() + cmd.timeoutMs - 1e3 : void 0;
           return runFillFields(ops, {
+            deadline,
             currentUrl: () => observedTabUrl(cmd, id),
             policy: () => this.getPolicy(),
             // Frame ids are re-probed per field too: an iframe that navigates

package/extension-dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "MCP Extension for Chrome",
-  "version": "0.9.8",
+  "version": "0.9.12",
   "description": "Lets a local chrome-mcp server drive this browser. Pair it with the server's handshake token.",
   "homepage_url": "https://chrome-mcp-omega.vercel.app",
   "minimum_chrome_version": "116",

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@mehmoodqureshi/chrome-mcp",
-  "version": "0.9.10",
+  "mcpName": "io.github.Mehmoodqureshi/chrome-mcp",
+  "version": "0.9.12",
   "description": "Drive your real Chrome browser over MCP — real logins, real cookies. A stdio MCP server (CLI) plus an MV3 extension, driving Chrome via chrome.scripting/chrome.tabs. Multi-tab batch automation, accessibility snapshots, deny-all security by default.",
   "author": "Mehmood Ur Rehman Qureshi",
   "license": "MIT",