recker 1.0.5 → 1.0.7

package/dist/bench/stats.d.ts

@@ -0,0 +1,35 @@
+export declare class LoadStats {
+    totalRequests: number;
+    successful: number;
+    failed: number;
+    bytesTransferred: number;
+    statusCodes: Record<number, number>;
+    errors: Record<string, number>;
+    latencies: number[];
+    private lastSnapshotTime;
+    private lastSnapshotRequests;
+    activeUsers: number;
+    addResult(durationMs: number, status: number, bytes: number, error?: Error): void;
+    getSnapshot(): {
+        rps: number;
+        p95: number;
+        activeUsers: number;
+    };
+    getSummary(): {
+        total: number;
+        success: number;
+        failed: number;
+        bytes: number;
+        rps: number;
+        latency: {
+            avg: number;
+            p50: number;
+            p95: number;
+            p99: number;
+            max: number;
+        };
+        codes: Record<number, number>;
+        errors: Record<string, number>;
+    };
+}
+//# sourceMappingURL=stats.d.ts.map

package/dist/bench/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../src/bench/stats.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAS;IACpB,aAAa,SAAK;IAClB,UAAU,SAAK;IACf,MAAM,SAAK;IACX,gBAAgB,SAAK;IAErB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAGpC,SAAS,EAAE,MAAM,EAAE,CAAM;IAGzB,OAAO,CAAC,gBAAgB,CAAc;IACtC,OAAO,CAAC,oBAAoB,CAAK;IAGjC,WAAW,SAAK;IAEhB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;IAoB1E,WAAW;;;;;IAmBX,UAAU;;;;;;;;;;;;;;;;CAmBX"}

package/dist/bench/stats.js

@@ -0,0 +1,60 @@
+export class LoadStats {
+    totalRequests = 0;
+    successful = 0;
+    failed = 0;
+    bytesTransferred = 0;
+    statusCodes = {};
+    errors = {};
+    latencies = [];
+    lastSnapshotTime = Date.now();
+    lastSnapshotRequests = 0;
+    activeUsers = 0;
+    addResult(durationMs, status, bytes, error) {
+        this.totalRequests++;
+        this.bytesTransferred += bytes;
+        this.latencies.push(durationMs);
+        if (error || status >= 400) {
+            this.failed++;
+            if (error) {
+                const msg = error.message || 'Unknown Error';
+                this.errors[msg] = (this.errors[msg] || 0) + 1;
+            }
+        }
+        else {
+            this.successful++;
+        }
+        if (status) {
+            this.statusCodes[status] = (this.statusCodes[status] || 0) + 1;
+        }
+    }
+    getSnapshot() {
+        const now = Date.now();
+        const timeDiff = (now - this.lastSnapshotTime) / 1000;
+        const reqDiff = this.totalRequests - this.lastSnapshotRequests;
+        const rps = reqDiff / timeDiff;
+        this.lastSnapshotTime = now;
+        this.lastSnapshotRequests = this.totalRequests;
+        const recentLatencies = this.latencies.slice(-reqDiff);
+        recentLatencies.sort((a, b) => a - b);
+        const p95 = recentLatencies[Math.floor(recentLatencies.length * 0.95)] || 0;
+        return { rps, p95, activeUsers: this.activeUsers };
+    }
+    getSummary() {
+        this.latencies.sort((a, b) => a - b);
+        const avg = this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length || 0;
+        const p50 = this.latencies[Math.floor(this.latencies.length * 0.50)] || 0;
+        const p95 = this.latencies[Math.floor(this.latencies.length * 0.95)] || 0;
+        const p99 = this.latencies[Math.floor(this.latencies.length * 0.99)] || 0;
+        const max = this.latencies[this.latencies.length - 1] || 0;
+        return {
+            total: this.totalRequests,
+            success: this.successful,
+            failed: this.failed,
+            bytes: this.bytesTransferred,
+            rps: Math.round(this.totalRequests / ((Date.now() - this.latencies[0]) / 1000) || 0),
+            latency: { avg, p50, p95, p99, max },
+            codes: this.statusCodes,
+            errors: this.errors
+        };
+    }
+}

