chrome-relay 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/index.ts
+var CHROME_RELAY_VERSION = "0.1.0";
+
+// src/install/install.ts
+import os from "os";
+import path from "path";
+import { chmod, mkdir, readFile, stat, writeFile } from "fs/promises";
+import { fileURLToPath } from "url";
+
+// ../protocol/dist/index.js
+var NATIVE_HOST_NAME = "dev.chrome_relay.native_host";
+var DEFAULT_HTTP_PORT = 12122;
+var DEFAULT_EXTENSION_ID = "cdmmkpadhnpcfjljhgpdnnljhjafmhop";
+var TOOL_NAMES = {
+  GET_WINDOWS_AND_TABS: "get_windows_and_tabs",
+  NAVIGATE: "chrome_navigate",
+  SWITCH_TAB: "chrome_switch_tab",
+  CLOSE_TABS: "chrome_close_tabs",
+  SCREENSHOT: "chrome_screenshot",
+  READ_PAGE: "chrome_read_page",
+  CLICK: "chrome_click_element",
+  FILL: "chrome_fill_or_select",
+  KEYBOARD: "chrome_keyboard",
+  JAVASCRIPT: "chrome_javascript"
+};
+var TOOL_SCHEMAS = [
+  {
+    name: TOOL_NAMES.GET_WINDOWS_AND_TABS,
+    description: "List open Chrome windows and tabs.",
+    inputSchema: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: TOOL_NAMES.NAVIGATE,
+    description: "Navigate the current tab or a specific tab to a URL.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Destination URL." },
+        tabId: { type: "number", description: "Optional target tab ID." },
+        newTab: { type: "boolean", description: "Open the URL in a new tab." },
+        active: { type: "boolean", description: "Whether the navigated tab should be active." }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: TOOL_NAMES.SWITCH_TAB,
+    description: "Switch the active browser tab.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Tab ID to activate." }
+      },
+      required: ["tabId"]
+    }
+  },
+  {
+    name: TOOL_NAMES.CLOSE_TABS,
+    description: "Close one or more tabs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabIds: {
+          type: "array",
+          description: "Tab IDs to close.",
+          items: { type: "number" }
+        }
+      },
+      required: ["tabIds"]
+    }
+  },
+  {
+    name: TOOL_NAMES.SCREENSHOT,
+    description: "Capture a screenshot of the current page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Optional target tab ID." },
+        fullPage: { type: "boolean", description: "Capture the full page when supported." }
+      },
+      required: []
+    }
+  },
+  {
+    name: TOOL_NAMES.READ_PAGE,
+    description: "Extract visible page structure and interactive elements.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Optional target tab ID." },
+        interactiveOnly: {
+          type: "boolean",
+          description: "Return only interactive elements."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: TOOL_NAMES.CLICK,
+    description: "Click a page element by selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to click." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: TOOL_NAMES.FILL,
+    description: "Fill an input or textarea by selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to fill." },
+        value: { type: "string", description: "Text to insert." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: TOOL_NAMES.KEYBOARD,
+    description: "Send keyboard input to the active page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        keys: {
+          type: "string",
+          description: "Literal key text or chord, for example Enter or Meta+L."
+        },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["keys"]
+    }
+  },
+  {
+    name: TOOL_NAMES.JAVASCRIPT,
+    description: "Evaluate JavaScript in the page context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        expression: { type: "string", description: "JavaScript expression to run." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["expression"]
+    }
+  }
+];
+
+// src/install/install.ts
+var APP_DIR = path.join(os.homedir(), ".chrome-relay");
+function getChromeManifestDir() {
+  if (process.platform === "darwin") {
+    return path.join(
+      os.homedir(),
+      "Library/Application Support/Google/Chrome/NativeMessagingHosts"
+    );
+  }
+  if (process.platform === "linux") {
+    return path.join(os.homedir(), ".config/google-chrome/NativeMessagingHosts");
+  }
+  throw new Error(`Unsupported platform for install: ${process.platform}`);
+}
+function getDistDir() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+async function writeWrapperScript(hostPath) {
+  await mkdir(APP_DIR, { recursive: true });
+  const wrapperPath = path.join(APP_DIR, "run-host.sh");
+  const content = `#!/bin/sh
+exec "${process.execPath}" "${hostPath}"
+`;
+  await writeFile(wrapperPath, content, "utf8");
+  await chmod(wrapperPath, 493);
+  return wrapperPath;
+}
+async function writeManifest(wrapperPath) {
+  const manifestDir = getChromeManifestDir();
+  await mkdir(manifestDir, { recursive: true });
+  const manifestPath = path.join(manifestDir, `${NATIVE_HOST_NAME}.json`);
+  const manifest = {
+    name: NATIVE_HOST_NAME,
+    description: "Native host for Chrome Relay",
+    path: wrapperPath,
+    type: "stdio",
+    allowed_origins: [`chrome-extension://${DEFAULT_EXTENSION_ID}/`]
+  };
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return manifestPath;
+}
+async function runInstall() {
+  const distDir = getDistDir();
+  const hostPath = path.join(distDir, "native-host.js");
+  const wrapperPath = await writeWrapperScript(hostPath);
+  const manifestPath = await writeManifest(wrapperPath);
+  console.log(`Installed Chrome Relay native host.`);
+  console.log(`Wrapper: ${wrapperPath}`);
+  console.log(`Manifest: ${manifestPath}`);
+  console.log(`HTTP MCP endpoint: http://127.0.0.1:${DEFAULT_HTTP_PORT}/mcp`);
+}
+async function runDoctor() {
+  try {
+    const wrapperPath = path.join(APP_DIR, "run-host.sh");
+    const manifestPath = path.join(getChromeManifestDir(), `${NATIVE_HOST_NAME}.json`);
+    await stat(wrapperPath);
+    await stat(manifestPath);
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    let serverReachable = false;
+    try {
+      const response = await fetch(`http://127.0.0.1:${DEFAULT_HTTP_PORT}/ping`);
+      serverReachable = response.ok;
+    } catch {
+      serverReachable = false;
+    }
+    console.log(`Wrapper present: yes`);
+    console.log(`Manifest present: yes`);
+    console.log(`Allowed origin: ${manifest.allowed_origins?.[0] ?? "missing"}`);
+    console.log(`HTTP server reachable: ${serverReachable ? "yes" : "no"}`);
+    if (!serverReachable) {
+      console.log(`Tip: load the extension so it can launch the native host.`);
+    }
+    return true;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return false;
+  }
+}
+
+// src/stdio.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+async function runStdioProxy() {
+  const client = new Client({ name: "chrome-relay-stdio", version: "0.1.0" }, { capabilities: {} });
+  const transport = new StreamableHTTPClientTransport(
+    new URL(`http://127.0.0.1:${DEFAULT_HTTP_PORT}/mcp`)
+  );
+  await client.connect(transport);
+  const server = new Server(
+    { name: "chrome-relay-stdio", version: "0.1.0" },
+    { capabilities: { tools: {}, resources: {}, prompts: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_SCHEMAS }));
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: [] }));
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [] }));
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (request) => client.callTool({ name: request.params.name, arguments: request.params.arguments ?? {} })
+  );
+  await server.connect(new StdioServerTransport());
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("chrome-relay").description("Connect your local Chrome browser to coding agents through MCP.").version(CHROME_RELAY_VERSION);
+program.command("install").description("Install and register the local Chrome Relay host.").action(async () => {
+  await runInstall();
+});
+program.command("doctor").description("Validate the local Chrome Relay installation.").action(async () => {
+  const ok = await runDoctor();
+  process.exit(ok ? 0 : 1);
+});
+program.command("stdio").description("Expose Chrome Relay over stdio for MCP clients that do not support HTTP.").action(async () => {
+  await runStdioProxy();
+});
+program.parse(process.argv);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare const CHROME_RELAY_VERSION = "0.1.0";
+
+export { CHROME_RELAY_VERSION };

