recker 1.0.20-next.9796be9 → 1.0.20-next.a5aea1e

package/dist/testing/mock-telnet-server.js

@@ -0,0 +1,273 @@
+import { EventEmitter } from 'node:events';
+import * as net from 'node:net';
+export class MockTelnetServer extends EventEmitter {
+    options;
+    server = null;
+    sessions = new Map();
+    commands = new Map();
+    started = false;
+    sessionCounter = 0;
+    stats = {
+        connectionsTotal: 0,
+        connectionsActive: 0,
+        commandsReceived: 0,
+        commandLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 2323,
+            host: '127.0.0.1',
+            echo: true,
+            banner: 'Welcome to Recker Mock Telnet Server\r\nType "help" for available commands.\r\n',
+            prompt: '> ',
+            delay: 0,
+            ...options,
+        };
+        this.addDefaultCommands();
+    }
+    get isRunning() {
+        return this.started;
+    }
+    get port() {
+        return this.options.port;
+    }
+    get host() {
+        return this.options.host;
+    }
+    get url() {
+        return `telnet://${this.options.host}:${this.options.port}`;
+    }
+    get activeSessions() {
+        return this.sessions.size;
+    }
+    get statistics() {
+        return {
+            ...this.stats,
+            connectionsActive: this.sessions.size,
+        };
+    }
+    addCommand(name, handler) {
+        this.commands.set(name.toLowerCase(), handler);
+    }
+    removeCommand(name) {
+        this.commands.delete(name.toLowerCase());
+    }
+    getCommand(name) {
+        return this.commands.get(name.toLowerCase());
+    }
+    clearCommands() {
+        this.commands.clear();
+        this.addDefaultCommands();
+    }
+    addDefaultCommands() {
+        this.addCommand('help', () => {
+            const cmds = Array.from(this.commands.keys()).sort();
+            return `Available commands:\r\n${cmds.map((c) => `  ${c}`).join('\r\n')}\r\n`;
+        });
+        this.addCommand('echo', (args) => args.join(' '));
+        this.addCommand('date', () => new Date().toDateString());
+        this.addCommand('time', () => new Date().toTimeString());
+        this.addCommand('datetime', () => new Date().toISOString());
+        this.addCommand('uptime', () => `${Math.floor(process.uptime())} seconds`);
+        this.addCommand('version', () => 'Recker Mock Telnet Server v1.0.0');
+        this.addCommand('whoami', (_args, session) => `Session ID: ${session.id}`);
+        this.addCommand('sessions', () => `Active sessions: ${this.sessions.size}`);
+        this.addCommand('clear', () => '\x1b[2J\x1b[H');
+        this.addCommand('quit', (_args, session) => {
+            session.socket.end('Goodbye!\r\n');
+            return '';
+        });
+        this.addCommand('exit', (_args, session) => {
+            session.socket.end('Goodbye!\r\n');
+            return '';
+        });
+        this.addCommand('ping', () => 'pong');
+        this.addCommand('reverse', (args) => args.join(' ').split('').reverse().join(''));
+        this.addCommand('upper', (args) => args.join(' ').toUpperCase());
+        this.addCommand('lower', (args) => args.join(' ').toLowerCase());
+        this.addCommand('count', (args) => `${args.join(' ').length} characters`);
+        this.addCommand('sleep', async (args) => {
+            const ms = parseInt(args[0]) || 1000;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(ms, 10000)));
+            return `Slept for ${ms}ms`;
+        });
+    }
+    broadcast(message) {
+        for (const session of this.sessions.values()) {
+            session.socket.write(`\r\n[BROADCAST] ${message}\r\n${this.options.prompt}`);
+        }
+    }
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    disconnectSession(id) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.socket.end('Disconnected by server.\r\n');
+            return true;
+        }
+        return false;
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('Server already started');
+        }
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                this.emit('error', err);
+                if (!this.started) {
+                    reject(err);
+                }
+            });
+            this.server.listen(this.options.port, this.options.host, () => {
+                this.started = true;
+                this.emit('start');
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.started || !this.server)
+            return;
+        for (const session of this.sessions.values()) {
+            session.socket.end('Server shutting down.\r\n');
+        }
+        this.sessions.clear();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.server = null;
+                this.started = false;
+                this.emit('stop');
+                resolve();
+            });
+        });
+    }
+    reset() {
+        this.stats = {
+            connectionsTotal: 0,
+            connectionsActive: 0,
+            commandsReceived: 0,
+            commandLog: [],
+        };
+        this.clearCommands();
+        this.emit('reset');
+    }
+    handleConnection(socket) {
+        const sessionId = `session-${++this.sessionCounter}`;
+        const session = {
+            id: sessionId,
+            socket,
+            connectedAt: new Date(),
+            lastActivity: new Date(),
+            data: {},
+        };
+        this.sessions.set(sessionId, session);
+        this.stats.connectionsTotal++;
+        this.emit('connect', session);
+        socket.write(this.options.banner);
+        socket.write(this.options.prompt);
+        let inputBuffer = '';
+        socket.on('data', async (data) => {
+            session.lastActivity = new Date();
+            const filtered = this.filterTelnetCommands(data);
+            const text = filtered.toString('utf8');
+            if (this.options.echo) {
+                socket.write(text);
+            }
+            inputBuffer += text;
+            while (inputBuffer.includes('\n') || inputBuffer.includes('\r')) {
+                const lineEnd = Math.max(inputBuffer.indexOf('\n'), inputBuffer.indexOf('\r'));
+                if (lineEnd === -1)
+                    break;
+                let line = inputBuffer.substring(0, lineEnd).trim();
+                inputBuffer = inputBuffer.substring(lineEnd + 1).replace(/^[\r\n]+/, '');
+                if (!line) {
+                    socket.write(this.options.prompt);
+                    continue;
+                }
+                await this.handleCommand(line, session);
+            }
+        });
+        socket.on('close', () => {
+            this.sessions.delete(sessionId);
+            this.emit('disconnect', session);
+        });
+        socket.on('error', (err) => {
+            this.emit('error', err, session);
+            this.sessions.delete(sessionId);
+        });
+    }
+    filterTelnetCommands(data) {
+        const filtered = [];
+        let i = 0;
+        while (i < data.length) {
+            if (data[i] === 255) {
+                if (i + 1 < data.length) {
+                    const cmd = data[i + 1];
+                    if (cmd >= 251 && cmd <= 254) {
+                        i += 3;
+                        continue;
+                    }
+                    else if (cmd === 255) {
+                        filtered.push(255);
+                        i += 2;
+                        continue;
+                    }
+                    else {
+                        i += 2;
+                        continue;
+                    }
+                }
+            }
+            filtered.push(data[i]);
+            i++;
+        }
+        return Buffer.from(filtered);
+    }
+    async handleCommand(input, session) {
+        this.stats.commandsReceived++;
+        this.stats.commandLog.push({
+            command: input,
+            sessionId: session.id,
+            timestamp: Date.now(),
+        });
+        this.emit('command', input, session);
+        if (this.options.delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+        const parts = input.trim().split(/\s+/);
+        const cmdName = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        const handler = this.commands.get(cmdName);
+        let response;
+        if (!handler) {
+            response = `Unknown command: ${cmdName}\r\nType "help" for available commands.`;
+        }
+        else if (typeof handler === 'string') {
+            response = handler;
+        }
+        else {
+            try {
+                response = await handler(args, session);
+            }
+            catch (err) {
+                response = `Error: ${err instanceof Error ? err.message : 'Unknown error'}`;
+            }
+        }
+        if (response) {
+            session.socket.write(`${response}\r\n`);
+        }
+        if (!session.socket.destroyed) {
+            session.socket.write(this.options.prompt);
+        }
+    }
+    static async create(options = {}) {
+        const server = new MockTelnetServer(options);
+        await server.start();
+        return server;
+    }
+}

