@bool01master/gemini-web-mcp 1.0.0

package/src/gemini-web-client.js

@@ -0,0 +1,678 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { chromium } from "playwright-core";
+
+const GEMINI_URL = "https://gemini.google.com/";
+const DEFAULT_CHROME_PATH =
+  process.env.GEMINI_WEB_CHROME_PATH ||
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+const DEFAULT_USER_DATA_DIR = path.resolve(
+  process.env.GEMINI_WEB_USER_DATA_DIR ||
+    process.env.GEMINI_WEB_PROFILE_DIR ||
+    ".chrome-profile",
+);
+const DEFAULT_PROFILE_NAME = process.env.GEMINI_WEB_PROFILE_NAME || "Default";
+const DEFAULT_OUTPUT_DIR = path.resolve(
+  process.env.GEMINI_WEB_OUTPUT_DIR || "artifacts",
+);
+const DEFAULT_PROXY_SERVER =
+  process.env.GEMINI_WEB_PROXY_SERVER ||
+  process.env.ALL_PROXY ||
+  process.env.all_proxy ||
+  process.env.HTTPS_PROXY ||
+  process.env.https_proxy ||
+  process.env.HTTP_PROXY ||
+  process.env.http_proxy ||
+  "";
+const DEFAULT_REMOTE_DEBUGGING_PORT =
+  process.env.GEMINI_WEB_REMOTE_DEBUGGING_PORT || "";
+const DEFAULT_CDP_URL =
+  process.env.GEMINI_WEB_CDP_URL ||
+  (DEFAULT_REMOTE_DEBUGGING_PORT
+    ? `http://127.0.0.1:${DEFAULT_REMOTE_DEBUGGING_PORT}`
+    : "");
+const VIEWPORT = { width: 1440, height: 1100 };
+const COMPOSER_SELECTORS = [
+  'textarea',
+  '[role="textbox"]',
+  '[contenteditable="true"]',
+  'div[contenteditable="true"]',
+];
+const SEND_BUTTON_NAMES = [/^send$/i, /send message/i, /发送/, /提交/];
+const LOGIN_BUTTON_NAMES = [/sign in/i, /login/i, /登录/, /登入/];
+const NEW_CHAT_BUTTON_NAMES = [/new chat/i, /new conversation/i, /新对话/, /新聊天/];
+const STOP_BUTTON_NAMES = [/stop/i, /停止/, /cancel/i, /取消/];
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeWhitespace(text) {
+  return text
+    .replace(/\u00a0/g, " ")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48) || "prompt";
+}
+
+function makeTimestamp() {
+  const now = new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return [
+    now.getFullYear(),
+    pad(now.getMonth() + 1),
+    pad(now.getDate()),
+    "-",
+    pad(now.getHours()),
+    pad(now.getMinutes()),
+    pad(now.getSeconds()),
+  ].join("");
+}
+
+function dataUrlToBuffer(dataUrl) {
+  const [, base64] = dataUrl.split(",", 2);
+  return Buffer.from(base64, "base64");
+}
+
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+async function firstVisibleLocator(page, selectors, options = {}) {
+  const minWidth = options.minWidth ?? 120;
+  const minHeight = options.minHeight ?? 24;
+  const maxPerSelector = options.maxPerSelector ?? 10;
+  const candidates = [];
+
+  for (const selector of selectors) {
+    const locator = page.locator(selector);
+    const count = Math.min(await locator.count(), maxPerSelector);
+
+    for (let index = 0; index < count; index += 1) {
+      const item = locator.nth(index);
+      const visible = await item.isVisible().catch(() => false);
+      if (!visible) {
+        continue;
+      }
+
+      const box = await item.boundingBox().catch(() => null);
+      if (!box || box.width < minWidth || box.height < minHeight) {
+        continue;
+      }
+
+      candidates.push({ box, item });
+    }
+  }
+
+  candidates.sort(
+    (left, right) =>
+      right.box.y + right.box.height - (left.box.y + left.box.height),
+  );
+
+  return candidates[0]?.item || null;
+}
+
+async function firstVisibleButton(page, namePatterns) {
+  for (const pattern of namePatterns) {
+    const button = page.getByRole("button", { name: pattern }).first();
+    const visible = await button.isVisible().catch(() => false);
+    if (visible) {
+      return button;
+    }
+  }
+
+  return null;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export class GeminiWebClient {
+  constructor(options = {}) {
+    this.chromePath = options.chromePath || DEFAULT_CHROME_PATH;
+    this.userDataDir = path.resolve(
+      options.userDataDir || options.profileDir || DEFAULT_USER_DATA_DIR,
+    );
+    this.profileName = options.profileName || DEFAULT_PROFILE_NAME;
+    this.outputDir = path.resolve(options.outputDir || DEFAULT_OUTPUT_DIR);
+    this.proxyServer = options.proxyServer || DEFAULT_PROXY_SERVER;
+    this.cdpUrl = options.cdpUrl || DEFAULT_CDP_URL;
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.headless = null;
+    this.connectionMode = "launch";
+  }
+
+  async openSession(options = {}) {
+    const headless = options.headless ?? false;
+    await this.ensurePage({ headless });
+
+    return this.getLoginStatus();
+  }
+
+  async getLoginStatus() {
+    if (!this.context) {
+      await this.ensurePage({ headless: false });
+    }
+
+    const composer = await this.findComposer();
+    const page = await this.ensurePageReference();
+    const loginButton = await firstVisibleButton(page, LOGIN_BUTTON_NAMES);
+
+    return {
+      ready: Boolean(composer),
+      url: page.url(),
+      title: await page.title(),
+      headless: this.headless,
+      profileDir: this.userDataDir,
+      userDataDir: this.userDataDir,
+      profileName: this.profileName,
+      outputDir: this.outputDir,
+      loginButtonVisible: Boolean(loginButton),
+      chromePath: this.chromePath,
+      proxyServer: this.proxyServer || null,
+      cdpUrl: this.cdpUrl || null,
+      connectionMode: this.connectionMode,
+    };
+  }
+
+  async runPrompt(options) {
+    const prompt = options.prompt?.trim();
+    if (!prompt) {
+      throw new Error("`prompt` cannot be empty.");
+    }
+
+    const headless = options.headless ?? false;
+    const waitTimeoutMs = options.waitTimeoutMs ?? 120000;
+    const maxImages = options.maxImages ?? 4;
+    const newChat = options.newChat ?? true;
+    const takeScreenshot = options.takeScreenshot ?? true;
+
+    await this.ensurePage({ headless });
+    await this.navigateHome();
+
+    const status = await this.getLoginStatus();
+    if (!status.ready) {
+      throw new Error(
+        [
+          "Gemini session is not logged in yet.",
+          `Chrome user data dir: ${this.userDataDir}`,
+          `Chrome profile name: ${this.profileName}`,
+          "Run `gemini_open_session`, sign in in the opened window, then retry.",
+        ].join(" "),
+      );
+    }
+
+    if (newChat) {
+      await this.tryOpenNewChat();
+    }
+
+    const page = await this.ensurePageReference();
+    const composer = await this.findComposer();
+    if (!composer) {
+      throw new Error(
+        "Unable to find the Gemini prompt input box. The page layout may have changed.",
+      );
+    }
+
+    const beforeState = await this.capturePageState();
+
+    await composer.click({ force: true }).catch(async () => composer.click());
+    await page.keyboard.press("Meta+A").catch(() => {});
+    await page.keyboard.press("Backspace").catch(() => {});
+    await composer.pressSequentially(prompt, { delay: 14 });
+
+    const started = await this.sendPromptAndWaitForStart(beforeState);
+    if (!started) {
+      throw new Error(
+        "The prompt was typed, but Gemini did not appear to start responding.",
+      );
+    }
+
+    const finalState = await this.waitForResponseCompletion(
+      beforeState,
+      waitTimeoutMs,
+    );
+    const runDir = await this.createRunDir(prompt);
+    const screenshotPath = takeScreenshot
+      ? path.join(runDir, "page.png")
+      : null;
+
+    if (screenshotPath) {
+      await page.screenshot({ path: screenshotPath, fullPage: true });
+    }
+
+    const imagePaths = await this.extractVisibleImages({ runDir, maxImages });
+    const result = {
+      prompt,
+      ready: true,
+      title: await page.title(),
+      url: page.url(),
+      text: finalState.text,
+      textLength: finalState.textLength,
+      imageCountOnPage: finalState.imageCount,
+      imagePaths,
+      screenshotPath,
+      runDir,
+      profileDir: this.userDataDir,
+      userDataDir: this.userDataDir,
+      profileName: this.profileName,
+      outputDir: this.outputDir,
+      headless: this.headless,
+      hostname: os.hostname(),
+      proxyServer: this.proxyServer || null,
+      cdpUrl: this.cdpUrl || null,
+      connectionMode: this.connectionMode,
+    };
+
+    await fs.writeFile(
+      path.join(runDir, "result.json"),
+      JSON.stringify(result, null, 2),
+      "utf8",
+    );
+
+    return result;
+  }
+
+  async closeSession() {
+    if (this.context) {
+      if (this.browser) {
+        await this.browser.close();
+      } else {
+        await this.context.close();
+      }
+    }
+
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.headless = null;
+    this.connectionMode = "launch";
+
+    return {
+      closed: true,
+      profileDir: this.userDataDir,
+      userDataDir: this.userDataDir,
+      profileName: this.profileName,
+      outputDir: this.outputDir,
+      proxyServer: this.proxyServer || null,
+      cdpUrl: this.cdpUrl || null,
+      connectionMode: this.connectionMode,
+    };
+  }
+
+  async ensurePage(options = {}) {
+    const headless = options.headless ?? false;
+
+    if (this.context) {
+      await this.ensurePageReference();
+      if (!headless) {
+        await this.page.bringToFront().catch(() => {});
+      }
+      return this.page;
+    }
+
+    if (this.cdpUrl) {
+      this.browser = await chromium.connectOverCDP(this.cdpUrl);
+      this.connectionMode = "cdp";
+      this.context = this.browser.contexts()[0];
+      if (!this.context) {
+        throw new Error(
+          `No default browser context was available at ${this.cdpUrl}.`,
+        );
+      }
+
+      this.context.on("page", (page) => {
+        this.page = page;
+      });
+
+      this.page =
+        this.context
+          .pages()
+          .find((page) => /gemini\.google\.com/i.test(page.url())) ||
+        this.context.pages()[0] ||
+        (await this.context.newPage());
+      this.page.setDefaultTimeout(30000);
+      this.page.setDefaultNavigationTimeout(120000);
+      this.headless = false;
+      return this.page;
+    }
+
+    if (!(await pathExists(this.chromePath))) {
+      throw new Error(
+        `Chrome executable not found at ${this.chromePath}. Set GEMINI_WEB_CHROME_PATH if needed.`,
+      );
+    }
+
+    await ensureDir(this.userDataDir);
+    await ensureDir(this.outputDir);
+
+    this.context = await chromium.launchPersistentContext(this.userDataDir, {
+      headless,
+      executablePath: this.chromePath,
+      proxy: this.proxyServer ? { server: this.proxyServer } : undefined,
+      viewport: VIEWPORT,
+      acceptDownloads: true,
+      args: [
+        "--no-first-run",
+        "--disable-default-browser-check",
+        `--profile-directory=${this.profileName}`,
+      ],
+    });
+    this.connectionMode = "launch";
+    this.headless = headless;
+
+    this.context.on("page", (page) => {
+      this.page = page;
+    });
+
+    this.page = this.context.pages()[0] || (await this.context.newPage());
+    this.page.setDefaultTimeout(30000);
+    this.page.setDefaultNavigationTimeout(120000);
+
+    await this.navigateHome();
+    if (!headless) {
+      await this.page.bringToFront().catch(() => {});
+    }
+
+    return this.page;
+  }
+
+  async ensurePageReference() {
+    if (!this.context) {
+      throw new Error("Browser session is not open.");
+    }
+
+    if (!this.page || this.page.isClosed()) {
+      this.page =
+        this.context.pages().find((page) => !page.isClosed()) ||
+        (await this.context.newPage());
+      this.page.setDefaultTimeout(30000);
+      this.page.setDefaultNavigationTimeout(120000);
+    }
+
+    return this.page;
+  }
+
+  async navigateHome() {
+    const page = await this.ensurePageReference();
+    await page.goto(GEMINI_URL, {
+      waitUntil: "commit",
+      timeout: 120000,
+    });
+    await sleep(2500);
+  }
+
+  async findComposer() {
+    const page = await this.ensurePageReference();
+    return firstVisibleLocator(page, COMPOSER_SELECTORS, {
+      minWidth: 160,
+      minHeight: 24,
+      maxPerSelector: 12,
+    });
+  }
+
+  async tryOpenNewChat() {
+    const page = await this.ensurePageReference();
+    const button = await firstVisibleButton(page, NEW_CHAT_BUTTON_NAMES);
+
+    if (!button) {
+      return false;
+    }
+
+    await button.click().catch(() => {});
+    await sleep(1500);
+    return true;
+  }
+
+  async sendPromptAndWaitForStart(beforeState) {
+    const page = await this.ensurePageReference();
+
+    const sendButton = await firstVisibleButton(page, SEND_BUTTON_NAMES);
+    if (sendButton) {
+      await sendButton.click().catch(() => {});
+    } else {
+      await page.keyboard.press("Enter").catch(() => {});
+    }
+
+    if (await this.waitForResponseStart(beforeState, 8000)) {
+      return true;
+    }
+
+    if (!sendButton) {
+      const secondTryButton = await firstVisibleButton(page, SEND_BUTTON_NAMES);
+      if (secondTryButton) {
+        await secondTryButton.click().catch(() => {});
+        if (await this.waitForResponseStart(beforeState, 8000)) {
+          return true;
+        }
+      }
+    }
+
+    await page.keyboard.press("Meta+Enter").catch(() => {});
+    return this.waitForResponseStart(beforeState, 8000);
+  }
+
+  async waitForResponseStart(beforeState, timeoutMs) {
+    const startedAt = Date.now();
+
+    while (Date.now() - startedAt < timeoutMs) {
+      const state = await this.capturePageState();
+      const changed =
+        state.textLength > beforeState.textLength + 20 ||
+        state.imageCount > beforeState.imageCount ||
+        state.stopVisible;
+
+      if (changed) {
+        return true;
+      }
+
+      await sleep(1000);
+    }
+
+    return false;
+  }
+
+  async waitForResponseCompletion(beforeState, timeoutMs) {
+    const startedAt = Date.now();
+    let stableSignature = "";
+    let stableMs = 0;
+
+    while (Date.now() - startedAt < timeoutMs) {
+      const state = await this.capturePageState();
+      const changed =
+        state.textLength > beforeState.textLength + 20 ||
+        state.imageCount > beforeState.imageCount;
+
+      if (!changed) {
+        await sleep(1200);
+        continue;
+      }
+
+      const signature = JSON.stringify({
+        textTail: state.text.slice(-1200),
+        imageCount: state.imageCount,
+        stopVisible: state.stopVisible,
+      });
+
+      if (signature === stableSignature) {
+        stableMs += 1200;
+      } else {
+        stableSignature = signature;
+        stableMs = 0;
+      }
+
+      if (stableMs >= 4800 && !state.stopVisible) {
+        return state;
+      }
+
+      await sleep(1200);
+    }
+
+    return this.capturePageState();
+  }
+
+  async capturePageState() {
+    const page = await this.ensurePageReference();
+
+    return page.evaluate(
+      ({ stopPatterns }) => {
+        const root =
+          document.querySelector("main, [role='main']") || document.body;
+
+        const isVisible = (element) => {
+          const rect = element.getBoundingClientRect();
+          const style = window.getComputedStyle(element);
+          return (
+            rect.width >= 100 &&
+            rect.height >= 40 &&
+            style.display !== "none" &&
+            style.visibility !== "hidden" &&
+            style.opacity !== "0"
+          );
+        };
+
+        const text = normalize(root.innerText || document.body.innerText || "");
+        const imageCount = Array.from(document.querySelectorAll("img, canvas")).filter(
+          (element) => isVisible(element),
+        ).length;
+        const visibleButtons = Array.from(document.querySelectorAll("button"))
+          .map(
+            (button) =>
+              (button.innerText || button.getAttribute("aria-label") || "").trim(),
+          )
+          .filter(Boolean)
+          .slice(-40);
+        const stopVisible = visibleButtons.some((label) =>
+          stopPatterns.some((pattern) => new RegExp(pattern, "i").test(label)),
+        );
+
+        return {
+          text: text.slice(-20000),
+          textLength: text.length,
+          imageCount,
+          visibleButtons,
+          stopVisible,
+        };
+
+        function normalize(value) {
+          return value
+            .replace(/\u00a0/g, " ")
+            .replace(/[ \t]+\n/g, "\n")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim();
+        }
+      },
+      {
+        stopPatterns: STOP_BUTTON_NAMES.map((pattern) => pattern.source),
+      },
+    );
+  }
+
+  async createRunDir(prompt) {
+    const runDir = path.join(
+      this.outputDir,
+      `${makeTimestamp()}-${slugify(prompt)}`,
+    );
+    await ensureDir(runDir);
+    return runDir;
+  }
+
+  async extractVisibleImages({ runDir, maxImages }) {
+    const page = await this.ensurePageReference();
+    const images = await page.evaluate(async (limit) => {
+      const isVisible = (element) => {
+        const rect = element.getBoundingClientRect();
+        const style = window.getComputedStyle(element);
+        return (
+          rect.width >= 180 &&
+          rect.height >= 180 &&
+          style.display !== "none" &&
+          style.visibility !== "hidden" &&
+          style.opacity !== "0"
+        );
+      };
+
+      const score = (element) => {
+        const rect = element.getBoundingClientRect();
+        return rect.bottom * 100000 + rect.width * rect.height;
+      };
+
+      const nodes = Array.from(document.querySelectorAll("img, canvas"))
+        .filter((element) => isVisible(element))
+        .sort((left, right) => score(right) - score(left))
+        .slice(0, limit);
+
+      const results = [];
+
+      for (const element of nodes) {
+        const rect = element.getBoundingClientRect();
+        let dataUrl = null;
+        let error = null;
+
+        try {
+          if (element instanceof HTMLCanvasElement) {
+            dataUrl = element.toDataURL("image/png");
+          } else if (element instanceof HTMLImageElement) {
+            if (element.src.startsWith("data:image/")) {
+              dataUrl = element.src;
+            } else {
+              const canvas = document.createElement("canvas");
+              const width = element.naturalWidth || Math.round(rect.width);
+              const height = element.naturalHeight || Math.round(rect.height);
+              canvas.width = width;
+              canvas.height = height;
+              const context = canvas.getContext("2d");
+              context.drawImage(element, 0, 0, width, height);
+              dataUrl = canvas.toDataURL("image/png");
+            }
+          }
+        } catch (caughtError) {
+          error = String(caughtError);
+        }
+
+        results.push({
+          dataUrl,
+          width: Math.round(rect.width),
+          height: Math.round(rect.height),
+          tagName: element.tagName.toLowerCase(),
+          alt: element.alt || "",
+          error,
+        });
+      }
+
+      return results;
+    }, maxImages);
+
+    const savedPaths = [];
+
+    for (const [index, image] of images.entries()) {
+      if (!image.dataUrl) {
+        continue;
+      }
+
+      const targetPath = path.join(runDir, `image-${index + 1}.png`);
+      await fs.writeFile(targetPath, dataUrlToBuffer(image.dataUrl));
+      savedPaths.push(targetPath);
+    }
+
+    return savedPaths;
+  }
+}