recker 1.0.26 → 1.0.27-next.1cb21f8

package/dist/browser/websocket/client.js

@@ -0,0 +1,313 @@
+import { WebSocket } from 'undici';
+import { EventEmitter } from 'events';
+import { pipeline } from 'node:stream/promises';
+import { webToNodeStream } from '../utils/streaming.js';
+import { StateError, StreamError, ConnectionError } from '../core/errors.js';
+export class ReckerWebSocket extends EventEmitter {
+    ws = null;
+    url;
+    options;
+    reconnectAttempts = 0;
+    reconnectTimer;
+    heartbeatTimer;
+    isClosed = false;
+    isReconnecting = false;
+    pongWatchdog;
+    backoff;
+    closedByUser = false;
+    constructor(url, options = {}) {
+        super();
+        this.url = url;
+        this.options = {
+            protocols: options.protocols || [],
+            headers: options.headers || {},
+            reconnect: options.reconnect ?? false,
+            reconnectDelay: options.reconnectDelay ?? 1000,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? 5,
+            heartbeatInterval: options.heartbeatInterval ?? 30000,
+            heartbeatTimeout: options.heartbeatTimeout ?? 10000,
+            dispatcher: options.dispatcher,
+            proxy: options.proxy,
+            tls: options.tls,
+            perMessageDeflate: options.perMessageDeflate ?? false
+        };
+        this.backoff = {
+            base: this.options.reconnectDelay,
+            factor: 2,
+            jitter: true,
+            max: 30000
+        };
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                const wsOptions = {
+                    headers: this.options.headers,
+                    dispatcher: this.options.dispatcher,
+                    perMessageDeflate: this.options.perMessageDeflate,
+                };
+                if (this.options.proxy) {
+                    const proxyConfig = typeof this.options.proxy === 'string'
+                        ? { url: this.options.proxy }
+                        : this.options.proxy;
+                    const { ProxyAgent } = require('undici');
+                    wsOptions.dispatcher = new ProxyAgent(proxyConfig.url);
+                }
+                if (this.options.tls) {
+                    wsOptions.tls = this.options.tls;
+                }
+                this.ws = new WebSocket(this.url, this.options.protocols, wsOptions);
+                this.ws.addEventListener('open', () => {
+                    this.reconnectAttempts = 0;
+                    this.isReconnecting = false;
+                    this.startHeartbeat();
+                    this.emit('open');
+                    resolve();
+                });
+                this.ws.addEventListener('message', (event) => {
+                    const message = {
+                        data: event.data,
+                        isBinary: event.data instanceof Buffer
+                    };
+                    this.emit('message', message);
+                    this.stopPongWatchdog();
+                });
+                this.ws.addEventListener('close', (event) => {
+                    this.stopHeartbeat();
+                    this.stopPongWatchdog();
+                    this.emit('close', event.code, event.reason);
+                    if (!this.closedByUser && !this.isClosed && this.options.reconnect) {
+                        this.attemptReconnect();
+                    }
+                });
+                this.ws.addEventListener('error', (event) => {
+                    const err = event.error instanceof Error
+                        ? event.error
+                        : new ConnectionError('WebSocket connection error', {
+                            host: this.url,
+                            retriable: true,
+                        });
+                    this.emit('error', err);
+                    reject(err);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async send(data, options) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new StateError('WebSocket is not connected', {
+                expectedState: 'open',
+                actualState: this.ws ? 'closed' : 'not-created',
+            });
+        }
+        const awaitDrain = options?.awaitDrain ?? false;
+        const highWaterMark = options?.highWaterMark ?? 16 * 1024;
+        this.ws.send(data);
+        if (awaitDrain) {
+            await this.waitForDrain(highWaterMark);
+        }
+    }
+    async sendStream(stream, options) {
+        for await (const chunk of stream) {
+            await this.send(chunk, options);
+        }
+    }
+    sendJSON(data) {
+        void this.send(JSON.stringify(data));
+    }
+    close(code = 1000, reason = '') {
+        this.isClosed = true;
+        this.closedByUser = true;
+        this.stopHeartbeat();
+        this.clearReconnectTimer();
+        if (this.ws) {
+            this.ws.close(code, reason);
+            this.ws = null;
+        }
+    }
+    ping() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const anyWs = this.ws;
+        if (typeof anyWs.ping === 'function') {
+            try {
+                anyWs.ping();
+                return;
+            }
+            catch {
+            }
+        }
+        try {
+            this.ws.send('__heartbeat__');
+        }
+        catch {
+        }
+    }
+    get readyState() {
+        return this.ws?.readyState ?? WebSocket.CLOSED;
+    }
+    get isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    toReadable() {
+        if (!this.ws)
+            return null;
+        const wsAny = this.ws;
+        if (wsAny.readable) {
+            return webToNodeStream(wsAny.readable);
+        }
+        return null;
+    }
+    async pipeFrom(source, options) {
+        await this.sendStream(source, options);
+    }
+    async pipeTo(destination) {
+        const readable = this.toReadable();
+        if (!readable) {
+            throw new StreamError('WebSocket has no readable stream', {
+                streamType: 'websocket',
+                retriable: false,
+            });
+        }
+        await pipeline(readable, destination);
+    }
+    async *[Symbol.asyncIterator]() {
+        const queue = [];
+        let resolveNext = null;
+        let closed = false;
+        const messageHandler = (msg) => {
+            if (resolveNext) {
+                resolveNext(msg);
+                resolveNext = null;
+            }
+            else {
+                queue.push(msg);
+            }
+        };
+        const closeHandler = () => {
+            closed = true;
+            if (resolveNext) {
+                resolveNext(null);
+                resolveNext = null;
+            }
+        };
+        this.on('message', messageHandler);
+        this.on('close', closeHandler);
+        try {
+            while (true) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                }
+                else {
+                    if (closed)
+                        break;
+                    const msg = await new Promise((resolve) => {
+                        resolveNext = resolve;
+                    });
+                    if (msg) {
+                        yield msg;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            this.off('message', messageHandler);
+            this.off('close', closeHandler);
+        }
+    }
+    attemptReconnect() {
+        if (this.isReconnecting)
+            return;
+        if (this.options.maxReconnectAttempts > 0 &&
+            this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+            this.emit('max-reconnect-attempts');
+            return;
+        }
+        this.isReconnecting = true;
+        this.reconnectAttempts++;
+        const baseDelay = this.backoff.base * Math.pow(this.backoff.factor, this.reconnectAttempts - 1);
+        const capped = this.backoff.max ? Math.min(baseDelay, this.backoff.max) : baseDelay;
+        const jittered = this.backoff.jitter ? randomJitter(capped) : capped;
+        this.emit('reconnecting', this.reconnectAttempts, jittered);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch((error) => {
+                this.emit('reconnect-error', error);
+            });
+        }, jittered);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
+    startHeartbeat() {
+        if (this.options.heartbeatInterval <= 0)
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            if (this.isConnected) {
+                this.ping();
+                this.startPongWatchdog();
+            }
+        }, this.options.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+        this.stopPongWatchdog();
+    }
+    startPongWatchdog() {
+        this.stopPongWatchdog();
+        if (this.options.heartbeatTimeout <= 0)
+            return;
+        this.pongWatchdog = setTimeout(() => {
+            this.emit('heartbeat-timeout');
+            if (!this.closedByUser && this.options.reconnect) {
+                this.ws?.close(4000, 'heartbeat timeout');
+            }
+        }, this.options.heartbeatTimeout);
+    }
+    stopPongWatchdog() {
+        if (this.pongWatchdog) {
+            clearTimeout(this.pongWatchdog);
+            this.pongWatchdog = undefined;
+        }
+    }
+    getBufferedAmount() {
+        return this.ws?.bufferedAmount ?? 0;
+    }
+    async waitForDrain(highWaterMark) {
+        const buffered = this.getBufferedAmount();
+        if (buffered <= highWaterMark)
+            return;
+        await new Promise((resolve) => {
+            const check = () => {
+                if (this.getBufferedAmount() <= highWaterMark || !this.isConnected) {
+                    resolve();
+                }
+                else {
+                    setTimeout(check, 10);
+                }
+            };
+            setTimeout(check, 10);
+        });
+    }
+}
+export function createWebSocket(url, options) {
+    const ws = new ReckerWebSocket(url, options);
+    ws.connect().catch(() => {
+    });
+    return ws;
+}
+function randomJitter(value) {
+    const jitter = 0.2 * value;
+    return value - jitter + Math.random() * (2 * jitter);
+}

