machine-bridge-mcp 2.0.0 → 3.0.0-beta.102

package/browser-extension/broker-auth.js

@@ -0,0 +1,83 @@
+(() => {
+  const TOKEN = /^[A-Za-z0-9_-]{32,100}$/;
+  const NONCE = /^[A-Za-z0-9_-]{32}$/;
+  const PROOF = /^[A-Za-z0-9_-]{43}$/;
+  const BROKER_AUTH_REQUEST_HEADER = "x-machine-bridge-broker-auth";
+  const BROKER_AUTH_REQUEST_VALUE = "machine-bridge-browser-v2";
+
+  async function extensionProtocol(endpoint, token) {
+    if (!TOKEN.test(String(token || ""))) throw new Error("browser pairing token is invalid");
+    const parsed = parseEndpoint(endpoint);
+    if (!parsed) throw new Error("browser broker endpoint is invalid");
+    const clientChallenge = randomBase64Url(24);
+    const authUrl = new URL(endpoint);
+    authUrl.protocol = "http:";
+    authUrl.pathname = "/extension-auth";
+    const initProof = await hmac(token, `machine-bridge-browser-extension-init-v2\0${clientChallenge}`);
+    authUrl.search = `?challenge=${encodeURIComponent(clientChallenge)}&init=${encodeURIComponent(initProof)}`;
+    const response = await brokerFetch(authUrl, "GET");
+    if (response.status !== 204) throw new Error("browser broker authentication failed");
+    const serverNonce = String(response.headers.get("x-machine-bridge-broker-nonce") || "");
+    const serverProof = String(response.headers.get("x-machine-bridge-broker-proof") || "");
+    if (!NONCE.test(serverNonce) || !PROOF.test(serverProof)) throw new Error("browser broker authentication failed");
+    const expected = await hmac(token, `machine-bridge-browser-extension-server-v2\0${clientChallenge}\0${serverNonce}`);
+    if (!fixedEqual(expected, serverProof)) throw new Error("browser broker authentication failed");
+    const clientProof = await hmac(token, `machine-bridge-browser-extension-client-v2\0${clientChallenge}\0${serverNonce}`);
+    return `mbm-extension-v2.${clientChallenge}.${serverNonce}.${clientProof}`;
+  }
+
+  function parseEndpoint(value) {
+    let parsed;
+    try { parsed = new URL(String(value || "")); } catch { return null; }
+    const port = Number(parsed.port);
+    if (parsed.protocol !== "ws:" || parsed.hostname !== "127.0.0.1" || parsed.pathname !== "/extension"
+        || parsed.username || parsed.password || parsed.search || parsed.hash
+        || !Number.isInteger(port) || port < 1024 || port > 65535) return null;
+    return parsed;
+  }
+  function pairingUrlFromEndpoint(endpoint) {
+    const parsed = parseEndpoint(endpoint);
+    return parsed ? `http://127.0.0.1:${parsed.port}/pair` : "";
+  }
+  function parsePairingPage(value) {
+    let parsed;
+    try { parsed = new URL(String(value || "")); } catch { return null; }
+    const port = Number(parsed.port);
+    if (parsed.protocol !== "http:" || parsed.hostname !== "127.0.0.1" || parsed.pathname !== "/pair"
+        || parsed.username || parsed.password || parsed.search || parsed.hash
+        || !Number.isInteger(port) || port < 1024 || port > 65535) return null;
+    return parsed;
+  }
+  async function brokerFetch(url, method) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    try {
+      return await fetch(url, {
+        method, redirect: "error", cache: "no-store", signal: controller.signal,
+        headers: { [BROKER_AUTH_REQUEST_HEADER]: BROKER_AUTH_REQUEST_VALUE },
+      });
+    } finally { clearTimeout(timer); }
+  }
+  async function hmac(token, message) {
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(token), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    return base64Url(new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(message))));
+  }
+  function randomBase64Url(size) {
+    const bytes = new Uint8Array(size); crypto.getRandomValues(bytes); return base64Url(bytes);
+  }
+  function base64Url(bytes) {
+    let binary = ""; for (const value of bytes) binary += String.fromCharCode(value);
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  }
+  function fixedEqual(left, right) {
+    if (left.length !== right.length) return false;
+    let difference = 0;
+    for (let index = 0; index < left.length; index += 1) difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+    return difference === 0;
+  }
+
+  globalThis.__machineBridgeBrokerAuth = Object.freeze({
+    extensionProtocol, pairingUrlFromEndpoint, parseBrokerEndpoint: parseEndpoint, parsePairingPage,
+    internal: Object.freeze({ brokerFetch, fixedEqual, hmac, randomBase64Url, tokenPattern: TOKEN, noncePattern: NONCE, proofPattern: PROOF }),
+  });
+})();

