webpeel 0.9.0 → 0.11.0

package/dist/cli.js

@@ -14,7 +14,8 @@
  */
 import { Command } from 'commander';
 import ora from 'ora';
-import { writeFileSync, readFileSync } from 'fs';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { getProfilePath, loadStorageState, touchProfile, listProfiles, deleteProfile, createProfile } from './core/profiles.js';
 import { peel, peelBatch, cleanup } from './index.js';
 import { checkUsage, showUsageFooter, handleLogin, handleLogout, handleUsage, loadConfig, saveConfig } from './cli-auth.js';
 import { getCache, setCache, parseTTL, clearCache, cacheStats } from './cache.js';
@@ -130,6 +131,7 @@ program
     .argument('[url]', 'URL to fetch')
     .option('-r, --render', 'Use headless browser (for JS-heavy sites)')
     .option('--stealth', 'Use stealth mode to bypass bot detection (auto-enables --render)')
+    .option('--proxy <url>', 'Proxy URL for requests (http://host:port, socks5://user:pass@host:port)')
     .option('-w, --wait <ms>', 'Wait time after page load (ms)', parseInt)
     .option('--html', 'Output raw HTML instead of markdown')
     .option('--text', 'Output plain text instead of markdown')
@@ -154,14 +156,19 @@ program
     .option('--raw', 'Return full page without smart content extraction')
     .option('--action <actions...>', 'Page actions before scraping (e.g., "click:.btn" "wait:2000" "scroll:bottom")')
     .option('--extract <json>', 'Extract structured data using CSS selectors (JSON object of field:selector pairs)')
-    .option('--llm-extract <prompt>', 'AI-powered extraction using LLM (requires OPENAI_API_KEY env var)')
+    .option('--llm-extract [instruction]', 'Extract structured data using LLM (optional instruction, e.g. "extract hotel names and prices")')
+    .option('--extract-schema <schema>', 'JSON schema for structured extraction (requires LLM key). Pass inline JSON or @file.json')
     .option('--llm-key <key>', 'LLM API key for AI features (or use OPENAI_API_KEY env var)')
+    .option('--llm-model <model>', 'LLM model to use (default: gpt-4o-mini)')
+    .option('--llm-base-url <url>', 'LLM API base URL (default: https://api.openai.com/v1)')
     .option('--summary', 'Generate AI summary of content (requires --llm-key or OPENAI_API_KEY)')
     .option('--location <country>', 'ISO country code for geo-targeting (e.g., "US", "DE", "JP")')
     .option('--language <lang>', 'Language preference (e.g., "en", "de", "ja")')
     .option('--max-tokens <n>', 'Maximum token count for output (truncate if exceeded)', parseInt)
     .option('--budget <n>', 'Smart token budget — distill content to fit within N tokens (heuristic, no LLM key needed)', parseInt)
     .option('--extract-all', 'Auto-detect and extract repeated listing items (e.g., search results)')
+    .option('--schema <name>', 'Force a specific extraction schema by name or domain (e.g., "booking.com", "amazon")')
+    .option('--list-schemas', 'List all available extraction schemas and their supported domains')
     .option('--scroll-extract [count]', 'Scroll page N times to load lazy content, then extract (implies --render)', (v) => parseInt(v, 10))
     .option('--csv', 'Output extraction results as CSV')
     .option('--table', 'Output extraction results as a formatted table')
@@ -182,6 +189,31 @@ program
             options.budget = 4000;
     }
     const isJson = options.json;
