recker 1.0.42 → 1.0.43-next.0b080a5

package/dist/cache/service-worker-cache.js

@@ -0,0 +1,103 @@
+const CACHE_NAME = 'recker-cache-v1';
+export class ServiceWorkerCache {
+    cacheName;
+    cachePromise = null;
+    constructor(options = {}) {
+        this.cacheName = options.cacheName || CACHE_NAME;
+    }
+    static isSupported() {
+        return typeof caches !== 'undefined';
+    }
+    async getCache() {
+        if (!this.cachePromise) {
+            if (!ServiceWorkerCache.isSupported()) {
+                throw new Error('Cache API is not supported in this environment');
+            }
+            this.cachePromise = caches.open(this.cacheName);
+        }
+        return this.cachePromise;
+    }
+    keyToUrl(key) {
+        return `https://recker-cache.local/${encodeURIComponent(key)}`;
+    }
+    async get(key) {
+        try {
+            const cache = await this.getCache();
+            const url = this.keyToUrl(key);
+            const response = await cache.match(url);
+            if (!response) {
+                return null;
+            }
+            const data = await response.json();
+            if (data.expiresAt && Date.now() > data.expiresAt) {
+                this.delete(key).catch(() => { });
+                return null;
+            }
+            return data.entry;
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(key, value, ttl) {
+        const cache = await this.getCache();
+        const url = this.keyToUrl(key);
+        const item = {
+            entry: value,
+            expiresAt: Date.now() + ttl,
+        };
+        const response = new Response(JSON.stringify(item), {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Recker-Cache': 'true',
+                'X-Recker-Expires': String(item.expiresAt),
+            },
+        });
+        await cache.put(url, response);
+    }
+    async delete(key) {
+        const cache = await this.getCache();
+        const url = this.keyToUrl(key);
+        await cache.delete(url);
+    }
+    async clear() {
+        await caches.delete(this.cacheName);
+        this.cachePromise = null;
+    }
+    async keys() {
+        const cache = await this.getCache();
+        const requests = await cache.keys();
+        return requests
+            .map((req) => {
+            const url = new URL(req.url);
+            return decodeURIComponent(url.pathname.slice(1));
+        })
+            .filter((key) => key.length > 0);
+    }
+    async size() {
+        const keys = await this.keys();
+        return keys.length;
+    }
+    async prune() {
+        const cache = await this.getCache();
+        const requests = await cache.keys();
+        let removed = 0;
+        for (const request of requests) {
+            const response = await cache.match(request);
+            if (response) {
+                try {
+                    const data = await response.json();
+                    if (data.expiresAt && Date.now() > data.expiresAt) {
+                        await cache.delete(request);
+                        removed++;
+                    }
+                }
+                catch {
+                    await cache.delete(request);
+                    removed++;
+                }
+            }
+        }
+        return removed;
+    }
+}

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

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

package/dist/cli/commands/ai.js

@@ -0,0 +1,162 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import colors from '../../utils/colors.js';
+import { loadEnvFile } from '../helpers.js';
+import { resolvePreset } from '../presets.js';
+export function registerAiCommand(program) {
+    program
+        .command('ai')
+        .alias('chat')
+        .alias('ask')
+        .description('Chat with AI models (OpenAI, Claude, Groq, etc)')
+        .argument('<preset>', 'AI preset to use (e.g., @openai, @anthropic, @groq)')
+        .argument('<prompt...>', 'The prompt and options: "prompt text" model=<model> temperature=<temp> max-tokens=<tokens> wait json env=<path>')
+        .addHelpText('after', `
+${colors.bold(colors.blue('What it does:'))}
+  Sends a prompt to an AI language model and streams the response back.
+  Supports all major AI providers including OpenAI, Anthropic, Google, Groq,
+  Mistral, and more. API keys are loaded from environment variables.
+
+  Each provider uses sensible defaults but you can override the model,
+  temperature, and max tokens. Responses stream in real-time by default.
+
+${colors.bold(colors.yellow('Options:'))}
+  ${colors.cyan('model=<model>')}        Override default model
+  ${colors.cyan('temperature=<temp>')}   Temperature (0-1, default: 0.7)
+  ${colors.cyan('max-tokens=<tokens>')}  Max tokens in response (default: 2048)
+  ${colors.cyan('wait')}                 Wait for full response (disable streaming)
+  ${colors.cyan('json')}                 Output raw JSON response
+  ${colors.cyan('env=<path>')}           Load .env file (auto-loads from cwd if exists)
+
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek ai @openai "What is the capital of France?"')}
+  ${colors.green('$ rek ai @anthropic "Explain quantum computing" model=claude-sonnet-4-20250514')}
+  ${colors.green('$ rek ai @groq "Write a haiku" wait')}
+  ${colors.green('$ rek ai @openai "Translate to Spanish: Hello world"')}
+
+${colors.bold(colors.yellow('Available AI Presets:'))}
+  ${colors.cyan('@openai')}       OpenAI (GPT-4o, GPT-5.1)
+  ${colors.cyan('@anthropic')}    Anthropic (Claude)
+  ${colors.cyan('@groq')}         Groq (fast inference)
+  ${colors.cyan('@google')}       Google (Gemini)
+  ${colors.cyan('@xai')}          xAI (Grok)
+  ${colors.cyan('@mistral')}      Mistral AI
+  ${colors.cyan('@cohere')}       Cohere
+  ${colors.cyan('@deepseek')}     DeepSeek
+  ${colors.cyan('@perplexity')}   Perplexity
+  ${colors.cyan('@together')}     Together AI
+  ${colors.cyan('@fireworks')}    Fireworks AI
+  ${colors.cyan('@replicate')}    Replicate
+  ${colors.cyan('@huggingface')}  Hugging Face
+
+${colors.bold(colors.yellow('Note:'))}
+  This command sends a single prompt without conversation memory.
+  For chat with memory, use: ${colors.cyan('rek shell')} then ${colors.cyan('@openai Your message')}
+`)
+        .action(async (preset, promptParts) => {
+        let model;
+        let temperature = '0.7';
+        let maxTokens = '2048';
+        let wait = false;
+        let jsonOutput = false;
+        let envPath;
+        const actualPromptParts = [];
+        for (const part of promptParts) {
+            if (part.startsWith('model='))
+                model = part.split('=')[1];
+            else if (part.startsWith('temperature='))
+                temperature = part.split('=')[1];
+            else if (part.startsWith('max-tokens='))
+                maxTokens = part.split('=')[1];
+            else if (part === 'wait')
+                wait = true;
+            else if (part === 'json')
+                jsonOutput = true;
+            else if (part.startsWith('env='))
+                envPath = part.split('=')[1];
+            else if (part === 'env')
+                envPath = true;
+            else
+                actualPromptParts.push(part);
+        }
+        if (envPath !== undefined) {
+            await loadEnvFile(envPath);
+        }
+        else {
+            try {
+                const envFilePath = join(process.cwd(), '.env');
+                await fs.access(envFilePath);
+                await loadEnvFile(true);
+            }
+            catch {
+            }
+        }
+        let presetName = preset;
+        if (presetName.startsWith('@')) {
+            presetName = presetName.slice(1);
+        }
+        const presetConfig = await resolvePreset(presetName);
+        if (!presetConfig) {
+            console.error(colors.red(`Unknown AI preset: @${presetName}`));
+            console.log(colors.gray('Available AI presets: @openai, @anthropic, @groq, @google, @xai, @mistral, @cohere'));
+            process.exit(1);
+        }
+        if (!presetConfig._aiConfig) {
+            console.error(colors.red(`Preset @${presetName} does not support AI features.`));
+            console.log(colors.gray('Use an AI preset like @openai, @anthropic, @groq, etc.'));
+            process.exit(1);
+        }
+        const prompt = actualPromptParts.join(' ');
+        if (!prompt.trim()) {
+            console.error(colors.red('Error: Prompt is required'));
+            process.exit(1);
+        }
+        try {
+            const { createClient } = await import('../../core/client.js');
+            const client = createClient(presetConfig);
+            if (model) {
+                client.ai.setMemoryConfig({ systemPrompt: undefined });
+                client._aiConfig.model = model;
+            }
+            if (!jsonOutput) {
+                console.log(colors.gray(`Using @${presetName} (${client._aiConfig.model})...
+`));
+            }
+            if (wait || jsonOutput) {
+                const response = await client.ai.prompt(prompt);
+                if (jsonOutput) {
+                    console.log(JSON.stringify({
+                        content: response.content,
+                        model: response.model,
+                        usage: response.usage,
+                        finishReason: response.finishReason,
+                    }, null, 2));
+                }
+                else {
+                    console.log(response.content);
+                    if (response.usage) {
+                        console.log(colors.gray(`
+─────────────────────────────────────────`));
+                        console.log(colors.gray(`Tokens: ${response.usage.inputTokens} in / ${response.usage.outputTokens} out`));
+                    }
+                }
+            }
+            else {
+                const stream = await client.ai.promptStream(prompt);
+                for await (const event of stream) {
+                    if (event.type === 'text') {
+                        process.stdout.write(event.content);
+                    }
+                }
+                console.log('');
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`AI request failed: ${error.message}`));
+            if (error.cause) {
+                console.error(colors.gray(error.cause.message || error.cause));
+            }
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/cli/commands/bench.js

@@ -0,0 +1,51 @@
+import colors from '../../utils/colors.js';
+import { RekArgs, generateHelp } from '../parser/index.js';
+const loadSchema = {
+    name: 'load',
+    description: 'Run a load test with real-time dashboard',
+    params: {
+        users: { type: 'number', default: 50, description: 'Number of concurrent users' },
+        duration: { type: 'number', default: 300, description: 'Test duration in seconds' },
+        ramp: { type: 'number', default: 5, description: 'Ramp-up time in seconds' },
+        mode: { type: 'string', default: 'throughput', choices: ['throughput', 'stress', 'realistic'], description: 'Test mode' },
+    },
+    flags: {
+        http2: { description: 'Force HTTP/2', default: false }
+    },
+    examples: [
+        { cmd: 'rek bench load httpbin.org/get users=100 duration=60', desc: '100 users for 60s' },
+        { cmd: 'rek bench load https://api.com/heavy mode=stress', desc: 'Stress test' }
+    ]
+};
+export function registerBenchCommand(program) {
+    const bench = program.command('bench').description('Performance benchmarking tools');
+    bench
+        .command('load')
+        .description(loadSchema.description)
+        .argument('[args...]', 'URL and options (users=10 duration=10s...)')
+        .addHelpText('after', generateHelp(loadSchema))
+        .action(async (rawArgs) => {
+        const { data, options, args } = RekArgs.parse(rawArgs, loadSchema);
+        let url = '';
+        for (const arg of args) {
+            if (typeof arg === 'string' && !url && (arg.includes('.') || arg.includes('localhost'))) {
+                url = arg;
+            }
+        }
+        if (!url) {
+            console.error(colors.red('Error: URL is required. Example: rek bench load httpbin.org users=50'));
+            process.exit(1);
+        }
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const { startLoadDashboard } = await import('../tui/load-dashboard.js');
+        await startLoadDashboard({
+            url,
+            users: data.users,
+            duration: data.duration,
+            mode: data.mode,
+            http2: !!(options.http2 || data.http2),
+            rampUp: data.ramp
+        });
+    });
+}

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

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

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;