@bool01master/gemini-web-mcp 1.0.0

package/src/extension-bridge.js

@@ -0,0 +1,749 @@
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+const DEFAULT_HOST = process.env.GEMINI_BRIDGE_HOST || "127.0.0.1";
+const DEFAULT_PORT = Number(process.env.GEMINI_BRIDGE_PORT || "8765");
+const DEFAULT_OUTPUT_DIR = path.resolve(
+  process.env.GEMINI_WEB_OUTPUT_DIR || "artifacts",
+);
+const CLIENT_STALE_MS = 90_000;
+const POLL_TIMEOUT_MS = 25_000;
+const COMMAND_TIMEOUT_MS = 180_000;
+
+/**
+ * Server-side safety-net: extract only the last model response from the raw
+ * text that the content script returns.  The content script may return either
+ * a clean model response (if DOM selectors matched) or a noisy full-page diff.
+ * This function handles both cases.
+ */
+function cleanResponseText(text) {
+  if (!text) return "";
+
+  // --- Try to extract the last model response via turn separators ---
+  // Gemini's conversation text contains "Gemini 说\n" / "Gemini said\n" and
+  // "你说\n" / "You said\n" markers between turns.
+  const modelMarkerRe = /\n(Gemini\s*(?:[说曰]|said))\s*\n/gi;
+  const positions = [];
+  let m;
+  while ((m = modelMarkerRe.exec(text)) !== null) {
+    positions.push(m.index + m[0].length);
+  }
+
+  if (positions.length > 0) {
+    let response = text.slice(positions[positions.length - 1]);
+
+    // Trim at next user turn
+    const userTurn = response.search(/\n(?:你[说曰]|You\s+said)\s*\n/i);
+    if (userTurn > 0) response = response.slice(0, userTurn);
+
+    // Trim footer: "工具\n" or "Gemini 是一款 AI ..."
+    const footer = response.search(
+      /\n(?:工具|Tools)\s*\n|Gemini\s*(?:是一款|is\s+a)\s*AI/i,
+    );
+    if (footer > 0) response = response.slice(0, footer);
+
+    // Trim trailing mode labels
+    response = response.replace(/\n(?:快速|思考)\s*$/i, "");
+
+    response = response.trim();
+    if (response.length > 3) return response;
+  }
+
+  // --- Fallback: just strip known noise ---
+  text = text.replace(/\n?Gemini\s*(?:是一款|is\s+a)\s*AI.*$/is, "");
+  text = text.replace(/\n(?:快速|思考|工具|Tools)\s*$/i, "");
+  text = text.replace(/^Gemini\s*[说曰]\s*/i, "");
+
+  return text.trim();
+}
+
+function ensureJsonHeaders(response, statusCode = 200) {
+  response.writeHead(statusCode, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Content-Type",
+    "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+}
+
+async function readJsonBody(request) {
+  const chunks = [];
+
+  for await (const chunk of request) {
+    chunks.push(chunk);
+  }
+
+  const raw = Buffer.concat(chunks).toString("utf8");
+  return raw ? JSON.parse(raw) : {};
+}
+
+function now() {
+  return Date.now();
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48) || "prompt";
+}
+
+function makeTimestamp() {
+  const value = new Date();
+  const pad = (input) => String(input).padStart(2, "0");
+  return [
+    value.getFullYear(),
+    pad(value.getMonth() + 1),
+    pad(value.getDate()),
+    "-",
+    pad(value.getHours()),
+    pad(value.getMinutes()),
+    pad(value.getSeconds()),
+  ].join("");
+}
+
+function commandTimeoutForWait(waitTimeoutMs, explicitTimeoutMs) {
+  if (explicitTimeoutMs) {
+    return explicitTimeoutMs;
+  }
+
+  return Math.max(Number(waitTimeoutMs || 0) + 30_000, COMMAND_TIMEOUT_MS);
+}
+
+export class GeminiExtensionBridge {
+  constructor(options = {}) {
+    this.host = options.host || DEFAULT_HOST;
+    this.port = options.port || DEFAULT_PORT;
+    this.outputDir = path.resolve(options.outputDir || DEFAULT_OUTPUT_DIR);
+    this.server = null;
+    this.clients = new Map();
+    this.pendingCommands = new Map();
+  }
+
+  async start() {
+    if (this.server) {
+      return;
+    }
+
+    await fs.mkdir(this.outputDir, { recursive: true });
+
+    this.server = http.createServer(async (request, response) => {
+      try {
+        await this.handleRequest(request, response);
+      } catch (error) {
+        ensureJsonHeaders(response, 500);
+        response.end(
+          JSON.stringify({
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+          }),
+        );
+      }
+    });
+
+    await new Promise((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.port, this.host, () => {
+        this.server.off("error", reject);
+        resolve();
+      });
+    });
+  }
+
+  async close() {
+    for (const client of this.clients.values()) {
+      this.clearPendingPoll(client);
+    }
+
+    for (const pending of this.pendingCommands.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Bridge server closed."));
+    }
+    this.pendingCommands.clear();
+
+    if (!this.server) {
+      return;
+    }
+
+    await new Promise((resolve, reject) => {
+      this.server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        resolve();
+      });
+    });
+
+    this.server = null;
+  }
+
+  async getStatus() {
+    this.pruneStaleClients();
+
+    return {
+      ok: true,
+      host: this.host,
+      port: this.port,
+      bridgeUrl: `http://${this.host}:${this.port}`,
+      clientCount: this.clients.size,
+      clients: Array.from(this.clients.values())
+        .map((client) => ({
+          clientId: client.clientId,
+          pageUrl: client.pageUrl,
+          title: client.title,
+          connectedAt: client.connectedAt,
+          lastSeenAt: client.lastSeenAt,
+          lastHeartbeat: client.lastHeartbeat,
+          capabilities: client.capabilities,
+          lastKnownState: client.lastKnownState,
+        }))
+        .sort((left, right) => right.lastSeenAt - left.lastSeenAt),
+    };
+  }
+
+  async runCommand(name, args = {}, options = {}) {
+    this.pruneStaleClients();
+
+    const client = this.selectClient(options.targetClientId);
+    if (!client) {
+      throw new Error(
+        [
+          "No Gemini extension client is connected.",
+          "Load the unpacked extension from `extension/` and keep a Gemini tab open.",
+        ].join(" "),
+      );
+    }
+
+    const requestId = randomUUID();
+    const timeoutMs = options.timeoutMs || COMMAND_TIMEOUT_MS;
+    const payload = {
+      requestId,
+      name,
+      args,
+      issuedAt: new Date().toISOString(),
+    };
+
+    const result = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingCommands.delete(requestId);
+        reject(
+          new Error(
+            `Timed out waiting for extension response to command ${name}.`,
+          ),
+        );
+      }, timeoutMs);
+
+      this.pendingCommands.set(requestId, {
+        requestId,
+        clientId: client.clientId,
+        resolve,
+        reject,
+        timer,
+      });
+    });
+
+    client.commandQueue.push(payload);
+    this.flushPendingPoll(client);
+
+    return result;
+  }
+
+  async finalizeRunResult(prompt, rawResult, options = {}) {
+    const outputDir = path.resolve(options.outputDir || this.outputDir);
+    const runDir = path.join(
+      outputDir,
+      `${makeTimestamp()}-${slugify(prompt)}`,
+    );
+    await fs.mkdir(runDir, { recursive: true });
+
+    const savedImages = [];
+    const images = Array.isArray(rawResult.images) ? rawResult.images : [];
+    const remoteImages = [];
+
+    for (const [index, image] of images.entries()) {
+      if (image?.url) {
+        remoteImages.push({
+          url: image.url,
+          width: image.width ?? null,
+          height: image.height ?? null,
+          alt: image.alt || "",
+          tagName: image.tagName || "",
+          error: image.error || null,
+        });
+      }
+
+      if (!image?.dataUrl || typeof image.dataUrl !== "string") {
+        continue;
+      }
+
+      const extension = this.extensionFromDataUrl(image.dataUrl);
+      const targetPath = path.join(runDir, `image-${index + 1}.${extension}`);
+      await fs.writeFile(targetPath, this.bufferFromDataUrl(image.dataUrl));
+      savedImages.push({
+        path: targetPath,
+        url: image.url || null,
+        mimeType: this.mimeTypeFromDataUrl(image.dataUrl),
+        width: image.width ?? null,
+        height: image.height ?? null,
+        alt: image.alt || "",
+        tagName: image.tagName || "",
+      });
+    }
+
+    const imageUrls = Array.from(
+      new Set(
+        [
+          ...savedImages.map((item) => item.url).filter(Boolean),
+          ...remoteImages.map((item) => item.url).filter(Boolean),
+        ],
+      ),
+    );
+
+    let downloadResult = null;
+    if (
+      imageUrls.length > 0 &&
+      options.downloadRemoteImages !== false
+    ) {
+      try {
+        downloadResult = await this.runCommand(
+          "download_image_urls",
+          { urls: imageUrls },
+          {
+            targetClientId: options.targetClientId,
+            timeoutMs: Math.max(60_000, imageUrls.length * 20_000),
+          },
+        );
+      } catch (error) {
+        downloadResult = {
+          downloads: imageUrls.map((url) => ({
+            url,
+            dataUrl: null,
+            error: error instanceof Error ? error.message : String(error),
+          })),
+        };
+      }
+    }
+
+    const downloadedImages = Array.isArray(downloadResult?.downloads)
+      ? downloadResult.downloads
+      : [];
+
+    for (const download of downloadedImages) {
+      if (!download?.url) {
+        continue;
+      }
+
+      const remoteImage = remoteImages.find((item) => item.url === download.url);
+      if (remoteImage) {
+        remoteImage.downloadError = download.error || null;
+      }
+
+      if (!download?.dataUrl || typeof download.dataUrl !== "string") {
+        continue;
+      }
+
+      const extension = this.extensionFromDataUrl(download.dataUrl);
+      const targetPath = path.join(
+        runDir,
+        `image-${savedImages.length + 1}.${extension}`,
+      );
+      await fs.writeFile(targetPath, this.bufferFromDataUrl(download.dataUrl));
+
+      const metadata = remoteImage || {};
+      savedImages.push({
+        path: targetPath,
+        url: download.url,
+        mimeType: this.mimeTypeFromDataUrl(download.dataUrl),
+        width: metadata.width ?? null,
+        height: metadata.height ?? null,
+        alt: metadata.alt || "",
+        tagName: metadata.tagName || "",
+      });
+
+      if (remoteImage) {
+        remoteImage.downloadPath = targetPath;
+      }
+    }
+
+    // For images that have URLs but failed to save locally, generate curl commands.
+    // Note: Gemini gg-dl URLs require authentication and curl may return 403.
+    const savedUrlSet = new Set(savedImages.map((item) => item.url).filter(Boolean));
+    const unsavedUrls = imageUrls.filter((url) => !savedUrlSet.has(url));
+    const curlCommands = unsavedUrls.map((url, i) => {
+      const ext = url.match(/\.(png|jpe?g|gif|webp|svg)/i)?.[1] || "png";
+      const outFile = path.join(runDir, `image-curl-${i + 1}.${ext}`);
+      return `curl -L -o '${outFile}' '${url}'`;
+    });
+
+    const result = {
+      prompt,
+      ready: Boolean(rawResult.ready),
+      url: rawResult.url || "",
+      mode: rawResult.mode || null,
+      text: cleanResponseText(rawResult.text || ""),
+      imageCountOnPage: Number(rawResult.imageCountOnPage || 0),
+      imagePaths: savedImages.map((item) => item.path),
+      curlCommands,
+      runDir,
+    };
+
+    // Full detail saved to disk for debugging; MCP result stays lean.
+    const detailedResult = {
+      ...result,
+      title: rawResult.title || "",
+      modeResult: rawResult.modeResult || null,
+      attachmentResult: rawResult.attachmentResult || null,
+      images: savedImages,
+      imageUrls,
+      remoteImages,
+      outputDir,
+    };
+
+    await fs.writeFile(
+      path.join(runDir, "result.json"),
+      JSON.stringify(detailedResult, null, 2),
+      "utf8",
+    );
+
+    return result;
+  }
+
+  async readLocalImages(imagePaths = []) {
+    const results = [];
+
+    for (const imagePath of imagePaths) {
+      const absolutePath = path.resolve(imagePath);
+      const buffer = await fs.readFile(absolutePath);
+      const mimeType = this.mimeTypeFromPath(absolutePath);
+
+      results.push({
+        path: absolutePath,
+        name: path.basename(absolutePath),
+        mimeType,
+        base64: buffer.toString("base64"),
+      });
+    }
+
+    return results;
+  }
+
+  async handleRequest(request, response) {
+    const url = new URL(request.url || "/", `http://${this.host}:${this.port}`);
+
+    if (request.method === "OPTIONS") {
+      ensureJsonHeaders(response, 204);
+      response.end();
+      return;
+    }
+
+    if (request.method === "GET" && url.pathname === "/health") {
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify(await this.getStatus()));
+      return;
+    }
+
+    if (request.method === "GET" && url.pathname === "/debug/page-status") {
+      const result = await this.runCommand("get_status", {}, { timeoutMs: 20_000 });
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify({ ok: true, result }));
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/debug/command") {
+      const payload = await readJsonBody(request);
+      const result = await this.runCommand(payload.name, payload.args || {}, {
+        timeoutMs: payload.timeoutMs,
+        targetClientId: payload.targetClientId,
+      });
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify({ ok: true, result }));
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/debug/run-prompt") {
+      const payload = await readJsonBody(request);
+      const preparedImages = await this.readLocalImages(payload.images || []);
+      const rawResult = await this.runCommand(
+        "run_prompt",
+        {
+          prompt: payload.prompt,
+          mode: payload.mode,
+          images: preparedImages,
+          newChat: payload.newChat,
+          waitTimeoutMs: payload.waitTimeoutMs,
+          maxImages: payload.maxImages,
+        },
+        {
+          timeoutMs: commandTimeoutForWait(
+            payload.waitTimeoutMs,
+            payload.timeoutMs,
+          ),
+          targetClientId: payload.targetClientId,
+        },
+      );
+      const result = await this.finalizeRunResult(payload.prompt, rawResult, {
+        outputDir: payload.outputDir,
+        targetClientId: payload.targetClientId,
+      });
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify({ ok: true, result }));
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/debug/capture-images") {
+      const payload = await readJsonBody(request);
+      const rawResult = await this.runCommand(
+        "capture_images",
+        {
+          maxImages: payload.maxImages,
+        },
+        {
+          timeoutMs: payload.timeoutMs || 60_000,
+          targetClientId: payload.targetClientId,
+        },
+      );
+      const result = await this.finalizeRunResult(
+        payload.label || "capture-images",
+        rawResult,
+        {
+          outputDir: payload.outputDir,
+          targetClientId: payload.targetClientId,
+        },
+      );
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify({ ok: true, result }));
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/bridge/register") {
+      const payload = await readJsonBody(request);
+      const client = this.upsertClient(payload);
+      ensureJsonHeaders(response, 200);
+      response.end(
+        JSON.stringify({
+          ok: true,
+          clientId: client.clientId,
+          pollTimeoutMs: POLL_TIMEOUT_MS,
+        }),
+      );
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/bridge/heartbeat") {
+      const payload = await readJsonBody(request);
+      const client = this.upsertClient(payload);
+      client.lastHeartbeat = new Date().toISOString();
+      client.lastKnownState = payload.state || client.lastKnownState || null;
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify({ ok: true }));
+      return;
+    }
+
+    if (request.method === "GET" && url.pathname === "/bridge/next") {
+      const clientId = url.searchParams.get("clientId");
+      if (!clientId) {
+        ensureJsonHeaders(response, 400);
+        response.end(JSON.stringify({ ok: false, error: "Missing clientId." }));
+        return;
+      }
+
+      const client = this.clients.get(clientId);
+      if (!client) {
+        ensureJsonHeaders(response, 404);
+        response.end(JSON.stringify({ ok: false, error: "Unknown clientId." }));
+        return;
+      }
+
+      client.lastSeenAt = now();
+
+      if (client.commandQueue.length > 0) {
+        ensureJsonHeaders(response, 200);
+        response.end(JSON.stringify({ ok: true, command: client.commandQueue.shift() }));
+        return;
+      }
+
+      this.clearPendingPoll(client);
+      client.pendingPoll = {
+        response,
+        timer: setTimeout(() => {
+          if (client.pendingPoll?.response === response) {
+            ensureJsonHeaders(response, 200);
+            response.end(JSON.stringify({ ok: true, command: null }));
+            client.pendingPoll = null;
+          }
+        }, POLL_TIMEOUT_MS),
+      };
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/bridge/result") {
+      const payload = await readJsonBody(request);
+      const client = this.clients.get(payload.clientId);
+      if (client) {
+        client.lastSeenAt = now();
+        client.lastKnownState = payload.result || client.lastKnownState || null;
+      }
+
+      const pending = this.pendingCommands.get(payload.requestId);
+      if (!pending) {
+        ensureJsonHeaders(response, 404);
+        response.end(
+          JSON.stringify({ ok: false, error: "Unknown requestId." }),
+        );
+        return;
+      }
+
+      clearTimeout(pending.timer);
+      this.pendingCommands.delete(payload.requestId);
+
+      ensureJsonHeaders(response, 200);
+      response.end(JSON.stringify({ ok: true }));
+
+      if (payload.ok === false) {
+        pending.reject(
+          new Error(payload.error || "Extension command failed without details."),
+        );
+        return;
+      }
+
+      pending.resolve(payload.result || {});
+      return;
+    }
+
+    ensureJsonHeaders(response, 404);
+    response.end(JSON.stringify({ ok: false, error: "Not found." }));
+  }
+
+  upsertClient(payload = {}) {
+    const clientId = payload.clientId || randomUUID();
+    const existing = this.clients.get(clientId);
+    const client =
+      existing ||
+      {
+        clientId,
+        connectedAt: new Date().toISOString(),
+        lastSeenAt: now(),
+        lastHeartbeat: null,
+        pageUrl: "",
+        title: "",
+        capabilities: {},
+        commandQueue: [],
+        pendingPoll: null,
+        lastKnownState: null,
+      };
+
+    client.pageUrl = payload.pageUrl || client.pageUrl;
+    client.title = payload.title || client.title;
+    client.capabilities = payload.capabilities || client.capabilities;
+    client.lastSeenAt = now();
+
+    this.clients.set(clientId, client);
+    return client;
+  }
+
+  selectClient(targetClientId) {
+    if (targetClientId) {
+      return this.clients.get(targetClientId) || null;
+    }
+
+    return Array.from(this.clients.values())
+      .sort((left, right) => {
+        const leftState = left.lastKnownState || {};
+        const rightState = right.lastKnownState || {};
+        const leftScore =
+          (leftState.visibilityState === "visible" ? 2 : 0) +
+          (leftState.hasFocus ? 1 : 0);
+        const rightScore =
+          (rightState.visibilityState === "visible" ? 2 : 0) +
+          (rightState.hasFocus ? 1 : 0);
+
+        if (rightScore !== leftScore) {
+          return rightScore - leftScore;
+        }
+
+        return right.lastSeenAt - left.lastSeenAt;
+      })
+      .find((client) => /gemini\.google\.com/i.test(client.pageUrl));
+  }
+
+  flushPendingPoll(client) {
+    if (!client.pendingPoll || client.commandQueue.length === 0) {
+      return;
+    }
+
+    const { response } = client.pendingPoll;
+    clearTimeout(client.pendingPoll.timer);
+    client.pendingPoll = null;
+    ensureJsonHeaders(response, 200);
+    response.end(JSON.stringify({ ok: true, command: client.commandQueue.shift() }));
+  }
+
+  clearPendingPoll(client) {
+    if (!client?.pendingPoll) {
+      return;
+    }
+
+    clearTimeout(client.pendingPoll.timer);
+    try {
+      ensureJsonHeaders(client.pendingPoll.response, 200);
+      client.pendingPoll.response.end(JSON.stringify({ ok: true, command: null }));
+    } catch {
+      // Ignore broken client connections during shutdown.
+    }
+    client.pendingPoll = null;
+  }
+
+  pruneStaleClients() {
+    for (const [clientId, client] of this.clients.entries()) {
+      if (now() - client.lastSeenAt <= CLIENT_STALE_MS) {
+        continue;
+      }
+
+      this.clearPendingPoll(client);
+      this.clients.delete(clientId);
+    }
+  }
+
+  bufferFromDataUrl(dataUrl) {
+    const [, base64] = dataUrl.split(",", 2);
+    return Buffer.from(base64, "base64");
+  }
+
+  mimeTypeFromDataUrl(dataUrl) {
+    const match = /^data:([^;]+);base64,/i.exec(dataUrl);
+    return match?.[1] || "application/octet-stream";
+  }
+
+  extensionFromDataUrl(dataUrl) {
+    const mimeType = this.mimeTypeFromDataUrl(dataUrl);
+    return {
+      "image/png": "png",
+      "image/jpeg": "jpg",
+      "image/webp": "webp",
+      "image/gif": "gif",
+    }[mimeType] || "bin";
+  }
+
+  mimeTypeFromPath(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    return (
+      {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+        ".bmp": "image/bmp",
+        ".heic": "image/heic",
+        ".heif": "image/heif",
+        ".svg": "image/svg+xml",
+      }[extension] || "application/octet-stream"
+    );
+  }
+}