stealth-cli 0.5.0

package/src/profiles.js

@@ -0,0 +1,308 @@
+/**
+ * Profile management — persistent browser identity profiles
+ *
+ * Each profile stores:
+ *   - Fingerprint config (locale, timezone, viewport, os)
+ *   - Proxy settings
+ *   - Cookie data (auto-saved between sessions)
+ *   - Usage stats
+ *
+ * Storage: ~/.stealth/profiles/<name>.json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+const PROFILES_DIR = path.join(os.homedir(), '.stealth', 'profiles');
+
+// Realistic fingerprint presets
+const FINGERPRINT_PRESETS = {
+  'us-desktop': {
+    locale: 'en-US',
+    timezone: 'America/New_York',
+    viewport: { width: 1920, height: 1080 },
+    os: 'windows',
+    geo: { latitude: 40.7128, longitude: -74.006 },
+  },
+  'us-laptop': {
+    locale: 'en-US',
+    timezone: 'America/Los_Angeles',
+    viewport: { width: 1440, height: 900 },
+    os: 'macos',
+    geo: { latitude: 37.7749, longitude: -122.4194 },
+  },
+  'uk-desktop': {
+    locale: 'en-GB',
+    timezone: 'Europe/London',
+    viewport: { width: 1920, height: 1080 },
+    os: 'windows',
+    geo: { latitude: 51.5074, longitude: -0.1278 },
+  },
+  'de-desktop': {
+    locale: 'de-DE',
+    timezone: 'Europe/Berlin',
+    viewport: { width: 1920, height: 1080 },
+    os: 'windows',
+    geo: { latitude: 52.52, longitude: 13.405 },
+  },
+  'jp-desktop': {
+    locale: 'ja-JP',
+    timezone: 'Asia/Tokyo',
+    viewport: { width: 1920, height: 1080 },
+    os: 'windows',
+    geo: { latitude: 35.6762, longitude: 139.6503 },
+  },
+  'cn-desktop': {
+    locale: 'zh-CN',
+    timezone: 'Asia/Shanghai',
+    viewport: { width: 1920, height: 1080 },
+    os: 'windows',
+    geo: { latitude: 31.2304, longitude: 121.4737 },
+  },
+  'mobile-ios': {
+    locale: 'en-US',
+    timezone: 'America/Chicago',
+    viewport: { width: 390, height: 844 },
+    os: 'macos',
+    geo: { latitude: 41.8781, longitude: -87.6298 },
+  },
+  'mobile-android': {
+    locale: 'en-US',
+    timezone: 'America/Denver',
+    viewport: { width: 412, height: 915 },
+    os: 'linux',
+    geo: { latitude: 39.7392, longitude: -104.9903 },
+  },
+};
+
+// Random viewport sizes for generating unique profiles
+const VIEWPORTS = [
+  { width: 1920, height: 1080 },
+  { width: 1440, height: 900 },
+  { width: 1536, height: 864 },
+  { width: 1366, height: 768 },
+  { width: 1280, height: 720 },
+  { width: 1600, height: 900 },
+  { width: 2560, height: 1440 },
+  { width: 1280, height: 800 },
+];
+
+const LOCALES = [
+  { locale: 'en-US', tz: 'America/New_York', geo: { latitude: 40.7128, longitude: -74.006 } },
+  { locale: 'en-US', tz: 'America/Los_Angeles', geo: { latitude: 34.0522, longitude: -118.2437 } },
+  { locale: 'en-US', tz: 'America/Chicago', geo: { latitude: 41.8781, longitude: -87.6298 } },
+  { locale: 'en-GB', tz: 'Europe/London', geo: { latitude: 51.5074, longitude: -0.1278 } },
+  { locale: 'de-DE', tz: 'Europe/Berlin', geo: { latitude: 52.52, longitude: 13.405 } },
+  { locale: 'fr-FR', tz: 'Europe/Paris', geo: { latitude: 48.8566, longitude: 2.3522 } },
+  { locale: 'ja-JP', tz: 'Asia/Tokyo', geo: { latitude: 35.6762, longitude: 139.6503 } },
+  { locale: 'zh-CN', tz: 'Asia/Shanghai', geo: { latitude: 31.2304, longitude: 121.4737 } },
+];
+
+/**
+ * Ensure profiles directory exists
+ */
+function ensureDir() {
+  fs.mkdirSync(PROFILES_DIR, { recursive: true });
+}
+
+/**
+ * Get path to a profile file
+ */
+function profilePath(name) {
+  // Sanitize name
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(PROFILES_DIR, `${safeName}.json`);
+}
+
+/**
+ * Generate a random fingerprint
+ */
+function randomFingerprint() {
+  const localeInfo = LOCALES[Math.floor(Math.random() * LOCALES.length)];
+  const viewport = VIEWPORTS[Math.floor(Math.random() * VIEWPORTS.length)];
+  const osOptions = ['windows', 'macos', 'linux'];
+  const selectedOs = osOptions[Math.floor(Math.random() * osOptions.length)];
+
+  return {
+    locale: localeInfo.locale,
+    timezone: localeInfo.tz,
+    viewport,
+    os: selectedOs,
+    geo: localeInfo.geo,
+  };
+}
+
+/**
+ * Create a new profile
+ *
+ * @param {string} name - Profile name
+ * @param {object} opts
+ * @param {string} [opts.preset] - Use a preset (us-desktop, uk-desktop, etc.)
+ * @param {string} [opts.proxy] - Proxy server
+ * @param {boolean} [opts.random] - Generate random fingerprint
+ */
+export function createProfile(name, opts = {}) {
+  ensureDir();
+  const filePath = profilePath(name);
+
+  if (fs.existsSync(filePath)) {
+    throw new Error(`Profile "${name}" already exists. Use --force to overwrite.`);
+  }
+
+  let fingerprint;
+
+  if (opts.preset) {
+    fingerprint = FINGERPRINT_PRESETS[opts.preset];
+    if (!fingerprint) {
+      throw new Error(`Unknown preset "${opts.preset}". Available: ${Object.keys(FINGERPRINT_PRESETS).join(', ')}`);
+    }
+    fingerprint = { ...fingerprint }; // Clone
+  } else if (opts.random || !opts.locale) {
+    fingerprint = randomFingerprint();
+  } else {
+    fingerprint = {
+      locale: opts.locale || 'en-US',
+      timezone: opts.timezone || 'America/New_York',
+      viewport: opts.viewport || { width: 1920, height: 1080 },
+      os: opts.os || 'windows',
+      geo: opts.geo || { latitude: 40.7128, longitude: -74.006 },
+    };
+  }
+
+  const profile = {
+    id: crypto.randomUUID(),
+    name,
+    fingerprint,
+    proxy: opts.proxy || null,
+    cookies: [],
+    createdAt: new Date().toISOString(),
+    lastUsed: null,
+    useCount: 0,
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(profile, null, 2));
+  return profile;
+}
+
+/**
+ * Load a profile by name
+ */
+export function loadProfile(name) {
+  const filePath = profilePath(name);
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Profile "${name}" not found. Create with: stealth profile create ${name}`);
+  }
+
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+/**
+ * Save profile (update cookies, stats, etc.)
+ */
+export function saveProfile(name, profile) {
+  ensureDir();
+  const filePath = profilePath(name);
+  fs.writeFileSync(filePath, JSON.stringify(profile, null, 2));
+}
+
+/**
+ * Update profile usage stats
+ */
+export function touchProfile(name) {
+  const profile = loadProfile(name);
+  profile.lastUsed = new Date().toISOString();
+  profile.useCount += 1;
+  saveProfile(name, profile);
+  return profile;
+}
+
+/**
+ * Save cookies to profile (auto-called when browser closes)
+ */
+export async function saveCookiesToProfile(name, context) {
+  try {
+    const profile = loadProfile(name);
+    const cookies = await context.cookies();
+    profile.cookies = cookies;
+    profile.lastUsed = new Date().toISOString();
+    saveProfile(name, profile);
+    return cookies.length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Load cookies from profile into browser context
+ */
+export async function loadCookiesFromProfile(name, context) {
+  try {
+    const profile = loadProfile(name);
+    if (profile.cookies && profile.cookies.length > 0) {
+      await context.addCookies(profile.cookies);
+      return profile.cookies.length;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * List all profiles
+ */
+export function listProfiles() {
+  ensureDir();
+  const files = fs.readdirSync(PROFILES_DIR).filter((f) => f.endsWith('.json'));
+
+  return files.map((f) => {
+    try {
+      const profile = JSON.parse(fs.readFileSync(path.join(PROFILES_DIR, f), 'utf-8'));
+      return {
+        name: profile.name,
+        locale: profile.fingerprint?.locale || '?',
+        timezone: profile.fingerprint?.timezone || '?',
+        os: profile.fingerprint?.os || '?',
+        viewport: profile.fingerprint?.viewport
+          ? `${profile.fingerprint.viewport.width}x${profile.fingerprint.viewport.height}`
+          : '?',
+        proxy: profile.proxy ? '✓' : '-',
+        cookies: profile.cookies?.length || 0,
+        lastUsed: profile.lastUsed || 'never',
+        useCount: profile.useCount || 0,
+      };
+    } catch {
+      return { name: f.replace('.json', ''), error: 'corrupted' };
+    }
+  });
+}
+
+/**
+ * Delete a profile
+ */
+export function deleteProfile(name) {
+  const filePath = profilePath(name);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Profile "${name}" not found`);
+  }
+  fs.unlinkSync(filePath);
+}
+
+/**
+ * Get available presets
+ */
+export function getPresets() {
+  return Object.keys(FINGERPRINT_PRESETS);
+}
+
+/**
+ * Pick a random profile from existing ones
+ */
+export function randomProfile() {
+  const profiles = listProfiles();
+  if (profiles.length === 0) return null;
+  return profiles[Math.floor(Math.random() * profiles.length)].name;
+}

