stealth-cli 0.5.0

package/src/commands/monitor.js

@@ -0,0 +1,160 @@
+/**
+ * stealth monitor <url> - Monitor a page for changes
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import { launchBrowser, closeBrowser, navigate, evaluate, waitForReady } from '../browser.js';
+import { randomDelay } from '../humanize.js';
+import { log } from '../output.js';
+
+export function registerMonitor(program) {
+  program
+    .command('monitor')
+    .description('Monitor a page for changes')
+    .argument('<url>', 'URL to monitor')
+    .option('-s, --selector <selector>', 'CSS selector to watch (default: body)')
+    .option('-i, --interval <seconds>', 'Check interval in seconds', '60')
+    .option('-n, --count <n>', 'Max checks (0 = infinite)', '0')
+    .option('--attr <attribute>', 'Watch an attribute instead of text')
+    .option('--contains <text>', 'Alert when page contains this text')
+    .option('--not-contains <text>', 'Alert when page no longer contains this text')
+    .option('--json', 'Output changes as JSON')
+    .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')
+    .action(async (url, opts) => {
+      const interval = parseInt(opts.interval) * 1000;
+      const maxChecks = parseInt(opts.count);
+      const selector = opts.selector || 'body';
+
+      log.info(`Monitoring ${url}`);
+      log.dim(`  Selector: ${selector}`);
+      log.dim(`  Interval: ${opts.interval}s`);
+      if (maxChecks > 0) log.dim(`  Max checks: ${maxChecks}`);
+      console.log();
+
+      let handle;
+      let previousValue = null;
+      let checkCount = 0;
+      let changeCount = 0;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+          proxyRotate: opts.proxyRotate,
+          profile: opts.profile,
+        });
+
+        if (handle.isDaemon) {
+          log.error('Monitor requires direct mode');
+          process.exit(1);
+        }
+
+        // Main monitoring loop
+        while (true) {
+          checkCount++;
+          const ts = new Date().toISOString();
+
+          try {
+            await navigate(handle, url, { retries: 1 });
+            await waitForReady(handle.page, { timeout: 5000 });
+
+            // Extract current value
+            let currentValue;
+            if (opts.attr) {
+              currentValue = await handle.page.$eval(selector, (el, attr) => el.getAttribute(attr), opts.attr)
+                .catch(() => null);
+            } else {
+              currentValue = await handle.page.$eval(selector, (el) => el.textContent?.trim())
+                .catch(() => null);
+            }
+
+            // Text contains check
+            if (opts.contains) {
+              const found = currentValue?.includes(opts.contains);
+              if (found) {
+                changeCount++;
+                const msg = `[${ts}] ✓ FOUND: "${opts.contains}"`;
+                if (opts.json) {
+                  console.log(JSON.stringify({ event: 'found', text: opts.contains, url, timestamp: ts, check: checkCount }));
+                } else {
+                  console.log(chalk.green(msg));
+                }
+              } else {
+                if (!opts.json) process.stderr.write(chalk.dim(`[${ts}] Check #${checkCount} — not found\r`));
+              }
+            }
+            // Text not-contains check
+            else if (opts.notContains) {
+              const found = currentValue?.includes(opts.notContains);
+              if (!found) {
+                changeCount++;
+                const msg = `[${ts}] ✓ DISAPPEARED: "${opts.notContains}"`;
+                if (opts.json) {
+                  console.log(JSON.stringify({ event: 'disappeared', text: opts.notContains, url, timestamp: ts, check: checkCount }));
+                } else {
+                  console.log(chalk.yellow(msg));
+                }
+              } else {
+                if (!opts.json) process.stderr.write(chalk.dim(`[${ts}] Check #${checkCount} — still present\r`));
+              }
+            }
+            // Diff check
+            else {
+              if (previousValue === null) {
+                previousValue = currentValue;
+                if (!opts.json) {
+                  log.info(`[${ts}] Initial snapshot captured (${currentValue?.length || 0} chars)`);
+                }
+              } else if (currentValue !== previousValue) {
+                changeCount++;
+
+                if (opts.json) {
+                  console.log(JSON.stringify({
+                    event: 'changed',
+                    url,
+                    selector,
+                    previous: previousValue?.slice(0, 500),
+                    current: currentValue?.slice(0, 500),
+                    timestamp: ts,
+                    check: checkCount,
+                    changeNumber: changeCount,
+                  }));
+                } else {
+                  console.log(chalk.yellow(`\n[${ts}] CHANGE #${changeCount} detected!`));
+                  console.log(chalk.dim('  Previous:'), (previousValue || '').slice(0, 200));
+                  console.log(chalk.cyan('  Current: '), (currentValue || '').slice(0, 200));
+                  console.log();
+                }
+
+                previousValue = currentValue;
+              } else {
+                if (!opts.json) process.stderr.write(chalk.dim(`[${ts}] Check #${checkCount} — no change\r`));
+              }
+            }
+          } catch (err) {
+            log.warn(`Check #${checkCount} failed: ${err.message}`);
+          }
+
+          // Check if we should stop
+          if (maxChecks > 0 && checkCount >= maxChecks) {
+            break;
+          }
+
+          // Wait for next check (with jitter)
+          await randomDelay(interval * 0.9, interval * 1.1);
+        }
+
+        console.log();
+        log.success(`Monitoring complete: ${checkCount} checks, ${changeCount} changes`);
+      } catch (err) {
+        log.error(`Monitor failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}

package/src/commands/pdf.js

@@ -0,0 +1,109 @@
+/**
+ * stealth pdf <url> - Save a page as PDF
+ */
+
+import ora from 'ora';
+import { launchBrowser, closeBrowser, navigate, waitForReady } from '../browser.js';
+import { log } from '../output.js';
+
+export function registerPdf(program) {
+  program
+    .command('pdf')
+    .description('Save a page as PDF')
+    .argument('<url>', 'URL to convert')
+    .option('-o, --output <file>', 'Output file path', 'page.pdf')
+    .option('--format <size>', 'Paper size: A4, Letter, Legal, A3', 'A4')
+    .option('--landscape', 'Landscape orientation')
+    .option('--margin <px>', 'Margin in pixels (all sides)', '20')
+    .option('--no-background', 'Omit background graphics')
+    .option('--scale <n>', 'Scale factor (0.1-2.0)', '1')
+    .option('--header <text>', 'Header template (HTML)')
+    .option('--footer <text>', 'Footer template (HTML)')
+    .option('--pages <range>', 'Page range (e.g. "1-3", "1,3,5")')
+    .option('--wait <ms>', 'Wait time after page load (ms)', '2000')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--cookies <file>', 'Load cookies from Netscape-format file')
+    .option('--profile <name>', 'Use a browser profile')
+    .option('--no-headless', 'Show browser window')
+    .option('--retries <n>', 'Max retries on failure', '2')
+    .action(async (url, opts) => {
+      const spinner = ora('Launching stealth browser...').start();
+      let handle;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+          profile: opts.profile,
+        });
+
+        if (handle.isDaemon) {
+          spinner.stop();
+          log.error('PDF generation requires direct mode (daemon does not support it)');
+          log.dim('  Tip: stop daemon first or use --profile to force direct mode');
+          process.exit(1);
+        }
+
+        if (opts.cookies) {
+          const { loadCookies } = await import('../cookies.js');
+          await loadCookies(handle.context, opts.cookies);
+        }
+
+        spinner.text = `Navigating to ${url}...`;
+        await navigate(handle, url, { retries: parseInt(opts.retries) });
+        await waitForReady(handle.page, { timeout: parseInt(opts.wait) });
+
+        spinner.text = 'Generating PDF...';
+
+        // Firefox/Camoufox doesn't support page.pdf() — use print-to-PDF via CDP
+        // Fallback: take a full-page screenshot and convert context
+        try {
+          await handle.page.pdf({
+            path: opts.output,
+            format: opts.format,
+            landscape: opts.landscape || false,
+            printBackground: opts.background !== false,
+            scale: parseFloat(opts.scale),
+            margin: { top: `${opts.margin}px`, right: `${opts.margin}px`, bottom: `${opts.margin}px`, left: `${opts.margin}px` },
+          });
+        } catch {
+          // Firefox fallback: emulate print media and take full screenshot
+          // This creates a high-quality image, not a true PDF
+          spinner.text = 'Firefox detected — using screenshot-based PDF...';
+
+          const outputFile = opts.output.endsWith('.pdf')
+            ? opts.output.replace(/\.pdf$/, '.png')
+            : opts.output + '.png';
+
+          await handle.page.screenshot({
+            path: outputFile,
+            fullPage: true,
+            type: 'png',
+          });
+
+          log.warn('Firefox/Camoufox does not support native PDF generation');
+          log.dim(`  Full-page screenshot saved instead: ${outputFile}`);
+          log.dim('  Tip: Use a tool like "img2pdf" to convert: img2pdf screenshot.png -o page.pdf');
+
+          spinner.stop();
+          return;
+        }
+
+        spinner.stop();
+
+        const { statSync } = await import('fs');
+        const size = statSync(opts.output).size;
+        const sizeKB = (size / 1024).toFixed(1);
+
+        log.success(`PDF saved: ${opts.output} (${sizeKB} KB)`);
+        log.dim(`  URL:    ${handle.page.url()}`);
+        log.dim(`  Format: ${opts.format}${opts.landscape ? ' landscape' : ''}`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`PDF failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}

package/src/commands/profile.js

@@ -0,0 +1,112 @@
+/**
+ * stealth profile - Manage browser identity profiles
+ */
+
+import {
+  createProfile, loadProfile, deleteProfile,
+  listProfiles, getPresets,
+} from '../profiles.js';
+import { log } from '../output.js';
+import chalk from 'chalk';
+
+export function registerProfile(program) {
+  const profile = program
+    .command('profile')
+    .description('Manage browser identity profiles');
+
+  // stealth profile create <name>
+  profile
+    .command('create')
+    .description('Create a new profile')
+    .argument('<name>', 'Profile name')
+    .option('--preset <preset>', `Use a preset: ${getPresets().join(', ')}`)
+    .option('--random', 'Generate random fingerprint')
+    .option('--locale <locale>', 'Browser locale (e.g. en-US, zh-CN)')
+    .option('--timezone <tz>', 'Timezone (e.g. America/New_York)')
+    .option('--proxy <proxy>', 'Proxy server for this profile')
+    .option('--os <os>', 'OS fingerprint: windows, macos, linux')
+    .action((name, opts) => {
+      try {
+        const p = createProfile(name, opts);
+        log.success(`Profile "${name}" created`);
+        log.dim(`  Locale:   ${p.fingerprint.locale}`);
+        log.dim(`  Timezone: ${p.fingerprint.timezone}`);
+        log.dim(`  OS:       ${p.fingerprint.os}`);
+        log.dim(`  Viewport: ${p.fingerprint.viewport.width}x${p.fingerprint.viewport.height}`);
+        if (p.proxy) log.dim(`  Proxy:    ${p.proxy}`);
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // stealth profile list
+  profile
+    .command('list')
+    .description('List all profiles')
+    .action(() => {
+      const profiles = listProfiles();
+      if (profiles.length === 0) {
+        log.info('No profiles yet. Create one with: stealth profile create <name>');
+        return;
+      }
+
+      console.log(chalk.bold('\n  Profiles:\n'));
+      const header = `  ${'Name'.padEnd(18)} ${'Locale'.padEnd(8)} ${'OS'.padEnd(8)} ${'Viewport'.padEnd(12)} ${'Proxy'.padEnd(6)} ${'Cookies'.padEnd(8)} ${'Uses'.padEnd(6)}`;
+      console.log(chalk.dim(header));
+      console.log(chalk.dim('  ' + '─'.repeat(70)));
+
+      for (const p of profiles) {
+        if (p.error) {
+          console.log(`  ${chalk.red(p.name.padEnd(18))} ${chalk.dim('corrupted')}`);
+          continue;
+        }
+        console.log(
+          `  ${chalk.cyan(p.name.padEnd(18))} ${p.locale.padEnd(8)} ${p.os.padEnd(8)} ${p.viewport.padEnd(12)} ${p.proxy.padEnd(6)} ${String(p.cookies).padEnd(8)} ${String(p.useCount).padEnd(6)}`,
+        );
+      }
+      console.log();
+    });
+
+  // stealth profile show <name>
+  profile
+    .command('show')
+    .description('Show profile details')
+    .argument('<name>', 'Profile name')
+    .action((name) => {
+      try {
+        const p = loadProfile(name);
+        console.log(JSON.stringify(p, null, 2));
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // stealth profile delete <name>
+  profile
+    .command('delete')
+    .description('Delete a profile')
+    .argument('<name>', 'Profile name')
+    .action((name) => {
+      try {
+        deleteProfile(name);
+        log.success(`Profile "${name}" deleted`);
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // stealth profile presets
+  profile
+    .command('presets')
+    .description('List available fingerprint presets')
+    .action(() => {
+      console.log(chalk.bold('\n  Available presets:\n'));
+      for (const name of getPresets()) {
+        console.log(`  ${chalk.cyan(name)}`);
+      }
+      console.log(chalk.dim('\n  Usage: stealth profile create myprofile --preset us-desktop\n'));
+    });
+}

package/src/commands/proxy.js

@@ -0,0 +1,116 @@
+/**
+ * stealth proxy - Manage proxy pool
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import {
+  addProxy, removeProxy, listProxies,
+  testProxy, testAllProxies, poolSize,
+} from '../proxy-pool.js';
+import { log } from '../output.js';
+
+export function registerProxy(program) {
+  const proxy = program
+    .command('proxy')
+    .description('Manage proxy pool');
+
+  // stealth proxy add <url>
+  proxy
+    .command('add')
+    .description('Add a proxy to the pool')
+    .argument('<url>', 'Proxy URL (http://user:pass@host:port)')
+    .option('--label <label>', 'Label for this proxy')
+    .option('--region <region>', 'Geographic region (e.g. US, EU, Asia)')
+    .action((url, opts) => {
+      try {
+        const count = addProxy(url, opts);
+        log.success(`Proxy added (${count} total in pool)`);
+      } catch (err) {
+        log.error(err.message);
+      }
+    });
+
+  // stealth proxy remove <url>
+  proxy
+    .command('remove')
+    .description('Remove a proxy from the pool')
+    .argument('<url>', 'Proxy URL or label')
+    .action((url) => {
+      try {
+        removeProxy(url);
+        log.success('Proxy removed');
+      } catch (err) {
+        log.error(err.message);
+      }
+    });
+
+  // stealth proxy list
+  proxy
+    .command('list')
+    .description('List all proxies')
+    .action(() => {
+      const proxies = listProxies();
+      if (proxies.length === 0) {
+        log.info('No proxies configured. Add one with: stealth proxy add <url>');
+        return;
+      }
+
+      console.log(chalk.bold('\n  Proxy Pool:\n'));
+      const header = `  ${'URL'.padEnd(40)} ${'Label'.padEnd(10)} ${'Status'.padEnd(8)} ${'Latency'.padEnd(10)} ${'Uses'.padEnd(6)} ${'Fails'.padEnd(6)}`;
+      console.log(chalk.dim(header));
+      console.log(chalk.dim('  ' + '─'.repeat(84)));
+
+      for (const p of proxies) {
+        const statusColor = p.status === 'ok' ? chalk.green : p.status === 'fail' ? chalk.red : chalk.dim;
+        console.log(
+          `  ${p.url.padEnd(40).slice(0, 40)} ${p.label.padEnd(10)} ${statusColor(p.status.padEnd(8))} ${p.latency.padEnd(10)} ${String(p.useCount).padEnd(6)} ${String(p.failCount).padEnd(6)}`,
+        );
+      }
+      console.log();
+    });
+
+  // stealth proxy test [url]
+  proxy
+    .command('test')
+    .description('Test proxy connectivity')
+    .argument('[url]', 'Specific proxy URL to test (or test all)')
+    .action(async (url) => {
+      if (url) {
+        const spinner = ora(`Testing ${url}...`).start();
+        const result = await testProxy(url);
+        spinner.stop();
+
+        if (result.ok) {
+          log.success(`Proxy OK — IP: ${result.ip}, Latency: ${result.latency}ms`);
+        } else {
+          log.error(`Proxy FAILED — ${result.error}`);
+        }
+      } else {
+        const size = poolSize();
+        if (size === 0) {
+          log.info('No proxies to test');
+          return;
+        }
+
+        const spinner = ora(`Testing ${size} proxies...`).start();
+        const results = await testAllProxies();
+        spinner.stop();
+
+        let ok = 0;
+        let fail = 0;
+        for (const r of results) {
+          if (r.ok) {
+            ok++;
+            log.success(`${r.proxy} — IP: ${r.ip}, ${r.latency}ms`);
+          } else {
+            fail++;
+            log.error(`${r.proxy} — ${r.error}`);
+          }
+        }
+
+        console.log();
+        log.info(`Results: ${chalk.green(`${ok} ok`)} / ${chalk.red(`${fail} failed`)} / ${size} total`);
+      }
+    });
+}

package/src/commands/screenshot.js

@@ -0,0 +1,96 @@
+/**
+ * stealth screenshot <url> - Take a screenshot of a page
+ */
+
+import ora from 'ora';
+import { launchBrowser, closeBrowser, navigate, takeScreenshot, getUrl, waitForReady } from '../browser.js';
+import { log } from '../output.js';
+
+export function registerScreenshot(program) {
+  program
+    .command('screenshot')
+    .description('Take a screenshot of a page')
+    .argument('<url>', 'URL to screenshot')
+    .option('-o, --output <file>', 'Output file path', 'screenshot.png')
+    .option('--full', 'Capture full page (not just viewport)')
+    .option('--width <px>', 'Viewport width', '1280')
+    .option('--height <px>', 'Viewport height', '720')
+    .option('--wait <ms>', 'Wait time after page load (ms)', '2000')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--cookies <file>', 'Load cookies from Netscape-format file')
+    .option('--no-headless', 'Show browser window')
+    .option('--quality <n>', 'JPEG quality (1-100), only for .jpg output')
+    .option('--humanize', 'Enable human behavior simulation')
+    .option('--retries <n>', 'Max retries on failure', '2')
+    .option('--profile <name>', 'Use a browser profile')
+    .option('--session <name>', 'Use/restore a named session')
+    .option('--proxy-rotate', 'Rotate proxy from pool')
+    .action(async (url, opts) => {
+      const spinner = ora('Launching stealth browser...').start();
+      let handle;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+          proxyRotate: opts.proxyRotate,
+          profile: opts.profile,
+          session: opts.session,
+          viewport: {
+            width: parseInt(opts.width),
+            height: parseInt(opts.height),
+          },
+        });
+
+        // Load cookies (direct mode only)
+        if (opts.cookies && !handle.isDaemon) {
+          const { loadCookies } = await import('../cookies.js');
+          await loadCookies(handle.context, opts.cookies);
+        }
+
+        spinner.text = `Navigating to ${url}...`;
+        await navigate(handle, url, {
+          humanize: opts.humanize,
+          retries: parseInt(opts.retries),
+        });
+
+        if (!handle.isDaemon) {
+          await waitForReady(handle.page, { timeout: parseInt(opts.wait) });
+        }
+
+        spinner.text = 'Taking screenshot...';
+
+        if (handle.isDaemon) {
+          // Daemon mode: get base64 and write to file
+          await takeScreenshot(handle, { path: opts.output, fullPage: opts.full || false });
+        } else {
+          // Direct mode: native screenshot
+          const screenshotOpts = {
+            path: opts.output,
+            fullPage: opts.full || false,
+          };
+
+          if (opts.output.endsWith('.jpg') || opts.output.endsWith('.jpeg')) {
+            screenshotOpts.type = 'jpeg';
+            if (opts.quality) screenshotOpts.quality = parseInt(opts.quality);
+          } else {
+            screenshotOpts.type = 'png';
+          }
+
+          await handle.page.screenshot(screenshotOpts);
+        }
+
+        spinner.stop();
+        const currentUrl = await getUrl(handle);
+        log.success(`Screenshot saved: ${opts.output}`);
+        log.dim(`  URL: ${currentUrl}`);
+        log.dim(`  Size: ${opts.width}x${opts.height}${opts.full ? ' (full page)' : ''}`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`Screenshot failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}