package/dist/index.js

@@ -0,0 +1,5 @@
+// src/index.ts
+var CHROME_RELAY_VERSION = "0.1.0";
+export {
+  CHROME_RELAY_VERSION
+};

package/dist/native-host.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/native-host.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+
+// src/native-host.ts
+import process from "process";
+
+// src/http/server.ts
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import { randomUUID } from "crypto";
+import {
+  StreamableHTTPServerTransport
+} from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+
+// ../protocol/dist/index.js
+var DEFAULT_HTTP_PORT = 12122;
+var TOOL_NAMES = {
+  GET_WINDOWS_AND_TABS: "get_windows_and_tabs",
+  NAVIGATE: "chrome_navigate",
+  SWITCH_TAB: "chrome_switch_tab",
+  CLOSE_TABS: "chrome_close_tabs",
+  SCREENSHOT: "chrome_screenshot",
+  READ_PAGE: "chrome_read_page",
+  CLICK: "chrome_click_element",
+  FILL: "chrome_fill_or_select",
+  KEYBOARD: "chrome_keyboard",
+  JAVASCRIPT: "chrome_javascript"
+};
+var TOOL_SCHEMAS = [
+  {
+    name: TOOL_NAMES.GET_WINDOWS_AND_TABS,
+    description: "List open Chrome windows and tabs.",
+    inputSchema: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: TOOL_NAMES.NAVIGATE,
+    description: "Navigate the current tab or a specific tab to a URL.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Destination URL." },
+        tabId: { type: "number", description: "Optional target tab ID." },
+        newTab: { type: "boolean", description: "Open the URL in a new tab." },
+        active: { type: "boolean", description: "Whether the navigated tab should be active." }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: TOOL_NAMES.SWITCH_TAB,
+    description: "Switch the active browser tab.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Tab ID to activate." }
+      },
+      required: ["tabId"]
+    }
+  },
+  {
+    name: TOOL_NAMES.CLOSE_TABS,
+    description: "Close one or more tabs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabIds: {
+          type: "array",
+          description: "Tab IDs to close.",
+          items: { type: "number" }
+        }
+      },
+      required: ["tabIds"]
+    }
+  },
+  {
+    name: TOOL_NAMES.SCREENSHOT,
+    description: "Capture a screenshot of the current page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Optional target tab ID." },
+        fullPage: { type: "boolean", description: "Capture the full page when supported." }
+      },
+      required: []
+    }
+  },
+  {
+    name: TOOL_NAMES.READ_PAGE,
+    description: "Extract visible page structure and interactive elements.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Optional target tab ID." },
+        interactiveOnly: {
+          type: "boolean",
+          description: "Return only interactive elements."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: TOOL_NAMES.CLICK,
+    description: "Click a page element by selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to click." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: TOOL_NAMES.FILL,
+    description: "Fill an input or textarea by selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to fill." },
+        value: { type: "string", description: "Text to insert." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: TOOL_NAMES.KEYBOARD,
+    description: "Send keyboard input to the active page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        keys: {
+          type: "string",
+          description: "Literal key text or chord, for example Enter or Meta+L."
+        },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["keys"]
+    }
+  },
+  {
+    name: TOOL_NAMES.JAVASCRIPT,
+    description: "Evaluate JavaScript in the page context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        expression: { type: "string", description: "JavaScript expression to run." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["expression"]
+    }
+  }
+];
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function toCallToolResult(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data)
+      }
+    ],
+    isError: false
+  };
+}
+function createMcpServer(bridge2) {
+  const server2 = new Server(
+    { name: "chrome-relay", version: "0.1.0" },
+    { capabilities: { tools: {}, resources: {}, prompts: {} } }
+  );
+  server2.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_SCHEMAS }));
+  server2.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: [] }));
+  server2.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [] }));
+  server2.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      const result = await bridge2.callTool(
+        request.params.name,
+        request.params.arguments ?? {}
+      );
+      return toCallToolResult(result);
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: error instanceof Error ? error.message : String(error)
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  return server2;
+}
+
+// src/http/server.ts
+var RelayHttpServer = class {
+  constructor(bridge2, port = DEFAULT_HTTP_PORT) {
+    this.port = port;
+    this.mcpServer = createMcpServer(bridge2);
+  }
+  port;
+  app = Fastify({ logger: false });
+  transports = /* @__PURE__ */ new Map();
+  mcpServer;
+  async start() {
+    await this.app.register(cors, { origin: true });
+    this.app.get("/ping", async () => ({ ok: true, port: this.port }));
+    this.app.post("/mcp", async (request, reply) => {
+      const sessionId = request.headers["mcp-session-id"];
+      let transport = sessionId ? this.transports.get(sessionId) : void 0;
+      if (!transport) {
+        if (sessionId || !isInitializeRequest(request.body)) {
+          reply.code(400).send({ error: "Invalid MCP session." });
+          return;
+        }
+        transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (nextSessionId) => {
+            if (transport) {
+              this.transports.set(nextSessionId, transport);
+            }
+          }
+        });
+        transport.onclose = () => {
+          if (transport?.sessionId) {
+            this.transports.delete(transport.sessionId);
+          }
+        };
+        await this.mcpServer.connect(transport);
+      }
+      await transport.handleRequest(request.raw, reply.raw, request.body);
+    });
+    this.app.get("/mcp", async (request, reply) => {
+      const sessionId = request.headers["mcp-session-id"];
+      if (!sessionId) {
+        reply.code(400).send({ error: "Missing MCP session ID." });
+        return;
+      }
+      const transport = this.transports.get(sessionId);
+      if (!transport) {
+        reply.code(404).send({ error: "Unknown MCP session." });
+        return;
+      }
+      await transport.handleRequest(request.raw, reply.raw);
+    });
+    this.app.delete("/mcp", async (request, reply) => {
+      const sessionId = request.headers["mcp-session-id"];
+      if (!sessionId) {
+        reply.code(400).send({ error: "Missing MCP session ID." });
+        return;
+      }
+      const transport = this.transports.get(sessionId);
+      if (!transport) {
+        reply.code(404).send({ error: "Unknown MCP session." });
+        return;
+      }
+      await transport.handleRequest(request.raw, reply.raw);
+    });
+    await this.app.listen({ port: this.port, host: "127.0.0.1" });
+  }
+  async stop() {
+    await this.app.close();
+  }
+};
+
+// src/native/bridge.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var ExtensionBridge = class {
+  constructor(send) {
+    this.send = send;
+  }
+  send;
+  pending = /* @__PURE__ */ new Map();
+  readyWaiters = /* @__PURE__ */ new Set();
+  ready = false;
+  handleMessage(message) {
+    if (message.type === "bridge.ready") {
+      this.handleReady(message);
+      return;
+    }
+    if (message.type === "tool.result") {
+      this.handleToolResult(message);
+      return;
+    }
+    if (message.type === "bridge.pong") {
+      const pending = this.pending.get(message.id);
+      if (!pending) {
+        return;
+      }
+      clearTimeout(pending.timer);
+      this.pending.delete(message.id);
+      pending.resolve(true);
+    }
+  }
+  handleReady(_message) {
+    this.ready = true;
+    for (const notify of this.readyWaiters) {
+      notify();
+    }
+    this.readyWaiters.clear();
+  }
+  handleToolResult(message) {
+    const pending = this.pending.get(message.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(message.id);
+    if (message.payload.ok) {
+      pending.resolve(message.payload.data);
+      return;
+    }
+    pending.reject(new Error(message.payload.error));
+  }
+  async waitUntilReady(timeoutMs = 15e3) {
+    if (this.ready) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.readyWaiters.delete(onReady);
+        reject(new Error("Chrome Relay extension is not connected."));
+      }, timeoutMs);
+      const onReady = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      this.readyWaiters.add(onReady);
+    });
+  }
+  async ping(timeoutMs = 2e3) {
+    const id = randomUUID2();
+    const message = { type: "bridge.ping", id };
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve(false);
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: () => resolve(true),
+        reject: () => resolve(false),
+        timer
+      });
+      this.send(message);
+    });
+  }
+  async callTool(name, args, timeoutMs = 3e4) {
+    await this.waitUntilReady();
+    const id = randomUUID2();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Timed out waiting for tool result: ${name}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.send({
+        type: "tool.call",
+        id,
+        payload: { name, args }
+      });
+    });
+  }
+};
+
+// src/native/framing.ts
+function writeNativeMessage(stream, message) {
+  const payload = Buffer.from(JSON.stringify(message), "utf8");
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(payload.length, 0);
+  stream.write(header);
+  stream.write(payload);
+}
+function readNativeMessages(stream, onMessage) {
+  let buffer = Buffer.alloc(0);
+  stream.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (buffer.length >= 4) {
+      const length = buffer.readUInt32LE(0);
+      if (buffer.length < 4 + length) {
+        break;
+      }
+      const payload = buffer.subarray(4, 4 + length);
+      buffer = buffer.subarray(4 + length);
+      onMessage(JSON.parse(payload.toString("utf8")));
+    }
+  });
+}
+
+// src/native-host.ts
+var bridge = new ExtensionBridge((message) => {
+  writeNativeMessage(process.stdout, message);
+});
+var server = new RelayHttpServer(bridge);
+async function main() {
+  await server.start();
+  readNativeMessages(process.stdin, (message) => {
+    bridge.handleMessage(message);
+  });
+  process.stdin.resume();
+  process.stdin.on("end", async () => {
+    await server.stop();
+    process.exit(0);
+  });
+}
+main().catch(async (error) => {
+  console.error(error);
+  await server.stop();
+  process.exit(1);
+});