+    // --- --list-schemas: print all available schemas and exit ---
+    if (options.listSchemas) {
+        const { loadBundledSchemas } = await import('./core/schema-extraction.js');
+        const schemas = loadBundledSchemas();
+        if (isJson) {
+            await writeStdout(JSON.stringify(schemas.map(s => ({
+                name: s.name,
+                version: s.version,
+                domains: s.domains,
+                urlPatterns: s.urlPatterns,
+            })), null, 2) + '\n');
+        }
+        else {
+            console.log(`\nAvailable extraction schemas (${schemas.length}):\n`);
+            for (const s of schemas) {
+                console.log(`  ${s.name} (v${s.version})`);
+                console.log(`    Domains: ${s.domains.join(', ')}`);
+                if (s.urlPatterns && s.urlPatterns.length > 0) {
+                    console.log(`    URL patterns: ${s.urlPatterns.join(', ')}`);
+                }
+                console.log('');
+            }
+        }
+        process.exit(0);
+    }
     // --- #5: Concise error for missing URL (no help dump) ---
     if (!url || url.trim() === '') {
         if (isJson) {
@@ -265,6 +297,49 @@ program
                 cachedResult.content = distillToBudget(cachedResult.content, options.budget, fmt);
                 cachedResult.tokens = Math.ceil(cachedResult.content.length / 4);
             }
+            // LLM extraction from cached content
+            if (options.llmExtract || options.extractSchema) {
+                const { extractWithLLM } = await import('./core/llm-extract.js');
+                const llmCfgCached = loadConfig();
+                const llmApiKeyCached = options.llmKey || llmCfgCached.llm?.apiKey || process.env.OPENAI_API_KEY;
+                if (!llmApiKeyCached) {
+                    console.error('Error: LLM extraction requires an API key.\nSet OPENAI_API_KEY environment variable or use --llm-key <key>');
+                    process.exit(1);
+                }
+                const llmModelCached = options.llmModel || llmCfgCached.llm?.model || process.env.WEBPEEL_LLM_MODEL || 'gpt-4o-mini';
+                const llmBaseUrlCached = options.llmBaseUrl || llmCfgCached.llm?.baseUrl || process.env.WEBPEEL_LLM_BASE_URL || 'https://api.openai.com/v1';
+                const llmInstructionCached = typeof options.llmExtract === 'string' ? options.llmExtract : undefined;
+                // Parse schema if provided
+                let llmSchemaCached;
+                if (options.extractSchema) {
+                    let schemaStr = options.extractSchema;
+                    if (schemaStr.startsWith('@')) {
+                        schemaStr = readFileSync(schemaStr.slice(1), 'utf-8');
+                    }
+                    try {
+                        llmSchemaCached = JSON.parse(schemaStr);
+                    }
+                    catch {
+                        console.error('Error: --extract-schema must be valid JSON or a valid @file.json path');
+                        process.exit(1);
+                    }
+                }
+                const llmResultCached = await extractWithLLM({
+                    content: cachedResult.content,
+                    instruction: llmInstructionCached,
+                    schema: llmSchemaCached,
+                    apiKey: llmApiKeyCached,
+                    model: llmModelCached,
+                    baseUrl: llmBaseUrlCached,
+                });
+                await writeStdout(JSON.stringify(llmResultCached.items, null, 2) + '\n');
+                if (!options.silent) {
+                    const { input, output } = llmResultCached.tokensUsed;
+                    const costStr = llmResultCached.cost !== undefined ? ` | Est. cost: $${llmResultCached.cost.toFixed(6)}` : '';
+                    console.error(`\n🤖 LLM extraction: ${llmResultCached.items.length} items | ${input} input + ${output} output tokens${costStr} | model: ${llmResultCached.model}`);
+                }
+                process.exit(0);
+            }
             await outputResult(cachedResult, options, { cached: true });
             process.exit(0);
         }
@@ -299,19 +374,22 @@ program
                 throw Object.assign(new Error(e.message), { _code: 'FETCH_FAILED' });
             }
         }
+        // --extract-schema auto-enables JSON output
+        if (options.extractSchema) {
+            options.json = true;
+        }
         // Parse extract
         let extract;
