veil-browser 0.1.0

package/dist/captcha.js

@@ -0,0 +1,203 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+const CONFIG_FILE = join(homedir(), '.veil', 'config.json');
+async function loadConfig() {
+    try {
+        const raw = await fs.readFile(CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export class VeilError extends Error {
+    code;
+    screenshotPath;
+    suggestion;
+    constructor(code, message, suggestion) {
+        super(message);
+        this.code = code;
+        this.suggestion = suggestion;
+        this.name = 'VeilError';
+    }
+}
+// Detect CAPTCHA on current page
+export async function detectCaptcha(page) {
+    return await page.evaluate(() => {
+        if (document.querySelector('iframe[src*="challenges.cloudflare.com"]'))
+            return 'turnstile';
+        if (document.querySelector('iframe[src*="recaptcha"]') || document.querySelector('.g-recaptcha'))
+            return 'recaptcha';
+        if (document.querySelector('iframe[src*="hcaptcha"]') || document.querySelector('.h-captcha'))
+            return 'hcaptcha';
+        if (document.querySelector('img[alt*="captcha" i]') || document.querySelector('input[name*="captcha" i]'))
+            return 'image';
+        return null;
+    });
+}
+// Auto-solve via 2captcha API
+async function solveWith2Captcha(apiKey, type, page) {
+    const siteKey = await page.evaluate((t) => {
+        if (t === 'recaptcha') {
+            const el = document.querySelector('.g-recaptcha');
+            return el?.getAttribute('data-sitekey') ?? null;
+        }
+        if (t === 'hcaptcha') {
+            const el = document.querySelector('.h-captcha');
+            return el?.getAttribute('data-sitekey') ?? null;
+        }
+        if (t === 'turnstile') {
+            const el = document.querySelector('[data-sitekey]');
+            return el?.getAttribute('data-sitekey') ?? null;
+        }
+        return null;
+    }, type);
+    if (!siteKey)
+        return null;
+    const pageUrl = page.url();
+    const taskType = type === 'recaptcha' ? 'RecaptchaV2TaskProxyless'
+        : type === 'hcaptcha' ? 'HCaptchaTaskProxyless'
+            : 'TurnstileTaskProxyless';
+    const spinner = ora(`Solving ${type} CAPTCHA via 2captcha...`).start();
+    try {
+        // Submit task
+        const submitRes = await fetch('https://api.2captcha.com/createTask', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                clientKey: apiKey,
+                task: { type: taskType, websiteURL: pageUrl, websiteKey: siteKey },
+            }),
+        });
+        const submitData = await submitRes.json();
+        if (submitData.errorId > 0)
+            throw new Error(submitData.errorDescription);
+        const taskId = submitData.taskId;
+        // Poll for result (up to 120s)
+        for (let i = 0; i < 24; i++) {
+            await new Promise((r) => setTimeout(r, 5000));
+            const pollRes = await fetch('https://api.2captcha.com/getTaskResult', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ clientKey: apiKey, taskId }),
+            });
+            const pollData = await pollRes.json();
+            if (pollData.status === 'ready') {
+                spinner.succeed(chalk.green('✅ CAPTCHA solved!'));
+                return pollData.solution?.gRecaptchaResponse ?? pollData.solution?.token ?? null;
+            }
+        }
+        spinner.fail('CAPTCHA solve timed out');
+        return null;
+    }
+    catch (err) {
+        spinner.fail(`CAPTCHA solve failed: ${err.message}`);
+        return null;
+    }
+}
+// Inject solved token into page
+async function injectCaptchaToken(page, type, token) {
+    if (type === 'recaptcha') {
+        await page.evaluate((t) => {
+            const el = document.querySelector('#g-recaptcha-response');
+            if (el)
+                el.value = t;
+            // @ts-ignore
+            if (window.___grecaptcha_cfg) {
+                // Trigger callback
+                const callbacks = Object.values(window.___grecaptcha_cfg.clients ?? {});
+                // @ts-ignore
+                callbacks.forEach((c) => c?.['']?.['']?.callback?.(t));
+            }
+        }, token);
+    }
+    else if (type === 'hcaptcha') {
+        await page.evaluate((t) => {
+            const el = document.querySelector('[name="h-captcha-response"]');
+            if (el)
+                el.value = t;
+        }, token);
+    }
+    else if (type === 'turnstile') {
+        await page.evaluate((t) => {
+            const el = document.querySelector('[name="cf-turnstile-response"]');
+            if (el)
+                el.value = t;
+        }, token);
+    }
+}
+// Main CAPTCHA handler — call this before/after any page action
+export async function handleCaptcha(page, screenshotDir) {
+    const captchaType = await detectCaptcha(page);
+    if (!captchaType)
+        return false;
+    console.log(chalk.yellow(`\n⚠️  CAPTCHA detected: ${chalk.bold(captchaType)}`));
+    const config = await loadConfig();
+    // Try auto-solve
+    if (config.captcha?.apiKey && config.captcha.provider === '2captcha') {
+        const token = await solveWith2Captcha(config.captcha.apiKey, captchaType, page);
+        if (token) {
+            await injectCaptchaToken(page, captchaType, token);
+            await page.waitForTimeout(1500);
+            return true;
+        }
+    }
+    // Human fallback
+    console.log(chalk.cyan('\n🧑 Human needed! Opening visible browser for CAPTCHA solve...'));
+    console.log(chalk.gray('  Solve the CAPTCHA in the browser window. Veil will continue automatically.\n'));
+    // Screenshot the failure state
+    if (screenshotDir) {
+        const path = join(screenshotDir, `captcha-${Date.now()}.png`);
+        await page.screenshot({ path }).catch(() => { });
+        console.log(chalk.gray(`  Screenshot: ${path}`));
+    }
+    // Wait for human to solve (up to 5 min)
+    const startUrl = page.url();
+    await new Promise((resolve) => {
+        const check = setInterval(async () => {
+            const captchaStillThere = await detectCaptcha(page).catch(() => null);
+            if (!captchaStillThere || page.url() !== startUrl) {
+                clearInterval(check);
+                resolve();
+            }
+        }, 2000);
+        setTimeout(() => { clearInterval(check); resolve(); }, 300000);
+    });
+    console.log(chalk.green('✅ CAPTCHA cleared, resuming...\n'));
+    return true;
+}
+// Retry wrapper with backoff
+export async function withRetry(fn, opts = {}) {
+    const { attempts = 3, delay = 2000, label = 'action' } = opts;
+    let lastError = null;
+    for (let i = 1; i <= attempts; i++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            if (i < attempts) {
+                const wait = delay * i;
+                console.log(chalk.yellow(`  ⟳ Retry ${i}/${attempts} for "${label}" in ${wait}ms...`));
+                await new Promise((r) => setTimeout(r, wait));
+            }
+        }
+    }
+    throw lastError;
+}
+// Screenshot on error helper
+export async function screenshotOnError(page, label) {
+    const dir = join(homedir(), '.veil', 'errors');
+    await fs.mkdir(dir, { recursive: true });
+    const path = join(dir, `error-${label}-${Date.now()}.png`);
+    try {
+        await page.screenshot({ path });
+        return path;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/act.d.ts

@@ -0,0 +1,7 @@
+export declare function actCommand(instruction: string, opts: {
+    headed?: boolean;
+    platform?: string;
+    url?: string;
+    json?: boolean;
+    verbose?: boolean;
+}): Promise<void>;

package/dist/commands/act.js

@@ -0,0 +1,107 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getBrowser, closeBrowser, humanDelay } from '../browser.js';
+import { aiAct } from '../ai.js';
+// Fallback: simple heuristic actions (no LLM needed)
+async function performFallbackAction(page, instruction) {
+    const lower = instruction.toLowerCase();
+    const clickMatch = lower.match(/^click\s+(?:on\s+)?["']?(.+?)["']?\s*$/);
+    if (clickMatch) {
+        const target = clickMatch[1];
+        await page.getByRole('button', { name: new RegExp(target, 'i') }).first().click().catch(async () => {
+            await page.getByText(new RegExp(target, 'i')).first().click();
+        });
+        await humanDelay();
+        return `Clicked: ${target}`;
+    }
+    const typeMatch = lower.match(/^type\s+["'](.+?)["']\s+(?:in|into)\s+["']?(.+?)["']?\s*$/);
+    if (typeMatch) {
+        const [, text, field] = typeMatch;
+        await page.getByRole('textbox', { name: new RegExp(field, 'i') }).fill(text);
+        await humanDelay();
+        return `Typed "${text}" into ${field}`;
+    }
+    const tweetMatch = instruction.match(/^post\s+(?:tweet|on twitter|on x)[:\s]+["']?(.+?)["']?\s*$/i);
+    if (tweetMatch) {
+        const tweetText = tweetMatch[1];
+        await page.goto('https://x.com/compose/post', { waitUntil: 'domcontentloaded' });
+        await humanDelay(1000, 2000);
+        const editor = page.locator('[data-testid="tweetTextarea_0"]');
+        await editor.click();
+        await humanDelay(300, 600);
+        await editor.fill(tweetText);
+        await humanDelay(500, 1000);
+        await page.locator('[data-testid="tweetButtonInline"]').click();
+        await humanDelay(1000, 2000);
+        return `Posted tweet: "${tweetText}"`;
+    }
+    if (lower.includes('like') && (lower.includes('tweet') || lower.includes('post'))) {
+        await page.locator('[data-testid="like"]').first().click();
+        await humanDelay();
+        return 'Liked the post';
+    }
+    if (lower.includes('scroll down')) {
+        await page.evaluate(() => window.scrollBy(0, 600));
+        await humanDelay();
+        return 'Scrolled down';
+    }
+    if (lower.includes('scroll up')) {
+        await page.evaluate(() => window.scrollBy(0, -600));
+        await humanDelay();
+        return 'Scrolled up';
+    }
+    if (lower.includes('press enter') || lower.includes('submit')) {
+        await page.keyboard.press('Enter');
+        await humanDelay();
+        return 'Pressed Enter';
+    }
+    const gotoMatch = instruction.match(/^(?:go to|navigate to|open)\s+(https?:\/\/\S+)/i);
+    if (gotoMatch) {
+        await page.goto(gotoMatch[1], { waitUntil: 'domcontentloaded' });
+        await humanDelay(800, 1500);
+        return `Navigated to ${gotoMatch[1]}`;
+    }
+    throw new Error(`Could not parse instruction without AI: "${instruction}". Set an LLM API key for smart act.`);
+}
+export async function actCommand(instruction, opts) {
+    const { page } = await getBrowser({ headed: opts.headed, platform: opts.platform });
+    try {
+        if (opts.url) {
+            const spinner = ora({ text: `Loading ${opts.url}...`, color: 'cyan' }).start();
+            await page.goto(opts.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+            await humanDelay(800, 1500);
+            spinner.succeed(chalk.gray(`Loaded ${opts.url}`));
+        }
+        // Try AI-powered act first
+        try {
+            const result = await aiAct(page, instruction, { verbose: opts.verbose });
+            if (opts.json) {
+                console.log(JSON.stringify({ success: result.success, action: instruction, steps: result.steps }));
+            }
+            if (!result.success)
+                process.exit(1);
+        }
+        catch (aiErr) {
+            // If AI not configured, fall back to heuristics
+            if (aiErr.message.includes('No LLM configured')) {
+                console.log(chalk.yellow('⚠️  No LLM configured, using fallback heuristics...'));
+                const result = await performFallbackAction(page, instruction);
+                console.log(chalk.green(`✅ ${result}`));
+                if (opts.json)
+                    console.log(JSON.stringify({ success: true, action: instruction, result }));
+            }
+            else {
+                throw aiErr;
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`❌ Action failed: ${err.message}`));
+        if (opts.json)
+            console.log(JSON.stringify({ success: false, action: instruction, error: err.message }));
+        process.exit(1);
+    }
+    finally {
+        await closeBrowser(opts.platform);
+    }
+}

package/dist/commands/extract.d.ts

@@ -0,0 +1,6 @@
+export declare function extractCommand(query: string, opts: {
+    headed?: boolean;
+    platform?: string;
+    url?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/extract.js

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getBrowser, closeBrowser, humanDelay } from '../browser.js';
+export async function extractCommand(query, opts) {
+    const spinner = ora({ text: `Extracting: ${query}`, color: 'cyan' }).start();
+    const { page } = await getBrowser({ headed: opts.headed, platform: opts.platform });
+    try {
+        if (opts.url) {
+            await page.goto(opts.url, { waitUntil: 'domcontentloaded' });
+            await humanDelay(800, 1500);
+        }
+        const lower = query.toLowerCase();
+        let result;
+        // Twitter/X feed
+        if (lower.includes('tweet') || lower.includes('feed') || lower.includes('timeline')) {
+            const tweets = await page.locator('[data-testid="tweet"]').all();
+            const data = await Promise.all(tweets.slice(0, 20).map(async (t) => {
+                const text = await t.locator('[data-testid="tweetText"]').textContent().catch(() => '');
+                const author = await t.locator('[data-testid="User-Name"]').textContent().catch(() => '');
+                return { author: author?.trim(), text: text?.trim() };
+            }));
+            result = data.filter((d) => d.text);
+        }
+        // Links
+        else if (lower.includes('link') || lower.includes('url')) {
+            const links = await page.locator('a[href]').all();
+            result = await Promise.all(links.slice(0, 50).map(async (l) => ({
+                text: (await l.textContent())?.trim(),
+                href: await l.getAttribute('href'),
+            })));
+        }
+        // Page text
+        else if (lower.includes('text') || lower.includes('content')) {
+            result = await page.evaluate(() => document.body.innerText.slice(0, 5000));
+        }
+        // Title
+        else if (lower.includes('title')) {
+            result = await page.title();
+        }
+        // Default: page metadata
+        else {
+            result = {
+                title: await page.title(),
+                url: page.url(),
+                text: await page.evaluate(() => document.body.innerText.slice(0, 2000)),
+            };
+        }
+        spinner.succeed(chalk.green('✅ Extracted'));
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, query, result }, null, 2));
+        }
+        else {
+            console.log(chalk.cyan('\nResult:'));
+            console.log(JSON.stringify(result, null, 2));
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`❌ Extract failed: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        await closeBrowser(opts.platform);
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(platform: string): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getBrowser, closeBrowser } from '../browser.js';
+import { loadSession } from '../session.js';
+const PLATFORM_LOGIN_URLS = {
+    twitter: 'https://x.com/login',
+    x: 'https://x.com/login',
+    reddit: 'https://www.reddit.com/login',
+    linkedin: 'https://www.linkedin.com/login',
+    github: 'https://github.com/login',
+    instagram: 'https://www.instagram.com/accounts/login',
+};
+const PLATFORM_SUCCESS_PATTERNS = {
+    twitter: ['x.com/home', 'twitter.com/home'],
+    x: ['x.com/home', 'twitter.com/home'],
+    reddit: ['reddit.com/?'],
+    linkedin: ['linkedin.com/feed'],
+    github: ['github.com', '!/login', '!/session'],
+    instagram: ['instagram.com', '!/accounts/login'],
+};
+function isLoggedIn(url, platform) {
+    const patterns = PLATFORM_SUCCESS_PATTERNS[platform.toLowerCase()] ?? [];
+    return patterns.some((p) => {
+        if (p.startsWith('!'))
+            return !url.includes(p.slice(1));
+        return url.includes(p);
+    });
+}
+export async function loginCommand(platform) {
+    const p = platform.toLowerCase();
+    const loginUrl = PLATFORM_LOGIN_URLS[p] ?? `https://${p}.com/login`;
+    const existing = await loadSession(p);
+    if (existing) {
+        console.log(chalk.yellow(`⚠️  Session for ${chalk.bold(platform)} already exists. Use ${chalk.bold('veil logout ' + platform)} to clear it first.`));
+        return;
+    }
+    console.log(chalk.cyan(`\n🔐 Opening browser for ${chalk.bold(platform)} login...`));
+    console.log(chalk.gray('   Complete the login in the browser window. Veil will detect when you\'re done.\n'));
+    const { browser, context, page } = await getBrowser({ headed: true, platform: p });
+    await page.goto(loginUrl);
+    const spinner = ora({ text: 'Waiting for login...', color: 'cyan' }).start();
+    await new Promise((resolve) => {
+        const check = async () => {
+            try {
+                const url = page.url();
+                if (isLoggedIn(url, p)) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }
+            catch { }
+        };
+        const interval = setInterval(check, 1000);
+        // Also handle manual close
+        browser.on('disconnected', () => {
+            clearInterval(interval);
+            resolve();
+        });
+    });
+    spinner.succeed(chalk.green(`✅ Logged in to ${chalk.bold(platform)}! Saving session...`));
+    await closeBrowser(p);
+    console.log(chalk.green(`\n🎉 Session saved! You can now use ${chalk.bold('veil')} with ${chalk.bold(platform)} in headless mode.\n`));
+}

package/dist/commands/navigate.d.ts

@@ -0,0 +1,5 @@
+export declare function navigateCommand(url: string, opts: {
+    headed?: boolean;
+    platform?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/navigate.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getBrowser, closeBrowser, humanDelay } from '../browser.js';
+export async function navigateCommand(url, opts) {
+    const spinner = ora({ text: `Navigating to ${url}...`, color: 'cyan' }).start();
+    const { page } = await getBrowser({ headed: opts.headed, platform: opts.platform });
+    try {
+        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await humanDelay(500, 1200);
+        const title = await page.title();
+        const finalUrl = page.url();
+        spinner.succeed(chalk.green(`Navigated to: ${chalk.bold(title)}`));
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, url: finalUrl, title }));
+        }
+        else {
+            console.log(chalk.gray(`  URL: ${finalUrl}`));
+        }
+    }
+    finally {
+        await closeBrowser(opts.platform);
+    }
+}

package/dist/commands/screenshot.d.ts

@@ -0,0 +1,7 @@
+export declare function screenshotCommand(opts: {
+    headed?: boolean;
+    platform?: string;
+    url?: string;
+    output?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/screenshot.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getBrowser, closeBrowser, humanDelay } from '../browser.js';
+import { join } from 'path';
+export async function screenshotCommand(opts) {
+    const outPath = opts.output ?? join(process.cwd(), `screenshot-${Date.now()}.png`);
+    const spinner = ora({ text: 'Taking screenshot...', color: 'cyan' }).start();
+    const { page } = await getBrowser({ headed: opts.headed, platform: opts.platform });
+    try {
+        if (opts.url) {
+            await page.goto(opts.url, { waitUntil: 'domcontentloaded' });
+            await humanDelay(800, 1500);
+        }
+        await page.screenshot({ path: outPath, fullPage: false });
+        spinner.succeed(chalk.green(`📸 Screenshot saved: ${chalk.bold(outPath)}`));
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, path: outPath }));
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`❌ Screenshot failed: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        await closeBrowser(opts.platform);
+    }
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,13 @@
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    source: string;
+}
+export declare function searchCommand(query: string, opts: {
+    engine?: string;
+    platform?: string;
+    headed?: boolean;
+    json?: boolean;
+    limit?: string;
+}): Promise<void>;