recker 1.0.43 → 1.0.44-next.084c2ef

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;

package/dist/cli/commands/protocols.js

@@ -0,0 +1,344 @@
+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';
+const ftpSchema = {
+    name: 'ftp',
+    description: 'FTP client operations',
+    params: {
+        user: { type: 'string', default: 'anonymous', description: 'Username' },
+        pass: { type: 'string', default: 'anonymous@', description: 'Password' },
+        port: { type: 'number', default: 21, description: 'Port' },
+    },
+    flags: {
+        secure: { description: 'Use FTPS (explicit TLS)', default: false },
+        implicit: { description: 'Use implicit FTPS (port 990)', default: false }
+    },
+    examples: [
+        { cmd: 'rek ftp ls ftp.example.com', desc: 'List files' },
+        { cmd: 'rek ftp get ftp.example.com /file.txt', desc: 'Download file' }
+    ]
+};
+const telnetSchema = {
+    name: 'telnet',
+    description: 'Connect to a Telnet server',
+    params: {
+        timeout: { type: 'number', default: 30000, description: 'Timeout in ms' }
+    },
+    examples: [
+        { cmd: 'rek telnet towel.blinkenlights.nl', desc: 'Star Wars' },
+        { cmd: 'rek telnet localhost 23', desc: 'Local server' }
+    ]
+};
+const graphqlSchema = {
+    name: 'graphql',
+    description: 'Execute GraphQL queries and mutations',
+    params: {
+        query: { type: 'string', description: 'Inline query' },
+        file: { type: 'string', description: 'Query file path' },
+        variables: { type: 'json', description: 'Variables JSON' },
+        'var-file': { type: 'string', description: 'Variables file path' }
+    },
+    examples: [
+        { cmd: 'rek graphql api.com/graphql query="{ me { name } }"', desc: 'Simple query' }
+    ]
+};
+const jsonRpcSchema = {
+    name: 'jsonrpc',
+    description: 'Make JSON-RPC 2.0 calls',
+    params: {
+        method: { type: 'string', description: 'RPC Method' },
+        params: { type: 'json', description: 'RPC Params (array or object)' }
+    },
+    examples: [
+        { cmd: 'rek jsonrpc api.com/rpc method=sum params=[1,2]', desc: 'Call method' }
+    ]
+};
+const soapSchema = {
+    name: 'soap',
+    description: 'Make a SOAP request',
+    params: {
+        namespace: { type: 'string', description: 'SOAP namespace' },
+        envelope: { type: 'string', default: '1.1', description: 'SOAP envelope version' },
+    },
+    examples: [
+        { cmd: 'rek soap api.com/ws GetWeather city="New York"', desc: 'SOAP Action' }
+    ]
+};
+const odataSchema = {
+    name: 'odata',
+    description: 'Query an OData service',
+    params: {
+        select: { type: 'string', description: 'Select fields' },
+        filter: { type: 'string', description: 'Filter expression' },
+        orderby: { type: 'string', description: 'Order by' },
+        top: { type: 'number', description: 'Limit results' },
+        skip: { type: 'number', description: 'Skip results' },
+        expand: { type: 'string', description: 'Expand navigation' },
+    },
+    examples: [
+        { cmd: 'rek odata api.com/odata Customers top=10', desc: 'Query' }
+    ]
+};
+export function registerProtocolCommands(program) {
+    const ftpCmd = program.command('ftp')
+        .description('FTP client operations')
+        .addHelpText('after', generateHelp(ftpSchema));
+    ftpCmd.command('ls')
+        .description('List files')
+        .argument('<host>', 'FTP Host')
+        .argument('[args...]', 'Path and options')
+        .action(async (host, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, ftpSchema);
+        const path = args[0] || '/';
+        const secure = data.implicit ? 'implicit' : !!data.secure;
+        const { createFTP } = await import('../../protocols/ftp.js');
+        const client = createFTP({ host, port: data.port, user: data.user, password: data.pass, secure });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            const connectResult = await client.connect();
+            if (!connectResult.success)
+                throw new Error(connectResult.message);
+            console.log(colors.green('Connected'));
+            const result = await client.list(path);
+            if (!result.success || !result.data)
+                throw new Error(result.message);
+            console.log(`\n${colors.bold(`Contents of ${path}:`)}\n`);
+            for (const item of result.data) {
+                const typeChar = item.type === 'directory' ? 'd' : item.type === 'link' ? 'l' : '-';
+                const nameColor = item.type === 'directory' ? colors.blue : colors.white;
+                console.log(`${typeChar}${item.permissions || 'rwxr-xr-x'}  ${item.size.toString().padStart(10)}  ${item.rawModifiedAt || ''}  ${nameColor(item.name)}`);
+            }
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd.command('get')
+        .description('Download file')
+        .argument('<host>', 'FTP Host')
+        .argument('<remote>', 'Remote path')
+        .argument('[args...]', 'Local path and options')
+        .action(async (host, remote, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, ftpSchema);
+        const local = args[0] || pathMod.basename(remote);
+        const secure = data.implicit ? 'implicit' : !!data.secure;
+        const { createFTP } = await import('../../protocols/ftp.js');
+        const client = createFTP({ host, port: data.port, user: data.user, password: data.pass, secure });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            if (!(await client.connect()).success)
+                throw new Error('Connection failed');
+            console.log(colors.gray(`Downloading ${remote} -> ${local}...`));
+            let lastProgress = 0;
+            client.progress((p) => {
+                if (p.bytesOverall - lastProgress > 100000) {
+                    process.stdout.write(`\r  ${colors.cyan((p.bytesOverall / 1024 / 1024).toFixed(2) + ' MB')} downloaded...`);
+                    lastProgress = p.bytesOverall;
+                }
+            });
+            const result = await client.download(remote, local);
+            console.log('');
+            if (!result.success)
+                throw new Error(result.message);
+            console.log(colors.green(`✔ Downloaded to ${local}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    ftpCmd.command('put')
+        .description('Upload file')
+        .argument('<host>', 'FTP Host')
+        .argument('<local>', 'Local path')
+        .argument('[args...]', 'Remote path and options')
+        .action(async (host, local, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, ftpSchema);
+        const remote = args[0] || '/' + pathMod.basename(local);
+        const secure = data.implicit ? 'implicit' : !!data.secure;
+        const { createFTP } = await import('../../protocols/ftp.js');
+        const client = createFTP({ host, port: data.port, user: data.user, password: data.pass, secure });
+        console.log(colors.gray(`Connecting to ${host}...`));
+        try {
+            if (!(await client.connect()).success)
+                throw new Error('Connection failed');
+            console.log(colors.gray(`Uploading ${local} -> ${remote}...`));
+            let lastProgress = 0;
+            client.progress((p) => {
+                if (p.bytesOverall - lastProgress > 100000) {
+                    process.stdout.write(`\r  ${colors.cyan((p.bytesOverall / 1024 / 1024).toFixed(2) + ' MB')} uploaded...`);
+                    lastProgress = p.bytesOverall;
+                }
+            });
+            const result = await client.upload(local, remote);
+            console.log('');
+            if (!result.success)
+                throw new Error(result.message);
+            console.log(colors.green(`✔ Uploaded to ${remote}`));
+            await client.close();
+        }
+        catch (err) {
+            console.error(colors.red(`FTP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('telnet')
+        .description(telnetSchema.description)
+        .argument('<host>', 'Hostname')
+        .argument('[args...]', 'Port and options')
+        .addHelpText('after', generateHelp(telnetSchema))
+        .action(async (host, rawArgs) => {
+        const { data, args } = RekArgs.parse(rawArgs, telnetSchema);
+        let port = 23;
+        if (args.length > 0)
+            port = parseInt(String(args[0]));
+        const { createTelnet } = await import('../../protocols/telnet.js');
+        console.log(colors.gray(`Connecting to ${host}:${port}...`));
+        const client = createTelnet({ host, port, timeout: data.timeout });
+        try {
+            await client.connect();
+            console.log(colors.green(`Connected to ${host}:${port}`));
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', async (d) => {
+                if (d[0] === 0x03) {
+                    await client.close();
+                    process.exit(0);
+                }
+                await client.send(d.toString());
+            });
+            client.on('data', (d) => process.stdout.write(d));
+            client.on('close', () => process.exit(0));
+            client.on('error', (e) => { console.error(colors.red(e.message)); process.exit(1); });
+        }
+        catch (err) {
+            console.error(colors.red(`Telnet Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('graphql').alias('gql')
+        .description(graphqlSchema.description)
+        .argument('<url>', 'GraphQL Endpoint')
+        .argument('[args...]', 'Options')
+        .addHelpText('after', generateHelp(graphqlSchema))
+        .action(async (url, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, graphqlSchema);
+        let query = data.query;
+        let variables = data.variables || {};
+        if (data.file)
+            query = await fs.readFile(data.file, 'utf-8');
+        if (data['var-file'])
+            variables = JSON.parse(await fs.readFile(data['var-file'], 'utf-8'));
+        if (!query) {
+            console.error(colors.red('Error: Query is required via query= or file='));
+            process.exit(1);
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { graphql } = await import('../../plugins/graphql.js');
+        const { createClient } = await import('../../core/client.js');
+        try {
+            const client = createClient({ baseUrl: url, headers: { 'Content-Type': 'application/json', ...headers } });
+            const result = await graphql(client, query, variables);
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`GraphQL Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('jsonrpc')
+        .description(jsonRpcSchema.description)
+        .argument('<url>', 'Endpoint')
+        .argument('<method>', 'Method')
+        .argument('[args...]', 'Params and options')
+        .addHelpText('after', generateHelp(jsonRpcSchema))
+        .action(async (url, method, rawArgs) => {
+        const { data, headers, args } = RekArgs.parse(rawArgs, jsonRpcSchema);
+        let params = data.params;
+        if (!params && args.length > 0) {
+            params = args;
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createJsonRpcClient } = await import('../../plugins/jsonrpc.js');
+        const { createClient } = await import('../../core/client.js');
+        try {
+            const client = createClient({ baseUrl: url, headers });
+            const rpc = createJsonRpcClient(client, { endpoint: url });
+            const result = await rpc.call(method, params);
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`RPC Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('soap')
+        .description(soapSchema.description)
+        .argument('<url>', 'SOAP Endpoint')
+        .argument('<action>', 'Action/Operation')
+        .argument('[args...]', 'Parameters')
+        .addHelpText('after', generateHelp(soapSchema))
+        .action(async (url, action, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, soapSchema);
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createClient } = await import('../../core/client.js');
+        const { createSoapClient } = await import('../../plugins/soap.js');
+        try {
+            const httpClient = createClient({ headers });
+            const soap = createSoapClient(httpClient, { endpoint: url, namespace: data.namespace });
+            const body = { ...data };
+            delete body.namespace;
+            delete body.envelope;
+            const result = await soap.call(action, body);
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`SOAP Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+    program.command('odata')
+        .description(odataSchema.description)
+        .argument('<url>', 'OData Service URL')
+        .argument('<entity>', 'Entity Set')
+        .argument('[args...]', 'Query Options')
+        .addHelpText('after', generateHelp(odataSchema))
+        .action(async (url, entity, rawArgs) => {
+        const { data, headers } = RekArgs.parse(rawArgs, odataSchema);
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { createClient } = await import('../../core/client.js');
+        const { createODataClient } = await import('../../plugins/odata.js');
+        try {
+            const httpClient = createClient({ headers });
+            const odata = createODataClient(httpClient, { serviceRoot: url });
+            let query = odata.query(entity);
+            if (data.select)
+                query = query.select(...data.select.split(','));
+            if (data.filter)
+                query = query.filter(data.filter);
+            if (data.orderby)
+                query = query.orderBy(data.orderby);
+            if (data.top)
+                query = query.top(data.top);
+            if (data.skip)
+                query = query.skip(data.skip);
+            if (data.expand)
+                query = query.expand(data.expand);
+            const results = await query.get();
+            console.log(JSON.stringify(results, null, 2));
+        }
+        catch (err) {
+            console.error(colors.red(`OData Error: ${err.message}`));
+            process.exit(1);
+        }
+    });
+}

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

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