veil-browser 0.1.7 → 0.2.0

package/SKILL.md

@@ -0,0 +1,275 @@
+# veil — OpenClaw Stealth Browser Remote
+
+## What is veil
+
+veil is a **headless browser remote control** for OpenClaw. It runs a persistent stealth Chromium browser and exposes it through a clean CLI. You (OpenClaw) are the brain — veil is just the hands.
+
+Every command outputs clean JSON: `{ ok: true, ... }` or `{ ok: false, error: "..." }`
+
+## Installation
+
+```bash
+npm install -g veil-browser
+npx playwright install chromium
+```
+
+## Core Mental Model
+
+You chain veil commands like a human would:
+1. Open the browser to the right platform (`veil open x`)
+2. Read the page (`veil snapshot` or `veil read`)
+3. Act on what you see (`veil click`, `veil type`)
+4. Verify the result (`veil find`, `veil read`, `veil shot`)
+
+---
+
+## Full Command Reference
+
+### Session Setup (do once)
+```bash
+veil login x              # Opens visible browser → log in → saves cookies
+veil login linkedin
+veil login reddit
+veil sessions             # List saved sessions
+```
+
+### Open a Session
+```bash
+veil open x               # Restore X session, navigate to home feed
+veil open linkedin        # Restore LinkedIn session
+veil open <platform>      # Any saved platform
+```
+
+### Navigation
+```bash
+veil go https://x.com/home           # Navigate to URL
+veil go https://x.com --wait load    # Wait for full load
+veil url                              # Get current URL + title
+veil back                             # Go back
+```
+
+### Reading the Page
+```bash
+veil snapshot             # DOM/ARIA tree — use this to understand page structure
+veil snapshot --max 4000  # Smaller snapshot for faster processing
+veil read                 # Full page text (first 5000 chars)
+veil read "[data-testid='tweetText']"          # Text of first match
+veil read "[data-testid='tweetText']" --all    # All matches as array
+veil read "a" --attr href                       # Read attribute
+veil find "Sign in"       # Check if text exists: { ok: true, found: true }
+veil exists "[data-testid='like']"  # Check if selector exists
+```
+
+### Clicking
+```bash
+veil click "[data-testid='like']"             # Click first match
+veil click "[data-testid='like']" --nth 2     # Click 3rd match (0-indexed)
+veil click "[data-testid='like']" --force     # Force click (bypass overlays)
+veil click "[data-testid='reply']" --timeout 8000
+```
+
+### Typing
+```bash
+veil type "[data-testid='tweetTextarea_0']" "Hello world"
+veil type "input[name='search']" "AI architecture" --clear   # Clear first
+veil type "[data-testid='tweetTextarea_0']" "text" --delay 60 # Slower, more human
+```
+
+### Keyboard
+```bash
+veil press Enter
+veil press Tab
+veil press Escape
+veil press ArrowDown
+```
+
+### Scrolling
+```bash
+veil scroll down           # Scroll 600px down
+veil scroll up             # Scroll 600px up
+veil scroll down --amount 1200
+veil scroll top            # Jump to top of page
+veil scroll bottom         # Jump to bottom
+```
+
+### Timing
+```bash
+veil wait 500              # Wait 500ms
+veil wait 2000             # Wait 2 seconds
+veil wait-for "[data-testid='timeline']"            # Wait until element appears
+veil wait-for "[data-testid='timeline']" --timeout 15000
+```
+
+### Screenshots
+```bash
+veil shot                        # Screenshot to veil-<timestamp>.png
+veil shot page.png               # Custom filename
+veil shot page.png --full        # Full page
+veil shot el.png --selector "[data-testid='tweet']"  # Screenshot element
+```
+
+### JavaScript Execution
+```bash
+veil eval "document.title"
+veil eval "window.scrollY"
+veil eval "document.querySelectorAll('article').length"
+```
+
+### Close Browser
+```bash
+veil close                 # Close current browser
+```
+
+---
+
+## Platform Selectors
+
+### X (Twitter) — x.com
+
+| Element | Selector |
+|---------|----------|
+| Tweet text area | `[data-testid="tweetTextarea_0"]` |
+| Post/Tweet button | `[data-testid="tweetButtonInline"]` |
+| Like button | `[data-testid="like"]` |
+| Unlike (already liked) | `[data-testid="unlike"]` |
+| Reply button | `[data-testid="reply"]` |
+| Retweet button | `[data-testid="retweet"]` |
+| Share/More options | `[aria-label="Share Tweet"]` |
+| A tweet (article) | `article[data-testid="tweet"]` |
+| First tweet | `article[data-testid="tweet"]:first-of-type` |
+| Tweet text content | `[data-testid="tweetText"]` |
+| Feed timeline | `[data-testid="primaryColumn"]` |
+| Search box | `[data-testid="SearchBox_Search_Input"]` |
+| Menu items | `[role="menuitem"]` |
+| Follow button | `[data-testid="follow"]` |
+
+### LinkedIn — linkedin.com
+
+| Element | Selector |
+|---------|----------|
+| Like button | `button[aria-label*="Like"]` |
+| Comment button | `button[aria-label*="Comment"]` |
+| Share button | `button[aria-label*="Share"]` |
+| Comment text area | `[contenteditable="true"][role="textbox"]` |
+| Post button | `button.comments-comment-box__submit-button` |
+| Feed posts | `.feed-shared-update-v2` |
+
+### Reddit — reddit.com
+
+| Element | Selector |
+|---------|----------|
+| Upvote button | `button[aria-label="upvote"]` |
+| Comment link | `a[data-click-id="comments"]` |
+| Comment box | `[contenteditable="true"]` |
+| Submit comment | `button:has-text("Comment")` |
+
+---
+
+## Common Task Sequences
+
+### Post a Tweet on X
+```bash
+veil open x
+veil wait-for "[data-testid='primaryColumn']"
+veil click "[data-testid='tweetTextarea_0']"
+veil wait 300
+veil type "[data-testid='tweetTextarea_0']" "Your tweet text here"
+veil wait 500
+veil click "[data-testid='tweetButtonInline']" --force
+veil wait 1500
+veil find "Your tweet text here"
+```
+
+### Like First 5 Posts on X Feed
+```bash
+veil open x
+veil wait-for "article[data-testid='tweet']"
+veil click "[data-testid='like']" --nth 0
+veil wait 800
+veil click "[data-testid='like']" --nth 1
+veil wait 800
+veil click "[data-testid='like']" --nth 2
+veil wait 800
+veil click "[data-testid='like']" --nth 3
+veil wait 800
+veil click "[data-testid='like']" --nth 4
+veil wait 800
+```
+
+### Reply to First Post on X Feed
+```bash
+veil open x
+veil wait-for "article[data-testid='tweet']"
+veil click "[data-testid='reply']" --nth 0 --force
+veil wait 600
+veil click "[data-testid='tweetTextarea_0']"
+veil wait 200
+veil type "[data-testid='tweetTextarea_0']" "Great post! This is exactly why AI needs structured reasoning."
+veil wait 400
+veil click "[data-testid='tweetButton']" --force
+veil wait 1500
+```
+
+### Search X for AI Posts
+```bash
+veil open x
+veil go https://x.com/search?q=AI+architecture&f=live
+veil wait-for "article[data-testid='tweet']"
+veil snapshot --max 3000
+# Now you can see the results and decide which to interact with
+```
+
+### Read Feed Before Interacting
+```bash
+veil open x
+veil wait-for "article[data-testid='tweet']"
+veil read "[data-testid='tweetText']" --all
+# Returns JSON array of tweet texts — you can decide which to reply to
+```
+
+---
+
+## Error Handling
+
+Every command returns JSON. Always check `ok`:
+
+```bash
+result=$(veil click "[data-testid='like']")
+# Check: echo $result | jq .ok
+# If false: echo $result | jq .error
+```
+
+**Common errors and fixes:**
+
+| Error | Fix |
+|-------|-----|
+| `No browser open` | Run `veil open x` first |
+| `Timeout waiting for selector` | Page not loaded yet — add `veil wait 2000` before |
+| `Element not found` | Use `veil snapshot` to inspect actual DOM, adjust selector |
+| `Session not found` | Run `veil login x` to create session |
+| Click fails (overlay) | Add `--force` flag to `veil click` |
+
+**Debug workflow:**
+```bash
+veil shot debug.png          # What does the page actually look like?
+veil snapshot --max 5000     # What's in the DOM?
+veil exists "[selector]"     # Does the element even exist?
+```
+
+---
+
+## Session Persistence
+
+- Sessions stored in `~/.veil/sessions/<platform>.json` (encrypted cookies)
+- Browser instance stays open within a single execution chain
+- Each new `veil` command that needs the browser checks for existing session
+- Use `veil close` to explicitly close the browser
+
+---
+
+## Notes
+
+- All clicks on X use `--force` by default to bypass overlay interceptors
+- Human-like delays are added automatically between interactions
+- FlareSolverr auto-starts via Docker if Cloudflare challenges are detected
+- veil outputs only JSON to stdout — safe to pipe and parse