-        if (options.llmExtract) {
-            // LLM-based extraction
-            extract = {
-                prompt: options.llmExtract,
-                llmApiKey: process.env.OPENAI_API_KEY,
-                llmModel: process.env.WEBPEEL_LLM_MODEL || 'gpt-4o-mini',
-                llmBaseUrl: process.env.WEBPEEL_LLM_BASE_URL || 'https://api.openai.com/v1',
-            };
-            if (!extract.llmApiKey) {
-                throw Object.assign(new Error('--llm-extract requires OPENAI_API_KEY environment variable'), { _code: 'FETCH_FAILED' });
+        if (options.llmExtract || options.extractSchema) {
+            // LLM-based extraction is handled post-fetch (after peel returns markdown).
+            // Early-validate that an API key is available so we fail fast.
+            const llmCfg = loadConfig();
+            const llmApiKey = options.llmKey || llmCfg.llm?.apiKey || process.env.OPENAI_API_KEY;
+            if (!llmApiKey) {
+                throw Object.assign(new Error('LLM extraction requires an API key.\n' +
+                    'Set OPENAI_API_KEY environment variable or use --llm-key <key>'), { _code: 'FETCH_FAILED' });
             }
+            // Do NOT set extract here — peel runs normally, LLM extraction happens below.
         }
         else if (options.extract) {
             // CSS-based extraction
@@ -351,6 +429,26 @@ program
                 locationOptions.languages = [options.language];
             }
         }
+        // ── Resolve --profile: name → path + storage state ─────────────────
+        let resolvedProfileDir;
+        let resolvedStorageState;
+        let resolvedProfileName;
+        if (options.profile) {
+            const profilePath = getProfilePath(options.profile);
+            if (profilePath) {
+                // It's a named profile in ~/.webpeel/profiles/
+                resolvedProfileDir = profilePath;
+                resolvedStorageState = loadStorageState(options.profile) ?? undefined;
+                resolvedProfileName = options.profile;
+            }
+            else if (existsSync(options.profile)) {
+                // It's a raw directory path (backward compat)
+                resolvedProfileDir = options.profile;
+            }
+            else {
+                exitWithJsonError(`Profile "${options.profile}" not found. Run "webpeel profile list" to see available profiles.`, 'PROFILE_NOT_FOUND');
+            }
+        }
         // Build peel options
         // --stealth auto-enables --render (stealth requires browser)
         // --action auto-enables --render (actions require browser)
@@ -391,8 +489,10 @@ program
             extract,
             images: options.images || false,
             location: locationOptions,
-            profileDir: options.profile || undefined,
+            profileDir: resolvedProfileDir,
             headed: options.headed || false,
+            storageState: resolvedStorageState,
+            proxy: options.proxy,
         };
         // Add summary option if requested
         if (options.summary) {
@@ -419,6 +519,10 @@ program
         }
         // Fetch the page
         const result = await peel(url, peelOptions);
+        // Update lastUsed timestamp for named profiles
+        if (resolvedProfileName) {
+            touchProfile(resolvedProfileName);
+        }
         if (spinner) {
             spinner.succeed(`Fetched in ${result.elapsed}ms using ${result.method} method`);
         }
@@ -477,19 +581,92 @@ program
                 console.error(`⚠ ${warningMsg}`);
             }
         }
