recker 1.0.43 → 1.0.44-next.084c2ef

package/dist/cli/commands/dns.js

@@ -0,0 +1,295 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+const propagateSchema = {
+    name: 'propagate',
+    description: 'Check global DNS propagation across multiple providers',
+    examples: [
+        { cmd: 'rek dns propagate example.com', desc: 'Check A record' },
+        { cmd: 'rek dns propagate example.com MX', desc: 'Check MX record' }
+    ]
+};
+const lookupSchema = {
+    name: 'lookup',
+    description: 'Look up DNS records (A, MX, TXT, etc)',
+    examples: [
+        { cmd: 'rek dns lookup google.com', desc: 'A records' },
+        { cmd: 'rek dns lookup google.com MX', desc: 'MX records' },
+        { cmd: 'rek dns lookup google.com ANY', desc: 'All records' }
+    ]
+};
+const reverseSchema = {
+    name: 'reverse',
+    description: 'Perform reverse DNS lookup (IP to hostname)',
+    examples: [
+        { cmd: 'rek dns reverse 8.8.8.8', desc: 'Lookup Google DNS IP' }
+    ]
+};
+const healthSchema = {
+    name: 'health',
+    description: 'Comprehensive DNS health check with scoring',
+    examples: [
+        { cmd: 'rek dns health example.com', desc: 'Check domain health' }
+    ]
+};
+const spfSchema = {
+    name: 'spf',
+    description: 'Validate SPF record',
+    examples: [
+        { cmd: 'rek dns spf example.com', desc: 'Validate SPF' }
+    ]
+};
+const dmarcSchema = {
+    name: 'dmarc',
+    description: 'Validate DMARC record',
+    examples: [
+        { cmd: 'rek dns dmarc example.com', desc: 'Validate DMARC' }
+    ]
+};
+const dkimSchema = {
+    name: 'dkim',
+    description: 'Check DKIM record for a domain',
+    params: {
+        selector: { type: 'string', default: 'default', description: 'DKIM selector' }
+    },
+    examples: [
+        { cmd: 'rek dns dkim example.com', desc: 'Default selector' },
+        { cmd: 'rek dns dkim example.com selector=google', desc: 'Google selector' }
+    ]
+};
+const emailSchema = {
+    name: 'email',
+    description: 'Full email security audit (SPF + DMARC + DKIM + MX)',
+    params: {
+        selector: { type: 'string', default: 'default', description: 'DKIM selector' }
+    },
+    examples: [
+        { cmd: 'rek dns email example.com', desc: 'Full audit' }
+    ]
+};
+const systemSchema = {
+    name: 'system',
+    description: 'Show system DNS configuration (OS-level)',
+    examples: [
+        { cmd: 'rek dns system', desc: 'Show current DNS servers' }
+    ]
+};
+export function registerDnsCommands(program) {
+    const dns = program.command('dns').description('DNS tools and diagnostics');
+    dns.command('propagate')
+        .description(propagateSchema.description)
+        .argument('<domain>', 'Domain')
+        .argument('[type]', 'Record Type', 'A')
+        .addHelpText('after', generateHelp(propagateSchema))
+        .action(async (domain, type) => {
+        const { checkPropagation, formatPropagationReport } = await import('../../dns/propagation.js');
+        console.log(colors.gray(`Checking propagation for ${domain} (${type})...`));
+        const results = await checkPropagation(domain, type);
+        console.log(formatPropagationReport(results, domain, type));
+    });
+    dns.command('lookup')
+        .alias('resolve')
+        .description(lookupSchema.description)
+        .argument('<domain>', 'Domain')
+        .argument('[type]', 'Type', 'A')
+        .addHelpText('after', generateHelp(lookupSchema))
+        .action(async (domain, type) => {
+        const { dnsLookup } = await import('../../utils/dns-toolkit.js');
+        console.log(colors.gray(`Looking up ${type.toUpperCase()} records for ${domain}...`));
+        try {
+            const results = await dnsLookup(domain, type);
+            if (results.length === 0) {
+                console.log(colors.yellow(`\nNo ${type.toUpperCase()} records found for ${domain}`));
+                return;
+            }
+            console.log(`\n${colors.bold(colors.cyan('DNS Lookup Results'))}`);
+            results.forEach(record => {
+                const data = typeof record.data === 'object' ? JSON.stringify(record.data) : String(record.data);
+                console.log(`  ${colors.green('•')} ${colors.bold(record.type.padEnd(6))} ${data}`);
+            });
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`DNS Lookup Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    dns.command('reverse')
+        .description(reverseSchema.description)
+        .argument('<ip>', 'IP Address')
+        .addHelpText('after', generateHelp(reverseSchema))
+        .action(async (ip) => {
+        const { reverseLookup } = await import('../../utils/dns-toolkit.js');
+        console.log(colors.gray(`Performing reverse lookup for ${ip}...`));
+        try {
+            const hostnames = await reverseLookup(ip);
+            if (hostnames.length === 0) {
+                console.log(colors.yellow(`\nNo PTR records found`));
+                return;
+            }
+            console.log(`\n${colors.bold(colors.cyan('Reverse DNS Lookup'))}`);
+            hostnames.forEach(h => console.log(`  ${colors.green('•')} ${h}`));
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`Reverse Lookup Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    dns.command('health')
+        .description(healthSchema.description)
+        .argument('<domain>', 'Domain')
+        .addHelpText('after', generateHelp(healthSchema))
+        .action(async (domain) => {
+        const { checkDnsHealth } = await import('../../utils/dns-toolkit.js');
+        console.log(colors.gray(`Running DNS health check for ${domain}...`));
+        try {
+            const report = await checkDnsHealth(domain);
+            let gradeColor = colors.red;
+            if (report.grade === 'A')
+                gradeColor = colors.green;
+            else if (report.grade === 'B')
+                gradeColor = colors.blue;
+            else if (report.grade === 'C')
+                gradeColor = colors.yellow;
+            console.log(`\n${colors.bold(colors.cyan('🏥 DNS Health Report'))}`);
+            console.log(`${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray('Score:')} ${report.score}/100\n`);
+            report.checks.forEach(check => {
+                const icon = check.status === 'pass' ? colors.green('✔') : check.status === 'warn' ? colors.yellow('⚠') : colors.red('✖');
+                console.log(`  ${icon} ${colors.bold(check.name.padEnd(16))} ${check.message}`);
+            });
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`Health Check Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    dns.command('spf')
+        .description(spfSchema.description)
+        .argument('<domain>', 'Domain')
+        .addHelpText('after', generateHelp(spfSchema))
+        .action(async (domain) => {
+        const { validateSpf } = await import('../../utils/dns-toolkit.js');
+        try {
+            const result = await validateSpf(domain);
+            console.log(`\n${colors.bold(colors.cyan('📧 SPF Validation'))}`);
+            if (result.valid)
+                console.log(`  ${colors.green('✔')} Valid SPF: ${colors.gray(result.record || '')}`);
+            else if (result.record)
+                console.log(`  ${colors.yellow('⚠')} Invalid SPF: ${colors.gray(result.record)}`);
+            else
+                console.log(`  ${colors.red('✖')} No SPF record found`);
+            result.errors.forEach(e => console.log(`    ${colors.red('→')} ${e}`));
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`SPF Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    dns.command('dmarc')
+        .description(dmarcSchema.description)
+        .argument('<domain>', 'Domain')
+        .addHelpText('after', generateHelp(dmarcSchema))
+        .action(async (domain) => {
+        const { validateDmarc } = await import('../../utils/dns-toolkit.js');
+        try {
+            const result = await validateDmarc(domain);
+            console.log(`\n${colors.bold(colors.cyan('🛡️  DMARC Validation'))}`);
+            if (result.valid)
+                console.log(`  ${colors.green('✔')} Valid DMARC (Policy: ${result.policy})`);
+            else
+                console.log(`  ${colors.red('✖')} DMARC issue`);
+            if (result.record)
+                console.log(`    ${colors.gray(result.record)}`);
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`DMARC Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    dns.command('dkim')
+        .description(dkimSchema.description)
+        .argument('<domain>', 'Domain')
+        .argument('[args...]', 'Options')
+        .addHelpText('after', generateHelp(dkimSchema))
+        .action(async (domain, rawArgs) => {
+        const { data } = RekArgs.parse(rawArgs, dkimSchema);
+        const { checkDkim } = await import('../../utils/dns-toolkit.js');
+        try {
+            const result = await checkDkim(domain, data.selector);
+            console.log(`\n${colors.bold(colors.cyan('🔑 DKIM Check'))}`);
+            if (result.found)
+                console.log(`  ${colors.green('✔')} DKIM found (selector: ${data.selector})`);
+            else
+                console.log(`  ${colors.red('✖')} No DKIM found (selector: ${data.selector})`);
+            console.log('');
+        }
+        catch (err) {
+            console.error(colors.red(`DKIM Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    dns.command('email')
+        .description(emailSchema.description)
+        .argument('<domain>', 'Domain')
+        .argument('[args...]', 'Options')
+        .addHelpText('after', generateHelp(emailSchema))
+        .action(async (domain, rawArgs) => {
+        console.log(colors.gray('Running full email audit...'));
+    });
+    dns.command('system')
+        .alias('status')
+        .description(systemSchema.description)
+        .addHelpText('after', generateHelp(systemSchema))
+        .action(async () => {
+        const platform = process.platform;
+        let cmd = '';
+        if (platform === 'linux') {
+            cmd = 'resolvectl status';
+        }
+        else if (platform === 'darwin') {
+            cmd = 'scutil --dns';
+        }
+        else if (platform === 'win32') {
+            cmd = 'ipconfig /all';
+        }
+        else {
+            console.log(colors.red('Unsupported platform for system DNS check.'));
+            return;
+        }
+        console.log(colors.gray(`Running system DNS check (${cmd})...\n`));
+        try {
+            const { stdout } = await execAsync(cmd);
+            console.log(stdout);
+        }
+        catch (err) {
+            if (platform === 'linux') {
+                try {
+                    const { stdout } = await execAsync('cat /etc/resolv.conf');
+                    console.log(colors.bold('/etc/resolv.conf:'));
+                    console.log(stdout);
+                }
+                catch {
+                    console.error(colors.red(`Failed to check DNS: ${err.message}`));
+                }
+            }
+            else {
+                console.error(colors.red(`Failed to check DNS: ${err.message}`));
+            }
+        }
+    });
+    dns.command('dig')
+        .description('DNS lookup utility (like the real dig)')
+        .argument('[args...]', 'Query arguments')
+        .allowUnknownOption()
+        .action(async (args) => {
+        const { dig, formatDigOutput } = await import('../../utils/dns-toolkit.js');
+        let domain = '';
+        let type = 'A';
+    });
+}

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

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

package/dist/cli/commands/har.js

@@ -0,0 +1,171 @@
+import colors from '../../utils/colors.js';
+import { generateHelp } from '../parser/index.js';
+import { promises as fs } from 'node:fs';
+const harSchema = {
+    name: 'har',
+    description: 'HAR recording and playback',
+    flags: {
+        append: { description: 'Append to existing HAR file', alias: 'a' },
+        strict: { description: 'Fail if request not found in HAR', alias: 's' },
+        verbose: { description: 'Show detailed output', alias: 'v' },
+        json: { description: 'Output as JSON' }
+    },
+    params: {
+        delay: { type: 'number', default: 0, description: 'Delay between requests' }
+    },
+    examples: [
+        { cmd: 'rek har record session.har', desc: 'Record requests' },
+        { cmd: 'rek har play session.har', desc: 'Replay requests' },
+        { cmd: 'rek har info session.har', desc: 'Inspect HAR' }
+    ]
+};
+export function registerHarCommand(program) {
+    const har = program.command('har')
+        .description(harSchema.description)
+        .addHelpText('after', generateHelp(harSchema));
+    har.command('record')
+        .description('Record HTTP requests to HAR file')
+        .argument('<file>', 'Output HAR file path')
+        .argument('[url]', 'Optional URL to start recording with')
+        .option('-a, --append', 'Append to existing HAR file')
+        .action(async (file, url, options) => {
+        const { createClient } = await import('../../core/client.js');
+        const { harRecorderPlugin } = await import('../../plugins/har-recorder.js');
+        let existingEntries = [];
+        if (options.append) {
+            try {
+                const existing = await fs.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();
+        }
+    });
+    har.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')
+        .action(async (file, options) => {
+        try {
+            const content = await fs.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);
+        }
+    });
+    har.command('info')
+        .description('Show information about a HAR file')
+        .argument('<file>', 'HAR file to inspect')
+        .argument('[args...]', 'Options: json')
+        .action(async (file, args) => {
+        const jsonOutput = args.includes('json');
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const har = JSON.parse(content);
+            if (jsonOutput) {
+                console.log(JSON.stringify(har.log, null, 2));
+                return;
+            }
+            console.log(colors.bold(colors.cyan('HAR File Info')));
+            console.log(`Version: ${har.log.version}`);
+            console.log(`Creator: ${har.log.creator.name} ${har.log.creator.version}`);
+            console.log(`Entries: ${har.log.entries.length}`);
+        }
+        catch (error) {
+            console.error(colors.red(`Failed to read HAR file: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/cli/commands/hls.js

@@ -0,0 +1,192 @@
+import colors from '../../utils/colors.js';
+import { parseEnhancerPresets } from '../helpers.js';
+export function registerHlsCommand(program) {
+    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('[args...]', 'Output, options, and headers')
+        .option('-v, --verbose', 'Show detailed error information')
+        .option('-l, --live', 'Enable live stream mode')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Options:'))}
+  ${colors.cyan('[output]')}             Output file path (default: output.ts)
+  ${colors.cyan('quality=<quality>')}    Quality: highest, lowest, or resolution (e.g., 720p)
+  ${colors.cyan('live')}                 Enable live stream mode
+  ${colors.cyan('duration=<seconds>')}   Duration for live recording in seconds
+  ${colors.cyan('concurrency=<n>')}      Concurrent segment downloads (default: 4)
+  ${colors.cyan('Header:Value')}         Add custom HTTP header (e.g., Referer:https://example.com)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek hls download https://example.com/stream.m3u8')}                     ${colors.gray('Download stream')}
+  ${colors.green('$ rek hls download https://example.com/stream.m3u8 video.ts')}            ${colors.gray('Custom output')}
+  ${colors.green('$ rek hls download https://example.com/stream.m3u8 quality=720p')}        ${colors.gray('Select quality')}
+  ${colors.green('$ rek hls download https://example.com/live.m3u8 live duration=60')}      ${colors.gray('Record live stream')}
+  ${colors.green('$ rek hls download https://example.com/stream.m3u8 Referer:https://site.com User-Agent:"My Browser"')} ${colors.gray('With custom headers')}
+`)
+        .action(async (...args) => {
+        const url = args[0];
+        const rawArgs = args[1] || [];
+        const cmdObj = args[args.length - 1];
+        const options = cmdObj.opts ? cmdObj.opts() : {};
+        const verbose = options.verbose;
+        const { hls } = await import('../../plugins/hls.js');
+        const { Client } = await import('../../core/client.js');
+        const { clientOptions, remainingArgs } = await parseEnhancerPresets([]);
+        let output = 'stream.ts';
+        let quality;
+        let live = options.live;
+        let duration;
+        let concurrency = 4;
+        const headers = { ...clientOptions.headers };
+        let outputHandled = false;
+        for (const arg of remainingArgs) {
+            if (arg.startsWith('--')) {
+                continue;
+            }
+            else if (arg.includes('=')) {
+                const [key, value] = arg.split('=');
+                if (key === 'quality')
+                    quality = value;
+                else if (key === 'duration')
+                    duration = parseInt(value, 10);
+                else if (key === 'concurrency')
+                    concurrency = parseInt(value, 10);
+            }
+            else if (arg.includes(':') && !arg.startsWith('http')) {
+                const [key, ...valueParts] = arg.split(':');
+                headers[key.trim()] = valueParts.join(':').trim();
+            }
+            else if (!outputHandled) {
+                output = arg;
+                outputHandled = true;
+            }
+        }
+        const client = new Client(clientOptions);
+        console.log(colors.gray(`Downloading HLS stream from ${url}...`));
+        console.log(colors.gray(`Output: ${output}`));
+        if (Object.keys(headers).length > 0) {
+            console.log(colors.gray('With headers:'));
+            for (const [key, value] of Object.entries(headers)) {
+                console.log(`  ${colors.gray(`${key}: ${value.slice(0, 50)}${value.length > 50 ? '...' : ''}`)}`);
+            }
+        }
+        console.log('');
+        try {
+            const hlsOptions = {
+                concurrency,
+                headers: Object.keys(headers).length > 0 ? headers : undefined,
+                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 (quality) {
+                if (quality === 'highest' || quality === 'lowest') {
+                    hlsOptions.quality = quality;
+                }
+                else if (quality.includes('p')) {
+                    hlsOptions.quality = { resolution: quality };
+                }
+            }
+            if (live) {
+                hlsOptions.live = duration
+                    ? { duration: duration * 1000 }
+                    : true;
+            }
+            await hls(client, url, hlsOptions).download(output);
+            console.log('');
+            console.log(colors.green(`✔ Download complete: ${output}`));
+        }
+        catch (err) {
+            console.log('');
+            const msg = err.message || String(err);
+            console.error(colors.red(`HLS Download Error: ${msg}`));
+            if (verbose) {
+                console.error(colors.gray('\n--- Error Details ---'));
+                if (err.cause)
+                    console.error('Cause:', err.cause);
+                if (err.stack)
+                    console.error(err.stack);
+            }
+            process.exit(1);
+        }
+    });
+}

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

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