package/browser-extension/broker-liveness.js

@@ -0,0 +1,35 @@
+globalThis.__machineBridgeBrokerLiveness = (() => {
+  const PONG_TIMEOUT_MS = 10000;
+  function initialize(socket) {
+    socket.pongTimer = null;
+    socket.pongWatchdog = false;
+    socket.pingSequence = 0;
+  }
+  function clear(socket) {
+    clearTimeout(socket?.pongTimer);
+    if (socket) socket.pongTimer = null;
+  }
+  function negotiate(socket, enabled) { socket.pongWatchdog = enabled === true; }
+  function keepalive(socket, current, send, close) {
+    if (!current || !socket.bridgeReady || socket.readyState !== WebSocket.OPEN) return;
+    const seq = socket.pongWatchdog ? ++socket.pingSequence : 0;
+    if (!send(socket, JSON.stringify({ type: "ping", ...(seq ? { seq } : {}) }))) {
+      close(socket, 1011, "browser extension keepalive failed");
+      return;
+    }
+    if (!seq) return;
+    clear(socket);
+    socket.pongTimer = setTimeout(() => {
+      if (socket.bridgeReady && socket.pingSequence === seq) close(socket, 1012, "browser broker pong timed out");
+    }, PONG_TIMEOUT_MS);
+  }
+  function handlePong(socket, message, close) {
+    if (!socket.pongWatchdog) return;
+    if (!Number.isSafeInteger(message.seq) || message.seq !== socket.pingSequence) {
+      close(socket, 1002, "invalid browser broker pong");
+      return;
+    }
+    clear(socket);
+  }
+  return Object.freeze({ initialize, clear, negotiate, keepalive, handlePong });
+})();

package/browser-extension/browser-error-boundary.js

