@bsbofmusic/agent-browser-mcp-opencode 0.1.0

package/dist/bootstrap.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+function run(cmd, args, opts = {}) {
+    const r = spawnSync(cmd, args, {
+        stdio: opts.silent ? "ignore" : "inherit",
+        shell: false,
+        windowsHide: true
+    });
+    return r.status ?? 1;
+}
+function ensureAgentBrowser() {
+    // 1) Prefer local install (no admin required)
+    const localBinWin = join(process.cwd(), "node_modules", ".bin", "agent-browser.cmd");
+    const localBinNix = join(process.cwd(), "node_modules", ".bin", "agent-browser");
+    const hasLocal = existsSync(localBinWin) || existsSync(localBinNix);
+    if (!hasLocal) {
+        console.error("[agent-browser-mcp] Installing agent-browser locally...");
+        const code = run("npm", ["i", "agent-browser"], { silent: false });
+        if (code === 0) {
+            return { runner: "local" };
+        }
+        console.error("[agent-browser-mcp] Local install failed, will try npx/global fallback...");
+    }
+    else {
+        return { runner: "local" };
+    }
+    // 2) Fallback to npx (still no admin, but depends on npx resolving)
+    // We won't pre-install here; we'll just use npx to run it.
+    // If npx fails, try global.
+    const npxOk = run("npx", ["-y", "agent-browser", "--help"], { silent: true }) === 0;
+    if (npxOk)
+        return { runner: "npx" };
+    // 3) Last resort: global install (may require admin depending on policy)
+    console.error("[agent-browser-mcp] Installing agent-browser globally (may require permissions)...");
+    const g = run("npm", ["i", "-g", "agent-browser"], { silent: false });
+    if (g !== 0)
+        throw new Error("Failed to install agent-browser (local/npx/global all failed).");
+    return { runner: "global" };
+}
+function ensureChromium(runner) {
+    console.error("[agent-browser-mcp] Ensuring Chromium is installed (agent-browser install)...");
+    if (runner === "local") {
+        // Use local binary via npm exec (cross-platform)
+        const code = run("npm", ["exec", "--", "agent-browser", "install"], { silent: false });
+        if (code !== 0)
+            throw new Error("agent-browser install failed (local).");
+        return;
+    }
+    if (runner === "npx") {
+        const code = run("npx", ["-y", "agent-browser", "install"], { silent: false });
+        if (code !== 0)
+            throw new Error("agent-browser install failed (npx).");
+        return;
+    }
+    // global
+    const code = run("agent-browser", ["install"], { silent: false });
+    if (code !== 0)
+        throw new Error("agent-browser install failed (global).");
+}
+function startMcp() {
+    console.error("[agent-browser-mcp] Starting MCP server...");
+    const code = run("node", [new URL("./index.js", import.meta.url).pathname], { silent: false });
+    process.exit(code);
+}
+function main() {
+    const { runner } = ensureAgentBrowser();
+    ensureChromium(runner);
+    startMcp();
+}
+main();

