chrome-relay 0.1.1 → 0.1.2

package/dist/cli.js

@@ -2,6 +2,7 @@
 
 // src/cli.ts
 import { Command } from "commander";
+import { writeFileSync } from "fs";
 
 // src/index.ts
 var CHROME_RELAY_VERSION = "0.1.0";
@@ -266,6 +267,34 @@ async function runStdioProxy() {
   await server.connect(new StdioServerTransport());
 }
 
+// src/client/call.ts
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+async function callTool(name, args) {
+  const transport = new StreamableHTTPClientTransport2(
+    new URL(`http://127.0.0.1:${DEFAULT_HTTP_PORT}/mcp`)
+  );
+  const client = new Client2(
+    { name: "chrome-relay-cli", version: "0.1.2" },
+    { capabilities: {} }
+  );
+  await client.connect(transport);
+  try {
+    const result = await client.callTool({ name, arguments: args });
+    const content = result.content ?? [];
+    const text = content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+    if (!text) return result;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+
 // 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);
@@ -279,4 +308,108 @@ program.command("doctor").description("Validate the local Chrome Relay installat
 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);
+async function run(name, args) {
+  try {
+    const result = await callTool(name, args);
+    if (typeof result === "string") {
+      process.stdout.write(result + "\n");
+    } else {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    }
+  } catch (error) {
+    process.stderr.write(
+      (error instanceof Error ? error.message : String(error)) + "\n"
+    );
+    process.exit(1);
+  }
+}
+function tabOpt(cmd) {
+  return cmd.option("-t, --tab <id>", "target tab ID", (v) => Number(v));
+}
+tabOpt(
+  program.command("tabs").description("List open Chrome windows and tabs.")
+).action(async () => {
+  await run("get_windows_and_tabs", {});
+});
+tabOpt(
+  program.command("navigate <url>").description("Navigate a tab to a URL.").option("--new", "open in a new tab").option("--inactive", "do not activate the tab")
+).action(async (url, opts) => {
+  const args = { url };
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  if (opts.new) args.newTab = true;
+  if (opts.inactive) args.active = false;
+  await run("chrome_navigate", args);
+});
+tabOpt(
+  program.command("screenshot").description("Capture a screenshot of the current page.").option("--full", "capture full page").option("-o, --out <path>", "save image to path (base64 PNG decoded)")
+).action(async (opts) => {
+  const args = {};
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  if (opts.full) args.fullPage = true;
+  try {
+    const result = await callTool("chrome_screenshot", args);
+    if (opts.out && result && typeof result === "object") {
+      const data = result.dataUrl ?? result.data;
+      if (typeof data === "string") {
+        const b64 = data.includes(",") ? data.split(",")[1] : data;
+        writeFileSync(opts.out, Buffer.from(b64, "base64"));
+        process.stdout.write(`Saved screenshot to ${opts.out}
+`);
+        return;
+      }
+    }
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  } catch (error) {
+    process.stderr.write(
+      (error instanceof Error ? error.message : String(error)) + "\n"
+    );
+    process.exit(1);
+  }
+});
+tabOpt(
+  program.command("read").description("Extract page structure and interactive elements.").option("-i, --interactive", "return only interactive elements")
+).action(async (opts) => {
+  const args = {};
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  if (opts.interactive) args.interactiveOnly = true;
+  await run("chrome_read_page", args);
+});
+tabOpt(
+  program.command("click <selector>").description("Click an element by CSS selector.")
+).action(async (selector, opts) => {
+  const args = { selector };
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  await run("chrome_click_element", args);
+});
+tabOpt(
+  program.command("fill <selector> <value>").description("Fill an input or textarea.")
+).action(async (selector, value, opts) => {
+  const args = { selector, value };
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  await run("chrome_fill_or_select", args);
+});
+tabOpt(
+  program.command("keys <keys>").description("Send keyboard input (e.g. Enter, Meta+L).")
+).action(async (keys, opts) => {
+  const args = { keys };
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  await run("chrome_keyboard", args);
+});
+tabOpt(
+  program.command("js <expression>").description("Evaluate JavaScript in the page context.")
+).action(async (expression, opts) => {
+  const args = { expression };
+  if (opts.tab !== void 0) args.tabId = opts.tab;
+  await run("chrome_javascript", args);
+});
+program.command("switch <tabId>").description("Activate a tab by ID.").action(async (tabId) => {
+  await run("chrome_switch_tab", { tabId: Number(tabId) });
+});
+program.command("close <tabIds...>").description("Close one or more tabs by ID.").action(async (tabIds) => {
+  await run("chrome_close_tabs", { tabIds: tabIds.map(Number) });
+});
+program.command("call <tool> [json]").description("Call any Chrome Relay tool with raw JSON args.").action(async (tool, json) => {
+  const args = json ? JSON.parse(json) : {};
+  await run(tool, args);
+});
+program.parseAsync(process.argv);

package/dist/native-host.js

@@ -205,13 +205,13 @@ function createMcpServer(bridge2) {
 // src/http/server.ts
 var RelayHttpServer = class {
   constructor(bridge2, port = DEFAULT_HTTP_PORT) {
+    this.bridge = bridge2;
     this.port = port;
-    this.mcpServer = createMcpServer(bridge2);
   }
+  bridge;
   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 }));
@@ -236,7 +236,8 @@ var RelayHttpServer = class {
             this.transports.delete(transport.sessionId);
           }
         };
-        await this.mcpServer.connect(transport);
+        const mcpServer = createMcpServer(this.bridge);
+        await mcpServer.connect(transport);
       }
       await transport.handleRequest(request.raw, reply.raw, request.body);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-relay",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",