@bsbofmusic/agent-browser-mcp-opencode 0.1.1 → 1.0.0

package/src/tools/ensure.js

@@ -0,0 +1,46 @@
+import { fullEnsure, bootstrapEnsure } from '../ensure.js';
+
+export const ensureTool = {
+  name: 'browser_ensure',
+  description: 'Manually trigger full environment repair. Installs or upgrades agent-browser CLI and Chromium browser. This is idempotent - can be run multiple times safely.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      force: {
+        type: 'boolean',
+        description: 'Force reinstall even if already installed (default: false)',
+        default: false,
+      },
+    },
+  },
+};
+
+export async function ensureToolHandler(args = {}) {
+  const { force = false } = args;
+  const logs = [];
+  
+  logs.push(`[${new Date().toISOString()}] browser_ensure called (force=${force})`);
+  
+  if (force) {
+    const result = await fullEnsure();
+    return {
+      ok: result.ok,
+      logs: result.logs,
+      stdout: result.logs.join('\n'),
+      version: result.version,
+      latestVersion: result.latestVersion,
+      duration: result.duration,
+      nextSteps: result.ok ? [] : ['Check logs for errors', 'Run: browser_doctor for diagnosis'],
+    };
+  }
+  
+  const result = await bootstrapEnsure();
+  
+  return {
+    ok: result.ok,
+    logs: result.logs,
+    stdout: result.logs.join('\n'),
+    duration: result.duration,
+    nextSteps: result.ok ? [] : result.nextSteps || [],
+  };
+}

package/src/tools/exec.js

