stealth-cli 0.5.0

package/src/commands/browse.js

@@ -0,0 +1,101 @@
+/**
+ * stealth browse <url> - Visit a URL and print page content
+ */
+
+import ora from 'ora';
+import {
+  launchBrowser, closeBrowser, navigate, getSnapshot,
+  getTextContent, getTitle, getUrl, evaluate, waitForReady,
+} from '../browser.js';
+import { formatOutput, log } from '../output.js';
+
+export function registerBrowse(program) {
+  program
+    .command('browse')
+    .description('Visit a URL and print page content')
+    .argument('<url>', 'URL to visit')
+    .option('-f, --format <format>', 'Output format: text, json, markdown, snapshot', 'text')
+    .option('-w, --wait <ms>', 'Wait time after page load (ms)', '2000')
+    .option('--proxy <proxy>', 'Proxy server (http://user:pass@host:port)')
+    .option('--cookies <file>', 'Load cookies from Netscape-format file')
+    .option('--no-headless', 'Show browser window')
+    .option('--locale <locale>', 'Browser locale', 'en-US')
+    .option('--user-agent', 'Print the browser user-agent')
+    .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,
+          locale: opts.locale,
+        });
+
+        // Load cookies if provided (direct mode only)
+        if (opts.cookies && !handle.isDaemon) {
+          const { loadCookies } = await import('../cookies.js');
+          const result = await loadCookies(handle.context, opts.cookies);
+          spinner.text = `Loaded ${result.count} 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.stop();
+
+        // Print user-agent if requested
+        if (opts.userAgent) {
+          const ua = await evaluate(handle, 'navigator.userAgent');
+          log.info(`User-Agent: ${ua}`);
+        }
+
+        // Get page content based on format
+        let output;
+
+        if (opts.format === 'snapshot') {
+          output = await getSnapshot(handle);
+        } else if (opts.format === 'json') {
+          const title = await getTitle(handle);
+          const currentUrl = await getUrl(handle);
+          const ua = await evaluate(handle, 'navigator.userAgent');
+          const text = await getTextContent(handle);
+          output = formatOutput({
+            url: currentUrl,
+            title,
+            userAgent: ua,
+            content: text.slice(0, 10000),
+            timestamp: new Date().toISOString(),
+          }, 'json');
+        } else {
+          output = await getTextContent(handle);
+        }
+
+        console.log(output);
+
+        const currentUrl = await getUrl(handle);
+        log.success(`Done: ${currentUrl}`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`Browse failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}

package/src/commands/config.js

