recker 1.0.43 → 1.0.44

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;

package/dist/cli/commands/network.js

@@ -0,0 +1,288 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+const ipSchema = {
+    name: 'ip',
+    description: 'Look up geolocation and ISP info for an IP address.\nUses local MaxMind GeoLite2 database (downloaded automatically).',
+    examples: [
+        { cmd: 'rek ip 8.8.8.8', desc: 'Google DNS' },
+        { cmd: 'rek ip 1.1.1.1', desc: 'Cloudflare DNS' }
+    ]
+};
+const tlsSchema = {
+    name: 'tls',
+    description: 'Inspect TLS/SSL certificate of a host.\nShows issuer, validity, fingerprints, and subject alternative names.',
+    examples: [
+        { cmd: 'rek tls google.com', desc: 'Inspect Google cert' },
+        { cmd: 'rek tls example.com 8443', desc: 'Custom port' },
+        { cmd: 'rek tls 192.168.1.1', desc: 'Check IP directly' }
+    ]
+};
+const whoisSchema = {
+    name: 'whois',
+    description: 'Look up domain registration and ownership info.\nQueries WHOIS servers for registrar, dates, and nameservers.',
+    flags: {
+        raw: { description: 'Show raw WHOIS response', default: false }
+    },
+    examples: [
+        { cmd: 'rek whois github.com', desc: 'Domain info' },
+        { cmd: 'rek whois google.com --raw', desc: 'Raw response' }
+    ]
+};
+const rdapSchema = {
+    name: 'rdap',
+    description: 'RDAP lookup (modern WHOIS with JSON).\nStandardized replacement for WHOIS with structured data.',
+    examples: [
+        { cmd: 'rek rdap github.com', desc: 'Domain info' }
+    ]
+};
+const pingSchema = {
+    name: 'ping',
+    description: 'Test TCP connectivity to host:port.\nMeasures connection latency (not ICMP).',
+    params: {
+        count: { type: 'number', default: 4, description: 'Number of pings' }
+    },
+    examples: [
+        { cmd: 'rek ping google.com', desc: 'Test HTTPS (443)' },
+        { cmd: 'rek ping google.com 80', desc: 'Test HTTP (80)' },
+        { cmd: 'rek ping redis.local 6379 count=10', desc: '10 pings to Redis' }
+    ]
+};
+export function registerNetworkCommands(program) {
+    program.command('ip').alias('geo').alias('geoip')
+        .description('Look up geolocation and ISP info for an IP address')
+        .argument('<address>', 'IP address to lookup')
+        .addHelpText('after', generateHelp(ipSchema))
+        .action(async (address) => {
+        const { getIpInfo, isGeoIPAvailable } = await import('../../mcp/ip-intel.js');
+        if (!isGeoIPAvailable()) {
+            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;
+            }
+            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').alias('cert')
+        .description('Inspect TLS/SSL certificate of a host')
+        .argument('<host>', 'Hostname or IP address')
+        .argument('[port]', 'Port number (default: 443)', '443')
+        .addHelpText('after', generateHelp(tlsSchema))
+        .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('');
+            }
+        }
+        catch (err) {
+            console.error(colors.red(`TLS Inspection Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('whois')
+        .description('Look up domain registration and ownership info')
+        .argument('<query>', 'Domain name or IP address')
+        .argument('[args...]', 'Options: raw')
+        .addHelpText('after', generateHelp(whoisSchema))
+        .action(async (query, rawArgs) => {
+        const { options } = RekArgs.parse(rawArgs, whoisSchema);
+        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 with JSON)')
+        .argument('<domain>', 'Domain name to lookup')
+        .addHelpText('after', generateHelp(rdapSchema))
+        .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?.length) {
+                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.entities?.length) {
+                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('');
+            }
+        }
+        catch (err) {
+            console.error(colors.red(`RDAP Lookup Failed: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('ping')
+        .description('Test TCP connectivity to host:port')
+        .argument('<host>', 'Hostname or IP address')
+        .argument('[args...]', 'Port and options: [port] count=4')
+        .addHelpText('after', generateHelp(pingSchema))
+        .action(async (host, rawArgs) => {
+        const { data, args: posArgs } = RekArgs.parse(rawArgs, pingSchema);
+        const net = await import('node:net');
+        let port = 443;
+        if (posArgs.length > 0 && typeof posArgs[0] === 'number') {
+            port = posArgs[0];
+        }
+        else if (posArgs.length > 0 && /^\d+$/.test(String(posArgs[0]))) {
+            port = parseInt(String(posArgs[0]));
+        }
+        const count = data.count || 4;
+        const results = [];
+        console.log(colors.gray(`Pinging ${host}:${port}...`));
+        console.log('');
+        for (let i = 0; i < count; i++) {
+            const start = performance.now();
+            try {
+                await new Promise((resolve, reject) => {
+                    const socket = net.connect(port, 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}:${port} - ${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
+`);
+        }
+    });
+}

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

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