package/dist/index.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+const env = process.env;
+const AGENT_BROWSER_BIN = env.AGENT_BROWSER_BIN || "agent-browser";
+const DEFAULT_SESSION = env.AGENT_BROWSER_SESSION || "opencode";
+const STATE_PATH = env.AGENT_BROWSER_STATE || "";
+const ALLOW_DOMAINS = (env.AGENT_BROWSER_ALLOW_DOMAINS || "").split(",").map(s => s.trim()).filter(Boolean);
+const DEFAULT_TIMEOUT_MS = Number(env.AGENT_BROWSER_TIMEOUT_MS || "60000");
+const MAX_OUTPUT_CHARS = Number(env.AGENT_BROWSER_MAX_OUTPUT_CHARS || "200000");
+// helper: ensure literal type "text"
+const txt = (text) => ({ type: "text", text });
+let queue = Promise.resolve();
+function enqueue(fn) {
+    const next = queue.then(fn, fn);
+    queue = next.then(() => undefined, () => undefined);
+    return next;
+}
+function limitOutput(s) {
+    if (s.length <= MAX_OUTPUT_CHARS)
+        return s;
+    return s.slice(0, MAX_OUTPUT_CHARS) + "\n...[truncated]";
+}
+function domainAllowed(urlStr) {
+    if (!ALLOW_DOMAINS.length)
+        return true;
+    try {
+        const u = new URL(urlStr);
+        const host = u.hostname.toLowerCase();
+        return ALLOW_DOMAINS.some(d => host === d.toLowerCase() || host.endsWith("." + d.toLowerCase()));
+    }
+    catch {
+        return false;
+    }
+}
+async function runAgentBrowser(args, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    return await enqueue(() => new Promise((resolveRun) => {
+        const finalArgs = [];
+        finalArgs.push(...args, "--json");
+        finalArgs.push("--session-name", DEFAULT_SESSION);
+        if (STATE_PATH)
+            finalArgs.push("--state", STATE_PATH);
+        const child = spawn(AGENT_BROWSER_BIN, finalArgs, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => child.kill(), timeoutMs);
+        child.stdout.on("data", (d) => { stdout += d.toString("utf8"); });
+        child.stderr.on("data", (d) => { stderr += d.toString("utf8"); });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const out = limitOutput(stdout.trim());
+            const err = limitOutput(stderr.trim());
+            let parsed;
+            try {
+                parsed = out ? JSON.parse(out) : undefined;
+            }
+            catch {
+                const lines = out.split("\n").map(l => l.trim()).filter(Boolean);
+                for (let i = lines.length - 1; i >= 0; i--) {
+                    try {
+                        parsed = JSON.parse(lines[i]);
+                        break;
+                    }
+                    catch { }
+                }
+            }
+            resolveRun({ ok: code === 0, exitCode: code, stdout: out, stderr: err, parsedJson: parsed });
+        });
+    }));
+}
+const server = new McpServer({ name: "agent-browser-mcp", version: "0.1.0" });
+server.tool("browser_open", "Open a URL in agent-browser (reuses session).", { url: z.string().url(), headed: z.boolean().optional().default(false), timeoutMs: z.number().int().positive().optional() }, async ({ url, headed, timeoutMs }) => {
+    if (!domainAllowed(url))
+        return { content: [txt(`Blocked by allowlist: ${url}`)] };
+    const args = ["open", url];
+    if (headed)
+        args.push("--headed");
+    const r = await runAgentBrowser(args, timeoutMs);
+    const content = [txt(r.ok ? "OK" : "FAILED"), txt(r.stdout || "")];
+    if (r.stderr)
+        content.push(txt(`stderr:\n${r.stderr}`));
+    return { content };
+});
+server.tool("browser_click", "Click an element by selector.", { selector: z.string().min(1), timeoutMs: z.number().int().positive().optional() }, async ({ selector, timeoutMs }) => {
+    const r = await runAgentBrowser(["click", selector], timeoutMs);
+    return { content: [txt(r.ok ? (r.stdout || "OK") : (r.stderr || r.stdout || "FAILED"))] };
+});
+server.tool("browser_type", "Type into an input/textarea by selector.", { selector: z.string().min(1), text: z.string(), submit: z.boolean().optional().default(false), timeoutMs: z.number().int().positive().optional() }, async ({ selector, text, submit, timeoutMs }) => {
+    const args = ["type", selector, text];
+    if (submit)
+        args.push("--submit");
+    const r = await runAgentBrowser(args, timeoutMs);
+    return { content: [txt(r.ok ? (r.stdout || "OK") : (r.stderr || r.stdout || "FAILED"))] };
+});
+server.tool("browser_extract", "Extract text/html from a selector.", { selector: z.string().min(1), mode: z.enum(["text", "html"]).optional().default("text"), timeoutMs: z.number().int().positive().optional() }, async ({ selector, mode, timeoutMs }) => {
+    const r = await runAgentBrowser(["extract", mode, selector], timeoutMs);
+    const payload = r.parsedJson ?? r.stdout;
+    return { content: [txt(typeof payload === "string" ? payload : JSON.stringify(payload, null, 2))] };
+});
+server.tool("browser_screenshot", "Take a screenshot and save to a file path.", { path: z.string().min(1).optional().default("agent-browser.png"), fullPage: z.boolean().optional().default(true), timeoutMs: z.number().int().positive().optional() }, async ({ path, fullPage, timeoutMs }) => {
+    const outPath = resolve(process.cwd(), path);
+    const args = ["screenshot", outPath];
+    if (fullPage)
+        args.push("--full-page");
+    const r = await runAgentBrowser(args, timeoutMs);
+    const content = [txt(r.ok ? `OK: ${outPath}` : "FAILED")];
+    if (r.stdout)
+        content.push(txt(r.stdout));
+    if (r.stderr)
+        content.push(txt(`stderr:\n${r.stderr}`));
+    return { content };
+});
+server.tool("browser_set_viewport", "Set viewport size.", { width: z.number().int().min(200).max(4000), height: z.number().int().min(200).max(4000), timeoutMs: z.number().int().positive().optional() }, async ({ width, height, timeoutMs }) => {
+    const r = await runAgentBrowser(["set", "viewport", String(width), String(height)], timeoutMs);
+    return { content: [txt(r.ok ? (r.stdout || "OK") : (r.stderr || r.stdout || "FAILED"))] };
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bsbofmusic/agent-browser-mcp-opencode",
+  "version": "0.1.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/bootstrap.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "agent-browser-mcp-opencode": "dist/bootstrap.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.1",
+    "typescript": "^5.5.0"
+  }
+}