@@ -0,0 +1,85 @@
+/**
+ * stealth config - Manage global configuration
+ */
+
+import chalk from 'chalk';
+import {
+  getConfigValue, setConfigValue, deleteConfigValue,
+  listConfig, resetConfig, CONFIG_FILE,
+} from '../config.js';
+import { log } from '../output.js';
+
+export function registerConfig(program) {
+  const config = program
+    .command('config')
+    .description('Manage global configuration (~/.stealth/config.json)');
+
+  // stealth config list
+  config
+    .command('list')
+    .description('Show all config values')
+    .action(() => {
+      const items = listConfig();
+      console.log(chalk.bold('\n  Configuration:\n'));
+      console.log(chalk.dim(`  ${'Key'.padEnd(20)} ${'Value'.padEnd(25)} Source`));
+      console.log(chalk.dim('  ' + '─'.repeat(55)));
+
+      for (const item of items) {
+        const val = item.value === null ? chalk.dim('null') : String(item.value);
+        const src = item.source === 'user' ? chalk.cyan('user') : chalk.dim('default');
+        console.log(`  ${item.key.padEnd(20)} ${val.padEnd(25)} ${src}`);
+      }
+
+      console.log(chalk.dim(`\n  File: ${CONFIG_FILE}\n`));
+    });
+
+  // stealth config get <key>
+  config
+    .command('get')
+    .description('Get a config value')
+    .argument('<key>', 'Config key')
+    .action((key) => {
+      try {
+        const value = getConfigValue(key);
+        console.log(value);
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // stealth config set <key> <value>
+  config
+    .command('set')
+    .description('Set a config value')
+    .argument('<key>', 'Config key')
+    .argument('<value>', 'Config value')
+    .action((key, value) => {
+      try {
+        const result = setConfigValue(key, value);
+        log.success(`${key} = ${result}`);
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // stealth config delete <key>
+  config
+    .command('delete')
+    .description('Reset a config value to default')
+    .argument('<key>', 'Config key')
+    .action((key) => {
+      deleteConfigValue(key);
+      log.success(`${key} reset to default`);
+    });
+
+  // stealth config reset
+  config
+    .command('reset')
+    .description('Reset all config to defaults')
+    .action(() => {
+      resetConfig();
+      log.success('All config reset to defaults');
+    });
+}

package/src/commands/crawl.js

@@ -0,0 +1,169 @@
+/**
+ * stealth crawl <url> - Crawl pages recursively with anti-detection
+ */
+
+import ora from 'ora';
+import { launchBrowser, closeBrowser, getTextContent, evaluate, waitForReady } from '../browser.js';
+import { navigateWithRetry } from '../retry.js';
+import { randomDelay, humanScroll } from '../humanize.js';
+import { formatOutput, log } from '../output.js';
+
+export function registerCrawl(program) {
+  program
+    .command('crawl')
+    .description('Crawl pages recursively with anti-detection')
+    .argument('<url>', 'Starting URL')
+    .option('-d, --depth <n>', 'Maximum crawl depth', '1')
+    .option('-l, --limit <n>', 'Maximum pages to crawl', '10')
+    .option('--same-origin', 'Only follow same-origin links (default: true)', true)
+    .option('--delay <ms>', 'Delay between requests (ms)', '1000')
+    .option('-f, --format <format>', 'Output format: json, jsonl, text', 'jsonl')
+    .option('-o, --output <file>', 'Output file (default: stdout)')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--cookies <file>', 'Load cookies from Netscape-format file')
+    .option('--no-headless', 'Show browser window')
+    .option('--include <pattern>', 'Only crawl URLs matching this pattern (regex)')
+    .option('--exclude <pattern>', 'Skip URLs matching this pattern (regex)')
+    .option('--humanize', 'Enable human behavior simulation')
+    .option('--retries <n>', 'Max retries per page', '2')
+    .option('--profile <name>', 'Use a browser profile')
+    .option('--proxy-rotate', 'Rotate proxy from pool')
+    .action(async (startUrl, opts) => {
+      const spinner = ora('Launching stealth browser...').start();
+      let handle;
+
+      const maxDepth = parseInt(opts.depth);
+      const maxPages = parseInt(opts.limit);
+      const delay = parseInt(opts.delay);
+      const maxRetries = parseInt(opts.retries);
+      const includeRegex = opts.include ? new RegExp(opts.include) : null;
+      const excludeRegex = opts.exclude ? new RegExp(opts.exclude) : null;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+          proxyRotate: opts.proxyRotate,
+          profile: opts.profile,
+        });
+
+        // Crawl requires direct mode (page access)
+        if (handle.isDaemon) {
+          log.warn('Crawl uses direct mode (daemon does not support multi-page crawling)');
+        }
+
+        if (opts.cookies && handle.context) {
+          const { loadCookies } = await import('../cookies.js');
+          await loadCookies(handle.context, opts.cookies);
+        }
+
+        const startOrigin = new URL(startUrl).origin;
+        const visited = new Set();
+        const queue = [{ url: startUrl, depth: 0 }];
+        const results = [];
+        let outputStream;
+
+        if (opts.output) {
+          const { createWriteStream } = await import('fs');
+          outputStream = createWriteStream(opts.output);
+        }
+
+        const writeResult = (result) => {
+          const line = opts.format === 'jsonl'
+            ? JSON.stringify(result)
+            : formatOutput(result, opts.format);
+
+          if (outputStream) {
+            outputStream.write(line + '\n');
+          } else {
+            console.log(line);
+          }
+          results.push(result);
+        };
+
+        while (queue.length > 0 && results.length < maxPages) {
+          const { url, depth } = queue.shift();
+
+          if (visited.has(url)) continue;
+          visited.add(url);
+
+          if (includeRegex && !includeRegex.test(url)) continue;
+          if (excludeRegex && excludeRegex.test(url)) continue;
+
+          spinner.text = `[${results.length + 1}/${maxPages}] Crawling: ${url.slice(0, 60)}...`;
+
+          try {
+            // Navigate with retry
+            await navigateWithRetry(handle.page, url, {
+              timeout: 30000,
+              maxRetries,
+            });
+            await waitForReady(handle.page, { timeout: 3000 });
+
+            const title = await handle.page.title().catch(() => '');
+            const text = await getTextContent(handle);
+
+            const result = {
+              url: handle.page.url(),
+              title,
+              content: text.slice(0, 5000),
+              depth,
+              timestamp: new Date().toISOString(),
+            };
+
+            writeResult(result);
+
+            // Extract links for next depth
+            if (depth < maxDepth) {
+              const links = await handle.page.evaluate(() => {
+                return Array.from(document.querySelectorAll('a[href]'))
+                  .map((a) => a.href)
+                  .filter((href) => href && href.startsWith('http'));
+              });
+
+              for (const link of links) {
+                if (visited.has(link)) continue;
+
+                if (opts.sameOrigin) {
+                  try {
+                    if (new URL(link).origin !== startOrigin) continue;
+                  } catch { continue; }
+                }
+
+                queue.push({ url: link, depth: depth + 1 });
+              }
+            }
+
+            // Human-like delay between pages
+            if (delay > 0) {
+              if (opts.humanize) {
+                // Human mode: scroll + random delay
+                await humanScroll(handle.page, { scrolls: 1 });
+                await randomDelay(delay * 0.8, delay * 1.5);
+              } else {
+                // Standard: fixed delay + small jitter
+                const jitter = delay + Math.random() * delay * 0.3;
+                await handle.page.waitForTimeout(jitter);
+              }
+            }
+          } catch (err) {
+            log.warn(`Failed to crawl ${url}: ${err.message}`);
+          }
+        }
+
+        if (outputStream) outputStream.end();
+
+        spinner.stop();
+        log.success(`Crawl complete: ${results.length} pages crawled`);
+        log.dim(`  Start: ${startUrl}`);
+        log.dim(`  Depth: ${maxDepth}, Visited: ${visited.size}`);
+        if (opts.output) log.dim(`  Output: ${opts.output}`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`Crawl failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}

package/src/commands/daemon.js

@@ -0,0 +1,143 @@
+/**
+ * stealth daemon - Manage background browser daemon
+ */
+
+import { fork } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import { isDaemonRunning, PID_PATH, SOCKET_PATH, STEALTH_DIR } from '../daemon.js';
+import { daemonStatus, daemonShutdown } from '../client.js';
+import { log } from '../output.js';
+
+export function registerDaemon(program) {
+  const daemon = program
+    .command('daemon')
+    .description('Manage background browser daemon for instant startup');
+
+  // stealth daemon start
+  daemon
+    .command('start')
+    .description('Start background browser daemon')
+    .option('--idle-timeout <minutes>', 'Auto-shutdown after idle (minutes)', '5')
+    .option('--verbose', 'Show daemon logs in terminal')
+    .action(async (opts) => {
+      if (isDaemonRunning()) {
+        const status = await daemonStatus();
+        if (status?.ok) {
+          log.info(`Daemon already running (pid: ${status.pid}, uptime: ${status.uptime}s, memory: ${status.memoryMB}MB)`);
+          return;
+        }
+      }
+
+      const idleTimeout = parseInt(opts.idleTimeout) * 60 * 1000;
+
+      if (opts.verbose) {
+        // Run in foreground
+        log.info('Starting daemon in foreground (Ctrl+C to stop)...');
+        const { startDaemon } = await import('../daemon.js');
+        await startDaemon({ idleTimeout, verbose: true });
+      } else {
+        // Fork as background process
+        fs.mkdirSync(STEALTH_DIR, { recursive: true });
+
+        const daemonScript = path.join(
+          path.dirname(fileURLToPath(import.meta.url)),
+          '..',
+          'daemon-entry.js',
+        );
+
+        const child = fork(daemonScript, [], {
+          detached: true,
+          stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+          env: {
+            ...process.env,
+            STEALTH_IDLE_TIMEOUT: String(idleTimeout),
+          },
+        });
+
+        // Wait for daemon to report ready
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            reject(new Error('Daemon startup timeout (15s)'));
+          }, 15000);
+
+          child.on('message', (msg) => {
+            if (msg === 'ready') {
+              clearTimeout(timer);
+              resolve();
+            }
+          });
+
+          child.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+          });
+
+          child.on('exit', (code) => {
+            if (code !== 0) {
+              clearTimeout(timer);
+              reject(new Error(`Daemon exited with code ${code}`));
+            }
+          });
+        });
+
+        child.unref();
+        child.disconnect();
+
+        log.success(`Daemon started (pid: ${child.pid})`);
+        log.dim(`  Socket: ${SOCKET_PATH}`);
+        log.dim(`  Idle timeout: ${opts.idleTimeout} minutes`);
+        log.dim(`  Stop with: stealth daemon stop`);
+      }
+    });
+
+  // stealth daemon stop
+  daemon
+    .command('stop')
+    .description('Stop the background daemon')
+    .action(async () => {
+      if (!isDaemonRunning()) {
+        log.info('Daemon is not running');
+        return;
+      }
+
+      const result = await daemonShutdown();
+      if (result?.ok) {
+        log.success('Daemon stopped');
+      } else {
+        // Force kill via PID
+        try {
+          const pid = parseInt(fs.readFileSync(PID_PATH, 'utf-8').trim());
+          process.kill(pid, 'SIGTERM');
+          log.success(`Daemon killed (pid: ${pid})`);
+        } catch {
+          log.error('Failed to stop daemon');
+        }
+      }
+    });
+
+  // stealth daemon status
+  daemon
+    .command('status')
+    .description('Show daemon status')
+    .action(async () => {
+      if (!isDaemonRunning()) {
+        log.info('Daemon is not running');
+        log.dim('  Start with: stealth daemon start');
+        return;
+      }
+
+      const status = await daemonStatus();
+      if (status?.ok) {
+        log.success('Daemon is running');
+        log.dim(`  PID: ${status.pid}`);
+        log.dim(`  Uptime: ${status.uptime}s`);
+        log.dim(`  Contexts: ${status.contexts}`);
+        log.dim(`  Memory: ${status.memoryMB}MB`);
+        log.dim(`  Browser: ${status.browserConnected ? 'connected' : 'disconnected'}`);
+      } else {
+        log.warn('Daemon is running but not responding');
+      }
+    });
+}

package/src/commands/extract.js

@@ -0,0 +1,153 @@
+/**
+ * stealth extract <url> - Extract structured data from a page
+ */
+
+import ora from 'ora';
+import {
+  launchBrowser, closeBrowser, navigate, getTitle,
+  getUrl, evaluate, waitForReady,
+} from '../browser.js';
+import { formatOutput, log } from '../output.js';
+
+export function registerExtract(program) {
+  program
+    .command('extract')
+    .description('Extract structured data from a page')
+    .argument('<url>', 'URL to extract from')
+    .option('-s, --selector <selector>', 'CSS selector to extract', 'body')
+    .option('-a, --attr <attribute>', 'Extract attribute instead of text (e.g. href, src)')
+    .option('--all', 'Extract all matching elements (not just the first)')
+    .option('--links', 'Extract all links from the page')
+    .option('--images', 'Extract all image URLs from the page')
+    .option('--meta', 'Extract meta tags (title, description, og tags)')
+    .option('--headers', 'Extract all headings (h1-h6)')
+    .option('-f, --format <format>', 'Output format: json, text, markdown', 'json')
+    .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('--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,
+        });
+
+        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 = 'Extracting data...';
+        spinner.stop();
+
+        let result;
+        const evalFn = (expr) => evaluate(handle, expr);
+
+        if (opts.links) {
+          result = await evalFn(`(() => {
+            const links = [];
+            document.querySelectorAll('a[href]').forEach(a => {
+              const href = a.href;
+              const text = a.textContent?.trim().slice(0, 200) || '';
+              if (href && href.startsWith('http')) links.push({ url: href, text });
+            });
+            return links;
+          })()`);
+        } else if (opts.images) {
+          result = await evalFn(`(() => {
+            const images = [];
+            document.querySelectorAll('img[src]').forEach(img => {
+              images.push({
+                src: img.src,
+                alt: img.alt || '',
+                width: img.naturalWidth || img.width || 0,
+                height: img.naturalHeight || img.height || 0,
+              });
+            });
+            return images;
+          })()`);
+        } else if (opts.meta) {
+          result = await evalFn(`(() => {
+            const getMeta = (name) => {
+              const el = document.querySelector('meta[name="' + name + '"]')
+                || document.querySelector('meta[property="' + name + '"]');
+              return el?.getAttribute('content') || '';
+            };
+            return {
+              title: document.title || '',
+              description: getMeta('description'),
+              keywords: getMeta('keywords'),
+              ogTitle: getMeta('og:title'),
+              ogDescription: getMeta('og:description'),
+              ogImage: getMeta('og:image'),
+              ogUrl: getMeta('og:url'),
+              canonical: document.querySelector('link[rel="canonical"]')?.href || '',
+            };
+          })()`);
+        } else if (opts.headers) {
+          result = await evalFn(`(() => {
+            const headings = [];
+            document.querySelectorAll('h1, h2, h3, h4, h5, h6').forEach(h => {
+              headings.push({ level: parseInt(h.tagName[1]), text: h.textContent?.trim() || '' });
+            });
+            return headings;
+          })()`);
+        } else {
+          const selector = opts.selector;
+          const attr = opts.attr;
+          const all = opts.all;
+          result = await evalFn(`(() => {
+            const elements = ${all}
+              ? Array.from(document.querySelectorAll('${selector}'))
+              : [document.querySelector('${selector}')].filter(Boolean);
+            return elements.map(el => {
+              if ('${attr || ''}') return el.getAttribute('${attr || ''}');
+              return el.textContent?.trim() || '';
+            });
+          })()`);
+        }
+
+        const title = await getTitle(handle);
+        const currentUrl = await getUrl(handle);
+
+        const output = formatOutput({
+          url: currentUrl,
+          title,
+          data: result,
+          count: Array.isArray(result) ? result.length : 1,
+          timestamp: new Date().toISOString(),
+        }, opts.format);
+
+        console.log(output);
+        log.success(`Extracted from: ${currentUrl}`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`Extract failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}