recker 1.0.43 → 1.0.44

package/dist/mcp/tools/network.js

@@ -1,8 +1,13 @@
 import { createClient } from '../../core/client.js';
-import { createDNS } from '../../dns/index.js';
 import { createWhois } from '../../utils/whois.js';
 import { createConnection } from 'net';
-const dnsClient = createDNS({ provider: 'system' });
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { checkPropagation } from '../../dns/propagation.js';
+import { checkDnsHealth, validateSpf, validateDmarc, checkDkim, dig, dnsLookup } from '../../utils/dns-toolkit.js';
+import { inspectTLS } from '../../utils/tls-inspector.js';
+import { rdap } from '../../utils/rdap.js';
+const execAsync = promisify(exec);
 const whoisClient = createWhois();
 async function httpRequest(args) {
     const url = String(args.url || '');
@@ -11,20 +16,10 @@ async function httpRequest(args) {
     const body = args.body;
     const timeout = Number(args.timeout) || 10000;
     const retries = Number(args.retries) || 0;
-    if (!url) {
-        return {
-            content: [{ type: 'text', text: 'Error: url is required' }],
-            isError: true,
-        };
-    }
+    if (!url)
+        return { content: [{ type: 'text', text: 'Error: url is required' }], isError: true };
     try {
-        const client = createClient({
-            headers,
-            timeout,
-            retry: {
-                maxAttempts: retries,
-            },
-        });
+        const client = createClient({ headers, timeout, retry: { maxAttempts: retries } });
         let response;
         switch (method) {
             case 'GET':
@@ -45,223 +40,368 @@ async function httpRequest(args) {
             case 'HEAD':
                 response = await client.head(url);
                 break;
-            default:
-                return {
-                    content: [{ type: 'text', text: `Error: Unsupported method ${method}` }],
-                    isError: true,
-                };
+            default: return { content: [{ type: 'text', text: `Error: Unsupported method ${method}` }], isError: true };
         }
-        const responseHeaders = {};
-        response.headers.forEach((val, key) => {
-            responseHeaders[key] = val;
-        });
         const result = {
             status: response.status,
             statusText: response.statusText,
-            headers: responseHeaders,
+            headers: Object.fromEntries(response.headers.entries()),
             data: await response.text(),
         };
         try {
             result.data = JSON.parse(result.data);
         }
-        catch {
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                }],
-        };
+        catch { }
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     }
     catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Request failed: ${error.message}`,
-                }],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `Request failed: ${error.message}` }], isError: true };
     }
 }
-async function dnsLookup(args) {
-    const domain = String(args.domain || '');
-    const type = String(args.type || 'A').toUpperCase();
-    if (!domain) {
-        return {
-            content: [{ type: 'text', text: 'Error: domain is required' }],
-            isError: true,
-        };
+async function dnsResolve(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    const type = String(args.type || 'A');
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const results = await dnsLookup(domain, type);
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     }
+    catch (error) {
+        return { content: [{ type: 'text', text: `DNS lookup failed: ${error.message}` }], isError: true };
+    }
+}
+async function dnsPropagate(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    const type = String(args.type || 'A');
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
     try {
-        let result;
-        if (type === 'ALL') {
-            result = await dnsClient.resolveAll(domain);
-        }
-        else {
-            result = await dnsClient.resolve(domain, type);
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({ domain, type, result }, null, 2),
-                }],
-        };
+        const results = await checkPropagation(domain, type);
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     }
     catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `DNS lookup failed: ${error.message}`,
-                }],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `Propagation check failed: ${error.message}` }], isError: true };
     }
 }
-async function whoisLookup(args) {
-    const query = String(args.query || '');
-    if (!query) {
-        return {
-            content: [{ type: 'text', text: 'Error: query is required' }],
-            isError: true,
-        };
+async function dnsHealth(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const report = await checkDnsHealth(domain);
+        return { content: [{ type: 'text', text: JSON.stringify(report, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Health check failed: ${error.message}` }], isError: true };
+    }
+}
+async function dnsSpf(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const result = await validateSpf(domain);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `SPF check failed: ${error.message}` }], isError: true };
+    }
+}
+async function dnsDmarc(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const result = await validateDmarc(domain);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `DMARC check failed: ${error.message}` }], isError: true };
     }
