webpeel 0.7.0 → 0.7.1

package/dist/cli.js

@@ -16,7 +16,7 @@ import { Command } from 'commander';
 import ora from 'ora';
 import { writeFileSync, readFileSync } from 'fs';
 import { peel, peelBatch, cleanup } from './index.js';
-import { checkUsage, showUsageFooter, handleLogin, handleLogout, handleUsage, loadConfig } from './cli-auth.js';
+import { checkUsage, showUsageFooter, handleLogin, handleLogout, handleUsage, loadConfig, saveConfig } from './cli-auth.js';
 import { getCache, setCache, parseTTL, clearCache, cacheStats } from './cache.js';
 const program = new Command();
 // Read version from package.json dynamically
@@ -35,9 +35,39 @@ program
     .description('Fast web fetcher for AI agents')
     .version(cliVersion)
     .enablePositionalOptions();
+// Check for updates (non-blocking, runs in background)
+async function checkForUpdates() {
+    try {
+        const res = await fetch('https://registry.npmjs.org/webpeel/latest', {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!res.ok)
+            return;
+        const data = await res.json();
+        const latest = data.version;
+        if (latest && latest !== cliVersion && cliVersion !== '0.0.0') {
+            console.error(`\n💡 WebPeel v${latest} available (you have v${cliVersion}). Update: npm i -g webpeel@latest\n`);
+        }
+    }
+    catch { /* silently ignore — don't slow down the user */ }
+}
+// Fire and forget — don't await, don't block
+void checkForUpdates();
 /**
  * Parse action strings into PageAction array
- * Format: "type:value" where type is wait|click|scroll|type|fill|press|hover|waitFor
+ * Formats:
+ *   click:.selector         — click an element
+ *   type:.selector=text     — type text into an input
+ *   fill:.selector=text     — fill an input (replaces existing value)
+ *   scroll:down:500         — scroll direction + amount
+ *   scroll:bottom           — scroll to bottom (legacy)
+ *   scroll:top              — scroll to top (legacy)
+ *   wait:2000               — wait N ms
+ *   press:Enter             — press a keyboard key
+ *   hover:.selector         — hover over an element
+ *   waitFor:.selector       — wait for a selector to appear
+ *   select:.selector=value  — select dropdown option
+ *   screenshot              — take a screenshot
  */
 function parseActions(actionStrings) {
     return actionStrings.map(str => {
@@ -48,8 +78,25 @@ function parseActions(actionStrings) {
                 return { type: 'wait', ms: parseInt(value) || 1000 };
             case 'click':
                 return { type: 'click', selector: value };
-            case 'scroll':
-                return { type: 'scroll', to: value === 'top' ? 'top' : value === 'bottom' ? 'bottom' : parseInt(value) };
+            case 'scroll': {
+                // scroll:down:500  or  scroll:bottom  or  scroll:500
+                const parts = value.split(':');
+                const dir = parts[0];
+                if (dir === 'top' || dir === 'bottom') {
+                    return { type: 'scroll', to: dir };
+                }
+                if (dir === 'down' || dir === 'up' || dir === 'left' || dir === 'right') {
+                    const amount = parseInt(parts[1] || '500', 10);
+                    return { type: 'scroll', direction: dir, amount };
+                }
+                // Bare number: absolute position
+                const num = parseInt(dir, 10);
+                if (!isNaN(num)) {
+                    return { type: 'scroll', to: num };
+                }
+                // Default: scroll to bottom
+                return { type: 'scroll', to: 'bottom' };
+            }
             case 'type': {
                 const [sel, ...text] = value.split('=');
                 return { type: 'type', selector: sel, value: text.join('=') };
@@ -58,12 +105,18 @@ function parseActions(actionStrings) {
                 const [sel, ...text] = value.split('=');
                 return { type: 'fill', selector: sel, value: text.join('=') };
             }
+            case 'select': {
+                const [sel, ...vals] = value.split('=');
+                return { type: 'select', selector: sel, value: vals.join('=') };
+            }
             case 'press':
                 return { type: 'press', key: value };
             case 'hover':
                 return { type: 'hover', selector: value };
             case 'waitFor':
                 return { type: 'waitForSelector', selector: value };
+            case 'screenshot':
+                return { type: 'screenshot' };
             default:
                 throw new Error(`Unknown action type: ${type}`);
         }
@@ -334,6 +387,26 @@ program
         }
         if (error instanceof Error) {
             console.error(`\nError: ${error.message}`);
+            // Provide actionable hints based on error type
+            const msg = error.message.toLowerCase();
+            if (msg.includes('timeout') || msg.includes('timed out')) {
+                console.error('\n💡 Hint: Try --render for JS-heavy sites, or --wait 5000 to wait longer.');
+            }
+            else if (msg.includes('blocked') || msg.includes('403') || msg.includes('cloudflare')) {
+                console.error('\n💡 Hint: Try --stealth to bypass bot detection (uses more credits).');
+            }
+            else if (msg.includes('enotfound') || msg.includes('getaddrinfo')) {
+                console.error('\n💡 Hint: Could not resolve hostname. Check the URL is correct.');
+            }
+            else if (msg.includes('econnrefused') || msg.includes('econnreset')) {
+                console.error('\n💡 Hint: Connection refused. The site may be down or blocking requests.');
+            }
+            else if (msg.includes('certificate') || msg.includes('ssl') || msg.includes('tls')) {
+                console.error('\n💡 Hint: SSL/TLS error. The site may have an invalid certificate.');
+            }
+            else if (msg.includes('usage') || msg.includes('quota') || msg.includes('limit')) {
+                console.error('\n💡 Hint: Run `webpeel usage` to check your quota, or `webpeel login` to authenticate.');
+            }
         }
         else {
             console.error('\nError: Unknown error occurred');
@@ -345,8 +418,10 @@ program
 // Search command
 program
     .command('search <query>')
-    .description('Search using DuckDuckGo')
+    .description('Search the web (DuckDuckGo by default, or Brave with --provider brave)')
     .option('-n, --count <n>', 'Number of results (1-10)', '5')
+    .option('--provider <provider>', 'Search provider: duckduckgo (default) or brave')
+    .option('--search-api-key <key>', 'API key for the search provider (or env WEBPEEL_BRAVE_API_KEY)')
     .option('--json', 'Output as JSON')
     .option('-s, --silent', 'Silent mode')
     .action(async (query, options) => {
@@ -361,61 +436,21 @@ program
     }
     const spinner = isSilent ? null : ora('Searching...').start();
     try {
-        // Import the search function dynamically
-        const { fetch: undiciFetch } = await import('undici');
-        const { load } = await import('cheerio');
-        const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-        const response = await undiciFetch(searchUrl, {
-            headers: {
-                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Search failed: HTTP ${response.status}`);
-        }
-        const html = await response.text();
-        const $ = load(html);
-        const results = [];
-        $('.result').each((_i, elem) => {
-            if (results.length >= count)
-                return;
-            const $result = $(elem);
-            const title = $result.find('.result__title').text().trim();
-            const rawUrl = $result.find('.result__a').attr('href') || '';
-            const snippet = $result.find('.result__snippet').text().trim();
-            if (!title || !rawUrl)
-                return;
-            // Extract actual URL from DuckDuckGo redirect
-            let url = rawUrl;
-            try {
-                const ddgUrl = new URL(rawUrl, 'https://duckduckgo.com');
-                const uddg = ddgUrl.searchParams.get('uddg');
-                if (uddg) {
-                    url = decodeURIComponent(uddg);
-                }
-            }
-            catch {
-                // Use raw URL if parsing fails
-            }
-            // Validate final URL
-            try {
-                const parsed = new URL(url);
-                if (!['http:', 'https:'].includes(parsed.protocol)) {
-                    return;
-                }
-                url = parsed.href;
-            }
-            catch {
-                return;
-            }
-            results.push({
-                title: title.slice(0, 200),
-                url,
-                snippet: snippet.slice(0, 500)
-            });
+        const { getSearchProvider } = await import('./core/search-provider.js');
+        // Resolve provider
+        const providerId = (options.provider || 'duckduckgo');
+        const config = loadConfig();
+        const apiKey = options.searchApiKey
+            || process.env.WEBPEEL_BRAVE_API_KEY
+            || config.braveApiKey
+            || undefined;
+        const provider = getSearchProvider(providerId);
+        const results = await provider.searchWeb(query, {
+            count: Math.min(Math.max(count, 1), 10),
+            apiKey,
         });
         if (spinner) {
-            spinner.succeed(`Found ${results.length} results`);
+            spinner.succeed(`Found ${results.length} results (${providerId})`);
         }
         // Show usage footer for free/anonymous users
         if (usageCheck.usageInfo && !isSilent) {
@@ -447,6 +482,14 @@ program
         }
         if (error instanceof Error) {
             console.error(`\nError: ${error.message}`);
+            const msg = error.message.toLowerCase();
+            if (msg.includes('brave') && msg.includes('api key')) {
+                console.error('\n💡 Hint: Set your Brave API key: webpeel config set braveApiKey YOUR_KEY');
+                console.error('   Or use free DuckDuckGo search (default, no key needed).');
+            }
+            else if (msg.includes('timeout') || msg.includes('timed out')) {
+                console.error('\n💡 Hint: Search timed out. Try a more specific query or try again.');
+            }
         }
         else {
             console.error('\nError: Unknown error occurred');
@@ -787,21 +830,34 @@ program
     .action(async () => {
     await import('./mcp/server.js');
 });
-// Config command
+// Config command  —  webpeel config [get|set] [key] [value]
 program
     .command('config')
     .description('View or update CLI configuration')
-    .argument('[key]', 'Config key to get or set')
+    .argument('[action]', '"get <key>", "set <key> <value>", or omit for overview')
+    .argument('[key]', 'Config key')
     .argument('[value]', 'Value to set')
-    .action(async (key, value) => {
+    .action(async (action, key, value) => {
     const config = loadConfig();
-    if (!key) {
+    // Settable config keys (safe for user modification)
+    const SETTABLE_KEYS = {
+        braveApiKey: 'Brave Search API key',
+    };
+    const maskSecret = (k, v) => {
+        if (!v)
+            return '(not set)';
+        if (k === 'apiKey' || k === 'braveApiKey')
+            return v.slice(0, 4) + '...' + v.slice(-4);
+        return String(v);
+    };
+    if (!action) {
         // Show all config
         console.log('WebPeel CLI Configuration');
         console.log(`  Config file: ~/.webpeel/config.json`);
         console.log('');
-        console.log(`  apiKey:     ${config.apiKey ? config.apiKey.slice(0, 7) + '...' + config.apiKey.slice(-4) : '(not set)'}`);
-        console.log(`  planTier:   ${config.planTier || 'free'}`);
+        console.log(`  apiKey:         ${maskSecret('apiKey', config.apiKey)}`);
+        console.log(`  braveApiKey:    ${maskSecret('braveApiKey', config.braveApiKey)}`);
+        console.log(`  planTier:       ${config.planTier || 'free'}`);
         console.log(`  anonymousUsage: ${config.anonymousUsage}`);
         const stats = cacheStats();
         console.log('');
@@ -809,21 +865,52 @@ program
         console.log(`    entries:  ${stats.entries}`);
         console.log(`    size:     ${(stats.sizeBytes / 1024).toFixed(1)} KB`);
         console.log(`    dir:      ${stats.dir}`);
+        console.log('');
+        console.log('  Settable keys: ' + Object.keys(SETTABLE_KEYS).join(', '));
+        console.log('  Usage: webpeel config set <key> <value>');
         process.exit(0);
     }
-    if (key && !value) {
-        // Get a specific key
-        const val = config[key];
+    if (action === 'set') {
+        if (!key) {
+            console.error('Usage: webpeel config set <key> <value>');
+            console.error('Settable keys: ' + Object.keys(SETTABLE_KEYS).join(', '));
+            process.exit(1);
+        }
+        if (!(key in SETTABLE_KEYS)) {
+            console.error(`Cannot set "${key}". Settable keys: ${Object.keys(SETTABLE_KEYS).join(', ')}`);
+            process.exit(1);
+        }
+        if (!value) {
+            console.error(`Usage: webpeel config set ${key} <value>`);
+            process.exit(1);
+        }
+        config[key] = value;
+        saveConfig(config);
+        console.log(`✓ ${key} saved`);
+        process.exit(0);
+    }
+    if (action === 'get') {
+        const lookupKey = key || '';
+        const val = config[lookupKey];
         if (val !== undefined) {
-            console.log(key === 'apiKey' && val ? val.slice(0, 7) + '...' + val.slice(-4) : val);
+            console.log(maskSecret(lookupKey, String(val)));
         }
         else {
-            console.error(`Unknown config key: ${key}`);
+            console.error(`Unknown config key: ${lookupKey}`);
             process.exit(1);
         }
+        process.exit(0);
+    }
+    // Legacy: `webpeel config <key>` — treat action as the key name
+    const val = config[action];
+    if (val !== undefined) {
+        console.log(maskSecret(action, String(val)));
+    }
+    else {
+        console.error(`Unknown config key or action: ${action}`);
+        console.error('Usage: webpeel config [get|set] [key] [value]');
+        process.exit(1);
     }
-    // Note: Setting config values directly is not supported for security
-    // Use `webpeel login` for API key, plan is fetched from server
     process.exit(0);
 });
 // Cache management command
@@ -1058,10 +1145,121 @@ program
         process.exit(1);
     }
 });
-// Jobs command - list active jobs
+// Jobs command - search job boards (LinkedIn, Indeed, Glassdoor)
 program
-    .command('jobs')
-    .description('List active jobs (crawl, batch)')
+    .command('jobs <keywords>')
+    .description('Search job boards for listings (LinkedIn, Indeed, Glassdoor)')
+    .option('-l, --location <location>', 'Location filter')
+    .option('-s, --source <source>', 'Job board: glassdoor, indeed, or linkedin (default: linkedin)', 'linkedin')
+    .option('-n, --limit <number>', 'Max results (default: 25)', '25')
+    .option('-d, --details <number>', 'Fetch full details for top N results (default: 0)', '0')
+    .option('--json', 'Output raw JSON')
+    .option('--timeout <ms>', 'Request timeout in ms (default: 30000)', '30000')
+    .option('--silent', 'Silent mode (no spinner)')
+    .action(async (keywords, options) => {
+    const spinner = options.silent ? null : ora('Searching jobs...').start();
+    try {
+        const { searchJobs } = await import('./core/jobs.js');
+        const source = (['glassdoor', 'indeed', 'linkedin'].includes(options.source) ? options.source : 'linkedin');
+        const limit = Math.min(Math.max(parseInt(options.limit, 10) || 25, 1), 100);
+        const fetchDetails = Math.min(Math.max(parseInt(options.details, 10) || 0, 0), limit);
+        const timeout = parseInt(options.timeout, 10) || 30000;
+        const result = await searchJobs({
+            keywords,
+            location: options.location,
+            source,
+            limit,
+            fetchDetails,
+            timeout,
+        });
+        if (spinner)
+            spinner.stop();
+        // --json: raw output
+        if (options.json) {
+            await writeStdout(JSON.stringify(result, null, 2) + '\n');
+            process.exit(0);
+        }
+        // Formatted table output
+        const totalLabel = result.totalFound >= 1000
+            ? `${(result.totalFound / 1000).toFixed(0).replace(/\.0$/, '')}k+`
+            : String(result.totalFound);
+        const locationLabel = options.location ? ` in ${options.location}` : '';
+        console.log(`\n🔍 Found ${totalLabel} ${keywords} jobs${locationLabel} (${result.source})\n`);
+        if (result.jobs.length === 0) {
+            console.log('  No jobs found.\n');
+            process.exit(0);
+        }
+        // Column widths
+        const colNum = 3;
+        const colTitle = 40;
+        const colCompany = 18;
+        const colLocation = 16;
+        const colSalary = 14;
+        const colPosted = 10;
+        const pad = (s, w) => s.length > w ? s.slice(0, w - 1) + '…' : s.padEnd(w);
+        const rpad = (s, w) => s.padStart(w);
+        // Header
+        console.log(` ${rpad('#', colNum)}  ${pad('Title', colTitle)}  ${pad('Company', colCompany)}  ${pad('Location', colLocation)}  ${pad('Salary', colSalary)}  ${pad('Posted', colPosted)}`);
+        // Rows
+        result.jobs.forEach((job, i) => {
+            const title = job.title + (job.remote ? ' 🏠' : '');
+            console.log(` ${rpad(String(i + 1), colNum)}  ${pad(title, colTitle)}  ${pad(job.company, colCompany)}  ${pad(job.location, colLocation)}  ${pad(job.salary || '', colSalary)}  ${pad(job.postedAt || '', colPosted)}`);
+        });
+        // Footer
+        const timeSec = (result.timeTakenMs / 1000).toFixed(1);
+        const detailsNote = fetchDetails > 0 ? ` | Details: ${result.detailsFetched} fetched` : '';
+        console.log(`\nFetched ${result.jobs.length} jobs in ${timeSec}s${detailsNote}\n`);
+        // Detailed job cards (when --details > 0)
+        const detailedJobs = result.jobs.filter((j) => 'description' in j);
+        for (let i = 0; i < detailedJobs.length; i++) {
+            const job = detailedJobs[i];
+            console.log(`━━━ Job #${i + 1}: ${job.title} ━━━`);
+            const metaParts = [`Company: ${job.company}`, `Location: ${job.location}`];
+            if (job.salary)
+                metaParts.push(`Salary: ${job.salary}`);
+            console.log(metaParts.join(' | '));
+            const typeParts = [];
+            if (job.employmentType)
+                typeParts.push(`Type: ${job.employmentType}`);
+            if (job.experienceLevel)
+                typeParts.push(`Level: ${job.experienceLevel}`);
+            if (job.postedAt)
+                typeParts.push(`Posted: ${job.postedAt}`);
+            if (typeParts.length > 0)
+                console.log(typeParts.join(' | '));
+            if (job.description) {
+                console.log(`\nDescription:\n  ${job.description.slice(0, 500).replace(/\n/g, '\n  ')}`);
+            }
+            if (job.requirements && job.requirements.length > 0) {
+                console.log(`\nRequirements:`);
+                job.requirements.forEach(r => console.log(`  • ${r}`));
+            }
+            if (job.responsibilities && job.responsibilities.length > 0) {
+                console.log(`\nResponsibilities:`);
+                job.responsibilities.forEach(r => console.log(`  • ${r}`));
+            }
+            if (job.benefits && job.benefits.length > 0) {
+                console.log(`\nBenefits:`);
+                job.benefits.forEach(b => console.log(`  • ${b}`));
+            }
+            if (job.applyUrl) {
+                console.log(`\nApply: ${job.applyUrl}`);
+            }
+            console.log('');
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        if (spinner)
+            spinner.fail('Job search failed');
+        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+// Queue command - list active async jobs (crawl, batch)
+program
+    .command('queue')
+    .description('List active async jobs (crawl, batch)')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     try {
@@ -1079,12 +1277,13 @@ program
         if (!response.ok) {
             throw new Error(`API error: HTTP ${response.status}`);
         }
-        const jobs = await response.json();
+        const data = await response.json();
+        const jobs = data.jobs || data;
         if (options.json) {
-            console.log(JSON.stringify(jobs, null, 2));
+            console.log(JSON.stringify(data, null, 2));
         }
         else {
-            if (jobs.length === 0) {
+            if (!Array.isArray(jobs) || jobs.length === 0) {
                 console.log('No active jobs.');
             }
             else {
@@ -1160,6 +1359,205 @@ program
         process.exit(1);
     }
 });
+// Answer command - search + fetch + LLM-generated answer
+program
+    .command('answer <question>')
+    .description('Ask a question, search the web, and get an AI-generated answer with citations (BYOK)')
+    .option('--provider <provider>', 'Search provider: duckduckgo (default) or brave')
+    .option('--search-api-key <key>', 'Search provider API key (or env WEBPEEL_BRAVE_API_KEY)')
+    .option('--llm <provider>', 'LLM provider: openai, anthropic, or google (required)')
+    .option('--llm-api-key <key>', 'LLM API key (or env OPENAI_API_KEY / ANTHROPIC_API_KEY / GOOGLE_API_KEY)')
+    .option('--llm-model <model>', 'LLM model name (optional, uses provider default)')
+    .option('--max-sources <n>', 'Maximum sources to fetch (1-10, default 5)', '5')
+    .option('--json', 'Output as JSON')
+    .option('-s, --silent', 'Silent mode')
+    .action(async (question, options) => {
+    const spinner = options.silent ? null : ora('Thinking...').start();
+    try {
+        const { answerQuestion } = await import('./core/answer.js');
+        const config = loadConfig();
+        const llmProvider = options.llm;
+        if (!llmProvider || !['openai', 'anthropic', 'google'].includes(llmProvider)) {
+            console.error('Error: --llm is required (openai, anthropic, or google)');
+            process.exit(1);
+        }
+        const llmApiKey = options.llmApiKey
+            || process.env.OPENAI_API_KEY
+            || process.env.ANTHROPIC_API_KEY
+            || process.env.GOOGLE_API_KEY
+            || '';
+        if (!llmApiKey) {
+            console.error('Error: --llm-api-key is required (or set OPENAI_API_KEY / ANTHROPIC_API_KEY / GOOGLE_API_KEY)');
+            process.exit(1);
+        }
+        const searchProvider = (options.provider || 'duckduckgo');
+        const searchApiKey = options.searchApiKey
+            || process.env.WEBPEEL_BRAVE_API_KEY
+            || config.braveApiKey
+            || undefined;
+        const maxSources = Math.min(Math.max(parseInt(options.maxSources) || 5, 1), 10);
+        if (spinner)
+            spinner.text = 'Searching the web...';
+        const result = await answerQuestion({
+            question,
+            searchProvider,
+            searchApiKey,
+            llmProvider,
+            llmApiKey,
+            llmModel: options.llmModel,
+            maxSources,
+            stream: false,
+        });
+        if (spinner)
+            spinner.succeed('Done');
+        if (options.json) {
+            const jsonStr = JSON.stringify(result, null, 2);
+            await new Promise((resolve, reject) => {
+                process.stdout.write(jsonStr + '\n', (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        }
+        else {
+            console.log(`\n${result.answer}`);
+            console.log(`\nSources:`);
+            result.citations.forEach((c, i) => {
+                console.log(`  [${i + 1}] ${c.title}`);
+                console.log(`      ${c.url}`);
+            });
+            console.log(`\nModel: ${result.llmModel} (${result.llmProvider})`);
+        }
+        await cleanup();
+        process.exit(0);
+    }
+    catch (error) {
+        if (spinner)
+            spinner.fail('Answer generation failed');
+        console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        await cleanup();
+        process.exit(1);
+    }
+});
+// Screenshot command
+program
+    .command('screenshot <url>')
+    .description('Take a screenshot of a URL and save as PNG/JPEG')
+    .option('--full-page', 'Capture full page (not just viewport)')
+    .option('--width <px>', 'Viewport width in pixels (default: 1280)', parseInt)
+    .option('--height <px>', 'Viewport height in pixels (default: 720)', parseInt)
+    .option('--format <fmt>', 'Image format: png (default) or jpeg', 'png')
+    .option('--quality <n>', 'JPEG quality 1-100 (ignored for PNG)', parseInt)
+    .option('-w, --wait <ms>', 'Wait time after page load (ms)', parseInt)
+    .option('-t, --timeout <ms>', 'Request timeout (ms)', parseInt, 30000)
+    .option('--stealth', 'Use stealth mode to bypass bot detection')
+    .option('--action <actions...>', 'Page actions before screenshot (e.g., "click:.btn" "wait:2000")')
+    .option('-o, --output <path>', 'Output file path (default: screenshot.png)')
+    .option('-s, --silent', 'Silent mode (no spinner)')
+    .option('--json', 'Output base64 JSON instead of binary file')
+    .action(async (url, options) => {
+    // Validate URL
+    try {
+        const parsed = new URL(url);
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            console.error('Error: Only HTTP and HTTPS protocols are allowed');
+            process.exit(1);
+        }
+    }
+    catch {
+        console.error(`Error: Invalid URL format: ${url}`);
+        process.exit(1);
+    }
+    // Check usage quota
+    const usageCheck = await checkUsage();
+    if (!usageCheck.allowed) {
+        console.error(usageCheck.message);
+        process.exit(1);
+    }
+    const spinner = options.silent ? null : ora('Taking screenshot...').start();
+    try {
+        // Validate format
+        const format = options.format?.toLowerCase();
+        if (format && !['png', 'jpeg', 'jpg'].includes(format)) {
+            console.error('Error: --format must be png, jpeg, or jpg');
+            process.exit(1);
+        }
+        // Parse actions
+        let actions;
+        if (options.action && options.action.length > 0) {
+            try {
+                actions = parseActions(options.action);
+            }
+            catch (e) {
+                console.error(`Error: ${e.message}`);
+                process.exit(1);
+            }
+        }
+        const { takeScreenshot } = await import('./core/screenshot.js');
+        const result = await takeScreenshot(url, {
+            fullPage: options.fullPage || false,
+            width: options.width,
+            height: options.height,
+            format: format || 'png',
+            quality: options.quality,
+            waitFor: options.wait,
+            timeout: options.timeout,
+            stealth: options.stealth || false,
+            actions,
+        });
+        if (spinner) {
+            spinner.succeed(`Screenshot taken (${result.format})`);
+        }
+        // Show usage footer for free/anonymous users
+        if (usageCheck.usageInfo && !options.silent) {
+            showUsageFooter(usageCheck.usageInfo, usageCheck.isAnonymous || false, true);
+        }
+        if (options.json) {
+            // Output JSON with base64
+            const jsonStr = JSON.stringify({
+                url: result.url,
+                format: result.format,
+                contentType: result.contentType,
+                screenshot: result.screenshot,
+            }, null, 2);
+            await new Promise((resolve, reject) => {
+                process.stdout.write(jsonStr + '\n', (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        }
+        else {
+            // Save to file
+            const ext = result.format === 'jpeg' ? 'jpg' : 'png';
+            const outputPath = options.output || `screenshot.${ext}`;
+            const buffer = Buffer.from(result.screenshot, 'base64');
+            writeFileSync(outputPath, buffer);
+            if (!options.silent) {
+                console.error(`Screenshot saved to: ${outputPath} (${(buffer.length / 1024).toFixed(1)} KB)`);
+            }
+        }
+        await cleanup();
+        process.exit(0);
+    }
+    catch (error) {
+        if (spinner) {
+            spinner.fail('Screenshot failed');
+        }
+        if (error instanceof Error) {
+            console.error(`\nError: ${error.message}`);
+        }
+        else {
+            console.error('\nError: Unknown error occurred');
+        }
+        await cleanup();
+        process.exit(1);
+    }
+});
 program.parse();
 // ============================================================
 // Shared output helper