package/dist/testing/mock-udp-server.d.ts

@@ -41,4 +41,3 @@ export declare class MockUDPServer extends EventEmitter {
     static create(options?: MockUDPServerOptions): Promise<MockUDPServer>;
 }
 export declare function createMockUDPServer(responses?: Record<string, Buffer | string>, options?: MockUDPServerOptions): Promise<MockUDPServer>;
-//# sourceMappingURL=mock-udp-server.d.ts.map

package/dist/testing/mock-websocket-server.d.ts

@@ -75,4 +75,3 @@ export declare class MockWebSocketServer extends EventEmitter {
     static create(options?: MockWebSocketServerOptions): Promise<MockWebSocketServer>;
 }
 export declare function createMockWebSocketServer(responses?: Record<string, string>, options?: MockWebSocketServerOptions): Promise<MockWebSocketServer>;
-//# sourceMappingURL=mock-websocket-server.d.ts.map

package/dist/testing/mock-whois-server.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from 'node:events';
+export interface MockWhoisServerOptions {
+    port?: number;
+    host?: string;
+    delay?: number;
+}
+export interface WhoisDomainData {
+    registrar?: string;
+    registrarUrl?: string;
+    createdDate?: string;
+    updatedDate?: string;
+    expiryDate?: string;
+    status?: string[];
+    nameservers?: string[];
+    registrantName?: string;
+    registrantOrg?: string;
+    registrantEmail?: string;
+    adminEmail?: string;
+    techEmail?: string;
+    dnssec?: string;
+}
+export interface MockWhoisStats {
+    queriesReceived: number;
+    responseSent: number;
+    queryLog: Array<{
+        query: string;
+        timestamp: number;
+    }>;
+}
+export declare class MockWhoisServer extends EventEmitter {
+    private options;
+    private server;
+    private domains;
+    private started;
+    private stats;
+    constructor(options?: MockWhoisServerOptions);
+    get isRunning(): boolean;
+    get port(): number;
+    get host(): string;
+    get url(): string;
+    get statistics(): MockWhoisStats;
+    addDomain(domain: string, data: WhoisDomainData): void;
+    removeDomain(domain: string): void;
+    getDomain(domain: string): WhoisDomainData | undefined;
+    clearDomains(): void;
+    private addDefaultDomains;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reset(): void;
+    private handleConnection;
+    private handleQuery;
+    private buildResponse;
+    private buildNotFoundResponse;
+    private buildDomainResponse;
+    static create(options?: MockWhoisServerOptions): Promise<MockWhoisServer>;
+}