package/src/proxy-pool.js

@@ -0,0 +1,256 @@
+/**
+ * Proxy pool management — store, test, and rotate proxies
+ *
+ * Storage: ~/.stealth/proxies.json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STEALTH_DIR = path.join(os.homedir(), '.stealth');
+const PROXIES_FILE = path.join(STEALTH_DIR, 'proxies.json');
+
+function ensureDir() {
+  fs.mkdirSync(STEALTH_DIR, { recursive: true });
+}
+
+function loadData() {
+  ensureDir();
+  if (!fs.existsSync(PROXIES_FILE)) {
+    return { proxies: [], lastRotateIndex: 0 };
+  }
+  return JSON.parse(fs.readFileSync(PROXIES_FILE, 'utf-8'));
+}
+
+function saveData(data) {
+  ensureDir();
+  fs.writeFileSync(PROXIES_FILE, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Add a proxy to the pool
+ *
+ * @param {string} proxyUrl - Proxy URL (http://user:pass@host:port)
+ * @param {object} opts
+ * @param {string} [opts.label] - Label/name for this proxy
+ * @param {string} [opts.region] - Geographic region
+ */
+export function addProxy(proxyUrl, opts = {}) {
+  const data = loadData();
+
+  // Check for duplicates
+  if (data.proxies.some((p) => p.url === proxyUrl)) {
+    throw new Error('Proxy already exists in pool');
+  }
+
+  data.proxies.push({
+    url: proxyUrl,
+    label: opts.label || null,
+    region: opts.region || null,
+    addedAt: new Date().toISOString(),
+    lastUsed: null,
+    useCount: 0,
+    lastStatus: null, // 'ok' | 'fail' | null
+    lastLatency: null, // ms
+    failCount: 0,
+  });
+
+  saveData(data);
+  return data.proxies.length;
+}
+
+/**
+ * Remove a proxy from the pool
+ */
+export function removeProxy(proxyUrl) {
+  const data = loadData();
+  const idx = data.proxies.findIndex((p) => p.url === proxyUrl || p.label === proxyUrl);
+  if (idx === -1) throw new Error('Proxy not found');
+  data.proxies.splice(idx, 1);
+  saveData(data);
+}
+
+/**
+ * List all proxies
+ */
+export function listProxies() {
+  const data = loadData();
+  return data.proxies.map((p) => ({
+    url: maskPassword(p.url),
+    label: p.label || '-',
+    region: p.region || '-',
+    status: p.lastStatus || 'unknown',
+    latency: p.lastLatency ? `${p.lastLatency}ms` : '-',
+    useCount: p.useCount,
+    failCount: p.failCount,
+    lastUsed: p.lastUsed || 'never',
+  }));
+}
+
+/**
+ * Get the next proxy (round-robin rotation)
+ */
+export function getNextProxy() {
+  const data = loadData();
+
+  if (data.proxies.length === 0) return null;
+
+  // Filter out proxies with too many consecutive failures
+  const available = data.proxies.filter((p) => p.failCount < 5);
+  if (available.length === 0) {
+    // Reset all fail counts and try again
+    data.proxies.forEach((p) => { p.failCount = 0; });
+    saveData(data);
+    return data.proxies[0]?.url || null;
+  }
+
+  // Round-robin
+  const idx = data.lastRotateIndex % available.length;
+  const proxy = available[idx];
+
+  // Update stats
+  proxy.lastUsed = new Date().toISOString();
+  proxy.useCount += 1;
+  data.lastRotateIndex = idx + 1;
+
+  saveData(data);
+  return proxy.url;
+}
+
+/**
+ * Get a random proxy from the pool
+ */
+export function getRandomProxy() {
+  const data = loadData();
+  const available = data.proxies.filter((p) => p.failCount < 5);
+  if (available.length === 0) return null;
+
+  const proxy = available[Math.floor(Math.random() * available.length)];
+  proxy.lastUsed = new Date().toISOString();
+  proxy.useCount += 1;
+  saveData(data);
+
+  return proxy.url;
+}
+
+/**
+ * Report proxy success/failure (updates stats)
+ */
+export function reportProxy(proxyUrl, success, latencyMs = null) {
+  const data = loadData();
+  const proxy = data.proxies.find((p) => p.url === proxyUrl);
+  if (!proxy) return;
+
+  if (success) {
+    proxy.lastStatus = 'ok';
+    proxy.failCount = 0;
+    proxy.lastLatency = latencyMs;
+  } else {
+    proxy.lastStatus = 'fail';
+    proxy.failCount += 1;
+  }
+
+  saveData(data);
+}
+
+/**
+ * Test a proxy by making a request
+ */
+export async function testProxy(proxyUrl) {
+  const { launchOptions } = await import('camoufox-js');
+  const { firefox } = await import('playwright-core');
+
+  const start = Date.now();
+  let browser;
+
+  try {
+    // Parse proxy URL
+    let proxyConfig;
+    try {
+      const url = new URL(proxyUrl.startsWith('http') ? proxyUrl : `http://${proxyUrl}`);
+      proxyConfig = {
+        server: `${url.protocol}//${url.hostname}:${url.port}`,
+        username: url.username || undefined,
+        password: url.password || undefined,
+      };
+    } catch {
+      throw new Error(`Invalid proxy URL: ${proxyUrl}`);
+    }
+
+    const options = await launchOptions({
+      headless: true,
+      proxy: proxyConfig,
+    });
+
+    browser = await firefox.launch(options);
+    const context = await browser.newContext();
+    const page = await context.newPage();
+
+    // Test with a fast, reliable site
+    await page.goto('https://httpbin.org/ip', { timeout: 15000 });
+    const body = await page.textContent('body');
+    const ip = JSON.parse(body)?.origin || 'unknown';
+
+    const latency = Date.now() - start;
+
+    await context.close();
+    await browser.close();
+
+    reportProxy(proxyUrl, true, latency);
+
+    return {
+      ok: true,
+      ip,
+      latency,
+      proxy: maskPassword(proxyUrl),
+    };
+  } catch (err) {
+    if (browser) await browser.close().catch(() => {});
+    reportProxy(proxyUrl, false);
+
+    return {
+      ok: false,
+      error: err.message,
+      latency: Date.now() - start,
+      proxy: maskPassword(proxyUrl),
+    };
+  }
+}
+
+/**
+ * Test all proxies in pool
+ */
+export async function testAllProxies() {
+  const data = loadData();
+  const results = [];
+
+  for (const proxy of data.proxies) {
+    const result = await testProxy(proxy.url);
+    results.push(result);
+  }
+
+  return results;
+}
+
+/**
+ * Get pool size
+ */
+export function poolSize() {
+  return loadData().proxies.length;
+}
+
+/**
+ * Mask password in proxy URL for display
+ */
+function maskPassword(url) {
+  try {
+    const parsed = new URL(url.startsWith('http') ? url : `http://${url}`);
+    if (parsed.password) {
+      parsed.password = '****';
+    }
+    return parsed.toString().replace(/\/$/, '');
+  } catch {
+    return url;
+  }
+}