+        // --- LLM-based extraction (post-peel) ---
+        if (options.llmExtract || options.extractSchema) {
+            const { extractWithLLM } = await import('./core/llm-extract.js');
+            const llmCfg = loadConfig();
+            const llmApiKey = options.llmKey || llmCfg.llm?.apiKey || process.env.OPENAI_API_KEY;
+            const llmModel = options.llmModel || llmCfg.llm?.model || process.env.WEBPEEL_LLM_MODEL || 'gpt-4o-mini';
+            const llmBaseUrl = options.llmBaseUrl || llmCfg.llm?.baseUrl || process.env.WEBPEEL_LLM_BASE_URL || 'https://api.openai.com/v1';
+            const llmInstruction = typeof options.llmExtract === 'string' ? options.llmExtract : undefined;
+            // Parse --extract-schema if provided
+            let llmSchema;
+            if (options.extractSchema) {
+                let schemaStr = options.extractSchema;
+                if (schemaStr.startsWith('@')) {
+                    schemaStr = readFileSync(schemaStr.slice(1), 'utf-8');
+                }
+                try {
+                    llmSchema = JSON.parse(schemaStr);
+                }
+                catch {
+                    exitWithJsonError('--extract-schema must be valid JSON or a valid @file.json path', 'FETCH_FAILED');
+                }
+            }
+            const llmResult = await extractWithLLM({
+                content: result.content,
+                instruction: llmInstruction,
+                schema: llmSchema,
+                apiKey: llmApiKey,
+                model: llmModel,
+                baseUrl: llmBaseUrl,
+            });
+            // Output structured items as JSON
+            await writeStdout(JSON.stringify(llmResult.items, null, 2) + '\n');
+            // Show token usage and estimated cost
+            if (!options.silent) {
+                const { input, output } = llmResult.tokensUsed;
+                const costStr = llmResult.cost !== undefined
+                    ? ` | Est. cost: $${llmResult.cost.toFixed(6)}`
+                    : '';
+                console.error(`\n🤖 LLM extraction: ${llmResult.items.length} items | ${input} input + ${output} output tokens${costStr} | model: ${llmResult.model}`);
+            }
+            await cleanup();
+            process.exit(0);
+        }
         // --- Extract-all / pagination / output formatting ---
         const wantsExtractAll = options.extractAll || options.scrollExtract !== undefined;
         const pagesCount = Math.min(Math.max(options.pages || 1, 1), 10);
         if (wantsExtractAll) {
             const { extractListings } = await import('./core/extract-listings.js');
             const { findNextPageUrl } = await import('./core/paginate.js');
+            const { findSchemaForUrl, extractWithSchema, loadBundledSchemas } = await import('./core/schema-extraction.js');
+            // Resolve which schema to use (explicit --schema flag or auto-detect)
+            let activeSchema = null;
+            if (options.schema) {
+                // Find schema by name or domain match
+                const schemaQuery = options.schema.toLowerCase();
+                const allSchemas = loadBundledSchemas();
+                activeSchema = allSchemas.find(s => s.name.toLowerCase().includes(schemaQuery) ||
+                    s.domains.some(d => d.toLowerCase().includes(schemaQuery))) ?? null;
+                if (!activeSchema && !options.silent) {
+                    console.error(`Warning: No schema found for "${options.schema}", falling back to auto-detection`);
+                }
+            }
+            else {
+                // Auto-detect from URL
+                activeSchema = findSchemaForUrl(result.url || url);
+            }
             // We need the raw HTML for extraction. Re-fetch with format=html if needed.
             let allListings = [];
             // Fetch HTML for extraction
             const htmlResult = peelOptions.format === 'html'
                 ? result
                 : await peel(url, { ...peelOptions, format: 'html', maxTokens: undefined });
-            allListings.push(...extractListings(htmlResult.content, result.url));
+            // Try schema extraction first, fall back to generic
+            if (activeSchema) {
+                const schemaListings = extractWithSchema(htmlResult.content, activeSchema, result.url);
+                if (schemaListings.length > 0) {
+                    allListings.push(...schemaListings);
+                }
+                else {
+                    // Schema returned nothing — fall back to generic
+                    allListings.push(...extractListings(htmlResult.content, result.url));
+                }
+            }
+            else {
+                allListings.push(...extractListings(htmlResult.content, result.url));
+            }
             // Pagination: follow "Next" links
             if (pagesCount > 1) {
                 let currentHtml = htmlResult.content;
@@ -500,7 +677,16 @@ program
                         break;
                     try {
                         const nextResult = await peel(nextUrl, { ...peelOptions, format: 'html', maxTokens: undefined });
-                        const pageListings = extractListings(nextResult.content, nextResult.url);
+                        let pageListings;
+                        if (activeSchema) {
+                            const schemaPage = extractWithSchema(nextResult.content, activeSchema, nextResult.url);
+                            pageListings = schemaPage.length > 0
+                                ? schemaPage
+                                : extractListings(nextResult.content, nextResult.url);
+                        }
+                        else {
+                            pageListings = extractListings(nextResult.content, nextResult.url);
+                        }
                         allListings.push(...pageListings);
                         currentHtml = nextResult.content;
                         currentUrl = nextResult.url;
@@ -658,7 +844,18 @@ program
     .option('--csv', 'Output site-search results as CSV (requires --site)')
     .option('--budget <n>', 'Token budget for site-search result content', parseInt)
     .option('-s, --silent', 'Silent mode')
+    .option('--proxy <url>', 'Proxy URL for requests (http://host:port, socks5://user:pass@host:port)')
+    .option('--agent', 'Agent mode: sets --json, --silent, and --budget 4000 (override with --budget N)')
     .action(async (query, options) => {
+    // --agent sets sensible defaults for AI agents; explicit flags override
+    if (options.agent) {
+        if (!options.json)
+            options.json = true;
+        if (!options.silent)
+            options.silent = true;
+        if (options.budget === undefined)
+            options.budget = 4000;
+    }
     const isJson = options.json;
     const isSilent = options.silent;
     // --top overrides --count when both are provided
@@ -679,6 +876,7 @@ program
             const htmlResult = await peel(siteResult.url, {
                 format: 'html',
                 timeout: 30000,
+                proxy: options.proxy,
             });
             if (spinner) {
                 spinner.succeed(`Fetched ${siteResult.site} in ${htmlResult.elapsed}ms`);
@@ -773,10 +971,24 @@ program
             || config.braveApiKey
             || undefined;
         const provider = getSearchProvider(providerId);
-        const results = await provider.searchWeb(query, {
+        let results = await provider.searchWeb(query, {
             count: Math.min(Math.max(count, 1), 10),
             apiKey,
         });
+        // Apply budget to search results if requested (trim results to fit token budget)
+        if (options.budget && options.budget > 0 && results.length > 0) {
+            let totalTokens = 0;
+            let maxResults = 0;
+            for (const r of results) {
+                // Estimate ~4 chars per token for title + url + snippet
+                const resultTokens = Math.ceil((`${r.title || ''}\n${r.url || ''}\n${r.snippet || ''}`).length / 4);
+                if (totalTokens + resultTokens > options.budget)
+                    break;
+                totalTokens += resultTokens;
+                maxResults++;
+            }
+            results = results.slice(0, Math.max(maxResults, 1));
+        }
         if (spinner) {
             spinner.succeed(`Found ${results.length} results (${providerId})`);
         }
@@ -1370,24 +1582,52 @@ program
 program
     .command('config')
     .description('View or update CLI configuration')
-    .argument('[action]', '"get <key>", "set <key> <value>", or omit for overview')
+    .argument('[action]', '"list", "get <key>", "set <key> <value>", or omit for overview')
     .argument('[key]', 'Config key')
     .argument('[value]', 'Value to set')
     .action(async (action, key, value) => {
     const config = loadConfig();
     // Settable config keys (safe for user modification)
+    // Supports dot-notation for nested keys (e.g., llm.apiKey)
     const SETTABLE_KEYS = {
         braveApiKey: 'Brave Search API key',
+        'llm.apiKey': 'LLM API key for AI-powered extraction (OpenAI-compatible)',
+        'llm.model': 'LLM model name (default: gpt-4o-mini)',
+        'llm.baseUrl': 'LLM API base URL (default: https://api.openai.com/v1)',
     };
     const maskSecret = (k, v) => {
         if (!v)
             return '(not set)';
-        if (k === 'apiKey' || k === 'braveApiKey')
+        if (k === 'apiKey' || k === 'braveApiKey' || k === 'llm.apiKey') {
             return v.slice(0, 4) + '...' + v.slice(-4);
+        }
         return String(v);
     };
-    if (!action) {
-        // Show all config
+    /** Get a potentially nested value using dot-notation (e.g., "llm.apiKey") */
+    function getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let cur = obj;
+        for (const part of parts) {
+            if (cur == null || typeof cur !== 'object')
+                return undefined;
+            cur = cur[part];
+        }
+        return cur;
+    }
+    /** Set a potentially nested value using dot-notation (e.g., "llm.apiKey") */
+    function setNestedValue(obj, path, val) {
+        const parts = path.split('.');
+        let cur = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (cur[part] == null || typeof cur[part] !== 'object')
+                cur[part] = {};
+            cur = cur[part];
+        }
+        cur[parts[parts.length - 1]] = val;
+    }
+    if (!action || action === 'list') {
+        // Show all config (also triggered by `webpeel config list`)
         console.log('WebPeel CLI Configuration');
         console.log(`  Config file: ~/.webpeel/config.json`);
         console.log('');
@@ -1395,6 +1635,11 @@ program
         console.log(`  braveApiKey:    ${maskSecret('braveApiKey', config.braveApiKey)}`);
         console.log(`  planTier:       ${config.planTier || 'free'}`);
         console.log(`  anonymousUsage: ${config.anonymousUsage}`);
+        console.log('');
+        console.log('  LLM:');
+        console.log(`    llm.apiKey:   ${maskSecret('llm.apiKey', config.llm?.apiKey)}`);
+        console.log(`    llm.model:    ${config.llm?.model || '(not set, default: gpt-4o-mini)'}`);
+        console.log(`    llm.baseUrl:  ${config.llm?.baseUrl || '(not set, default: https://api.openai.com/v1)'}`);
         const stats = cacheStats();
         console.log('');
         console.log('  Cache:');
@@ -1420,14 +1665,14 @@ program
             console.error(`Usage: webpeel config set ${key} <value>`);
             process.exit(1);
         }
-        config[key] = value;
+        setNestedValue(config, key, value);
         saveConfig(config);
         console.log(`✓ ${key} saved`);
         process.exit(0);
     }
     if (action === 'get') {
         const lookupKey = key || '';
-        const val = config[lookupKey];
+        const val = getNestedValue(config, lookupKey) ?? config[lookupKey];
         if (val !== undefined) {
             console.log(maskSecret(lookupKey, String(val)));
         }
@@ -1438,7 +1683,7 @@ program
         process.exit(0);
     }
     // Legacy: `webpeel config <key>` — treat action as the key name
-    const val = config[action];
+    const val = getNestedValue(config, action) ?? config[action];
     if (val !== undefined) {
         console.log(maskSecret(action, String(val)));
     }
@@ -2635,6 +2880,244 @@ applyCmd
         process.exit(1);
     }
 });
+// ============================================================
+// Profile management commands
+// ============================================================
+const profileCmd = program
+    .command('profile')
+    .description('Manage named browser profiles (saved login sessions)');
+profileCmd
+    .command('create <name>')
+    .description('Create a new profile interactively (launches browser, log in, press Ctrl+C when done)')
+    .option('--description <text>', 'Optional description for this profile')
+    .action(async (name, opts) => {
+    try {
+        await createProfile(name, opts.description);
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});
+profileCmd
+    .command('list')
+    .description('List all saved browser profiles')
+    .action(() => {
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+        console.log('No profiles found.');
+        console.log('');
+        console.log('Create one with:');
+        console.log('  webpeel profile create <name>');
+        console.log('');
+        console.log('Then use it with:');
+        console.log('  webpeel <url> --profile <name>');
+        process.exit(0);
+    }
+    console.log('');
+    console.log('Saved profiles:');
+    console.log('');
+    // Column widths
+    const nameW = Math.max(8, ...profiles.map((p) => p.name.length));
+    const domainsW = Math.max(10, ...profiles.map((p) => (p.domains.join(', ') || '(none)').length));
+    const header = 'Name'.padEnd(nameW) + '  ' +
+        'Domains'.padEnd(domainsW) + '  ' +
+        'Last Used'.padEnd(12) + '  ' +
+        'Created';
+    console.log(header);
+    console.log('─'.repeat(header.length + 4));
+    for (const p of profiles) {
+        const domainsStr = p.domains.length > 0 ? p.domains.join(', ') : '(none)';
+        const lastUsed = formatRelativeTime(new Date(p.lastUsed));
+        const created = new Date(p.created).toISOString().split('T')[0];
+        console.log(p.name.padEnd(nameW) + '  ' +
+            domainsStr.padEnd(domainsW) + '  ' +
+            lastUsed.padEnd(12) + '  ' +
+            created);
+    }
+    console.log('');
+    process.exit(0);
+});
+profileCmd
+    .command('show <name>')
+    .description('Show details for a profile')
+    .action((name) => {
+    const profilePath = getProfilePath(name);
+    if (!profilePath) {
+        console.error(`Error: Profile "${name}" not found.`);
+        console.error('Run "webpeel profile list" to see available profiles.');
+        process.exit(1);
+    }
+    try {
+        const meta = JSON.parse(readFileSync(`${profilePath}/metadata.json`, 'utf-8'));
+        console.log('');
+        console.log(`Profile: ${meta.name}`);
+        if (meta.description)
+            console.log(`Description: ${meta.description}`);
+        console.log(`Created:     ${new Date(meta.created).toLocaleString()}`);
+        console.log(`Last used:   ${new Date(meta.lastUsed).toLocaleString()}`);
+        console.log(`Domains:     ${meta.domains.length > 0 ? meta.domains.join(', ') : '(none)'}`);
+        console.log(`Directory:   ${profilePath}`);
+        console.log('');
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(`Error reading profile: ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+    }
+});
+profileCmd
+    .command('delete <name>')
+    .description('Delete a saved profile')
+    .action((name) => {
+    const deleted = deleteProfile(name);
+    if (deleted) {
+        console.log(`Profile "${name}" deleted.`);
+        process.exit(0);
+    }
+    else {
+        console.error(`Error: Profile "${name}" not found.`);
+        console.error('Run "webpeel profile list" to see available profiles.');
+        process.exit(1);
+    }
+});
+// ── Hotels command ─────────────────────────────────────────────────────────────
+program
+    .command('hotels <destination>')
+    .description('Search multiple travel sites for hotels (Kayak, Booking.com, Google Travel)')
+    .option('--checkin <date>', 'Check-in date (ISO or relative, e.g. "tomorrow", "2026-02-20"). Default: tomorrow')
+    .option('--checkout <date>', 'Check-out date (ISO or relative). Default: checkin + 1 day')
+    .option('--sort <method>', 'Sort by: price, rating, value (default: price)', 'price')
+    .option('--limit <n>', 'Max results (default: 20)', '20')
+    .option('--source <name...>', 'Only use specific source(s): kayak, booking, google (repeatable)')
+    .option('--json', 'Output as JSON')
+    .option('--stealth', 'Use stealth mode for all sources')
+    .option('--proxy <url>', 'Proxy URL for requests (http://host:port, socks5://user:pass@host:port)')
+    .option('-s, --silent', 'Suppress progress messages')
+    .action(async (destination, options) => {
+    const isJson = options.json;
+    const isSilent = options.silent;
+    // Build checkin/checkout
+    const { parseDate, addDays: hotelAddDays } = await import('./core/hotel-search.js');
+    let checkinStr;
+    let checkoutStr;
+    try {
+        checkinStr = parseDate(options.checkin ?? 'tomorrow');
+        checkoutStr = options.checkout
+            ? parseDate(options.checkout)
+            : hotelAddDays(checkinStr, 1);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (isJson) {
+            await writeStdout(JSON.stringify({ error: msg, code: 'INVALID_DATE' }) + '\n');
+        }
+        else {
+            console.error(`Error: ${msg}`);
+        }
+        process.exit(1);
+    }
+    const sortMethod = (['price', 'rating', 'value'].includes(options.sort)
+        ? options.sort
+        : 'price');
+    const limit = Math.max(1, parseInt(options.limit, 10) || 20);
+    const sources = options.source
+        ? (Array.isArray(options.source) ? options.source : [options.source])
+        : undefined;
+    // Spinner per-source progress (non-silent, non-JSON)
+    let searchSpinner = null;
+    if (!isSilent && !isJson) {
+        searchSpinner = ora(`Searching hotels in ${destination}...`).start();
+    }
+    else if (!isSilent && !isJson) {
+        console.error(`⏳ Searching kayak.com...`);
+        console.error(`⏳ Searching booking.com...`);
+        console.error(`⏳ Searching google.com...`);
+    }
+    try {
+        const { searchHotels } = await import('./core/hotel-search.js');
+        const result = await searchHotels({
+            destination,
+            checkin: checkinStr,
+            checkout: checkoutStr,
+            sort: sortMethod,
+            limit,
+            sources,
+            stealth: options.stealth,
+            silent: isSilent,
+            proxy: options.proxy,
+        });
+        if (searchSpinner)
+            searchSpinner.stop();
+        // Show per-source status
+        if (!isSilent && !isJson) {
+            for (const src of result.sources) {
+                if (src.status === 'ok') {
+                    console.error(`✅ ${src.name}: ${src.count} hotels found`);
+                }
+                else {
+                    console.error(`❌ ${src.name}: ${src.status}${src.error ? ' — ' + src.error : ''}`);
+                }
+            }
+        }
+        if (isJson) {
+            await writeStdout(JSON.stringify(result, null, 2) + '\n');
+            await cleanup();
+            process.exit(0);
+        }
+        // Human-readable table output
+        const { formatDate: fmtDate } = {
+            formatDate: (iso) => {
+                const d = new Date(iso + 'T12:00:00Z');
+                return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' });
+            },
+        };
+        const ci = fmtDate(result.checkin);
+        const co = fmtDate(result.checkout);
+        console.log(`\n🏨 Hotels in ${result.destination}`);
+        console.log(`   ${ci} → ${co} | Sorted by ${sortMethod}\n`);
+        if (result.results.length === 0) {
+            console.log('   No hotels found.\n');
+        }
+        else {
+            const colNum = 3;
+            const colName = 42;
+            const colPrice = 8;
+            const colRating = 8;
+            const colSource = 10;
+            const padEnd = (s, w) => s.length > w ? s.slice(0, w - 1) + '…' : s.padEnd(w);
+            const padStart = (s, w) => s.padStart(w);
+            console.log(` ${padStart('#', colNum)}  ${padEnd('Hotel', colName)}  ${padEnd('Price', colPrice)}  ${padEnd('Rating', colRating)}  ${padEnd('Source', colSource)}`);
+            result.results.forEach((hotel, i) => {
+                const priceStr = hotel.priceDisplay || '—';
+                const ratingStr = hotel.rating !== null ? String(hotel.rating) : '—';
+                console.log(` ${padStart(String(i + 1), colNum)}  ${padEnd(hotel.name, colName)}  ${padEnd(priceStr, colPrice)}  ${padEnd(ratingStr, colRating)}  ${padEnd(hotel.source, colSource)}`);
+            });
+            console.log('');
+            const sourceSummary = result.sources
+                .map(s => `${s.name} (${s.count} ${s.status === 'ok' ? '✅' : s.status === 'blocked' ? '🚫' : '❌'})`)
+                .join(' | ');
+            console.log(`Sources: ${sourceSummary}`);
+        }
+        console.log('');
+        await cleanup();
+        process.exit(0);
+    }
+    catch (error) {
+        if (searchSpinner)
+            searchSpinner.fail('Hotel search failed');
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        if (isJson) {
+            await writeStdout(JSON.stringify({ error: msg, code: 'FETCH_FAILED' }) + '\n');
+        }
+        else {
+            console.error(`\nError: ${msg}`);
+        }
+        await cleanup();
+        process.exit(1);
+    }
+});
 program.parse();
 // ============================================================
 // Time formatting helper