stealth-cli 0.5.0

package/src/commands/search.js

@@ -0,0 +1,162 @@
+/**
+ * stealth search <engine> <query> - Search with anti-detection
+ */
+
+import ora from 'ora';
+import {
+  launchBrowser, closeBrowser, navigate, getSnapshot,
+  getTextContent, getUrl, waitForReady,
+} from '../browser.js';
+import { expandMacro, getSupportedEngines } from '../macros.js';
+import { getExtractorByEngine } from '../extractors/index.js';
+import * as googleExtractor from '../extractors/google.js';
+import { humanScroll, randomDelay, warmup } from '../humanize.js';
+import { formatOutput, log } from '../output.js';
+
+export function registerSearch(program) {
+  program
+    .command('search')
+    .description('Search the web with anti-detection')
+    .argument('<engine>', `Search engine: ${getSupportedEngines().join(', ')}`)
+    .argument('<query>', 'Search query')
+    .option('-f, --format <format>', 'Output format: text, json, snapshot', 'text')
+    .option('-n, --num <n>', 'Max results to extract', '10')
+    .option('--proxy <proxy>', 'Proxy server')
+    .option('--no-headless', 'Show browser window')
+    .option('--humanize', 'Simulate human behavior (auto for Google)')
+    .option('--warmup', 'Visit a random site before searching (helps bypass detection)')
+    .option('--retries <n>', 'Max retries on failure', '2')
+    .option('--also-ask', 'Include "People also ask" questions (Google only)')
+    .option('--profile <name>', 'Use a browser profile')
+    .option('--session <name>', 'Use/restore a named session')
+    .option('--proxy-rotate', 'Rotate proxy from pool')
+    .action(async (engine, query, opts) => {
+      const url = expandMacro(engine, query);
+
+      if (!url) {
+        log.error(`Unknown engine: "${engine}"`);
+        log.info(`Supported: ${getSupportedEngines().join(', ')}`);
+        process.exit(1);
+      }
+
+      const spinner = ora(`Searching ${engine} for "${query}"...`).start();
+      let handle;
+
+      try {
+        handle = await launchBrowser({
+          headless: opts.headless,
+          proxy: opts.proxy,
+          proxyRotate: opts.proxyRotate,
+          profile: opts.profile,
+          session: opts.session,
+        });
+
+        const isGoogle = engine.toLowerCase() === 'google';
+        const extractor = getExtractorByEngine(engine);
+
+        // --- Google: full anti-detection search flow ---
+        if (isGoogle && !handle.isDaemon) {
+          // Optional warmup: visit a random site first
+          if (opts.warmup) {
+            spinner.text = 'Warming up browser...';
+            await warmup(handle.page);
+          }
+
+          // Simulate human search: homepage → type → enter
+          spinner.text = 'Navigating to Google...';
+          const success = await googleExtractor.humanSearch(handle.page, query);
+
+          if (!success) {
+            // Fallback: direct URL navigation
+            spinner.text = 'Fallback: direct navigation...';
+            await navigate(handle, url, { retries: parseInt(opts.retries) });
+          }
+
+          await waitForReady(handle.page, { timeout: 5000 });
+          await randomDelay(500, 1200);
+          await humanScroll(handle.page, { scrolls: 1 });
+
+          // Check for block
+          const currentUrl = handle.page.url();
+          if (googleExtractor.isBlocked(currentUrl)) {
+            spinner.stop();
+            log.warn('Google detected automation and blocked the request');
+            log.dim('  Try: --proxy <proxy> or --warmup flag');
+            log.dim('  Or use a different engine: stealth search duckduckgo "..."');
+
+            if (opts.format === 'json') {
+              console.log(formatOutput({
+                engine, query, url: currentUrl,
+                blocked: true, results: [], count: 0,
+                timestamp: new Date().toISOString(),
+              }, 'json'));
+            }
+            return;
+          }
+        }
+        // --- Other engines: direct navigation ---
+        else {
+          spinner.text = `Navigating to ${engine}...`;
+          await navigate(handle, url, {
+            humanize: opts.humanize,
+            retries: parseInt(opts.retries),
+          });
+
+          if (!handle.isDaemon) {
+            await waitForReady(handle.page, { timeout: 4000 });
+          }
+        }
+
+        spinner.stop();
+
+        const currentUrl = await getUrl(handle);
+
+        // --- Output ---
+        if (opts.format === 'snapshot') {
+          const snapshot = await getSnapshot(handle);
+          console.log(snapshot);
+        } else if (opts.format === 'json') {
+          let results = [];
+          let alsoAsk = [];
+
+          if (!handle.isDaemon) {
+            results = await extractor.extractResults(handle.page, parseInt(opts.num));
+
+            // Google "People also ask"
+            if (isGoogle && opts.alsoAsk) {
+              alsoAsk = await googleExtractor.extractPeopleAlsoAsk(handle.page);
+            }
+          } else {
+            const text = await getTextContent(handle);
+            results = [{ title: 'Raw text (daemon mode)', content: text.slice(0, 5000) }];
+          }
+
+          const output = {
+            engine,
+            query,
+            url: currentUrl,
+            results,
+            count: results.length,
+            timestamp: new Date().toISOString(),
+          };
+
+          if (alsoAsk.length > 0) {
+            output.peopleAlsoAsk = alsoAsk;
+          }
+
+          console.log(formatOutput(output, 'json'));
+        } else {
+          const text = await getTextContent(handle);
+          console.log(text);
+        }
+
+        log.success(`Search complete: ${currentUrl}`);
+      } catch (err) {
+        spinner.stop();
+        log.error(`Search failed: ${err.message}`);
+        process.exit(1);
+      } finally {
+        if (handle) await closeBrowser(handle);
+      }
+    });
+}

