@bool01master/gemini-web-mcp 1.0.0

package/extension/content.js

@@ -0,0 +1,1475 @@
+(() => {
+  const BRIDGE_BASE = "http://127.0.0.1:8765";
+  const POLL_BACKOFF_MS = 2500;
+  const HEARTBEAT_MS = 10000;
+  const COMPOSER_SELECTORS = [
+    "textarea",
+    "[role='textbox']",
+    "[contenteditable='true']",
+    "div[contenteditable='true']"
+  ];
+  const NEW_CHAT_PATTERNS = [/new chat/i, /new conversation/i, /新对话/, /新聊天/];
+  const SEND_PATTERNS = [/^send$/i, /send message/i, /发送/, /提交/];
+  const STOP_PATTERNS = [/stop/i, /停止/, /cancel/i, /取消/];
+  const ATTACH_PATTERNS = [/attach/i, /upload/i, /photo/i, /picture/i, /add files?/i, /add photos?/i, /添加/, /上传/, /照片/, /附件/, /^\+$/];
+  // More specific patterns for file upload buttons (preferred over ATTACH_PATTERNS)
+  const FILE_UPLOAD_PATTERNS = [/文件上传/i, /上传文件/i, /upload.*file/i, /file.*upload/i, /attach.*file/i, /add file/i];
+  const MODE_PATTERNS = [/model/i, /mode/i, /flash/i, /pro/i, /image/i, /canvas/i, /deep research/i, /video/i, /gemini/i, /模式/, /模型/, /图像/, /深度研究/, /打开模式选择器/, /快速/, /thinking/i, /思考/, /推理/];
+
+  const state = {
+    clientId: sessionStorage.getItem("__geminiBridgeClientId") || crypto.randomUUID(),
+    running: false,
+    heartbeatTimer: null,
+    backoffTimer: null,
+    commandDebug: null
+  };
+  sessionStorage.setItem("__geminiBridgeClientId", state.clientId);
+
+  function setCommandDebug(name, stage, extra = {}) {
+    state.commandDebug = {
+      name,
+      stage,
+      updatedAt: new Date().toISOString(),
+      ...extra,
+    };
+  }
+
+  function clearCommandDebug(extra = {}) {
+    state.commandDebug = {
+      name: null,
+      stage: "idle",
+      updatedAt: new Date().toISOString(),
+      ...extra,
+    };
+  }
+
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  function normalizeText(value) {
+    return (value || "")
+      .replace(/\u00a0/g, " ")
+      .replace(/[ \t]+\n/g, "\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim();
+  }
+
+  function shortText(value, max = 180) {
+    return normalizeText(value).slice(0, max);
+  }
+
+  function elementText(element) {
+    return shortText(
+      element.innerText ||
+        element.textContent ||
+        element.getAttribute("aria-label") ||
+        element.getAttribute("title") ||
+        "",
+    );
+  }
+
+  function isVisible(element, minWidth = 1, minHeight = 1) {
+    if (!element) {
+      return false;
+    }
+
+    const rect = element.getBoundingClientRect();
+    const style = window.getComputedStyle(element);
+    return (
+      rect.width >= minWidth &&
+      rect.height >= minHeight &&
+      style.display !== "none" &&
+      style.visibility !== "hidden" &&
+      style.opacity !== "0"
+    );
+  }
+
+  function buttonSnapshot(element) {
+    return {
+      text: elementText(element),
+      ariaLabel: shortText(element.getAttribute("aria-label") || ""),
+      title: shortText(element.getAttribute("title") || ""),
+      expanded: element.getAttribute("aria-expanded") === "true",
+      hasPopup: element.hasAttribute("aria-haspopup")
+    };
+  }
+
+  function visibleButtons() {
+    return Array.from(document.querySelectorAll("button, [role='button']"))
+      .filter((element) => isVisible(element, 20, 20))
+      .map((element) => ({ element, ...buttonSnapshot(element) }));
+  }
+
+  function visibleImageNodes(minWidth = 120, minHeight = 120) {
+    return Array.from(document.querySelectorAll("img, canvas")).filter((element) =>
+      isVisible(element, minWidth, minHeight),
+    );
+  }
+
+  async function withTimeout(promise, timeoutMs, fallback) {
+    let timer = null;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise((resolve) => {
+          timer = window.setTimeout(() => resolve(fallback()), timeoutMs);
+        }),
+      ]);
+    } finally {
+      if (timer) {
+        window.clearTimeout(timer);
+      }
+    }
+  }
+
+  async function fetchImageViaExtension(imageUrl) {
+    if (!imageUrl || !chrome?.runtime?.sendMessage) {
+      return null;
+    }
+
+    return new Promise((resolve) => {
+      chrome.runtime.sendMessage(
+        {
+          type: "bridge:fetch_image",
+          url: imageUrl,
+        },
+        (response) => {
+          if (chrome.runtime.lastError) {
+            resolve({
+              error: chrome.runtime.lastError.message,
+              url: imageUrl,
+            });
+            return;
+          }
+
+          if (response?.ok && typeof response.dataUrl === "string") {
+            resolve(response.dataUrl);
+            return;
+          }
+
+          resolve({
+            error: response?.error || "Extension image fetch failed.",
+            url: imageUrl,
+          });
+        },
+      );
+    });
+  }
+
+  async function captureVisibleTabDataUrl() {
+    if (!chrome?.runtime?.sendMessage) {
+      return null;
+    }
+
+    await new Promise((resolve) => {
+      chrome.runtime.sendMessage(
+        {
+          type: "bridge:activate_self",
+        },
+        () => resolve(),
+      );
+    });
+
+    const visibilityDeadline = Date.now() + 2500;
+    while (document.visibilityState !== "visible" && Date.now() < visibilityDeadline) {
+      await sleep(100);
+    }
+
+    await sleep(200);
+
+    return new Promise((resolve) => {
+      chrome.runtime.sendMessage(
+        {
+          type: "bridge:capture_tab",
+        },
+        (response) => {
+          if (chrome.runtime.lastError) {
+            resolve({
+              error: chrome.runtime.lastError.message,
+            });
+            return;
+          }
+
+          if (response?.ok && typeof response.dataUrl === "string") {
+            resolve(response.dataUrl);
+            return;
+          }
+
+          resolve({
+            error: response?.error || "Visible tab capture failed.",
+          });
+        },
+      );
+    });
+  }
+
+  async function cropDataUrl(dataUrl, rect) {
+    if (!dataUrl || !rect?.width || !rect?.height) {
+      return null;
+    }
+
+    const source = await new Promise((resolve, reject) => {
+      const image = new Image();
+      image.onload = () => resolve(image);
+      image.onerror = () => reject(new Error("Failed to decode captured tab image."));
+      image.src = dataUrl;
+    });
+
+    const scale = window.devicePixelRatio || 1;
+    const sx = Math.max(0, Math.round(rect.left * scale));
+    const sy = Math.max(0, Math.round(rect.top * scale));
+    const sw = Math.max(1, Math.round(rect.width * scale));
+    const sh = Math.max(1, Math.round(rect.height * scale));
+    const canvas = document.createElement("canvas");
+    canvas.width = sw;
+    canvas.height = sh;
+    const context = canvas.getContext("2d");
+    if (!context) {
+      return null;
+    }
+
+    context.drawImage(source, sx, sy, sw, sh, 0, 0, sw, sh);
+    return canvas.toDataURL("image/png");
+  }
+
+  function composerRect() {
+    const composer = findComposer();
+    return composer ? composer.getBoundingClientRect() : null;
+  }
+
+  function buttonsNearComposer() {
+    const rect = composerRect();
+    if (!rect) {
+      return [];
+    }
+
+    return visibleButtons().filter((button) => {
+      const buttonRect = button.element.getBoundingClientRect();
+      const withinVerticalBand =
+        buttonRect.bottom >= rect.top - 220 &&
+        buttonRect.top <= rect.bottom + 180;
+      const withinHorizontalBand =
+        buttonRect.right >= rect.left - 220 &&
+        buttonRect.left <= rect.right + 220;
+      return withinVerticalBand && withinHorizontalBand;
+    });
+  }
+
+  function fileInputsSummary() {
+    return Array.from(document.querySelectorAll("input[type='file']")).map((element) => ({
+      accept: element.getAttribute("accept") || "",
+      multiple: element.hasAttribute("multiple"),
+      disabled: element.disabled,
+      visible: isVisible(element, 1, 1),
+    }));
+  }
+
+  function matchesPatterns(value, patterns) {
+    return patterns.some((pattern) => pattern.test(value || ""));
+  }
+
+  function getMainRoot() {
+    return document.querySelector("main, [role='main']") || document.body;
+  }
+
+  /**
+   * Find the conversation content container by walking up from the composer.
+   * This avoids including sidebar/navigation in text capture.
+   */
+  function getConversationContainer() {
+    const composer = findComposer();
+    if (!composer) return null;
+
+    // Walk up from the composer to find a scrollable or large container
+    // that represents the conversation panel (not the full page).
+    let el = composer.parentElement;
+    while (el && el !== document.body) {
+      const style = window.getComputedStyle(el);
+      const isScrollable =
+        style.overflowY === "auto" || style.overflowY === "scroll";
+      const isLarge = el.offsetHeight > 300 && el.offsetWidth > 400;
+      if (isScrollable && isLarge) {
+        return el;
+      }
+      el = el.parentElement;
+    }
+
+    return null;
+  }
+
+  /**
+   * Get the text content of the conversation area only (no sidebar).
+   */
+  function getConversationText() {
+    const container = getConversationContainer();
+    if (container) {
+      const text = normalizeText(container.innerText || "");
+      // If the container text is meaningful, use it; otherwise fall back.
+      if (text.length > 20) {
+        return text;
+      }
+    }
+    return normalizeText(getMainRoot().innerText || "");
+  }
+
+  // Turn separator patterns for parsing model responses from conversation text.
+  const USER_TURN_RE = /\n(你[说曰]|You\s+said)\s*\n/gi;
+  const MODEL_TURN_RE = /\n(Gemini\s*(?:[说曰]|said))\s*\n/gi;
+  const FOOTER_RE = /\n(?:工具|Tools)\s*\n|Gemini\s*(?:是一款|is\s+a)\s*AI/i;
+
+  /**
+   * Extract only the last model response text from the conversation,
+   * avoiding sidebar, buttons, and previous turns.
+   *
+   * Strategy (in order):
+   *   1. Try Gemini-specific DOM selectors for model response elements
+   *   2. Parse full page text by turn separators ("Gemini 说" / "你说")
+   *   3. Return null → caller falls back to diff-based extraction
+   */
+  function getLastResponseText() {
+    // --- Strategy 1: DOM selectors ---
+    const responseSelectors = [
+      "model-response .message-content",
+      "model-response",
+      "[data-message-author-role='model'] .message-content",
+      "[data-message-author-role='model']",
+      ".response-container .message-content",
+      ".response-container",
+      ".conversation-container model-response",
+    ];
+
+    for (const selector of responseSelectors) {
+      const elements = document.querySelectorAll(selector);
+      if (elements.length > 0) {
+        const last = elements[elements.length - 1];
+        const text = normalizeText(last.innerText || "");
+        if (text.length > 5) {
+          return text;
+        }
+      }
+    }
+
+    // --- Strategy 2: Parse turn separators from full page text ---
+    const fullText = normalizeText(getMainRoot().innerText || "");
+    if (fullText.length > 20) {
+      // Find all "Gemini 说" / "Gemini said" positions
+      const modelPositions = [];
+      let match;
+      const re = /\n(Gemini\s*(?:[说曰]|said))\s*\n/gi;
+      while ((match = re.exec(fullText)) !== null) {
+        modelPositions.push(match.index + match[0].length);
+      }
+
+      if (modelPositions.length > 0) {
+        // Take content after the LAST "Gemini 说"
+        let responseText = fullText.slice(modelPositions[modelPositions.length - 1]);
+
+        // Trim at next user turn ("你说" / "You said")
+        const userMatch = responseText.search(USER_TURN_RE);
+        if (userMatch > 0) {
+          responseText = responseText.slice(0, userMatch);
+        }
+
+        // Trim footer ("工具" / "Gemini 是一款 AI 工具")
+        const footerMatch = responseText.search(FOOTER_RE);
+        if (footerMatch > 0) {
+          responseText = responseText.slice(0, footerMatch);
+        }
+
+        responseText = normalizeText(responseText);
+        if (responseText.length > 3) {
+          return responseText;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  function findComposer() {
+    const candidates = [];
+
+    for (const selector of COMPOSER_SELECTORS) {
+      for (const element of document.querySelectorAll(selector)) {
+        if (!isVisible(element, 160, 24)) {
+          continue;
+        }
+
+        const rect = element.getBoundingClientRect();
+        candidates.push({ element, rect });
+      }
+    }
+
+    candidates.sort(
+      (left, right) =>
+        right.rect.y + right.rect.height - (left.rect.y + left.rect.height),
+    );
+
+    return candidates[0]?.element || null;
+  }
+
+  function collectModeCandidates() {
+    const localButtons = buttonsNearComposer();
+    const source = localButtons.length > 0 ? localButtons : visibleButtons();
+
+    return source
+      .filter((button) =>
+        matchesPatterns(
+          `${button.text} ${button.ariaLabel} ${button.title}`,
+          MODE_PATTERNS,
+        ),
+      )
+      .slice(0, 12)
+      .map((button) => ({
+        text: button.text,
+        ariaLabel: button.ariaLabel,
+        title: button.title
+      }));
+  }
+
+  function resolveModeLabels(mode) {
+    const labels = new Set([mode.trim()]);
+    const normalized = mode.trim().toLowerCase();
+
+    if (/(thinking|思考|reason|推理)/i.test(normalized)) {
+      labels.add("思考");
+      labels.add("Thinking");
+      labels.add("推理");
+    }
+
+    if (/(image|图片|制图|作图|nanobanana|nano banana)/i.test(normalized)) {
+      labels.add("制作图片");
+      labels.add("图片");
+      labels.add("Nano Banana 2");
+    }
+
+    return Array.from(labels)
+      .map((value) => value.trim())
+      .filter(Boolean);
+  }
+
+  function isStarterMode(mode) {
+    return /制作图片|创作音乐|创作视频|image|music|video|nanobanana|nano banana/i.test(
+      mode || "",
+    );
+  }
+
+  function pageSummary() {
+    const composer = findComposer();
+    const fileInputs = fileInputsSummary();
+    const localButtons = buttonsNearComposer();
+    const rect = composerRect();
+
+    return {
+      ready: Boolean(composer),
+      url: location.href,
+      title: document.title,
+      hasFocus: document.hasFocus(),
+      visibilityState: document.visibilityState,
+      composerFound: Boolean(composer),
+      composerPlaceholder: composer
+        ? shortText(
+            composer.getAttribute?.("placeholder") ||
+              composer.getAttribute?.("aria-label") ||
+              "",
+          )
+        : "",
+      composerRect: rect
+        ? {
+            left: Math.round(rect.left),
+            top: Math.round(rect.top),
+            width: Math.round(rect.width),
+            height: Math.round(rect.height),
+          }
+        : null,
+      fileInputCount: fileInputs.length,
+      fileInputs,
+      availableButtons: visibleButtons()
+        .slice(0, 24)
+        .map((button) => button.text || button.ariaLabel || button.title)
+        .filter(Boolean),
+      composerButtons: localButtons
+        .slice(0, 16)
+        .map((button) => button.text || button.ariaLabel || button.title)
+        .filter(Boolean),
+      modeCandidates: collectModeCandidates(),
+      commandDebug: state.commandDebug,
+      visibleImageCount: visibleImageNodes().length,
+      mainText: shortText(getMainRoot().innerText || "", 4000),
+    };
+  }
+
+  function clearComposer(composer) {
+    if ("value" in composer) {
+      const prototype =
+        composer instanceof HTMLTextAreaElement
+          ? HTMLTextAreaElement.prototype
+          : HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, "value");
+      descriptor?.set?.call(composer, "");
+      composer.dispatchEvent(new Event("input", { bubbles: true }));
+      composer.dispatchEvent(new Event("change", { bubbles: true }));
+      return;
+    }
+
+    composer.textContent = "";
+    composer.dispatchEvent(new InputEvent("input", { bubbles: true, data: "" }));
+  }
+
+  function writeComposer(composer, prompt) {
+    composer.focus();
+
+    if ("value" in composer) {
+      const prototype =
+        composer instanceof HTMLTextAreaElement
+          ? HTMLTextAreaElement.prototype
+          : HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, "value");
+      descriptor?.set?.call(composer, prompt);
+      composer.dispatchEvent(new Event("input", { bubbles: true }));
+      composer.dispatchEvent(new Event("change", { bubbles: true }));
+      return;
+    }
+
+    composer.textContent = prompt;
+    composer.dispatchEvent(
+      new InputEvent("input", {
+        bubbles: true,
+        data: prompt,
+        inputType: "insertText",
+      }),
+    );
+  }
+
+  function clickElement(element) {
+    element.scrollIntoView({ block: "center", inline: "center" });
+    element.dispatchEvent(
+      new MouseEvent("mousedown", { bubbles: true, cancelable: true }),
+    );
+    element.dispatchEvent(
+      new MouseEvent("mouseup", { bubbles: true, cancelable: true }),
+    );
+    element.dispatchEvent(
+      new MouseEvent("click", { bubbles: true, cancelable: true }),
+    );
+  }
+
+  function currentComposerText() {
+    const composer = findComposer();
+    if (!composer) {
+      return "";
+    }
+
+    if ("value" in composer) {
+      return normalizeText(composer.value || "");
+    }
+
+    return normalizeText(composer.textContent || composer.innerText || "");
+  }
+
+  function findSendButton() {
+    const localButtons = buttonsNearComposer();
+    const source = localButtons.length > 0 ? localButtons : visibleButtons();
+    return source.find((button) =>
+      matchesPatterns(
+        `${button.text} ${button.ariaLabel} ${button.title}`,
+        SEND_PATTERNS,
+      ),
+    );
+  }
+
+  async function tryOpenNewChat() {
+    const target = visibleButtons().find((button) =>
+      matchesPatterns(
+        `${button.text} ${button.ariaLabel} ${button.title}`,
+        NEW_CHAT_PATTERNS,
+      ),
+    );
+
+    if (!target) {
+      return false;
+    }
+
+    clickElement(target.element);
+    await sleep(1200);
+    return true;
+  }
+
+  function findMenuOption(labels) {
+    const normalizedLabels = labels.map((label) => label.trim().toLowerCase());
+    const options = Array.from(
+      document.querySelectorAll("[role='menuitem'], [role='option'], [role='tab'], button"),
+    )
+      .filter((element) => isVisible(element, 24, 16))
+      .map((element) => ({
+        element,
+        text: elementText(element).toLowerCase(),
+      }));
+
+    return (
+      options.find((option) => normalizedLabels.some((label) => option.text === label)) ||
+      options.find((option) => normalizedLabels.some((label) => option.text.includes(label)))
+    );
+  }
+
+  async function selectMode(mode) {
+    if (!mode) {
+      return { attempted: false, selected: null, available: collectModeCandidates() };
+    }
+
+    const labels = resolveModeLabels(mode);
+    const normalizedLabels = labels.map((label) => label.toLowerCase());
+    const localButtons = buttonsNearComposer();
+    const source = localButtons.length > 0 ? localButtons : visibleButtons();
+    const directButton = source.find((button) => {
+      const text = `${button.text} ${button.ariaLabel} ${button.title}`.toLowerCase();
+      return normalizedLabels.some((label) => text === label || text.includes(label));
+    });
+
+    if (directButton) {
+      clickElement(directButton.element);
+      await sleep(600);
+      return {
+        attempted: true,
+        selected: mode,
+        method: "direct-button",
+        available: collectModeCandidates(),
+      };
+    }
+
+    const trigger = source.find((button) =>
+      matchesPatterns(
+        `${button.text} ${button.ariaLabel} ${button.title}`,
+        MODE_PATTERNS,
+      ),
+    );
+
+    if (!trigger) {
+      return {
+        attempted: true,
+        selected: null,
+        method: "not-found",
+        available: collectModeCandidates(),
+      };
+    }
+
+    clickElement(trigger.element);
+    await sleep(700);
+
+    const option = findMenuOption(labels);
+    if (!option) {
+      return {
+        attempted: true,
+        selected: null,
+        method: "menu-opened-no-match",
+        available: collectModeCandidates(),
+      };
+    }
+
+    clickElement(option.element);
+    await sleep(900);
+    return {
+      attempted: true,
+      selected: mode,
+      method: "menu-option",
+      available: collectModeCandidates(),
+    };
+  }
+
+  async function ensureFileInput() {
+    let input = Array.from(document.querySelectorAll("input[type='file']")).find(
+      (element) => !element.disabled,
+    );
+
+    if (input) {
+      return input;
+    }
+
+    const localButtons = buttonsNearComposer();
+    const source = localButtons.length > 0 ? localButtons : visibleButtons();
+
+    // Prefer buttons matching specific file-upload patterns, then fall back to general attach patterns.
+    const matchButton = (patterns) =>
+      source.find((button) =>
+        matchesPatterns(`${button.text} ${button.ariaLabel} ${button.title}`, patterns),
+      );
+    const attachButton = matchButton(FILE_UPLOAD_PATTERNS) || matchButton(ATTACH_PATTERNS);
+
+    if (!attachButton) {
+      return null;
+    }
+
+    clickElement(attachButton.element);
+    await sleep(1000);
+
+    // Check if clicking produced a file input directly.
+    input = Array.from(document.querySelectorAll("input[type='file']")).find(
+      (element) => !element.disabled,
+    );
+    if (input) return input;
+
+    // Gemini may show a sub-menu after clicking the attach button.
+    // Look for a menu item that triggers the local file upload.
+    const UPLOAD_MENU_PATTERNS = [
+      /从.*(?:电脑|设备|本地).*上传/i,
+      /upload.*(?:file|computer|device)/i,
+      /上传文件/i,
+      /我的电脑/i,
+      /本地文件/i,
+      /my computer/i,
+      /from computer/i,
+    ];
+    const allButtons = visibleButtons();
+    const menuItems = Array.from(
+      document.querySelectorAll("[role='menuitem'], [role='option'], [role='listitem'], [role='button']"),
+    )
+      .filter((el) => isVisible(el, 10, 10))
+      .map((el) => ({ element: el, ...buttonSnapshot(el) }));
+    const candidates = [...menuItems, ...allButtons];
+
+    const uploadItem = candidates.find((item) =>
+      matchesPatterns(
+        `${item.text} ${item.ariaLabel} ${item.title}`,
+        UPLOAD_MENU_PATTERNS,
+      ),
+    );
+
+    if (uploadItem) {
+      clickElement(uploadItem.element);
+      await sleep(800);
+      input = Array.from(document.querySelectorAll("input[type='file']")).find(
+        (element) => !element.disabled,
+      );
+      if (input) return input;
+    }
+
+    // If still no file input, try clicking any menu item containing "上传" or "upload"
+    const fallbackItem = candidates.find((item) =>
+      matchesPatterns(
+        `${item.text} ${item.ariaLabel} ${item.title}`,
+        [/上传/, /upload/i],
+      ),
+    );
+    if (fallbackItem && fallbackItem !== uploadItem) {
+      clickElement(fallbackItem.element);
+      await sleep(800);
+      input = Array.from(document.querySelectorAll("input[type='file']")).find(
+        (element) => !element.disabled,
+      );
+      if (input) return input;
+    }
+
+    return null;
+  }
+
+  function base64ToBytes(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+
+    return bytes;
+  }
+
+  async function attachImages(images) {
+    if (!Array.isArray(images) || images.length === 0) {
+      return { attempted: false, count: 0 };
+    }
+
+    const input = await ensureFileInput();
+    if (!input) {
+      throw new Error("Unable to find an image upload input on the page.");
+    }
+
+    const transfer = new DataTransfer();
+
+    for (const image of images) {
+      const file = new File([base64ToBytes(image.base64)], image.name, {
+        type: image.mimeType || "application/octet-stream",
+        lastModified: Date.now(),
+      });
+      transfer.items.add(file);
+    }
+
+    input.files = transfer.files;
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+    input.dispatchEvent(new Event("change", { bubbles: true }));
+    await sleep(1200);
+
+    return {
+      attempted: true,
+      count: transfer.files.length,
+      inputAccept: input.getAttribute("accept") || "",
+    };
+  }
+
+  function captureState() {
+    // Use full main root text for reliable change detection.
+    const text = normalizeText(getMainRoot().innerText || "");
+    const buttons = visibleButtons();
+
+    return {
+      text,
+      textLength: text.length,
+      stopVisible: buttons.some((button) =>
+        matchesPatterns(
+          `${button.text} ${button.ariaLabel} ${button.title}`,
+          STOP_PATTERNS,
+        ),
+      ),
+      buttonLabels: buttons
+        .slice(0, 30)
+        .map((button) => button.text || button.ariaLabel || button.title)
+        .filter(Boolean),
+      imageCount: visibleImageNodes().length,
+    };
+  }
+
+  async function waitForResponseStart(beforeState, timeoutMs) {
+    const startedAt = Date.now();
+
+    while (Date.now() - startedAt < timeoutMs) {
+      const current = captureState();
+      if (
+        current.textLength > beforeState.textLength + 20 ||
+        current.imageCount > beforeState.imageCount ||
+        current.stopVisible
+      ) {
+        return true;
+      }
+
+      await sleep(900);
+    }
+
+    return false;
+  }
+
+  async function waitForResponseCompletion(beforeState, timeoutMs) {
+    const startedAt = Date.now();
+    let stableSignature = "";
+    let stableMs = 0;
+
+    while (Date.now() - startedAt < timeoutMs) {
+      const current = captureState();
+      const hasMeaningfulChange =
+        current.text !== beforeState.text ||
+        current.imageCount !== beforeState.imageCount;
+
+      if (!hasMeaningfulChange && current.stopVisible) {
+        await sleep(1200);
+        continue;
+      }
+
+      const signature = JSON.stringify({
+        textTail: current.text.slice(-1500),
+        imageCount: current.imageCount,
+        stopVisible: current.stopVisible,
+        buttons: current.buttonLabels.slice(0, 8),
+      });
+
+      if (signature === stableSignature) {
+        stableMs += 1200;
+      } else {
+        stableSignature = signature;
+        stableMs = 0;
+      }
+
+      if (hasMeaningfulChange && stableMs >= 3600 && !current.stopVisible) {
+        return current;
+      }
+
+      await sleep(1200);
+    }
+
+    return captureState();
+  }
+
+  async function waitForImageReady(beforeState, timeoutMs) {
+    const startedAt = Date.now();
+    let stableImageCount = beforeState.imageCount;
+    let stableMs = 0;
+    let stableSignature = "";
+    // After Gemini's text response stabilizes, the image generation tool may
+    // still be rendering.  Wait at least this long for images to appear.
+    const IMAGE_RENDER_GRACE_MS = 45_000;
+
+    while (Date.now() - startedAt < timeoutMs) {
+      const current = captureState();
+      const hasMeaningfulChange =
+        current.text !== beforeState.text ||
+        current.imageCount !== beforeState.imageCount ||
+        current.buttonLabels.join("\n") !== beforeState.buttonLabels.join("\n");
+
+      const signature = JSON.stringify({
+        textTail: current.text.slice(-1500),
+        imageCount: current.imageCount,
+        stopVisible: current.stopVisible,
+        buttons: current.buttonLabels.slice(0, 8),
+      });
+
+      if (current.imageCount > beforeState.imageCount) {
+        if (current.imageCount === stableImageCount) {
+          stableMs += 1000;
+        } else {
+          stableImageCount = current.imageCount;
+          stableMs = 0;
+        }
+
+        if (!current.stopVisible && stableMs >= 2000) {
+          return current;
+        }
+      }
+
+      if (signature === stableSignature) {
+        stableMs += 1000;
+      } else {
+        stableSignature = signature;
+        if (current.imageCount <= beforeState.imageCount) {
+          stableMs = 0;
+        }
+      }
+
+      // Only give up when no new images appeared AND the page has been stable
+      // long enough for images to have rendered (Gemini's image tool can take
+      // 10-20 s after the text response completes).
+      const graceThreshold =
+        current.imageCount > beforeState.imageCount ? 3000 : IMAGE_RENDER_GRACE_MS;
+      if (hasMeaningfulChange && !current.stopVisible && stableMs >= graceThreshold) {
+        return current;
+      }
+
+      await sleep(1000);
+    }
+
+    return captureState();
+  }
+
+  function newTextFromStates(beforeState, afterState) {
+    const before = beforeState.text || "";
+    const after = afterState.text || "";
+    let index = 0;
+    const max = Math.min(before.length, after.length);
+
+    while (index < max && before[index] === after[index]) {
+      index += 1;
+    }
+
+    return normalizeText(after.slice(index)) || after.slice(-20000);
+  }
+
+  async function imageToDataUrl(image) {
+    if (image instanceof HTMLCanvasElement) {
+      try {
+        return image.toDataURL("image/png");
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : String(error),
+          url: null,
+        };
+      }
+    }
+
+    if (!(image instanceof HTMLImageElement)) {
+      return null;
+    }
+
+    const imageUrl = image.currentSrc || image.src || "";
+
+    if (imageUrl.startsWith("data:image/")) {
+      return imageUrl;
+    }
+
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = Math.max(1, image.naturalWidth || image.width || 1);
+      canvas.height = Math.max(1, image.naturalHeight || image.height || 1);
+      const context = canvas.getContext("2d");
+      if (context) {
+        context.drawImage(image, 0, 0);
+        return canvas.toDataURL("image/png");
+      }
+    } catch {
+      // Canvas tainted by cross-origin image; tab-capture fallback handles this.
+    }
+
+    return {
+      error: "Unable to read image bytes directly from page element.",
+      url: imageUrl,
+    };
+  }
+
+  async function collectVisibleImages(maxImages) {
+    if (!Number.isFinite(maxImages) || maxImages <= 0) {
+      return [];
+    }
+
+    const nodes = visibleImageNodes(180, 180)
+      .sort((left, right) => {
+        const leftHasUrl =
+          left instanceof HTMLImageElement && Boolean(left.currentSrc || left.src);
+        const rightHasUrl =
+          right instanceof HTMLImageElement && Boolean(right.currentSrc || right.src);
+        if (leftHasUrl !== rightHasUrl) {
+          return Number(rightHasUrl) - Number(leftHasUrl);
+        }
+
+        const leftRect = left.getBoundingClientRect();
+        const rightRect = right.getBoundingClientRect();
+        return (
+          rightRect.bottom * rightRect.width * rightRect.height -
+          leftRect.bottom * leftRect.width * leftRect.height
+        );
+      })
+      .slice(0, maxImages);
+
+    const results = [];
+    const failedIndices = [];
+
+    for (const [index, node] of nodes.entries()) {
+      const rect = node.getBoundingClientRect();
+      const url = node instanceof HTMLImageElement ? node.currentSrc || node.src : null;
+      let dataUrl = null;
+      let error = null;
+      try {
+        const extracted = await imageToDataUrl(node);
+        if (typeof extracted === "string") {
+          dataUrl = extracted;
+        } else if (extracted && extracted.error) {
+          error = extracted.error;
+          failedIndices.push(index);
+        }
+      } catch (extractError) {
+        error = extractError instanceof Error ? extractError.message : String(extractError);
+        failedIndices.push(index);
+      }
+      results.push({
+        dataUrl,
+        url,
+        width: Math.round(rect.width),
+        height: Math.round(rect.height),
+        alt: node instanceof HTMLImageElement ? node.alt || "" : "",
+        tagName: node.tagName.toLowerCase(),
+        error,
+      });
+    }
+
+    // Fallback: capture visible tab and crop each failed image region.
+    if (failedIndices.length > 0) {
+      try {
+        for (const index of failedIndices) {
+          // Scroll the image into view first
+          nodes[index].scrollIntoView({ block: "center", inline: "center" });
+          await sleep(300);
+
+          const tabCapture = await captureVisibleTabDataUrl();
+          if (typeof tabCapture !== "string") {
+            // Tab capture failed entirely; stop trying further images.
+            break;
+          }
+
+          const rect = nodes[index].getBoundingClientRect();
+          const cropped = await cropDataUrl(tabCapture, rect);
+          if (typeof cropped === "string") {
+            results[index].dataUrl = cropped;
+            results[index].error = null;
+          }
+        }
+      } catch {
+        // Tab capture unavailable; keep existing errors.
+      }
+    }
+
+    return results;
+  }
+
+  async function sendPrompt(prompt) {
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+      const sendButton = findSendButton();
+      if (sendButton) {
+        clickElement(sendButton.element);
+        await sleep(200);
+        if (!findSendButton()) {
+          return;
+        }
+      }
+
+      await sleep(250);
+    }
+
+    const composer = findComposer();
+    if (!composer) {
+      throw new Error("Unable to find Gemini composer before submitting.");
+    }
+
+    composer.dispatchEvent(
+      new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }),
+    );
+    composer.dispatchEvent(
+      new KeyboardEvent("keyup", { key: "Enter", bubbles: true, cancelable: true }),
+    );
+
+    await sleep(100);
+
+    if (prompt && findComposer() && currentComposerText()) {
+      document.activeElement?.dispatchEvent(
+        new KeyboardEvent("keydown", {
+          key: "Enter",
+          metaKey: true,
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+      await sleep(150);
+    }
+
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      const sendButton = findSendButton();
+      if (!sendButton) {
+        return;
+      }
+
+      clickElement(sendButton.element);
+      await sleep(250);
+    }
+  }
+
+  async function runPrompt(args) {
+    const prompt = normalizeText(args.prompt || "");
+    if (!prompt) {
+      throw new Error("`prompt` cannot be empty.");
+    }
+
+    setCommandDebug("run_prompt", "prepare", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+
+    let modeResult = {
+      attempted: false,
+      selected: null,
+      available: collectModeCandidates(),
+    };
+    const starterMode = isStarterMode(args.mode || "");
+
+    if (starterMode && args.mode) {
+      setCommandDebug("run_prompt", "starter-mode", {
+        promptPreview: shortText(prompt, 120),
+        mode: args.mode || null,
+      });
+      modeResult = await selectMode(args.mode);
+    }
+
+    if (
+      args.newChat !== false &&
+      !(starterMode && modeResult?.selected && modeResult?.method === "direct-button")
+    ) {
+      setCommandDebug("run_prompt", "new-chat", {
+        promptPreview: shortText(prompt, 120),
+        mode: args.mode || null,
+      });
+      await tryOpenNewChat();
+    }
+
+    if (!modeResult.attempted && args.mode) {
+      setCommandDebug("run_prompt", "select-mode", {
+        promptPreview: shortText(prompt, 120),
+        mode: args.mode || null,
+      });
+      modeResult = await selectMode(args.mode);
+    }
+
+    setCommandDebug("run_prompt", "attach-images", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+    const attachmentResult = await attachImages(args.images || []);
+    const composer = findComposer();
+    if (!composer) {
+      throw new Error("Unable to find the Gemini prompt input box.");
+    }
+
+    setCommandDebug("run_prompt", "write-composer", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+    clearComposer(composer);
+    writeComposer(composer, prompt);
+
+    const beforeState = captureState();
+    setCommandDebug("run_prompt", "send-prompt", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+    await sendPrompt(prompt);
+
+    setCommandDebug("run_prompt", "wait-response-start", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+    const started = await waitForResponseStart(beforeState, 12_000);
+    if (!started) {
+      throw new Error("Gemini did not appear to start responding.");
+    }
+
+    const maxImages = Number(args.maxImages ?? 4);
+    const timeoutMs = Number(args.waitTimeoutMs || 120_000);
+    const prefersImages = maxImages > 0 || /制作图片|image|图片|nanobanana|nano banana/i.test(args.mode || "");
+
+    setCommandDebug("run_prompt", prefersImages ? "wait-image-ready" : "wait-response-complete", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+    const afterState = prefersImages
+      ? await waitForImageReady(beforeState, timeoutMs)
+      : await waitForResponseCompletion(beforeState, timeoutMs);
+    setCommandDebug("run_prompt", "collect-images", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+    });
+    const images = await collectVisibleImages(maxImages);
+    setCommandDebug("run_prompt", "build-result", {
+      promptPreview: shortText(prompt, 120),
+      mode: args.mode || null,
+      imageCount: images.length,
+    });
+
+    return {
+      ready: true,
+      title: document.title,
+      url: location.href,
+      mode: args.mode || null,
+      modeResult,
+      attachmentResult,
+      text: getLastResponseText() || newTextFromStates(beforeState, afterState),
+      imageCountOnPage: afterState.imageCount,
+      images,
+    };
+  }
+
+  async function captureImages(args) {
+    setCommandDebug("capture_images", "collect-images");
+    const summary = pageSummary();
+    const images = await collectVisibleImages(Number(args.maxImages ?? 4));
+    setCommandDebug("capture_images", "build-result", {
+      imageCount: images.length,
+    });
+
+    return {
+      ready: summary.ready,
+      title: document.title,
+      url: location.href,
+      mode: null,
+      modeResult: null,
+      attachmentResult: null,
+      text: getLastResponseText() || summary.mainText || "",
+      imageCountOnPage: Number(summary.visibleImageCount || images.length),
+      images,
+    };
+  }
+
+  async function downloadImageUrls(args) {
+    const urls = Array.isArray(args.urls)
+      ? Array.from(new Set(args.urls.filter((value) => typeof value === "string" && value)))
+      : [];
+    const downloads = [];
+
+    for (const url of urls) {
+      const result = await withTimeout(
+        fetchImageViaExtension(url),
+        15_000,
+        () => ({
+          error: "Timed out while downloading image URL.",
+          url,
+        }),
+      );
+
+      if (typeof result === "string") {
+        downloads.push({
+          url,
+          dataUrl: result,
+          error: null,
+        });
+        continue;
+      }
+
+      downloads.push({
+        url,
+        dataUrl: null,
+        error: result?.error || "Failed to download image URL.",
+      });
+    }
+
+    return { downloads };
+  }
+
+  async function executeCommand(command) {
+    setCommandDebug(command.name, "dispatch");
+    if (command.name === "get_status") {
+      const result = pageSummary();
+      clearCommandDebug({ lastCompletedCommand: command.name });
+      return result;
+    }
+
+    if (command.name === "run_prompt") {
+      const result = await runPrompt(command.args || {});
+      clearCommandDebug({ lastCompletedCommand: command.name });
+      return result;
+    }
+
+    if (command.name === "capture_images") {
+      const result = await captureImages(command.args || {});
+      clearCommandDebug({ lastCompletedCommand: command.name });
+      return result;
+    }
+
+    if (command.name === "download_image_urls") {
+      const result = await downloadImageUrls(command.args || {});
+      clearCommandDebug({ lastCompletedCommand: command.name });
+      return result;
+    }
+
+    if (command.name === "eval_js") {
+      const code = (command.args && command.args.code) || "";
+      try {
+        const fn = new Function(code);
+        const evalResult = fn();
+        clearCommandDebug({ lastCompletedCommand: command.name });
+        return { ok: true, value: evalResult };
+      } catch (err) {
+        clearCommandDebug({ lastCompletedCommand: command.name, error: err.message });
+        return { ok: false, error: err.message };
+      }
+    }
+
+    clearCommandDebug({
+      lastCompletedCommand: command.name,
+      error: `Unsupported command: ${command.name}`,
+    });
+    throw new Error(`Unsupported command: ${command.name}`);
+  }
+
+  async function bridgeFetch(pathname, options = {}) {
+    const headers = { ...(options.headers || {}) };
+    if (options.body) {
+      headers["Content-Type"] = "application/json";
+    }
+
+    const response = await fetch(`${BRIDGE_BASE}${pathname}`, {
+      headers,
+      ...options,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Bridge request failed with status ${response.status}.`);
+    }
+
+    return response.json();
+  }
+
+  async function register() {
+    const response = await bridgeFetch("/bridge/register", {
+      method: "POST",
+      body: JSON.stringify({
+        clientId: state.clientId,
+        pageUrl: location.href,
+        title: document.title,
+        capabilities: {
+          modeSelection: true,
+          imageUpload: true,
+          imageExtraction: true,
+        },
+      }),
+    });
+
+    state.clientId = response.clientId;
+    sessionStorage.setItem("__geminiBridgeClientId", state.clientId);
+  }
+
+  async function heartbeat() {
+    await bridgeFetch("/bridge/heartbeat", {
+      method: "POST",
+      body: JSON.stringify({
+        clientId: state.clientId,
+        pageUrl: location.href,
+        title: document.title,
+        state: pageSummary(),
+      }),
+    });
+  }
+
+  async function postResult(requestId, ok, result, error) {
+    await bridgeFetch("/bridge/result", {
+      method: "POST",
+      body: JSON.stringify({
+        clientId: state.clientId,
+        requestId,
+        ok,
+        result,
+        error,
+      }),
+    });
+  }
+
+  async function pollLoop() {
+    if (state.running) {
+      return;
+    }
+
+    state.running = true;
+
+    while (state.running) {
+      try {
+        await register();
+        const payload = await bridgeFetch(
+          `/bridge/next?clientId=${encodeURIComponent(state.clientId)}`,
+          { method: "GET" },
+        );
+        if (payload.command) {
+          try {
+            const result = await executeCommand(payload.command);
+            await postResult(payload.command.requestId, true, result, null);
+          } catch (error) {
+            await postResult(
+              payload.command.requestId,
+              false,
+              null,
+              error instanceof Error ? error.message : String(error),
+            );
+          }
+        }
+      } catch (error) {
+        console.debug("Gemini MCP bridge poll failed:", error);
+        await sleep(POLL_BACKOFF_MS);
+      }
+    }
+  }
+
+  chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+    if (message?.type !== "popup:get_status") {
+      return false;
+    }
+
+    Promise.resolve(pageSummary())
+      .then((result) => sendResponse({ ok: true, result }))
+      .catch((error) =>
+        sendResponse({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        }),
+      );
+    return true;
+  });
+
+  window.addEventListener("focus", () => {
+    heartbeat().catch(() => {});
+  });
+
+  state.heartbeatTimer = window.setInterval(() => {
+    heartbeat().catch(() => {});
+  }, HEARTBEAT_MS);
+
+  pollLoop().catch(() => {});
+})();