recker 1.0.43 → 1.0.44-next.084c2ef

package/dist/cli/commands/spider.js

@@ -0,0 +1,478 @@
+import { promises as fs } from 'node:fs';
+import colors from '../../utils/colors.js';
+import { summarizeErrors, formatErrorSummary } from '../helpers.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+const schema = {
+    name: 'spider',
+    description: 'Crawl a website and analyze all pages.\nThe crawler respects robots.txt, handles JavaScript-rendered content, and provides detailed reports on site structure, broken links, and SEO issues.',
+    params: {
+        depth: { type: 'number', default: 5, description: 'Max link depth to follow' },
+        limit: { type: 'number', default: 100, description: 'Max pages to crawl' },
+        concurrency: { type: 'number', default: 5, description: 'Parallel requests' },
+        output: { type: 'string', description: 'Save JSON report to file' },
+        focus: { type: 'string', default: 'all', choices: ['all', 'links', 'duplicates', 'security', 'ai', 'resources'], description: 'Focus analysis on specific area (requires seo)' }
+    },
+    keywords: {
+        seo: { description: 'Enable SEO analysis mode' }
+    },
+    flags: {
+        json: { description: 'Output JSON to stdout', alias: 'j' },
+        robots: { description: 'Respect robots.txt rules', default: false }
+    },
+    examples: [
+        { cmd: 'rek spider example.com', desc: 'Crawl (ignores robots.txt)' },
+        { cmd: 'rek spider example.com --robots', desc: 'Crawl respecting robots.txt' },
+        { cmd: 'rek spider example.com depth=3 limit=50', desc: 'Depth 3, max 50 pages' },
+        { cmd: 'rek spider example.com seo focus=security', desc: 'Focus on security issues' },
+        { cmd: 'rek spider example.com seo output=report.json', desc: 'SEO with JSON export' }
+    ]
+};
+export async function runSpider(rawArgs, defaultUrl) {
+    const { data, options, args } = RekArgs.parse(rawArgs, schema);
+    let url = args[0];
+    if (!url && defaultUrl) {
+        url = defaultUrl;
+    }
+    const formatJson = options.json || data.format === 'json';
+    const outputFile = data.output;
+    const seoEnabled = data.seo;
+    const focusMode = data.focus;
+    const respectRobotsTxt = !!options.robots;
+    const focusCategories = {
+        links: ['links'],
+        duplicates: ['title', 'meta', 'content'],
+        security: ['security'],
+        ai: ['ai-search'],
+        resources: ['resources', 'performance'],
+        all: [],
+    };
+    if (!url) {
+        if (!formatJson) {
+            console.log(colors.yellow('Usage: spider <url> [options]'));
+            console.log(generateHelp(schema));
+        }
+        return;
+    }
+    if (!url.startsWith('http'))
+        url = `https://${url}`;
+    if (!formatJson) {
+        const modeLabel = seoEnabled ? colors.magenta(' + SEO') : '';
+        const focusLabel = focusMode !== 'all' ? colors.cyan(` [focus: ${focusMode}]`) : '';
+        console.log(colors.cyan(`
+Spider starting: ${url}`));
+        console.log(colors.gray(`  Depth: ${data.depth} | Limit: ${data.limit} | Concurrency: ${data.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: data.depth,
+                maxPages: data.limit,
+                concurrency: data.concurrency,
+                sameDomain: true,
+                delay: 100,
+                seo: true,
+                respectRobotsTxt,
+                output: outputFile || undefined,
+                focusCategories: focusCategories[focusMode],
+                focusMode: focusMode,
+                onProgress: formatJson ? undefined : (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);
+            if (formatJson) {
+                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 statusCounts = {};
+                for (const page of result.pages) {
+                    const key = page.status?.toString() || 'error';
+                    statusCounts[key] = (statusCounts[key] || 0) + 1;
+                }
+                let totalInternalLinks = 0;
+                let totalExternalLinks = 0;
+                let totalImages = 0;
+                let imagesWithoutAlt = 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;
+                    }
+                }
+                const jsonOutput = {
+                    startUrl: url,
+                    crawledAt: new Date().toISOString(),
+                    duration: result.duration,
+                    config: {
+                        maxDepth: data.depth,
+                        maxPages: data.limit,
+                        concurrency: data.concurrency,
+                        focusMode,
+                    },
+                    summary: {
+                        totalPages: result.pages.length,
+                        uniqueUrls: result.visited.size,
+                        avgSeoScore: result.summary.avgScore,
+                        avgResponseTime,
+                        pagesWithErrors: result.summary.pagesWithErrors,
+                        pagesWithWarnings: result.summary.pagesWithWarnings,
+                        duplicateTitles: result.summary.duplicateTitles,
+                        duplicateDescriptions: result.summary.duplicateDescriptions,
+                        duplicateH1s: result.summary.duplicateH1s,
+                        orphanPages: result.summary.orphanPages,
+                    },
+                    discovery: result.discovery ? {
+                        humans: result.discovery.humans.found,
+                        llms: result.discovery.llms.found,
+                        sitemap: result.discovery.sitemap.found,
+                        manifest: result.discovery.manifest.found ? {
+                            valid: result.discovery.manifest.valid,
+                            issues: result.discovery.manifest.issues,
+                        } : undefined,
+                    } : undefined,
+                    rssFeeds: result.rssFeeds,
+                    content: {
+                        totalInternalLinks,
+                        totalExternalLinks,
+                        totalImages,
+                        imagesWithoutAlt,
+                    },
+                    httpStatus: statusCounts,
+                    siteWideIssues: result.siteWideIssues.map(issue => ({
+                        type: issue.type,
+                        severity: issue.severity,
+                        message: issue.message,
+                        value: issue.value,
+                        affectedUrls: issue.affectedUrls,
+                    })),
+                    pages: result.pages.map(page => ({
+                        url: page.url,
+                        status: page.status,
+                        depth: page.depth,
+                        duration: page.duration,
+                        title: page.title,
+                        error: page.error,
+                        seo: page.seoReport ? {
+                            score: page.seoReport.score,
+                            grade: page.seoReport.grade,
+                            title: page.seoReport.title,
+                            metaDescription: page.seoReport.metaDescription,
+                            headings: page.seoReport.headings,
+                            links: page.seoReport.links,
+                            images: page.seoReport.images,
+                            checks: page.seoReport.checks,
+                        } : null,
+                    })),
+                    errors: result.pages.filter(p => p.error).map(p => ({
+                        url: p.url,
+                        status: p.status,
+                        error: p.error
+                    })),
+                };
+                console.log(JSON.stringify(jsonOutput, null, 2));
+                return;
+            }
+            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 key = page.status ? page.status.toString() : 'error';
+                statusCounts.set(key, (statusCounts.get(key) || 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 [statusKey, count] of sortedStatuses.slice(0, 5)) {
+                const statusNum = parseInt(statusKey);
+                const statusColor = statusNum >= 400 ? colors.red :
+                    statusNum >= 300 ? colors.yellow :
+                        statusKey === 'error' ? colors.red : colors.green;
+                const pct = ((count / result.pages.length) * 100).toFixed(0);
+                console.log(`    ${statusColor(statusKey.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.discovery) {
+                console.log(colors.bold('\n  Discovery:'));
+                const { humans, llms, sitemap, manifest } = result.discovery;
+                if (humans.found)
+                    console.log(`    ${colors.green('✔')} humans.txt found`);
+                if (llms.found)
+                    console.log(`    ${colors.green('✔')} llms.txt found`);
+                if (sitemap.found) {
+                    const urlCount = sitemap.urlCount ? ` (${sitemap.urlCount} URLs)` : '';
+                    console.log(`    ${colors.green('✔')} sitemap.xml found${urlCount}`);
+                }
+                if (manifest.found) {
+                    const status = manifest.valid ? colors.green('valid') : colors.yellow('invalid');
+                    console.log(`    ${colors.green('✔')} manifest.json found (${status})`);
+                    if (manifest.issues && manifest.issues.length > 0) {
+                        manifest.issues.slice(0, 3).forEach(issue => {
+                            console.log(`      ${colors.yellow('⚠')} ${issue}`);
+                        });
+                        if (manifest.issues.length > 3) {
+                            console.log(`      ${colors.gray(`...and ${manifest.issues.length - 3} more issues`)}`);
+                        }
+                    }
+                }
+                if (!humans.found && !llms.found && !sitemap.found && !manifest.found) {
+                    console.log(`    ${colors.gray('○')} No discovery files found`);
+                }
+            }
+            if (result.rssFeeds && result.rssFeeds.length > 0) {
+                console.log(colors.bold('\n  RSS/Atom Feeds:'));
+                result.rssFeeds.forEach(feed => {
+                    const typeLabel = feed.type === 'rss' ? 'RSS' : 'Atom';
+                    const title = feed.title ? `"${feed.title}"` : 'Untitled';
+                    const count = feed.itemCount > 0 ? `(${feed.itemCount} items)` : '';
+                    console.log(`    ${colors.green('✔')} ${colors.cyan(typeLabel)} ${title} ${colors.gray(count)}`);
+                    console.log(`      ${colors.gray(feed.url)}`);
+                });
+            }
+            if (result.siteWideIssues.length > 0) {
+                console.log(colors.bold('\n  Site-Wide Issues:'));
+                const sortedIssues = [...result.siteWideIssues].sort((a, b) => {
+                    const priority = { error: 0, warning: 1, info: 2 };
+                    return priority[a.severity] - priority[b.severity];
+                });
+                for (const issue of sortedIssues.slice(0, 10)) {
+                    const icon = issue.severity === 'error' ? colors.red('✗') :
+                        issue.severity === 'warning' ? colors.yellow('⚠') : colors.gray('○');
+                    const colorFn = issue.severity === 'error' ? colors.red :
+                        issue.severity === 'warning' ? colors.yellow : colors.gray;
+                    console.log(`    ${icon} ${colorFn(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 => {
+                            try {
+                                return new URL(u).pathname;
+                            }
+                            catch {
+                                return u;
+                            }
+                        }))];
+                    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: data.depth,
+                maxPages: data.limit,
+                concurrency: data.concurrency,
+                sameDomain: true,
+                delay: 100,
+                respectRobotsTxt,
+                onProgress: formatJson ? undefined : (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);
+            if (formatJson) {
+                const jsonOutput = {
+                    startUrl: result.startUrl,
+                    crawledAt: new Date().toISOString(),
+                    duration: result.duration,
+                    config: {
+                        maxDepth: data.depth,
+                        maxPages: data.limit,
+                        concurrency: data.concurrency,
+                    },
+                    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,
+                        meta: p.meta,
+                        metrics: p.metrics,
+                        social: p.social,
+                    })), errors: result.pages.filter(p => p.error).map(p => ({
+                        url: p.url,
+                        status: p.status,
+                        error: p.error
+                    })),
+                };
+                console.log(JSON.stringify(jsonOutput, null, 2));
+                return;
+            }
+            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}`);
+                }
+            }
+            if (result.errors.length > 0) {
+                const errorSummary = summarizeErrors(result.errors);
+                console.log(formatErrorSummary(errorSummary));
+            }
+            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,
+                        meta: p.meta,
+                        metrics: p.metrics,
+                        social: p.social,
+                    })), errors: result.pages.filter(p => p.error).map(p => ({
+                        url: p.url,
+                        status: p.status,
+                        error: p.error
+                    })),
+                };
+                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);
+    }
+}
+export function registerSpiderCommand(program) {
+    program
+        .command('spider')
+        .alias('crawl')
+        .description('Crawl a website and analyze all pages')
+        .argument('<url>', 'Starting URL to crawl')
+        .argument('[args...]', 'Options: depth=N limit=N concurrency=N seo focus=MODE...')
+        .addHelpText('after', generateHelp(schema))
+        .action(async (url, rawArgs) => {
+        await runSpider([url, ...rawArgs]);
+    });
+}