package/src/commands/serve.js

@@ -0,0 +1,240 @@
+/**
+ * stealth serve - Start an HTTP API server for external integrations
+ *
+ * Exposes stealth-cli capabilities as a REST API, compatible with
+ * AI agents and other tools.
+ */
+
+import http from 'http';
+import { launchOptions } from 'camoufox-js';
+import { firefox } from 'playwright-core';
+import os from 'os';
+import { log } from '../output.js';
+
+export function registerServe(program) {
+  program
+    .command('serve')
+    .description('Start HTTP API server for AI agents and external tools')
+    .option('-p, --port <port>', 'Port number', '9377')
+    .option('--host <host>', 'Host to bind to', '127.0.0.1')
+    .option('--proxy <proxy>', 'Default proxy for all requests')
+    .option('--no-headless', 'Show browser window')
+    .action(async (opts) => {
+      const port = parseInt(opts.port);
+      const host = opts.host;
+
+      log.info('Starting stealth API server...');
+
+      // Launch browser
+      const hostOS = os.platform() === 'darwin' ? 'macos' : os.platform() === 'win32' ? 'windows' : 'linux';
+      const options = await launchOptions({
+        headless: opts.headless,
+        os: hostOS,
+        humanize: true,
+        enable_cache: true,
+      });
+      const browser = await firefox.launch(options);
+
+      // Page pool
+      const pages = new Map(); // id → { page, context, lastUsed }
+      let idCounter = 0;
+
+      async function createPage() {
+        const context = await browser.newContext({
+          viewport: { width: 1280, height: 720 },
+          locale: 'en-US',
+          timezoneId: 'America/Los_Angeles',
+        });
+        const page = await context.newPage();
+        const id = `tab-${++idCounter}`;
+        pages.set(id, { page, context, lastUsed: Date.now() });
+        return { id, page, context };
+      }
+
+      function getPage(id) {
+        const entry = pages.get(id);
+        if (!entry) return null;
+        entry.lastUsed = Date.now();
+        return entry;
+      }
+
+      // Parse JSON body
+      function parseBody(req) {
+        return new Promise((resolve) => {
+          let body = '';
+          req.on('data', (c) => { body += c; });
+          req.on('end', () => {
+            try { resolve(body ? JSON.parse(body) : {}); }
+            catch { resolve({}); }
+          });
+        });
+      }
+
+      // JSON response helper
+      function json(res, data, status = 200) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+      }
+
+      const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url, `http://${host}:${port}`);
+        const route = url.pathname;
+        const method = req.method;
+
+        try {
+          const body = method === 'POST' ? await parseBody(req) : {};
+          const query = Object.fromEntries(url.searchParams);
+
+          // --- Health ---
+          if (route === '/health') {
+            return json(res, { ok: true, engine: 'camoufox', pages: pages.size });
+          }
+
+          // --- Create tab ---
+          if (route === '/tabs' && method === 'POST') {
+            const { url: targetUrl } = body;
+            const { id, page } = await createPage();
+            if (targetUrl) {
+              await page.goto(targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+            }
+            return json(res, { ok: true, id, url: page.url() });
+          }
+
+          // --- List tabs ---
+          if (route === '/tabs' && method === 'GET') {
+            const tabs = [];
+            for (const [id, entry] of pages) {
+              tabs.push({ id, url: entry.page.url(), title: await entry.page.title().catch(() => '') });
+            }
+            return json(res, { tabs });
+          }
+
+          // Tab-specific routes
+          const tabMatch = route.match(/^\/tabs\/([^/]+)\/(.+)$/);
+          if (tabMatch) {
+            const [, tabId, action] = tabMatch;
+            const entry = getPage(tabId);
+            if (!entry) return json(res, { error: 'Tab not found' }, 404);
+            const { page } = entry;
+
+            switch (action) {
+              case 'navigate': {
+                const { url: navUrl } = body;
+                await page.goto(navUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+                return json(res, { ok: true, url: page.url() });
+              }
+
+              case 'snapshot': {
+                const snapshot = await page.locator('body').ariaSnapshot({ timeout: 8000 }).catch(() => '');
+                return json(res, { ok: true, snapshot, url: page.url() });
+              }
+
+              case 'text': {
+                const text = await page.evaluate(() => {
+                  const c = document.body.cloneNode(true);
+                  c.querySelectorAll('script,style,noscript').forEach((e) => e.remove());
+                  return c.innerText || '';
+                });
+                return json(res, { ok: true, text, url: page.url() });
+              }
+
+              case 'screenshot': {
+                const buffer = await page.screenshot({ type: 'png' });
+                return json(res, { ok: true, data: buffer.toString('base64'), mimeType: 'image/png' });
+              }
+
+              case 'click': {
+                const { selector } = body;
+                await page.click(selector, { timeout: 5000 });
+                return json(res, { ok: true, url: page.url() });
+              }
+
+              case 'type': {
+                const { selector, text } = body;
+                await page.fill(selector, text);
+                return json(res, { ok: true });
+              }
+
+              case 'evaluate': {
+                const { expression } = body;
+                const result = await page.evaluate(expression);
+                return json(res, { ok: true, result });
+              }
+
+              case 'close': {
+                await entry.context.close().catch(() => {});
+                pages.delete(tabId);
+                return json(res, { ok: true });
+              }
+
+              default:
+                return json(res, { error: `Unknown action: ${action}` }, 400);
+            }
+          }
+
+          // --- Close tab by DELETE ---
+          const deleteMatch = route.match(/^\/tabs\/([^/]+)$/);
+          if (deleteMatch && method === 'DELETE') {
+            const entry = getPage(deleteMatch[1]);
+            if (entry) {
+              await entry.context.close().catch(() => {});
+              pages.delete(deleteMatch[1]);
+            }
+            return json(res, { ok: true });
+          }
+
+          // --- Shutdown ---
+          if (route === '/shutdown' && method === 'POST') {
+            json(res, { ok: true, message: 'Shutting down' });
+            setTimeout(async () => {
+              for (const [, e] of pages) await e.context.close().catch(() => {});
+              await browser.close().catch(() => {});
+              process.exit(0);
+            }, 200);
+            return;
+          }
+
+          json(res, { error: 'Not found' }, 404);
+        } catch (err) {
+          json(res, { error: err.message }, 500);
+        }
+      });
+
+      // Cleanup stale tabs every minute
+      setInterval(() => {
+        const now = Date.now();
+        for (const [id, entry] of pages) {
+          if (now - entry.lastUsed > 10 * 60 * 1000) {
+            entry.context.close().catch(() => {});
+            pages.delete(id);
+          }
+        }
+      }, 60000);
+
+      server.listen(port, host, () => {
+        log.success(`Stealth API server running on http://${host}:${port}`);
+        log.dim('  Endpoints:');
+        log.dim('    GET  /health                    — Server status');
+        log.dim('    POST /tabs                      — Create tab { url }');
+        log.dim('    GET  /tabs                      — List tabs');
+        log.dim('    POST /tabs/:id/navigate         — Navigate { url }');
+        log.dim('    GET  /tabs/:id/snapshot          — Accessibility snapshot');
+        log.dim('    GET  /tabs/:id/text              — Page text');
+        log.dim('    GET  /tabs/:id/screenshot        — Screenshot (base64)');
+        log.dim('    POST /tabs/:id/click             — Click { selector }');
+        log.dim('    POST /tabs/:id/type              — Type { selector, text }');
+        log.dim('    POST /tabs/:id/evaluate          — Eval JS { expression }');
+        log.dim('    DELETE /tabs/:id                 — Close tab');
+        log.dim('    POST /shutdown                   — Stop server');
+      });
+
+      // Graceful shutdown
+      process.on('SIGINT', async () => {
+        log.info('Shutting down...');
+        for (const [, e] of pages) await e.context.close().catch(() => {});
+        await browser.close().catch(() => {});
+        server.close();
+        process.exit(0);
+      });
+    });
+}

