recker 1.0.4 → 1.0.6

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"}

package/dist/cli/tui/load-dashboard.js

@@ -0,0 +1,117 @@
+import pc from '../../utils/colors.js';
+import { plot } from '../../utils/chart.js';
+import readline from 'node:readline';
+import { LoadGenerator } from '../../bench/generator.js';
+const ALTERNATE_SCREEN_ENTER = '\x1b[?1049h';
+const ALTERNATE_SCREEN_EXIT = '\x1b[?1049l';
+export async function startLoadDashboard(config) {
+    process.stdout.write(ALTERNATE_SCREEN_ENTER);
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+    }
+    const generator = new LoadGenerator(config);
+    let abortReject;
+    const abortPromise = new Promise((_, reject) => {
+        abortReject = reject;
+    });
+    const onKeypress = (_str, key) => {
+        if (key && (key.name === 'escape' || (key.ctrl && key.name === 'c'))) {
+            generator.stop();
+            if (abortReject)
+                abortReject(new Error('User aborted'));
+        }
+    };
+    process.stdin.on('keypress', onKeypress);
+    const rpsHistory = new Array(60).fill(0);
+    const latencyHistory = new Array(60).fill(0);
+    const usersHistory = new Array(60).fill(0);
+    const runPromise = generator.start();
+    const startTime = Date.now();
+    const interval = setInterval(() => {
+        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+        const remaining = Math.max(0, config.duration - elapsed);
+        if (remaining <= 0) {
+            clearInterval(interval);
+            return;
+        }
+        const snapshot = generator.stats.getSnapshot();
+        rpsHistory.shift();
+        rpsHistory.push(snapshot.rps);
+        latencyHistory.shift();
+        latencyHistory.push(snapshot.p95);
+        usersHistory.shift();
+        usersHistory.push(snapshot.activeUsers);
+        render(config, elapsed, remaining, snapshot, rpsHistory, latencyHistory, usersHistory, generator.stats);
+    }, 1000);
+    try {
+        await Promise.race([runPromise, abortPromise]);
+    }
+    catch (e) {
+        if (e.message !== 'User aborted')
+            throw e;
+    }
+    finally {
+        clearInterval(interval);
+        process.stdin.off('keypress', onKeypress);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        process.stdout.write(ALTERNATE_SCREEN_EXIT);
+    }
+    renderFinalReport(generator.stats, config);
+}
+function render(config, elapsed, remaining, snapshot, rpsHistory, latencyHistory, usersHistory, stats) {
+    readline.cursorTo(process.stdout, 0, 0);
+    readline.clearScreenDown(process.stdout);
+    console.log(pc.bold(pc.cyan('🔥 Rek Load Generator')));
+    console.log(pc.gray(`Target: ${config.url}`));
+    console.log(pc.gray(`Mode: ${config.mode.toUpperCase()} ${config.http2 ? '(HTTP/2)' : ''}`));
+    console.log(pc.gray('Press ESC to stop'));
+    console.log('');
+    console.log(`${pc.white('Time:')} ${pc.green(elapsed + 's')} ` +
+        `${pc.gray('/')} ${config.duration}s ` +
+        `${pc.gray('(')}${pc.yellow(remaining + 's left')}${pc.gray(')')}   ` +
+        `${pc.white('Reqs:')} ${pc.bold(stats.totalRequests)}`);
+    console.log(`${pc.blue('Users:')} ${pc.bold(snapshot.activeUsers)}   ` +
+        `${pc.green('RPS:')} ${pc.bold(snapshot.rps.toFixed(0))}   ` +
+        `${pc.magenta('Latency (P95):')} ${pc.bold(snapshot.p95.toFixed(0) + 'ms')}   ` +
+        `${pc.white('Errors:')} ${stats.failed > 0 ? pc.red(stats.failed) : pc.green('0')}`);
+    console.log(pc.gray('──────────────────────────────────────────────────'));
+    console.log(pc.bold(pc.blue('👥 Active Users')));
+    console.log(pc.blue(plot(usersHistory, { height: 4 })));
+    console.log('');
+    console.log(pc.bold(pc.green('⚡ Requests per Second')));
+    console.log(pc.green(plot(rpsHistory, { height: 6 })));
+    console.log('');
+    console.log(pc.bold(pc.magenta('⏱️  Latency P95 (ms)')));
+    console.log(pc.magenta(plot(latencyHistory, { height: 4 })));
+}
+function renderFinalReport(stats, config) {
+    const summary = stats.getSummary();
+    console.log(pc.bold(pc.green('\n✅ Load Test Complete')));
+    console.log(pc.bold('Configuration:'));
+    console.log(`  URL:      ${config.url}`);
+    console.log(`  Mode:     ${config.mode}`);
+    console.log(`  Users:    ${config.users}`);
+    console.log(`  Duration: ${config.duration}s`);
+    console.log('\n' + pc.bold('Traffic:'));
+    console.log(`  Total Requests:  ${summary.total}`);
+    console.log(`  Successful:      ${pc.green(summary.success)}`);
+    console.log(`  Failed:          ${summary.failed > 0 ? pc.red(summary.failed) : pc.gray(0)}`);
+    console.log(`  Total Bytes:     ${(summary.bytes / 1024 / 1024).toFixed(2)} MB`);
+    console.log('\n' + pc.bold('Latency (ms):'));
+    console.log(`  Avg: ${summary.latency.avg.toFixed(2)}`);
+    console.log(`  P50: ${summary.latency.p50.toFixed(0)}`);
+    console.log(`  P95: ${summary.latency.p95.toFixed(0)}`);
+    console.log(`  P99: ${summary.latency.p99.toFixed(0)}`);
+    console.log(`  Max: ${summary.latency.max.toFixed(0)}`);
+    if (Object.keys(summary.codes).length > 0) {
+        console.log('\n' + pc.bold('Status Codes:'));
+        Object.entries(summary.codes).forEach(([code, count]) => {
+            const color = code.startsWith('2') ? pc.green : code.startsWith('5') ? pc.red : pc.yellow;
+            console.log(`  ${color(code)}: ${count}`);
+        });
+    }
+    console.log('');
+}