package/dist/cli/commands/utils.d.ts

@@ -0,0 +1,2 @@
+import { RekCommand as Command } from '../router.js';
+export declare function registerUtilsCommands(program: Command): void;

package/dist/cli/commands/utils.js

@@ -0,0 +1,176 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+import { promises as fs } from 'node:fs';
+import pathMod from 'node:path';
+import { installCurlImpersonate, hasImpersonate, getCurlPath } from '../../utils/binary-manager.js';
+const uploadSchema = {
+    name: 'upload',
+    description: 'Upload a file to a URL',
+    params: {
+        field: { type: 'string', default: 'file', description: 'Form field name' },
+    },
+    flags: {
+        progress: { description: 'Show upload progress', default: true },
+        'no-progress': { description: 'Disable progress bar' }
+    },
+    examples: [
+        { cmd: 'rek upload api.com/files ./image.png', desc: 'Simple upload' },
+        { cmd: 'rek upload api.com/files data.json field=doc', desc: 'Custom field' }
+    ]
+};
+const downloadSchema = {
+    name: 'download',
+    description: 'Download a file from a URL',
+    flags: {
+        resume: { description: 'Resume partial download', default: false },
+        progress: { description: 'Show progress', default: true },
+        'no-progress': { description: 'Disable progress' }
+    },
+    examples: [
+        { cmd: 'rek download example.com/file.zip', desc: 'Download' },
+        { cmd: 'rek download example.com/large.iso resume', desc: 'Resume download' }
+    ]
+};
+const proxySchema = {
+    name: 'proxy',
+    description: 'Route requests through a proxy',
+    params: {
+        method: { type: 'string', default: 'GET', description: 'HTTP Method' },
+    },
+    examples: [
+        { cmd: 'rek proxy http://127.0.0.1:8080 api.com/get', desc: 'Proxy GET' },
+        { cmd: 'rek proxy socks5://127.0.0.1:9050 api.com/post method=POST', desc: 'SOCKS5 POST' }
+    ]
+};
+export function registerUtilsCommands(program) {
+    program.command('upload')
+        .description(uploadSchema.description)
+        .argument('<url>', 'Target URL')
+        .argument('<file>', 'File path')
+        .argument('[args...]', 'Options')
+        .addHelpText('after', generateHelp(uploadSchema))
+        .action(async (url, file, rawArgs) => {
+        const { data, options, headers } = RekArgs.parse(rawArgs, uploadSchema);
+        const showProgress = options['no-progress'] ? false : (options.progress !== false);
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createClient } = await import('../../core/client.js');
+        try {
+            await fs.access(file);
+            const stats = await fs.stat(file);
+            console.log(colors.gray(`Uploading ${pathMod.basename(file)} (${(stats.size / 1024).toFixed(1)} KB)...`));
+            const client = createClient();
+            const fileContent = await fs.readFile(file);
+            const boundary = `----ReckerBoundary${Date.now()}`;
+            const filename = pathMod.basename(file);
+            const bodyParts = [
+                `--${boundary}`,
+                `Content-Disposition: form-data; name="${data.field}"; 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 text = await response.text();
+            if (text)
+                console.log(text);
+        }
+        catch (err) {
+            console.error(colors.red(`Upload Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('download')
+        .description(downloadSchema.description)
+        .argument('<url>', 'Source URL')
+        .argument('[args...]', 'Output path and options')
+        .addHelpText('after', generateHelp(downloadSchema))
+        .action(async (url, rawArgs) => {
+        const { options, headers, args } = RekArgs.parse(rawArgs, downloadSchema);
+        const output = args[0];
+        const showProgress = options['no-progress'] ? false : (options.progress !== false);
+        const resume = !!options.resume;
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { downloadToFile } = await import('../../utils/download.js');
+        const { createClient } = await import('../../core/client.js');
+        const urlPath = new URL(url).pathname;
+        const filename = output || pathMod.basename(urlPath) || 'download';
+        console.log(colors.gray(`Downloading to ${filename}...`));
+        try {
+            const client = createClient();
+            await downloadToFile(client, url, filename, {
+                resume,
+                headers,
+                onProgress: showProgress ? (p) => {
+                    const total = p.total || 0;
+                    const pct = total > 0 ? Math.round((p.loaded / total) * 100) : 0;
+                    const mb = (p.loaded / 1024 / 1024).toFixed(1);
+                    process.stdout.write(`\r  ${pct}% (${mb} MB)`);
+                } : undefined
+            });
+            if (showProgress)
+                process.stdout.write('\n');
+            console.log(colors.green(`✔ Download complete`));
+        }
+        catch (err) {
+            console.error(colors.red(`Download Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('proxy')
+        .description(proxySchema.description)
+        .argument('<proxy>', 'Proxy URL')
+        .argument('<target>', 'Target URL')
+        .argument('[args...]', 'Request options')
+        .addHelpText('after', generateHelp(proxySchema))
+        .action(async (proxy, target, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, proxySchema);
+        if (!target.startsWith('http'))
+            target = `https://${target}`;
+        console.log(colors.gray(`Proxy: ${proxy}`));
+        console.log(colors.gray(`Target: ${target}`));
+        const { createClient } = await import('../../core/client.js');
+        try {
+            const client = createClient({ proxy: { url: proxy } });
+            const method = data.method.toLowerCase();
+            const body = { ...data };
+            delete body.method;
+            const hasBody = Object.keys(body).length > 0;
+            const options = hasBody ? { json: body, headers } : { headers };
+            const response = await client[method](target, options);
+            console.log(colors.green(`✔ ${response.status} ${response.statusText}`));
+            console.log(await response.text());
+        }
+        catch (err) {
+            console.error(colors.red(`Proxy Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('setup')
+        .description('Install external dependencies (curl-impersonate) for advanced features')
+        .action(async () => {
+        if (await hasImpersonate()) {
+            console.log(colors.green(`✔ curl-impersonate is already installed at:`));
+            console.log(colors.gray(getCurlPath()));
+            return;
+        }
+        try {
+            console.log(colors.cyan('Installing curl-impersonate...'));
+            await installCurlImpersonate(console);
+        }
+        catch (e) {
+            console.error(colors.red(`Installation failed: ${e.message}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/vector.d.ts

@@ -0,0 +1,2 @@
+import { RekCommand as Command } from '../router.js';
+export declare function registerVectorCommand(program: Command): void;