@mehmoodqureshi/chrome-mcp 0.6.7 → 0.7.0

package/extension-dist/page-hook.js

@@ -0,0 +1,215 @@
+"use strict";
+(() => {
+  // shared/observers.ts
+  var OBSERVER_HOOK_VERSION = 1;
+  var OBSERVER_GLOBAL = "__chromeMcpObservers";
+  var MAX_CONSOLE_ENTRIES = 500;
+  var MAX_NETWORK_ENTRIES = 300;
+  var MAX_DIALOG_ENTRIES = 50;
+
+  // extension/src/page/hook.ts
+  (function install() {
+    try {
+      const w = window;
+      if (w[OBSERVER_GLOBAL]) return;
+      const state = {
+        v: OBSERVER_HOOK_VERSION,
+        seq: 0,
+        console: [],
+        network: [],
+        dialogs: [],
+        dialogPolicy: "dismiss",
+        promptText: "",
+        dropped: false,
+        resourceCursor: 0
+      };
+      Object.defineProperty(w, OBSERVER_GLOBAL, { value: state, writable: true, enumerable: false, configurable: true });
+      const push = (buf, entry, max) => {
+        buf.push(entry);
+        if (buf.length > max) {
+          buf.splice(0, buf.length - max);
+          state.dropped = true;
+        }
+      };
+      const render = (value, depth = 0) => {
+        try {
+          if (value === null) return "null";
+          if (value === void 0) return "undefined";
+          const t = typeof value;
+          if (t === "string") return value;
+          if (t === "number" || t === "boolean" || t === "bigint") return String(value);
+          if (t === "function") return `[Function ${value.name || "anonymous"}]`;
+          if (value instanceof Error) return `${value.name}: ${value.message}`;
+          if (value instanceof Element) return `<${value.tagName.toLowerCase()}>`;
+          if (depth >= 2) return Array.isArray(value) ? "[Array]" : "[Object]";
+          if (Array.isArray(value)) {
+            return `[${value.slice(0, 20).map((v) => render(v, depth + 1)).join(", ")}${value.length > 20 ? ", \u2026" : ""}]`;
+          }
+          const entries = Object.entries(value).slice(0, 20);
+          return `{${entries.map(([k, v]) => `${k}: ${render(v, depth + 1)}`).join(", ")}}`;
+        } catch {
+          return "[unrenderable]";
+        }
+      };
+      const CAP = 2e3;
+      const clamp = (s) => s.length > CAP ? `${s.slice(0, CAP)}\u2026[${s.length} chars]` : s;
+      const record = (level, text, extra) => {
+        push(
+          state.console,
+          {
+            seq: ++state.seq,
+            ts: Date.now(),
+            level,
+            text: clamp(text),
+            ...extra?.stack ? { stack: clamp(extra.stack) } : {},
+            url: location.href
+          },
+          MAX_CONSOLE_ENTRIES
+        );
+      };
+      const LEVELS = ["log", "info", "warn", "error", "debug"];
+      for (const level of LEVELS) {
+        const original = console[level];
+        if (typeof original !== "function") continue;
+        console[level] = function patched(...args) {
+          try {
+            record(level, args.map((v) => render(v)).join(" "));
+          } catch {
+          }
+          original.apply(console, args);
+        };
+      }
+      window.addEventListener(
+        "error",
+        (e) => {
+          try {
+            const err = e.error;
+            const where = e.filename ? ` (${e.filename}:${e.lineno}:${e.colno})` : "";
+            record("exception", `${e.message}${where}`, { stack: err?.stack });
+          } catch {
+          }
+        },
+        true
+      );
+      window.addEventListener("unhandledrejection", (e) => {
+        try {
+          const r = e.reason;
+          record("exception", `Unhandled rejection: ${r?.message ?? render(e.reason)}`, { stack: r?.stack });
+        } catch {
+        }
+      });
+      const netStart = (via, method, url) => {
+        const entry = { seq: ++state.seq, ts: Date.now(), via, method, url };
+        push(state.network, entry, MAX_NETWORK_ENTRIES);
+        return entry;
+      };
+      const absolute = (url) => {
+        try {
+          return new URL(url, location.href).href;
+        } catch {
+          return url;
+        }
+      };
+      const originalFetch = w.fetch;
+      if (typeof originalFetch === "function") {
+        w.fetch = function patchedFetch(input, init) {
+          let entry = null;
+          let began = 0;
+          try {
+            const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url ?? String(input);
+            const method = (init?.method ?? input?.method ?? "GET").toUpperCase();
+            began = Date.now();
+            entry = netStart("fetch", method, clamp(absolute(url)));
+          } catch {
+          }
+          return originalFetch.call(w, input, init).then(
+            (res) => {
+              if (entry) {
+                entry.status = res.status;
+                entry.ok = res.ok;
+                entry.durationMs = Date.now() - began;
+              }
+              return res;
+            },
+            (err) => {
+              if (entry) {
+                entry.error = clamp(err instanceof Error ? err.message : String(err));
+                entry.durationMs = Date.now() - began;
+              }
+              throw err;
+            }
+          );
+        };
+      }
+      const XHR = w.XMLHttpRequest;
+      if (typeof XHR === "function") {
+        const open = XHR.prototype.open;
+        const send = XHR.prototype.send;
+        const MARK = "__chromeMcpEntry";
+        XHR.prototype.open = function patchedOpen(method, url, ...rest) {
+          try {
+            this[MARK] = {
+              method: String(method ?? "GET").toUpperCase(),
+              url: absolute(String(url))
+            };
+          } catch {
+          }
+          return open.call(this, method, url, ...rest);
+        };
+        XHR.prototype.send = function patchedSend(body) {
+          let entry = null;
+          const began = Date.now();
+          try {
+            const meta = this[MARK];
+            if (meta) entry = netStart("xhr", meta.method, clamp(meta.url));
+            this.addEventListener("loadend", () => {
+              if (!entry) return;
+              entry.durationMs = Date.now() - began;
+              if (this.status === 0) entry.error = "network error or aborted";
+              else {
+                entry.status = this.status;
+                entry.ok = this.status >= 200 && this.status < 400;
+              }
+            });
+          } catch {
+          }
+          return send.call(this, body);
+        };
+      }
+      const noteDialog = (kind, message, answered) => {
+        push(
+          state.dialogs,
+          { seq: ++state.seq, ts: Date.now(), kind, message: clamp(message), answered },
+          MAX_DIALOG_ENTRIES
+        );
+      };
+      w.alert = function patchedAlert(message) {
+        noteDialog("alert", message === void 0 ? "" : String(message), "dismissed");
+      };
+      w.confirm = function patchedConfirm(message) {
+        const answer = state.dialogPolicy === "accept";
+        noteDialog("confirm", message === void 0 ? "" : String(message), String(answer));
+        return answer;
+      };
+      w.prompt = function patchedPrompt(message, fallback) {
+        const answer = state.dialogPolicy === "accept" ? state.promptText || String(fallback ?? "") : null;
+        noteDialog("prompt", message === void 0 ? "" : String(message), answer === null ? "null" : answer);
+        return answer;
+      };
+      window.addEventListener(
+        "beforeunload",
+        (e) => {
+          try {
+            if (state.dialogPolicy !== "dismiss") return;
+            noteDialog("beforeunload", "page asked to confirm leaving", "suppressed");
+            e.stopImmediatePropagation();
+            delete e.returnValue;
+          } catch {
+          }
+        },
+        true
+      );
+    } catch {
+    }
+  })();
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mehmoodqureshi/chrome-mcp",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "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",