package/dist/testing/mock-whois-server.js

@@ -0,0 +1,234 @@
+import { EventEmitter } from 'node:events';
+import * as net from 'node:net';
+export class MockWhoisServer extends EventEmitter {
+    options;
+    server = null;
+    domains = new Map();
+    started = false;
+    stats = {
+        queriesReceived: 0,
+        responseSent: 0,
+        queryLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 4343,
+            host: '127.0.0.1',
+            delay: 0,
+            ...options,
+        };
+        this.addDefaultDomains();
+    }
+    get isRunning() {
+        return this.started;
+    }
+    get port() {
+        return this.options.port;
+    }
+    get host() {
+        return this.options.host;
+    }
+    get url() {
+        return `${this.options.host}:${this.options.port}`;
+    }
+    get statistics() {
+        return { ...this.stats };
+    }
+    addDomain(domain, data) {
+        this.domains.set(domain.toLowerCase(), data);
+    }
+    removeDomain(domain) {
+        this.domains.delete(domain.toLowerCase());
+    }
+    getDomain(domain) {
+        return this.domains.get(domain.toLowerCase());
+    }
+    clearDomains() {
+        this.domains.clear();
+        this.addDefaultDomains();
+    }
+    addDefaultDomains() {
+        this.addDomain('example.com', {
+            registrar: 'RESERVED-Internet Assigned Numbers Authority',
+            registrarUrl: 'http://www.iana.org',
+            createdDate: '1995-08-14T04:00:00Z',
+            updatedDate: '2023-08-14T07:01:38Z',
+            expiryDate: '2024-08-13T04:00:00Z',
+            status: ['client delete prohibited', 'client transfer prohibited', 'client update prohibited'],
+            nameservers: ['a.iana-servers.net', 'b.iana-servers.net'],
+            dnssec: 'signedDelegation',
+        });
+        this.addDomain('google.com', {
+            registrar: 'MarkMonitor Inc.',
+            registrarUrl: 'http://www.markmonitor.com',
+            createdDate: '1997-09-15T04:00:00Z',
+            updatedDate: '2019-09-09T15:39:04Z',
+            expiryDate: '2028-09-14T04:00:00Z',
+            status: ['client delete prohibited', 'client transfer prohibited', 'client update prohibited', 'server delete prohibited', 'server transfer prohibited', 'server update prohibited'],
+            nameservers: ['ns1.google.com', 'ns2.google.com', 'ns3.google.com', 'ns4.google.com'],
+            registrantOrg: 'Google LLC',
+            registrantEmail: 'Select Request Email Form at https://domains.markmonitor.com/whois/google.com',
+            dnssec: 'unsigned',
+        });
+        this.addDomain('test.local', {
+            registrar: 'Mock Registrar',
+            registrarUrl: 'http://localhost',
+            createdDate: '2020-01-01T00:00:00Z',
+            updatedDate: '2024-01-01T00:00:00Z',
+            expiryDate: '2030-01-01T00:00:00Z',
+            status: ['ok'],
+            nameservers: ['ns1.test.local', 'ns2.test.local'],
+            registrantName: 'Test User',
+            registrantOrg: 'Test Organization',
+            registrantEmail: 'admin@test.local',
+        });
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('Server already started');
+        }
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                this.emit('error', err);
+                if (!this.started) {
+                    reject(err);
+                }
+            });
+            this.server.listen(this.options.port, this.options.host, () => {
+                this.started = true;
+                this.emit('start');
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.started || !this.server)
+            return;
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.server = null;
+                this.started = false;
+                this.emit('stop');
+                resolve();
+            });
+        });
+    }
+    reset() {
+        this.stats = {
+            queriesReceived: 0,
+            responseSent: 0,
+            queryLog: [],
+        };
+        this.clearDomains();
+        this.emit('reset');
+    }
+    handleConnection(socket) {
+        let data = '';
+        socket.on('data', (chunk) => {
+            data += chunk.toString();
+            if (data.includes('\n') || data.includes('\r')) {
+                this.handleQuery(data.trim(), socket);
+            }
+        });
+        socket.on('error', (err) => {
+            this.emit('error', err);
+        });
+    }
+    async handleQuery(query, socket) {
+        this.stats.queriesReceived++;
+        this.stats.queryLog.push({ query, timestamp: Date.now() });
+        this.emit('query', query);
+        if (this.options.delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+        const response = this.buildResponse(query);
+        socket.write(response, () => {
+            this.stats.responseSent++;
+            this.emit('response', query);
+            socket.end();
+        });
+    }
+    buildResponse(query) {
+        const domain = query.toLowerCase().trim();
+        const data = this.domains.get(domain);
+        if (!data) {
+            return this.buildNotFoundResponse(domain);
+        }
+        return this.buildDomainResponse(domain, data);
+    }
+    buildNotFoundResponse(domain) {
+        return `
+% WHOIS Mock Server
+
+No match for domain "${domain}".
+
+>>> Last update of WHOIS database: ${new Date().toISOString()} <<<
+
+NOTICE: This is a mock WHOIS server for testing purposes.
+`.trim() + '\n';
+    }
+    buildDomainResponse(domain, data) {
+        const lines = [
+            '% WHOIS Mock Server',
+            '',
+            `Domain Name: ${domain.toUpperCase()}`,
+        ];
+        if (data.registrar) {
+            lines.push(`Registrar: ${data.registrar}`);
+        }
+        if (data.registrarUrl) {
+            lines.push(`Registrar URL: ${data.registrarUrl}`);
+        }
+        if (data.createdDate) {
+            lines.push(`Creation Date: ${data.createdDate}`);
+        }
+        if (data.updatedDate) {
+            lines.push(`Updated Date: ${data.updatedDate}`);
+        }
+        if (data.expiryDate) {
+            lines.push(`Registry Expiry Date: ${data.expiryDate}`);
+        }
+        if (data.status && data.status.length > 0) {
+            for (const status of data.status) {
+                lines.push(`Domain Status: ${status}`);
+            }
+        }
+        if (data.nameservers && data.nameservers.length > 0) {
+            for (const ns of data.nameservers) {
+                lines.push(`Name Server: ${ns}`);
+            }
+        }
+        if (data.registrantName) {
+            lines.push(`Registrant Name: ${data.registrantName}`);
+        }
+        if (data.registrantOrg) {
+            lines.push(`Registrant Organization: ${data.registrantOrg}`);
+        }
+        if (data.registrantEmail) {
+            lines.push(`Registrant Email: ${data.registrantEmail}`);
+        }
+        if (data.adminEmail) {
+            lines.push(`Admin Email: ${data.adminEmail}`);
+        }
+        if (data.techEmail) {
+            lines.push(`Tech Email: ${data.techEmail}`);
+        }
+        if (data.dnssec) {
+            lines.push(`DNSSEC: ${data.dnssec}`);
+        }
+        lines.push('');
+        lines.push(`>>> Last update of WHOIS database: ${new Date().toISOString()} <<<`);
+        lines.push('');
+        lines.push('NOTICE: This is a mock WHOIS server for testing purposes.');
+        return lines.join('\n') + '\n';
+    }
+    static async create(options = {}) {
+        const server = new MockWhoisServer(options);
+        await server.start();
+        return server;
+    }
+}