package/dist/cli/tui/shell.d.ts

@@ -0,0 +1,27 @@
+export declare class RekShell {
+    private rl;
+    private client;
+    private history;
+    private baseUrl;
+    private lastResponse;
+    private variables;
+    private initialized;
+    constructor();
+    private ensureInitialized;
+    private getPrompt;
+    private completer;
+    start(): Promise<void>;
+    private prompt;
+    private handleCommand;
+    private runInteractiveMode;
+    private runAIChat;
+    private runLoadTest;
+    private parseLine;
+    private setBaseUrl;
+    private setVariable;
+    private resolveVariables;
+    private resolveUrl;
+    private executeRequest;
+    private printHelp;
+}
+//# sourceMappingURL=shell.d.ts.map

package/dist/cli/tui/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/shell.ts"],"names":[],"mappings":"AAsBA,qBAAa,QAAQ;IACnB,OAAO,CAAC,EAAE,CAAsB;IAChC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,WAAW,CAAS;;YAWd,iBAAiB;IAe/B,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,SAAS;IAMJ,KAAK;IA8BlB,OAAO,CAAC,MAAM;YAKA,aAAa;YAgGb,kBAAkB;YAkBlB,SAAS;YAkBT,WAAW;IA0DzB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,UAAU;YAeJ,cAAc;IAyE5B,OAAO,CAAC,SAAS;CAwClB"}

package/dist/cli/tui/shell.js