package/src/retry.js

@@ -0,0 +1,112 @@
+/**
+ * Retry mechanism with exponential backoff
+ */
+
+import { log } from './output.js';
+
+/**
+ * Retryable error types
+ */
+const RETRYABLE_PATTERNS = [
+  'timeout',
+  'net::ERR_',
+  'Navigation failed',
+  'Target closed',
+  'Session closed',
+  'Connection refused',
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'ETIMEDOUT',
+  'page.goto: Timeout',
+  'frame was detached',
+  'browser has disconnected',
+];
+
+/**
+ * Check if an error is retryable
+ */
+function isRetryable(err) {
+  const msg = err.message || String(err);
+  return RETRYABLE_PATTERNS.some((p) => msg.toLowerCase().includes(p.toLowerCase()));
+}
+
+/**
+ * Execute a function with retry logic
+ *
+ * @param {Function} fn - Async function to execute
+ * @param {object} opts
+ * @param {number} [opts.maxRetries=3] - Maximum retry attempts
+ * @param {number} [opts.baseDelay=1000] - Base delay in ms (doubles each retry)
+ * @param {number} [opts.maxDelay=10000] - Maximum delay between retries
+ * @param {string} [opts.label='operation'] - Label for log messages
+ * @param {Function} [opts.shouldRetry] - Custom retry check (receives error)
+ * @param {Function} [opts.onRetry] - Callback before each retry (receives { error, attempt, delay })
+ * @returns {Promise<*>} Result of fn
+ */
+export async function withRetry(fn, opts = {}) {
+  const {
+    maxRetries = 3,
+    baseDelay = 1000,
+    maxDelay = 10000,
+    label = 'operation',
+    shouldRetry = isRetryable,
+    onRetry,
+  } = opts;
+
+  let lastError;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastError = err;
+
+      // Don't retry if max attempts reached
+      if (attempt >= maxRetries) break;
+
+      // Don't retry if error is not retryable
+      if (!shouldRetry(err)) {
+        break;
+      }
+
+      // Calculate delay with exponential backoff + jitter
+      const exponentialDelay = baseDelay * Math.pow(2, attempt);
+      const jitter = Math.random() * baseDelay * 0.5;
+      const delay = Math.min(exponentialDelay + jitter, maxDelay);
+
+      log.warn(`${label} failed (attempt ${attempt + 1}/${maxRetries + 1}): ${err.message}`);
+      log.dim(`  Retrying in ${Math.round(delay)}ms...`);
+
+      if (onRetry) {
+        await onRetry({ error: err, attempt: attempt + 1, delay });
+      }
+
+      await sleep(delay);
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Navigate to URL with automatic retry
+ */
+export async function navigateWithRetry(page, url, opts = {}) {
+  const { timeout = 30000, waitUntil = 'domcontentloaded', maxRetries = 2, ...retryOpts } = opts;
+
+  return withRetry(
+    async () => {
+      await page.goto(url, { waitUntil, timeout });
+      return page.url();
+    },
+    {
+      maxRetries,
+      label: `navigate to ${url.slice(0, 60)}`,
+      ...retryOpts,
+    },
+  );
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}