package/dist/ai.js

@@ -81,30 +81,51 @@ async function getPageSnapshot(page) {
 }
 // Call LLM to get action steps
 async function getActionsFromLLM(instruction, snapshot, pageUrl, llm) {
-    const systemPrompt = `You are a browser automation assistant. Given a page snapshot (ARIA/DOM tree) and a user instruction, return a JSON array of action steps to complete the task.
+    // 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", description: "..." }
-- type: { action: "type", selector: "...", text: "the text to type", description: "..." }
-- press: { action: "press", key: "Enter|Tab|Escape|...", description: "..." }
-- navigate: { action: "navigate", url: "https://...", description: "..." }
-- wait: { action: "wait", ms: 1000, description: "..." }
-- scroll: { action: "scroll", direction: "down", description: "..." }
+## 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:
-- Prefer data-testid selectors when available (most stable)
-- For Twitter/X: use [data-testid="tweetTextarea_0"] for tweet box, [data-testid="tweetButtonInline"] for post button
-- Return ONLY valid JSON array, no explanation
-- Add a wait step after clicks on buttons that trigger UI changes
-- For typing in contenteditable areas, click first then type`;
+## 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, 4000)}
+${snapshot.slice(0, 3500)}
 
 Instruction: ${instruction}
 
-Return JSON array of action steps:`;
+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';

package/dist/browser.d.ts

@@ -1,12 +1,12 @@
-import type { Browser, BrowserContext, Page } from 'playwright';
-export interface LaunchOptions {
+import { Browser, BrowserContext, Page } from 'playwright';
+export declare function ensureBrowser(opts?: {
     headed?: boolean;
     platform?: string;
-}
-export declare function getBrowser(opts?: LaunchOptions): Promise<{
+}): Promise<{
     browser: Browser;
     context: BrowserContext;
     page: Page;
 }>;
+export declare function getPage(): Promise<Page | null>;
 export declare function closeBrowser(platform?: string): Promise<void>;
 export declare function humanDelay(min?: number, max?: number): Promise<void>;

package/dist/browser.js

@@ -1,46 +1,92 @@
-import { chromium } from 'playwright-extra';
-import StealthPlugin from 'puppeteer-extra-plugin-stealth';
-import { loadSession, saveSession } from './session.js';
-// @ts-ignore
-chromium.use(StealthPlugin());
+import { chromium } from 'playwright';
+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)
 let _browser = null;
 let _context = null;
 let _page = null;
-export async function getBrowser(opts = {}) {
-    const headless = !opts.headed;
-    _browser = await chromium.launch({
-        headless,
+let _platform = 'default';
+export async function ensureBrowser(opts = {}) {
+    const platform = opts.platform ?? 'default';
+    if (_browser && _context && _page && !_page.isClosed()) {
+        return { browser: _browser, context: _context, page: _page };
+    }
+    // Launch browser with stealth args
+    const browser = await chromium.launch({
+        headless: !opts.headed,
         args: [
-            '--no-sandbox',
             '--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',
         ],
     });
-    const storageState = opts.platform ? await loadSession(opts.platform) : undefined;
-    _context = await _browser.newContext({
-        storageState: storageState ?? undefined,
+    // 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/121.0.0.0 Safari/537.36',
+        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',
         locale: 'en-US',
-        timezoneId: 'Europe/Bratislava',
+        timezoneId: 'America/New_York',
+        permissions: ['notifications'],
+        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'],
+        });
     });
-    _page = await _context.newPage();
-    return { browser: _browser, context: _context, page: _page };
+    // Restore session cookies if available
+    const session = await loadSession(platform);
+    if (session?.cookies && session.cookies.length > 0) {
+        await context.addCookies(session.cookies);
+    }
+    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(() => { });
+    return { browser, context, page };
+}
+export async function getPage() {
+    if (_page && !_page.isClosed())
+        return _page;
+    return null;
 }
 export async function closeBrowser(platform) {
-    if (_context && platform) {
-        const state = await _context.storageState();
-        await saveSession(platform, state);
-    }
     if (_browser) {
-        await _browser.close();
+        await _browser.close().catch(() => { });
         _browser = null;
         _context = null;
         _page = null;
     }
+    await fs.rm(STATE_FILE).catch(() => { });
 }
-export function humanDelay(min = 300, max = 900) {
-    const ms = Math.floor(Math.random() * (max - min) + min);
-    return new Promise((r) => setTimeout(r, ms));
+export function humanDelay(min = 500, max = 1200) {
+    const delay = Math.floor(Math.random() * (max - min) + min);
+    return new Promise(r => setTimeout(r, delay));
 }

package/dist/index.js

@@ -1,171 +1,386 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { veilStartup } from './startup.js';
-import { loginCommand } from './commands/login.js';
-import { navigateCommand } from './commands/navigate.js';
-import { actCommand } from './commands/act.js';
-import { extractCommand } from './commands/extract.js';
-import { screenshotCommand } from './commands/screenshot.js';
-import { sessionListCommand, logoutCommand } from './commands/session.js';
-import { searchCommand } from './commands/search.js';
-import { startMcpServer } from './mcp.js';
+import { ensureBrowser, closeBrowser, getPage } from './browser.js';
+import { saveSession } from './session.js';
 const program = new Command();
 program
     .name('veil')
-    .description(chalk.cyan('🕶️  Stealth browser CLI for AI agents'))
-    .version('0.1.0');
-// --- Auth ---
+    .description('🕶️  OpenClaw browser remote — stealth headless browser')
+    .version('0.2.0');
+// ─── Session ──────────────────────────────────────────────────────────────────
 program
     .command('login <platform>')
-    .description('Open visible browser for manual login, save session')
-    .action(loginCommand);
-program
-    .command('logout <platform>')
-    .description('Remove saved session for a platform')
-    .action(logoutCommand);
-// --- Browse ---
-program
-    .command('navigate <url>')
-    .description('Navigate to a URL in headless stealth mode')
-    .option('-p, --platform <platform>', 'Use saved session for this platform')
-    .option('-H, --headed', 'Run in visible browser mode')
-    .option('--json', 'Output JSON')
-    .action((url, opts) => navigateCommand(url, opts));
-program
-    .command('act <instruction>')
-    .description('Perform a natural language action in the browser')
-    .option('-p, --platform <platform>', 'Use saved session for this platform')
-    .option('-u, --url <url>', 'Navigate to this URL first')
-    .option('-H, --headed', 'Run in visible browser mode')
-    .option('--json', 'Output JSON')
-    .action((instruction, opts) => actCommand(instruction, opts));
-program
-    .command('extract <query>')
-    .description('Extract data from current page as JSON')
-    .option('-p, --platform <platform>', 'Use saved session for this platform')
-    .option('-u, --url <url>', 'Navigate to this URL first')
-    .option('-H, --headed', 'Run in visible browser mode')
-    .option('--json', 'Output JSON')
-    .action((query, opts) => extractCommand(query, opts));
-program
-    .command('screenshot')
-    .description('Take a screenshot of the current page')
-    .option('-p, --platform <platform>', 'Use saved session for this platform')
-    .option('-u, --url <url>', 'Navigate to this URL first')
-    .option('-o, --output <path>', 'Output file path')
-    .option('-H, --headed', 'Run in visible browser mode')
-    .option('--json', 'Output JSON')
-    .action((opts) => screenshotCommand(opts));
-// --- Search ---
-program
-    .command('search <query>')
-    .description('Search the web — google, bing, duckduckgo, or twitter')
-    .option('-e, --engine <engines>', 'Comma-separated engines: google,bing,duckduckgo,twitter', 'google')
-    .option('-p, --platform <platform>', 'Use saved session for platform search')
-    .option('-l, --limit <n>', 'Max results', '10')
-    .option('-H, --headed', 'Run in visible browser mode')
-    .option('--json', 'Output JSON')
-    .action((query, opts) => searchCommand(query, opts));
-// --- Sessions ---
-const sessionCmd = program.command('session').description('Manage saved sessions');
-sessionCmd.command('list').description('List all saved sessions').action(sessionListCommand);
-// --- Config ---
-program
-    .command('config [key] [value]')
-    .description('Set or show veil configuration')
-    .action(async (key, value) => {
-    const { promises: fs } = await import('fs');
-    const { homedir } = await import('os');
-    const { join } = await import('path');
-    const configFile = join(homedir(), '.veil', 'config.json');
-    await fs.mkdir(join(homedir(), '.veil'), { recursive: true });
-    let config = {};
+    .description('Open visible browser to log in and save session (x, linkedin, reddit)')
+    .action(async (platform) => {
+    const platformUrls = {
+        x: 'https://x.com/login',
+        twitter: 'https://x.com/login',
+        linkedin: 'https://www.linkedin.com/login',
+        reddit: 'https://www.reddit.com/login',
+        bluesky: 'https://bsky.app',
+    };
+    const url = platformUrls[platform.toLowerCase()] ?? `https://${platform}`;
+    const { browser, context, page } = await ensureBrowser({ headed: true, platform });
+    await page.goto(url, { waitUntil: 'domcontentloaded' });
+    console.log(chalk.cyan(`\n🔐 Log into ${platform} in the browser window.`));
+    console.log(chalk.gray('   Press Enter here when done.\n'));
+    await new Promise(res => process.stdin.once('data', () => res()));
+    await saveSession(platform, context);
+    console.log(chalk.green(`✅ Session saved for ${platform}`));
+    await browser.close();
+});
+program
+    .command('sessions')
+    .description('List saved sessions')
+    .action(async () => {
+    const { listSessions } = await import('./session.js');
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+        console.log(chalk.gray('No sessions saved. Run: veil login <platform>'));
+    }
+    else {
+        sessions.forEach(s => console.log(chalk.green(`  ✓ ${s}`)));
+    }
+});
+// ─── Navigation ───────────────────────────────────────────────────────────────
+program
+    .command('go <url>')
+    .description('Navigate to a URL')
+    .option('--platform <platform>', 'Platform for session restore', 'default')
+    .option('--wait <event>', 'Wait event: load|domcontentloaded|networkidle', 'domcontentloaded')
+    .option('--timeout <ms>', 'Timeout in ms', '30000')
+    .action(async (url, opts) => {
+    const { page } = await ensureBrowser({ platform: opts.platform });
+    try {
+        await page.goto(url, { waitUntil: opts.wait, timeout: parseInt(opts.timeout) });
+        const title = await page.title();
+        const finalUrl = page.url();
+        console.log(JSON.stringify({ ok: true, url: finalUrl, title }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+});
+program
+    .command('url')
+    .description('Get current URL')
+    .action(async () => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser session open' }));
+        process.exit(1);
+    }
+    console.log(JSON.stringify({ ok: true, url: page.url(), title: await page.title() }));
+});
+program
+    .command('back')
+    .description('Navigate back')
+    .action(async () => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser session open' }));
+        process.exit(1);
+    }
+    await page.goBack();
+    console.log(JSON.stringify({ ok: true, url: page.url() }));
+});
+// ─── Interaction ──────────────────────────────────────────────────────────────
+program
+    .command('click <selector>')
+    .description('Click an element by CSS selector or data-testid')
+    .option('--nth <n>', 'Which match (0-indexed)', '0')
+    .option('--force', 'Force click (bypass overlays)', false)
+    .option('--timeout <ms>', 'Timeout', '5000')
+    .action(async (selector, opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open. Run: veil go <url>' }));
+        process.exit(1);
+    }
+    try {
+        const el = page.locator(selector).nth(parseInt(opts.nth));
+        await el.waitFor({ timeout: parseInt(opts.timeout) });
+        await el.click({ force: opts.force, timeout: parseInt(opts.timeout) });
+        console.log(JSON.stringify({ ok: true, selector, nth: opts.nth }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message, selector }));
+        process.exit(1);
+    }
+});
+program
+    .command('type <selector> <text>')
+    .description('Type text into an element')
+    .option('--clear', 'Clear field first', false)
+    .option('--delay <ms>', 'Delay between keystrokes in ms', '40')
+    .option('--nth <n>', 'Which match (0-indexed)', '0')
+    .action(async (selector, text, opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    try {
+        const el = page.locator(selector).nth(parseInt(opts.nth));
+        await el.waitFor({ timeout: 5000 });
+        if (opts.clear)
+            await el.clear();
+        await el.click({ force: true });
+        await page.keyboard.type(text, { delay: parseInt(opts.delay) });
+        console.log(JSON.stringify({ ok: true, selector, typed: text }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message, selector }));
+        process.exit(1);
+    }
+});
+program
+    .command('press <key>')
+    .description('Press a keyboard key (Enter, Tab, Escape, ArrowDown...)')
+    .action(async (key) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    await page.keyboard.press(key);
+    console.log(JSON.stringify({ ok: true, key }));
+});
+program
+    .command('scroll <direction>')
+    .description('Scroll page: up, down, top, bottom')
+    .option('--amount <px>', 'Pixels to scroll', '600')
+    .action(async (direction, opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    const amount = parseInt(opts.amount);
+    const scrollMap = {
+        down: `window.scrollBy(0, ${amount})`,
+        up: `window.scrollBy(0, -${amount})`,
+        top: 'window.scrollTo(0, 0)',
+        bottom: 'window.scrollTo(0, document.body.scrollHeight)',
+    };
+    await page.evaluate(scrollMap[direction] ?? scrollMap.down);
+    console.log(JSON.stringify({ ok: true, direction, amount }));
+});
+program
+    .command('wait <ms>')
+    .description('Wait for N milliseconds')
+    .action(async (ms) => {
+    await new Promise(r => setTimeout(r, parseInt(ms)));
+    console.log(JSON.stringify({ ok: true, waited: parseInt(ms) }));
+});
+program
+    .command('wait-for <selector>')
+    .description('Wait until selector appears on the page')
+    .option('--timeout <ms>', 'Timeout', '10000')
+    .action(async (selector, opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
     try {
-        config = JSON.parse(await fs.readFile(configFile, 'utf-8'));
-    }
-    catch { }
-    // Show config
-    if (!key || key === 'show') {
-        console.log(chalk.cyan('\n🕶️  veil config\n'));
-        console.log(chalk.bold('  LLM (for veil act):'));
-        console.log(`    provider:  ${chalk.green(config.llm?.provider ?? 'auto-detect')}`);
-        console.log(`    model:     ${chalk.green(config.llm?.model ?? 'auto-detect')}`);
-        console.log(`    apiKey:    ${config.llm?.apiKey ? chalk.green('set') : chalk.gray('not set')}`);
-        console.log(`    baseUrl:   ${chalk.green(config.llm?.baseUrl ?? 'http://localhost:11434 (ollama default)')}`);
-        console.log(chalk.bold('\n  CAPTCHA:'));
-        console.log(`    provider:  ${chalk.green(config.captcha?.provider ?? 'local (FlareSolverr + Ollama)')}`);
-        console.log(`    apiKey:    ${config.captcha?.apiKey ? chalk.green('set') : chalk.gray('not set')}`);
-        console.log(chalk.bold('\n  Quick setup:'));
-        console.log(chalk.gray('    Ollama:    veil config llm.provider ollama'));
-        console.log(chalk.gray('    Model:     veil config llm.model llama3.2'));
-        console.log(chalk.gray('    Ollama URL:veil config llm.baseUrl http://localhost:11434'));
-        console.log(chalk.gray('    OpenAI:    veil config llm.provider openai && veil config llm.apiKey sk-...'));
-        console.log('');
-        return;
-    }
-    // Set config key
-    const parts = key.split('.');
-    let obj = config;
-    for (let i = 0; i < parts.length - 1; i++) {
-        obj[parts[i]] = obj[parts[i]] ?? {};
-        obj = obj[parts[i]];
-    }
-    obj[parts[parts.length - 1]] = value;
-    await fs.writeFile(configFile, JSON.stringify(config, null, 2), 'utf-8');
-    console.log(chalk.green(`✅ Set ${key} = ${value}`));
-});
-// --- Daemon mode ---
-program
-    .command('daemon [instruction...]')
-    .description('Run veil continuously at intervals (like posts every 5 minutes)')
-    .option('--platform <platform>', 'Platform: x, linkedin, reddit, bluesky', 'x')
-    .option('--interval <minutes>', 'Run every N minutes', '5')
-    .option('--max-runs <n>', 'Stop after N runs (default: infinite)')
-    .option('--stop-on <errors...>', 'Stop if error contains this text')
-    .action(async (instructions, opts) => {
-    const instruction = instructions?.join(' ');
-    if (!instruction) {
-        console.error(chalk.red('Error: instruction required'));
-        console.error(chalk.gray('Usage: veil daemon "Like posts about AI" --interval 5 --platform x'));
-        process.exit(1);
-    }
-    const config = {
-        instruction,
-        interval: parseInt(opts.interval, 10),
-        platform: opts.platform,
-        maxRuns: opts.maxRuns ? parseInt(opts.maxRuns, 10) : Infinity,
-        stopOn: opts.stopOn || [],
+        await page.waitForSelector(selector, { timeout: parseInt(opts.timeout) });
+        console.log(JSON.stringify({ ok: true, selector }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: `Timeout waiting for: ${selector}` }));
+        process.exit(1);
+    }
+});
+// ─── Reading / Extraction ─────────────────────────────────────────────────────
+program
+    .command('read [selector]')
+    .description('Read text from page or specific element')
+    .option('--all', 'Return all matches as array', false)
+    .option('--attr <attribute>', 'Read attribute instead of text (e.g. href, src)')
+    .action(async (selector, opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    try {
+        if (!selector) {
+            // Full page text
+            const text = await page.evaluate(() => document.body.innerText);
+            console.log(JSON.stringify({ ok: true, text: text.slice(0, 5000) }));
+            return;
+        }
+        if (opts.all) {
+            const items = await page.locator(selector).allTextContents();
+            console.log(JSON.stringify({ ok: true, items }));
+        }
+        else if (opts.attr) {
+            const val = await page.locator(selector).first().getAttribute(opts.attr);
+            console.log(JSON.stringify({ ok: true, value: val }));
+        }
+        else {
+            const text = await page.locator(selector).first().textContent();
+            console.log(JSON.stringify({ ok: true, text }));
+        }
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+});
+program
+    .command('snapshot')
+    .description('Get full page accessibility snapshot (ARIA tree) for reasoning')
+    .option('--max <chars>', 'Max chars to return', '8000')
+    .action(async (opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    // Use DOM snapshot instead of deprecated accessibility
+    const snapshot = await page.evaluate((max) => {
+        function nodeToObj(el, depth = 0) {
+            if (depth > 8)
+                return null;
+            const obj = {
+                tag: el.tagName?.toLowerCase(),
+                role: el.getAttribute('role'),
+                label: el.getAttribute('aria-label'),
+                testid: el.getAttribute('data-testid'),
+                text: el instanceof HTMLElement && !el.children.length ? el.innerText?.slice(0, 100) : undefined,
+                href: el instanceof HTMLAnchorElement ? el.href : undefined,
+            };
+            // Remove undefined keys
+            Object.keys(obj).forEach(k => obj[k] === undefined && delete obj[k]);
+            const children = Array.from(el.children)
+                .map(c => nodeToObj(c, depth + 1))
+                .filter(Boolean)
+                .slice(0, 10);
+            if (children.length)
+                obj.children = children;
+            return obj;
+        }
+        return JSON.stringify(nodeToObj(document.body), null, 2).slice(0, max);
+    }, parseInt(opts.max));
+    console.log(JSON.stringify({ ok: true, snapshot, url: page.url() }));
+});
+program
+    .command('find <text>')
+    .description('Check if text exists on the current page')
+    .action(async (text) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    const found = await page.getByText(text).first().isVisible().catch(() => false);
+    console.log(JSON.stringify({ ok: true, found, text }));
+});
+program
+    .command('exists <selector>')
+    .description('Check if a selector exists on the page')
+    .action(async (selector) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    const count = await page.locator(selector).count();
+    console.log(JSON.stringify({ ok: true, exists: count > 0, count, selector }));
+});
+// ─── Screenshots ──────────────────────────────────────────────────────────────
+program
+    .command('shot [filename]')
+    .description('Take a screenshot')
+    .option('--selector <sel>', 'Screenshot specific element')
+    .option('--full', 'Full page screenshot', false)
+    .action(async (filename, opts) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    const path = filename ?? `veil-${Date.now()}.png`;
+    if (opts.selector) {
+        await page.locator(opts.selector).first().screenshot({ path });
+    }
+    else {
+        await page.screenshot({ path, fullPage: opts.full });
+    }
+    console.log(JSON.stringify({ ok: true, path }));
+});
+// ─── Evaluate ─────────────────────────────────────────────────────────────────
+program
+    .command('eval <script>')
+    .description('Run JavaScript in the browser and return result')
+    .action(async (script) => {
+    const page = await getPage();
+    if (!page) {
+        console.log(JSON.stringify({ ok: false, error: 'No browser open' }));
+        process.exit(1);
+    }
+    try {
+        const result = await page.evaluate(script);
+        console.log(JSON.stringify({ ok: true, result }));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+    }
+});
+// ─── Session management ───────────────────────────────────────────────────────
+program
+    .command('open <platform>')
+    .description('Open a browser session using saved login cookies for a platform')
+    .option('--headed', 'Show browser window', false)
+    .action(async (platform, opts) => {
+    const { browser, context, page } = await ensureBrowser({ headed: opts.headed, platform });
+    const platformUrls = {
+        x: 'https://x.com/home',
+        twitter: 'https://x.com/home',
+        linkedin: 'https://www.linkedin.com/feed',
+        reddit: 'https://www.reddit.com',
+        bluesky: 'https://bsky.app',
     };
-    const { daemonCommand } = await import('./commands/daemon.js');
-    const { aiAct } = await import('./ai.js');
-    await daemonCommand(config, async (page) => {
-        const result = await aiAct(page, config.instruction, {});
-        if (!result.success)
-            throw new Error(result.error);
-    });
-});
-// --- MCP Server ---
-program
-    .command('serve')
-    .description('Start veil as an MCP tool server for AI agents')
-    .option('--port <port>', 'Port to listen on', '3456')
-    .action((opts) => startMcpServer(parseInt(opts.port)));
-// --- Status ---
+    const url = platformUrls[platform.toLowerCase()] ?? `https://${platform}`;
+    await page.goto(url, { waitUntil: 'domcontentloaded' });
+    const title = await page.title();
+    console.log(JSON.stringify({ ok: true, platform, url: page.url(), title }));
+});
+program
+    .command('close')
+    .description('Close the current browser session')
+    .option('--platform <platform>', 'Platform to close', 'default')
+    .action(async (opts) => {
+    await closeBrowser(opts.platform);
+    console.log(JSON.stringify({ ok: true }));
+});
+// ─── Status ───────────────────────────────────────────────────────────────────
 program
     .command('status')