package/src/bootstrap.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+function run(cmd: string, args: string[], opts: { silent?: boolean } = {}) {
+  const r = spawnSync(cmd, args, {
+    stdio: opts.silent ? "ignore" : "inherit",
+    shell: false,
+    windowsHide: true
+  });
+  return r.status ?? 1;
+}
+
+function ensureAgentBrowser(): { runner: "local" | "npx" | "global" } {
+  // 1) Prefer local install (no admin required)
+  const localBinWin = join(process.cwd(), "node_modules", ".bin", "agent-browser.cmd");
+  const localBinNix = join(process.cwd(), "node_modules", ".bin", "agent-browser");
+  const hasLocal = existsSync(localBinWin) || existsSync(localBinNix);
+
+  if (!hasLocal) {
+    console.error("[agent-browser-mcp] Installing agent-browser locally...");
+    const code = run("npm", ["i", "agent-browser"], { silent: false });
+    if (code === 0) {
+      return { runner: "local" };
+    }
+    console.error("[agent-browser-mcp] Local install failed, will try npx/global fallback...");
+  } else {
+    return { runner: "local" };
+  }
+
+  // 2) Fallback to npx (still no admin, but depends on npx resolving)
+  // We won't pre-install here; we'll just use npx to run it.
+  // If npx fails, try global.
+  const npxOk = run("npx", ["-y", "agent-browser", "--help"], { silent: true }) === 0;
+  if (npxOk) return { runner: "npx" };
+
+  // 3) Last resort: global install (may require admin depending on policy)
+  console.error("[agent-browser-mcp] Installing agent-browser globally (may require permissions)...");
+  const g = run("npm", ["i", "-g", "agent-browser"], { silent: false });
+  if (g !== 0) throw new Error("Failed to install agent-browser (local/npx/global all failed).");
+  return { runner: "global" };
+}
+
+function ensureChromium(runner: "local" | "npx" | "global") {
+  console.error("[agent-browser-mcp] Ensuring Chromium is installed (agent-browser install)...");
+  if (runner === "local") {
+    // Use local binary via npm exec (cross-platform)
+    const code = run("npm", ["exec", "--", "agent-browser", "install"], { silent: false });
+    if (code !== 0) throw new Error("agent-browser install failed (local).");
+    return;
+  }
+  if (runner === "npx") {
+    const code = run("npx", ["-y", "agent-browser", "install"], { silent: false });
+    if (code !== 0) throw new Error("agent-browser install failed (npx).");
+    return;
+  }
+  // global
+  const code = run("agent-browser", ["install"], { silent: false });
+  if (code !== 0) throw new Error("agent-browser install failed (global).");
+}
+
+function startMcp() {
+  console.error("[agent-browser-mcp] Starting MCP server...");
+  const code = run("node", [new URL("./index.js", import.meta.url).pathname], { silent: false });
+  process.exit(code);
+}
+
+function main() {
+  const { runner } = ensureAgentBrowser();
+  ensureChromium(runner);
+  startMcp();
+}
+
+main();