package/dist/cli/handler.d.ts

@@ -0,0 +1,11 @@
+interface RequestOptions {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: any;
+    verbose?: boolean;
+    presetConfig?: any;
+}
+export declare function handleRequest(options: RequestOptions): Promise<void>;
+export {};
+//# sourceMappingURL=handler.d.ts.map

package/dist/cli/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/cli/handler.ts"],"names":[],"mappings":"AAmBA,UAAU,cAAc;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,cAAc,iBAqG1D"}

package/dist/cli/handler.js

@@ -0,0 +1,92 @@
+import { createClient } from '../core/client.js';
+import { requireOptional } from '../utils/optional-require.js';
+import pc from '../utils/colors.js';
+import oraImport from 'ora';
+let highlight;
+const ora = oraImport;
+async function initDependencies() {
+    if (!highlight) {
+        const cardinal = await requireOptional('cardinal', 'recker/cli');
+        highlight = cardinal.highlight;
+    }
+}
+export async function handleRequest(options) {
+    await initDependencies();
+    const spinner = ora({
+        text: `${pc.bold(options.method)} ${pc.cyan(options.url)}`,
+        color: 'cyan',
+        spinner: 'dots'
+    }).start();
+    const start = performance.now();
+    try {
+        let client;
+        if (options.presetConfig) {
+            client = createClient(options.presetConfig);
+        }
+        else {
+            try {
+                const urlObj = new URL(options.url);
+                client = createClient({ baseUrl: urlObj.origin });
+            }
+            catch {
+                client = createClient();
+            }
+        }
+        let requestBody = undefined;
+        if (options.body) {
+            requestBody = JSON.stringify(options.body);
+            if (!options.headers['Content-Type'] && !options.headers['content-type']) {
+                options.headers['Content-Type'] = 'application/json';
+            }
+        }
+        const response = await client.request(options.url, {
+            method: options.method,
+            headers: options.headers,
+            body: requestBody
+        });
+        const duration = Math.round(performance.now() - start);
+        spinner.stop();
+        const statusColor = response.ok ? pc.green : pc.red;
+        console.log(`${statusColor(pc.bold(response.status))} ${statusColor(response.statusText)} ` +
+            `${pc.gray(`(${duration}ms)`)}`);
+        if (options.verbose) {
+            console.log(pc.gray('\n--- Request ---'));
+            console.log(`${pc.bold(options.method)} ${options.url}`);
+            Object.entries(options.headers).forEach(([k, v]) => {
+                console.log(`${pc.blue(k)}: ${v}`);
+            });
+            if (options.body) {
+                console.log(pc.gray('Body:'), JSON.stringify(options.body, null, 2));
+            }
+            console.log(pc.gray('---------------\n'));
+        }
+        if (options.verbose) {
+            console.log(pc.gray('--- Response Headers ---'));
+            response.headers.forEach((value, key) => {
+                console.log(`${pc.blue(key)}: ${value}`);
+            });
+            console.log(pc.gray('------------------------\n'));
+        }
+        const contentType = response.headers.get('content-type') || '';
+        const text = await response.text();
+        if (!text)
+            return;
+        if (contentType.includes('application/json')) {
+            try {
+                const jsonObj = JSON.parse(text);
+                const jsonString = JSON.stringify(jsonObj, null, 2);
+                console.log(highlight(jsonString));
+            }
+            catch {
+                console.log(text);
+            }
+        }
+        else {
+            console.log(text);
+        }
+    }
+    catch (error) {
+        spinner.fail(pc.red('Request Failed'));
+        throw error;
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import pc from '../utils/colors.js';
+async function main() {
+    const { handleRequest } = await import('./handler.js');
+    const { resolvePreset } = await import('./presets.js');
+    const presets = await import('../presets/index.js');
+    let version = '0.0.0';
+    try {
+        const pkg = await import('../../package.json', { with: { type: 'json' } });
+        version = pkg.default?.version || '0.0.0';
+    }
+    catch {
+    }
+    function parseMixedArgs(args, hasPreset = false) {
+        const headers = {};
+        const data = {};
+        let method = 'GET';
+        let url = '';
+        const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        for (const arg of args) {
+            if (methods.includes(arg.toUpperCase())) {
+                method = arg.toUpperCase();
+                continue;
+            }
+            if (arg.includes(':') && !arg.includes('://') && !arg.includes('=')) {
+                const [key, value] = arg.split(':');
+                headers[key.trim()] = value.trim();
+                continue;
+            }
+            if (arg.includes('=')) {
+                if (method === 'GET')
+                    method = 'POST';
+                const isTyped = arg.includes(':=');
+                const separator = isTyped ? ':=' : '=';
+                const [key, value] = arg.split(separator);
+                if (isTyped) {
+                    if (value === 'true')
+                        data[key] = true;
+                    else if (value === 'false')
+                        data[key] = false;
+                    else if (!isNaN(Number(value)))
+                        data[key] = Number(value);
+                    else
+                        data[key] = value;
+                }
+                else {
+                    data[key] = value;
+                }
+                continue;
+            }
+            if (!url) {
+                url = arg;
+                if (!hasPreset && !url.startsWith('http') && !url.startsWith('ws') && !url.startsWith('udp')) {
+                    url = `https://${url}`;
+                }
+            }
+        }
+        return { method, url, headers, data };
+    }
+    const PRESET_NAMES = Object.keys(presets).filter(k => k !== 'registry' && !k.startsWith('_'));
+    program
+        .name('rek')
+        .description('The HTTP Client for Humans (and Robots)')
+        .version(version)
+        .argument('[args...]', 'URL, Method, Headers (Key:Value), Data (key=value)')
+        .option('-v, --verbose', 'Show full request/response details')
+        .option('-j, --json', 'Force JSON content-type')
+        .addHelpText('after', `
+${pc.bold(pc.yellow('Examples:'))}
+  ${pc.green('$ rek httpbin.org/json')}
+  ${pc.green('$ rek post api.com/users name="Cyber" role="Admin"')}
+  ${pc.green('$ rek @github/user')}
+  ${pc.green('$ rek @openai/v1/chat/completions model="gpt-5.1"')}
+
+${pc.bold(pc.yellow('Available Presets:'))}
+  ${pc.cyan(PRESET_NAMES.map(p => '@' + p).join(', '))}
+`)
+        .action(async (args, options) => {
+        if (args.length === 0) {
+            program.help();
+            return;
+        }
+        let argsToParse = args;
+        let presetConfig = undefined;
+        if (args[0].startsWith('@')) {
+            let presetName = args[0].slice(1);
+            let pathFromPreset = '';
+            if (presetName.includes('/')) {
+                const parts = presetName.split('/');
+                presetName = parts[0];
+                pathFromPreset = '/' + parts.slice(1).join('/');
+            }
+            presetConfig = resolvePreset(presetName);
+            argsToParse = args.slice(1);
+            if (pathFromPreset) {
+                argsToParse.unshift(pathFromPreset);
+            }
+        }
+        const { method, url, headers, data } = parseMixedArgs(argsToParse, !!presetConfig);
+        if (!url) {
+            console.error(pc.red('Error: URL/Path is required'));
+            process.exit(1);
+        }
+        if (options.json) {
+            headers['Content-Type'] = 'application/json';
+            headers['Accept'] = 'application/json';
+        }
+        if (url.startsWith('ws://') || url.startsWith('wss://')) {
+            const { startInteractiveWebSocket } = await import('./tui/websocket.js');
+            await startInteractiveWebSocket(url, headers);
+            return;
+        }
+        if (url.startsWith('udp://')) {
+            console.log(pc.yellow('UDP mode coming soon...'));
+            return;
+        }
+        try {
+            await handleRequest({
+                method,
+                url,
+                headers,
+                body: Object.keys(data).length > 0 ? data : undefined,
+                verbose: options.verbose,
+                presetConfig
+            });
+        }
+        catch (error) {
+            console.error(pc.red(`
+Error: ${error.message}`));
+            if (options.verbose && error.cause) {
+                console.error(error.cause);
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command('completion')
+        .description('Generate shell completion script')
+        .action(() => {
+        const script = `
+###-begin-rek-completion-###
+#
+# rek command completion script
+#
+# Installation: rek completion >> ~/.bashrc  (or ~/.zshrc)
+# Or, maybe: source <(rek completion)
+#
+
+_rek_completions()
+{
+  local cur prev words cword
+  _init_completion -n : || return
+
+  local presets="${PRESET_NAMES.map(p => '@' + p).join(' ')}"
+  local methods="GET POST PUT DELETE PATCH HEAD OPTIONS"
+  local opts="-v --verbose -j --json -h --help -V --version"
+
+  if [[ \\$cur == -* ]] ; then
+    COMPREPLY=( $(compgen -W "\\$opts" -- \\$cur) )
+    return 0
+  fi
+
+  if [[ \\$cur == @* ]] ; then
+    COMPREPLY=( $(compgen -W "\\$presets" -- \\$cur) )
+    return 0
+  fi
+
+  # If prev is a method, we likely want a URL next
+  # If prev is a preset, we might want a path (handled by generic completion)
+
+  # Suggest methods if it's the first argument (and not a preset/option)
+  if [[ \\$cword -eq 1 && ! \\$cur == -* && ! \\$cur == @* ]]; then
+     COMPREPLY=( $(compgen -W "\\$methods" -- \\$cur) )
+  fi
+
+  return 0
+}
+complete -F _rek_completions rek
+###-end-rek-completion-###
+`;
+        console.log(script);
+    });
+    program
+        .command('shell')
+        .alias('interactive')
+        .alias('repl')
+        .description('Start the interactive Rek Shell')
+        .action(async () => {
+        const { RekShell } = await import('./tui/shell.js');
+        const shell = new RekShell();
+        shell.start();
+    });
+    const bench = program.command('bench').description('Performance benchmarking tools');
+    bench
+        .command('load')
+        .description('Run a load test with real-time dashboard')
+        .argument('[args...]', 'URL and options (users=10 duration=10s mode=throughput http2)')
+        .addHelpText('after', `
+${pc.bold(pc.yellow('Options (key=value):'))}
+  ${pc.green('users')}     Number of concurrent users    ${pc.gray('(default: 50)')}
+  ${pc.green('duration')}  Test duration in seconds      ${pc.gray('(default: 300)')}
+  ${pc.green('ramp')}      Ramp-up time in seconds       ${pc.gray('(default: 5)')}
+  ${pc.green('mode')}      Test mode                     ${pc.gray('(default: throughput)')}
+               ${pc.gray('Values: throughput, stress, realistic')}
+  ${pc.green('http2')}     Force HTTP/2                  ${pc.gray('(default: false)')}
+
+${pc.bold(pc.yellow('Examples:'))}
+  ${pc.green('$ rek bench load httpbin.org/get users=100 duration=60 ramp=10')}
+  ${pc.green('$ rek bench load https://api.com/heavy mode=stress http2=true')}
+`)
+        .action(async (args) => {
+        let url = '';
+        let users = 50;
+        let duration = 300;
+        let mode = 'throughput';
+        let http2 = false;
+        let rampUp = 5;
+        for (const arg of args) {
+            if (arg.includes('=')) {
+                const [key, val] = arg.split('=');
+                const k = key.toLowerCase();
+                if (k === 'users' || k === 'u')
+                    users = parseInt(val);
+                else if (k === 'duration' || k === 'd' || k === 'time')
+                    duration = parseInt(val);
+                else if (k === 'mode' || k === 'm')
+                    mode = val;
+                else if (k === 'http2')
+                    http2 = val === 'true';
+                else if (k === 'ramp' || k === 'rampup')
+                    rampUp = parseInt(val);
+            }
+            else if (arg.toLowerCase() === 'http2') {
+                http2 = true;
+            }
+            else if (!url) {
+                url = arg;
+                if (!url.startsWith('http'))
+                    url = `https://${url}`;
+            }
+        }
+        if (!url) {
+            console.error(pc.red('Error: URL is required. Example: rek bench load httpbin.org users=50'));
+            process.exit(1);
+        }
+        const { startLoadDashboard } = await import('./tui/load-dashboard.js');
+        await startLoadDashboard({ url, users, duration, mode, http2, rampUp });
+    });
+    program.parse();
+}
+main().catch((error) => {
+    console.error('CLI Error:', error.message);
+    process.exit(1);
+});

package/dist/cli/presets.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePreset(name: string): any;
+//# sourceMappingURL=presets.d.ts.map

package/dist/cli/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/cli/presets.ts"],"names":[],"mappings":"AAiBA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,OAsCzC"}

package/dist/cli/presets.js

@@ -0,0 +1,67 @@
+import * as presets from '../presets/index.js';
+import pc from '../utils/colors.js';
+const ENV_MAPPING = {
+    openai: ['OPENAI_API_KEY'],
+    anthropic: ['ANTHROPIC_API_KEY'],
+    github: ['GITHUB_TOKEN'],
+    gitlab: ['GITLAB_TOKEN'],
+    stripe: ['STRIPE_SECRET_KEY'],
+    discord: ['DISCORD_TOKEN'],
+    slack: ['SLACK_TOKEN'],
+    vercel: ['VERCEL_TOKEN'],
+    supabase: ['SUPABASE_URL', 'SUPABASE_KEY'],
+};
+export function resolvePreset(name) {
+    const presetFn = presets[name];
+    if (!presetFn) {
+        console.error(pc.red(`Error: Unknown preset '@${name}'`));
+        process.exit(1);
+    }
+    const requiredEnvs = ENV_MAPPING[name];
+    const options = {};
+    if (requiredEnvs) {
+        let missing = false;
+        for (const envVar of requiredEnvs) {
+            const value = process.env[envVar];
+            if (!value) {
+                console.error(pc.yellow(`Warning: Missing env variable ${envVar} for preset @${name}`));
+                missing = true;
+            }
+            else {
+                const key = mapEnvToOption(name, envVar);
+                options[key] = value;
+            }
+        }
+        if (missing) {
+            console.log(pc.gray(`Tip: export ${requiredEnvs.join('=... ')}=...`));
+        }
+    }
+    try {
+        return presetFn(options);
+    }
+    catch (error) {
+        console.error(pc.red(`Error initializing preset @${name}: ${error.message}`));
+        process.exit(1);
+    }
+}
+function mapEnvToOption(preset, env) {
+    if (env.endsWith('_KEY') || env.endsWith('_TOKEN'))
+        return 'apiKey';
+    if (env === 'GITHUB_TOKEN')
+        return 'token';
+    if (env === 'GITLAB_TOKEN')
+        return 'token';
+    if (env === 'DISCORD_TOKEN')
+        return 'token';
+    if (env === 'SLACK_TOKEN')
+        return 'token';
+    if (env === 'VERCEL_TOKEN')
+        return 'token';
+    if (env === 'STRIPE_SECRET_KEY')
+        return 'secretKey';
+    if (env === 'SUPABASE_URL')
+        return 'projectUrl';
+    if (env === 'SUPABASE_KEY')
+        return 'apiKey';
+    return 'apiKey';
+}

package/dist/cli/tui/ai-chat.d.ts

@@ -0,0 +1,3 @@
+import readline from 'node:readline';
+export declare function startAIChat(rl: readline.Interface, provider?: string, apiKey?: string, model?: string): Promise<void>;
+//# sourceMappingURL=ai-chat.d.ts.map

package/dist/cli/tui/ai-chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-chat.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/ai-chat.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,eAAe,CAAC;AAKrC,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAE,MAAiB,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,iBAwHrH"}

package/dist/cli/tui/ai-chat.js

@@ -0,0 +1,100 @@
+import readline from 'node:readline';
+import pc from '../../utils/colors.js';
+import { createAIClient } from '../../ai/client.js';
+export async function startAIChat(rl, provider = 'openai', apiKey, model) {
+    console.clear();
+    console.log(pc.bold(pc.magenta(`🤖 Rek AI Chat (${provider})`)));
+    console.log(pc.gray('Type your message. Ctrl+C to exit.'));
+    const envKey = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
+    const key = apiKey || process.env[envKey];
+    if (!key) {
+        console.log(pc.yellow(`
+Warning: No API Key found for ${provider}.`));
+        console.log(`Please set it via environment variable ${pc.bold(envKey)} or passing it to the command.`);
+        console.log(`Example: set ${envKey}=sk-... inside the shell.`);
+        return;
+    }
+    const client = createAIClient({
+        defaultProvider: provider,
+        providers: {
+            [provider]: { apiKey: key }
+        },
+        observability: false
+    });
+    const history = [
+        { role: 'system', content: 'You are Recker AI, a helpful and concise assistant in a terminal environment.' }
+    ];
+    rl.setPrompt(pc.magenta('You › '));
+    rl.prompt();
+    return new Promise((resolve) => {
+        const onLine = async (line) => {
+            const input = line.trim();
+            if (!input) {
+                rl.prompt();
+                return;
+            }
+            if (input.toLowerCase() === '/clear') {
+                history.length = 1;
+                console.clear();
+                console.log(pc.gray('Context cleared.'));
+                rl.prompt();
+                return;
+            }
+            if (input.toLowerCase() === '/exit') {
+                cleanup();
+                resolve();
+                return;
+            }
+            history.push({ role: 'user', content: input });
+            rl.pause();
+            process.stdout.write(pc.cyan('AI  › '));
+            let fullResponse = '';
+            try {
+                const stream = await client.stream({
+                    provider: provider,
+                    model: model,
+                    messages: history
+                });
+                for await (const chunk of stream) {
+                    const content = typeof chunk === 'string' ? chunk : chunk.content || chunk.delta?.content || '';
+                    if (content) {
+                        process.stdout.write(content);
+                        fullResponse += content;
+                    }
+                }
+                process.stdout.write('\n');
+                history.push({ role: 'assistant', content: fullResponse });
+            }
+            catch (error) {
+                console.log(pc.red(`
+Error: ${error.message}`));
+                if (error.cause)
+                    console.log(pc.gray(error.cause));
+            }
+            finally {
+                rl.resume();
+                rl.prompt();
+            }
+        };
+        const cleanup = () => {
+            rl.off('line', onLine);
+            rl.off('SIGINT', onSigInt);
+            process.stdin.off('keypress', onKeypress);
+        };
+        if (process.stdin.isTTY)
+            readline.emitKeypressEvents(process.stdin);
+        const onKeypress = (_str, key) => {
+            if (key && key.name === 'escape') {
+                cleanup();
+                resolve();
+            }
+        };
+        process.stdin.on('keypress', onKeypress);
+        rl.on('line', onLine);
+        const onSigInt = () => {
+            cleanup();
+            resolve();
+        };
+        rl.once('SIGINT', onSigInt);
+    });
+}

package/dist/cli/tui/load-dashboard.d.ts

@@ -0,0 +1,3 @@
+import { LoadConfig } from '../../bench/generator.js';
+export declare function startLoadDashboard(config: LoadConfig): Promise<void>;
+//# sourceMappingURL=load-dashboard.d.ts.map

package/dist/cli/tui/load-dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-dashboard.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/load-dashboard.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAKrE,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,UAAU,iBA4E1D"}