-    .description('Show veil status and saved sessions')
+    .description('Show veil status')
     .action(async () => {
     const { listSessions } = await import('./session.js');
     const { isFlareSolverrUp } = await import('./local-captcha.js');
     const sessions = await listSessions();
     const flare = await isFlareSolverrUp();
-    console.log(chalk.cyan('\n🕶️  veil v0.1.0\n'));
-    console.log(`  Sessions:     ${sessions.length > 0 ? chalk.bold.green(sessions.join(', ')) : chalk.gray('none')}`);
-    console.log(`  FlareSolverr: ${flare ? chalk.green('running') : chalk.gray('not running')}`);
-    console.log(`  MCP:          ${chalk.gray('veil serve --port 3456')}`);
+    console.log(chalk.cyan('\n🕶️  veil v0.2.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('');
+    console.log(chalk.gray('  Quick reference:'));
+    console.log(chalk.gray('    veil login x        # save X session'));
+    console.log(chalk.gray('    veil open x         # restore X session'));
+    console.log(chalk.gray('    veil go <url>       # navigate'));
+    console.log(chalk.gray('    veil snapshot       # read current page'));
+    console.log(chalk.gray('    veil click <sel>    # click element'));
+    console.log(chalk.gray('    veil type <sel> <text>'));
+    console.log(chalk.gray('    veil read [sel]     # extract text'));
+    console.log(chalk.gray('    veil shot           # screenshot'));
     console.log('');
 });
-// Boot FlareSolverr in background on any command
-veilStartup();
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veil-browser",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Stealth browser CLI for AI agents — bypass bot detection, persist sessions, local CAPTCHA solving, MCP server",
   "keywords": [
     "browser",
@@ -31,7 +31,8 @@
   },
   "files": [
     "dist/**/*",
-    "README.md"
+    "README.md",
+    "SKILL.md"
   ],
   "dependencies": {
     "chalk": "^5.3.0",