package/dist/cli/index.d.ts

@@ -1 +1,2 @@
+#!/usr/bin/env node
 export {};

package/dist/cli/index.js

@@ -1,7 +1,9 @@
+#!/usr/bin/env node
 import { program } from 'commander';
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
 import colors from '../utils/colors.js';
+import { formatColumns } from '../utils/columns.js';
 async function readStdin() {
     if (process.stdin.isTTY) {
         return null;
@@ -119,7 +121,13 @@ async function main() {
         }
         return { method, url, headers, data };
     }
-    const PRESET_NAMES = Object.keys(presets).filter(k => k !== 'registry' && !k.startsWith('_'));
+    const utilityFunctions = [
+        'registry', 'presetRegistry', 'detectPreset', 'getPreset',
+        'listPresets', 'listAIPresets', 'listCloudPresets', 'listSaaSPresets', 'listDevToolsPresets'
+    ];
+    const PRESET_NAMES = Object.keys(presets)
+        .filter(k => !utilityFunctions.includes(k) && !k.startsWith('_') && typeof presets[k] === 'function')
+        .sort();
     program
         .name('rek')
         .description('The HTTP Client for Humans (and Robots)')
@@ -130,7 +138,7 @@ async function main() {
         .option('-o, --output <file>', 'Write response body to file')
         .option('-j, --json', 'Force JSON content-type')
         .option('-e, --env [path]', 'Load .env file from current directory or specified path')
-        .addHelpText('after', `
+        .addHelpText('after', () => `
 ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek httpbin.org/json')}
   ${colors.green('$ rek post api.com/users name="Cyber" role="Admin"')}
@@ -138,7 +146,7 @@ ${colors.bold(colors.yellow('Examples:'))}
   ${colors.green('$ rek @openai/v1/chat/completions model="gpt-5.1"')}
 
 ${colors.bold(colors.yellow('Available Presets:'))}
-  ${colors.cyan(PRESET_NAMES.map(p => '@' + p).join(', '))}
+${formatColumns(PRESET_NAMES, { prefix: '@', indent: 2, minWidth: 16, transform: colors.cyan })}
 `)
         .action(async (args, options) => {
         if (args.length === 0) {
@@ -380,6 +388,138 @@ ${colors.bold('Details:')}`);
             process.exit(1);
         }
     });
