@automatebrowser/mcp 0.3.0

package/dist/cli.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import {
+  Context,
+  asToolError,
+  callTool,
+  package_default,
+  renderError,
+  selectTools
+} from "./chunk-WAXVZKT5.js";
+import {
+  debugLog
+} from "./chunk-R5JREBXQ.js";
+
+// src/cli.ts
+import { randomUUID } from "crypto";
+import { writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { program } from "commander";
+process.env.AUTOMATE_BROWSER_CLIENT_NAME ||= "cli";
+process.env.AUTOMATE_BROWSER_INSTANCE_ID ||= randomUUID();
+var ALIASES = {
+  navigate: { tool: "browser_navigate", positional: "url" },
+  "read-page": { tool: "browser_read_page" },
+  snapshot: { tool: "browser_snapshot" },
+  screenshot: { tool: "browser_screenshot" },
+  status: { tool: "browser_status" },
+  eval: { tool: "browser_eval", positional: "expression" },
+  tabs: { tool: "browser_list_tabs" }
+};
+var IMAGE_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp"
+};
+var TOOLS = selectTools("full").tools;
+var write = (stream, text) => new Promise((resolve) => stream.write(text, () => resolve()));
+function resolveTool(command) {
+  const alias = ALIASES[command];
+  const name = alias?.tool ?? command;
+  const tool = TOOLS.find((t) => t.schema.name === name) ?? TOOLS.find((t) => t.schema.name === `browser_${name}`);
+  if (!tool) {
+    throw new Error(
+      `Unknown command "${command}".
+
+Aliases: ${Object.keys(ALIASES).join(", ")}
+
+Tools:
+${TOOLS.map((t) => `  ${t.schema.name}`).join("\n")}`
+    );
+  }
+  return { tool, positional: alias?.positional };
+}
+function buildArgs(command, positional, value, json) {
+  let args = {};
+  if (json) {
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch (err) {
+      throw new Error(`--args is not valid JSON: ${err.message}`, { cause: err });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`--args must be a JSON object, e.g. --args '{"url":"https://example.com"}'`);
+    }
+    args = parsed;
+  }
+  if (value !== void 0) {
+    if (!positional) {
+      throw new Error(
+        `"${command}" takes no positional argument \u2014 pass its options with --args '{\u2026}'.`
+      );
+    }
+    args[positional] = value;
+  }
+  return args;
+}
+async function printResult(result, asJson) {
+  if (asJson) {
+    await write(process.stdout, JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  for (const part of result.content) {
+    if (part.type === "text") {
+      await write(process.stdout, part.text + "\n");
+      continue;
+    }
+    const file = join(
+      tmpdir(),
+      `automate-browser-${Date.now()}.${IMAGE_EXT[part.mimeType] ?? "bin"}`
+    );
+    writeFileSync(file, Buffer.from(part.data, "base64"));
+    await write(process.stdout, `${part.mimeType} saved \u2192 ${file}
+`);
+  }
+}
+program.name("automate-browser").description(
+  "Drive your logged-in browser from the terminal, alongside any connected IDE agents."
+).version(package_default.version).argument("<command>", `alias (${Object.keys(ALIASES).join(", ")}) or a tool name`).argument("[value]", "the alias's argument, e.g. the URL for `navigate`").option("--args <json>", "tool arguments as a JSON object").option("--json", "print the whole tool result as JSON, for scripting").addHelpText(
+  "after",
+  `
+Examples:
+  automate-browser status
+  automate-browser navigate https://example.com
+  automate-browser eval 'document.title'
+  automate-browser read-page --args '{"format":"markdown"}'
+  automate-browser tabs --json
+`
+).action(
+  async (command, value, opts) => {
+    let context;
+    try {
+      const { tool, positional } = resolveTool(command);
+      const args = buildArgs(command, positional, value, opts.args);
+      context = new Context({ version: package_default.version });
+      await context.start().catch((err) => {
+        debugLog("[cli] relay link not ready:", String(err));
+      });
+      const result = await callTool(context, tool, args);
+      await printResult(result, opts.json === true);
+      await context.close();
+      process.exit(result.isError ? 1 : 0);
+    } catch (err) {
+      const typed = asToolError(err);
+      await write(
+        process.stderr,
+        `${typed ? renderError(typed) : err instanceof Error ? err.message : String(err)}
+`
+      );
+      await context?.close().catch(() => void 0);
+      process.exit(1);
+    }
+  }
+);
+void program.parseAsync(process.argv);

package/dist/index.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+import {
+  Context,
+  activeSelection,
+  callTool,
+  errorResult,
+  logRootSources,
+  package_default,
+  selectTools,
+  setRoots
+} from "./chunk-WAXVZKT5.js";
+import {
+  appConfig,
+  debugLog,
+  log,
+  logPath
+} from "./chunk-R5JREBXQ.js";
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Option, program } from "commander";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+  RootsListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/tool.ts
+function wireSchema(schema) {
+  const strip = (value) => {
+    if (value === null || typeof value !== "object") return value;
+    const { $schema: _dialect, ...rest } = value;
+    return rest;
+  };
+  return {
+    ...schema,
+    inputSchema: strip(schema.inputSchema),
+    ...schema.outputSchema === void 0 ? {} : { outputSchema: strip(schema.outputSchema) }
+  };
+}
+
+// src/server.ts
+async function createServerWithTools(options) {
+  const { name, version, tools, resources: resources2 } = options;
+  const context = new Context({ version });
+  void context.start().catch((err) => {
+    debugLog("[server] relay link not ready yet (will retry):", String(err));
+  });
+  const server = new Server(
+    { name, version },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  const refreshRoots = async () => {
+    try {
+      if (!server.getClientCapabilities()?.roots) {
+        debugLog(
+          "[roots] client offers no roots; path sandbox uses cwd + tmpdir + AUTOMATE_BROWSER_WORKSPACE"
+        );
+        logRootSources();
+        return;
+      }
+      const { roots } = await server.listRoots();
+      setRoots(roots);
+    } catch (err) {
+      debugLog("[roots] listRoots failed; keeping the current allow-list:", String(err));
+      logRootSources();
+    }
+  };
+  try {
+    server.oninitialized = () => void refreshRoots();
+    server.setNotificationHandler(RootsListChangedNotificationSchema, () => void refreshRoots());
+  } catch (err) {
+    debugLog("[roots] could not subscribe to roots changes:", String(err));
+  }
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: tools.map((tool) => wireSchema(tool.schema)) };
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources: resources2.map((resource) => resource.schema) };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const tool = tools.find((tool2) => tool2.schema.name === request.params.name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `Tool "${request.params.name}" not found` }],
+        isError: true
+      };
+    }
+    const startedAt = Date.now();
+    try {
+      const result = await callTool(context, tool, request.params.arguments);
+      debugLog(`[tool] name=${request.params.name} ms=${Date.now() - startedAt}`);
+      return result;
+    } catch (error) {
+      debugLog(
+        `[tool] name=${request.params.name} ms=${Date.now() - startedAt} error=${String(error)}`
+      );
+      return errorResult(tool, error);
+    }
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const resource = resources2.find((resource2) => resource2.schema.uri === request.params.uri);
+    if (!resource) {
+      return { contents: [] };
+    }
+    const contents = await resource.read(context, request.params.uri);
+    return { contents };
+  });
+  const originalClose = server.close.bind(server);
+  server.close = async () => {
+    await Promise.allSettled([originalClose(), context.close()]);
+  };
+  return server;
+}
+
+// src/utils/update-check.ts
+import { readFileSync, writeFileSync } from "fs";
+var PACKAGE = "@automatebrowser/mcp";
+var REGISTRY = `https://registry.npmjs.org/${PACKAGE}/latest`;
+var CACHE_FILE = "update-check.json";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var TIMEOUT_MS = 3e3;
+function compareVersions(a, b) {
+  const split = (v) => {
+    const s = String(v ?? "").trim().replace(/^v/, "");
+    const plus = s.indexOf("+");
+    const core = plus === -1 ? s : s.slice(0, plus);
+    const dash = core.indexOf("-");
+    return {
+      nums: (dash === -1 ? core : core.slice(0, dash)).split(".").map((n) => Number.parseInt(n, 10) || 0),
+      pre: dash === -1 ? "" : core.slice(dash + 1)
+    };
+  };
+  const x = split(a);
+  const y = split(b);
+  for (let i = 0; i < 3; i++) {
+    const d = (x.nums[i] ?? 0) - (y.nums[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  if (x.pre === y.pre) return 0;
+  if (!x.pre) return 1;
+  if (!y.pre) return -1;
+  return x.pre < y.pre ? -1 : 1;
+}
+function readCache(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return typeof parsed?.checkedAt === "number" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(file, cache) {
+  try {
+    writeFileSync(file, JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function notify(current, latest) {
+  log.warn(
+    `A newer ${PACKAGE} is available: ${current} \u2192 ${latest}. Update with \`npm i -g ${PACKAGE}\`. Set AUTOMATE_BROWSER_NO_UPDATE_CHECK=1 to silence this.`
+  );
+}
+async function checkForUpdate(current, opts = {}) {
+  if (process.env.AUTOMATE_BROWSER_NO_UPDATE_CHECK) return;
+  const file = opts.cacheFile ?? logPath(CACHE_FILE);
+  const now = opts.now ?? Date.now();
+  const announce = opts.onNotice ?? notify;
+  const cache = readCache(file);
+  if (cache?.latest && compareVersions(current, cache.latest) < 0) {
+    announce(current, cache.latest);
+  }
+  if (cache && now - cache.checkedAt < DAY_MS) return;
+  let latest;
+  try {
+    const res = await (opts.fetchImpl ?? fetch)(REGISTRY, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+      headers: { accept: "application/json" }
+    });
+    if (res.ok) {
+      const body = await res.json();
+      if (typeof body?.version === "string") latest = body.version;
+    }
+  } catch {
+  }
+  writeCache(file, { checkedAt: now, ...latest ? { latest } : {} });
+  if (latest && latest !== cache?.latest && compareVersions(current, latest) < 0) {
+    announce(current, latest);
+  }
+}
+
+// src/index.ts
+var FORCE_EXIT_MS = 5e3;
+var PARENT_WATCH_MS = 5e3;
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function installShutdownHandlers(server) {
+  let closing = false;
+  const shutdown = async (reason) => {
+    if (closing) return;
+    closing = true;
+    debugLog(`[shutdown] ${reason}`);
+    const forceTimer = setTimeout(() => {
+      debugLog("[shutdown] force exit after timeout");
+      process.exit(0);
+    }, FORCE_EXIT_MS);
+    forceTimer.unref?.();
+    try {
+      await server.close();
+    } catch (err) {
+      debugLog("[shutdown] error during close:", err);
+    } finally {
+      clearTimeout(forceTimer);
+      process.exit(0);
+    }
+  };
+  process.stdin.on("close", () => void shutdown("stdin closed"));
+  process.stdin.on("end", () => void shutdown("stdin ended"));
+  process.stdin.on("error", () => void shutdown("stdin error"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  const parentPid = process.ppid;
+  if (parentPid > 1) {
+    const watch = setInterval(() => {
+      if (!processAlive(parentPid)) {
+        clearInterval(watch);
+        void shutdown(`parent process ${parentPid} gone (orphaned)`);
+      }
+    }, PARENT_WATCH_MS);
+    watch.unref?.();
+  }
+}
+function installCrashGuards() {
+  process.on("uncaughtException", (err) => {
+    debugLog("[uncaughtException]", String(err));
+  });
+  process.on("unhandledRejection", (reason) => {
+    debugLog("[unhandledRejection]", String(reason));
+  });
+}
+var resources = [];
+async function createServer() {
+  return createServerWithTools({
+    name: appConfig.name,
+    version: package_default.version,
+    tools: activeSelection().tools,
+    resources
+  });
+}
+program.version("Version " + package_default.version).name(package_default.name).addOption(
+  new Option("--print-tools [profile]", "print tool schemas as JSON and exit").hideHelp()
+).action(async (options) => {
+  if (options.printTools) {
+    const selection = typeof options.printTools === "string" ? selectTools(options.printTools) : activeSelection();
+    process.stdout.write(
+      JSON.stringify(selection.tools.map((tool) => wireSchema(tool.schema))) + "\n"
+    );
+    return;
+  }
+  installCrashGuards();
+  void checkForUpdate(package_default.version);
+  try {
+    const server = await createServer();
+    installShutdownHandlers(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  } catch (err) {
+    debugLog("[startup] failed to start server:", String(err));
+  }
+});
+program.parse(process.argv);