@@ -0,0 +1,120 @@
+import { execSync } from 'child_process';
+
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+
+function log(level, message, data = null) {
+  const levels = { error: 0, warn: 1, info: 2, debug: 3 };
+  if (levels[level] <= levels[LOG_LEVEL]) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [${level.toUpperCase()}] ${message}`, data ? JSON.stringify(data) : '');
+  }
+}
+
+export const execTool = {
+  name: 'browser_exec',
+  description: 'Execute any agent-browser CLI command. Use this for commands not covered by structured tools. Examples: agent-browser open <url>, agent-browser click <selector>, agent-browser fill <selector> <text>, agent-browser find role button click --name "Submit", etc.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: {
+        type: 'string',
+        description: 'The full agent-browser command to execute (without "agent-browser" prefix). Example: "open example.com" or "click #submit"',
+      },
+      timeoutMs: {
+        type: 'number',
+        description: 'Timeout in milliseconds (default: 120000)',
+        default: 120000,
+      },
+      cwd: {
+        type: 'string',
+        description: 'Working directory for the command',
+      },
+      json: {
+        type: 'boolean',
+        description: 'Request JSON output from agent-browser (default: true)',
+        default: true,
+      },
+    },
+    required: ['command'],
+  },
+};
+
+export async function execToolHandler(args) {
+  const { command, timeoutMs = 120000, cwd, json = true } = args;
+  const logs = [];
+  const startTime = Date.now();
+  
+  logs.push(`[${new Date().toISOString()}] Executing: agent-browser ${command}`);
+  
+  try {
+    const fullCommand = `agent-browser ${command}${json ? ' --json' : ''}`;
+    log('info', 'Executing command', { command: fullCommand, timeoutMs, cwd });
+    
+    const options = {
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      maxBuffer: 50 * 1024 * 1024,
+    };
+    
+    if (cwd) {
+      options.cwd = cwd;
+    }
+    
+    const stdout = execSync(fullCommand, options);
+    const elapsed = Date.now() - startTime;
+    
+    logs.push(`[${new Date().toISOString()}] Completed in ${elapsed}ms`);
+    
+    let parsedOutput = stdout;
+    if (json) {
+      try {
+        parsedOutput = JSON.parse(stdout);
+      } catch {
+        parsedOutput = stdout;
+      }
+    }
+    
+    return {
+      ok: true,
+      logs,
+      stdout,
+      output: parsedOutput,
+      duration: elapsed,
+    };
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    const errorMsg = error.message || String(error);
+    const stderr = error.stderr || '';
+    
+    logs.push(`[${new Date().toISOString()}] Error after ${elapsed}ms: ${errorMsg}`);
+    
+    let parsedError = errorMsg;
+    if (json && stderr) {
+      try {
+        parsedError = JSON.parse(stderr);
+      } catch {
+        parsedError = stderr;
+      }
+    }
+    
+    const nextSteps = [
+      'Check if the command syntax is correct',
+      'Run: agent-browser --help to see available commands',
+      'Check if browser is running: agent-browser tab',
+    ];
+    
+    if (error.message?.includes('ENOENT') || error.message?.includes('not found')) {
+      nextSteps.push('Run: browser_ensure to install agent-browser');
+    }
+    
+    return {
+      ok: false,
+      logs,
+      stderr,
+      error: errorMsg,
+      output: parsedError,
+      duration: elapsed,
+      nextSteps,
+    };
+  }
+}

package/src/tools/help.js

@@ -0,0 +1,76 @@
+import { execSync } from 'child_process';
+
+export const helpTool = {
+  name: 'browser_help',
+  description: 'List all available agent-browser commands and capabilities. Provides self-discovery of MCP tools.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: {
+        type: 'string',
+        description: 'Optional: specific command to get help for (e.g., "open", "click", "snapshot")',
+      },
+    },
+  },
+};
+
+export async function helpToolHandler(args = {}) {
+  const { command } = args;
+  const logs = [];
+  
+  logs.push(`[${new Date().toISOString()}] browser_help called`);
+  
+  const toolDescription = `
+=== Browser Automation MCP Tools ===
+
+Core Tools:
+- browser_ensure: Install/repair agent-browser and Chromium
+- browser_doctor: Diagnose issues and get fix recommendations
+- browser_help: Show this help message
+- browser_version: Show version information
+- browser_exec: Execute any agent-browser CLI command
+
+Structured Actions:
+- browser_open: Navigate to URL
+- browser_snapshot: Get accessibility tree with refs
+- browser_click: Click an element
+- browser_fill: Fill a form field
+- browser_screenshot: Take a screenshot
+- browser_close: Close the browser
+- browser_get_text: Get text content from element
+- browser_find: Find element by semantic locator
+- browser_wait: Wait for element/text/URL
+- browser_tab: Manage browser tabs
+`;
+  
+  let helpText = toolDescription;
+  
+  if (command) {
+    try {
+      const helpOutput = execSync(`agent-browser ${command} --help`, { encoding: 'utf8', timeout: 10000 });
+      helpText = `=== Help for: ${command} ===\n\n${helpOutput}`;
+    } catch (e) {
+      helpText = `Could not get help for "${command}". The command may not exist or require installation.`;
+    }
+  } else {
+    try {
+      const cliHelp = execSync('agent-browser --help', { encoding: 'utf8', timeout: 10000 });
+      helpText += `\n\n=== agent-browser CLI Help ===\n\n${cliHelp}`;
+    } catch (e) {
+      helpText += '\n\nRun browser_ensure first to install agent-browser.';
+    }
+  }
+  
+  return {
+    ok: true,
+    logs,
+    stdout: helpText,
+    output: helpText,
+    commands: [
+      'open', 'snapshot', 'click', 'fill', 'screenshot', 'close',
+      'get', 'find', 'wait', 'tab', 'type', 'press', 'hover',
+      'select', 'check', 'uncheck', 'scroll', 'drag', 'upload',
+      'cookies', 'storage', 'network', 'back', 'forward', 'reload',
+    ],
+  };
+}

package/src/tools/index.js

@@ -0,0 +1,50 @@
+import { execTool } from './exec.js';
+import { ensureTool } from './ensure.js';
+import { doctorTool } from './doctor.js';
+import { helpTool } from './help.js';
+import { versionTool } from './version.js';
+import { openTool } from './actions/open.js';
+import { snapshotTool } from './actions/snapshot.js';
+import { clickTool } from './actions/click.js';
+import { fillTool } from './actions/fill.js';
+import { screenshotTool } from './actions/screenshot.js';
+import { closeTool } from './actions/close.js';
+import { getTextTool } from './actions/getText.js';
+import { findTool } from './actions/find.js';
+import { waitTool } from './actions/wait.js';
+import { tabTool } from './actions/tab.js';
+
+export const tools = [
+  ensureTool,
+  doctorTool,
+  helpTool,
+  versionTool,
+  execTool,
+  openTool,
+  snapshotTool,
+  clickTool,
+  fillTool,
+  screenshotTool,
+  closeTool,
+  getTextTool,
+  findTool,
+  waitTool,
+  tabTool,
+];
+
+export const toolMap = {};
+for (const tool of tools) {
+  toolMap[tool.name] = tool;
+}
+
+export function getTool(name) {
+  return toolMap[name];
+}
+
+export function listTools() {
+  return tools.map(t => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema,
+  }));
+}

package/src/tools/version.js

@@ -0,0 +1,83 @@
+import { execSync } from 'child_process';
+import ensure from '../ensure.js';
+const { getAgentBrowserVersion, checkForUpdates } = ensure;
+
+const MCP_VERSION = '1.0.0';
+
+export const versionTool = {
+  name: 'browser_version',
+  description: 'Show version information for this MCP and the wrapped agent-browser CLI. Includes current version, latest available version, and update strategy.',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+  },
+};
+
+export async function versionToolHandler(args = {}) {
+  const logs = [];
+  
+  logs.push(`[${new Date().toISOString()}] browser_version called`);
+  
+  const mcpVersion = MCP_VERSION;
+  const alwaysLatest = process.env.ALWAYS_LATEST !== '0';
+  const updateStrategy = process.env.UPDATE_STRATEGY || 'simple';
+  
+  let agentBrowserInfo = {
+    installed: false,
+    version: null,
+  };
+  
+  try {
+    agentBrowserInfo = await getAgentBrowserVersion();
+  } catch (e) {
+    agentBrowserInfo = { installed: false, version: null };
+  }
+  
+  let updateInfo = {
+    hasUpdate: null,
+    currentVersion: agentBrowserInfo.version,
+    latestVersion: null,
+  };
+  
+  try {
+    updateInfo = await checkForUpdates();
+  } catch (e) {
+    updateInfo = {
+      hasUpdate: null,
+      currentVersion: agentBrowserInfo.version,
+      latestVersion: null,
+    };
+  }
+  
+  const output = {
+    mcp: {
+      version: mcpVersion,
+      name: '@bsbofmusic/agent-browser-mcp-opencode',
+    },
+    agentBrowser: {
+      installed: agentBrowserInfo.installed,
+      currentVersion: agentBrowserInfo.version,
+      latestVersion: updateInfo.latestVersion,
+      hasUpdate: updateInfo.hasUpdate,
+    },
+    updateStrategy: {
+      alwaysLatest,
+      strategy: updateStrategy,
+      description: updateStrategy === 'atomic' 
+        ? 'Atomic updates with staging directory and rollback'
+        : 'Simple updates without rollback',
+    },
+    environment: {
+      nodeVersion: process.version,
+      platform: process.platform,
+      arch: process.arch,
+    },
+  };
+  
+  return {
+    ok: true,
+    logs,
+    stdout: JSON.stringify(output, null, 2),
+    ...output,
+  };
+}

package/dist/bootstrap.js

@@ -1,72 +0,0 @@
-#!/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

@@ -1,121 +0,0 @@
-#!/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/src/bootstrap.ts

@@ -1,75 +0,0 @@
-#!/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();