veil-browser 0.1.4 → 0.1.6

package/dist/ai.d.ts

@@ -1,4 +1,5 @@
 import type { Page } from 'playwright';
+import { humanDelay } from './browser.js';
 interface ActionStep {
     action: 'click' | 'type' | 'press' | 'navigate' | 'wait' | 'scroll' | 'select';
     selector?: string;
@@ -9,6 +10,14 @@ interface ActionStep {
     ms?: number;
     description?: string;
 }
+interface LLMConfig {
+    provider: 'openai' | 'anthropic' | 'openrouter' | 'ollama';
+    apiKey?: string;
+    model: string;
+    baseUrl?: string;
+}
+declare function getActionsFromLLM(instruction: string, snapshot: string, pageUrl: string, llm: LLMConfig): Promise<ActionStep[]>;
+declare function executeStep(page: Page, step: ActionStep): Promise<void>;
 export declare function aiAct(page: Page, instruction: string, opts?: {
     verbose?: boolean;
 }): Promise<{
@@ -16,4 +25,4 @@ export declare function aiAct(page: Page, instruction: string, opts?: {
     steps: ActionStep[];
     error?: string;
 }>;
-export {};
+export { getActionsFromLLM, executeStep, humanDelay };

package/dist/ai.js

@@ -228,6 +228,10 @@ Return JSON array of action steps:`;
 }
 // Execute a single action step with X-specific handling
 async function executeStep(page, step) {
+    // Validate before executing
+    if (step.action === 'navigate' && !step.url) {
+        throw new Error('navigate requires url parameter');
+    }
     switch (step.action) {
         case 'click': {
             if (!step.selector)
@@ -303,7 +307,18 @@ export async function aiAct(page, instruction, opts = {}) {
         const pageUrl = page.url();
         spinner.text = '🧠 Asking AI what to do...';
         // 2. Get action steps from LLM
-        const steps = await getActionsFromLLM(instruction, snapshot, pageUrl, 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:'));
@@ -332,3 +347,4 @@ export async function aiAct(page, instruction, opts = {}) {
         return { success: false, steps: [], error: err.message };
     }
 }
+export { getActionsFromLLM, executeStep, humanDelay };

package/dist/commands/daemon.d.ts

@@ -0,0 +1,16 @@
+import { Page } from 'playwright';
+export interface DaemonConfig {
+    instruction: string;
+    interval: number;
+    platform: 'x' | 'linkedin' | 'reddit' | 'bluesky';
+    maxRuns?: number;
+    stopOn?: string[];
+}
+/**
+ * Run veil in daemon mode — continuously execute actions at intervals
+ */
+export declare function daemonCommand(config: DaemonConfig, executeAction: (page: Page, instruction: string) => Promise<void>): Promise<void>;
+/**
+ * Parse daemon CLI args
+ */
+export declare function parseDaemonArgs(args: Record<string, any>): DaemonConfig | null;

package/dist/commands/daemon.js

@@ -0,0 +1,124 @@
+import chalk from 'chalk';
+import ora from 'ora';
+/**
+ * Run veil in daemon mode — continuously execute actions at intervals
+ */
+export async function daemonCommand(config, executeAction) {
+    const { instruction, interval, platform, maxRuns = Infinity, stopOn = [] } = config;
+    let runCount = 0;
+    let errors = 0;
+    const startTime = new Date();
+    console.log(chalk.cyan(`\n🤖 veil daemon started`));
+    console.log(chalk.gray(`   Instruction: ${instruction}`));
+    console.log(chalk.gray(`   Interval: ${interval}m`));
+    console.log(chalk.gray(`   Platform: ${platform}`));
+    console.log(chalk.gray(`   Max runs: ${maxRuns === Infinity ? '∞' : maxRuns}`));
+    console.log(chalk.gray(`   Ctrl+C to stop\n`));
+    const intervalMs = interval * 60 * 1000;
+    // Graceful shutdown handler
+    const shutdown = (sig) => {
+        console.log(chalk.yellow(`\n⏹️  ${sig} received, shutting down gracefully...`));
+        console.log(chalk.green(`\n✅ Daemon stopped`));
+        console.log(chalk.gray(`   Runs: ${runCount}`));
+        console.log(chalk.gray(`   Errors: ${errors}`));
+        console.log(chalk.gray(`   Duration: ${Math.round((Date.now() - startTime.getTime()) / 1000)}s`));
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    // Run loop
+    const runLoop = async () => {
+        while (runCount < maxRuns) {
+            const spinner = ora({
+                text: `Run ${runCount + 1}/${maxRuns === Infinity ? '∞' : maxRuns}`,
+                color: 'cyan',
+            }).start();
+            try {
+                // Import browser here to keep session fresh
+                const { chromium } = await import('playwright');
+                const browser = await chromium.launch({
+                    headless: true,
+                    args: ['--disable-blink-features=AutomationControlled'],
+                });
+                const context = await browser.newContext();
+                const page = await context.newPage();
+                // Navigate to platform home first
+                const platformUrls = {
+                    x: 'https://x.com/home',
+                    twitter: 'https://twitter.com/home',
+                    linkedin: 'https://www.linkedin.com/feed',
+                    reddit: 'https://www.reddit.com',
+                    bluesky: 'https://bsky.app',
+                };
+                const startUrl = platformUrls[platform];
+                if (startUrl) {
+                    await page.goto(startUrl, { waitUntil: 'domcontentloaded' }).catch(() => { });
+                    // Wait for page to settle
+                    await new Promise(r => setTimeout(r, 2000));
+                }
+                try {
+                    await executeAction(page, instruction);
+                    runCount++;
+                    spinner.succeed(chalk.green(`✅ Run ${runCount} succeeded`));
+                    errors = 0; // Reset error counter on success
+                }
+                catch (err) {
+                    errors++;
+                    const errMsg = err.message ?? String(err);
+                    if (stopOn.some(pattern => errMsg.includes(pattern))) {
+                        spinner.fail(chalk.red(`Run ${runCount + 1} failed: ${errMsg}`));
+                        console.log(chalk.red(`\n⛔ Stop condition triggered: ${errMsg}`));
+                        process.exit(1);
+                    }
+                    if (errors > 3) {
+                        spinner.fail(chalk.red(`Run ${runCount + 1} failed (3rd error in a row)`));
+                        console.log(chalk.red(`\n⛔ Too many consecutive errors, stopping.`));
+                        process.exit(1);
+                    }
+                    spinner.warn(chalk.yellow(`Run ${runCount + 1} failed: ${errMsg}`));
+                    spinner.text = `Retrying in ${interval}m...`;
+                }
+                finally {
+                    await page.close().catch(() => { });
+                    await context.close().catch(() => { });
+                    await browser.close().catch(() => { });
+                }
+            }
+            catch (fatalErr) {
+                spinner.fail(chalk.red(`Fatal error: ${fatalErr.message}`));
+                console.log(chalk.red(`\n⛔ Daemon stopped due to fatal error`));
+                process.exit(1);
+            }
+            // Wait before next run
+            if (runCount < maxRuns) {
+                spinner.start(`Next run in ${interval}m...`);
+                await new Promise(resolve => setTimeout(resolve, intervalMs));
+                spinner.stop();
+            }
+        }
+        // Reached max runs
+        console.log(chalk.green(`\n✅ Completed ${maxRuns} runs`));
+        process.exit(0);
+    };
+    await runLoop();
+}
+/**
+ * Parse daemon CLI args
+ */
+export function parseDaemonArgs(args) {
+    if (!args.daemon)
+        return null;
+    const instruction = args._?.[0];
+    if (!instruction) {
+        console.error(chalk.red('Error: instruction required'));
+        console.error(chalk.gray('Usage: veil daemon <instruction> --interval 5 --platform x [--max-runs 10]'));
+        process.exit(1);
+    }
+    return {
+        instruction,
+        interval: parseInt(args.interval ?? '5', 10),
+        platform: args.platform ?? 'x',
+        maxRuns: args.maxRuns ? parseInt(args.maxRuns, 10) : Infinity,
+        stopOn: args.stopOn ? (Array.isArray(args.stopOn) ? args.stopOn : [args.stopOn]) : [],
+    };
+}

package/dist/index.js

@@ -115,6 +115,36 @@ program
     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 || [],
+    };
+    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')

package/package.json

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