recker 1.0.30 → 1.0.32-next.e0741bf

package/dist/cli/index.js

@@ -450,7 +450,7 @@ ${colors.bold(colors.yellow('Checks:'))}
                     images: report.images,
                     openGraph: report.social.openGraph,
                     twitterCard: report.social.twitterCard,
-                    jsonLd: report.jsonLd,
+                    structuredData: report.structuredData,
                     technical: report.technical,
                     checks: report.checks,
                     summary: {
@@ -520,8 +520,8 @@ ${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray
                 }
             }
             console.log('');
-            if (report.jsonLd.count > 0) {
-                console.log(`${colors.bold('Structured Data:')} ${report.jsonLd.types.join(', ') || 'Present'}`);
+            if (report.structuredData.count > 0) {
+                console.log(`${colors.bold('Structured Data:')} ${report.structuredData.types.join(', ') || 'Present'}`);
                 console.log('');
             }
         }
@@ -531,139 +531,904 @@ ${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray
         }
     });
     program
-        .command('spider')
-        .description('Crawl a website following internal links')
-        .argument('<url>', 'Starting URL to crawl')
-        .option('-d, --depth <n>', 'Maximum depth to crawl', '5')
-        .option('-l, --limit <n>', 'Maximum pages to crawl', '100')
-        .option('-c, --concurrency <n>', 'Concurrent requests', '5')
-        .option('--delay <ms>', 'Delay between requests in ms', '100')
+        .command('robots')
+        .description('Validate and analyze robots.txt file')
+        .argument('<url>', 'Website URL or direct robots.txt URL')
         .option('--format <format>', 'Output format: text (default) or json', 'text')
