@bool01master/gemini-web-mcp 1.0.0

package/src/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+import { createApp } from "./server.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const extensionPath = path.resolve(here, "../extension");
+
+function maybeHandleCliArgs() {
+  const args = new Set(process.argv.slice(2));
+
+  if (args.has("--extension-path")) {
+    console.log(extensionPath);
+    return true;
+  }
+
+  if (args.has("--help") || args.has("-h")) {
+    console.log(`gemini-web-mcp
+
+Usage:
+  gemini-web-mcp                 Start the MCP stdio server
+  gemini-web-mcp --extension-path  Print the unpacked Chrome extension path
+  gemini-web-mcp --help            Show this help
+`);
+    return true;
+  }
+
+  return false;
+}
+
+async function main() {
+  if (maybeHandleCliArgs()) {
+    return;
+  }
+
+  const app = await createApp({ startBridge: true });
+  const transport = new StdioServerTransport();
+  await app.server.connect(transport);
+
+  const shutdown = async () => {
+    await app.close().catch(() => {});
+    process.exit(0);
+  };
+
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, shutdown);
+  }
+}
+
+main().catch(async (error) => {
+  console.error("Gemini web MCP failed:", error);
+  process.exit(1);
+});

package/src/server.js

@@ -0,0 +1,272 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod/v4";
+
+import { GeminiExtensionBridge } from "./extension-bridge.js";
+
+export const TOOL_NAMES = [
+  "gemini_bridge_status",
+  "gemini_page_status",
+  "gemini_capture_images",
+  "gemini_run_prompt",
+];
+
+function formatSummary(result) {
+  const lines = [];
+
+  if (typeof result.clientCount === "number") {
+    lines.push(`Connected extension clients: ${result.clientCount}`);
+  }
+
+  if ("ready" in result) {
+    lines.push(
+      result.ready
+        ? "Gemini session is ready."
+        : "Gemini session needs manual login.",
+    );
+  }
+
+  if (result.bridgeUrl) {
+    lines.push(`Bridge: ${result.bridgeUrl}`);
+  }
+
+  if (result.url) {
+    lines.push(`URL: ${result.url}`);
+  }
+
+  if (result.runDir) {
+    lines.push(`Run dir: ${result.runDir}`);
+  }
+
+  if (result.mode) {
+    lines.push(`Mode: ${result.mode}`);
+  }
+
+  if (Array.isArray(result.imagePaths) && result.imagePaths.length > 0) {
+    lines.push(`Saved images: ${result.imagePaths.join(", ")}`);
+  }
+
+  if (Array.isArray(result.curlCommands) && result.curlCommands.length > 0) {
+    lines.push(
+      `\nImages could not be saved directly. Use these curl commands to download:\n${result.curlCommands.join("\n")}`,
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function asToolResult(result) {
+  const content = [];
+  const summary = formatSummary(result);
+
+  if (summary) {
+    content.push({
+      type: "text",
+      text: summary,
+    });
+  }
+
+  if (result.text) {
+    content.push({
+      type: "text",
+      text: result.text,
+    });
+  }
+
+  return {
+    content,
+    structuredContent: result,
+  };
+}
+
+function commandTimeoutForWait(waitTimeoutMs) {
+  return Math.max(Number(waitTimeoutMs || 0) + 30_000, 180_000);
+}
+
+export async function createApp(options = {}) {
+  const bridge = new GeminiExtensionBridge(options.bridge);
+  if (options.startBridge !== false) {
+    await bridge.start();
+  }
+
+  const server = new McpServer({
+    name: "gemini-extension-local",
+    version: "0.2.0",
+  });
+
+  server.registerTool(
+    "gemini_bridge_status",
+    {
+      description:
+        "Return the local Gemini bridge status and list connected extension clients.",
+      inputSchema: {},
+    },
+    async () => {
+      const result = await bridge.getStatus();
+      return asToolResult(result);
+    },
+  );
+
+  server.registerTool(
+    "gemini_page_status",
+    {
+      description:
+        "Ask the active Gemini browser tab for its current page status through the extension bridge.",
+      inputSchema: {
+        targetClientId: z
+          .string()
+          .optional()
+          .describe("Optional bridge client id to query a specific Gemini tab."),
+      },
+    },
+    async ({ targetClientId } = {}) => {
+      const result = await bridge.runCommand(
+        "get_status",
+        {},
+        { timeoutMs: 20_000, targetClientId },
+      );
+      return asToolResult(result);
+    },
+  );
+
+  server.registerTool(
+    "gemini_capture_images",
+    {
+      description:
+        "Capture currently visible generated images from the active Gemini tab and save them to disk without sending a new prompt.",
+      inputSchema: {
+        outputDir: z
+          .string()
+          .optional()
+          .describe(
+            "Directory where this capture should save result.json and extracted images.",
+          ),
+        targetClientId: z
+          .string()
+          .optional()
+          .describe("Optional bridge client id to capture from a specific Gemini tab."),
+        maxImages: z
+          .number()
+          .int()
+          .positive()
+          .max(8)
+          .optional()
+          .describe("Maximum number of visible images to save. Defaults to 4."),
+        label: z
+          .string()
+          .optional()
+          .describe("Optional label used in the saved run directory name."),
+      },
+    },
+    async ({
+      outputDir,
+      targetClientId,
+      maxImages = 4,
+      label = "capture-images",
+    } = {}) => {
+      const rawResult = await bridge.runCommand(
+        "capture_images",
+        { maxImages },
+        { timeoutMs: 60_000, targetClientId },
+      );
+      const result = await bridge.finalizeRunResult(label, rawResult, {
+        outputDir,
+        targetClientId,
+      });
+      return asToolResult(result);
+    },
+  );
+
+  server.registerTool(
+    "gemini_run_prompt",
+    {
+      description:
+        "Send one prompt through the active Gemini tab, optionally upload local images, optionally select a Gemini mode, then save returned images to disk.",
+      inputSchema: {
+        prompt: z.string().min(1).describe("Prompt to send to Gemini."),
+        mode: z
+          .string()
+          .optional()
+          .describe("Visible Gemini mode/model label to try to select before sending."),
+        images: z
+          .array(z.string())
+          .optional()
+          .describe("Local image file paths to upload before sending."),
+        outputDir: z
+          .string()
+          .optional()
+          .describe(
+            "Directory where this run should save result.json and any extracted images.",
+          ),
+        targetClientId: z
+          .string()
+          .optional()
+          .describe("Optional bridge client id to run against a specific Gemini tab."),
+        newChat: z
+          .boolean()
+          .optional()
+          .describe("Try to start a fresh chat before sending. Defaults to true."),
+        waitTimeoutMs: z
+          .number()
+          .int()
+          .positive()
+          .max(600000)
+          .optional()
+          .describe("How long to wait for a stable response. Defaults to 120000."),
+        maxImages: z
+          .number()
+          .int()
+          .nonnegative()
+          .max(8)
+          .optional()
+          .describe(
+            "Maximum number of visible output images to save. Use 0 to skip extraction. Defaults to 4.",
+          ),
+        takeScreenshot: z
+          .boolean()
+          .optional()
+          .describe("Save a full-page screenshot. Defaults to true."),
+      },
+    },
+    async ({
+      prompt,
+      mode,
+      images = [],
+      outputDir,
+      targetClientId,
+      newChat = true,
+      waitTimeoutMs = 120000,
+      maxImages = 4,
+    }) => {
+      const preparedImages = await bridge.readLocalImages(images);
+      const rawResult = await bridge.runCommand(
+        "run_prompt",
+        {
+          prompt,
+          mode,
+          images: preparedImages,
+          newChat,
+          waitTimeoutMs,
+          maxImages,
+        },
+        {
+          targetClientId,
+          timeoutMs: commandTimeoutForWait(waitTimeoutMs),
+        },
+      );
+      const result = await bridge.finalizeRunResult(prompt, rawResult, {
+        outputDir,
+        targetClientId,
+      });
+      return asToolResult(result);
+    },
+  );
+
+  return {
+    server,
+    bridge,
+    async close() {
+      await server.close().catch(() => {});
+      await bridge.close().catch(() => {});
+    },
+  };
+}