@@ -0,0 +1,96 @@
+(() => {
+  const SAFE_EXACT = new Set([
+    "unsupported browser tab action",
+    "no active browser tab",
+    "navigate requires url",
+    "trusted input is unavailable for this action",
+    "trusted input currently requires the top frame; use input_mode=dom for a subframe",
+    "this page cannot be scripted by a browser extension",
+    "page automation module is unavailable",
+    "page automation module version mismatch",
+    "browser request cancelled",
+    "snapshot browser tab changed before navigation dispatch; observe again",
+    "snapshot browser tab could not be verified before navigation dispatch; observe again",
+    "snapshot history document changed before dispatch; observe again",
+    "snapshot history document could not be verified before dispatch; observe again",
+    "snapshot history entry changed before dispatch; observe again",
+    "snapshot history entry could not be verified before dispatch; observe again",
+    "snapshot browser history has no back entry before dispatch; observe again",
+    "snapshot browser history has no forward entry before dispatch; observe again",
+    "snapshot history mutation API is unavailable before dispatch; observe again",
+    "browser tab activation completed but its current window is unavailable before focus; inspect tabs before retrying",
+    "browser tab activation completed but the target tab could not be verified before focus; inspect tabs before retrying",
+    "browser tab activation completed but the target tab was no longer active before focus; inspect tabs before retrying",
+    "browser tab activation and window focus completed but the target tab could not be verified; inspect tabs before retrying",
+    "browser tab activation and window focus completed but the target tab moved windows; inspect tabs before retrying",
+    "browser tab activation and window focus completed but the target tab was no longer active; inspect tabs before retrying",
+    "tab closed during navigation wait",
+    "element reference is stale; inspect the page again",
+    "element did not become geometrically stable before timeout",
+    "matched element is not a file input",
+    "no form or submit control found",
+    "matched element is not associated with a form",
+    "select option was not found",
+    "trusted input requires a valid tab",
+    "trusted input target has no usable viewport point",
+    "browser screenshot cannot safely switch tabs without a restore baseline",
+    "browser screenshot could not revalidate the active tab before temporary activation",
+    "browser screenshot active tab changed before temporary activation",
+    "browser screenshot could not verify target tab at capture boundary",
+    "browser screenshot target tab was not active at capture boundary",
+    "browser screenshot could not verify the active tab after capture",
+    "browser screenshot active tab changed during capture",
+    "browser screenshot could not verify active-tab restoration",
+    "browser screenshot could not restore the previous active tab",
+    "browser tab became unavailable during computer observation",
+  ]);
+
+  function publicError(error) {
+    const message = String(error?.message || error || "");
+    if (message.startsWith("unknown browser method:")) return "unknown browser method";
+    if (message.startsWith("invalid CSS selector:")) return "invalid CSS selector";
+    if (/^selector matched \d+ elements;/.test(message)) return "selector matched multiple elements; use ref or index to disambiguate";
+    if (message.startsWith("browser wait timed out")) return "browser wait timed out";
+    if (message.startsWith("trusted browser input may have been partially dispatched")) {
+      return "trusted browser input may have been partially dispatched; the action outcome is unknown. Inspect the page before retrying.";
+    }
+    if (message.startsWith("browser action may have been dispatched; the action outcome is unknown")) {
+      return "browser action may have been dispatched; the action outcome is unknown. Inspect the page before retrying.";
+    }
+    if (message.startsWith("browser tab mutation may have been dispatched; the outcome is unknown")) {
+      return "browser tab mutation may have been dispatched; the outcome is unknown. Inspect tabs before retrying.";
+    }
+    if (message.startsWith("browser screenshot temporary tab activation may have been dispatched; the outcome is unknown")) {
+      return "browser screenshot temporary tab activation may have been dispatched; the outcome is unknown. Inspect tabs before retrying.";
+    }
+    if (message.startsWith("browser screenshot restoration may have been dispatched; the active-tab outcome is unknown")) {
+      return "browser screenshot restoration may have been dispatched; the active-tab outcome is unknown. Inspect tabs before retrying.";
+    }
+    if (message.startsWith("trusted browser input unavailable: visual_snapshot_changed_before_dispatch")) {
+      return "visual snapshot changed before trusted input; observe again";
+    }
+    if (message.startsWith("snapshot_backend_target_changed_before_dispatch")) {
+      return "snapshot backend target changed before trusted input; observe again";
+    }
+    if (message.startsWith("snapshot_ref_identity_changed_before_dispatch")) {
+      return "snapshot ref identity changed before dispatch; observe again";
+    }
+    if (message.startsWith("snapshot_backend_geometry_unavailable_before_dispatch")
+        || message.startsWith("snapshot_backend_trusted_input_unavailable_before_dispatch")) {
+      return "snapshot backend trusted input unavailable before dispatch";
+    }
+    if (message.startsWith("form submission failed after")) {
+      return "form submission failed after partial changes; inspect the page before retrying";
+    }
+    if (message.startsWith("element was not actionable before timeout")) return "element was not actionable before timeout";
+    if (message.startsWith("element was not clickable before timeout")) return "element was not clickable before timeout";
+    if (message.startsWith("unsupported element action:")) return "unsupported element action";
+    if (message.startsWith("unsupported key modifier:") || message.startsWith("unsupported key:")) return "unsupported keyboard input";
+    return SAFE_EXACT.has(message) ? message : "browser operation failed";
+  }
+
+  Object.defineProperty(globalThis, "__machineBridgeBrowserErrorBoundary", {
+    value: Object.freeze({ publicError }),
+    configurable: false,
+  });
+})();