@@ -0,0 +1,386 @@
+import readline from 'node:readline';
+import { requireOptional } from '../../utils/optional-require.js';
+import { createClient } from '../../core/client.js';
+import { startInteractiveWebSocket } from './websocket.js';
+import pc from '../../utils/colors.js';
+let highlight;
+async function initDependencies() {
+    if (!highlight) {
+        const cardinal = await requireOptional('cardinal', 'recker/cli');
+        highlight = cardinal.highlight;
+    }
+}
+export class RekShell {
+    rl;
+    client;
+    history = [];
+    baseUrl = '';
+    lastResponse = null;
+    variables = {};
+    initialized = false;
+    constructor() {
+        this.client = createClient({
+            baseUrl: 'http://localhost',
+            checkHooks: false
+        });
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        await initDependencies();
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            completer: this.completer.bind(this),
+            prompt: ''
+        });
+        this.initialized = true;
+    }
+    getPrompt() {
+        const base = this.baseUrl ? pc.cyan(new URL(this.baseUrl).hostname) : pc.gray('rek');
+        return `${base} ${pc.magenta('›')} `;
+    }
+    completer(line) {
+        const commands = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options', 'ws', 'udp', 'load', 'chat', 'ai', 'help', 'clear', 'exit', 'set', 'url'];
+        const hits = commands.filter((c) => c.startsWith(line));
+        return [hits.length ? hits : commands, line];
+    }
+    async start() {
+        await this.ensureInitialized();
+        console.clear();
+        console.log(pc.bold(pc.cyan('Rek Console')));
+        console.log(pc.gray('Chat with your APIs. Type "help" for magic.'));
+        console.log(pc.gray('--------------------------------------------\n'));
+        this.prompt();
+        this.rl.on('line', async (line) => {
+            const input = line.trim();
+            if (input) {
+                await this.handleCommand(input);
+            }
+            this.prompt();
+        });
+        this.rl.on('SIGINT', () => {
+            readline.clearLine(process.stdout, 0);
+            this.prompt();
+        });
+        this.rl.on('close', () => {
+            console.log(pc.gray('\nSee ya.'));
+            process.exit(0);
+        });
+    }
+    prompt() {
+        this.rl.setPrompt(this.getPrompt());
+        this.rl.prompt();
+    }
+    async handleCommand(input) {
+        if (input.includes('=') && !input.includes(' ') && !input.startsWith('http')) {
+        }
+        const parts = this.parseLine(input);
+        const cmd = parts[0].toLowerCase();
+        switch (cmd) {
+            case 'help':
+                this.printHelp();
+                return;
+            case 'clear':
+                console.clear();
+                return;
+            case 'exit':
+            case 'quit':
+                this.rl.close();
+                return;
+            case 'url':
+                this.setBaseUrl(parts[1]);
+                return;
+            case 'set':
+                this.setVariable(parts.slice(1));
+                return;
+            case 'vars':
+                console.log(this.variables);
+                return;
+            case 'load':
+                await this.runLoadTest(parts.slice(1));
+                return;
+            case 'ai':
+            case 'chat':
+                await this.runAIChat(parts.slice(1));
+                return;
+        }
+        const methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+        let method = 'GET';
+        let url = '';
+        let bodyParts = [];
+        let headers = {};
+        if (methods.includes(cmd)) {
+            method = cmd.toUpperCase();
+            url = parts[1];
+            bodyParts = parts.slice(2);
+        }
+        else if (cmd.startsWith('http') || cmd.startsWith('/') || cmd.includes('.')) {
+            method = 'GET';
+            url = cmd;
+            bodyParts = parts.slice(1);
+        }
+        else {
+            console.log(pc.red(`Unknown command: ${cmd}`));
+            return;
+        }
+        url = this.resolveUrl(url);
+        if (!url) {
+            console.log(pc.yellow('No URL provided and no Base URL set. Use "url <url>" or provide full URL.'));
+            return;
+        }
+        const body = {};
+        for (const part of bodyParts) {
+            if (part.includes(':')) {
+                const [k, v] = part.split(':');
+                headers[k] = this.resolveVariables(v);
+            }
+            else if (part.includes('=')) {
+                const isTyped = part.includes(':=');
+                const sep = isTyped ? ':=' : '=';
+                const [k, v] = part.split(sep);
+                let val = this.resolveVariables(v);
+                if (isTyped) {
+                    if (val === 'true')
+                        val = true;
+                    else if (val === 'false')
+                        val = false;
+                    else if (!isNaN(Number(val)))
+                        val = Number(val);
+                }
+                if (method === 'GET')
+                    method = 'POST';
+                body[k] = val;
+            }
+        }
+        await this.executeRequest(method, url, headers, body);
+    }
+    async runInteractiveMode(runner) {
+        const shellListeners = this.rl.listeners('line');
+        this.rl.removeAllListeners('line');
+        try {
+            await runner(this.rl);
+        }
+        finally {
+            this.rl.removeAllListeners('line');
+            shellListeners.forEach(listener => this.rl.on('line', listener));
+            this.prompt();
+        }
+    }
+    async runAIChat(args) {
+        const provider = args[0] || 'openai';
+        const model = args[1];
+        const envKeyName = provider === 'openai' ? 'OPENAI_API_KEY' : 'ANTHROPIC_API_KEY';
+        const apiKey = this.variables[envKeyName] || process.env[envKeyName];
+        const { startAIChat } = await import('./ai-chat.js');
+        await this.runInteractiveMode(async (rl) => {
+            await startAIChat(rl, provider, apiKey, model);
+        });
+    }
+    async runLoadTest(args) {
+        let targetUrl = '';
+        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 (!targetUrl) {
+                targetUrl = arg;
+            }
+        }
+        targetUrl = this.resolveUrl(targetUrl);
+        if (!targetUrl) {
+            console.log(pc.yellow('Target URL required. usage: load <url> users=10 duration=10s ramp=5'));
+            return;
+        }
+        const { startLoadDashboard } = await import('./load-dashboard.js');
+        this.rl.pause();
+        process.stdout.write('\x1B[?25l');
+        try {
+            await startLoadDashboard({
+                url: targetUrl,
+                users,
+                duration,
+                mode,
+                http2,
+                rampUp
+            });
+        }
+        catch (e) {
+            console.error(pc.red('Load Test Failed: ' + e.message));
+        }
+        finally {
+            process.stdout.write('\x1B[?25h');
+            this.rl.resume();
+            this.prompt();
+        }
+    }
+    parseLine(input) {
+        return input.match(/(?:[^\s"]+|"[^"]*")+/g)?.map(s => s.replace(/"/g, '')) || [];
+    }
+    setBaseUrl(url) {
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        this.baseUrl = url;
+        console.log(pc.gray(`Base URL set to: ${pc.cyan(this.baseUrl)}`));
+    }
+    setVariable(args) {
+        const [expr] = args;
+        if (!expr || !expr.includes('='))
+            return;
+        const [key, val] = expr.split('=');
+        this.variables[key] = val;
+        console.log(pc.gray(`Variable $${key} set.`));
+    }
+    resolveVariables(value) {
+        if (value.startsWith('$')) {
+            const key = value.slice(1);
+            if (key.startsWith('response.') || key.startsWith('res.')) {
+                const path = key.split('.').slice(1);
+                let current = this.lastResponse;
+                for (const p of path) {
+                    if (current && typeof current === 'object')
+                        current = current[p];
+                    else
+                        return '';
+                }
+                return String(current);
+            }
+            return this.variables[key] || value;
+        }
+        return value;
+    }
+    resolveUrl(inputUrl) {
+        if (!inputUrl)
+            return this.baseUrl;
+        if (inputUrl.startsWith('http') || inputUrl.startsWith('ws') || inputUrl.startsWith('udp'))
+            return inputUrl;
+        if (this.baseUrl) {
+            const cleanBase = this.baseUrl.endsWith('/') ? this.baseUrl.slice(0, -1) : this.baseUrl;
+            const cleanPath = inputUrl.startsWith('/') ? inputUrl : `/${inputUrl}`;
+            return `${cleanBase}${cleanPath}`;
+        }
+        return `https://${inputUrl}`;
+    }
+    async executeRequest(method, url, headers, body) {
+        const startTime = performance.now();
+        if (url.startsWith('ws')) {
+            this.rl.pause();
+            try {
+                await startInteractiveWebSocket(url, headers);
+            }
+            finally {
+                this.rl.resume();
+                this.prompt();
+            }
+            return;
+        }
+        if (url.startsWith('udp')) {
+            const { UDPTransport } = await import('../../transport/udp.js');
+            const transport = new UDPTransport(url);
+            const msg = Object.keys(body).length ? JSON.stringify(body) : 'ping';
+            console.log(pc.gray(`UDP packet -> ${url}`));
+            const res = await transport.dispatch({
+                url, method: 'GET', headers: new Headers(),
+                body: msg, withHeader: () => ({}), withBody: () => ({})
+            });
+            const text = await res.text();
+            console.log(pc.green('✔ Sent/Received'));
+            if (text)
+                console.log(text);
+            return;
+        }
+        console.log(pc.gray(`${method} ${url}...`));
+        try {
+            const hasBody = Object.keys(body).length > 0;
+            const res = await this.client.request(url, {
+                method: method,
+                headers,
+                json: hasBody ? body : undefined
+            });
+            const duration = Math.round(performance.now() - startTime);
+            const statusColor = res.ok ? pc.green : pc.red;
+            console.log(`${statusColor(pc.bold(res.status))} ${statusColor(res.statusText)} ` +
+                `${pc.gray(`(${duration}ms)`)}`);
+            const text = await res.text();
+            const isJson = res.headers.get('content-type')?.includes('json');
+            if (isJson) {
+                try {
+                    const data = JSON.parse(text);
+                    console.log(highlight(JSON.stringify(data, null, 2)));
+                    this.lastResponse = data;
+                }
+                catch {
+                    console.log(text);
+                    this.lastResponse = text;
+                }
+            }
+            else {
+                console.log(text.slice(0, 500) + (text.length > 500 ? '...' : ''));
+                this.lastResponse = text;
+            }
+        }
+        catch (error) {
+            console.error(pc.red(`Error: ${error.message}`));
+        }
+        console.log('');
+    }
+    printHelp() {
+        console.log(`
+  ${pc.bold(pc.cyan('Rek Console Help'))}
+
+  ${pc.bold('Core Commands:')}
+    ${pc.green('url <url>')}           Set persistent Base URL.
+    ${pc.green('set <key>=<val>')}     Set a session variable.
+    ${pc.green('vars')}                List all session variables.
+    ${pc.green('clear')}               Clear the screen.
+    ${pc.green('exit')}                Exit the console.
+
+  ${pc.bold('HTTP Requests:')}
+    ${pc.green('<method> <path>')}     Execute HTTP request (GET, POST, PUT, DELETE, etc).
+                             ${pc.gray('Params:')} ${pc.white('key=value')} (string) or ${pc.white('key:=value')} (typed).
+                             ${pc.gray('Headers:')} ${pc.white('Key:Value')}
+
+  ${pc.bold('Advanced Tools:')}
+    ${pc.green('load <url>')}          Run Load Test.
+                             ${pc.gray('Options:')}
+                             ${pc.white('users=50')}      ${pc.gray('Concurrent users')}
+                             ${pc.white('duration=300')}  ${pc.gray('Duration in seconds')}
+                             ${pc.white('ramp=5')}        ${pc.gray('Ramp-up time in seconds')}
+                             ${pc.white('mode=throughput')}${pc.gray('throughput | stress | realistic')}
+                             ${pc.white('http2=false')}   ${pc.gray('Force HTTP/2')}
+
+    ${pc.green('chat <provider>')}     Start AI Chat.
+                             ${pc.gray('Providers:')} ${pc.white('openai')}, ${pc.white('anthropic')}
+                             ${pc.gray('Arg:')} ${pc.white('model=...')} (optional)
+
+    ${pc.green('ws <url>')}            Start interactive WebSocket session.
+    ${pc.green('udp <url>')}           Send UDP packet.
+
+  ${pc.bold('Examples:')}
+    › url httpbin.org
+    › get /json
+    › post /post name="Neo" active:=true role:Admin
+    › load /heavy-endpoint users=100 mode=stress
+    › chat openai gpt-5.1
+    `);
+    }
+}

package/dist/cli/tui/websocket.d.ts

@@ -0,0 +1,2 @@
+export declare function startInteractiveWebSocket(url: string, headers: Record<string, string>): Promise<void>;
+//# sourceMappingURL=websocket.d.ts.map

package/dist/cli/tui/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/websocket.ts"],"names":[],"mappings":"AAKA,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,iBAuG3F"}