+    program
+        .command('seo')
+        .description('Analyze page SEO (title, meta, headings, links, images, structured data)')
+        .argument('<url>', 'URL to analyze')
+        .option('-a, --all', 'Show all checks including passed ones')
+        .option('--format <format>', 'Output format: text (default) or json', 'text')
+        .addHelpText('after', `
+${colors.bold(colors.yellow('Examples:'))}
+  ${colors.green('$ rek seo example.com')}                    ${colors.gray('Basic SEO analysis')}
+  ${colors.green('$ rek seo example.com -a')}                 ${colors.gray('Show all checks')}
+  ${colors.green('$ rek seo example.com --format json')}      ${colors.gray('Output as JSON')}
+  ${colors.green('$ rek seo example.com --format json | jq')} ${colors.gray('Pipe to jq for processing')}
+
+${colors.bold(colors.yellow('Checks:'))}
+  ${colors.cyan('Title Tag')}          Length and presence
+  ${colors.cyan('Meta Description')}   Length and presence
+  ${colors.cyan('Headings')}           H1 presence and hierarchy
+  ${colors.cyan('Images')}             Alt text coverage
+  ${colors.cyan('Links')}              Internal/external distribution
+  ${colors.cyan('OpenGraph')}          Social sharing meta tags
+  ${colors.cyan('Twitter Card')}       Twitter sharing meta tags
+  ${colors.cyan('Structured Data')}    JSON-LD presence
+  ${colors.cyan('Technical')}          Canonical, viewport, lang
+`)
+        .action(async (url, options) => {
+        if (!url.startsWith('http'))
+            url = `https://${url}`;
+        const isJson = options.format === 'json';
+        const { createClient } = await import('../core/client.js');
+        const { analyzeSeo } = await import('../seo/analyzer.js');
+        if (!isJson) {
+            console.log(colors.gray(`Analyzing SEO for ${url}...`));
+        }
+        try {
+            const client = createClient({ timeout: 30000 });
+            const res = await client.get(url);
+            const html = await res.text();
+            const report = await analyzeSeo(html, { baseUrl: url });
+            if (isJson) {
+                const jsonOutput = {
+                    url,
+                    analyzedAt: new Date().toISOString(),
+                    score: report.score,
+                    grade: report.grade,
+                    title: report.title,
+                    metaDescription: report.metaDescription,
+                    content: report.content,
+                    headings: report.headings,
+                    links: report.links,
+                    images: report.images,
+                    openGraph: report.social.openGraph,
+                    twitterCard: report.social.twitterCard,
+                    jsonLd: report.jsonLd,
+                    technical: report.technical,
+                    checks: report.checks,
+                    summary: {
+                        total: report.checks.length,
+                        passed: report.checks.filter(c => c.status === 'pass').length,
+                        warnings: report.checks.filter(c => c.status === 'warn').length,
+                        errors: report.checks.filter(c => c.status === 'fail').length,
+                        info: report.checks.filter(c => c.status === 'info').length,
+                    },
+                };
+                console.log(JSON.stringify(jsonOutput, null, 2));
+                return;
+            }
+            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(`
+${colors.bold(colors.cyan('🔍 SEO Analysis Report'))}
+${colors.gray('URL:')} ${url}
+${colors.gray('Grade:')} ${gradeColor(colors.bold(report.grade))}  ${colors.gray('Score:')} ${report.score}/100
+`);
+            if (report.title) {
+                console.log(`${colors.bold('Title:')} ${colors.gray(report.title.text.slice(0, 60))}${report.title.text.length > 60 ? '...' : ''} ${colors.gray(`(${report.title.length} chars)`)}`);
+            }
+            if (report.metaDescription) {
+                console.log(`${colors.bold('Description:')} ${colors.gray(report.metaDescription.text.slice(0, 80))}${report.metaDescription.text.length > 80 ? '...' : ''}`);
+            }
+            console.log('');
+            console.log(`${colors.bold('Content Metrics:')}`);
+            console.log(`  ${colors.gray('Words:')} ${report.content.wordCount}  ${colors.gray('Reading time:')} ~${report.content.readingTimeMinutes} min`);
+            console.log(`  ${colors.gray('Headings:')} H1×${report.headings.h1Count}, total ${report.headings.structure.length}`);
+            console.log(`  ${colors.gray('Links:')} ${report.links.total} (${report.links.internal} internal, ${report.links.external} external)`);
+            console.log(`  ${colors.gray('Images:')} ${report.images.total} (${report.images.withAlt} with alt, ${report.images.withoutAlt} without)`);
+            console.log('');
+            console.log(`${colors.bold('Checks:')}`);
+            const checksToShow = options.all
+                ? report.checks
+                : report.checks.filter(c => c.status !== 'pass' && c.status !== 'info');
+            if (checksToShow.length === 0 && !options.all) {
+                console.log(colors.green('  All checks passed! Use -a to see details.'));
+            }
+            else {
+                for (const check of checksToShow) {
+                    const icon = check.status === 'pass' ? colors.green('✔')
+                        : check.status === 'warn' ? colors.yellow('⚠')
+                            : check.status === 'fail' ? colors.red('✖')
+                                : colors.gray('ℹ');
+                    const name = colors.bold(check.name.padEnd(18));
+                    console.log(`  ${icon} ${name} ${check.message}`);
+                    if (check.recommendation && check.status !== 'pass') {
+                        console.log(`      ${colors.gray('→')} ${colors.gray(check.recommendation)}`);
+                    }
+                    const evidence = check.evidence;
+                    if (evidence && check.status !== 'pass') {
+                        if (evidence.found && Array.isArray(evidence.found) && evidence.found.length > 0) {
+                            const items = evidence.found.slice(0, 3);
+                            console.log(`      ${colors.gray('Found:')} ${colors.red(items.join(', '))}${evidence.found.length > 3 ? ` (+${evidence.found.length - 3} more)` : ''}`);
+                        }
+                        if (evidence.example) {
+                            console.log(`      ${colors.gray('Example:')} ${colors.cyan(evidence.example.split('\n')[0])}`);
+                        }
+                    }
+                }
+            }
+            console.log('');
+            if (report.jsonLd.count > 0) {
+                console.log(`${colors.bold('Structured Data:')} ${report.jsonLd.types.join(', ') || 'Present'}`);
+                console.log('');
+            }
+        }
+        catch (error) {
+            console.error(colors.red(`SEO analysis failed: ${error.message}`));
+            process.exit(1);
+        }
+    });
     program
         .command('ip')
         .description('Get IP address intelligence using local GeoLite2 database')

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

@@ -43,6 +43,7 @@ export declare class RekShell {
     private runWhois;
     private runTLS;
     private runSecurityGrader;
+    private runSeo;
     private runIpIntelligence;
     private runDNS;
     private runDNSPropagation;