recker 1.0.20-next.963881c → 1.0.20-next.a5aea1e

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

@@ -0,0 +1,269 @@
+import { EventEmitter } from 'node:events';
+import * as dgram from 'node:dgram';
+const RECORD_TYPES = {
+    A: 1,
+    NS: 2,
+    CNAME: 5,
+    SOA: 6,
+    PTR: 12,
+    MX: 15,
+    TXT: 16,
+    AAAA: 28,
+    SRV: 33,
+};
+const RECORD_TYPE_NAMES = Object.fromEntries(Object.entries(RECORD_TYPES).map(([k, v]) => [v, k]));
+export class MockDnsServer extends EventEmitter {
+    options;
+    socket = null;
+    records = new Map();
+    started = false;
+    stats = {
+        queriesReceived: 0,
+        responseSent: 0,
+        queryLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 5353,
+            host: '127.0.0.1',
+            ttl: 300,
+            delay: 0,
+            ...options,
+        };
+        this.addDefaultRecords();
+    }
+    get isRunning() {
+        return this.started;
+    }
+    get port() {
+        return this.options.port;
+    }
+    get host() {
+        return this.options.host;
+    }
+    get statistics() {
+        return { ...this.stats };
+    }
+    addRecord(domain, type, value, ttl) {
+        const key = domain.toLowerCase();
+        const records = this.records.get(key) || [];
+        records.push({ type, value, ttl: ttl ?? this.options.ttl });
+        this.records.set(key, records);
+    }
+    removeRecords(domain) {
+        this.records.delete(domain.toLowerCase());
+    }
+    getRecords(domain) {
+        return this.records.get(domain.toLowerCase()) || [];
+    }
+    clearRecords() {
+        this.records.clear();
+        this.addDefaultRecords();
+    }
+    addDefaultRecords() {
+        this.addRecord('localhost', 'A', '127.0.0.1');
+        this.addRecord('localhost', 'AAAA', '::1');
+        this.addRecord('example.com', 'A', '93.184.216.34');
+        this.addRecord('example.com', 'AAAA', '2606:2800:220:1:248:1893:25c8:1946');
+        this.addRecord('example.com', 'NS', 'ns1.example.com');
+        this.addRecord('example.com', 'NS', 'ns2.example.com');
+        this.addRecord('example.com', 'MX', { priority: 10, exchange: 'mail.example.com' });
+        this.addRecord('example.com', 'TXT', 'v=spf1 include:_spf.example.com ~all');
+        this.addRecord('test.local', 'A', '192.168.1.100');
+        this.addRecord('api.test.local', 'A', '192.168.1.101');
+        this.addRecord('api.test.local', 'CNAME', 'test.local');
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('Server already started');
+        }
+        return new Promise((resolve, reject) => {
+            this.socket = dgram.createSocket('udp4');
+            this.socket.on('error', (err) => {
+                this.emit('error', err);
+                if (!this.started) {
+                    reject(err);
+                }
+            });
+            this.socket.on('message', (msg, rinfo) => {
+                this.handleQuery(msg, rinfo);
+            });
+            this.socket.bind(this.options.port, this.options.host, () => {
+                this.started = true;
+                this.emit('start');
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.started || !this.socket)
+            return;
+        return new Promise((resolve) => {
+            this.socket.close(() => {
+                this.socket = null;
+                this.started = false;
+                this.emit('stop');
+                resolve();
+            });
+        });
+    }
+    reset() {
+        this.stats = {
+            queriesReceived: 0,
+            responseSent: 0,
+            queryLog: [],
+        };
+        this.clearRecords();
+        this.emit('reset');
+    }
+    async handleQuery(msg, rinfo) {
+        this.stats.queriesReceived++;
+        if (this.options.delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+        try {
+            const query = this.parseDnsQuery(msg);
+            this.stats.queryLog.push({
+                domain: query.domain,
+                type: query.type,
+                timestamp: Date.now(),
+            });
+            this.emit('query', query, rinfo);
+            const response = this.buildResponse(msg, query);
+            this.socket?.send(response, rinfo.port, rinfo.address, (err) => {
+                if (err) {
+                    this.emit('error', err);
+                }
+                else {
+                    this.stats.responseSent++;
+                    this.emit('response', query);
+                }
+            });
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+    parseDnsQuery(msg) {
+        const id = msg.readUInt16BE(0);
+        let offset = 12;
+        const labels = [];
+        while (msg[offset] !== 0) {
+            const len = msg[offset];
+            offset++;
+            labels.push(msg.slice(offset, offset + len).toString('ascii'));
+            offset += len;
+        }
+        offset++;
+        const domain = labels.join('.');
+        const typeCode = msg.readUInt16BE(offset);
+        const type = RECORD_TYPE_NAMES[typeCode] || `TYPE${typeCode}`;
+        return { id, domain, type, typeCode };
+    }
+    buildResponse(query, parsed) {
+        const records = this.records.get(parsed.domain.toLowerCase()) || [];
+        const matchingRecords = records.filter((r) => r.type === parsed.type || parsed.type === 'ANY');
+        const header = Buffer.alloc(12);
+        header.writeUInt16BE(parsed.id, 0);
+        header.writeUInt16BE(0x8180, 2);
+        header.writeUInt16BE(1, 4);
+        header.writeUInt16BE(matchingRecords.length, 6);
+        header.writeUInt16BE(0, 8);
+        header.writeUInt16BE(0, 10);
+        const questionEnd = 12 + this.getDomainLength(query, 12) + 4;
+        const question = query.slice(12, questionEnd);
+        const answers = [];
+        for (const record of matchingRecords) {
+            answers.push(this.buildAnswerRecord(parsed.domain, record));
+        }
+        return Buffer.concat([header, question, ...answers]);
+    }
+    getDomainLength(buf, offset) {
+        let len = 0;
+        while (buf[offset + len] !== 0) {
+            len += buf[offset + len] + 1;
+        }
+        return len + 1;
+    }
+    buildAnswerRecord(domain, record) {
+        const parts = [];
+        parts.push(Buffer.from([0xc0, 0x0c]));
+        const typeCode = RECORD_TYPES[record.type] || 1;
+        const typeBuf = Buffer.alloc(2);
+        typeBuf.writeUInt16BE(typeCode, 0);
+        parts.push(typeBuf);
+        const classBuf = Buffer.alloc(2);
+        classBuf.writeUInt16BE(1, 0);
+        parts.push(classBuf);
+        const ttlBuf = Buffer.alloc(4);
+        ttlBuf.writeUInt32BE(record.ttl ?? this.options.ttl, 0);
+        parts.push(ttlBuf);
+        const rdata = this.encodeRdata(record);
+        const rdLengthBuf = Buffer.alloc(2);
+        rdLengthBuf.writeUInt16BE(rdata.length, 0);
+        parts.push(rdLengthBuf);
+        parts.push(rdata);
+        return Buffer.concat(parts);
+    }
+    encodeRdata(record) {
+        switch (record.type) {
+            case 'A': {
+                const parts = record.value.split('.').map(Number);
+                return Buffer.from(parts);
+            }
+            case 'AAAA': {
+                const ip = record.value;
+                const buf = Buffer.alloc(16);
+                const parts = ip.split(':');
+                for (let i = 0; i < 8; i++) {
+                    const val = parseInt(parts[i] || '0', 16);
+                    buf.writeUInt16BE(val, i * 2);
+                }
+                return buf;
+            }
+            case 'CNAME':
+            case 'NS':
+            case 'PTR': {
+                return this.encodeDomainName(record.value);
+            }
+            case 'MX': {
+                const mx = record.value;
+                const priority = Buffer.alloc(2);
+                priority.writeUInt16BE(mx.priority, 0);
+                return Buffer.concat([priority, this.encodeDomainName(mx.exchange)]);
+            }
+            case 'TXT': {
+                const txt = record.value;
+                const txtBuf = Buffer.from(txt, 'utf8');
+                const len = Buffer.from([txtBuf.length]);
+                return Buffer.concat([len, txtBuf]);
+            }
+            case 'SRV': {
+                const srv = record.value;
+                const buf = Buffer.alloc(6);
+                buf.writeUInt16BE(srv.priority, 0);
+                buf.writeUInt16BE(srv.weight, 2);
+                buf.writeUInt16BE(srv.port, 4);
+                return Buffer.concat([buf, this.encodeDomainName(srv.target)]);
+            }
+            default:
+                return Buffer.from(record.value, 'utf8');
+        }
+    }
+    encodeDomainName(domain) {
+        const parts = domain.split('.');
+        const buffers = [];
+        for (const part of parts) {
+            buffers.push(Buffer.from([part.length]));
+            buffers.push(Buffer.from(part, 'ascii'));
+        }
+        buffers.push(Buffer.from([0]));
+        return Buffer.concat(buffers);
+    }
+    static async create(options = {}) {
+        const server = new MockDnsServer(options);
+        await server.start();
+        return server;
+    }
+}

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

@@ -0,0 +1,89 @@
+import { EventEmitter } from 'node:events';
+import * as net from 'node:net';
+export interface MockFtpServerOptions {
+    port?: number;
+    host?: string;
+    anonymous?: boolean;
+    username?: string;
+    password?: string;
+    welcomeMessage?: string;
+    delay?: number;
+}
+export interface VirtualFile {
+    content: string | Buffer;
+    size: number;
+    modified: Date;
+    isDirectory: boolean;
+}
+export interface FtpSession {
+    id: string;
+    socket: net.Socket;
+    authenticated: boolean;
+    username: string | null;
+    currentDir: string;
+    transferMode: 'ASCII' | 'BINARY';
+    passiveSocket: net.Server | null;
+    connectedAt: Date;
+}
+export interface MockFtpStats {
+    connectionsTotal: number;
+    commandsReceived: number;
+    filesDownloaded: number;
+    filesUploaded: number;
+    bytesTransferred: number;
+    commandLog: Array<{
+        command: string;
+        sessionId: string;
+        timestamp: number;
+    }>;
+}
+export declare class MockFtpServer extends EventEmitter {
+    private options;
+    private server;
+    private sessions;
+    private files;
+    private started;
+    private sessionCounter;
+    private dataPortCounter;
+    private stats;
+    constructor(options?: MockFtpServerOptions);
+    get isRunning(): boolean;
+    get port(): number;
+    get host(): string;
+    get url(): string;
+    get statistics(): MockFtpStats;
+    addFile(path: string, content: string | Buffer): void;
+    addDirectory(path: string): void;
+    removeFile(path: string): boolean;
+    getFile(path: string): VirtualFile | undefined;
+    listDirectory(path: string): string[];
+    clearFiles(): void;
+    private normalizePath;
+    private addDefaultFiles;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reset(): void;
+    private handleConnection;
+    private handleCommand;
+    private handleUser;
+    private handlePass;
+    private handleCwd;
+    private handleCdup;
+    private handleType;
+    private handlePasv;
+    private handleList;
+    private handleNlst;
+    private handleRetr;
+    private handleStor;
+    private handleSize;
+    private handleMdtm;
+    private handleMkd;
+    private handleRmd;
+    private handleDele;
+    private requireAuth;
+    private resolvePath;
+    private sendResponse;
+    private sendMultilineResponse;
+    private waitForDataConnection;
+    static create(options?: MockFtpServerOptions): Promise<MockFtpServer>;
+}