real-browser-mcp-server 1.3.4 → 1.4.0

package/lib/cjs/index.js

@@ -1,352 +0,0 @@
-const { PlaywrightBlocker } = require("@ghostery/adblocker-playwright");
-const { pageController } = require("./module/pageController.js");
-
-const { chromium } = require("patchright");
-const { createCursor } = require("ghost-cursor-patchright");
-const fs = require('fs');
-const path = require('path');
-
-let adBlockerInstance = null;
-let adBlockerPromise = null;
-function getAdBlocker() {
-  if (!adBlockerPromise) {
-    const cachePath = path.join(__dirname, 'adblocker.bin');
-    adBlockerPromise = PlaywrightBlocker.fromPrebuiltAdsAndTracking(fetch, {
-      path: cachePath,
-      read: fs.promises.readFile,
-      write: fs.promises.writeFile,
-    }).then(blocker => {
-      adBlockerInstance = blocker;
-      return blocker;
-    }).catch(err => {
-      console.error('[adblocker] Failed to initialize adblocker:', err.message);
-      return null;
-    });
-  }
-  return adBlockerPromise;
-}
-
-function loadEnvFile() {
-  const envPaths = [
-    path.join(process.cwd(), '.env'),
-  ];
-
-  let currentDir = process.cwd();
-  for (let i = 0; i < 5; i++) {
-    const envPath = path.join(currentDir, '.env');
-    if (fs.existsSync(envPath) && !envPaths.includes(envPath)) {
-      envPaths.push(envPath);
-    }
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-  }
-
-  for (const envPath of envPaths) {
-    try {
-      if (fs.existsSync(envPath)) {
-        const envContent = fs.readFileSync(envPath, 'utf-8');
-        envContent.split('\n').forEach(line => {
-          const trimmed = line.trim();
-          if (trimmed && !trimmed.startsWith('#')) {
-            const [key, ...valueParts] = trimmed.split('=');
-            const value = valueParts.join('=').replace(/^["']|["']$/g, '');
-            if (key && !process.env[key]) {
-              process.env[key] = value;
-            }
-          }
-        });
-        break;
-      }
-    } catch (error) {
-      // Silently ignore .env loading errors
-    }
-  }
-}
-
-loadEnvFile();
-
-function getDefaultHeadless() {
-  const envHeadless = (process.env.HEADLESS || '').toLowerCase();
-  return envHeadless === 'true';
-}
-
-function applyBrowserShims(browser, page) {
-  if (page._shimsApplied) return page;
-  page._shimsApplied = true;
-
-  // Enable ad blocker
-  if (adBlockerInstance) {
-    adBlockerInstance.enableBlockingInPage(page).catch(() => {});
-  } else {
-    getAdBlocker().then(blocker => {
-      if (blocker) {
-        blocker.enableBlockingInPage(page).catch(() => {});
-      }
-    });
-  }
-
-  // Cookie shims (Compatibility adapter for Playwright context)
-  if (!page.cookies) {
-    page.cookies = async (urls) => {
-      return await page.context().cookies(urls ? (Array.isArray(urls) ? urls : [urls]) : []);
-    };
-  }
-
-  if (!page.setCookie) {
-    page.setCookie = async (...cookies) => {
-      const formatted = cookies.map(c => ({
-        name: c.name,
-        value: c.value,
-        domain: c.domain || new URL(page.url()).hostname,
-        path: c.path || '/',
-        expires: c.expires || undefined,
-        httpOnly: c.httpOnly,
-        secure: c.secure,
-        sameSite: c.sameSite
-      }));
-      await page.context().addCookies(formatted);
-    };
-  }
-
-  if (!page.deleteCookie) {
-    page.deleteCookie = async (...cookies) => {
-      await page.context().clearCookies();
-    };
-  }
-
-  // Navigation shims
-  if (!page.waitForNetworkIdle) {
-    page.waitForNetworkIdle = async (options = {}) => {
-      try {
-        await page.waitForLoadState('networkidle', { timeout: options.timeout });
-      } catch (e) {
-        // Ignore networkidle timeouts if they are non-fatal
-      }
-    };
-  }
-
-  if (!page.evaluateOnNewDocument) {
-    page.evaluateOnNewDocument = async (fn, ...args) => {
-      return await page.addInitScript(fn, ...args);
-    };
-  }
-
-  // Ghost Cursor integration via ghost-cursor-patchright
-  const cursorPromise = createCursor(page).catch(err => {
-    console.error("Failed to create cursor:", err);
-    return null;
-  });
-
-  page.realCursor = {
-    move: async (selector, options = {}) => {
-      try {
-        const cursor = await cursorPromise;
-        if (cursor) {
-          await cursor.move(selector, options);
-        } else {
-          await page.hover(selector, options);
-        }
-      } catch (e) {
-        // Silently fallback if element is not found
-        try {
-          await page.hover(selector, options);
-        } catch (err) {}
-      }
-    }
-  };
-  page.realClick = async (selector, options = {}) => {
-    try {
-      const cursor = await cursorPromise;
-      if (cursor) {
-        await cursor.click(selector, options);
-      } else {
-        await page.click(selector, options);
-      }
-    } catch (e) {
-      await page.click(selector, options);
-    }
-  };
-
-  // Mouse wheel shim (Adapter for Playwright positional args)
-  if (page.mouse && page.mouse.wheel) {
-    const originalWheel = page.mouse.wheel.bind(page.mouse);
-    page.mouse.wheel = async (x, y) => {
-      if (typeof x === 'object' && x !== null) {
-        const deltaX = x.deltaX || 0;
-        const deltaY = x.deltaY || 0;
-        return await originalWheel(deltaX, deltaY);
-      }
-      return await originalWheel(x, y);
-    };
-  }
-
-  // Browser shims
-  if (!browser.process) {
-    browser.process = () => ({
-      pid: browser._childProcess?.pid || 1337
-    });
-  }
-
-  if (!browser.pages) {
-    browser.pages = async () => {
-      return browser.contexts().flatMap(c => c.pages());
-    };
-  }
-
-  return page;
-}
-
-async function connect({
-  args = [],
-  headless = getDefaultHeadless(),
-  proxy = {},
-  turnstile = false,
-  disableXvfb = false,
-} = {}) {
-  let xvfbInstance = null;
-  if (process.platform === 'linux' && !process.env.DISPLAY && !disableXvfb) {
-    try {
-      const Xvfb = require('xvfb');
-      xvfbInstance = new Xvfb({
-        silent: true,
-        xvfb_args: ['-screen', '0', '1280x1024x24', '-ac']
-      });
-      xvfbInstance.startSync();
-    } catch (err) {
-      console.error('[xvfb] Failed to start Xvfb server automatically:', err.message);
-    }
-  }
-
-  let playwrightProxy = undefined;
-  if (proxy && proxy.host && proxy.port) {
-    playwrightProxy = {
-      server: `${proxy.host}:${proxy.port}`
-    };
-    if (proxy.username && proxy.password) {
-      playwrightProxy.username = proxy.username;
-      playwrightProxy.password = proxy.password;
-    }
-  }
-
-  const chromiumArgs = [
-    '--disable-blink-features=AutomationControlled',
-    '--no-sandbox',
-    '--disable-setuid-sandbox',
-    '--window-size=1920,1080',
-    ...args
-  ];
-
-  if (headless) {
-    chromiumArgs.push(
-      '--headless=new',
-      '--disable-gpu',
-      '--hide-scrollbars',
-      '--mute-audio'
-    );
-  }
-
-function getBravePath() {
-  if (process.platform === 'win32') {
-    const paths = [
-      "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-      "C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe",
-      path.join(process.env.LOCALAPPDATA || '', 'BraveSoftware\\Brave-Browser\\Application\\brave.exe'),
-      path.join(process.env.PROGRAMFILES || '', 'BraveSoftware\\Brave-Browser\\Application\\brave.exe'),
-      path.join(process.env['PROGRAMFILES(X86)'] || '', 'BraveSoftware\\Brave-Browser\\Application\\brave.exe')
-    ];
-    for (const p of paths) {
-      if (p && fs.existsSync(p)) return p;
-    }
-  } else if (process.platform === 'darwin') {
-    const paths = [
-      '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'
-    ];
-    for (const p of paths) {
-      if (fs.existsSync(p)) return p;
-    }
-  } else if (process.platform === 'linux') {
-    const paths = [
-      '/usr/bin/brave-browser',
-      '/usr/bin/brave'
-    ];
-    for (const p of paths) {
-      if (fs.existsSync(p)) return p;
-    }
-  }
-  return null;
-}
-
-  const bravePath = getBravePath();
-  if (!bravePath) {
-    throw new Error("Brave Browser was not found on this system. Real Browser MCP Server is configured to exclusively use Brave Browser.");
-  }
-
-  let browser;
-  try {
-    browser = await chromium.launch({
-      headless: false, // Prevent Playwright from adding leaky headless shims
-      args: chromiumArgs,
-      proxy: playwrightProxy,
-      executablePath: bravePath
-    });
-    console.error('[Launch] Successfully launched system Brave Browser');
-  } catch (err) {
-    console.error('[Launch] Failed to launch system Brave Browser:', err.message);
-    throw err;
-  }
-
-  if (xvfbInstance) {
-    browser.on('disconnected', () => {
-      try {
-        xvfbInstance.stopSync();
-      } catch (e) {
-        console.error('[xvfb] Failed to stop Xvfb server:', e.message);
-      }
-    });
-    const originalClose = browser.close.bind(browser);
-    browser.close = async () => {
-      await originalClose();
-      try {
-        xvfbInstance.stopSync();
-      } catch (e) {
-        console.error('[xvfb] Failed to stop Xvfb server during close:', e.message);
-      }
-    };
-  }
-
-  // Ensure ad blocker is ready
-  await getAdBlocker();
-
-  const context = await browser.newContext({
-    viewport: null,
-  });
-
-  let page = await context.newPage();
-
-  applyBrowserShims(browser, page);
-
-  page = await pageController({
-    browser,
-    page,
-    proxy,
-    turnstile,
-  });
-
-  context.on('page', async (newPage) => {
-    applyBrowserShims(browser, newPage);
-    await pageController({
-      browser,
-      page: newPage,
-      proxy,
-      turnstile,
-    });
-  });
-
-  return {
-    browser,
-    page,
-  };
-}
-
-module.exports = { connect };

package/src/ai/action-parser.js

@@ -1,274 +0,0 @@
-/**
- * AI Action Parser - Parse natural language commands into actions
- * 
- * Converts commands like:
- * - "click the login button" -> { type: 'click', target: 'login button' }
- * - "type hello in the search box" -> { type: 'type', target: 'search box', text: 'hello' }
- * - "scroll down" -> { type: 'scroll', direction: 'down' }
- */
-
-class ActionParser {
-  constructor() {
-    // Action patterns
-    this.actionPatterns = [
-      // Click patterns
-      {
-        pattern: /^(click|tap|press|hit|select)\s+(?:on\s+)?(?:the\s+)?(.+)/i,
-        type: 'click',
-        extract: (match) => ({ target: match[2].trim() })
-      },
-      // Type patterns
-      {
-        pattern: /^(type|enter|write|input)\s+["']?([^"']+)["']?\s+(?:in|into|in the|into the)\s+(.+)/i,
-        type: 'type',
-        extract: (match) => ({ text: match[2].trim(), target: match[3].trim() })
-      },
-      {
-        pattern: /^(type|enter|write|input)\s+(.+)\s+(?:in|into)\s+["']?([^"']+)["']?/i,
-        type: 'type',
-        extract: (match) => ({ target: match[2].trim(), text: match[3].trim() })
-      },
-      {
-        pattern: /^(fill|fill in|complete)\s+(?:the\s+)?(.+)\s+(?:with|as)\s+["']?([^"']+)["']?/i,
-        type: 'type',
-        extract: (match) => ({ target: match[2].trim(), text: match[3].trim() })
-      },
-      // Navigate patterns
-      {
-        pattern: /^(go to|navigate to|open|visit)\s+(.+)/i,
-        type: 'navigate',
-        extract: (match) => {
-          let url = match[2].trim();
-          if (!url.startsWith('http')) {
-            url = 'https://' + url;
-          }
-          return { url };
-        }
-      },
-      // Scroll patterns
-      {
-        pattern: /^scroll\s+(up|down|left|right)(?:\s+(\d+)\s*(?:px|pixels)?)?/i,
-        type: 'scroll',
-        extract: (match) => ({ 
-          direction: match[1].toLowerCase(), 
-          amount: parseInt(match[2]) || 300 
-        })
-      },
-      {
-        pattern: /^scroll\s+to\s+(?:the\s+)?(top|bottom|footer|header)/i,
-        type: 'scroll',
-        extract: (match) => {
-          const target = match[1].toLowerCase();
-          return {
-            direction: target === 'top' || target === 'header' ? 'up' : 'down',
-            amount: 10000,
-            scrollTo: target
-          };
-        }
-      },
-      // Wait patterns
-      {
-        pattern: /^wait\s+(?:for\s+)?(\d+)\s*(?:ms|milliseconds?|s|seconds?)?/i,
-        type: 'wait',
-        extract: (match) => {
-          let duration = parseInt(match[1]);
-          const unit = match[0].toLowerCase();
-          if (unit.includes('s') && !unit.includes('ms')) {
-            duration *= 1000;
-          }
-          return { duration };
-        }
-      },
-      {
-        pattern: /^wait\s+(?:for\s+)?(?:the\s+)?(.+?)(?:\s+to\s+(?:appear|load|show))?$/i,
-        type: 'waitFor',
-        extract: (match) => ({ target: match[1].trim() })
-      },
-      // Find/Search patterns
-      {
-        pattern: /^(find|search|look for|locate)\s+(?:the\s+)?(.+)/i,
-        type: 'find',
-        extract: (match) => ({ query: match[2].trim() })
-      },
-      // Hover patterns
-      {
-        pattern: /^(hover|mouse over|move to)\s+(?:the\s+)?(.+)/i,
-        type: 'hover',
-        extract: (match) => ({ target: match[2].trim() })
-      },
-      // Clear patterns
-      {
-        pattern: /^(clear|empty|delete)\s+(?:the\s+)?(.+)/i,
-        type: 'clear',
-        extract: (match) => ({ target: match[2].trim() })
-      },
-      // Submit patterns
-      {
-        pattern: /^submit\s+(?:the\s+)?(?:form)?(.*)$/i,
-        type: 'submit',
-        extract: (match) => ({ target: match[1].trim() || 'form' })
-      },
-      // Screenshot patterns
-      {
-        pattern: /^(take|capture)\s+(?:a\s+)?screenshot/i,
-        type: 'screenshot',
-        extract: () => ({})
-      },
-      // Go back/forward patterns
-      {
-        pattern: /^go\s+(back|forward)/i,
-        type: 'navigation',
-        extract: (match) => ({ direction: match[1].toLowerCase() })
-      },
-      // Refresh patterns
-      {
-        pattern: /^(refresh|reload)\s*(?:the\s+)?(?:page)?/i,
-        type: 'refresh',
-        extract: () => ({})
-      }
-    ];
-
-    // Context variable patterns (for substitution)
-    this.variablePattern = /\{(\w+)\}/g;
-  }
-
-  /**
-   * Parse a natural language command
-   */
-  async parse(command, context = {}) {
-    // Substitute context variables
-    let processedCommand = command.replace(this.variablePattern, (match, varName) => {
-      return context[varName] !== undefined ? context[varName] : match;
-    });
-
-    // Trim and normalize
-    processedCommand = processedCommand.trim();
-
-    // Try each pattern
-    for (const pattern of this.actionPatterns) {
-      const match = processedCommand.match(pattern.pattern);
-      if (match) {
-        const extracted = pattern.extract(match);
-        return {
-          type: pattern.type,
-          ...extracted,
-          originalCommand: command,
-          confidence: 0.9
-        };
-      }
-    }
-
-    // Fallback: Try to guess action from keywords
-    const fallback = this.guessFallback(processedCommand);
-    if (fallback) {
-      return {
-        ...fallback,
-        originalCommand: command,
-        confidence: 0.5
-      };
-    }
-
-    // Could not parse
-    return {
-      type: 'unknown',
-      originalCommand: command,
-      confidence: 0,
-      error: 'Could not understand command'
-    };
-  }
-
-  /**
-   * Try to guess action from keywords
-   */
-  guessFallback(command) {
-    const lower = command.toLowerCase();
-
-    // Check for action keywords
-    if (lower.includes('button') || lower.includes('link') || lower.includes('click')) {
-      return { type: 'click', target: command };
-    }
-
-    if (lower.includes('type') || lower.includes('enter') || lower.includes('input')) {
-      return { type: 'find', query: command, suggestedAction: 'type' };
-    }
-
-    if (lower.includes('search') || lower.includes('find') || lower.includes('look')) {
-      return { type: 'find', query: command };
-    }
-
-    if (lower.includes('scroll')) {
-      return { type: 'scroll', direction: 'down', amount: 300 };
-    }
-
-    // Default to find
-    return { type: 'find', query: command };
-  }
-
-  /**
-   * Parse multiple commands (separated by 'then', 'and', or newlines)
-   */
-  async parseMultiple(commands, context = {}) {
-    // Split by separators
-    const parts = commands.split(/\s+(?:then|and)\s+|\n|;/i).filter(p => p.trim());
-    
-    const results = [];
-    for (const part of parts) {
-      const parsed = await this.parse(part.trim(), context);
-      results.push(parsed);
-    }
-
-    return results;
-  }
-
-  /**
-   * Get suggestions for incomplete commands
-   */
-  getSuggestions(partialCommand) {
-    const lower = partialCommand.toLowerCase();
-    const suggestions = [];
-
-    if (lower.startsWith('click')) {
-      suggestions.push(
-        'click the login button',
-        'click the submit button',
-        'click the link',
-        'click the menu'
-      );
-    } else if (lower.startsWith('type')) {
-      suggestions.push(
-        'type "text" in the search box',
-        'type "username" in the login field',
-        'type "hello" in the input'
-      );
-    } else if (lower.startsWith('go')) {
-      suggestions.push(
-        'go to google.com',
-        'go back',
-        'go forward'
-      );
-    } else if (lower.startsWith('scroll')) {
-      suggestions.push(
-        'scroll down',
-        'scroll up',
-        'scroll to the bottom',
-        'scroll to the top'
-      );
-    } else if (lower.startsWith('wait')) {
-      suggestions.push(
-        'wait 2 seconds',
-        'wait for the button to appear',
-        'wait 500ms'
-      );
-    } else if (lower.startsWith('find')) {
-      suggestions.push(
-        'find the login button',
-        'find the search input',
-        'find all links'
-      );
-    }
-
-    return suggestions;
-  }
-}
-
-module.exports = ActionParser;