stealth-cli 0.5.0

package/src/browser.js

@@ -0,0 +1,341 @@
+/**
+ * Core browser module - wraps camoufox-js for anti-detection browsing
+ *
+ * Supports two modes:
+ *   1. Direct mode  — launches a new browser per command
+ *   2. Daemon mode  — reuses background browser (faster)
+ */
+
+import { launchOptions } from 'camoufox-js';
+import { firefox } from 'playwright-core';
+import os from 'os';
+import { withRetry, navigateWithRetry } from './retry.js';
+import { randomDelay, postNavigationBehavior } from './humanize.js';
+import { isDaemonRunning } from './daemon.js';
+import { daemonNavigate, daemonText, daemonScreenshot, daemonRequest } from './client.js';
+import { loadProfile, touchProfile, saveCookiesToProfile, loadCookiesFromProfile } from './profiles.js';
+import { restoreSession, captureSession } from './session.js';
+import { getNextProxy, getRandomProxy, reportProxy } from './proxy-pool.js';
+
+/**
+ * Detect host OS for fingerprint matching
+ */
+function getHostOS() {
+  const platform = os.platform();
+  if (platform === 'darwin') return 'macos';
+  if (platform === 'win32') return 'windows';
+  return 'linux';
+}
+
+/**
+ * Build proxy configuration
+ */
+function buildProxy(proxyStr) {
+  if (!proxyStr) return null;
+
+  try {
+    let url;
+    if (proxyStr.startsWith('http')) {
+      url = new URL(proxyStr);
+    } else {
+      url = new URL(`http://${proxyStr}`);
+    }
+
+    return {
+      server: `${url.protocol}//${url.hostname}:${url.port}`,
+      username: url.username || undefined,
+      password: url.password || undefined,
+    };
+  } catch {
+    const [host, port] = proxyStr.split(':');
+    return { server: `http://${host}:${port}` };
+  }
+}
+
+/**
+ * Launch a stealth browser instance
+ *
+ * @param {object} opts
+ * @param {boolean} [opts.headless=true] - Run in headless mode
+ * @param {string} [opts.proxy] - Proxy string (http://user:pass@host:port)
+ * @param {boolean} [opts.proxyRotate] - Use proxy pool rotation
+ * @param {string} [opts.profile] - Profile name to use
+ * @param {string} [opts.session] - Session name (persist cookies/state)
+ * @param {string} [opts.locale] - Browser locale (default: en-US)
+ * @param {string} [opts.timezone] - Timezone ID
+ * @param {object} [opts.viewport] - { width, height }
+ * @param {boolean} [opts.humanize] - Enable human behavior simulation
+ * @returns {Promise<{ browser, context, page, isDaemon, _meta }>}
+ */
+export async function launchBrowser(opts = {}) {
+  let {
+    headless = true,
+    proxy: proxyStr,
+    proxyRotate = false,
+    profile: profileName,
+    session: sessionName,
+    locale = 'en-US',
+    timezone = 'America/Los_Angeles',
+    viewport = { width: 1280, height: 720 },
+    humanize = false,
+  } = opts;
+
+  // --- Load profile if specified ---
+  let profileData = null;
+  if (profileName) {
+    try {
+      profileData = loadProfile(profileName);
+      const fp = profileData.fingerprint;
+      locale = fp.locale || locale;
+      timezone = fp.timezone || timezone;
+      viewport = fp.viewport || viewport;
+      if (profileData.proxy && !proxyStr) {
+        proxyStr = profileData.proxy;
+      }
+      touchProfile(profileName);
+    } catch {}
+  }
+
+  // --- Proxy pool rotation ---
+  if (proxyRotate && !proxyStr) {
+    proxyStr = getNextProxy();
+  }
+
+  // Check if daemon is available (skip if proxy/profile/session needed)
+  if (!proxyStr && !profileName && !sessionName && isDaemonRunning()) {
+    return {
+      browser: null,
+      context: null,
+      page: null,
+      isDaemon: true,
+      _meta: { profileName, sessionName, proxyUrl: null },
+    };
+  }
+
+  const hostOS = profileData?.fingerprint?.os || getHostOS();
+  const proxy = buildProxy(proxyStr);
+
+  const options = await launchOptions({
+    headless,
+    os: hostOS,
+    humanize: true,
+    enable_cache: true,
+    proxy: proxy || undefined,
+    geoip: !!proxy,
+  });
+
+  const browser = await firefox.launch(options);
+
+  const contextOptions = {
+    viewport,
+    permissions: ['geolocation'],
+  };
+
+  if (!proxy) {
+    contextOptions.locale = locale;
+    contextOptions.timezoneId = timezone;
+    const geo = profileData?.fingerprint?.geo || { latitude: 37.7749, longitude: -122.4194 };
+    contextOptions.geolocation = geo;
+  }
+
+  const context = await browser.newContext(contextOptions);
+
+  // --- Restore profile cookies ---
+  if (profileName) {
+    await loadCookiesFromProfile(profileName, context);
+  }
+
+  // --- Restore session ---
+  let sessionInfo = null;
+  if (sessionName) {
+    sessionInfo = await restoreSession(sessionName, context);
+  }
+
+  const page = await context.newPage();
+
+  // If session had a last URL, navigate to it
+  if (sessionInfo?.lastUrl && sessionInfo.lastUrl !== 'about:blank') {
+    try {
+      await page.goto(sessionInfo.lastUrl, { waitUntil: 'domcontentloaded', timeout: 15000 });
+    } catch {}
+  }
+
+  return {
+    browser, context, page, isDaemon: false,
+    _meta: { profileName, sessionName, proxyUrl: proxyStr, sessionInfo },
+  };
+}
+
+/**
+ * Safely close browser and clean up (no-op for daemon mode)
+ * Auto-saves profile cookies and session state before closing
+ */
+export async function closeBrowser(handle) {
+  const { browser, context, page, isDaemon, _meta } = handle;
+
+  if (isDaemon) return;
+
+  try {
+    // Auto-save profile cookies
+    if (_meta?.profileName && context) {
+      await saveCookiesToProfile(_meta.profileName, context).catch(() => {});
+    }
+
+    // Auto-save session
+    if (_meta?.sessionName && context && page) {
+      await captureSession(_meta.sessionName, context, page, {
+        profile: _meta.profileName,
+      }).catch(() => {});
+    }
+
+    if (context) await context.close().catch(() => {});
+    if (browser) await browser.close().catch(() => {});
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+/**
+ * Navigate to URL — uses daemon if available, with retry support
+ *
+ * @param {object} handle - { page, isDaemon } from launchBrowser
+ * @param {string} url - Target URL
+ * @param {object} opts - Navigation options
+ */
+export async function navigate(handle, url, opts = {}) {
+  const { timeout = 30000, waitUntil = 'domcontentloaded', humanize = false, retries = 2 } = opts;
+
+  if (handle.isDaemon) {
+    const result = await withRetry(
+      async () => {
+        const res = await daemonNavigate(url, { timeout, waitUntil });
+        if (!res?.ok) throw new Error(res?.error || 'Daemon navigation failed');
+        return res.url;
+      },
+      { maxRetries: retries, label: `navigate(daemon)` },
+    );
+    return result;
+  }
+
+  const finalUrl = await navigateWithRetry(handle.page, url, { timeout, waitUntil, maxRetries: retries });
+
+  // Human behavior after navigation
+  if (humanize) {
+    await postNavigationBehavior(handle.page);
+  }
+
+  return finalUrl;
+}
+
+/**
+ * Wait for page to be ready
+ */
+export async function waitForReady(page, opts = {}) {
+  const { timeout = 5000, waitForNetwork = true } = opts;
+
+  if (!page) return; // Daemon mode — no direct page access
+
+  try {
+    if (waitForNetwork) {
+      await page.waitForLoadState('networkidle', { timeout });
+    } else {
+      await page.waitForLoadState('domcontentloaded', { timeout });
+    }
+  } catch {
+    // Timeout is OK
+  }
+}
+
+/**
+ * Get accessibility snapshot of the page
+ */
+export async function getSnapshot(handle) {
+  if (handle.isDaemon) {
+    const res = await daemonRequest('/snapshot');
+    return res?.snapshot || '';
+  }
+
+  try {
+    await waitForReady(handle.page, { waitForNetwork: false });
+    const snapshot = await handle.page.locator('body').ariaSnapshot({ timeout: 8000 });
+    return snapshot || '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Extract visible text content from page
+ */
+export async function getTextContent(handle) {
+  if (handle.isDaemon) {
+    const res = await daemonRequest('/text');
+    return res?.text || '';
+  }
+
+  return handle.page.evaluate(() => {
+    const body = document.body;
+    if (!body) return '';
+
+    const clone = body.cloneNode(true);
+    clone.querySelectorAll('script, style, noscript').forEach((el) => el.remove());
+
+    return clone.innerText || clone.textContent || '';
+  });
+}
+
+/**
+ * Get page title
+ */
+export async function getTitle(handle) {
+  if (handle.isDaemon) {
+    const res = await daemonRequest('/title');
+    return res?.title || '';
+  }
+  return handle.page.title();
+}
+
+/**
+ * Get current URL
+ */
+export async function getUrl(handle) {
+  if (handle.isDaemon) {
+    // Use /title endpoint which returns the current page URL
+    const res = await daemonRequest('/title');
+    return res?.url || 'about:blank';
+  }
+  return handle.page.url();
+}
+
+/**
+ * Take screenshot
+ */
+export async function takeScreenshot(handle, opts = {}) {
+  const { path: filePath, fullPage = false } = opts;
+
+  if (handle.isDaemon) {
+    const res = await daemonRequest('/screenshot', { fullPage });
+    if (res?.data && filePath) {
+      const { writeFileSync } = await import('fs');
+      writeFileSync(filePath, Buffer.from(res.data, 'base64'));
+    }
+    return res;
+  }
+
+  const screenshotOpts = { fullPage };
+  if (filePath) screenshotOpts.path = filePath;
+
+  const buffer = await handle.page.screenshot(screenshotOpts);
+  return { data: buffer.toString('base64') };
+}
+
+/**
+ * Evaluate JavaScript in page
+ */
+export async function evaluate(handle, expression) {
+  if (handle.isDaemon) {
+    const res = await daemonRequest('/evaluate', { expression });
+    return res?.result;
+  }
+  return handle.page.evaluate(expression);
+}

package/src/client.js

@@ -0,0 +1,115 @@
+/**
+ * Daemon client — communicates with background daemon via unix socket
+ *
+ * Usage:
+ *   if (await daemonRequest('/status')) { ... } // daemon is running
+ *   const result = await daemonNavigate('https://example.com');
+ */
+
+import http from 'http';
+import { SOCKET_PATH, isDaemonRunning } from './daemon.js';
+
+/**
+ * Send a request to the daemon
+ *
+ * @param {string} route - Route path (e.g. '/navigate')
+ * @param {object} body - Request body
+ * @param {number} timeout - Request timeout in ms
+ * @returns {Promise<object|null>} Response data, or null if daemon not available
+ */
+export async function daemonRequest(route, body = {}, timeout = 35000) {
+  if (!isDaemonRunning()) return null;
+
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify(body);
+
+    const req = http.request(
+      {
+        socketPath: SOCKET_PATH,
+        path: route,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(postData),
+        },
+        timeout,
+      },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            resolve(null);
+          }
+        });
+      },
+    );
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+/**
+ * Navigate via daemon (returns null if daemon not available)
+ */
+export async function daemonNavigate(url, opts = {}) {
+  return daemonRequest('/navigate', { url, ...opts });
+}
+
+/**
+ * Get page snapshot via daemon
+ */
+export async function daemonSnapshot(opts = {}) {
+  return daemonRequest('/snapshot', opts);
+}
+
+/**
+ * Get page text via daemon
+ */
+export async function daemonText(opts = {}) {
+  return daemonRequest('/text', opts);
+}
+
+/**
+ * Take screenshot via daemon (returns base64)
+ */
+export async function daemonScreenshot(opts = {}) {
+  return daemonRequest('/screenshot', opts);
+}
+
+/**
+ * Get page title via daemon
+ */
+export async function daemonTitle(opts = {}) {
+  return daemonRequest('/title', opts);
+}
+
+/**
+ * Evaluate JS via daemon
+ */
+export async function daemonEvaluate(expression, opts = {}) {
+  return daemonRequest('/evaluate', { expression, ...opts });
+}
+
+/**
+ * Check daemon status
+ */
+export async function daemonStatus() {
+  return daemonRequest('/status');
+}
+
+/**
+ * Shutdown daemon
+ */
+export async function daemonShutdown() {
+  return daemonRequest('/shutdown');
+}

