stealth-cli 0.5.0

package/src/commands/fingerprint.js

@@ -0,0 +1,306 @@
+/**
+ * stealth fingerprint - Check browser fingerprint and anti-detection status
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import { launchBrowser, closeBrowser, navigate, evaluate, waitForReady } from '../browser.js';
+import { log } from '../output.js';
+
+export function registerFingerprint(program) {
+  program
+    .command('fingerprint')
+    .description('Check browser fingerprint and anti-detection status')
+    .option('--profile <name>', 'Use a browser profile')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--json', 'Output as JSON')
+    .option('--check', 'Run anti-detection tests against bot detection sites')
+    .option('--compare <n>', 'Launch N times and compare fingerprints for uniqueness', '1')
+    .option('--no-headless', 'Show browser window')
+    .action(async (opts) => {
+      const compareCount = parseInt(opts.compare);
+
+      if (compareCount > 1) {
+        await compareFingerprints(compareCount, opts);
+        return;
+      }
+
+      if (opts.check) {
+        await runDetectionTests(opts);
+        return;
+      }
+
+      // Default: show current fingerprint
+      await showFingerprint(opts);
+    });
+}
+
+async function showFingerprint(opts) {
+  const spinner = ora('Collecting fingerprint...').start();
+  let handle;
+
+  try {
+    handle = await launchBrowser({
+      headless: opts.headless,
+      profile: opts.profile,
+      proxy: opts.proxy,
+    });
+
+    if (handle.isDaemon) {
+      spinner.stop();
+      log.error('Fingerprint check requires direct mode');
+      process.exit(1);
+    }
+
+    await navigate(handle, 'about:blank');
+
+    const fp = await evaluate(handle, `(() => {
+      return {
+        userAgent: navigator.userAgent,
+        platform: navigator.platform,
+        language: navigator.language,
+        languages: navigator.languages,
+        hardwareConcurrency: navigator.hardwareConcurrency,
+        deviceMemory: navigator.deviceMemory || 'N/A',
+        maxTouchPoints: navigator.maxTouchPoints,
+        cookieEnabled: navigator.cookieEnabled,
+        doNotTrack: navigator.doNotTrack,
+        screenWidth: screen.width,
+        screenHeight: screen.height,
+        screenColorDepth: screen.colorDepth,
+        screenPixelDepth: screen.pixelDepth,
+        outerWidth: window.outerWidth,
+        outerHeight: window.outerHeight,
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight,
+        devicePixelRatio: window.devicePixelRatio,
+        timezoneOffset: new Date().getTimezoneOffset(),
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        webdriver: navigator.webdriver,
+        pdfViewerEnabled: navigator.pdfViewerEnabled,
+      };
+    })()`);
+
+    // WebGL info
+    const webgl = await evaluate(handle, `(() => {
+      try {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+        if (!gl) return { renderer: 'N/A', vendor: 'N/A' };
+        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        return {
+          renderer: debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : 'hidden',
+          vendor: debugInfo ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) : 'hidden',
+        };
+      } catch { return { renderer: 'error', vendor: 'error' }; }
+    })()`);
+
+    spinner.stop();
+
+    if (opts.json) {
+      console.log(JSON.stringify({ ...fp, webgl }, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold('\n  🦊 Browser Fingerprint\n'));
+
+    const print = (label, value, warn) => {
+      const icon = warn ? chalk.yellow('⚠') : chalk.green('✓');
+      console.log(`  ${icon} ${chalk.dim(label.padEnd(22))} ${value}`);
+    };
+
+    print('User-Agent', fp.userAgent);
+    print('Platform', fp.platform);
+    print('Language', `${fp.language} [${fp.languages?.join(', ')}]`);
+    print('Timezone', `${fp.timezone} (offset: ${fp.timezoneOffset})`);
+    print('Screen', `${fp.screenWidth}x${fp.screenHeight} @${fp.devicePixelRatio}x`);
+    print('Viewport', `${fp.innerWidth}x${fp.innerHeight}`);
+    print('Color Depth', `${fp.screenColorDepth}bit`);
+    print('CPU Cores', fp.hardwareConcurrency);
+    print('Memory', `${fp.deviceMemory}GB`);
+    print('Touch Points', fp.maxTouchPoints);
+    print('WebGL Renderer', webgl.renderer);
+    print('WebGL Vendor', webgl.vendor);
+    print('WebDriver', fp.webdriver ? chalk.red('true (DETECTED!)') : 'false', fp.webdriver);
+    print('Do Not Track', fp.doNotTrack || 'unset');
+    print('Cookies', fp.cookieEnabled ? 'enabled' : 'disabled');
+
+    console.log();
+
+    if (fp.webdriver) {
+      log.warn('navigator.webdriver is true — this is a detection flag!');
+    } else {
+      log.success('No obvious detection flags found');
+    }
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    log.error(`Fingerprint check failed: ${err.message}`);
+    process.exit(1);
+  } finally {
+    if (handle) await closeBrowser(handle);
+  }
+}
+
+async function runDetectionTests(opts) {
+  const spinner = ora('Running anti-detection tests...').start();
+  let handle;
+
+  const tests = [
+    {
+      name: 'Bot Detection (CreepJS)',
+      url: 'https://abrahamjuliot.github.io/creepjs/',
+      check: async (page) => {
+        await page.waitForTimeout(5000);
+        const score = await page.$eval('#fingerprint-data .visitor-info', (el) => el.textContent).catch(() => null);
+        return { score: score || 'Unable to extract — check manually' };
+      },
+    },
+    {
+      name: 'WebDriver Detection',
+      url: 'about:blank',
+      check: async (page) => {
+        const webdriver = await page.evaluate(() => navigator.webdriver);
+        return {
+          detected: webdriver,
+          status: webdriver ? 'FAIL — navigator.webdriver is true' : 'PASS',
+        };
+      },
+    },
+    {
+      name: 'Browser Fingerprint Consistency',
+      url: 'about:blank',
+      check: async (page) => {
+        const data = await page.evaluate(() => {
+          const ua = navigator.userAgent;
+          const platform = navigator.platform;
+          const isWindows = ua.includes('Windows');
+          const isMac = ua.includes('Macintosh');
+          const isLinux = ua.includes('Linux');
+
+          const platformMatch =
+            (isWindows && platform.startsWith('Win')) ||
+            (isMac && platform.startsWith('Mac')) ||
+            (isLinux && platform.startsWith('Linux'));
+
+          return { ua: ua.slice(0, 60), platform, consistent: platformMatch };
+        });
+        return {
+          ...data,
+          status: data.consistent ? 'PASS — UA matches platform' : 'WARN — UA/platform mismatch',
+        };
+      },
+    },
+  ];
+
+  try {
+    handle = await launchBrowser({
+      headless: opts.headless,
+      profile: opts.profile,
+      proxy: opts.proxy,
+    });
+
+    if (handle.isDaemon) {
+      spinner.stop();
+      log.error('Detection tests require direct mode');
+      process.exit(1);
+    }
+
+    spinner.stop();
+    console.log(chalk.bold('\n  🔍 Anti-Detection Test Results\n'));
+
+    const results = [];
+
+    for (const test of tests) {
+      process.stderr.write(chalk.dim(`  Testing: ${test.name}...`));
+      try {
+        await handle.page.goto(test.url, { waitUntil: 'domcontentloaded', timeout: 15000 });
+        await waitForReady(handle.page, { timeout: 3000 });
+        const result = await test.check(handle.page);
+        results.push({ name: test.name, ...result });
+
+        const icon = result.status?.startsWith('PASS') ? chalk.green(' ✓') :
+          result.status?.startsWith('FAIL') ? chalk.red(' ✗') : chalk.yellow(' ⚠');
+        console.log(`\r  ${icon} ${chalk.bold(test.name)}`);
+
+        for (const [key, val] of Object.entries(result)) {
+          console.log(chalk.dim(`      ${key}: ${val}`));
+        }
+      } catch (err) {
+        console.log(`\r  ${chalk.red('✗')} ${test.name}: ${err.message}`);
+        results.push({ name: test.name, error: err.message });
+      }
+    }
+
+    console.log();
+
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+    }
+  } catch (err) {
+    spinner.stop();
+    log.error(`Detection tests failed: ${err.message}`);
+    process.exit(1);
+  } finally {
+    if (handle) await closeBrowser(handle);
+  }
+}
+
+async function compareFingerprints(count, opts) {
+  const spinner = ora(`Comparing ${count} fingerprint launches...`).start();
+  const fingerprints = [];
+
+  for (let i = 0; i < count; i++) {
+    spinner.text = `Launch ${i + 1}/${count}...`;
+    let handle;
+    try {
+      handle = await launchBrowser({
+        headless: opts.headless,
+        profile: opts.profile,
+      });
+
+      if (handle.isDaemon) {
+        spinner.stop();
+        log.error('Compare requires direct mode');
+        process.exit(1);
+      }
+
+      const fp = await evaluate(handle, `(() => ({
+        ua: navigator.userAgent,
+        platform: navigator.platform,
+        cores: navigator.hardwareConcurrency,
+        memory: navigator.deviceMemory,
+        screen: screen.width + 'x' + screen.height,
+        tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        lang: navigator.language,
+        webdriver: navigator.webdriver,
+      }))()`);
+
+      fingerprints.push(fp);
+    } finally {
+      if (handle) await closeBrowser(handle);
+    }
+  }
+
+  spinner.stop();
+
+  console.log(chalk.bold(`\n  Fingerprint Comparison (${count} launches)\n`));
+
+  // Check which fields differ
+  const fields = Object.keys(fingerprints[0]);
+  for (const field of fields) {
+    const values = fingerprints.map((fp) => String(fp[field]));
+    const unique = [...new Set(values)];
+    const icon = unique.length > 1 ? chalk.green('✓ varies') : chalk.yellow('= same');
+    console.log(`  ${icon}  ${chalk.dim(field.padEnd(12))} ${unique.join(' | ')}`);
+  }
+
+  console.log();
+  const varyingFields = fields.filter((f) => new Set(fingerprints.map((fp) => String(fp[f]))).size > 1);
+  if (varyingFields.length > 0) {
+    log.success(`${varyingFields.length}/${fields.length} fields vary between launches — good fingerprint rotation`);
+  } else {
+    log.warn('All fields identical — fingerprints are not rotating');
+  }
+  console.log();
+}

package/src/commands/interactive.js

@@ -0,0 +1,284 @@
+/**
+ * stealth interactive - Interactive REPL mode for browsing
+ */
+
+import { createInterface } from 'readline';
+import ora from 'ora';
+import chalk from 'chalk';
+import {
+  launchBrowser, closeBrowser, navigate, getSnapshot,
+  getTextContent, getUrl, getTitle, evaluate, takeScreenshot, waitForReady,
+} from '../browser.js';
+import { expandMacro, getSupportedEngines } from '../macros.js';
+import { humanClick, humanType, humanScroll, randomDelay } from '../humanize.js';
+import { log } from '../output.js';
+
+const HELP_TEXT = `
+${chalk.bold('Navigation:')}
+  ${chalk.cyan('goto <url>')}            Navigate to a URL
+  ${chalk.cyan('search <engine> <q>')}   Search (${getSupportedEngines().slice(0, 5).join(', ')}...)
+  ${chalk.cyan('back')}                  Go back
+  ${chalk.cyan('forward')}               Go forward
+  ${chalk.cyan('reload')}                Reload page
+
+${chalk.bold('Inspection:')}
+  ${chalk.cyan('snapshot')}              Accessibility snapshot
+  ${chalk.cyan('text')}                  Page text content
+  ${chalk.cyan('title')}                 Page title
+  ${chalk.cyan('url')}                   Current URL
+  ${chalk.cyan('links')}                 List all links
+  ${chalk.cyan('screenshot [file]')}     Take a screenshot
+
+${chalk.bold('Interaction:')}
+  ${chalk.cyan('click <selector>')}      Click an element
+  ${chalk.cyan('hclick <selector>')}     Human-like click (mouse movement)
+  ${chalk.cyan('type <sel> <text>')}     Type text into element
+  ${chalk.cyan('htype <sel> <text>')}    Human-like typing (variable speed)
+  ${chalk.cyan('scroll [up|down] [n]')}  Scroll page
+  ${chalk.cyan('eval <js>')}             Evaluate JavaScript
+  ${chalk.cyan('wait <ms>')}             Wait for milliseconds
+
+${chalk.bold('Other:')}
+  ${chalk.cyan('help')}                  Show this help
+  ${chalk.cyan('exit')}                  Exit
+`;
+
+export function registerInteractive(program) {
+  program
+    .command('interactive')
+    .alias('repl')
+    .description('Interactive browser REPL mode')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--cookies <file>', 'Load cookies from Netscape-format file')
+    .option('--no-headless', 'Show browser window')
+    .option('--url <url>', 'Initial URL to open')
+    .action(async (opts) => {
+      const spinner = ora('Launching stealth browser...').start();
+      let handle;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+        });
+
+        if (opts.cookies && !handle.isDaemon) {
+          const { loadCookies } = await import('../cookies.js');
+          const result = await loadCookies(handle.context, opts.cookies);
+          log.info(result.message);
+        }
+
+        if (opts.url) {
+          await navigate(handle, opts.url);
+          if (!handle.isDaemon) {
+            await waitForReady(handle.page);
+          }
+        }
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n🦊 Stealth Browser Interactive Mode'));
+        console.log(chalk.dim('Type "help" for commands, "exit" to quit.\n'));
+
+        if (opts.url) {
+          const currentUrl = await getUrl(handle);
+          log.info(`Current page: ${currentUrl}`);
+        }
+
+        const rl = createInterface({
+          input: process.stdin,
+          output: process.stderr,
+          prompt: chalk.green('stealth> '),
+        });
+
+        rl.prompt();
+
+        rl.on('line', async (line) => {
+          const input = line.trim();
+          if (!input) { rl.prompt(); return; }
+
+          const [cmd, ...args] = input.split(/\s+/);
+          const argStr = args.join(' ');
+
+          try {
+            switch (cmd.toLowerCase()) {
+              case 'goto': case 'go': case 'navigate': {
+                if (!argStr) { log.warn('Usage: goto <url>'); break; }
+                const s = ora(`Navigating...`).start();
+                await navigate(handle, argStr);
+                if (!handle.isDaemon) await waitForReady(handle.page);
+                s.stop();
+                log.success(`→ ${await getUrl(handle)}`);
+                break;
+              }
+
+              case 'search': {
+                if (args.length < 2) { log.warn('Usage: search <engine> <query>'); break; }
+                const engine = args[0];
+                const query = args.slice(1).join(' ');
+                const url = expandMacro(engine, query);
+                if (!url) { log.error(`Unknown engine. Try: ${getSupportedEngines().join(', ')}`); break; }
+                const s = ora(`Searching ${engine}...`).start();
+                await navigate(handle, url);
+                if (!handle.isDaemon) await waitForReady(handle.page);
+                s.stop();
+                log.success(`→ ${await getUrl(handle)}`);
+                break;
+              }
+
+              case 'click': {
+                if (!argStr) { log.warn('Usage: click <selector>'); break; }
+                if (handle.isDaemon) { log.warn('click requires direct mode'); break; }
+                await handle.page.click(argStr, { timeout: 5000 });
+                await waitForReady(handle.page, { timeout: 2000 });
+                log.success('Clicked');
+                break;
+              }
+
+              case 'hclick': {
+                if (!argStr) { log.warn('Usage: hclick <selector>'); break; }
+                if (handle.isDaemon) { log.warn('hclick requires direct mode'); break; }
+                await humanClick(handle.page, argStr);
+                await waitForReady(handle.page, { timeout: 2000 });
+                log.success('Human-clicked');
+                break;
+              }
+
+              case 'type': {
+                if (args.length < 2) { log.warn('Usage: type <selector> <text>'); break; }
+                if (handle.isDaemon) { log.warn('type requires direct mode'); break; }
+                await handle.page.fill(args[0], args.slice(1).join(' '));
+                log.success(`Typed: "${args.slice(1).join(' ')}"`);
+                break;
+              }
+
+              case 'htype': {
+                if (args.length < 2) { log.warn('Usage: htype <selector> <text>'); break; }
+                if (handle.isDaemon) { log.warn('htype requires direct mode'); break; }
+                await humanType(handle.page, args[0], args.slice(1).join(' '));
+                log.success(`Human-typed: "${args.slice(1).join(' ')}"`);
+                break;
+              }
+
+              case 'scroll': {
+                if (handle.isDaemon) { log.warn('scroll requires direct mode'); break; }
+                const direction = args[0] || 'down';
+                const scrolls = parseInt(args[1]) || 2;
+                await humanScroll(handle.page, { direction, scrolls });
+                log.success(`Scrolled ${direction}`);
+                break;
+              }
+
+              case 'snapshot': {
+                const snapshot = await getSnapshot(handle);
+                console.log(snapshot);
+                break;
+              }
+
+              case 'text': {
+                const text = await getTextContent(handle);
+                console.log(text);
+                break;
+              }
+
+              case 'title': {
+                console.log(await getTitle(handle));
+                break;
+              }
+
+              case 'url': {
+                console.log(await getUrl(handle));
+                break;
+              }
+
+              case 'links': {
+                const links = await evaluate(handle, `
+                  Array.from(document.querySelectorAll('a[href]'))
+                    .filter(a => a.href.startsWith('http'))
+                    .slice(0, 30)
+                    .map(a => ({ text: a.textContent?.trim().slice(0, 60), url: a.href }))
+                `);
+                if (links) {
+                  links.forEach((l, i) =>
+                    console.log(`${chalk.dim(`${i + 1}.`)} ${l.text || '(no text)'}\n   ${chalk.cyan(l.url)}`)
+                  );
+                  log.dim(`Total: ${links.length} links shown`);
+                }
+                break;
+              }
+
+              case 'screenshot': {
+                const file = argStr || 'screenshot.png';
+                await takeScreenshot(handle, { path: file });
+                log.success(`Screenshot saved: ${file}`);
+                break;
+              }
+
+              case 'back': {
+                if (handle.isDaemon) { log.warn('back requires direct mode'); break; }
+                await handle.page.goBack({ timeout: 10000 });
+                log.success(`← ${handle.page.url()}`);
+                break;
+              }
+
+              case 'forward': {
+                if (handle.isDaemon) { log.warn('forward requires direct mode'); break; }
+                await handle.page.goForward({ timeout: 10000 });
+                log.success(`→ ${handle.page.url()}`);
+                break;
+              }
+
+              case 'reload': {
+                if (handle.isDaemon) { log.warn('reload requires direct mode'); break; }
+                await handle.page.reload({ timeout: 30000 });
+                log.success('Reloaded');
+                break;
+              }
+
+              case 'eval': case 'js': {
+                if (!argStr) { log.warn('Usage: eval <javascript>'); break; }
+                const result = await evaluate(handle, argStr);
+                console.log(result);
+                break;
+              }
+
+              case 'wait': {
+                const ms = parseInt(argStr) || 1000;
+                await randomDelay(ms, ms);
+                log.success(`Waited ${ms}ms`);
+                break;
+              }
+
+              case 'help': case '?': {
+                console.log(HELP_TEXT);
+                break;
+              }
+
+              case 'exit': case 'quit': case 'q': {
+                rl.close();
+                return;
+              }
+
+              default:
+                log.warn(`Unknown command: ${cmd}. Type "help" for commands.`);
+            }
+          } catch (err) {
+            log.error(`${err.message}`);
+          }
+
+          rl.prompt();
+        });
+
+        rl.on('close', async () => {
+          await closeBrowser(handle);
+          log.success('Bye! 🦊');
+          process.exit(0);
+        });
+      } catch (err) {
+        spinner.stop();
+        log.error(`Failed to start: ${err.message}`);
+        if (handle) await closeBrowser(handle);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/mcp.js

@@ -0,0 +1,68 @@
+/**
+ * stealth mcp - Start MCP server for AI agent integration
+ */
+
+import chalk from 'chalk';
+import { log } from '../output.js';
+
+export function registerMcp(program) {
+  program
+    .command('mcp')
+    .description('Start MCP server for Claude Desktop, Cursor, etc.')
+    .option('--list-tools', 'List available MCP tools without starting server')
+    .option('--config', 'Print MCP configuration JSON for claude_desktop_config.json')
+    .action(async (opts) => {
+      if (opts.config) {
+        printConfig();
+        return;
+      }
+
+      if (opts.listTools) {
+        listTools();
+        return;
+      }
+
+      // Start MCP server on stdio
+      const { McpServer } = await import('../mcp-server.js');
+      const server = new McpServer();
+      await server.run();
+    });
+}
+
+function printConfig() {
+  const config = {
+    mcpServers: {
+      stealth: {
+        command: 'node',
+        args: [process.argv[1].replace(/\/commands\/.*/, '/../bin/stealth.js'), 'mcp'],
+      },
+    },
+  };
+
+  console.log(chalk.bold('\n  Add this to your claude_desktop_config.json:\n'));
+  console.log(JSON.stringify(config, null, 2));
+  console.log();
+
+  log.dim('  Config location:');
+  log.dim('    macOS: ~/Library/Application Support/Claude/claude_desktop_config.json');
+  log.dim('    Linux: ~/.config/Claude/claude_desktop_config.json');
+  console.log();
+}
+
+function listTools() {
+  const tools = [
+    { name: 'stealth_browse', desc: 'Visit URL with anti-detection, return text/snapshot' },
+    { name: 'stealth_screenshot', desc: 'Screenshot a page (returns base64 PNG)' },
+    { name: 'stealth_search', desc: 'Search Google/Bing/DuckDuckGo/YouTube/GitHub' },
+    { name: 'stealth_extract', desc: 'Extract links/images/meta/headers/selector' },
+    { name: 'stealth_click', desc: 'Click element by CSS selector' },
+    { name: 'stealth_type', desc: 'Type text into input element' },
+    { name: 'stealth_evaluate', desc: 'Execute JavaScript in page' },
+  ];
+
+  console.log(chalk.bold('\n  MCP Tools:\n'));
+  for (const t of tools) {
+    console.log(`  ${chalk.cyan(t.name.padEnd(24))} ${t.desc}`);
+  }
+  console.log();
+}