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

package/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from 'fs';
+import { spawn } from 'child_process';
+import { tools, listTools } from './src/tools/index.js';
+import { execToolHandler } from './src/tools/exec.js';
+import { ensureToolHandler } from './src/tools/ensure.js';
+import { doctorToolHandler } from './src/tools/doctor.js';
+import { helpToolHandler } from './src/tools/help.js';
+import { versionToolHandler } from './src/tools/version.js';
+import { openToolHandler } from './src/tools/actions/open.js';
+import { snapshotToolHandler } from './src/tools/actions/snapshot.js';
+import { clickToolHandler } from './src/tools/actions/click.js';
+import { fillToolHandler } from './src/tools/actions/fill.js';
+import { screenshotToolHandler } from './src/tools/actions/screenshot.js';
+import { closeToolHandler } from './src/tools/actions/close.js';
+import { getTextToolHandler } from './src/tools/actions/getText.js';
+import { findToolHandler } from './src/tools/actions/find.js';
+import { waitToolHandler } from './src/tools/actions/wait.js';
+import { tabToolHandler } from './src/tools/actions/tab.js';
+import { bootstrapEnsure, ensureLatest } from './src/ensure.js';
+
+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) : '');
+  }
+}
+
+const MCP_VERSION = '1.0.0';
+let isInitialized = false;
+let stdinBuffer = '';
+
+const handlerMap = {
+  'browser_ensure': ensureToolHandler,
+  'browser_doctor': doctorToolHandler,
+  'browser_help': helpToolHandler,
+  'browser_version': versionToolHandler,
+  'browser_exec': execToolHandler,
+  'browser_open': openToolHandler,
+  'browser_snapshot': snapshotToolHandler,
+  'browser_click': clickToolHandler,
+  'browser_fill': fillToolHandler,
+  'browser_screenshot': screenshotToolHandler,
+  'browser_close': closeToolHandler,
+  'browser_get_text': getTextToolHandler,
+  'browser_find': findToolHandler,
+  'browser_wait': waitToolHandler,
+  'browser_tab': tabToolHandler,
+};
+
+async function handleMessage(message) {
+  const { jsonrpc, id, method, params } = message;
+
+  try {
+    if (method === 'initialize') {
+      const result = {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'agent-browser-mcp', version: MCP_VERSION },
+      };
+      sendResponse(id, result);
+    } else if (method === 'tools/list') {
+      const result = { tools: listTools() };
+      sendResponse(id, result);
+    } else if (method === 'tools/call') {
+      const { name, arguments: args } = params;
+      
+      log('info', `Tool called: ${name}`, args);
+      
+      const ALWAYS_LATEST = process.env.ALWAYS_LATEST !== '0';
+      
+      if (ALWAYS_LATEST && isInitialized) {
+        try {
+          const updateResult = await ensureLatest();
+          if (!updateResult.skipped && updateResult.ok) {
+            log('info', 'Updated to latest version', { version: updateResult.latestVersion });
+          }
+        } catch (e) {
+          log('warn', 'Failed to check for updates', { error: e.message });
+        }
+      }
+      
+      const handler = handlerMap[name];
+      
+      if (!handler) {
+        sendResponse(id, {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              ok: false,
+              error: `Unknown tool: ${name}`,
+              logs: [`Tool ${name} not found`],
+              nextSteps: ['Use browser_help to see available tools'],
+            }),
+          }],
+        });
+        return;
+      }
+      
+      const result = await handler(args);
+      
+      sendResponse(id, {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+      });
+    } else {
+      sendResponse(id, null);
+    }
+  } catch (error) {
+    log('error', 'Error handling message', { error: error.message });
+    sendResponse(id, null, error.message);
+  }
+}
+
+function sendResponse(id, result, error = null) {
+  const response = {
+    jsonrpc: '2.0',
+    id,
+  };
+  
+  if (error) {
+    response.error = { code: -32603, message: error };
+  } else {
+    response.result = result;
+  }
+  
+  process.stdout.write(JSON.stringify(response) + '\n');
+}
+
+function sendNotification(method, params) {
+  const notification = { jsonrpc: '2.0', method, params };
+  process.stdout.write(JSON.stringify(notification) + '\n');
+}
+
+async function initialize() {
+  if (isInitialized) return;
+  
+  log('info', 'Initializing MCP server...');
+  
+  const result = await bootstrapEnsure();
+  
+  if (!result.ok) {
+    log('warn', 'Bootstrap failed, MCP may not be fully functional', { error: result.error });
+  } else {
+    log('info', 'Bootstrap completed successfully');
+  }
+  
+  isInitialized = true;
+}
+
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', (chunk) => {
+  stdinBuffer += chunk;
+  
+  let newlineIndex;
+  while ((newlineIndex = stdinBuffer.indexOf('\n')) !== -1) {
+    const line = stdinBuffer.slice(0, newlineIndex);
+    stdinBuffer = stdinBuffer.slice(newlineIndex + 1);
+    
+    if (line.trim()) {
+      try {
+        const message = JSON.parse(line);
+        
+        if (message.method === 'initialize') {
+          initialize().then(() => {
+            handleMessage(message);
+            sendNotification('initialized', {});
+          }).catch((error) => {
+            log('error', 'Failed to initialize', { error: error.message });
+            process.exit(1);
+          });
+        } else {
+          handleMessage(message);
+        }
+      } catch (e) {
+        log('error', 'Failed to parse message', { error: e.message, line });
+      }
+    }
+  }
+});
+
+log('info', 'MCP server started, waiting for initialization...');