package/src/index.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+type RunResult = {
+  ok: boolean;
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  parsedJson?: unknown;
+};
+
+const env = process.env;
+const AGENT_BROWSER_BIN = env.AGENT_BROWSER_BIN || "agent-browser";
+const DEFAULT_SESSION = env.AGENT_BROWSER_SESSION || "opencode";
+const STATE_PATH = env.AGENT_BROWSER_STATE || "";
+const ALLOW_DOMAINS = (env.AGENT_BROWSER_ALLOW_DOMAINS || "").split(",").map(s => s.trim()).filter(Boolean);
+
+const DEFAULT_TIMEOUT_MS = Number(env.AGENT_BROWSER_TIMEOUT_MS || "60000");
+const MAX_OUTPUT_CHARS = Number(env.AGENT_BROWSER_MAX_OUTPUT_CHARS || "200000");
+
+// helper: ensure literal type "text"
+const txt = (text: string) => ({ type: "text" as const, text });
+
+let queue = Promise.resolve();
+function enqueue<T>(fn: () => Promise<T>): Promise<T> {
+  const next = queue.then(fn, fn);
+  queue = next.then(() => undefined, () => undefined);
+  return next;
+}
+
+function limitOutput(s: string): string {
+  if (s.length <= MAX_OUTPUT_CHARS) return s;
+  return s.slice(0, MAX_OUTPUT_CHARS) + "\n...[truncated]";
+}
+
+function domainAllowed(urlStr: string): boolean {
+  if (!ALLOW_DOMAINS.length) return true;
+  try {
+    const u = new URL(urlStr);
+    const host = u.hostname.toLowerCase();
+    return ALLOW_DOMAINS.some(d => host === d.toLowerCase() || host.endsWith("." + d.toLowerCase()));
+  } catch {
+    return false;
+  }
+}
+
+async function runAgentBrowser(args: string[], timeoutMs = DEFAULT_TIMEOUT_MS): Promise<RunResult> {
+  return await enqueue(() => new Promise<RunResult>((resolveRun) => {
+    const finalArgs: string[] = [];
+    finalArgs.push(...args, "--json");
+    finalArgs.push("--session-name", DEFAULT_SESSION);
+    if (STATE_PATH) finalArgs.push("--state", STATE_PATH);
+
+    const child = spawn(AGENT_BROWSER_BIN, finalArgs, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    let stdout = "";
+    let stderr = "";
+
+    const timer = setTimeout(() => child.kill(), timeoutMs);
+
+    child.stdout.on("data", (d) => { stdout += d.toString("utf8"); });
+    child.stderr.on("data", (d) => { stderr += d.toString("utf8"); });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const out = limitOutput(stdout.trim());
+      const err = limitOutput(stderr.trim());
+
+      let parsed: unknown | undefined;
+      try { parsed = out ? JSON.parse(out) : undefined; } catch {
+        const lines = out.split("\n").map(l => l.trim()).filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+          try { parsed = JSON.parse(lines[i]); break; } catch {}
+        }
+      }
+      resolveRun({ ok: code === 0, exitCode: code, stdout: out, stderr: err, parsedJson: parsed });
+    });
+  }));
+}
+
+const server = new McpServer({ name: "agent-browser-mcp", version: "0.1.0" });
+
+server.tool(
+  "browser_open",
+  "Open a URL in agent-browser (reuses session).",
+  { url: z.string().url(), headed: z.boolean().optional().default(false), timeoutMs: z.number().int().positive().optional() },
+  async ({ url, headed, timeoutMs }) => {
+    if (!domainAllowed(url)) return { content: [txt(`Blocked by allowlist: ${url}`)] };
+    const args = ["open", url];
+    if (headed) args.push("--headed");
+    const r = await runAgentBrowser(args, timeoutMs);
+    const content = [txt(r.ok ? "OK" : "FAILED"), txt(r.stdout || "")];
+    if (r.stderr) content.push(txt(`stderr:\n${r.stderr}`));
+    return { content };
+  }
+);
+
+server.tool(
+  "browser_click",
+  "Click an element by selector.",
+  { selector: z.string().min(1), timeoutMs: z.number().int().positive().optional() },
+  async ({ selector, timeoutMs }) => {
+    const r = await runAgentBrowser(["click", selector], timeoutMs);
+    return { content: [txt(r.ok ? (r.stdout || "OK") : (r.stderr || r.stdout || "FAILED"))] };
+  }
+);
+
+server.tool(
+  "browser_type",
+  "Type into an input/textarea by selector.",
+  { selector: z.string().min(1), text: z.string(), submit: z.boolean().optional().default(false), timeoutMs: z.number().int().positive().optional() },
+  async ({ selector, text, submit, timeoutMs }) => {
+    const args = ["type", selector, text];
+    if (submit) args.push("--submit");
+    const r = await runAgentBrowser(args, timeoutMs);
+    return { content: [txt(r.ok ? (r.stdout || "OK") : (r.stderr || r.stdout || "FAILED"))] };
+  }
+);
+
+server.tool(
+  "browser_extract",
+  "Extract text/html from a selector.",
+  { selector: z.string().min(1), mode: z.enum(["text", "html"]).optional().default("text"), timeoutMs: z.number().int().positive().optional() },
+  async ({ selector, mode, timeoutMs }) => {
+    const r = await runAgentBrowser(["extract", mode, selector], timeoutMs);
+    const payload = r.parsedJson ?? r.stdout;
+    return { content: [txt(typeof payload === "string" ? payload : JSON.stringify(payload, null, 2))] };
+  }
+);
+
+server.tool(
+  "browser_screenshot",
+  "Take a screenshot and save to a file path.",
+  { path: z.string().min(1).optional().default("agent-browser.png"), fullPage: z.boolean().optional().default(true), timeoutMs: z.number().int().positive().optional() },
+  async ({ path, fullPage, timeoutMs }) => {
+    const outPath = resolve(process.cwd(), path);
+    const args = ["screenshot", outPath];
+    if (fullPage) args.push("--full-page");
+    const r = await runAgentBrowser(args, timeoutMs);
+    const content = [txt(r.ok ? `OK: ${outPath}` : "FAILED")];
+    if (r.stdout) content.push(txt(r.stdout));
+    if (r.stderr) content.push(txt(`stderr:\n${r.stderr}`));
+    return { content };
+  }
+);
+
+server.tool(
+  "browser_set_viewport",
+  "Set viewport size.",
+  { width: z.number().int().min(200).max(4000), height: z.number().int().min(200).max(4000), timeoutMs: z.number().int().positive().optional() },
+  async ({ width, height, timeoutMs }) => {
+    const r = await runAgentBrowser(["set", "viewport", String(width), String(height)], timeoutMs);
+    return { content: [txt(r.ok ? (r.stdout || "OK") : (r.stderr || r.stdout || "FAILED"))] };
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "types": ["node"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}