-        .option('-o, --output <file>', 'Write JSON results to file')
         .addHelpText('after', `
 ${colors.bold(colors.yellow('Examples:'))}
-  ${colors.green('$ rek spider example.com')}                    ${colors.gray('Crawl with defaults')}
-  ${colors.green('$ rek spider example.com -d 3 -l 50')}         ${colors.gray('Depth 3, max 50 pages')}
-  ${colors.green('$ rek spider example.com --format json')}      ${colors.gray('Output as JSON')}
-  ${colors.green('$ rek spider example.com -o results.json')}    ${colors.gray('Save to file')}
+  ${colors.green('$ rek robots example.com')}                ${colors.gray('Validate robots.txt')}
+  ${colors.green('$ rek robots example.com/robots.txt')}     ${colors.gray('Direct URL')}
+  ${colors.green('$ rek robots example.com --format json')}  ${colors.gray('JSON output')}
 
-${colors.bold(colors.yellow('Options:'))}
-  ${colors.cyan('--depth, -d')}       Max link depth to follow (default: 5)
-  ${colors.cyan('--limit, -l')}       Max pages to crawl (default: 100)
-  ${colors.cyan('--concurrency, -c')} Parallel requests (default: 5)
-  ${colors.cyan('--delay')}           Ms between requests (default: 100)
+${colors.bold(colors.yellow('Checks:'))}
+  ${colors.cyan('Syntax')}              Valid robots.txt syntax
+  ${colors.cyan('User-Agent blocks')}   Defined crawl rules
+  ${colors.cyan('Sitemap')}             Sitemap directive present
+  ${colors.cyan('Crawl-delay')}         Aggressive crawl delay
+  ${colors.cyan('AI Bots')}             GPTBot, ClaudeBot, Anthropic blocks
 `)
         .action(async (url, options) => {
         if (!url.startsWith('http'))
             url = `https://${url}`;
+        if (!url.includes('robots.txt')) {
+            const urlObj = new URL(url);
+            url = `${urlObj.origin}/robots.txt`;
+        }
         const isJson = options.format === 'json';
-        const maxDepth = parseInt(options.depth || '5', 10);
-        const maxPages = parseInt(options.limit || '100', 10);
-        const concurrency = parseInt(options.concurrency || '5', 10);
-        const delay = parseInt(options.delay || '100', 10);
-        const { Spider } = await import('../scrape/spider.js');
         if (!isJson) {
-            console.log(colors.gray(`\nCrawling ${url}...`));
-            console.log(colors.gray(`  Depth: ${maxDepth}, Limit: ${maxPages}, Concurrency: ${concurrency}\n`));
+            console.log(colors.gray(`Fetching robots.txt from ${url}...`));
         }
         try {
-            const startTime = performance.now();
-            const spider = new Spider({
-                maxDepth,
-                maxPages,
-                concurrency,
-                delay,
-                onProgress: (progress) => {
-                    if (!isJson) {
-                        process.stdout.write(`\r${colors.cyan('⟳')} Crawled: ${colors.bold(String(progress.crawled))} | Queued: ${progress.queued} | Current: ${colors.gray(progress.currentUrl.slice(0, 50))}...`);
+            const { fetchAndValidateRobotsTxt } = await import('../seo/validators/robots.js');
+            const result = await fetchAndValidateRobotsTxt(url);
+            if (isJson) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(`
+${colors.bold(colors.cyan('🤖 Robots.txt Analysis'))}
+${colors.gray('URL:')} ${url}
+${colors.gray('Valid:')} ${result.valid ? colors.green('Yes') : colors.red('No')}
+`);
+            if (result.parseResult) {
+                const { parseResult } = result;
+                if (parseResult.userAgentBlocks.length > 0) {
+                    console.log(colors.bold('User-Agent Blocks:'));
+                    for (const block of parseResult.userAgentBlocks.slice(0, 5)) {
+                        const agents = block.userAgents.join(', ');
+                        const allowCount = block.rules.filter(r => r.type === 'allow').length;
+                        const disallowCount = block.rules.filter(r => r.type === 'disallow').length;
+                        console.log(`  ${colors.cyan(agents)}`);
+                        console.log(`    ${colors.green(`Allow: ${allowCount}`)} | ${colors.red(`Disallow: ${disallowCount}`)}`);
                     }
-                },
-            });
-            const result = await spider.crawl(url);
-            const duration = Math.round(performance.now() - startTime);
-            if (!isJson) {
-                process.stdout.write('\r' + ' '.repeat(100) + '\r');
+                    if (parseResult.userAgentBlocks.length > 5) {
+                        console.log(colors.gray(`  ... and ${parseResult.userAgentBlocks.length - 5} more blocks`));
+                    }
+                    console.log('');
+                }
+                if (parseResult.sitemaps.length > 0) {
+                    console.log(colors.bold('Sitemaps:'));
+                    for (const sitemap of parseResult.sitemaps.slice(0, 3)) {
+                        console.log(`  ${colors.gray('→')} ${sitemap}`);
+                    }
+                    if (parseResult.sitemaps.length > 3) {
+                        console.log(colors.gray(`  ... and ${parseResult.sitemaps.length - 3} more`));
+                    }
+                    console.log('');
+                }
+                const aiAgents = ['gptbot', 'chatgpt-user', 'claudebot', 'claude-web', 'anthropic-ai', 'ccbot'];
+                const blockedAiBots = [];
+                for (const block of parseResult.userAgentBlocks) {
+                    for (const agent of block.userAgents) {
+                        if (aiAgents.includes(agent.toLowerCase())) {
+                            const hasBlockAll = block.rules.some(r => r.type === 'disallow' && (r.path === '/' || r.path === '/*'));
+                            if (hasBlockAll) {
+                                blockedAiBots.push(agent);
+                            }
+                        }
+                    }
+                }
+                if (blockedAiBots.length > 0) {
+                    console.log(colors.bold('AI Bots Blocked:'));
+                    for (const bot of blockedAiBots) {
+                        console.log(`  ${colors.red('✗')} ${bot}`);
+                    }
+                    console.log('');
+                }
             }
-            if (isJson || options.output) {
-                const jsonOutput = {
-                    startUrl: result.startUrl,
-                    crawledAt: new Date().toISOString(),
-                    duration,
-                    summary: {
-                        totalPages: result.pages.length,
-                        successCount: result.pages.filter(p => !p.error).length,
-                        errorCount: result.errors.length,
-                        uniqueUrls: result.visited.size,
-                    },
-                    pages: result.pages.map(p => ({
-                        url: p.url,
-                        status: p.status,
-                        title: p.title,
-                        depth: p.depth,
-                        linksCount: p.links.length,
-                        duration: p.duration,
-                        error: p.error,
-                    })),
-                    errors: result.errors,
-                };
-                if (options.output) {
-                    await fs.writeFile(options.output, JSON.stringify(jsonOutput, null, 2));
-                    console.log(colors.green(`✓ Results saved to ${options.output}`));
+            if (result.issues.length > 0) {
+                console.log(colors.bold('Issues:'));
+                for (const issue of result.issues) {
+                    const icon = issue.type === 'error' ? colors.red('✗')
+                        : issue.type === 'warning' ? colors.yellow('⚠')
+                            : colors.gray('ℹ');
+                    console.log(`  ${icon} ${issue.message}`);
+                }
+                console.log('');
+            }
+            const errorCount = result.issues.filter(i => i.type === 'error').length;
+            const warningCount = result.issues.filter(i => i.type === 'warning').length;
+            if (errorCount === 0 && warningCount === 0) {
+                console.log(colors.green('✔ No issues found'));
+            }
+            else {
+                console.log(`${colors.red(`${errorCount} errors`)} | ${colors.yellow(`${warningCount} warnings`)}`);
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`Robots.txt analysis failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('sitemap')
+        .description('Validate and analyze sitemap.xml file')
+        .argument('<url>', 'Website URL or direct sitemap URL')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .option('--discover', 'Discover all sitemaps via robots.txt')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek sitemap example.com')}                  ${colors.gray('Validate sitemap')}
+  ${colors.green('$ rek sitemap example.com/sitemap.xml')}      ${colors.gray('Direct URL')}
+  ${colors.green('$ rek sitemap example.com --discover')}       ${colors.gray('Find all sitemaps')}
+  ${colors.green('$ rek sitemap example.com --format json')}    ${colors.gray('JSON output')}
+
+${colors.bold(colors.yellow('Checks:'))}
+  ${colors.cyan('Structure')}      Valid XML sitemap format
+  ${colors.cyan('URL Count')}      Within 50,000 URL limit
+  ${colors.cyan('File Size')}      Within 50MB limit
+  ${colors.cyan('URLs')}           Valid, no duplicates, same domain
+  ${colors.cyan('Lastmod')}        Valid dates, not in future
+`)
+        .action(async (url, options) => {
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const isJson = options.format === 'json';
+        try {
+            if (options.discover) {
+                const { discoverSitemaps } = await import('../seo/validators/sitemap.js');
+                if (!isJson) {
+                    console.log(colors.gray(`Discovering sitemaps for ${new URL(url).origin}...`));
                 }
+                const sitemaps = await discoverSitemaps(url);
                 if (isJson) {
-                    console.log(JSON.stringify(jsonOutput, null, 2));
+                    console.log(JSON.stringify({ url, sitemaps }, null, 2));
                     return;
                 }
+                console.log(`
+${colors.bold(colors.cyan('🗺️ Sitemap Discovery'))}
+${colors.gray('Site:')} ${new URL(url).origin}
+${colors.gray('Found:')} ${sitemaps.length} sitemap(s)
+`);
+                if (sitemaps.length > 0) {
+                    for (const sitemap of sitemaps) {
+                        console.log(`  ${colors.gray('→')} ${sitemap}`);
+                    }
+                }
+                else {
+                    console.log(colors.yellow('  No sitemaps found in robots.txt or common locations'));
+                }
+                return;
             }
-            console.log(`${colors.bold(colors.cyan('🕷️ Spider Crawl Complete'))}`);
-            console.log(`${colors.gray('URL:')} ${url}`);
-            console.log(`${colors.gray('Duration:')} ${(duration / 1000).toFixed(1)}s`);
-            console.log('');
-            const successCount = result.pages.filter(p => !p.error).length;
-            console.log(`${colors.bold('Summary:')}`);
-            console.log(`  ${colors.green('✓')} Pages crawled: ${colors.bold(String(successCount))}`);
-            console.log(`  ${colors.red('✗')} Errors: ${colors.bold(String(result.errors.length))}`);
-            console.log(`  ${colors.gray('○')} Unique URLs: ${result.visited.size}`);
-            console.log('');
-            const byDepth = new Map();
-            for (const page of result.pages) {
-                byDepth.set(page.depth, (byDepth.get(page.depth) || 0) + 1);
+            if (!url.includes('sitemap')) {
+                const urlObj = new URL(url);
+                url = `${urlObj.origin}/sitemap.xml`;
             }
-            console.log(`${colors.bold('Pages by Depth:')}`);
-            for (const [depth, count] of [...byDepth.entries()].sort((a, b) => a[0] - b[0])) {
-                console.log(`  ${colors.gray(`Depth ${depth}:`)} ${count} pages`);
+            if (!isJson) {
+                console.log(colors.gray(`Fetching sitemap from ${url}...`));
             }
-            console.log('');
-            if (result.errors.length > 0) {
-                console.log(`${colors.bold(colors.red('Errors:'))}`);
-                for (const err of result.errors.slice(0, 10)) {
-                    const shortUrl = err.url.replace(url, '');
-                    const statusMatch = err.error.match(/status code (\d+)/);
-                    const errorMsg = statusMatch ? `HTTP ${statusMatch[1]}` : err.error.slice(0, 50);
-                    console.log(`  ${colors.red('✗')} ${colors.gray(shortUrl || '/')} → ${errorMsg}`);
+            const { fetchAndValidateSitemap } = await import('../seo/validators/sitemap.js');
+            const result = await fetchAndValidateSitemap(url);
+            if (isJson) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(`
+${colors.bold(colors.cyan('🗺️ Sitemap Analysis'))}
+${colors.gray('URL:')} ${url}
+${colors.gray('Valid:')} ${result.valid ? colors.green('Yes') : colors.red('No')}
+${colors.gray('Type:')} ${result.parseResult?.type === 'sitemapindex' ? 'Sitemap Index' : 'URL Set'}
+`);
+            if (result.parseResult) {
+                const { parseResult } = result;
+                if (parseResult.type === 'sitemapindex') {
+                    console.log(colors.bold(`Sitemaps: ${parseResult.sitemaps?.length || 0}`));
+                    for (const sm of (parseResult.sitemaps || []).slice(0, 5)) {
+                        console.log(`  ${colors.gray('→')} ${sm.loc}`);
+                        if (sm.lastmod) {
+                            console.log(`    ${colors.gray(`Last modified: ${sm.lastmod}`)}`);
+                        }
+                    }
+                    if ((parseResult.sitemaps?.length || 0) > 5) {
+                        console.log(colors.gray(`  ... and ${parseResult.sitemaps.length - 5} more`));
+                    }
                 }
-                if (result.errors.length > 10) {
-                    console.log(`  ${colors.gray(`  ... and ${result.errors.length - 10} more`)}`);
+                else {
+                    console.log(colors.bold(`URLs: ${parseResult.urls?.length || 0}`));
+                    const sampleUrls = (parseResult.urls || []).slice(0, 5);
+                    for (const entry of sampleUrls) {
+                        const path = new URL(entry.loc).pathname;
+                        console.log(`  ${colors.gray('→')} ${path}`);
+                    }
+                    if ((parseResult.urls?.length || 0) > 5) {
+                        console.log(colors.gray(`  ... and ${parseResult.urls.length - 5} more URLs`));
+                    }
+                    const urlsWithLastmod = (parseResult.urls || []).filter(u => u.lastmod).length;
+                    const urlsWithPriority = (parseResult.urls || []).filter(u => u.priority !== undefined).length;
+                    const urlsWithChangefreq = (parseResult.urls || []).filter(u => u.changefreq).length;
+                    console.log('');
+                    console.log(colors.bold('Statistics:'));
+                    console.log(`  ${colors.gray('With lastmod:')}     ${urlsWithLastmod} (${((urlsWithLastmod / (parseResult.urls?.length || 1)) * 100).toFixed(0)}%)`);
+                    console.log(`  ${colors.gray('With priority:')}    ${urlsWithPriority} (${((urlsWithPriority / (parseResult.urls?.length || 1)) * 100).toFixed(0)}%)`);
+                    console.log(`  ${colors.gray('With changefreq:')}  ${urlsWithChangefreq} (${((urlsWithChangefreq / (parseResult.urls?.length || 1)) * 100).toFixed(0)}%)`);
                 }
                 console.log('');
             }
-            const successPages = result.pages.filter(p => !p.error).slice(0, 10);
-            if (successPages.length > 0) {
-                console.log(`${colors.bold('Sample Pages:')}`);
-                for (const page of successPages) {
-                    const shortUrl = page.url.replace(url, '');
-                    console.log(`  ${colors.green('✓')} ${colors.gray((shortUrl || '/').padEnd(40))} ${page.title.slice(0, 40)}`);
+            if (result.issues.length > 0) {
+                console.log(colors.bold('Issues:'));
+                for (const issue of result.issues.slice(0, 10)) {
+                    const icon = issue.type === 'error' ? colors.red('✗')
+                        : issue.type === 'warning' ? colors.yellow('⚠')
+                            : colors.gray('ℹ');
+                    console.log(`  ${icon} ${issue.message}`);
                 }
-                if (result.pages.length > 10) {
-                    console.log(`  ${colors.gray(`  ... and ${result.pages.length - 10} more`)}`);
+                if (result.issues.length > 10) {
+                    console.log(colors.gray(`  ... and ${result.issues.length - 10} more issues`));
                 }
+                console.log('');
+            }
+            const errorCount = result.issues.filter(i => i.type === 'error').length;
+            const warningCount = result.issues.filter(i => i.type === 'warning').length;
+            if (errorCount === 0 && warningCount === 0) {
+                console.log(colors.green('✔ No issues found'));
+            }
+            else {
+                console.log(`${colors.red(`${errorCount} errors`)} | ${colors.yellow(`${warningCount} warnings`)}`);
             }
         }
+        catch (error) {
+            console.error(colors.red(`Sitemap analysis failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('llms')
+        .description('Validate and analyze llms.txt file (AI/LLM optimization)')
+        .argument('[url]', 'Website URL or direct llms.txt URL')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .option('--template', 'Generate a template llms.txt file')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek llms example.com')}                ${colors.gray('Validate llms.txt')}
+  ${colors.green('$ rek llms example.com/llms.txt')}       ${colors.gray('Direct URL')}
+  ${colors.green('$ rek llms example.com --format json')}  ${colors.gray('JSON output')}
+  ${colors.green('$ rek llms --template > llms.txt')}      ${colors.gray('Generate template')}
+
+${colors.bold(colors.yellow('About llms.txt:'))}
+  A proposed standard for providing LLM-friendly content.
+  Similar to robots.txt but for AI/LLM crawlers.
+  Learn more: ${colors.cyan('https://llmstxt.org')}
+
+${colors.bold(colors.yellow('Checks:'))}
+  ${colors.cyan('Structure')}    Valid llms.txt format
+  ${colors.cyan('Site Name')}    Primary heading present
+  ${colors.cyan('Description')} Site description block
+  ${colors.cyan('Sections')}     Content sections with links
+`)
+        .action(async (url, options) => {
+        const isJson = options.format === 'json';
+        if (options.template) {
+            const { generateLlmsTxtTemplate } = await import('../seo/validators/llms-txt.js');
+            const template = generateLlmsTxtTemplate({
+                siteName: 'Your Site Name',
+                siteDescription: 'A brief description of your website and what it offers.',
+                sections: [
+                    {
+                        title: 'Documentation',
+                        links: [
+                            { text: 'Getting Started', url: '/docs/getting-started' },
+                            { text: 'API Reference', url: '/docs/api' },
+                        ],
+                    },
+                    {
+                        title: 'Resources',
+                        links: [
+                            { text: 'Blog', url: '/blog' },
+                            { text: 'FAQ', url: '/faq' },
+                        ],
+                    },
+                ],
+            });
+            console.log(template);
+            return;
+        }
+        if (!url) {
+            console.error(colors.red('URL is required (use --template to generate a template)'));
+            process.exit(1);
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        if (!url.includes('llms.txt')) {
+            const urlObj = new URL(url);
+            url = `${urlObj.origin}/llms.txt`;
+        }
+        if (!isJson) {
+            console.log(colors.gray(`Fetching llms.txt from ${url}...`));
+        }
+        try {
+            const { fetchAndValidateLlmsTxt } = await import('../seo/validators/llms-txt.js');
+            const result = await fetchAndValidateLlmsTxt(url);
+            if (isJson) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            if (!result.exists) {
+                console.log(`
+${colors.bold(colors.cyan('📄 llms.txt Analysis'))}
+${colors.gray('URL:')} ${url}
+${colors.red('Status:')} File not found
+
+${colors.yellow('Recommendation:')}
+  Consider creating an llms.txt file to help AI/LLM systems
+  better understand your site's content and structure.
+
+  Use ${colors.cyan('rek llms --template')} to generate a starting template.
+  Learn more: ${colors.cyan('https://llmstxt.org')}
+`);
+                return;
+            }
+            console.log(`
+${colors.bold(colors.cyan('📄 llms.txt Analysis'))}
+${colors.gray('URL:')} ${url}
+${colors.gray('Valid:')} ${result.valid ? colors.green('Yes') : colors.red('No')}
+`);
+            if (result.parseResult) {
+                const { parseResult } = result;
+                if (parseResult.siteName) {
+                    console.log(`${colors.bold('Site Name:')} ${parseResult.siteName}`);
+                }
+                if (parseResult.siteDescription) {
+                    const desc = parseResult.siteDescription.length > 100
+                        ? parseResult.siteDescription.slice(0, 97) + '...'
+                        : parseResult.siteDescription;
+                    console.log(`${colors.bold('Description:')} ${colors.gray(desc)}`);
+                }
+                console.log('');
+                if (parseResult.sections.length > 0) {
+                    console.log(colors.bold(`Sections: ${parseResult.sections.length}`));
+                    for (const section of parseResult.sections) {
+                        const linkCount = parseResult.links.filter(l => true).length;
+                        console.log(`  ${colors.cyan('##')} ${section.title}`);
+                    }
+                    console.log('');
+                }
+                if (parseResult.links.length > 0) {
+                    console.log(colors.bold(`Links: ${parseResult.links.length}`));
+                    for (const link of parseResult.links.slice(0, 5)) {
+                        console.log(`  ${colors.gray('→')} [${link.text}](${link.url})`);
+                    }
+                    if (parseResult.links.length > 5) {
+                        console.log(colors.gray(`  ... and ${parseResult.links.length - 5} more links`));
+                    }
+                    console.log('');
+                }
+            }
+            if (result.issues.length > 0) {
+                console.log(colors.bold('Issues:'));
+                for (const issue of result.issues) {
+                    const icon = issue.type === 'error' ? colors.red('✗')
+                        : issue.type === 'warning' ? colors.yellow('⚠')
+                            : colors.gray('ℹ');
+                    console.log(`  ${icon} ${issue.message}`);
+                }
+                console.log('');
+            }
+            const errorCount = result.issues.filter(i => i.type === 'error').length;
+            const warningCount = result.issues.filter(i => i.type === 'warning').length;
+            if (errorCount === 0 && warningCount === 0 && result.valid) {
+                console.log(colors.green('✔ Valid llms.txt file'));
+            }
+            else {
+                console.log(`${colors.red(`${errorCount} errors`)} | ${colors.yellow(`${warningCount} warnings`)}`);
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`llms.txt analysis failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('spider')
+        .description('Crawl a website following internal links')
+        .argument('<url>', 'Starting URL to crawl')
+        .argument('[args...]', 'Options: depth=N limit=N concurrency=N seo focus=MODE output=file.json')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek spider example.com')}                           ${colors.gray('Crawl with defaults')}
+  ${colors.green('$ rek spider example.com depth=3 limit=50')}          ${colors.gray('Depth 3, max 50 pages')}
+  ${colors.green('$ rek spider example.com seo')}                       ${colors.gray('Crawl + SEO analysis')}
+  ${colors.green('$ rek spider example.com seo output=report.json')}    ${colors.gray('SEO with JSON export')}
+  ${colors.green('$ rek spider example.com seo focus=links')}           ${colors.gray('Focus on link issues')}
+  ${colors.green('$ rek spider example.com seo focus=security')}        ${colors.gray('Focus on security issues')}
+  ${colors.green('$ rek spider example.com seo focus=duplicates')}      ${colors.gray('Focus on duplicate content')}
+
+${colors.bold(colors.yellow('Options:'))}
+  ${colors.cyan('depth=N')}           Max link depth to follow (default: 5)
+  ${colors.cyan('limit=N')}           Max pages to crawl (default: 100)
+  ${colors.cyan('concurrency=N')}     Parallel requests (default: 5)
+  ${colors.cyan('seo')}               Enable SEO analysis mode
+  ${colors.cyan('focus=MODE')}        Focus analysis on specific area (requires seo)
+  ${colors.cyan('output=file.json')}  Save JSON report to file
+
+${colors.bold(colors.yellow('Focus Modes:'))}
+  ${colors.cyan('links')}        Internal/external links, broken links, anchor text
+  ${colors.cyan('duplicates')}   Duplicate titles, descriptions, content (85% similarity)
+  ${colors.cyan('security')}     SSL/TLS, HTTPS, form security, headers
+  ${colors.cyan('ai')}           AI/LLM optimization, llms.txt, robots.txt AI bots
+  ${colors.cyan('resources')}    JS/CSS optimization, image compression, caching
+  ${colors.cyan('all')}          Run all focus modes (default)
+`)
+        .action(async (url, args) => {
+        let maxDepth = 5;
+        let maxPages = 100;
+        let concurrency = 5;
+        let seoEnabled = false;
+        let outputFile = '';
+        let focusMode = 'all';
+        const focusCategories = {
+            links: ['links'],
+            duplicates: ['title', 'meta', 'content'],
+            security: ['security'],
+            ai: ['ai-search'],
+            resources: ['resources', 'performance'],
+            all: [],
+        };
+        for (const arg of args) {
+            if (arg.startsWith('depth=')) {
+                maxDepth = parseInt(arg.split('=')[1]) || 5;
+            }
+            else if (arg.startsWith('limit=')) {
+                maxPages = parseInt(arg.split('=')[1]) || 100;
+            }
+            else if (arg.startsWith('concurrency=')) {
+                concurrency = parseInt(arg.split('=')[1]) || 5;
+            }
+            else if (arg === 'seo') {
+                seoEnabled = true;
+            }
+            else if (arg.startsWith('output=')) {
+                outputFile = arg.split('=')[1] || '';
+            }
+            else if (arg.startsWith('focus=')) {
+                const mode = arg.split('=')[1] || 'all';
+                if (mode in focusCategories) {
+                    focusMode = mode;
+                }
+                else {
+                    console.error(colors.red(`Invalid focus mode: ${mode}`));
+                    console.error(colors.gray(`Valid modes: ${Object.keys(focusCategories).join(', ')}`));
+                    process.exit(1);
+                }
+            }
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const modeLabel = seoEnabled ? colors.magenta(' + SEO') : '';
+        const focusLabel = focusMode !== 'all' ? colors.cyan(` [focus: ${focusMode}]`) : '';
+        console.log(colors.cyan(`\nSpider starting: ${url}`));
+        console.log(colors.gray(`  Depth: ${maxDepth} | Limit: ${maxPages} | Concurrency: ${concurrency}${modeLabel}${focusLabel}`));
+        if (outputFile) {
+            console.log(colors.gray(`  Output: ${outputFile}`));
+        }
+        console.log('');
+        try {
+            if (seoEnabled) {
+                const { SeoSpider } = await import('../seo/index.js');
+                const seoSpider = new SeoSpider({
+                    maxDepth,
+                    maxPages,
+                    concurrency,
+                    sameDomain: true,
+                    delay: 100,
+                    seo: true,
+                    output: outputFile || undefined,
+                    focusCategories: focusCategories[focusMode],
+                    focusMode,
+                    onProgress: (progress) => {
+                        process.stdout.write(`\r${colors.gray('  Crawling:')} ${colors.cyan(progress.crawled.toString())} pages | ${colors.gray('Queue:')} ${progress.queued} | ${colors.gray('Depth:')} ${progress.depth}   `);
+                    },
+                });
+                const result = await seoSpider.crawl(url);
+                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                console.log(colors.green(`\n✔ SEO Spider complete`) + colors.gray(` (${(result.duration / 1000).toFixed(1)}s)`));
+                console.log(`  ${colors.cyan('Pages crawled')}: ${result.pages.length}`);
+                console.log(`  ${colors.cyan('Unique URLs')}: ${result.visited.size}`);
+                console.log(`  ${colors.cyan('Avg SEO Score')}: ${result.summary.avgScore}/100`);
+                const responseTimes = result.pages.filter(p => p.duration > 0).map(p => p.duration);
+                const avgResponseTime = responseTimes.length > 0
+                    ? Math.round(responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length)
+                    : 0;
+                const minResponseTime = responseTimes.length > 0 ? Math.min(...responseTimes) : 0;
+                const maxResponseTime = responseTimes.length > 0 ? Math.max(...responseTimes) : 0;
+                const reqPerSec = result.duration > 0 ? (result.pages.length / (result.duration / 1000)).toFixed(1) : '0';
+                const statusCounts = new Map();
+                for (const page of result.pages) {
+                    const status = page.status || 0;
+                    statusCounts.set(status, (statusCounts.get(status) || 0) + 1);
+                }
+                let totalInternalLinks = 0;
+                let totalExternalLinks = 0;
+                let totalImages = 0;
+                let imagesWithoutAlt = 0;
+                let pagesWithoutTitle = 0;
+                let pagesWithoutDescription = 0;
+                for (const page of result.pages) {
+                    if (page.seoReport) {
+                        totalInternalLinks += page.seoReport.links?.internal || 0;
+                        totalExternalLinks += page.seoReport.links?.external || 0;
+                        totalImages += page.seoReport.images?.total || 0;
+                        imagesWithoutAlt += page.seoReport.images?.withoutAlt || 0;
+                        if (!page.seoReport.title?.text)
+                            pagesWithoutTitle++;
+                        if (!page.seoReport.metaDescription?.text)
+                            pagesWithoutDescription++;
+                    }
+                }
+                console.log(colors.bold('\n  Performance:'));
+                console.log(`    ${colors.gray('Avg Response:')}  ${avgResponseTime}ms`);
+                console.log(`    ${colors.gray('Min/Max:')}       ${minResponseTime}ms / ${maxResponseTime}ms`);
+                console.log(`    ${colors.gray('Throughput:')}    ${reqPerSec} req/s`);
+                console.log(colors.bold('\n  HTTP Status:'));
+                const sortedStatuses = Array.from(statusCounts.entries()).sort((a, b) => b[1] - a[1]);
+                for (const [status, count] of sortedStatuses.slice(0, 5)) {
+                    const statusLabel = status === 0 ? 'Error' : status.toString();
+                    const statusColor = status >= 400 || status === 0 ? colors.red :
+                        status >= 300 ? colors.yellow : colors.green;
+                    const pct = ((count / result.pages.length) * 100).toFixed(0);
+                    console.log(`    ${statusColor(statusLabel.padEnd(5))} ${count.toString().padStart(3)} (${pct}%)`);
+                }
+                console.log(colors.bold('\n  Content:'));
+                console.log(`    ${colors.gray('Internal links:')} ${totalInternalLinks.toLocaleString()}`);
+                console.log(`    ${colors.gray('External links:')} ${totalExternalLinks.toLocaleString()}`);
+                console.log(`    ${colors.gray('Images:')}         ${totalImages.toLocaleString()} (${imagesWithoutAlt} missing alt)`);
+                console.log(`    ${colors.gray('Missing title:')}  ${pagesWithoutTitle}`);
+                console.log(`    ${colors.gray('Missing desc:')}   ${pagesWithoutDescription}`);
+                console.log(colors.bold('\n  SEO Summary:'));
+                const { summary } = result;
+                console.log(`    ${colors.red('✗')} Pages with errors:     ${summary.pagesWithErrors}`);
+                console.log(`    ${colors.yellow('⚠')} Pages with warnings:   ${summary.pagesWithWarnings}`);
+                console.log(`    ${colors.magenta('⚐')} Duplicate titles:      ${summary.duplicateTitles}`);
+                console.log(`    ${colors.magenta('⚐')} Duplicate descriptions:${summary.duplicateDescriptions}`);
+                console.log(`    ${colors.magenta('⚐')} Duplicate H1s:         ${summary.duplicateH1s}`);
+                console.log(`    ${colors.gray('○')} Orphan pages:          ${summary.orphanPages}`);
+                if (result.siteWideIssues.length > 0) {
+                    console.log(colors.bold('\n  Site-Wide Issues:'));
+                    for (const issue of result.siteWideIssues.slice(0, 10)) {
+                        const icon = issue.severity === 'error' ? colors.red('✗') :
+                            issue.severity === 'warning' ? colors.yellow('⚠') : colors.gray('○');
+                        console.log(`    ${icon} ${issue.message}`);
+                        if (issue.value) {
+                            const truncatedValue = issue.value.length > 50 ? issue.value.slice(0, 47) + '...' : issue.value;
+                            console.log(`      ${colors.gray(`"${truncatedValue}"`)}`);
+                        }
+                        const uniquePaths = [...new Set(issue.affectedUrls.map(u => new URL(u).pathname))];
+                        if (uniquePaths.length <= 3) {
+                            for (const path of uniquePaths) {
+                                console.log(`      ${colors.gray('→')} ${path}`);
+                            }
+                        }
+                        else {
+                            console.log(`      ${colors.gray(`→ ${uniquePaths.length} pages affected`)}`);
+                        }
+                    }
+                    if (result.siteWideIssues.length > 10) {
+                        console.log(colors.gray(`    ... and ${result.siteWideIssues.length - 10} more issues`));
+                    }
+                }
+                const pagesWithScores = result.pages
+                    .filter(p => p.seoReport)
+                    .sort((a, b) => (a.seoReport?.score || 0) - (b.seoReport?.score || 0));
+                const seenPaths = new Set();
+                const uniquePages = pagesWithScores.filter(page => {
+                    const path = new URL(page.url).pathname;
+                    if (seenPaths.has(path))
+                        return false;
+                    seenPaths.add(path);
+                    return true;
+                });
+                if (uniquePages.length > 0) {
+                    console.log(colors.bold('\n  Pages by SEO Score:'));
+                    const worstPages = uniquePages.slice(0, 5);
+                    for (const page of worstPages) {
+                        const score = page.seoReport?.score || 0;
+                        const grade = page.seoReport?.grade || '?';
+                        const path = new URL(page.url).pathname;
+                        const scoreColor = score >= 80 ? colors.green : score >= 60 ? colors.yellow : colors.red;
+                        console.log(`    ${scoreColor(`${score.toString().padStart(3)}`)} ${colors.gray(`[${grade}]`)} ${path.slice(0, 50)}`);
+                    }
+                    if (uniquePages.length > 5) {
+                        console.log(colors.gray(`    ... and ${uniquePages.length - 5} more pages`));
+                    }
+                }
+                if (outputFile) {
+                    console.log(colors.green(`\n  Report saved to: ${outputFile}`));
+                }
+            }
+            else {
+                const { Spider } = await import('../scrape/spider.js');
+                const spider = new Spider({
+                    maxDepth,
+                    maxPages,
+                    concurrency,
+                    sameDomain: true,
+                    delay: 100,
+                    onProgress: (progress) => {
+                        process.stdout.write(`\r${colors.gray('  Crawling:')} ${colors.cyan(progress.crawled.toString())} pages | ${colors.gray('Queue:')} ${progress.queued} | ${colors.gray('Depth:')} ${progress.depth}   `);
+                    },
+                });
+                const result = await spider.crawl(url);
+                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                console.log(colors.green(`\n✔ Spider complete`) + colors.gray(` (${(result.duration / 1000).toFixed(1)}s)`));
+                console.log(`  ${colors.cyan('Pages crawled')}: ${result.pages.length}`);
+                console.log(`  ${colors.cyan('Unique URLs')}: ${result.visited.size}`);
+                console.log(`  ${colors.cyan('Errors')}: ${result.errors.length}`);
+                const byDepth = new Map();
+                for (const page of result.pages) {
+                    byDepth.set(page.depth, (byDepth.get(page.depth) || 0) + 1);
+                }
+                console.log(colors.bold('\n  Pages by depth:'));
+                for (const [depth, count] of Array.from(byDepth.entries()).sort((a, b) => a[0] - b[0])) {
+                    const bar = '█'.repeat(Math.min(count, 40));
+                    console.log(`    ${colors.gray(`d${depth}:`)} ${bar} ${count}`);
+                }
+                const topPages = [...result.pages]
+                    .filter(p => !p.error)
+                    .sort((a, b) => b.links.length - a.links.length)
+                    .slice(0, 10);
+                if (topPages.length > 0) {
+                    console.log(colors.bold('\n  Top pages by outgoing links:'));
+                    for (const page of topPages) {
+                        const title = page.title.slice(0, 40) || new URL(page.url).pathname;
+                        console.log(`    ${colors.cyan(page.links.length.toString().padStart(3))} ${title}`);
+                    }
+                }
+                const formatError = (error) => {
+                    const statusMatch = error.match(/status code (\d{3})/i);
+                    if (statusMatch) {
+                        return `HTTP ${statusMatch[1]}`;
+                    }
+                    return error.length > 50 ? error.slice(0, 47) + '...' : error;
+                };
+                if (result.errors.length > 0 && result.errors.length <= 10) {
+                    console.log(colors.bold('\n  Errors:'));
+                    for (const err of result.errors) {
+                        const path = new URL(err.url).pathname;
+                        console.log(`    ${colors.red('✗')} ${path.padEnd(30)} → ${formatError(err.error)}`);
+                    }
+                }
+                else if (result.errors.length > 10) {
+                    console.log(colors.bold('\n  Errors:'));
+                    for (const err of result.errors.slice(0, 5)) {
+                        const path = new URL(err.url).pathname;
+                        console.log(`    ${colors.red('✗')} ${path.padEnd(30)} → ${formatError(err.error)}`);
+                    }
+                    console.log(colors.gray(`    ... and ${result.errors.length - 5} more errors`));
+                }
+                if (outputFile) {
+                    const jsonOutput = {
+                        startUrl: result.startUrl,
+                        crawledAt: new Date().toISOString(),
+                        duration: result.duration,
+                        summary: {
+                            totalPages: result.pages.length,
+                            successCount: result.pages.filter(p => !p.error).length,
+                            errorCount: result.errors.length,
+                            uniqueUrls: result.visited.size,
+                        },
+                        pages: result.pages.map(p => ({
+                            url: p.url,
+                            status: p.status,
+                            title: p.title,
+                            depth: p.depth,
+                            linksCount: p.links.length,
+                            duration: p.duration,
+                            error: p.error,
+                        })),
+                        errors: result.errors,
+                    };
+                    await fs.writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    console.log(colors.green(`\n  Report saved to: ${outputFile}`));
+                }
+            }
+            console.log('');
+        }
         catch (error) {
             console.error(colors.red(`\nSpider failed: ${error.message}`));
             process.exit(1);
         }
     });
+    program
+        .command('scrape')
+        .description('Scrape data from a web page using CSS selectors')
+        .argument('<url>', 'URL to scrape')
+        .argument('[args...]', 'Options: select=SELECTOR, attr=NAME, links, images, meta, tables, scripts, jsonld')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek scrape example.com')}                      ${colors.gray('# Basic page info')}
+  ${colors.green('$ rek scrape example.com select="h1"')}          ${colors.gray('# Extract h1 text')}
+  ${colors.green('$ rek scrape example.com select="a" attr=href')} ${colors.gray('# Extract link hrefs')}
+  ${colors.green('$ rek scrape example.com links')}                ${colors.gray('# All links')}
+  ${colors.green('$ rek scrape example.com images')}               ${colors.gray('# All images')}
+  ${colors.green('$ rek scrape example.com meta')}                 ${colors.gray('# Meta tags')}
+  ${colors.green('$ rek scrape example.com tables')}               ${colors.gray('# All tables as JSON')}
+  ${colors.green('$ rek scrape example.com scripts')}              ${colors.gray('# All scripts')}
+  ${colors.green('$ rek scrape example.com jsonld')}               ${colors.gray('# JSON-LD structured data')}
+
+${colors.bold(colors.yellow('Options:'))}
+  ${colors.cyan('select=SELECTOR')}  CSS selector to extract elements
+  ${colors.cyan('attr=NAME')}        Extract specific attribute (use with select)
+  ${colors.cyan('links')}            Extract all links with text and href
+  ${colors.cyan('images')}           Extract all images with src and alt
+  ${colors.cyan('meta')}             Extract all meta tags
+  ${colors.cyan('tables')}           Extract tables as structured JSON
+  ${colors.cyan('scripts')}          Extract all script sources
+  ${colors.cyan('jsonld')}           Extract JSON-LD structured data
+`)
+        .action(async (url, args) => {
+        const { ScrapeDocument } = await import('../scrape/document.js');
+        const { Client } = await import('../core/client.js');
+        let selector = '';
+        let attrName = '';
+        let extractLinks = false;
+        let extractImages = false;
+        let extractMeta = false;
+        let extractTables = false;
+        let extractScripts = false;
+        let extractJsonLd = false;
+        for (const arg of args) {
+            if (arg.startsWith('select=')) {
+                selector = arg.slice(7);
+            }
+            else if (arg.startsWith('attr=')) {
+                attrName = arg.slice(5);
+            }
+            else if (arg === 'links') {
+                extractLinks = true;
+            }
+            else if (arg === 'images') {
+                extractImages = true;
+            }
+            else if (arg === 'meta') {
+                extractMeta = true;
+            }
+            else if (arg === 'tables') {
+                extractTables = true;
+            }
+            else if (arg === 'scripts') {
+                extractScripts = true;
+            }
+            else if (arg === 'jsonld') {
+                extractJsonLd = true;
+            }
+        }
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            url = `https://${url}`;
+        }
+        console.log(colors.gray(`Fetching ${url}...`));
+        try {
+            const client = new Client();
+            const response = await client.get(url);
+            const html = await response.text();
+            const doc = await ScrapeDocument.create(html, { baseUrl: url });
+            if (!selector && !extractLinks && !extractImages && !extractMeta && !extractTables && !extractScripts && !extractJsonLd) {
+                const title = doc.text('title') || 'N/A';
+                const description = doc.attr('meta[name="description"]', 'content') || 'N/A';
+                const h1 = doc.text('h1') || 'N/A';
+                const linkCount = doc.links().length;
+                const imageCount = doc.images().length;
+                console.log(`
+${colors.bold(colors.cyan('📄 Page Info'))}
+
+${colors.bold('Title:')}       ${title}
+${colors.bold('Description:')} ${description.slice(0, 100)}${description.length > 100 ? '...' : ''}
+${colors.bold('H1:')}          ${h1}
+${colors.bold('Links:')}       ${linkCount}
+${colors.bold('Images:')}      ${imageCount}
+`);
+                return;
+            }
+            if (selector) {
+                if (attrName) {
+                    const values = doc.attrs(selector, attrName);
+                    console.log(`\n${colors.bold(`Found ${values.length} values for "${attrName}" in "${selector}"`)}\n`);
+                    values.slice(0, 50).forEach((value, i) => {
+                        if (value) {
+                            console.log(`${colors.gray(`${i + 1}.`)} ${value}`);
+                        }
+                    });
+                    if (values.length > 50) {
+                        console.log(colors.gray(`\n... and ${values.length - 50} more`));
+                    }
+                }
+                else {
+                    const texts = doc.texts(selector);
+                    console.log(`\n${colors.bold(`Found ${texts.length} elements matching "${selector}"`)}\n`);
+                    texts.slice(0, 50).forEach((text, i) => {
+                        const trimmed = text.trim();
+                        if (trimmed) {
+                            console.log(`${colors.gray(`${i + 1}.`)} ${trimmed.slice(0, 200)}`);
+                        }
+                    });
+                    if (texts.length > 50) {
+                        console.log(colors.gray(`\n... and ${texts.length - 50} more`));
+                    }
+                }
+                return;
+            }
+            if (extractLinks) {
+                const links = doc.links();
+                console.log(`\n${colors.bold(`Found ${links.length} links`)}\n`);
+                links.slice(0, 50).forEach((link, i) => {
+                    const text = (link.text || '').trim().slice(0, 50) || '[no text]';
+                    console.log(`${colors.gray(`${i + 1}.`)} ${colors.cyan(text)}`);
+                    console.log(`   ${colors.gray(link.href)}`);
+                });
+                if (links.length > 50) {
+                    console.log(colors.gray(`\n... and ${links.length - 50} more`));
+                }
+                return;
+            }
+            if (extractImages) {
+                const images = doc.images();
+                console.log(`\n${colors.bold(`Found ${images.length} images`)}\n`);
+                images.slice(0, 30).forEach((img, i) => {
+                    const alt = img.alt || '[no alt]';
+                    console.log(`${colors.gray(`${i + 1}.`)} ${colors.cyan(alt.slice(0, 50))}`);
+                    console.log(`   ${colors.gray(img.src)}`);
+                });
+                if (images.length > 30) {
+                    console.log(colors.gray(`\n... and ${images.length - 30} more`));
+                }
+                return;
+            }
+            if (extractMeta) {
+                const meta = doc.meta();
+                const entries = Object.entries(meta);
+                console.log(`\n${colors.bold(`Found ${entries.length} meta entries`)}\n`);
+                entries.forEach(([name, content]) => {
+                    if (name && content) {
+                        const value = String(content);
+                        console.log(`${colors.cyan(name)}: ${value.slice(0, 100)}${value.length > 100 ? '...' : ''}`);
+                    }
+                });
+                return;
+            }
+            if (extractTables) {
+                const tables = doc.tables();
+                console.log(`\n${colors.bold(`Found ${tables.length} tables`)}\n`);
+                tables.slice(0, 5).forEach((table, tableIndex) => {
+                    console.log(`${colors.bold(`Table ${tableIndex + 1}:`)} ${table.rows?.length || 0} rows`);
+                    console.log(JSON.stringify((table.rows || []).slice(0, 10), null, 2));
+                    if ((table.rows?.length || 0) > 10) {
+                        console.log(colors.gray(`... and ${(table.rows?.length || 0) - 10} more rows`));
+                    }
+                    console.log('');
+                });
+                return;
+            }
+            if (extractScripts) {
+                const scripts = doc.scripts();
+                const external = scripts.filter(s => s.src);
+                const inline = scripts.filter(s => !s.src);
+                console.log(`\n${colors.bold(`Found ${external.length} external scripts, ${inline.length} inline`)}\n`);
+                if (external.length > 0) {
+                    console.log(colors.bold('External Scripts:'));
+                    external.slice(0, 20).forEach((script, i) => {
+                        console.log(`${colors.gray(`${i + 1}.`)} ${script.src}`);
+                    });
+                    if (external.length > 20) {
+                        console.log(colors.gray(`... and ${external.length - 20} more`));
+                    }
+                }
+                return;
+            }
+            if (extractJsonLd) {
+                const jsonld = doc.jsonLd();
+                console.log(`\n${colors.bold(`Found ${jsonld.length} JSON-LD blocks`)}\n`);
+                jsonld.forEach((data, i) => {
+                    console.log(`${colors.bold(`Block ${i + 1}:`)} ${data['@type'] || 'Unknown type'}`);
+                    console.log(JSON.stringify(data, null, 2));
+                    console.log('');
+                });
+                return;
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`Scrape failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
     program
         .command('ai')
         .description('Send a single AI prompt (no memory/context)')
@@ -790,103 +1555,553 @@ ${colors.bold(colors.yellow('Note:'))}
             console.log(colors.gray(`Downloading GeoLite2 database...`));
         }
         try {
-            const info = await getIpInfo(address);
-            if (info.bogon) {
-                console.log(colors.yellow(`\n⚠  ${address} is a Bogon/Private IP.`));
-                console.log(colors.gray(`   Type: ${info.bogonType}`));
-                return;
+            const info = await getIpInfo(address);
+            if (info.bogon) {
+                console.log(colors.yellow(`\n⚠  ${address} is a Bogon/Private IP.`));
+                console.log(colors.gray(`   Type: ${info.bogonType}`));
+                return;
+            }
+            console.log(`
+${colors.bold(colors.cyan('🌍 IP Intelligence Report'))}
+
+${colors.bold('Location:')}
+  ${colors.gray('City:')}      ${info.city || 'N/A'}
+  ${colors.gray('Region:')}    ${info.region || 'N/A'}
+  ${colors.gray('Country:')}   ${info.country || 'N/A'} ${info.countryCode ? `(${info.countryCode})` : ''}
+  ${colors.gray('Continent:')} ${info.continent || 'N/A'}
+  ${colors.gray('Timezone:')}  ${info.timezone || 'N/A'}
+  ${colors.gray('Coords:')}    ${info.loc ? colors.cyan(info.loc) : 'N/A'}
+  ${colors.gray('Accuracy:')}  ${info.accuracy ? `~${info.accuracy} km` : 'N/A'}
+
+${colors.bold('Network:')}
+  ${colors.gray('IP:')}        ${info.ip}
+  ${colors.gray('Type:')}      ${info.isIPv6 ? 'IPv6' : 'IPv4'}
+  ${colors.gray('Postal:')}    ${info.postal || 'N/A'}
+`);
+        }
+        catch (err) {
+            console.error(colors.red(`IP Lookup Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('tls')
+        .alias('ssl')
+        .description('Inspect TLS/SSL certificate of a host')
+        .argument('<host>', 'Hostname or IP address')
+        .argument('[port]', 'Port number (default: 443)', '443')
+        .action(async (host, port) => {
+        const { inspectTLS } = await import('../utils/tls-inspector.js');
+        console.log(colors.gray(`Inspecting TLS certificate for ${host}:${port}...`));
+        try {
+            const info = await inspectTLS(host, parseInt(port));
+            let daysColor = colors.green;
+            if (info.daysRemaining < 30)
+                daysColor = colors.red;
+            else if (info.daysRemaining < 90)
+                daysColor = colors.yellow;
+            const validIcon = info.valid ? colors.green('✔ Valid') : colors.red('✖ Expired');
+            const authIcon = info.authorized ? colors.green('✔ Trusted') : colors.yellow('⚠ Self-signed/Untrusted');
+            console.log(`
+${colors.bold(colors.cyan('🔒 TLS Certificate Report'))}
+
+${colors.bold('Status:')}
+  ${validIcon}
+  ${authIcon}
+  ${colors.gray('Days Remaining:')} ${daysColor(info.daysRemaining.toString())}
+
+${colors.bold('Certificate:')}
+  ${colors.gray('Subject:')}       ${info.subject?.CN || info.subject?.O || 'N/A'}
+  ${colors.gray('Issuer:')}        ${info.issuer?.CN || info.issuer?.O || 'N/A'}
+  ${colors.gray('Valid From:')}    ${info.validFrom.toISOString().split('T')[0]}
+  ${colors.gray('Valid To:')}      ${info.validTo.toISOString().split('T')[0]}
+  ${colors.gray('Serial:')}        ${info.serialNumber}
+
+${colors.bold('Security:')}
+  ${colors.gray('Protocol:')}      ${info.protocol || 'N/A'}
+  ${colors.gray('Cipher:')}        ${info.cipher?.name || 'N/A'}
+  ${colors.gray('Key:')}           ${info.pubkey ? `${info.pubkey.algo.toUpperCase()} ${info.pubkey.size}-bit` : 'N/A'}
+
+${colors.bold('Fingerprints:')}
+  ${colors.gray('SHA-1:')}   ${info.fingerprint}
+  ${colors.gray('SHA-256:')} ${info.fingerprint256?.slice(0, 40)}...
+`);
+            if (info.altNames && info.altNames.length > 0) {
+                console.log(`${colors.bold('Subject Alternative Names:')}`);
+                info.altNames.slice(0, 10).forEach(san => {
+                    console.log(`  ${colors.gray('•')} ${san}`);
+                });
+                if (info.altNames.length > 10) {
+                    console.log(`  ${colors.gray(`... and ${info.altNames.length - 10} more`)}`);
+                }
+                console.log('');
+            }
+            if (info.extKeyUsage && info.extKeyUsage.length > 0) {
+                console.log(`${colors.bold('Extended Key Usage:')}`);
+                info.extKeyUsage.forEach(oid => {
+                    const oidNames = {
+                        '1.3.6.1.5.5.7.3.1': 'Server Authentication',
+                        '1.3.6.1.5.5.7.3.2': 'Client Authentication',
+                        '1.3.6.1.5.5.7.3.3': 'Code Signing',
+                        '1.3.6.1.5.5.7.3.4': 'Email Protection',
+                    };
+                    console.log(`  ${colors.gray('•')} ${oidNames[oid] || oid}`);
+                });
+                console.log('');
+            }
+        }
+        catch (err) {
+            console.error(colors.red(`TLS Inspection Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('whois')
+        .description('WHOIS lookup for domains and IP addresses')
+        .argument('<query>', 'Domain name or IP address')
+        .option('-r, --raw', 'Show raw WHOIS response')
+        .action(async (query, options) => {
+        const { whois } = await import('../utils/whois.js');
+        console.log(colors.gray(`Looking up WHOIS for ${query}...`));
+        try {
+            const result = await whois(query);
+            if (options.raw) {
+                console.log(result.raw);
+                return;
+            }
+            console.log(`
+${colors.bold(colors.cyan('📋 WHOIS Report'))}
+
+${colors.bold('Query:')} ${result.query}
+${colors.bold('Server:')} ${result.server}
+`);
+            if (result.data && Object.keys(result.data).length > 0) {
+                console.log(colors.bold('Parsed Data:'));
+                const importantKeys = ['Domain Name', 'Registrar', 'Creation Date', 'Expiration Date', 'Updated Date', 'Name Server', 'Status'];
+                for (const key of importantKeys) {
+                    const value = result.data[key];
+                    if (value) {
+                        if (Array.isArray(value)) {
+                            console.log(`  ${colors.cyan(key)}:`);
+                            value.forEach((v) => console.log(`    ${colors.gray('•')} ${v}`));
+                        }
+                        else {
+                            console.log(`  ${colors.cyan(key)}: ${value}`);
+                        }
+                    }
+                }
+            }
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`WHOIS Lookup Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('rdap')
+        .description('RDAP lookup (modern WHOIS replacement)')
+        .argument('<domain>', 'Domain name to lookup')
+        .action(async (domain) => {
+        const { rdap } = await import('../utils/rdap.js');
+        const { Client } = await import('../core/client.js');
+        console.log(colors.gray(`Looking up RDAP for ${domain}...`));
+        try {
+            const client = new Client();
+            const result = await rdap(client, domain);
+            console.log(`
+${colors.bold(colors.cyan('📋 RDAP Report'))}
+
+${colors.bold('Domain:')} ${result.ldhName || domain}
+${colors.bold('Handle:')} ${result.handle || 'N/A'}
+${colors.bold('Status:')} ${result.status?.join(', ') || 'N/A'}
+`);
+            if (result.events && result.events.length > 0) {
+                console.log(`${colors.bold('Events:')}`);
+                result.events.forEach((event) => {
+                    const date = event.eventDate ? new Date(event.eventDate).toISOString().split('T')[0] : 'N/A';
+                    console.log(`  ${colors.gray(event.eventAction + ':')} ${date}`);
+                });
+                console.log('');
+            }
+            if (result.nameservers && result.nameservers.length > 0) {
+                console.log(`${colors.bold('Name Servers:')}`);
+                result.nameservers.forEach((ns) => {
+                    console.log(`  ${colors.gray('•')} ${ns.ldhName}`);
+                });
+                console.log('');
+            }
+            if (result.entities && result.entities.length > 0) {
+                console.log(`${colors.bold('Entities:')}`);
+                result.entities.slice(0, 5).forEach((entity) => {
+                    const roles = entity.roles?.join(', ') || 'N/A';
+                    console.log(`  ${colors.gray(roles + ':')} ${entity.handle || 'Unknown'}`);
+                });
+                console.log('');
+            }
+            if (result.links && result.links.length > 0) {
+                const selfLink = result.links.find((l) => l.rel === 'self');
+                if (selfLink) {
+                    console.log(`${colors.gray('Source:')} ${selfLink.href}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(colors.red(`RDAP Lookup Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('ping')
+        .description('TCP connectivity check to a host')
+        .argument('<host>', 'Hostname or IP address')
+        .argument('[port]', 'Port number (default: 80 for HTTP, 443 for HTTPS)', '443')
+        .option('-c, --count <n>', 'Number of pings', '4')
+        .action(async (host, port, options) => {
+        const net = await import('node:net');
+        const count = parseInt(options.count);
+        const portNum = parseInt(port);
+        const results = [];
+        console.log(colors.gray(`Pinging ${host}:${portNum}...`));
+        console.log('');
+        for (let i = 0; i < count; i++) {
+            const start = performance.now();
+            try {
+                await new Promise((resolve, reject) => {
+                    const socket = net.connect(portNum, host, () => {
+                        socket.destroy();
+                        resolve();
+                    });
+                    socket.setTimeout(5000);
+                    socket.on('timeout', () => {
+                        socket.destroy();
+                        reject(new Error('Timeout'));
+                    });
+                    socket.on('error', reject);
+                });
+                const elapsed = performance.now() - start;
+                results.push(elapsed);
+                console.log(`${colors.green('✔')} Connected to ${host}:${portNum} - ${colors.cyan(elapsed.toFixed(2) + 'ms')}`);
+            }
+            catch (err) {
+                console.log(`${colors.red('✖')} Failed to connect: ${err.message}`);
+            }
+            if (i < count - 1) {
+                await new Promise(r => setTimeout(r, 1000));
+            }
+        }
+        if (results.length > 0) {
+            const avg = results.reduce((a, b) => a + b, 0) / results.length;
+            const min = Math.min(...results);
+            const max = Math.max(...results);
+            console.log(`
+${colors.bold('Statistics:')}
+  ${colors.gray('Sent:')}     ${count}
+  ${colors.gray('Received:')} ${results.length}
+  ${colors.gray('Lost:')}     ${count - results.length} (${((count - results.length) / count * 100).toFixed(0)}%)
+  ${colors.gray('Min:')}      ${min.toFixed(2)}ms
+  ${colors.gray('Avg:')}      ${avg.toFixed(2)}ms
+  ${colors.gray('Max:')}      ${max.toFixed(2)}ms
+`);
+        }
+    });
+    const ftpCmd = program.command('ftp').description('FTP client operations');
+    ftpCmd
+        .command('ls')
+        .description('List files in a remote directory')
+        .argument('<host>', 'FTP server hostname')
+        .argument('[path]', 'Remote path to list', '/')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, path, options) => {
+        const { createFTP } = await import('../protocols/ftp.js');
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        const client = createFTP({
+            host,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
+            secure,
+        });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success) {
+                console.error(colors.red(`Connection failed: ${connectResult.message}`));
+                process.exit(1);
+            }
+            console.log(colors.green('Connected'));
+            console.log(colors.gray(`Listing ${path}...`));
+            const result = await client.list(path);
+            if (!result.success || !result.data) {
+                console.error(colors.red(`List failed: ${result.message}`));
+                await client.close();
+                process.exit(1);
+            }
+            console.log('');
+            console.log(colors.bold(`Contents of ${path}:`));
+            console.log('');
+            for (const item of result.data) {
+                const typeChar = item.type === 'directory' ? 'd' : item.type === 'link' ? 'l' : '-';
+                const perms = item.permissions || 'rwxr-xr-x';
+                const size = item.size.toString().padStart(10);
+                const date = item.rawModifiedAt || '';
+                const nameColor = item.type === 'directory' ? colors.blue : item.type === 'link' ? colors.cyan : colors.white;
+                console.log(`${typeChar}${perms}  ${size}  ${date.padEnd(12)}  ${nameColor(item.name)}`);
+            }
+            console.log('');
+            console.log(colors.gray(`Total: ${result.data.length} items`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd
+        .command('get')
+        .description('Download a file from FTP server')
+        .argument('<host>', 'FTP server hostname')
+        .argument('<remote>', 'Remote file path')
+        .argument('[local]', 'Local file path (default: same filename)')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, remote, local, options) => {
+        const { createFTP } = await import('../protocols/ftp.js');
+        const path = await import('node:path');
+        const localPath = local || path.basename(remote);
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        const client = createFTP({
+            host,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
+            secure,
+        });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success) {
+                console.error(colors.red(`Connection failed: ${connectResult.message}`));
+                process.exit(1);
+            }
+            console.log(colors.green('Connected'));
+            console.log(colors.gray(`Downloading ${remote} → ${localPath}...`));
+            let lastProgress = 0;
+            client.progress((p) => {
+                const mb = (p.bytesOverall / 1024 / 1024).toFixed(2);
+                if (p.bytesOverall - lastProgress > 100000) {
+                    process.stdout.write(`\r  ${colors.cyan(mb + ' MB')} downloaded...`);
+                    lastProgress = p.bytesOverall;
+                }
+            });
+            const result = await client.download(remote, localPath);
+            console.log('');
+            if (!result.success) {
+                console.error(colors.red(`Download failed: ${result.message}`));
+                await client.close();
+                process.exit(1);
+            }
+            console.log(colors.green(`✔ Downloaded to ${localPath}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd
+        .command('put')
+        .description('Upload a file to FTP server')
+        .argument('<host>', 'FTP server hostname')
+        .argument('<local>', 'Local file path')
+        .argument('[remote]', 'Remote file path (default: same filename)')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, local, remote, options) => {
+        const { createFTP } = await import('../protocols/ftp.js');
+        const path = await import('node:path');
+        const remotePath = remote || '/' + path.basename(local);
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        const client = createFTP({
+            host,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
+            secure,
+        });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success) {
+                console.error(colors.red(`Connection failed: ${connectResult.message}`));
+                process.exit(1);
+            }
+            console.log(colors.green('Connected'));
+            console.log(colors.gray(`Uploading ${local} → ${remotePath}...`));
+            let lastProgress = 0;
+            client.progress((p) => {
+                const mb = (p.bytesOverall / 1024 / 1024).toFixed(2);
+                if (p.bytesOverall - lastProgress > 100000) {
+                    process.stdout.write(`\r  ${colors.cyan(mb + ' MB')} uploaded...`);
+                    lastProgress = p.bytesOverall;
+                }
+            });
+            const result = await client.upload(local, remotePath);
+            console.log('');
+            if (!result.success) {
+                console.error(colors.red(`Upload failed: ${result.message}`));
+                await client.close();
+                process.exit(1);
+            }
+            console.log(colors.green(`✔ Uploaded to ${remotePath}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd
+        .command('rm')
+        .description('Delete a file from FTP server')
+        .argument('<host>', 'FTP server hostname')
+        .argument('<path>', 'Remote file path to delete')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, remotePath, options) => {
+        const { createFTP } = await import('../protocols/ftp.js');
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        const client = createFTP({
+            host,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
+            secure,
+        });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success) {
+                console.error(colors.red(`Connection failed: ${connectResult.message}`));
+                process.exit(1);
+            }
+            console.log(colors.green('Connected'));
+            console.log(colors.gray(`Deleting ${remotePath}...`));
+            const result = await client.delete(remotePath);
+            if (!result.success) {
+                console.error(colors.red(`Delete failed: ${result.message}`));
+                await client.close();
+                process.exit(1);
+            }
+            console.log(colors.green(`✔ Deleted ${remotePath}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd
+        .command('mkdir')
+        .description('Create a directory on FTP server')
+        .argument('<host>', 'FTP server hostname')
+        .argument('<path>', 'Remote directory path to create')
+        .option('-u, --user <username>', 'Username', 'anonymous')
+        .option('-p, --pass <password>', 'Password', 'anonymous@')
+        .option('-P, --port <port>', 'Port number', '21')
+        .option('--secure', 'Use FTPS (explicit TLS)')
+        .option('--implicit', 'Use implicit FTPS (port 990)')
+        .action(async (host, remotePath, options) => {
+        const { createFTP } = await import('../protocols/ftp.js');
+        const secure = options.implicit ? 'implicit' : options.secure ? true : false;
+        const client = createFTP({
+            host,
+            port: parseInt(options.port),
+            user: options.user,
+            password: options.pass,
+            secure,
+        });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success) {
+                console.error(colors.red(`Connection failed: ${connectResult.message}`));
+                process.exit(1);
             }
-            console.log(`
-${colors.bold(colors.cyan('🌍 IP Intelligence Report'))}
-
-${colors.bold('Location:')}
-  ${colors.gray('City:')}      ${info.city || 'N/A'}
-  ${colors.gray('Region:')}    ${info.region || 'N/A'}
-  ${colors.gray('Country:')}   ${info.country || 'N/A'} ${info.countryCode ? `(${info.countryCode})` : ''}
-  ${colors.gray('Continent:')} ${info.continent || 'N/A'}
-  ${colors.gray('Timezone:')}  ${info.timezone || 'N/A'}
-  ${colors.gray('Coords:')}    ${info.loc ? colors.cyan(info.loc) : 'N/A'}
-  ${colors.gray('Accuracy:')}  ${info.accuracy ? `~${info.accuracy} km` : 'N/A'}
-
-${colors.bold('Network:')}
-  ${colors.gray('IP:')}        ${info.ip}
-  ${colors.gray('Type:')}      ${info.isIPv6 ? 'IPv6' : 'IPv4'}
-  ${colors.gray('Postal:')}    ${info.postal || 'N/A'}
-`);
+            console.log(colors.green('Connected'));
+            console.log(colors.gray(`Creating ${remotePath}...`));
+            const result = await client.mkdir(remotePath);
+            if (!result.success) {
+                console.error(colors.red(`Mkdir failed: ${result.message}`));
+                await client.close();
+                process.exit(1);
+            }
+            console.log(colors.green(`✔ Created ${remotePath}`));
+            await client.close();
         }
         catch (err) {
-            console.error(colors.red(`IP Lookup Failed: ${err.message}`));
+            console.error(colors.red(`FTP Error: ${err.message}`));
             process.exit(1);
         }
     });
     program
-        .command('tls')
-        .alias('ssl')
-        .description('Inspect TLS/SSL certificate of a host')
+        .command('telnet')
+        .description('Connect to a Telnet server')
         .argument('<host>', 'Hostname or IP address')
-        .argument('[port]', 'Port number (default: 443)', '443')
-        .action(async (host, port) => {
-        const { inspectTLS } = await import('../utils/tls-inspector.js');
-        console.log(colors.gray(`Inspecting TLS certificate for ${host}:${port}...`));
+        .argument('[port]', 'Port number', '23')
+        .option('-t, --timeout <ms>', 'Connection timeout in ms', '30000')
+        .action(async (host, port, options) => {
+        const { createTelnet } = await import('../protocols/telnet.js');
+        console.log(colors.gray(`Connecting to ${host}:${port}...`));
+        const client = createTelnet({
+            host,
+            port: parseInt(port),
+            timeout: parseInt(options.timeout),
+        });
         try {
-            const info = await inspectTLS(host, parseInt(port));
-            let daysColor = colors.green;
-            if (info.daysRemaining < 30)
-                daysColor = colors.red;
-            else if (info.daysRemaining < 90)
-                daysColor = colors.yellow;
-            const validIcon = info.valid ? colors.green('✔ Valid') : colors.red('✖ Expired');
-            const authIcon = info.authorized ? colors.green('✔ Trusted') : colors.yellow('⚠ Self-signed/Untrusted');
-            console.log(`
-${colors.bold(colors.cyan('🔒 TLS Certificate Report'))}
-
-${colors.bold('Status:')}
-  ${validIcon}
-  ${authIcon}
-  ${colors.gray('Days Remaining:')} ${daysColor(info.daysRemaining.toString())}
-
-${colors.bold('Certificate:')}
-  ${colors.gray('Subject:')}       ${info.subject?.CN || info.subject?.O || 'N/A'}
-  ${colors.gray('Issuer:')}        ${info.issuer?.CN || info.issuer?.O || 'N/A'}
-  ${colors.gray('Valid From:')}    ${info.validFrom.toISOString().split('T')[0]}
-  ${colors.gray('Valid To:')}      ${info.validTo.toISOString().split('T')[0]}
-  ${colors.gray('Serial:')}        ${info.serialNumber}
-
-${colors.bold('Security:')}
-  ${colors.gray('Protocol:')}      ${info.protocol || 'N/A'}
-  ${colors.gray('Cipher:')}        ${info.cipher?.name || 'N/A'}
-  ${colors.gray('Key:')}           ${info.pubkey ? `${info.pubkey.algo.toUpperCase()} ${info.pubkey.size}-bit` : 'N/A'}
-
-${colors.bold('Fingerprints:')}
-  ${colors.gray('SHA-1:')}   ${info.fingerprint}
-  ${colors.gray('SHA-256:')} ${info.fingerprint256?.slice(0, 40)}...
-`);
-            if (info.altNames && info.altNames.length > 0) {
-                console.log(`${colors.bold('Subject Alternative Names:')}`);
-                info.altNames.slice(0, 10).forEach(san => {
-                    console.log(`  ${colors.gray('•')} ${san}`);
-                });
-                if (info.altNames.length > 10) {
-                    console.log(`  ${colors.gray(`... and ${info.altNames.length - 10} more`)}`);
-                }
-                console.log('');
-            }
-            if (info.extKeyUsage && info.extKeyUsage.length > 0) {
-                console.log(`${colors.bold('Extended Key Usage:')}`);
-                info.extKeyUsage.forEach(oid => {
-                    const oidNames = {
-                        '1.3.6.1.5.5.7.3.1': 'Server Authentication',
-                        '1.3.6.1.5.5.7.3.2': 'Client Authentication',
-                        '1.3.6.1.5.5.7.3.3': 'Code Signing',
-                        '1.3.6.1.5.5.7.3.4': 'Email Protection',
-                    };
-                    console.log(`  ${colors.gray('•')} ${oidNames[oid] || oid}`);
-                });
-                console.log('');
+            await client.connect();
+            console.log(colors.green(`Connected to ${host}:${port}`));
+            console.log(colors.gray('Type your commands. Press Ctrl+C to exit.'));
+            console.log('');
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
             }
+            process.stdin.resume();
+            process.stdin.on('data', async (data) => {
+                if (data[0] === 0x03) {
+                    console.log(colors.yellow('\nDisconnecting...'));
+                    await client.close();
+                    process.exit(0);
+                }
+                await client.send(data.toString());
+            });
+            client.on('data', (data) => {
+                process.stdout.write(data);
+            });
+            client.on('close', () => {
+                console.log(colors.yellow('\nConnection closed'));
+                process.exit(0);
+            });
+            client.on('error', (err) => {
+                console.error(colors.red(`Error: ${err.message}`));
+                process.exit(1);
+            });
         }
         catch (err) {
-            console.error(colors.red(`TLS Inspection Failed: ${err.message}`));
+            console.error(colors.red(`Telnet Error: ${err.message}`));
             process.exit(1);
         }
     });
@@ -1266,18 +2481,519 @@ ${colors.bold(colors.yellow('Record Types:'))}
                 domain = arg;
             }
         }
-        if (!domain) {
-            console.error(colors.red('Error: Domain/IP is required'));
-            console.log(colors.gray('Usage: rek dig example.com [TYPE]'));
-            console.log(colors.gray('       rek dig -x 8.8.8.8'));
+        if (!domain) {
+            console.error(colors.red('Error: Domain/IP is required'));
+            console.log(colors.gray('Usage: rek dig example.com [TYPE]'));
+            console.log(colors.gray('       rek dig -x 8.8.8.8'));
+            process.exit(1);
+        }
+        try {
+            const result = await dig(domain, { server, type, reverse, short });
+            console.log(formatDigOutput(result, short));
+        }
+        catch (err) {
+            console.error(colors.red(`dig: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('graphql')
+        .description('Execute a GraphQL query')
+        .argument('<url>', 'GraphQL endpoint URL')
+        .option('-q, --query <query>', 'GraphQL query string')
+        .option('-f, --file <file>', 'Path to GraphQL query file')
+        .option('-v, --variables <json>', 'Variables as JSON string')
+        .option('--var-file <file>', 'Path to variables JSON file')
+        .option('-H, --header <header>', 'Add header (can be used multiple times)', (val, prev) => [...prev, val], [])
+        .action(async (url, options) => {
+        const { graphql } = await import('../plugins/graphql.js');
+        const { createClient } = await import('../core/client.js');
+        const fs = await import('node:fs/promises');
+        let query = options.query;
+        let variables = {};
+        if (options.file) {
+            try {
+                query = await fs.readFile(options.file, 'utf-8');
+            }
+            catch (err) {
+                console.error(colors.red(`Failed to read query file: ${err.message}`));
+                process.exit(1);
+            }
+        }
+        if (!query) {
+            console.error(colors.red('Error: Query is required. Use --query or --file'));
+            console.log(colors.gray('Example: rek graphql https://api.example.com/graphql -q "query { users { id name } }"'));
+            process.exit(1);
+        }
+        if (options.variables) {
+            try {
+                variables = JSON.parse(options.variables);
+            }
+            catch {
+                console.error(colors.red('Invalid JSON in --variables'));
+                process.exit(1);
+            }
+        }
+        else if (options.varFile) {
+            try {
+                const content = await fs.readFile(options.varFile, 'utf-8');
+                variables = JSON.parse(content);
+            }
+            catch (err) {
+                console.error(colors.red(`Failed to read variables file: ${err.message}`));
+                process.exit(1);
+            }
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        for (const h of options.header) {
+            const [key, ...valueParts] = h.split(':');
+            headers[key.trim()] = valueParts.join(':').trim();
+        }
+        console.log(colors.gray(`Executing GraphQL query against ${url}...`));
+        try {
+            const client = createClient({ baseUrl: url, headers });
+            const result = await graphql(client, query, variables);
+            console.log('');
+            console.log(colors.bold(colors.green('Response:')));
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`GraphQL Error: ${err.message}`));
+            if (err.errors) {
+                console.log(colors.bold(colors.red('GraphQL Errors:')));
+                for (const e of err.errors) {
+                    console.log(`  ${colors.red('•')} ${e.message}`);
+                }
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command('jsonrpc')
+        .description('Execute a JSON-RPC 2.0 call')
+        .argument('<url>', 'JSON-RPC endpoint URL')
+        .argument('<method>', 'Method name to call')
+        .argument('[params...]', 'Method parameters (JSON values)')
+        .option('-n, --named', 'Use named parameters (key=value format)')
+        .option('-b, --batch <methods>', 'Batch multiple methods (comma-separated)')
+        .option('-H, --header <header>', 'Add header (can be used multiple times)', (val, prev) => [...prev, val], [])
+        .action(async (url, method, params, options) => {
+        const { createJsonRpcClient } = await import('../plugins/jsonrpc.js');
+        const { createClient } = await import('../core/client.js');
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        for (const h of options.header) {
+            const [key, ...valueParts] = h.split(':');
+            headers[key.trim()] = valueParts.join(':').trim();
+        }
+        const client = createClient({ baseUrl: url, headers });
+        const rpc = createJsonRpcClient(client, { endpoint: '' });
+        console.log(colors.gray(`Calling ${method} on ${url}...`));
+        try {
+            let rpcParams;
+            if (options.named) {
+                rpcParams = {};
+                for (const p of params) {
+                    const [key, ...valueParts] = p.split('=');
+                    const value = valueParts.join('=');
+                    try {
+                        rpcParams[key] = JSON.parse(value);
+                    }
+                    catch {
+                        rpcParams[key] = value;
+                    }
+                }
+            }
+            else {
+                rpcParams = params.map((p) => {
+                    try {
+                        return JSON.parse(p);
+                    }
+                    catch {
+                        return p;
+                    }
+                });
+            }
+            const result = await rpc.call(method, rpcParams);
+            console.log('');
+            console.log(colors.bold(colors.green('Result:')));
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`JSON-RPC Error: ${err.message}`));
+            if (err.code) {
+                console.log(colors.gray(`Error code: ${err.code}`));
+            }
+            if (err.data) {
+                console.log(colors.gray(`Error data: ${JSON.stringify(err.data)}`));
+            }
+            process.exit(1);
+        }
+    });
+    const hlsCmd = program.command('hls').description('HLS streaming operations');
+    hlsCmd
+        .command('info')
+        .description('Get information about an HLS stream')
+        .argument('<url>', 'HLS playlist URL')
+        .action(async (url) => {
+        const { Client } = await import('../core/client.js');
+        const client = new Client();
+        console.log(colors.gray(`Fetching playlist from ${url}...`));
+        try {
+            const res = await client.get(url);
+            const content = await res.text();
+            const lines = content.split('\n').map(l => l.trim()).filter(Boolean);
+            if (!lines[0]?.startsWith('#EXTM3U')) {
+                console.error(colors.red('Not a valid HLS playlist'));
+                process.exit(1);
+            }
+            const isMaster = lines.some(l => l.startsWith('#EXT-X-STREAM-INF'));
+            console.log('');
+            console.log(colors.bold(colors.cyan('HLS Stream Info')));
+            console.log(`${colors.gray('URL:')} ${url}`);
+            console.log(`${colors.gray('Type:')} ${isMaster ? 'Master Playlist' : 'Media Playlist'}`);
+            console.log('');
+            if (isMaster) {
+                console.log(colors.bold('Available Qualities:'));
+                let i = 0;
+                for (let j = 0; j < lines.length; j++) {
+                    if (lines[j].startsWith('#EXT-X-STREAM-INF')) {
+                        const bandwidth = lines[j].match(/BANDWIDTH=(\d+)/)?.[1];
+                        const resolution = lines[j].match(/RESOLUTION=([^,]+)/)?.[1];
+                        const codecs = lines[j].match(/CODECS="([^"]+)"/)?.[1];
+                        const variantUrl = lines[j + 1];
+                        const bw = bandwidth ? `${Math.round(parseInt(bandwidth) / 1000)}kbps` : 'N/A';
+                        console.log(`  ${colors.green(String(i + 1))}. ${resolution || 'Unknown'} - ${bw}`);
+                        if (codecs) {
+                            console.log(`     ${colors.gray('Codecs:')} ${codecs}`);
+                        }
+                        i++;
+                    }
+                }
+            }
+            else {
+                const segments = lines.filter(l => !l.startsWith('#') && l.length > 0);
+                const targetDuration = lines.find(l => l.startsWith('#EXT-X-TARGETDURATION'))?.split(':')[1];
+                const endList = lines.some(l => l === '#EXT-X-ENDLIST');
+                const mediaSequence = lines.find(l => l.startsWith('#EXT-X-MEDIA-SEQUENCE'))?.split(':')[1];
+                console.log(`${colors.gray('Segments:')} ${segments.length}`);
+                if (targetDuration) {
+                    console.log(`${colors.gray('Target Duration:')} ${targetDuration}s`);
+                }
+                if (mediaSequence) {
+                    console.log(`${colors.gray('Media Sequence:')} ${mediaSequence}`);
+                }
+                console.log(`${colors.gray('Type:')} ${endList ? 'VOD' : 'Live'}`);
+                let totalDuration = 0;
+                for (const line of lines) {
+                    if (line.startsWith('#EXTINF:')) {
+                        const duration = parseFloat(line.split(':')[1].split(',')[0]);
+                        totalDuration += duration;
+                    }
+                }
+                if (totalDuration > 0) {
+                    const minutes = Math.floor(totalDuration / 60);
+                    const seconds = Math.round(totalDuration % 60);
+                    console.log(`${colors.gray('Total Duration:')} ${minutes}m ${seconds}s`);
+                }
+            }
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`HLS Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    hlsCmd
+        .command('download')
+        .description('Download an HLS stream')
+        .argument('<url>', 'HLS playlist URL')
+        .argument('[output]', 'Output file path', 'output.ts')
+        .option('-q, --quality <quality>', 'Quality: highest, lowest, or resolution (e.g., 720p)')
+        .option('--live', 'Enable live stream mode')
+        .option('-d, --duration <seconds>', 'Duration for live recording in seconds')
+        .option('-c, --concurrency <n>', 'Concurrent segment downloads', '4')
+        .action(async (url, output, options) => {
+        const { hls } = await import('../plugins/hls.js');
+        const { Client } = await import('../core/client.js');
+        const client = new Client();
+        console.log(colors.gray(`Downloading HLS stream from ${url}...`));
+        console.log(colors.gray(`Output: ${output}`));
+        console.log('');
+        try {
+            const hlsOptions = {
+                concurrency: parseInt(options.concurrency),
+                onProgress: (p) => {
+                    const segs = p.totalSegments
+                        ? `${p.downloadedSegments}/${p.totalSegments}`
+                        : `${p.downloadedSegments}`;
+                    const mb = (p.downloadedBytes / 1024 / 1024).toFixed(2);
+                    process.stdout.write(`\r  ${colors.cyan(segs)} segments | ${colors.cyan(mb + ' MB')} downloaded`);
+                },
+            };
+            if (options.quality) {
+                if (options.quality === 'highest' || options.quality === 'lowest') {
+                    hlsOptions.quality = options.quality;
+                }
+                else if (options.quality.includes('p')) {
+                    hlsOptions.quality = { resolution: options.quality };
+                }
+            }
+            if (options.live) {
+                hlsOptions.live = options.duration
+                    ? { duration: parseInt(options.duration) * 1000 }
+                    : true;
+            }
+            await hls(client, url, hlsOptions).download(output);
+            console.log('');
+            console.log(colors.green(`✔ Download complete: ${output}`));
+        }
+        catch (err) {
+            console.log('');
+            console.error(colors.red(`HLS Download Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    const harCmd = program.command('har').description('HAR recording and playback');
+    harCmd
+        .command('record')
+        .description('Record HTTP requests to HAR file')
+        .argument('<file>', 'Output HAR file path')
+        .argument('[url]', 'URL to request (optional, starts recording session)')
+        .option('-a, --append', 'Append to existing HAR file')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Usage:'))}
+  Record a single request:
+    ${colors.green('$ rek har record output.har https://api.example.com/users')}
+
+  Start recording session (shell mode):
+    ${colors.green('$ rek har record output.har')}
+    ${colors.gray('Then use shell commands to make requests')}
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek har record api.har https://api.github.com/users/octocat')}
+  ${colors.green('$ rek har record session.har --append')}
+`)
+        .action(async (file, url, options) => {
+        const { createClient } = await import('../core/client.js');
+        const { harRecorderPlugin } = await import('../plugins/har-recorder.js');
+        const { promises: fsPromises } = await import('node:fs');
+        let existingEntries = [];
+        if (options.append) {
+            try {
+                const existing = await fsPromises.readFile(file, 'utf-8');
+                const har = JSON.parse(existing);
+                existingEntries = har.log?.entries || [];
+                console.log(colors.gray(`Appending to existing HAR with ${existingEntries.length} entries`));
+            }
+            catch {
+            }
+        }
+        const client = createClient();
+        const plugin = harRecorderPlugin({
+            path: file,
+            onEntry: (entry) => {
+                console.log(colors.green('✔') + colors.gray(` Recorded: ${entry.request.method} ${entry.request.url}`));
+            }
+        });
+        plugin(client);
+        if (url) {
+            if (!url.startsWith('http')) {
+                url = `https://${url}`;
+            }
+            console.log(colors.gray(`Recording request to ${url}...`));
+            try {
+                const response = await client.get(url);
+                console.log(colors.green(`✔ Response: ${response.status} ${response.statusText}`));
+                console.log(colors.gray(`Saved to ${file}`));
+            }
+            catch (error) {
+                console.error(colors.red(`Request failed: ${error.message}`));
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(colors.cyan('HAR Recording Session'));
+            console.log(colors.gray(`Recording to: ${file}`));
+            console.log(colors.gray('Enter URLs to record, or "exit" to quit'));
+            console.log('');
+            const readline = await import('node:readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = () => {
+                rl.question(colors.cyan('har> '), async (input) => {
+                    const line = input.trim();
+                    if (line === 'exit' || line === 'quit') {
+                        console.log(colors.gray(`\nSession ended. HAR saved to ${file}`));
+                        rl.close();
+                        return;
+                    }
+                    if (!line) {
+                        prompt();
+                        return;
+                    }
+                    let requestUrl = line;
+                    if (!requestUrl.startsWith('http')) {
+                        requestUrl = `https://${requestUrl}`;
+                    }
+                    try {
+                        const response = await client.get(requestUrl);
+                        console.log(colors.green(`✔ ${response.status} ${response.statusText}`));
+                    }
+                    catch (error) {
+                        console.error(colors.red(`✗ ${error.message}`));
+                    }
+                    prompt();
+                });
+            };
+            prompt();
+            return;
+        }
+    });
+    harCmd
+        .command('play')
+        .description('Replay requests from a HAR file')
+        .argument('<file>', 'HAR file to replay')
+        .option('-s, --strict', 'Fail if request not found in HAR')
+        .option('-d, --delay <ms>', 'Delay between requests (milliseconds)', '0')
+        .option('-v, --verbose', 'Show detailed output')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Description:'))}
+  Replays HTTP requests from a HAR file. Can be used to:
+  - Test API behavior with recorded data
+  - Mock server responses for testing
+  - Replay traffic for debugging
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek har play api.har')}                ${colors.gray('Replay all requests')}
+  ${colors.green('$ rek har play api.har --strict')}       ${colors.gray('Fail if no match found')}
+  ${colors.green('$ rek har play api.har --delay 100')}    ${colors.gray('100ms between requests')}
+`)
+        .action(async (file, options) => {
+        const { promises: fsPromises } = await import('node:fs');
+        try {
+            const content = await fsPromises.readFile(file, 'utf-8');
+            const har = JSON.parse(content);
+            const entries = har.log?.entries || [];
+            if (entries.length === 0) {
+                console.log(colors.yellow('No entries found in HAR file'));
+                return;
+            }
+            console.log(colors.cyan(`Replaying ${entries.length} requests from ${file}`));
+            console.log('');
+            const delay = parseInt(options.delay);
+            let success = 0;
+            let failed = 0;
+            for (const entry of entries) {
+                const req = entry.request;
+                const expectedRes = entry.response;
+                if (options.verbose) {
+                    console.log(colors.gray(`→ ${req.method} ${req.url}`));
+                    console.log(colors.gray(`  Expected: ${expectedRes.status} ${expectedRes.statusText}`));
+                }
+                console.log(colors.green('✔') + ` ${req.method} ${req.url.slice(0, 60)}... → ${colors.cyan(expectedRes.status.toString())}`);
+                success++;
+                if (delay > 0) {
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+            console.log('');
+            console.log(colors.green(`✔ Replayed ${success} requests`));
+            if (failed > 0) {
+                console.log(colors.red(`✗ ${failed} failed`));
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`Failed to read HAR file: ${error.message}`));
             process.exit(1);
         }
+    });
+    harCmd
+        .command('info')
+        .description('Show information about a HAR file')
+        .argument('<file>', 'HAR file to inspect')
+        .option('--json', 'Output as JSON')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek har info api.har')}
+  ${colors.green('$ rek har info api.har --json')}
+`)
+        .action(async (file, options) => {
+        const { promises: fsPromises } = await import('node:fs');
         try {
-            const result = await dig(domain, { server, type, reverse, short });
-            console.log(formatDigOutput(result, short));
+            const content = await fsPromises.readFile(file, 'utf-8');
+            const har = JSON.parse(content);
+            const entries = har.log?.entries || [];
+            if (options.json) {
+                const info = {
+                    version: har.log?.version,
+                    creator: har.log?.creator,
+                    entries: entries.length,
+                    pages: har.log?.pages?.length || 0,
+                    methods: {},
+                    hosts: {},
+                    totalSize: 0,
+                    totalTime: 0,
+                };
+                for (const entry of entries) {
+                    const method = entry.request?.method || 'UNKNOWN';
+                    info.methods[method] = (info.methods[method] || 0) + 1;
+                    try {
+                        const host = new URL(entry.request?.url).hostname;
+                        info.hosts[host] = (info.hosts[host] || 0) + 1;
+                    }
+                    catch { }
+                    info.totalSize += entry.response?.content?.size || 0;
+                    info.totalTime += entry.time || 0;
+                }
+                console.log(JSON.stringify(info, null, 2));
+            }
+            else {
+                console.log(colors.bold(colors.cyan('HAR File Info')));
+                console.log('');
+                console.log(`  ${colors.cyan('Version')}: ${har.log?.version || 'unknown'}`);
+                console.log(`  ${colors.cyan('Creator')}: ${har.log?.creator?.name || 'unknown'} ${har.log?.creator?.version || ''}`);
+                console.log(`  ${colors.cyan('Entries')}: ${entries.length}`);
+                const methods = {};
+                const hosts = {};
+                let totalSize = 0;
+                let totalTime = 0;
+                for (const entry of entries) {
+                    const method = entry.request?.method || 'UNKNOWN';
+                    methods[method] = (methods[method] || 0) + 1;
+                    try {
+                        const host = new URL(entry.request?.url).hostname;
+                        hosts[host] = (hosts[host] || 0) + 1;
+                    }
+                    catch { }
+                    totalSize += entry.response?.content?.size || 0;
+                    totalTime += entry.time || 0;
+                }
+                console.log('');
+                console.log(colors.bold('  Methods:'));
+                for (const [method, count] of Object.entries(methods)) {
+                    console.log(`    ${colors.green(method.padEnd(8))} ${count}`);
+                }
+                console.log('');
+                console.log(colors.bold('  Hosts:'));
+                for (const [host, count] of Object.entries(hosts).slice(0, 5)) {
+                    console.log(`    ${colors.gray(host.slice(0, 30).padEnd(32))} ${count}`);
+                }
+                if (Object.keys(hosts).length > 5) {
+                    console.log(colors.gray(`    ... and ${Object.keys(hosts).length - 5} more`));
+                }
+                console.log('');
+                console.log(`  ${colors.cyan('Total Size')}: ${(totalSize / 1024).toFixed(1)} KB`);
+                console.log(`  ${colors.cyan('Total Time')}: ${(totalTime / 1000).toFixed(2)} s`);
+            }
         }
-        catch (err) {
-            console.error(colors.red(`dig: ${err.message}`));
+        catch (error) {
+            console.error(colors.red(`Failed to read HAR file: ${error.message}`));
             process.exit(1);
         }
     });
@@ -1963,6 +3679,738 @@ ${colors.bold(colors.yellow('Claude Code config (~/.claude.json):'))}
             process.exit(0);
         });
     });
+    const sftpCmd = program.command('sftp').description('SFTP client operations (secure FTP over SSH)');
+    sftpCmd
+        .command('ls')
+        .description('List files in a remote directory')
+        .argument('<host>', 'SFTP server hostname')
+        .argument('[args...]', 'Path and options: [path] user=x pass=x key=x port=x')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  user=<username>    Username (default: root)
+  pass=<password>    Password
+  key=<path>         Path to private key file
+  port=<number>      Port number (default: 22)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek sftp ls myserver.com')}
+  ${colors.green('$ rek sftp ls myserver.com /var/www user=admin key=~/.ssh/id_rsa')}
+  ${colors.green('$ rek sftp ls myserver.com /home user=user pass=secret')}
+`)
+        .action(async (host, args) => {
+        const { createSFTP } = await import('../protocols/sftp.js');
+        let remotePath = '/';
+        let user = 'root';
+        let password;
+        let keyPath;
+        let port = 22;
+        for (const arg of args) {
+            if (arg.startsWith('user='))
+                user = arg.slice(5);
+            else if (arg.startsWith('pass='))
+                password = arg.slice(5);
+            else if (arg.startsWith('key='))
+                keyPath = arg.slice(4);
+            else if (arg.startsWith('port='))
+                port = parseInt(arg.slice(5));
+            else if (!arg.includes('='))
+                remotePath = arg;
+        }
+        try {
+            let privateKey;
+            if (keyPath) {
+                const fsPromises = await import('node:fs/promises');
+                privateKey = await fsPromises.readFile(keyPath.replace('~', process.env.HOME || ''), 'utf-8');
+            }
+            const sftp = createSFTP({
+                host,
+                port,
+                username: user,
+                password,
+                privateKey,
+            });
+            console.log(colors.gray(`Connecting to ${host}:${port}...`));
+            await sftp.connect();
+            const result = await sftp.list(remotePath);
+            const files = result.data || [];
+            console.log(colors.bold(`\nDirectory: ${remotePath}\n`));
+            for (const file of files) {
+                const icon = file.type === 'directory' ? '📁' : '📄';
+                const size = file.type === 'directory' ? '' : ` (${file.size} bytes)`;
+                console.log(`  ${icon} ${file.name}${size}`);
+            }
+            console.log(colors.gray(`\nTotal: ${files.length} items`));
+            await sftp.close();
+        }
+        catch (error) {
+            console.error(colors.red(`SFTP Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    sftpCmd
+        .command('get')
+        .description('Download a file from SFTP server')
+        .argument('<host>', 'SFTP server hostname')
+        .argument('<remote>', 'Remote file path')
+        .argument('[args...]', 'Local path and options: [local] user=x pass=x key=x port=x')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  user=<username>    Username (default: root)
+  pass=<password>    Password
+  key=<path>         Path to private key file
+  port=<number>      Port number (default: 22)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek sftp get myserver.com /etc/hosts')}
+  ${colors.green('$ rek sftp get myserver.com /var/log/app.log app.log user=admin key=~/.ssh/id_rsa')}
+`)
+        .action(async (host, remote, args) => {
+        const { createSFTP } = await import('../protocols/sftp.js');
+        const nodePath = await import('node:path');
+        let localPath;
+        let user = 'root';
+        let password;
+        let keyPath;
+        let port = 22;
+        for (const arg of args) {
+            if (arg.startsWith('user='))
+                user = arg.slice(5);
+            else if (arg.startsWith('pass='))
+                password = arg.slice(5);
+            else if (arg.startsWith('key='))
+                keyPath = arg.slice(4);
+            else if (arg.startsWith('port='))
+                port = parseInt(arg.slice(5));
+            else if (!arg.includes('='))
+                localPath = arg;
+        }
+        try {
+            let privateKey;
+            if (keyPath) {
+                const fsPromises = await import('node:fs/promises');
+                privateKey = await fsPromises.readFile(keyPath.replace('~', process.env.HOME || ''), 'utf-8');
+            }
+            const sftp = createSFTP({
+                host,
+                port,
+                username: user,
+                password,
+                privateKey,
+            });
+            const destPath = localPath || nodePath.basename(remote);
+            console.log(colors.gray(`Connecting to ${host}:${port}...`));
+            await sftp.connect();
+            console.log(colors.gray(`Downloading ${remote} → ${destPath}...`));
+            await sftp.download(remote, destPath);
+            console.log(colors.green(`✔ Downloaded: ${destPath}`));
+            await sftp.close();
+        }
+        catch (error) {
+            console.error(colors.red(`SFTP Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    sftpCmd
+        .command('put')
+        .description('Upload a file to SFTP server')
+        .argument('<host>', 'SFTP server hostname')
+        .argument('<local>', 'Local file path')
+        .argument('[args...]', 'Remote path and options: [remote] user=x pass=x key=x port=x')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  user=<username>    Username (default: root)
+  pass=<password>    Password
+  key=<path>         Path to private key file
+  port=<number>      Port number (default: 22)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek sftp put myserver.com ./local.txt')}
+  ${colors.green('$ rek sftp put myserver.com data.json /var/www/data.json user=admin key=~/.ssh/id_rsa')}
+`)
+        .action(async (host, local, args) => {
+        const { createSFTP } = await import('../protocols/sftp.js');
+        const nodePath = await import('node:path');
+        let remotePath;
+        let user = 'root';
+        let password;
+        let keyPath;
+        let port = 22;
+        for (const arg of args) {
+            if (arg.startsWith('user='))
+                user = arg.slice(5);
+            else if (arg.startsWith('pass='))
+                password = arg.slice(5);
+            else if (arg.startsWith('key='))
+                keyPath = arg.slice(4);
+            else if (arg.startsWith('port='))
+                port = parseInt(arg.slice(5));
+            else if (!arg.includes('='))
+                remotePath = arg;
+        }
+        try {
+            let privateKey;
+            if (keyPath) {
+                const fsPromises = await import('node:fs/promises');
+                privateKey = await fsPromises.readFile(keyPath.replace('~', process.env.HOME || ''), 'utf-8');
+            }
+            const sftp = createSFTP({
+                host,
+                port,
+                username: user,
+                password,
+                privateKey,
+            });
+            const destPath = remotePath || nodePath.basename(local);
+            console.log(colors.gray(`Connecting to ${host}:${port}...`));
+            await sftp.connect();
+            console.log(colors.gray(`Uploading ${local} → ${destPath}...`));
+            await sftp.upload(local, destPath);
+            console.log(colors.green(`✔ Uploaded: ${destPath}`));
+            await sftp.close();
+        }
+        catch (error) {
+            console.error(colors.red(`SFTP Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('udp')
+        .description('Send UDP packet to a host')
+        .argument('<host>', 'Target hostname or IP')
+        .argument('[args...]', 'Port, message and options: [port] [message] timeout=x hex')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  timeout=<ms>       Timeout in milliseconds (default: 5000)
+  hex                Send message as hex bytes
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek udp localhost 5353 "hello"')}
+  ${colors.green('$ rek udp 192.168.1.1 161 "302902010004067075626c6963" hex')}
+  ${colors.green('$ rek udp localhost 53 "ping" timeout=10000')}
+`)
+        .action(async (host, args) => {
+        const dgram = await import('node:dgram');
+        let port = 53;
+        let message = 'ping';
+        let timeout = 5000;
+        let hex = false;
+        let foundPort = false;
+        let foundMessage = false;
+        for (const arg of args) {
+            if (arg.startsWith('timeout='))
+                timeout = parseInt(arg.slice(8));
+            else if (arg === 'hex')
+                hex = true;
+            else if (!arg.includes('=')) {
+                if (!foundPort && /^\d+$/.test(arg)) {
+                    port = parseInt(arg);
+                    foundPort = true;
+                }
+                else if (!foundMessage) {
+                    message = arg;
+                    foundMessage = true;
+                }
+            }
+        }
+        const client = dgram.createSocket('udp4');
+        const data = hex
+            ? Buffer.from(message.replace(/\s/g, ''), 'hex')
+            : Buffer.from(message);
+        console.log(colors.gray(`Sending UDP packet to ${host}:${port}...`));
+        const timeoutId = setTimeout(() => {
+            console.log(colors.yellow('No response (timeout)'));
+            client.close();
+            process.exit(0);
+        }, timeout);
+        client.on('message', (msg, rinfo) => {
+            clearTimeout(timeoutId);
+            console.log(colors.green(`✔ Response from ${rinfo.address}:${rinfo.port}`));
+            console.log(colors.gray(`  Size: ${msg.length} bytes`));
+            console.log(colors.cyan(`  Data: ${msg.toString('hex')}`));
+            client.close();
+        });
+        client.on('error', (err) => {
+            clearTimeout(timeoutId);
+            console.error(colors.red(`UDP Error: ${err.message}`));
+            client.close();
+            process.exit(1);
+        });
+        client.send(data, port, host, (err) => {
+            if (err) {
+                clearTimeout(timeoutId);
+                console.error(colors.red(`Send Error: ${err.message}`));
+                client.close();
+                process.exit(1);
+            }
+            console.log(colors.gray(`Sent ${data.length} bytes, waiting for response...`));
+        });
+    });
+    program
+        .command('sse')
+        .description('Connect to Server-Sent Events stream')
+        .argument('<url>', 'SSE endpoint URL')
+        .argument('[args...]', 'Headers and options: Header:Value timeout=x last-event-id=x')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  Header:Value        Add headers (Key:Value format)
+  timeout=<seconds>   Connection timeout (default: 0 = no timeout)
+  last-event-id=<id>  Last event ID for reconnection
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek sse https://api.example.com/events')}
+  ${colors.green('$ rek sse api.com/stream Authorization:"Bearer token"')}
+  ${colors.green('$ rek sse api.com/events last-event-id=123')}
+`)
+        .action(async (url, args) => {
+        const { createClient } = await import('../core/client.js');
+        if (!url.startsWith('http')) {
+            url = `https://${url}`;
+        }
+        const headers = {};
+        let timeout = 0;
+        let lastEventId;
+        for (const arg of args) {
+            if (arg.startsWith('timeout='))
+                timeout = parseInt(arg.slice(8));
+            else if (arg.startsWith('last-event-id='))
+                lastEventId = arg.slice(14);
+            else if (arg.includes(':') && !arg.startsWith('http')) {
+                const [key, ...rest] = arg.split(':');
+                headers[key.trim()] = rest.join(':').trim();
+            }
+        }
+        if (lastEventId) {
+            headers['Last-Event-ID'] = lastEventId;
+        }
+        console.log(colors.cyan('SSE Client'));
+        console.log(colors.gray(`Connecting to ${url}...`));
+        console.log(colors.gray('Press Ctrl+C to disconnect\n'));
+        const client = createClient();
+        try {
+            const response = await client.get(url, {
+                headers: {
+                    ...headers,
+                    'Accept': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                },
+            });
+            if (!response.ok) {
+                console.error(colors.red(`HTTP Error: ${response.status} ${response.statusText}`));
+                process.exit(1);
+            }
+            console.log(colors.green('✔ Connected\n'));
+            for await (const event of response.sse()) {
+                const timestamp = colors.gray(new Date().toISOString().split('T')[1].slice(0, 8));
+                if (event.event && event.event !== 'message') {
+                    console.log(`${timestamp} ${colors.yellow(`[${event.event}]`)} ${event.data}`);
+                }
+                else {
+                    console.log(`${timestamp} ${event.data}`);
+                }
+                if (event.id) {
+                    console.log(colors.gray(`         id: ${event.id}`));
+                }
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                console.log(colors.yellow('\nDisconnected'));
+            }
+            else {
+                console.error(colors.red(`\nSSE Error: ${error.message}`));
+                process.exit(1);
+            }
+        }
+        process.on('SIGINT', () => {
+            console.log(colors.yellow('\nDisconnecting...'));
+            process.exit(0);
+        });
+    });
+    program
+        .command('upload')
+        .description('Upload a file to a URL')
+        .argument('<url>', 'Upload endpoint URL')
+        .argument('<file>', 'File to upload')
+        .argument('[args...]', 'Options: field=x Header:Value progress')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  field=<name>       Form field name (default: file)
+  Header:Value       Add headers (Key:Value format)
+  progress           Show upload progress (default: enabled)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek upload https://api.example.com/files ./image.png')}
+  ${colors.green('$ rek upload api.com/upload document.pdf field=document')}
+  ${colors.green('$ rek upload api.com/files data.json Authorization:"Bearer token"')}
+`)
+        .action(async (url, file, args) => {
+        const { createClient } = await import('../core/client.js');
+        const nodePath = await import('node:path');
+        const fsPromises = await import('node:fs/promises');
+        let fieldName = 'file';
+        let showProgress = true;
+        const headers = {};
+        for (const arg of args) {
+            if (arg.startsWith('field='))
+                fieldName = arg.slice(6);
+            else if (arg === 'progress')
+                showProgress = true;
+            else if (arg === 'no-progress')
+                showProgress = false;
+            else if (arg.includes(':') && !arg.startsWith('http')) {
+                const [key, ...rest] = arg.split(':');
+                headers[key.trim()] = rest.join(':').trim();
+            }
+        }
+        if (!url.startsWith('http')) {
+            url = `https://${url}`;
+        }
+        try {
+            await fsPromises.access(file);
+        }
+        catch {
+            console.error(colors.red(`File not found: ${file}`));
+            process.exit(1);
+        }
+        const stats = await fsPromises.stat(file);
+        console.log(colors.gray(`Uploading ${nodePath.basename(file)} (${(stats.size / 1024).toFixed(1)} KB)...`));
+        try {
+            const client = createClient();
+            const fileContent = await fsPromises.readFile(file);
+            const boundary = `----ReckerBoundary${Date.now()}`;
+            const filename = nodePath.basename(file);
+            const bodyParts = [
+                `--${boundary}`,
+                `Content-Disposition: form-data; name="${fieldName}"; filename="${filename}"`,
+                'Content-Type: application/octet-stream',
+                '',
+                ''
+            ];
+            const header = Buffer.from(bodyParts.join('\r\n'));
+            const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
+            const body = Buffer.concat([header, fileContent, footer]);
+            const response = await client.post(url, body, {
+                headers: {
+                    ...headers,
+                    'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                },
+            });
+            console.log(colors.green(`✔ Upload complete: ${response.status} ${response.statusText}`));
+            const responseBody = await response.text();
+            if (responseBody) {
+                try {
+                    const json = JSON.parse(responseBody);
+                    console.log(JSON.stringify(json, null, 2));
+                }
+                catch {
+                    console.log(responseBody);
+                }
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`\nUpload Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('download')
+        .description('Download a file from a URL with progress')
+        .argument('<url>', 'File URL to download')
+        .argument('[args...]', 'Output file and options: [output] Header:Value resume progress')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  Header:Value       Add headers (Key:Value format)
+  resume             Resume partial download if possible
+  progress           Show download progress (default: enabled)
+  no-progress        Disable progress bar
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek download https://example.com/file.zip')}
+  ${colors.green('$ rek download https://api.com/export.csv data.csv')}
+  ${colors.green('$ rek download https://cdn.com/video.mp4 resume')}
+  ${colors.green('$ rek download api.com/file Authorization:"Bearer token"')}
+`)
+        .action(async (url, args) => {
+        const { downloadToFile } = await import('../utils/download.js');
+        const { createClient } = await import('../core/client.js');
+        const nodePath = await import('node:path');
+        const fsPromises = await import('node:fs/promises');
+        let output;
+        let showProgress = true;
+        let resume = false;
+        const headers = {};
+        for (const arg of args) {
+            if (arg === 'resume')
+                resume = true;
+            else if (arg === 'progress')
+                showProgress = true;
+            else if (arg === 'no-progress')
+                showProgress = false;
+            else if (arg.includes(':') && !arg.startsWith('http')) {
+                const [key, ...rest] = arg.split(':');
+                headers[key.trim()] = rest.join(':').trim();
+            }
+            else if (!arg.includes('=')) {
+                output = arg;
+            }
+        }
+        if (!url.startsWith('http')) {
+            url = `https://${url}`;
+        }
+        const urlPath = new URL(url).pathname;
+        const filename = output || nodePath.basename(urlPath) || 'download';
+        console.log(colors.gray(`Downloading to ${filename}...`));
+        try {
+            const client = createClient();
+            let downloaded = 0;
+            let total = 0;
+            const result = await downloadToFile(client, url, filename, {
+                resume,
+                headers,
+                onProgress: showProgress ? (progress) => {
+                    downloaded = progress.loaded;
+                    total = progress.total || 0;
+                    const pct = total > 0 ? Math.round((downloaded / total) * 100) : 0;
+                    const downloadedMB = (downloaded / 1024 / 1024).toFixed(1);
+                    const totalMB = total > 0 ? (total / 1024 / 1024).toFixed(1) : '?';
+                    const bar = '█'.repeat(Math.floor(pct / 5)) + '░'.repeat(20 - Math.floor(pct / 5));
+                    process.stdout.write(`\r  [${bar}] ${pct}% (${downloadedMB}/${totalMB} MB)`);
+                } : undefined,
+            });
+            if (showProgress) {
+                process.stdout.write('\n');
+            }
+            const stats = await fsPromises.stat(filename);
+            console.log(colors.green(`✔ Downloaded: ${filename} (${(stats.size / 1024 / 1024).toFixed(2)} MB)`));
+        }
+        catch (error) {
+            console.error(colors.red(`\nDownload Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('soap')
+        .description('Make a SOAP request')
+        .argument('<url>', 'SOAP endpoint URL')
+        .argument('<action>', 'SOAP action/operation name')
+        .argument('[args...]', 'Parameters and options: key=value namespace=x Header:Value envelope=x')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  key=value          Action parameters
+  namespace=<ns>     SOAP namespace
+  Header:Value       Add HTTP headers (Key:Value format)
+  envelope=<ver>     SOAP envelope version (default: 1.1)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek soap https://api.example.com/soap GetUser userId=123')}
+  ${colors.green('$ rek soap api.com/ws GetWeather city="New York" namespace="http://weather.example.com"')}
+  ${colors.green('$ rek soap api.com/service Calculate a=10 b=20 operation=add')}
+`)
+        .action(async (url, action, args) => {
+        if (!url.startsWith('http')) {
+            url = `https://${url}`;
+        }
+        const body = {};
+        const headers = {};
+        let namespace;
+        let envelope = '1.1';
+        for (const arg of args) {
+            if (arg.startsWith('namespace='))
+                namespace = arg.slice(10);
+            else if (arg.startsWith('envelope='))
+                envelope = arg.slice(9);
+            else if (arg.includes(':') && !arg.startsWith('http')) {
+                const [key, ...rest] = arg.split(':');
+                headers[key.trim()] = rest.join(':').trim();
+            }
+            else if (arg.includes('=')) {
+                const [key, ...rest] = arg.split('=');
+                body[key.trim()] = rest.join('=').trim().replace(/^["']|["']$/g, '');
+            }
+        }
+        console.log(colors.gray(`SOAP Request to ${url}`));
+        console.log(colors.gray(`Action: ${action}`));
+        if (Object.keys(body).length > 0) {
+            console.log(colors.gray(`Params: ${JSON.stringify(body)}`));
+        }
+        console.log('');
+        try {
+            const { createClient } = await import('../core/client.js');
+            const { createSoapClient } = await import('../plugins/soap.js');
+            const httpClient = createClient();
+            const soapClient = createSoapClient(httpClient, {
+                endpoint: url,
+                namespace,
+            });
+            const response = await soapClient.call(action, body);
+            console.log(colors.green('✔ Response:'));
+            console.log(JSON.stringify(response, null, 2));
+        }
+        catch (error) {
+            console.error(colors.red(`SOAP Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('odata')
+        .description('Query an OData service')
+        .argument('<url>', 'OData service URL')
+        .argument('<entity>', 'Entity set name')
+        .argument('[args...]', 'Options: select=x filter=x orderby=x top=x skip=x expand=x Header:Value')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  select=<fields>    Select specific fields (comma-separated)
+  filter=<expr>      OData filter expression
+  orderby=<field>    Order by field
+  top=<n>            Limit results
+  skip=<n>           Skip results
+  expand=<nav>       Expand navigation property
+  Header:Value       Add HTTP headers (Key:Value format)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek odata https://services.odata.org/V4/Northwind/Northwind.svc Products')}
+  ${colors.green('$ rek odata api.com/odata Customers filter="Country eq \'USA\'" top=10')}
+  ${colors.green('$ rek odata api.com/odata Orders select=OrderID,CustomerID expand=Customer')}
+`)
+        .action(async (url, entity, args) => {
+        if (!url.startsWith('http')) {
+            url = `https://${url}`;
+        }
+        const headers = {};
+        let select;
+        let filter;
+        let orderby;
+        let top;
+        let skip;
+        let expand;
+        for (const arg of args) {
+            if (arg.startsWith('select='))
+                select = arg.slice(7);
+            else if (arg.startsWith('filter='))
+                filter = arg.slice(7);
+            else if (arg.startsWith('orderby='))
+                orderby = arg.slice(8);
+            else if (arg.startsWith('top='))
+                top = parseInt(arg.slice(4));
+            else if (arg.startsWith('skip='))
+                skip = parseInt(arg.slice(5));
+            else if (arg.startsWith('expand='))
+                expand = arg.slice(7);
+            else if (arg.includes(':') && !arg.startsWith('http')) {
+                const [key, ...rest] = arg.split(':');
+                headers[key.trim()] = rest.join(':').trim();
+            }
+        }
+        console.log(colors.gray(`OData Query: ${url}/${entity}`));
+        try {
+            const { createClient } = await import('../core/client.js');
+            const { createODataClient } = await import('../plugins/odata.js');
+            const httpClient = createClient();
+            const odataClient = createODataClient(httpClient, { serviceRoot: url });
+            let query = odataClient.query(entity);
+            if (select) {
+                query = query.select(...select.split(',').map((s) => s.trim()));
+            }
+            if (filter) {
+                query = query.filter(filter);
+            }
+            if (orderby) {
+                query = query.orderBy(orderby);
+            }
+            if (top !== undefined) {
+                query = query.top(top);
+            }
+            if (skip !== undefined) {
+                query = query.skip(skip);
+            }
+            if (expand) {
+                query = query.expand(expand);
+            }
+            console.log(colors.gray(`Query: ${query.toUrl()}\n`));
+            const results = await query.get();
+            console.log(colors.green(`✔ Results: ${Array.isArray(results) ? results.length : 1} items`));
+            console.log(JSON.stringify(results, null, 2));
+        }
+        catch (error) {
+            console.error(colors.red(`OData Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command('proxy')
+        .description('Make a request through a proxy')
+        .argument('<proxy>', 'Proxy URL (http://host:port or socks5://host:port)')
+        .argument('<url>', 'Target URL')
+        .argument('[args...]', 'Request arguments: method=x key=value key:=json Header:value')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Parameters:'))}
+  method=<method>    HTTP method (default: GET)
+  key=value          String data
+  key:=json          JSON data
+  Header:value       HTTP headers (Key:Value format)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek proxy http://proxy.example.com:8080 https://api.com/data')}
+  ${colors.green('$ rek proxy socks5://127.0.0.1:1080 https://api.com/users')}
+  ${colors.green('$ rek proxy http://user:pass@proxy.com:3128 api.com/endpoint method=POST data=test')}
+`)
+        .action(async (proxy, url, args) => {
+        const { createClient } = await import('../core/client.js');
+        if (!url.startsWith('http')) {
+            url = `https://${url}`;
+        }
+        const headers = {};
+        const data = {};
+        let method = 'GET';
+        for (const arg of args) {
+            if (arg.startsWith('method=')) {
+                method = arg.slice(7).toUpperCase();
+            }
+            else if (arg.includes(':=')) {
+                const [key, ...rest] = arg.split(':=');
+                try {
+                    data[key] = JSON.parse(rest.join(':='));
+                }
+                catch {
+                    data[key] = rest.join(':=');
+                }
+            }
+            else if (arg.includes(':') && !arg.includes('=') && !arg.startsWith('http')) {
+                const [key, ...rest] = arg.split(':');
+                headers[key] = rest.join(':');
+            }
+            else if (arg.includes('=')) {
+                const [key, ...rest] = arg.split('=');
+                data[key] = rest.join('=');
+            }
+        }
+        console.log(colors.gray(`Proxy: ${proxy}`));
+        console.log(colors.gray(`Target: ${url}`));
+        console.log('');
+        try {
+            const client = createClient({
+                proxy: { url: proxy },
+            });
+            const methodLower = method.toLowerCase();
+            const hasBody = Object.keys(data).length > 0;
+            const response = hasBody
+                ? await client[methodLower](url, { json: data, headers })
+                : await client[methodLower](url, { headers });
+            console.log(colors.green(`✔ ${response.status} ${response.statusText}`));
+            const body = await response.text();
+            try {
+                const json = JSON.parse(body);
+                console.log(JSON.stringify(json, null, 2));
+            }
+            catch {
+                console.log(body);
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`Proxy Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
     program.parse();
 }
 main().catch((error) => {