+}
+async function dnsDkim(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    const selector = String(args.selector || 'default');
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const result = await checkDkim(domain, selector);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `DKIM check failed: ${error.message}` }], isError: true };
+    }
+}
+async function dnsDig(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    const type = String(args.type || 'A');
+    const server = args.server ? String(args.server) : undefined;
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const result = await dig(domain, { type, server });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Dig failed: ${error.message}` }], isError: true };
+    }
+}
+async function tlsCheck(args) {
+    const host = args.host ? String(args.host) : '';
+    const port = Number(args.port) || 443;
+    if (!host)
+        return { content: [{ type: 'text', text: 'Error: host is required' }], isError: true };
+    try {
+        const info = await inspectTLS(host, port);
+        return { content: [{ type: 'text', text: JSON.stringify(info, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `TLS check failed: ${error.message}` }], isError: true };
+    }
+}
+async function rdapCheck(args) {
+    const domain = args.domain ? String(args.domain) : '';
+    if (!domain)
+        return { content: [{ type: 'text', text: 'Error: domain is required' }], isError: true };
+    try {
+        const client = createClient();
+        const result = await rdap(client, domain);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `RDAP lookup failed: ${error.message}` }], isError: true };
+    }
+}
+async function whoisCheck(args) {
+    const query = args.query ? String(args.query) : '';
+    if (!query)
+        return { content: [{ type: 'text', text: 'Error: query is required' }], isError: true };
     try {
         const result = await whoisClient.lookup(query);
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        server: result.server,
-                        data: result.data,
-                    }, null, 2),
-                }],
-        };
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     }
     catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `WHOIS lookup failed: ${error.message}`,
-                }],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `WHOIS failed: ${error.message}` }], isError: true };
+    }
+}
+async function dnsSystemStatus(args) {
+    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
+        return { content: [{ type: 'text', text: 'Unsupported platform' }], isError: true };
+    try {
+        const { stdout } = await execAsync(cmd);
+        return { content: [{ type: 'text', text: stdout }] };
+    }
+    catch (error) {
+        if (platform === 'linux') {
+            try {
+                const { stdout } = await execAsync('cat /etc/resolv.conf');
+                return { content: [{ type: 'text', text: stdout }] };
+            }
+            catch { }
+        }
+        return { content: [{ type: 'text', text: `Failed to get system DNS: ${error.message}` }], isError: true };
     }
 }
-async function ping(args) {
-    const host = String(args.host || '');
+async function pingCheck(args) {
+    const host = args.host ? String(args.host) : '';
+    const count = Number(args.count) || 3;
     const port = Number(args.port) || 80;
     const timeout = Number(args.timeout) || 5000;
-    const count = Number(args.count) || 3;
-    if (!host) {
-        return {
-            content: [{ type: 'text', text: 'Error: host is required' }],
-            isError: true,
-        };
-    }
+    if (!host)
+        return { content: [{ type: 'text', text: 'Error: host is required' }], isError: true };
     const results = [];
     for (let i = 0; i < count; i++) {
         const start = Date.now();
         try {
             await new Promise((resolve, reject) => {
                 const socket = createConnection({ host, port, timeout });
-                socket.on('connect', () => {
-                    socket.destroy();
-                    resolve();
-                });
-                socket.on('timeout', () => {
-                    socket.destroy();
-                    reject(new Error('Timeout'));
-                });
-                socket.on('error', (err) => {
-                    socket.destroy();
-                    reject(err);
-                });
+                socket.on('connect', () => { socket.destroy(); resolve(); });
+                socket.on('timeout', () => { socket.destroy(); reject(new Error('Timeout')); });
+                socket.on('error', (e) => { socket.destroy(); reject(e); });
             });
-            results.push({ seq: i + 1, time: Date.now() - start });
+            results.push({ seq: i, time: Date.now() - start });
         }
-        catch (error) {
-            results.push({ seq: i + 1, error: error.message });
+        catch (e) {
+            results.push({ seq: i, error: e.message });
         }
-        if (i < count - 1) {
+        if (i < count - 1)
             await new Promise(r => setTimeout(r, 200));
-        }
     }
     const successful = results.filter(r => !r.error);
     const totalTime = successful.reduce((acc, r) => acc + (r.time || 0), 0);
     const avg = successful.length > 0 ? totalTime / successful.length : 0;
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({
+    return { content: [{ type: 'text', text: JSON.stringify({
                     host,
                     port,
                     sent: count,
                     received: successful.length,
-                    loss: `${((count - successful.length) / count * 100).toFixed(1)}%`,
-                    avgLatency: `${avg.toFixed(2)}ms`,
-                    details: results,
-                }, null, 2),
-            }],
-    };
+                    loss: count > 0 ? ((count - successful.length) / count * 100) : 0,
+                    avgLatency: avg,
+                    details: results
+                }, null, 2) }] };
 }
 export const networkTools = [
     {
         name: 'rek_http_request',
-        description: 'Perform an HTTP request to any URL using Recker\'s robust client. Supports all methods, headers, and automatic JSON parsing.',
+        description: 'Perform HTTP request. Useful for calling APIs, fetching pages, etc.',
         inputSchema: {
             type: 'object',
             properties: {
-                url: { type: 'string', description: 'Target URL' },
-                method: { type: 'string', description: 'HTTP method (GET, POST, PUT, DELETE, etc.)', default: 'GET' },
-                headers: { type: 'object', description: 'Request headers' },
-                body: { type: 'object', description: 'JSON body for POST/PUT/PATCH' },
-                timeout: { type: 'number', description: 'Timeout in ms', default: 10000 },
-                retries: { type: 'number', description: 'Number of retries', default: 0 },
+                url: { type: 'string' },
+                method: { type: 'string', default: 'GET' },
+                headers: { type: 'object' },
+                body: { type: 'object' }
             },
-            required: ['url'],
-        },
+            required: ['url']
+        }
     },
     {
-        name: 'rek_dns_lookup',
-        description: 'Resolve DNS records for a domain. Supports A, AAAA, MX, TXT, NS, etc.',
+        name: 'rek_dns',
+        description: 'Resolve DNS records (A, AAAA, MX, TXT, etc) using system resolver.',
         inputSchema: {
             type: 'object',
             properties: {
-                domain: { type: 'string', description: 'Domain name to resolve' },
-                type: { type: 'string', description: 'Record type (A, AAAA, MX, TXT, NS, ALL)', default: 'A' },
+                domain: { type: 'string' },
+                type: { type: 'string', default: 'A' }
             },
-            required: ['domain'],
-        },
+            required: ['domain']
+        }
     },
     {
-        name: 'rek_whois_lookup',
-        description: 'Perform a WHOIS lookup for a domain or IP address to find registration info.',
+        name: 'rek_dns_propagate',
+        description: 'Check DNS propagation globally across multiple providers.',
         inputSchema: {
             type: 'object',
             properties: {
-                query: { type: 'string', description: 'Domain or IP to lookup' },
+                domain: { type: 'string' },
+                type: { type: 'string', default: 'A' }
             },
-            required: ['query'],
-        },
+            required: ['domain']
+        }
     },
     {
-        name: 'rek_network_ping',
-        description: 'Check TCP connectivity to a host and port. Measures latency.',
+        name: 'rek_dns_health',
+        description: 'Perform a comprehensive DNS health check (Parent NS, SOAs, MX, etc).',
+        inputSchema: {
+            type: 'object',
+            properties: { domain: { type: 'string' } },
+            required: ['domain']
+        }
+    },
+    {
+        name: 'rek_dns_spf',
+        description: 'Validate SPF record for a domain.',
+        inputSchema: {
+            type: 'object',
+            properties: { domain: { type: 'string' } },
+            required: ['domain']
+        }
+    },
+    {
+        name: 'rek_dns_dmarc',
+        description: 'Validate DMARC record for a domain.',
+        inputSchema: {
+            type: 'object',
+            properties: { domain: { type: 'string' } },
+            required: ['domain']
+        }
+    },
+    {
+        name: 'rek_dns_dkim',
+        description: 'Check DKIM record presence.',
         inputSchema: {
             type: 'object',
             properties: {
-                host: { type: 'string', description: 'Hostname or IP' },
-                port: { type: 'number', description: 'Target port', default: 80 },
-                count: { type: 'number', description: 'Number of pings', default: 3 },
-                timeout: { type: 'number', description: 'Timeout per ping in ms', default: 5000 },
+                domain: { type: 'string' },
+                selector: { type: 'string', default: 'default' }
             },
-            required: ['host'],
-        },
+            required: ['domain']
+        }
     },
+    {
+        name: 'rek_dns_dig',
+        description: 'Advanced DNS lookup (like dig command) supporting specific nameservers.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                domain: { type: 'string' },
+                type: { type: 'string', default: 'A' },
+                server: { type: 'string', description: 'Optional specific nameserver to query (e.g. 8.8.8.8)' }
+            },
+            required: ['domain']
+        }
+    },
+    {
+        name: 'rek_dns_system',
+        description: 'Get system DNS configuration (local resolver status).',
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'rek_tls',
+        description: 'Inspect TLS/SSL certificate of a host.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                host: { type: 'string' },
+                port: { type: 'number', default: 443 }
+            },
+            required: ['host']
+        }
+    },
+    {
+        name: 'rek_whois',
+        description: 'Query WHOIS database for domain info.',
+        inputSchema: {
+            type: 'object',
+            properties: { query: { type: 'string' } },
+            required: ['query']
+        }
+    },
+    {
+        name: 'rek_rdap',
+        description: 'Query RDAP (modern WHOIS) for structured domain info.',
+        inputSchema: {
+            type: 'object',
+            properties: { domain: { type: 'string' } },
+            required: ['domain']
+        }
+    },
+    {
+        name: 'rek_ping',
+        description: 'TCP Ping a host:port to check connectivity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                host: { type: 'string' },
+                port: { type: 'number', default: 80 },
+                count: { type: 'number', default: 3 },
+                timeout: { type: 'number', default: 5000 }
+            },
+            required: ['host']
+        }
+    }
 ];
 export const networkToolHandlers = {
     rek_http_request: httpRequest,
-    rek_dns_lookup: dnsLookup,
-    rek_whois_lookup: whoisLookup,
-    rek_network_ping: ping,
+    rek_dns: dnsResolve,
+    rek_dns_propagate: dnsPropagate,
+    rek_dns_health: dnsHealth,
+    rek_dns_spf: dnsSpf,
+    rek_dns_dmarc: dnsDmarc,
+    rek_dns_dkim: dnsDkim,
+    rek_dns_dig: dnsDig,
+    rek_dns_system: dnsSystemStatus,
+    rek_tls: tlsCheck,
+    rek_whois: whoisCheck,
+    rek_rdap: rdapCheck,
+    rek_ping: pingCheck,
 };

package/dist/plugins/har-player.d.ts

@@ -1,6 +1,29 @@
 import { Plugin } from '../types/index.js';
+import type { Client } from '../core/client.js';
 export interface HarPlayerOptions {
     path: string;
     strict?: boolean;
 }
 export declare function harPlayerPlugin(options: HarPlayerOptions): Plugin;
+export declare function harInfo(path: string): Promise<{
+    entryCount: number;
+    startedDateTime: string;
+    topHosts: string[];
+}>;
+export declare function harPlayer(client: Client, path: string, options: {
+    count?: number;
+    delay?: number;
+    overrideHeaders?: Record<string, string>;
+    onProgress?: (p: {
+        completed: number;
+        total: number;
+    }) => void;
+}): Promise<({
+    url: string;
+    status: number;
+    error?: undefined;
+} | {
+    url: string;
+    error: unknown;
+    status?: undefined;
+})[]>;

package/dist/plugins/har-player.js

@@ -57,3 +57,52 @@ export function harPlayerPlugin(options) {
         client.use(middleware);
     };
 }
+export async function harInfo(path) {
+    const content = readFileSync(path, 'utf-8');
+    const har = JSON.parse(content);
+    const entries = har.log.entries;
+    const hosts = new Set();
+    entries.forEach((e) => {
+        try {
+            const url = new URL(e.request.url);
+            hosts.add(url.hostname);
+        }
+        catch { }
+    });
+    return {
+        entryCount: entries.length,
+        startedDateTime: entries[0]?.startedDateTime || new Date().toISOString(),
+        topHosts: Array.from(hosts).slice(0, 5)
+    };
+}
+export async function harPlayer(client, path, options) {
+    const content = readFileSync(path, 'utf-8');
+    const har = JSON.parse(content);
+    const entries = har.log.entries;
+    const results = [];
+    const count = options.count || 1;
+    const total = entries.length * count;
+    let completed = 0;
+    for (let i = 0; i < count; i++) {
+        for (const entry of entries) {
+            if (options.delay)
+                await new Promise(r => setTimeout(r, options.delay));
+            const req = entry.request;
+            try {
+                const headers = { ...options.overrideHeaders };
+                await client.request(req.url, {
+                    method: req.method,
+                    headers,
+                    body: req.postData?.text
+                });
+                results.push({ url: req.url, status: 200 });
+            }
+            catch (e) {
+                results.push({ url: req.url, error: e });
+            }
+            completed++;
+            options.onProgress?.({ completed, total });
+        }
+    }
+    return results;
+}

package/dist/plugins/har-recorder.d.ts

@@ -1,6 +1,40 @@
 import { Plugin } from '../types/index.js';
-export interface HarOptions {
+interface HarEntry {
+    startedDateTime: string;
+    time: number;
+    request: any;
+    response: any;
+    timings: any;
+    cache: {};
+}
+export declare class HarRecorder {
+    private entries;
+    private isRecording;
+    private onEntry?;
+    start(): void;
+    stop(): void;
+    clear(): void;
+    getEntries(): HarEntry[];
+    setOnEntry(cb: (entry: HarEntry) => void): void;
+    generateHar(): {
+        log: {
+            version: string;
+            creator: {
+                name: string;
+                version: string;
+            };
+            pages: never[];
+            entries: HarEntry[];
+        };
+    };
+    download(filename?: string): void;
+    save(path: string): Promise<void>;
+    plugin(): Plugin;
+    private mapHeaders;
+}
+export declare const harRecorder: HarRecorder;
+export declare const harRecorderPlugin: (options?: {
     path?: string;
     onEntry?: (entry: any) => void;
-}
-export declare function harRecorderPlugin(options?: HarOptions): Plugin;
+}) => Plugin;
+export {};