recker 1.0.43 → 1.0.44-next.084c2ef

package/dist/browser/utils/binary-manager.js

@@ -0,0 +1,72 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform, arch } from 'node:os';
+import { spawn } from 'node:child_process';
+import { createWriteStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+const BIN_DIR = join(homedir(), '.recker', 'bin');
+const VERSION = 'v0.6.1';
+export function getCurlBinName() {
+    return 'curl-impersonate-chrome';
+}
+export function getCurlPath() {
+    return join(BIN_DIR, getCurlBinName());
+}
+export async function hasImpersonate() {
+    try {
+        await fs.access(getCurlPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getDownloadUrl() {
+    const p = platform();
+    const a = arch();
+    const baseUrl = `https://github.com/lwthiker/curl-impersonate/releases/download/${VERSION}`;
+    if (p === 'linux') {
+        if (a === 'x64')
+            return `${baseUrl}/curl-impersonate-${VERSION}.x86_64-linux-gnu.tar.gz`;
+        if (a === 'arm64')
+            return `${baseUrl}/curl-impersonate-${VERSION}.aarch64-linux-gnu.tar.gz`;
+    }
+    if (p === 'darwin') {
+        throw new Error('Auto-install not yet supported on macOS. Please install curl-impersonate manually.');
+    }
+    if (p === 'win32') {
+        throw new Error('Auto-install not yet supported on Windows.');
+    }
+    throw new Error(`Unsupported platform: ${p} ${a}`);
+}
+export async function installCurlImpersonate(logger = console) {
+    const url = getDownloadUrl();
+    const tarPath = join(BIN_DIR, 'curl-impersonate.tar.gz');
+    await fs.mkdir(BIN_DIR, { recursive: true });
+    logger.log(`Downloading curl-impersonate from ${url}...`);
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Failed to download: ${res.statusText}`);
+    if (!res.body)
+        throw new Error('Empty body');
+    const fileStream = createWriteStream(tarPath);
+    await finished(Readable.fromWeb(res.body).pipe(fileStream));
+    logger.log('Extracting...');
+    await new Promise((resolve, reject) => {
+        const tar = spawn('tar', ['-xzf', tarPath, '-C', BIN_DIR]);
+        tar.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Tar exited with code ${code}`));
+        });
+    });
+    await fs.unlink(tarPath);
+    if (await hasImpersonate()) {
+        logger.log(`✅ Installed to ${getCurlPath()}`);
+    }
+    else {
+        throw new Error('Installation failed: Binary not found after extraction');
+    }
+}

package/dist/browser/utils/user-agent.js

@@ -1,17 +1,6 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-let RECKER_VERSION = '1.0.0';
-try {
-    const pkgPath = join(process.cwd(), 'package.json');
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-    if (pkg.name === 'recker' && pkg.version) {
-        RECKER_VERSION = pkg.version;
-    }
-}
-catch {
-}
+const VERSION = '0.0.0-dev';
 export function getDefaultUserAgent() {
-    return `recker/${RECKER_VERSION}`;
+    return `recker/${VERSION}`;
 }
 export const USER_AGENT_PRESETS = {
     chrome_windows: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',

package/dist/cache/indexed-db.d.ts

@@ -0,0 +1,10 @@
+import type { CacheStorage, CacheEntry } from '../types/index.js';
+export declare class IndexedDBStorage implements CacheStorage {
+    private dbPromise;
+    constructor(dbName?: string);
+    private openDB;
+    get(key: string): Promise<CacheEntry | undefined | null>;
+    set(key: string, value: CacheEntry, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/cache/indexed-db.js

@@ -0,0 +1,88 @@
+const DB_NAME = 'recker-cache';
+const STORE_NAME = 'entries';
+const DB_VERSION = 1;
+export class IndexedDBStorage {
+    dbPromise;
+    constructor(dbName = DB_NAME) {
+        this.dbPromise = this.openDB(dbName);
+    }
+    openDB(dbName) {
+        return new Promise((resolve, reject) => {
+            if (typeof indexedDB === 'undefined') {
+                reject(new Error('IndexedDB is not supported in this environment'));
+                return;
+            }
+            const request = indexedDB.open(dbName, DB_VERSION);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+                }
+            };
+            request.onsuccess = (event) => {
+                resolve(event.target.result);
+            };
+            request.onerror = (event) => {
+                reject(event.target.error);
+            };
+        });
+    }
+    async get(key) {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readonly');
+            const store = transaction.objectStore(STORE_NAME);
+            const request = store.get(key);
+            request.onsuccess = () => {
+                const result = request.result;
+                if (!result) {
+                    resolve(null);
+                    return;
+                }
+                if (result.expiresAt && Date.now() > result.expiresAt) {
+                    this.delete(key).catch(() => { });
+                    resolve(null);
+                    return;
+                }
+                resolve(result.value);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async set(key, value, ttl) {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const expiresAt = Date.now() + ttl;
+            const item = {
+                key,
+                value,
+                expiresAt
+            };
+            const request = store.put(item);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async delete(key) {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const request = store.delete(key);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async clear() {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+}

package/dist/cache/service-worker-cache.d.ts

@@ -0,0 +1,18 @@
+import type { CacheStorage, CacheEntry } from '../types/index.js';
+export declare class ServiceWorkerCache implements CacheStorage {
+    private cacheName;
+    private cachePromise;
+    constructor(options?: {
+        cacheName?: string;
+    });
+    static isSupported(): boolean;
+    private getCache;
+    private keyToUrl;
+    get(key: string): Promise<CacheEntry | undefined | null>;
+    set(key: string, value: CacheEntry, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    prune(): Promise<number>;
+}

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;