package/package.json

@@ -1,27 +1,42 @@
 {
   "name": "@bsbofmusic/agent-browser-mcp-opencode",
-  "version": "0.1.0",
-  "description": "",
+  "version": "1.0.0",
+  "description": "MCP server for Vercel agent-browser - browser automation CLI for AI agents",
   "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"
+    "agent-browser-mcp": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "doctor": "node index.js doctor"
   },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "agent-browser",
+    "browser-automation",
+    "ai-agent",
+    "headless-browser",
+    "vercel",
+    "opencode"
+  ],
+  "author": "bsbofmusic",
+  "license": "Apache-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "zod": "^4.0.0"
+    "execa": "^9.5.2",
+    "semver": "^7.7.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel-labs/agent-browser"
   },
-  "devDependencies": {
-    "@types/node": "^25.3.1",
-    "typescript": "^5.5.0"
+  "homepage": "https://github.com/vercel-labs/agent-browser",
+  "bugs": {
+    "url": "https://github.com/vercel-labs/agent-browser/issues"
   }
-}
+}

package/src/detect.js

@@ -0,0 +1,286 @@
+import { execSync, exec } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+
+export const DETECT_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[DETECT_LOG_LEVEL]) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [${level.toUpperCase()}] ${message}`, data ? JSON.stringify(data) : '');
+  }
+}
+
+export async function detectOS() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const release = os.release();
+  
+  let isAdmin = false;
+  try {
+    if (platform === 'win32') {
+      execSync('net session', { stdio: 'ignore' });
+      isAdmin = true;
+    } else {
+      execSync('id -u', { stdio: 'ignore' });
+      isAdmin = process.getuid?.() === 0 || execSync('id -u').toString().trim() === '0';
+    }
+  } catch (e) {
+    isAdmin = false;
+  }
+
+  return {
+    platform,
+    arch,
+    release,
+    isAdmin,
+    cpus: os.cpus().length,
+    totalMemory: os.totalmem(),
+    freeMemory: os.freemem(),
+  };
+}
+
+export async function detectRuntime() {
+  const results = {
+    node: { available: false, version: null },
+    npm: { available: false, version: null },
+    pnpm: { available: false, version: null },
+    yarn: { available: false, version: null },
+  };
+
+  const checkCommand = (cmd) => {
+    try {
+      const version = execSync(`${cmd} --version`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      return version;
+    } catch (e) {
+      return null;
+    }
+  };
+
+  results.node = { available: true, version: process.version };
+  results.npm = { available: false, version: checkCommand('npm') };
+  results.pnpm = { available: false, version: checkCommand('pnpm') };
+  results.yarn = { available: false, version: checkCommand('yarn') };
+
+  if (results.npm.version) results.npm.available = true;
+  if (results.pnpm.version) results.pnpm.available = true;
+  if (results.yarn.version) results.yarn.available = true;
+
+  return results;
+}
+
+export async function detectPackageManager() {
+  const managers = [];
+  
+  const checkCmd = (cmd) => {
+    try {
+      execSync(`${cmd} --version`, { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  if (checkCmd('npm')) managers.push('npm');
+  if (checkCmd('pnpm')) managers.push('pnpm');
+  if (checkCmd('yarn')) managers.push('yarn');
+
+  return managers;
+}
+
+export async function detectDocker() {
+  let available = false;
+  let version = null;
+
+  try {
+    version = execSync('docker --version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    available = true;
+  } catch (e) {
+    try {
+      version = execSync('podman --version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      available = true;
+    } catch (e2) {
+      available = false;
+    }
+  }
+
+  return { available, version };
+}
+
+export async function detectNetwork() {
+  const checks = {
+    npmRegistry: false,
+    github: false,
+    google: false,
+  };
+
+  const checkUrl = (url) => {
+    return new Promise((resolve) => {
+      const cmd = process.platform === 'win32' 
+        ? `ping -n 1 -w 1000 ${url} > nul 2>&1 && echo OK`
+        : `ping -c 1 -W 1 ${url} > /dev/null 2>&1 && echo OK`;
+      
+      try {
+        execSync(cmd, { encoding: 'utf8', timeout: 3000 });
+        resolve(true);
+      } catch {
+        resolve(false);
+      }
+    });
+  };
+
+  checks.npmRegistry = await checkUrl('registry.npmjs.org');
+  checks.github = await checkUrl('github.com');
+  checks.google = await checkUrl('google.com');
+
+  return checks;
+}
+
+export async function detectDisk() {
+  try {
+    const checkDir = process.platform === 'win32' ? 'C:' : '/';
+    const stats = require('child_process').execSync(
+      process.platform === 'win32' 
+        ? `wmic logicaldisk where "DeviceID='${checkDir}'" get Size,FreeSpace /value`
+        : `df -k "${checkDir}"`,
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
+    );
+    
+    let freeSpace = 0;
+    let totalSpace = 0;
+    
+    if (process.platform === 'win32') {
+      const freeMatch = checkDir === 'C:' ? checkDir.match(/FreeSpace=(\d+)/) : null;
+      const sizeMatch = checkDir === 'C:' ? checkDir.match(/Size=(\d+)/) : null;
+      if (freeMatch) freeSpace = parseInt(freeMatch[1], 10);
+      if (sizeMatch) totalSpace = parseInt(sizeMatch[1], 10);
+    } else {
+      const parts = checkDir.trim().split(/\s+/);
+      if (parts.length >= 4) {
+        freeSpace = parseInt(parts[3], 10) * 1024;
+        totalSpace = parseInt(parts[1], 10) * 1024;
+      }
+    }
+
+    return {
+      freeSpace,
+      totalSpace,
+      hasEnoughSpace: freeSpace > 1024 * 1024 * 1024,
+    };
+  } catch (e) {
+    return { freeSpace: 0, totalSpace: 0, hasEnoughSpace: false };
+  }
+}
+
+export async function detectAgentBrowser() {
+  let installed = false;
+  let version = null;
+  let chromiumInstalled = false;
+  let path_ = null;
+
+  try {
+    version = execSync('agent-browser --version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    installed = true;
+  } catch (e) {
+    try {
+      version = execSync('npx agent-browser --version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      installed = true;
+    } catch (e2) {
+      installed = false;
+    }
+  }
+
+  if (installed) {
+    try {
+      execSync('agent-browser --help', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      chromiumInstalled = true;
+    } catch (e) {
+      chromiumInstalled = false;
+    }
+
+    const homeDir = os.homedir();
+    path_ = path.join(homeDir, '.agent-browser');
+  }
+
+  return {
+    installed,
+    version,
+    chromiumInstalled,
+    path: path_,
+  };
+}
+
+export async function detectPermissions() {
+  const checks = {
+    npmGlobalWritable: false,
+    tempWritable: false,
+    homeWritable: false,
+  };
+
+  try {
+    execSync('npm config get prefix', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    checks.npmGlobalWritable = true;
+  } catch (e) {
+    checks.npmGlobalWritable = false;
+  }
+
+  try {
+    const tempDir = os.tmpdir();
+    const testFile = path.join(tempDir, `agent-browser-test-${Date.now()}`);
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    checks.tempWritable = true;
+  } catch (e) {
+    checks.tempWritable = false;
+  }
+
+  try {
+    const homeDir = os.homedir();
+    const testFile = path.join(homeDir, `.agent-browser-test-${Date.now()}`);
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    checks.homeWritable = true;
+  } catch (e) {
+    checks.homeWritable = false;
+  }
+
+  return checks;
+}
+
+export async function runFullDetection() {
+  log('info', 'Starting full environment detection...');
+  
+  const detection = {
+    timestamp: new Date().toISOString(),
+    os: await detectOS(),
+    runtime: await detectRuntime(),
+    packageManagers: await detectPackageManager(),
+    docker: await detectDocker(),
+    network: await detectNetwork(),
+    disk: await detectDisk(),
+    agentBrowser: await detectAgentBrowser(),
+    permissions: await detectPermissions(),
+  };
+
+  log('info', 'Environment detection completed', detection);
+  return detection;
+}
+
+export default {
+  detectOS,
+  detectRuntime,
+  detectPackageManager,
+  detectDocker,
+  detectNetwork,
+  detectDisk,
+  detectAgentBrowser,
+  detectPermissions,
+  runFullDetection,
+};