package/dist/stdio.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function runStdioProxy(): Promise<void>;
+
+export { runStdioProxy };

package/dist/stdio.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+// src/stdio.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// ../protocol/dist/index.js
+var DEFAULT_HTTP_PORT = 12122;
+var TOOL_NAMES = {
+  GET_WINDOWS_AND_TABS: "get_windows_and_tabs",
+  NAVIGATE: "chrome_navigate",
+  SWITCH_TAB: "chrome_switch_tab",
+  CLOSE_TABS: "chrome_close_tabs",
+  SCREENSHOT: "chrome_screenshot",
+  READ_PAGE: "chrome_read_page",
+  CLICK: "chrome_click_element",
+  FILL: "chrome_fill_or_select",
+  KEYBOARD: "chrome_keyboard",
+  JAVASCRIPT: "chrome_javascript"
+};
+var TOOL_SCHEMAS = [
+  {
+    name: TOOL_NAMES.GET_WINDOWS_AND_TABS,
+    description: "List open Chrome windows and tabs.",
+    inputSchema: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: TOOL_NAMES.NAVIGATE,
+    description: "Navigate the current tab or a specific tab to a URL.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Destination URL." },
+        tabId: { type: "number", description: "Optional target tab ID." },
+        newTab: { type: "boolean", description: "Open the URL in a new tab." },
+        active: { type: "boolean", description: "Whether the navigated tab should be active." }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: TOOL_NAMES.SWITCH_TAB,
+    description: "Switch the active browser tab.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Tab ID to activate." }
+      },
+      required: ["tabId"]
+    }
+  },
+  {
+    name: TOOL_NAMES.CLOSE_TABS,
+    description: "Close one or more tabs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabIds: {
+          type: "array",
+          description: "Tab IDs to close.",
+          items: { type: "number" }
+        }
+      },
+      required: ["tabIds"]
+    }
+  },
+  {
+    name: TOOL_NAMES.SCREENSHOT,
+    description: "Capture a screenshot of the current page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Optional target tab ID." },
+        fullPage: { type: "boolean", description: "Capture the full page when supported." }
+      },
+      required: []
+    }
+  },
+  {
+    name: TOOL_NAMES.READ_PAGE,
+    description: "Extract visible page structure and interactive elements.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tabId: { type: "number", description: "Optional target tab ID." },
+        interactiveOnly: {
+          type: "boolean",
+          description: "Return only interactive elements."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: TOOL_NAMES.CLICK,
+    description: "Click a page element by selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to click." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: TOOL_NAMES.FILL,
+    description: "Fill an input or textarea by selector.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        selector: { type: "string", description: "CSS selector to fill." },
+        value: { type: "string", description: "Text to insert." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: TOOL_NAMES.KEYBOARD,
+    description: "Send keyboard input to the active page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        keys: {
+          type: "string",
+          description: "Literal key text or chord, for example Enter or Meta+L."
+        },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["keys"]
+    }
+  },
+  {
+    name: TOOL_NAMES.JAVASCRIPT,
+    description: "Evaluate JavaScript in the page context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        expression: { type: "string", description: "JavaScript expression to run." },
+        tabId: { type: "number", description: "Optional target tab ID." }
+      },
+      required: ["expression"]
+    }
+  }
+];
+
+// src/stdio.ts
+async function runStdioProxy() {
+  const client = new Client({ name: "chrome-relay-stdio", version: "0.1.0" }, { capabilities: {} });
+  const transport = new StreamableHTTPClientTransport(
+    new URL(`http://127.0.0.1:${DEFAULT_HTTP_PORT}/mcp`)
+  );
+  await client.connect(transport);
+  const server = new Server(
+    { name: "chrome-relay-stdio", version: "0.1.0" },
+    { capabilities: { tools: {}, resources: {}, prompts: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_SCHEMAS }));
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: [] }));
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [] }));
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (request) => client.callTool({ name: request.params.name, arguments: request.params.arguments ?? {} })
+  );
+  await server.connect(new StdioServerTransport());
+}
+export {
+  runStdioProxy
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "chrome-relay",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "chrome-relay": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "description": "Connect your local Chrome browser to coding agents through MCP.",
+  "keywords": ["mcp", "chrome", "browser", "automation", "agents"],
+  "license": "MIT",
+  "dependencies": {
+    "@fastify/cors": "^11.0.1",
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "fastify": "^5.3.2"
+  },
+  "devDependencies": {
+    "@chrome-relay/protocol": "workspace:*",
+    "tsup": "^8.4.0"
+  }
+}