package/src/config.js

@@ -0,0 +1,123 @@
+/**
+ * Global configuration — ~/.stealth/config.json
+ *
+ * Provides defaults for all commands so you don't have to repeat flags.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.stealth');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  headless: true,
+  locale: 'en-US',
+  timezone: 'America/Los_Angeles',
+  timeout: 30000,
+  retries: 2,
+  humanize: false,
+  delay: 1000,
+  format: 'text',
+  proxy: null,
+  viewportWidth: 1280,
+  viewportHeight: 720,
+};
+
+const VALID_KEYS = Object.keys(DEFAULTS);
+
+/**
+ * Load config (merges file with defaults)
+ */
+export function loadConfig() {
+  const fileConfig = readConfigFile();
+  return { ...DEFAULTS, ...fileConfig };
+}
+
+/**
+ * Read raw config file
+ */
+function readConfigFile() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write config file
+ */
+function writeConfigFile(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get a config value
+ */
+export function getConfigValue(key) {
+  const config = loadConfig();
+  return config[key];
+}
+
+/**
+ * Set a config value
+ */
+export function setConfigValue(key, value) {
+  if (!VALID_KEYS.includes(key)) {
+    throw new Error(`Unknown config key: "${key}". Valid keys: ${VALID_KEYS.join(', ')}`);
+  }
+
+  const config = readConfigFile();
+
+  // Type coercion
+  const defaultVal = DEFAULTS[key];
+  if (typeof defaultVal === 'boolean') {
+    value = value === 'true' || value === true;
+  } else if (typeof defaultVal === 'number') {
+    value = Number(value);
+    if (isNaN(value)) throw new Error(`Invalid number for ${key}`);
+  } else if (value === 'null' || value === '') {
+    value = null;
+  }
+
+  config[key] = value;
+  writeConfigFile(config);
+  return value;
+}
+
+/**
+ * Delete a config value (reset to default)
+ */
+export function deleteConfigValue(key) {
+  const config = readConfigFile();
+  delete config[key];
+  writeConfigFile(config);
+}
+
+/**
+ * List all config values
+ */
+export function listConfig() {
+  const config = loadConfig();
+  const fileConfig = readConfigFile();
+
+  return VALID_KEYS.map((key) => ({
+    key,
+    value: config[key],
+    source: key in fileConfig ? 'user' : 'default',
+    default: DEFAULTS[key],
+  }));
+}
+
+/**
+ * Reset all config to defaults
+ */
+export function resetConfig() {
+  writeConfigFile({});
+}
+
+export { CONFIG_FILE, VALID_KEYS, DEFAULTS };

package/src/cookies.js

@@ -0,0 +1,67 @@
+/**
+ * Cookie file parser - supports Netscape cookie format
+ * Inspired by camofox-browser (MIT License)
+ */
+
+import { readFileSync } from 'fs';
+
+/**
+ * Parse a Netscape-format cookie file
+ *
+ * Format: domain\tincludeSubdomains\tpath\tsecure\texpires\tname\tvalue
+ *
+ * @param {string} filePath - Path to cookie file
+ * @param {string} [filterDomain] - Only return cookies matching this domain
+ * @returns {Array} Playwright-format cookies
+ */
+export function parseCookieFile(filePath, filterDomain) {
+  const content = readFileSync(filePath, 'utf-8');
+  const cookies = [];
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+
+    // Skip comments and empty lines
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const parts = trimmed.split('\t');
+    if (parts.length < 7) continue;
+
+    const [domain, , path, secure, expires, name, value] = parts;
+
+    // Filter by domain if specified
+    if (filterDomain) {
+      const cleanDomain = domain.startsWith('.') ? domain.slice(1) : domain;
+      if (!filterDomain.includes(cleanDomain) && !cleanDomain.includes(filterDomain)) {
+        continue;
+      }
+    }
+
+    cookies.push({
+      name,
+      value,
+      domain,
+      path: path || '/',
+      expires: parseInt(expires) || -1,
+      httpOnly: false,
+      secure: secure.toLowerCase() === 'true',
+      sameSite: 'Lax',
+    });
+  }
+
+  return cookies;
+}
+
+/**
+ * Load cookies from file and inject into browser context
+ */
+export async function loadCookies(context, filePath, filterDomain) {
+  const cookies = parseCookieFile(filePath, filterDomain);
+
+  if (cookies.length === 0) {
+    return { count: 0, message: 'No cookies found' };
+  }
+
+  await context.addCookies(cookies);
+  return { count: cookies.length, message: `Loaded ${cookies.length} cookies` };
+}

package/src/daemon-entry.js

@@ -0,0 +1,19 @@
+/**
+ * Daemon entry point — spawned as a detached child process
+ */
+
+import { startDaemon } from './daemon.js';
+
+const idleTimeout = parseInt(process.env.STEALTH_IDLE_TIMEOUT) || 5 * 60 * 1000;
+
+try {
+  await startDaemon({ idleTimeout, verbose: false });
+
+  // Signal parent that we're ready
+  if (process.send) {
+    process.send('ready');
+  }
+} catch (err) {
+  console.error(`Daemon failed to start: ${err.message}`);
+  process.exit(1);
+}