veil-browser 0.2.0 → 0.3.0

package/dist/browser.d.ts

@@ -8,5 +8,5 @@ export declare function ensureBrowser(opts?: {
     page: Page;
 }>;
 export declare function getPage(): Promise<Page | null>;
-export declare function closeBrowser(platform?: string): Promise<void>;
+export declare function closeBrowser(_platform?: string): Promise<void>;
 export declare function humanDelay(min?: number, max?: number): Promise<void>;

package/dist/browser.js

@@ -3,90 +3,52 @@ import { promises as fs } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import { loadSession } from './session.js';
-const STATE_FILE = join(homedir(), '.veil', 'browser.json');
-// Singleton references (in-process)
+const VEIL_DIR = join(homedir(), '.veil');
+const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36';
 let _browser = null;
 let _context = null;
 let _page = null;
-let _platform = 'default';
 export async function ensureBrowser(opts = {}) {
-    const platform = opts.platform ?? 'default';
-    if (_browser && _context && _page && !_page.isClosed()) {
+    if (_browser?.isConnected() && _page && !_page.isClosed()) {
         return { browser: _browser, context: _context, page: _page };
     }
-    // Launch browser with stealth args
     const browser = await chromium.launch({
         headless: !opts.headed,
-        args: [
-            '--disable-blink-features=AutomationControlled',
-            '--no-sandbox',
-            '--disable-setuid-sandbox',
-            '--disable-infobars',
-            '--disable-dev-shm-usage',
-            '--disable-accelerated-2d-canvas',
-            '--no-first-run',
-            '--no-zygote',
-            '--disable-gpu',
-            '--window-size=1280,800',
-            '--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
-        ],
+        args: ['--disable-blink-features=AutomationControlled', '--no-sandbox', '--disable-setuid-sandbox', '--window-size=1280,800'],
     });
-    // Create context with realistic settings
     const context = await browser.newContext({
         viewport: { width: 1280, height: 800 },
-        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+        userAgent: UA,
         locale: 'en-US',
         timezoneId: 'America/New_York',
-        permissions: ['notifications'],
-        extraHTTPHeaders: {
-            'Accept-Language': 'en-US,en;q=0.9',
-        },
+        extraHTTPHeaders: { 'Accept-Language': 'en-US,en;q=0.9' },
     });
-    // Inject stealth scripts
     await context.addInitScript(() => {
         Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
         window.chrome = { runtime: {} };
-        Object.defineProperty(navigator, 'plugins', {
-            get: () => [1, 2, 3, 4, 5],
-        });
-        Object.defineProperty(navigator, 'languages', {
-            get: () => ['en-US', 'en'],
-        });
+        Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
+        Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
     });
-    // Restore session cookies if available
-    const session = await loadSession(platform);
-    if (session?.cookies && session.cookies.length > 0) {
-        await context.addCookies(session.cookies);
-    }
+    const session = await loadSession(opts.platform ?? 'default').catch(() => null);
+    if (session?.cookies?.length)
+        await context.addCookies(session.cookies).catch(() => { });
     const page = await context.newPage();
     _browser = browser;
     _context = context;
     _page = page;
-    _platform = platform;
-    // Save state for reference
-    await fs.mkdir(join(homedir(), '.veil'), { recursive: true });
-    await fs.writeFile(STATE_FILE, JSON.stringify({
-        platform,
-        pid: process.pid,
-        timestamp: Date.now(),
-    }), 'utf-8').catch(() => { });
+    await fs.mkdir(VEIL_DIR, { recursive: true });
+    process.once('exit', () => { browser.close().catch(() => { }); });
     return { browser, context, page };
 }
 export async function getPage() {
-    if (_page && !_page.isClosed())
-        return _page;
-    return null;
+    return (_page && !_page.isClosed()) ? _page : null;
 }
-export async function closeBrowser(platform) {
-    if (_browser) {
-        await _browser.close().catch(() => { });
-        _browser = null;
-        _context = null;
-        _page = null;
-    }
-    await fs.rm(STATE_FILE).catch(() => { });
+export async function closeBrowser(_platform) {
+    await _browser?.close().catch(() => { });
+    _browser = null;
+    _context = null;
+    _page = null;
 }
-export function humanDelay(min = 500, max = 1200) {
-    const delay = Math.floor(Math.random() * (max - min) + min);
-    return new Promise(r => setTimeout(r, delay));
+export function humanDelay(min = 400, max = 900) {
+    return new Promise(r => setTimeout(r, Math.floor(Math.random() * (max - min) + min)));
 }

package/dist/index.js

@@ -7,7 +7,7 @@ const program = new Command();
 program
     .name('veil')
     .description('🕶️  OpenClaw browser remote — stealth headless browser')
-    .version('0.2.0');
+    .version('0.3.0');
 // ─── Session ──────────────────────────────────────────────────────────────────
 program
     .command('login <platform>')
@@ -351,6 +351,151 @@ program
     const title = await page.title();
     console.log(JSON.stringify({ ok: true, platform, url: page.url(), title }));
 });
+// ─── X / Social Interactions ─────────────────────────────────────────────────
+program
+    .command('like')
+    .description('Like the Nth post on the current page')
+    .option('--nth <n>', 'Which post (0-indexed)', '0')
+    .option('--platform <platform>', 'Platform for session', 'x')
+    .action(async (opts) => {
+    const { ensureBrowser, humanDelay } = await import('./browser.js');
+    const { browser, page } = await ensureBrowser({ platform: opts.platform });
+    try {
+        await page.goto('https://x.com/home', { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForSelector("article[data-testid='tweet']", { timeout: 20000 });
+        await humanDelay(1000, 1600);
+        await page.locator("[data-testid='like']").nth(parseInt(opts.nth)).click({ force: true });
+        await humanDelay(1000, 1400);
+        const isLiked = await page.locator("[data-testid='unlike']").count() > 0;
+        console.log(JSON.stringify({ ok: true, action: 'like', nth: opts.nth, confirmed: isLiked }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+    finally {
+        await browser.close();
+    }
+});
+program
+    .command('reply <text>')
+    .description('Reply to the Nth post on the current X feed')
+    .option('--nth <n>', 'Which post (0-indexed)', '0')
+    .option('--platform <platform>', 'Platform for session', 'x')
+    .action(async (text, opts) => {
+    const { ensureBrowser, humanDelay } = await import('./browser.js');
+    const { browser, page } = await ensureBrowser({ platform: opts.platform });
+    try {
+        await page.goto('https://x.com/home', { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForSelector("article[data-testid='tweet']", { timeout: 20000 });
+        await humanDelay(1000, 1500);
+        await page.locator("[data-testid='reply']").nth(parseInt(opts.nth)).click({ force: true });
+        await humanDelay(800, 1100);
+        await page.locator("[data-testid='tweetTextarea_0']").first().waitFor({ timeout: 8000 });
+        await page.locator("[data-testid='tweetTextarea_0']").first().click({ force: true });
+        await humanDelay(300, 500);
+        await page.keyboard.type(text, { delay: 38 });
+        await humanDelay(600, 900);
+        await page.locator("[data-testid='tweetButton']").first().click({ force: true });
+        await humanDelay(1800, 2400);
+        console.log(JSON.stringify({ ok: true, action: 'reply', nth: opts.nth, text }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+    finally {
+        await browser.close();
+    }
+});
+program
+    .command('repost')
+    .description('Repost (retweet) the Nth post on the current X feed')
+    .option('--nth <n>', 'Which post (0-indexed)', '0')
+    .option('--platform <platform>', 'Platform for session', 'x')
+    .action(async (opts) => {
+    const { ensureBrowser, humanDelay } = await import('./browser.js');
+    const { browser, page } = await ensureBrowser({ platform: opts.platform });
+    try {
+        await page.goto('https://x.com/home', { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForSelector("article[data-testid='tweet']", { timeout: 20000 });
+        await humanDelay(1000, 1500);
+        await page.locator("[data-testid='retweet']").nth(parseInt(opts.nth)).click({ force: true });
+        await humanDelay(500, 800);
+        await page.locator("[data-testid='retweetConfirm']").first().waitFor({ timeout: 5000 });
+        await page.locator("[data-testid='retweetConfirm']").first().click({ force: true });
+        await humanDelay(1200, 1800);
+        console.log(JSON.stringify({ ok: true, action: 'repost', nth: opts.nth }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+    finally {
+        await browser.close();
+    }
+});
+program
+    .command('quote <text>')
+    .description('Quote the Nth post on the current X feed with your comment')
+    .option('--nth <n>', 'Which post (0-indexed)', '0')
+    .option('--platform <platform>', 'Platform for session', 'x')
+    .action(async (text, opts) => {
+    const { ensureBrowser, humanDelay } = await import('./browser.js');
+    const { browser, page } = await ensureBrowser({ platform: opts.platform });
+    try {
+        await page.goto('https://x.com/home', { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForSelector("article[data-testid='tweet']", { timeout: 20000 });
+        await humanDelay(1000, 1500);
+        // Get tweet URL for the target post
+        const tweetUrls = await page.locator('a[href*="/status/"]').evaluateAll((els) => els.map(el => el.href).filter(h => /\/status\/\d+$/.test(h)));
+        const targetUrl = tweetUrls[parseInt(opts.nth)] ?? tweetUrls[0];
+        if (!targetUrl)
+            throw new Error('Could not find tweet URL for quoting');
+        // Navigate to compose with tweet URL appended
+        const composeUrl = `https://x.com/compose/post?text=${encodeURIComponent(text + '\n\n' + targetUrl)}`;
+        await page.goto(composeUrl, { waitUntil: 'domcontentloaded', timeout: 20000 });
+        await humanDelay(1500, 2000);
+        await page.locator("[data-testid='tweetButtonInline']").first().waitFor({ timeout: 8000 });
+        await page.locator("[data-testid='tweetButtonInline']").first().click({ force: true });
+        await humanDelay(2000, 2500);
+        console.log(JSON.stringify({ ok: true, action: 'quote', nth: opts.nth, text, quotedUrl: targetUrl }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+    finally {
+        await browser.close();
+    }
+});
+program
+    .command('post <text>')
+    .description('Post a tweet on X')
+    .option('--platform <platform>', 'Platform for session', 'x')
+    .action(async (text, opts) => {
+    const { ensureBrowser, humanDelay } = await import('./browser.js');
+    const { browser, page } = await ensureBrowser({ platform: opts.platform });
+    try {
+        await page.goto('https://x.com/home', { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForSelector("[data-testid='primaryColumn']", { timeout: 20000 });
+        await humanDelay(800, 1400);
+        await page.locator("[data-testid='tweetTextarea_0']").first().click({ force: true });
+        await humanDelay(400, 700);
+        await page.keyboard.type(text, { delay: 38 });
+        await humanDelay(600, 1000);
+        await page.locator("[data-testid='tweetButtonInline']").first().click({ force: true });
+        await humanDelay(2000, 2500);
+        console.log(JSON.stringify({ ok: true, action: 'post', text }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+    finally {
+        await browser.close();
+    }
+});
 program
     .command('close')
     .description('Close the current browser session')
@@ -368,7 +513,7 @@ program
     const { isFlareSolverrUp } = await import('./local-captcha.js');
     const sessions = await listSessions();
     const flare = await isFlareSolverrUp();
-    console.log(chalk.cyan('\n🕶️  veil v0.2.0 — OpenClaw Browser Remote\n'));
+    console.log(chalk.cyan('\n🕶️  veil v0.3.0 — OpenClaw Browser Remote\n'));
     console.log(`  Sessions:     ${sessions.length > 0 ? chalk.green(sessions.join(', ')) : chalk.gray('none')}`);
     console.log(`  FlareSolverr: ${flare ? chalk.green('running') : chalk.gray('not running (auto-starts on use)')}`);
     console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veil-browser",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Stealth browser CLI for AI agents — bypass bot detection, persist sessions, local CAPTCHA solving, MCP server",
   "keywords": [
     "browser",

package/dist/ai.js

@@ -1,377 +0,0 @@
-import { humanDelay } from './browser.js';
-import chalk from 'chalk';
-import ora from 'ora';
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-async function loadConfig() {
-    const configFile = join(homedir(), '.veil', 'config.json');
-    try {
-        const raw = await fs.readFile(configFile, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return {};
-    }
-}
-function getLLMConfig(config) {
-    // Priority: config file > env vars > ollama auto-detect
-    if (config.llm?.provider)
-        return config.llm;
-    const openaiKey = process.env.OPENAI_API_KEY;
-    if (openaiKey)
-        return { provider: 'openai', apiKey: openaiKey, model: 'gpt-4o-mini' };
-    const anthropicKey = process.env.ANTHROPIC_API_KEY;
-    if (anthropicKey)
-        return { provider: 'anthropic', apiKey: anthropicKey, model: 'claude-haiku-4-5' };
-    const openrouterKey = process.env.OPENROUTER_API_KEY;
-    if (openrouterKey)
-        return { provider: 'openrouter', apiKey: openrouterKey, model: 'openai/gpt-4o-mini' };
-    // Ollama fallback — no key needed
-    const ollamaUrl = process.env.OLLAMA_URL ?? 'http://localhost:11434';
-    const ollamaModel = process.env.OLLAMA_MODEL ?? 'llava';
-    return { provider: 'ollama', model: ollamaModel, baseUrl: ollamaUrl };
-}
-// Get a compact accessibility snapshot of the page for LLM consumption
-async function getPageSnapshot(page) {
-    const snapshot = await page.evaluate(() => {
-        const elements = [];
-        function processNode(el, depth = 0) {
-            if (depth > 6)
-                return;
-            const tag = el.tagName.toLowerCase();
-            const role = el.getAttribute('role');
-            const ariaLabel = el.getAttribute('aria-label');
-            const testId = el.getAttribute('data-testid');
-            const type = el.getAttribute('type');
-            const placeholder = el.getAttribute('placeholder');
-            const text = el.innerText?.slice(0, 80).trim().replace(/\n/g, ' ');
-            const href = el.getAttribute('href');
-            const disabled = el.getAttribute('disabled') !== null || el.getAttribute('aria-disabled') === 'true';
-            const isInteractive = ['a', 'button', 'input', 'textarea', 'select'].includes(tag) || role;
-            if (!isInteractive && !text)
-                return;
-            const attrs = [];
-            if (testId)
-                attrs.push(`data-testid="${testId}"`);
-            if (role)
-                attrs.push(`role="${role}"`);
-            if (ariaLabel)
-                attrs.push(`aria-label="${ariaLabel}"`);
-            if (type)
-                attrs.push(`type="${type}"`);
-            if (placeholder)
-                attrs.push(`placeholder="${placeholder}"`);
-            if (href)
-                attrs.push(`href="${href.slice(0, 60)}"`);
-            if (disabled)
-                attrs.push('disabled');
-            const indent = '  '.repeat(depth);
-            const attrStr = attrs.length ? ` [${attrs.join(', ')}]` : '';
-            const textStr = text ? ` "${text.slice(0, 60)}"` : '';
-            elements.push(`${indent}<${tag}${attrStr}${textStr}>`);
-            for (const child of el.children) {
-                processNode(child, depth + 1);
-            }
-        }
-        processNode(document.body);
-        return elements.slice(0, 200).join('\n');
-    });
-    return snapshot;
-}
-// Call LLM to get action steps
-async function getActionsFromLLM(instruction, snapshot, pageUrl, llm) {
-    // Load platform-specific guide
-    let platformGuide = '';
-    if (pageUrl.includes('x.com') || pageUrl.includes('twitter.com')) {
-        try {
-            const { readFileSync } = await import('fs');
-            platformGuide = readFileSync(new URL('../prompts/x-guide.md', import.meta.url), 'utf-8');
-        }
-        catch { }
-    }
-    else if (pageUrl.includes('linkedin.com')) {
-        try {
-            const { readFileSync } = await import('fs');
-            platformGuide = readFileSync(new URL('../prompts/linkedin-guide.md', import.meta.url), 'utf-8');
-        }
-        catch { }
-    }
-    const systemPrompt = `You are an expert browser automation assistant. Given a page snapshot and a user instruction, return ONLY a valid JSON array of action steps.
-
-${platformGuide ? `\n## Platform-Specific Guide\n${platformGuide}\n` : ''}
-
-## Available Actions
-- click: { action: "click", selector: "CSS or data-testid selector" }
-- type: { action: "type", selector: "...", text: "text to type" }
-- press: { action: "press", key: "Enter|Tab|Escape|..." }
-- navigate: { action: "navigate", url: "https://..." }
-- wait: { action: "wait", ms: 1000 }
-- scroll: { action: "scroll", direction: "down" }
-
-## Rules
-1. Return ONLY valid JSON array, nothing else
-2. Each action MUST have all required fields
-3. Never generate navigate actions unless instruction explicitly says to go to a URL
-4. Add description field to every action
-5. After clicks that open modals/menus, always add 500ms wait
-6. Use data-testid selectors when available (most stable)
-7. For contenteditable areas, click first then type
-8. Always filter posts by visible content before interacting`;
-    const userPrompt = `Current URL: ${pageUrl}
-
-Page snapshot:
-${snapshot.slice(0, 3500)}
-
-Instruction: ${instruction}
-
-Return ONLY a valid JSON array of action steps with no other text:`;
-    let response;
-    if (llm.provider === 'ollama') {
-        const baseUrl = llm.baseUrl ?? 'http://localhost:11434';
-        response = await fetch(`${baseUrl}/api/chat`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model: llm.model,
-                stream: false,
-                messages: [
-                    { role: 'system', content: systemPrompt },
-                    { role: 'user', content: userPrompt },
-                ],
-            }),
-        });
-        if (!response.ok)
-            throw new Error(`Ollama error: ${response.status} ${await response.text()}`);
-        const data = await response.json();
-        const content = data.message?.content ?? '';
-        let jsonMatch = content.match(/\[[\s\S]*\]/);
-        if (!jsonMatch)
-            throw new Error('Ollama returned no valid JSON array');
-        let jsonStr = jsonMatch[0];
-        try {
-            return JSON.parse(jsonStr);
-        }
-        catch {
-            jsonStr = jsonStr.replace(/("description":\s*)"([^"]*)"([^"]*?)"([^"]*)"/g, '$1"$2\\\"$3\\\"$4"');
-            try {
-                return JSON.parse(jsonStr);
-            }
-            catch {
-                const actions = [];
-                const blocks = jsonStr.match(/\{\s*"?action"?\s*:\s*"([^"]+)"/g) ?? [];
-                blocks.forEach((block) => {
-                    const actionMatch = block.match(/"action"\s*:\s*"([^"]+)"/);
-                    if (actionMatch)
-                        actions.push({ action: actionMatch[1] });
-                });
-                if (actions.length === 0)
-                    throw new Error('Could not extract actions from Ollama response');
-                return actions;
-            }
-        }
-    }
-    if (llm.provider === 'openai' || llm.provider === 'openrouter') {
-        const baseUrl = llm.provider === 'openrouter'
-            ? 'https://openrouter.ai/api/v1'
-            : 'https://api.openai.com/v1';
-        response = await fetch(`${baseUrl}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${llm.apiKey}`,
-            },
-            body: JSON.stringify({
-                model: llm.model,
-                messages: [
-                    { role: 'system', content: systemPrompt },
-                    { role: 'user', content: userPrompt },
-                ],
-                temperature: 0,
-                max_tokens: 1000,
-            }),
-        });
-    }
-    else {
-        // Anthropic
-        response = await fetch('https://api.anthropic.com/v1/messages', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': llm.apiKey ?? '',
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify({
-                model: llm.model,
-                max_tokens: 1000,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: userPrompt }],
-            }),
-        });
-    }
-    if (!response.ok) {
-        throw new Error(`LLM API error: ${response.status} ${await response.text()}`);
-    }
-    const data = await response.json();
-    const content = llm.provider === 'anthropic'
-        ? data.content[0].text
-        : data.choices[0].message.content;
-    // Extract JSON more robustly — handles malformed JSON
-    let jsonMatch = content.match(/\[[\s\S]*\]/);
-    if (!jsonMatch)
-        throw new Error('LLM returned no valid JSON array');
-    let jsonStr = jsonMatch[0];
-    // Try to parse as-is first
-    try {
-        return JSON.parse(jsonStr);
-    }
-    catch {
-        // If that fails, try to fix common issues
-        // Remove unescaped quotes in description fields
-        jsonStr = jsonStr.replace(/("description":\s*)"([^"]*)"([^"]*?)"([^"]*)"/g, '$1"$2\\\"$3\\\"$4"');
-        try {
-            return JSON.parse(jsonStr);
-        }
-        catch {
-            // Last resort: extract actions manually
-            const actions = [];
-            const blocks = jsonStr.match(/\{\s*"?action"?\s*:\s*"([^"]+)"/g) ?? [];
-            blocks.forEach((block) => {
-                const actionMatch = block.match(/"action"\s*:\s*"([^"]+)"/);
-                if (actionMatch)
-                    actions.push({ action: actionMatch[1] });
-            });
-            if (actions.length === 0)
-                throw new Error('Could not extract actions from LLM response');
-            return actions;
-        }
-    }
-}
-// Execute a single action step with X-specific handling
-async function executeStep(page, step) {
-    // Skip invalid steps silently
-    if (step.action === 'navigate' && !step.url) {
-        return; // Skip invalid navigate
-    }
-    if (step.action === 'click' && !step.selector) {
-        return; // Skip click without selector
-    }
-    if (step.action === 'type' && (!step.selector || !step.text)) {
-        return; // Skip type without selector or text
-    }
-    switch (step.action) {
-        case 'click': {
-            if (!step.selector)
-                throw new Error('click requires selector');
-            const el = page.locator(step.selector).first();
-            await el.waitFor({ timeout: 5000 }).catch(() => { });
-            // For X, use force click to bypass overlay interceptors
-            const isX = page.url().includes('x.com') || page.url().includes('twitter.com');
-            if (isX) {
-                await el.click({ force: true, timeout: 5000 });
-            }
-            else {
-                await el.click({ timeout: 5000 });
-            }
-            await humanDelay(300, 700);
-            break;
-        }
-        case 'type': {
-            if (!step.selector || !step.text)
-                throw new Error('type requires selector and text');
-            const el = page.locator(step.selector).first();
-            await el.waitFor({ timeout: 5000 }).catch(() => { });
-            await el.click({ force: true });
-            await humanDelay(200, 400);
-            // Type with human-like delays
-            for (const char of step.text) {
-                await page.keyboard.type(char, { delay: Math.random() * 60 + 30 });
-            }
-            await humanDelay(300, 600);
-            break;
-        }
-        case 'press': {
-            if (!step.key)
-                throw new Error('press requires key');
-            await page.keyboard.press(step.key);
-            await humanDelay(200, 400);
-            break;
-        }
-        case 'navigate': {
-            if (!step.url)
-                throw new Error('navigate requires url');
-            await page.goto(step.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-            await humanDelay(800, 1500);
-            break;
-        }
-        case 'wait': {
-            await new Promise((r) => setTimeout(r, step.ms ?? 1000));
-            break;
-        }
-        case 'scroll': {
-            const amount = step.direction === 'up' ? -600 : 600;
-            await page.evaluate((y) => window.scrollBy(0, y), amount);
-            await humanDelay(300, 500);
-            break;
-        }
-    }
-}
-// Main AI-powered act function
-export async function aiAct(page, instruction, opts = {}) {
-    const config = await loadConfig();
-    const llm = getLLMConfig(config);
-    if (!llm) {
-        throw new Error('No LLM configured. Options:\n' +
-            '  Ollama (local):    veil config llm.provider ollama && veil config llm.model llama3.2\n' +
-            '  OpenAI:            veil config llm.provider openai && veil config llm.apiKey sk-...\n' +
-            '  Anthropic:         veil config llm.provider anthropic && veil config llm.apiKey sk-ant-...\n' +
-            '  OpenRouter:        veil config llm.provider openrouter && veil config llm.apiKey sk-or-...');
-    }
-    const spinner = ora({ text: '🧠 Analyzing page...', color: 'cyan' }).start();
-    try {
-        // 1. Get page snapshot
-        const snapshot = await getPageSnapshot(page);
-        const pageUrl = page.url();
-        spinner.text = '🧠 Asking AI what to do...';
-        // 2. Get action steps from LLM
-        let steps = await getActionsFromLLM(instruction, snapshot, pageUrl, llm);
-        // 3. Filter out invalid steps (navigate without URL)
-        steps = steps.filter(s => {
-            if (s.action === 'navigate' && !s.url) {
-                console.warn(chalk.yellow('⚠️  Filtered out navigate action without URL'));
-                return false;
-            }
-            return true;
-        });
-        if (steps.length === 0) {
-            throw new Error('No valid action steps generated');
-        }
-        if (opts.verbose) {
-            spinner.stop();
-            console.log(chalk.cyan('\n📋 AI action plan:'));
-            steps.forEach((s, i) => {
-                console.log(chalk.gray(`  ${i + 1}. ${s.action}${s.description ? ': ' + s.description : ''}`));
-            });
-            console.log('');
-            spinner.start('Executing...');
-        }
-        else {
-            spinner.text = `Executing ${steps.length} steps...`;
-        }
-        // 3. Execute each step
-        for (let i = 0; i < steps.length; i++) {
-            const step = steps[i];
-            if (opts.verbose) {
-                spinner.text = `Step ${i + 1}/${steps.length}: ${step.action} ${step.description ?? ''}`;
-            }
-            await executeStep(page, step);
-        }
-        spinner.succeed(chalk.green(`✅ Done: ${instruction}`));
-        return { success: true, steps };
-    }
-    catch (err) {
-        spinner.fail(chalk.red(`❌ AI act failed: ${err.message}`));
-        return { success: false, steps: [], error: err.message };
-    }
-}
-export { getActionsFromLLM, executeStep, humanDelay };

package/dist/captcha.js

@@ -1,203 +0,0 @@
-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/mcp.js

@@ -1,232 +0,0 @@
-import { createServer } from 'http';
-import { getBrowser, closeBrowser, humanDelay } from './browser.js';
-import { searchCommand } from './commands/search.js';
-import { listSessions, loadSession } from './session.js';
-import chalk from 'chalk';
-const TOOLS = [
-    {
-        name: 'veil_navigate',
-        description: 'Navigate to a URL in stealth headless mode using a saved session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string', description: 'URL to navigate to' },
-                platform: { type: 'string', description: 'Platform session to use (e.g. twitter, reddit)' },
-                headed: { type: 'boolean', description: 'Run in visible browser mode' },
-            },
-            required: ['url'],
-        },
-    },
-    {
-        name: 'veil_act',
-        description: 'Perform a natural language action in the browser (click, type, post tweet, scroll, etc)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                instruction: { type: 'string', description: 'Natural language instruction, e.g. "post tweet: hello world"' },
-                platform: { type: 'string', description: 'Platform session to use' },
-                url: { type: 'string', description: 'Navigate to this URL first' },
-                headed: { type: 'boolean' },
-            },
-            required: ['instruction'],
-        },
-    },
-    {
-        name: 'veil_search',
-        description: 'Search the web using Google, Bing, DuckDuckGo, or Twitter. Returns JSON results.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Search query' },
-                engine: { type: 'string', description: 'Comma-separated engines: google,bing,duckduckgo,twitter', default: 'google' },
-                limit: { type: 'number', description: 'Max results', default: 10 },
-            },
-            required: ['query'],
-        },
-    },
-    {
-        name: 'veil_extract',
-        description: 'Extract data from a web page. Supports: tweets, links, text, title, metadata.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'What to extract: tweets, links, text, title' },
-                url: { type: 'string', description: 'URL to extract from' },
-                platform: { type: 'string', description: 'Platform session to use' },
-            },
-            required: ['query'],
-        },
-    },
-    {
-        name: 'veil_screenshot',
-        description: 'Take a screenshot of a page. Returns the file path.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                platform: { type: 'string' },
-                output: { type: 'string', description: 'Output file path' },
-            },
-        },
-    },
-    {
-        name: 'veil_session_list',
-        description: 'List all saved platform sessions',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'veil_login_status',
-        description: 'Check if a session exists for a given platform',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                platform: { type: 'string' },
-            },
-            required: ['platform'],
-        },
-    },
-];
-async function callTool(name, args) {
-    switch (name) {
-        case 'veil_navigate': {
-            const { page } = await getBrowser({ headed: args.headed, platform: args.platform });
-            await page.goto(args.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-            await humanDelay(500, 1200);
-            const title = await page.title();
-            const url = page.url();
-            await closeBrowser(args.platform);
-            return { success: true, url, title };
-        }
-        case 'veil_act': {
-            const { actCommand } = await import('./commands/act.js');
-            // Capture stdout
-            const chunks = [];
-            const orig = process.stdout.write.bind(process.stdout);
-            process.stdout.write = (c) => chunks.push(c.toString());
-            await actCommand(args.instruction, { platform: args.platform, url: args.url, headed: args.headed, json: true });
-            process.stdout.write = orig;
-            const out = chunks.join('');
-            try {
-                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
-            }
-            catch {
-                return { success: true };
-            }
-        }
-        case 'veil_search': {
-            const chunks = [];
-            const orig = process.stdout.write.bind(process.stdout);
-            process.stdout.write = (c) => chunks.push(c.toString());
-            await searchCommand(args.query, { engine: args.engine ?? 'google', json: true, limit: String(args.limit ?? 10) });
-            process.stdout.write = orig;
-            const out = chunks.join('');
-            try {
-                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
-            }
-            catch {
-                return { success: false };
-            }
-        }
-        case 'veil_extract': {
-            const { extractCommand } = await import('./commands/extract.js');
-            const chunks = [];
-            const orig = process.stdout.write.bind(process.stdout);
-            process.stdout.write = (c) => chunks.push(c.toString());
-            await extractCommand(args.query, { platform: args.platform, url: args.url, json: true });
-            process.stdout.write = orig;
-            const out = chunks.join('');
-            try {
-                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
-            }
-            catch {
-                return { success: false };
-            }
-        }
-        case 'veil_screenshot': {
-            const { screenshotCommand } = await import('./commands/screenshot.js');
-            const chunks = [];
-            const orig = process.stdout.write.bind(process.stdout);
-            process.stdout.write = (c) => chunks.push(c.toString());
-            await screenshotCommand({ platform: args.platform, url: args.url, output: args.output, json: true });
-            process.stdout.write = orig;
-            const out = chunks.join('');
-            try {
-                return JSON.parse(out.split('\n').filter(Boolean).pop() ?? '{}');
-            }
-            catch {
-                return { success: false };
-            }
-        }
-        case 'veil_session_list': {
-            const sessions = await listSessions();
-            return { sessions };
-        }
-        case 'veil_login_status': {
-            const session = await loadSession(args.platform);
-            return { platform: args.platform, loggedIn: !!session };
-        }
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
-}
-function jsonRpc(id, result, error) {
-    if (error)
-        return { jsonrpc: '2.0', id, error: { code: -32000, message: error } };
-    return { jsonrpc: '2.0', id, result };
-}
-async function handleRequest(body) {
-    const { id, method, params } = body;
-    if (method === 'initialize') {
-        return jsonRpc(id, {
-            protocolVersion: '2024-11-05',
-            capabilities: { tools: {} },
-            serverInfo: { name: 'veil', version: '0.1.0' },
-        });
-    }
-    if (method === 'tools/list') {
-        return jsonRpc(id, { tools: TOOLS });
-    }
-    if (method === 'tools/call') {
-        try {
-            const result = await callTool(params.name, params.arguments ?? {});
-            return jsonRpc(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
-        }
-        catch (err) {
-            return jsonRpc(id, undefined, err.message);
-        }
-    }
-    return jsonRpc(id, undefined, `Method not found: ${method}`);
-}
-export async function startMcpServer(port = 3456) {
-    const server = createServer(async (req, res) => {
-        if (req.method === 'POST') {
-            let body = '';
-            req.on('data', (chunk) => (body += chunk));
-            req.on('end', async () => {
-                try {
-                    const parsed = JSON.parse(body);
-                    const response = await handleRequest(parsed);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(response));
-                }
-                catch (err) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: err.message }));
-                }
-            });
-        }
-        else if (req.method === 'GET' && req.url === '/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', version: '0.1.0' }));
-        }
-        else {
-            res.writeHead(404);
-            res.end();
-        }
-    });
-    server.listen(port, () => {
-        console.log(chalk.cyan(`\n🕶️  veil MCP server running on http://localhost:${port}`));
-        console.log(chalk.gray(`   Tools: ${TOOLS.map((t) => t.name).join(', ')}\n`));
-    });
-    process.on('SIGINT', () => { server.close(); process.exit(0); });
-}

package/dist/startup.js

@@ -1,9 +0,0 @@
-import { ensureFlareSolverr } from './local-captcha.js';
-/**
- * Called once when veil starts any browser command.
- * Boots FlareSolverr in the background so it's ready before we hit a CAPTCHA.
- */
-export async function veilStartup() {
-    // Start FlareSolverr silently in background — don't await, don't block
-    ensureFlareSolverr().catch(() => { });
-}

package/dist/state.js

@@ -1,45 +0,0 @@
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-const STATE_DIR = join(homedir(), '.veil', 'state');
-async function ensureDir() {
-    await fs.mkdir(STATE_DIR, { recursive: true });
-}
-export async function saveState(sessionId, state) {
-    await ensureDir();
-    const file = join(STATE_DIR, `${sessionId}.json`);
-    let existing = {
-        sessionId,
-        currentUrl: '',
-        lastAction: '',
-        timestamp: Date.now(),
-        history: [],
-    };
-    try {
-        const raw = await fs.readFile(file, 'utf-8');
-        existing = JSON.parse(raw);
-    }
-    catch { }
-    const updated = { ...existing, ...state, timestamp: Date.now() };
-    if (state.currentUrl && state.currentUrl !== existing.currentUrl) {
-        updated.history = [...(existing.history ?? []).slice(-19), state.currentUrl];
-    }
-    await fs.writeFile(file, JSON.stringify(updated, null, 2), 'utf-8');
-}
-export async function loadState(sessionId) {
-    const file = join(STATE_DIR, `${sessionId}.json`);
-    try {
-        const raw = await fs.readFile(file, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export async function clearState(sessionId) {
-    const file = join(STATE_DIR, `${sessionId}.json`);
-    try {
-        await fs.unlink(file);
-    }
-    catch { }
-}