package/src/commands/batch.js

@@ -0,0 +1,180 @@
+/**
+ * stealth batch <file> - Execute commands for a list of URLs
+ */
+
+import fs from 'fs';
+import ora from 'ora';
+import {
+  launchBrowser, closeBrowser, navigate, getTextContent,
+  getTitle, takeScreenshot, waitForReady,
+} from '../browser.js';
+import { navigateWithRetry } from '../retry.js';
+import { randomDelay } from '../humanize.js';
+import { formatOutput, log } from '../output.js';
+
+export function registerBatch(program) {
+  program
+    .command('batch')
+    .description('Process a list of URLs in batch')
+    .argument('<file>', 'File containing URLs (one per line)')
+    .option('-c, --command <cmd>', 'Command to run: browse, screenshot, extract', 'browse')
+    .option('-o, --output <dir>', 'Output directory for results', '.')
+    .option('-f, --format <format>', 'Output format: json, jsonl, text', 'jsonl')
+    .option('--delay <ms>', 'Delay between URLs (ms)', '1000')
+    .option('--concurrency <n>', 'Max parallel operations (reuses single browser)', '1')
+    .option('-s, --selector <selector>', 'CSS selector for extract mode')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--profile <name>', 'Use a browser profile')
+    .option('--proxy-rotate', 'Rotate proxy from pool')
+    .option('--no-headless', 'Show browser window')
+    .option('--retries <n>', 'Max retries per URL', '2')
+    .option('--skip-errors', 'Continue on errors instead of stopping')
+    .action(async (file, opts) => {
+      // Read URLs from file
+      if (!fs.existsSync(file)) {
+        log.error(`File not found: ${file}`);
+        process.exit(1);
+      }
+
+      const urls = fs.readFileSync(file, 'utf-8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#') && line.startsWith('http'));
+
+      if (urls.length === 0) {
+        log.error('No valid URLs found in file');
+        process.exit(1);
+      }
+
+      log.info(`Batch processing ${urls.length} URLs (command: ${opts.command})`);
+
+      const spinner = ora('Launching stealth browser...').start();
+      let handle;
+      const results = [];
+      let success = 0;
+      let failed = 0;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+          proxyRotate: opts.proxyRotate,
+          profile: opts.profile,
+        });
+
+        // Ensure output directory exists for screenshot mode
+        if (opts.command === 'screenshot') {
+          fs.mkdirSync(opts.output, { recursive: true });
+        }
+
+        // Create output stream for jsonl mode
+        let outputStream;
+        if (opts.format === 'jsonl' && opts.command !== 'screenshot') {
+          const outFile = `${opts.output}/batch-${Date.now()}.jsonl`;
+          outputStream = fs.createWriteStream(outFile);
+          log.dim(`  Output: ${outFile}`);
+        }
+
+        for (let i = 0; i < urls.length; i++) {
+          const url = urls[i];
+          spinner.text = `[${i + 1}/${urls.length}] ${opts.command}: ${url.slice(0, 50)}...`;
+
+          try {
+            if (handle.isDaemon) {
+              await navigate(handle, url, { retries: parseInt(opts.retries) });
+            } else {
+              await navigateWithRetry(handle.page, url, {
+                maxRetries: parseInt(opts.retries),
+              });
+              await waitForReady(handle.page, { timeout: 3000 });
+            }
+
+            let result;
+
+            switch (opts.command) {
+              case 'browse': {
+                const title = await getTitle(handle);
+                const content = await getTextContent(handle);
+                result = {
+                  url,
+                  title,
+                  content: content.slice(0, 5000),
+                  timestamp: new Date().toISOString(),
+                };
+                break;
+              }
+
+              case 'screenshot': {
+                // Generate filename from URL
+                const filename = url
+                  .replace(/https?:\/\//, '')
+                  .replace(/[^a-zA-Z0-9]/g, '_')
+                  .slice(0, 80) + '.png';
+                const filepath = `${opts.output}/${filename}`;
+
+                await takeScreenshot(handle, { path: filepath });
+                result = { url, screenshot: filepath, timestamp: new Date().toISOString() };
+                break;
+              }
+
+              case 'extract': {
+                const selector = opts.selector || 'body';
+                let data;
+                if (handle.isDaemon) {
+                  const { evaluate } = await import('../browser.js');
+                  data = await evaluate(handle, `document.querySelector('${selector}')?.textContent?.trim() || ''`);
+                } else {
+                  data = await handle.page.$eval(selector, (el) => el.textContent?.trim()).catch(() => '');
+                }
+                result = {
+                  url,
+                  selector,
+                  data,
+                  timestamp: new Date().toISOString(),
+                };
+                break;
+              }
+
+              default:
+                throw new Error(`Unknown command: ${opts.command}`);
+            }
+
+            // Output result
+            if (outputStream) {
+              outputStream.write(JSON.stringify(result) + '\n');
+            } else if (opts.command !== 'screenshot') {
+              console.log(opts.format === 'jsonl' ? JSON.stringify(result) : formatOutput(result, opts.format));
+            }
+
+            results.push(result);
+            success++;
+          } catch (err) {
+            failed++;
+            log.warn(`[${i + 1}] Failed: ${url} — ${err.message}`);
+
+            if (!opts.skipErrors) {
+              throw err;
+            }
+          }
+
+          // Delay between URLs
+          if (i < urls.length - 1) {
+            const delay = parseInt(opts.delay);
+            await randomDelay(delay * 0.8, delay * 1.2);
+          }
+        }
+
+        if (outputStream) outputStream.end();
+
+        spinner.stop();
+        log.success(`Batch complete: ${success} succeeded, ${failed} failed, ${urls.length} total`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`Batch failed: ${err.message}`);
+        log.dim(`  Completed: ${success}/${urls.length}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}