package/dist/testing/mock.d.ts

@@ -55,4 +55,3 @@ export declare function installGlobalMock(options?: {
 }): MockAgent;
 export declare function uninstallGlobalMock(): void;
 export { MockAgent } from 'undici';
-//# sourceMappingURL=mock.d.ts.map

package/dist/transport/base-udp.d.ts

@@ -33,4 +33,3 @@ export declare abstract class BaseUDPTransport {
     protected sleep(ms: number): Promise<void>;
     close(): Promise<void>;
 }
-//# sourceMappingURL=base-udp.d.ts.map

package/dist/transport/fetch.d.ts

@@ -3,4 +3,3 @@ export declare class FetchTransport implements Transport {
     constructor();
     dispatch(req: ReckerRequest): Promise<ReckerResponse>;
 }
-//# sourceMappingURL=fetch.d.ts.map

package/dist/transport/udp-response.d.ts

@@ -62,4 +62,3 @@ export declare class StreamingUDPResponse implements UDPResponse {
     packets(): AsyncGenerator<Buffer>;
     [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
 }
-//# sourceMappingURL=udp-response.d.ts.map

package/dist/transport/udp.d.ts

@@ -20,4 +20,3 @@ export declare class UDPClient extends BaseUDPTransport {
 export declare function createUDP(options?: UDPTransportOptions): UDPClient;
 export declare const udp: SimpleUDPAPI;
 export { UDPClient as UDPTransport };
-//# sourceMappingURL=udp.d.ts.map

package/dist/transport/undici.d.ts

@@ -36,4 +36,3 @@ export declare class UndiciTransport implements Transport {
     private dispatchFast;
 }
 export {};
-//# sourceMappingURL=undici.d.ts.map

package/dist/transport/undici.js

@@ -23,7 +23,7 @@ undiciRequestChannel.subscribe((message) => {
 });
 undiciBodySentChannel.subscribe((message) => {
     const store = requestStorage.getStore();
-    if (store && store.hooks && store.hooks.onRequestSent) {
+    if (store?.hooks && store.hooks.onRequestSent) {
         store.hooks.onRequestSent();
     }
 });

package/dist/types/ai.d.ts

@@ -265,4 +265,3 @@ export interface Agent {
     run(prompt: string): Promise<AIResponse>;
     stream(prompt: string): AsyncIterable<AgentStreamEvent>;
 }
-//# sourceMappingURL=ai.d.ts.map

package/dist/types/index.d.ts

@@ -349,4 +349,3 @@ export interface ReckerResponse<T = unknown> {
     raw: Response;
     [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/types/logger.d.ts

@@ -14,4 +14,3 @@ export type MinimalLogger = Partial<Logger> & {
 export declare const consoleLogger: Logger;
 export declare const silentLogger: Logger;
 export declare function createLevelLogger(baseLogger: Logger, minLevel: 'debug' | 'info' | 'warn' | 'error'): Logger;
-//# sourceMappingURL=logger.d.ts.map

package/dist/types/udp.d.ts

@@ -136,4 +136,3 @@ export interface SimpleUDPAPI {
         timeout?: number;
     }): Promise<UDPDiscoveryResult[]>;
 }
-//# sourceMappingURL=udp.d.ts.map

package/dist/udp/index.d.ts

@@ -3,4 +3,3 @@ export { UDPResponseWrapper, StreamingUDPResponse } from '../transport/udp-respo
 export { BaseUDPTransport, udpRequestStorage } from '../transport/base-udp.js';
 export type { UDPRequestContext } from '../transport/base-udp.js';
 export type { UDPTimings, DTLSTimings, QUICTimings, UDPConnection, DTLSConnection, QUICConnection, BaseUDPTransportOptions, UDPTransportOptions, DTLSTransportOptions, QUICTransportOptions, UDPRequestOptions, UDPRequest, UDPResponse, UDPTransport as UDPTransportInterface, DTLSTransportInterface, QUICTransportInterface, UDPBatchResult, UDPDiscoveryResult, SimpleUDPAPI, } from '../types/udp.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/agent-manager.d.ts

@@ -27,4 +27,3 @@ export declare function analyzeBatchDomains(urls: string[]): {
     strategy: 'single' | 'multi';
     domains: Set<string>;
 };
-//# sourceMappingURL=agent-manager.d.ts.map

package/dist/utils/body.d.ts

@@ -8,4 +8,3 @@ export declare function processBody(body: BodyInput): ProcessedBody;
 export declare function createFormData(data: Record<string, any>): FormData;
 export declare function createMultipart(data: Record<string, any>): FormData;
 export declare function isFileUpload(body: any): boolean;
-//# sourceMappingURL=body.d.ts.map

package/dist/utils/cert.d.ts

@@ -9,4 +9,3 @@ export declare function createCertAgent(options: CertificateOptions): Agent;
 export declare function getCertInfo(response: any): {
     authorized: boolean;
 };
-//# sourceMappingURL=cert.d.ts.map

package/dist/utils/charset.d.ts

@@ -13,4 +13,3 @@ export declare function detectCharset(buffer: Uint8Array, contentType?: string |
 export declare function decodeText(buffer: Uint8Array, charsetOrInfo?: string | CharsetInfo): string;
 export declare function getSupportedEncodings(): string[];
 export declare function isCharsetSupported(charset: string): boolean;
-//# sourceMappingURL=charset.d.ts.map

package/dist/utils/chart.d.ts

@@ -12,4 +12,3 @@ declare const _default: {
     plotMultiple: typeof plotMultiple;
 };
 export default _default;
-//# sourceMappingURL=chart.d.ts.map