packet-events-js 1.0.0 → 1.0.1

package/src/advanced/PacketRecorder.js

@@ -0,0 +1,336 @@
+import { EventEmitter } from '../events/EventEmitter.js';
+import { PacketBuffer } from '../utils/PacketBuffer.js';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { gzipSync, gunzipSync } from 'zlib';
+
+const RECORDING_VERSION = 1;
+
+export class PacketRecord {
+    constructor(options = {}) {
+        this.timestamp = options.timestamp || Date.now();
+        this.direction = options.direction || 'CLIENTBOUND';
+        this.state = options.state || 'PLAY';
+        this.packetId = options.packetId || 0;
+        this.packetName = options.packetName || 'Unknown';
+        this.data = options.data || Buffer.alloc(0);
+        this.size = options.size || this.data.length;
+        this.metadata = options.metadata || {};
+    }
+
+    toJSON() {
+        return {
+            timestamp: this.timestamp,
+            direction: this.direction,
+            state: this.state,
+            packetId: this.packetId,
+            packetName: this.packetName,
+            data: this.data.toString('base64'),
+            size: this.size,
+            metadata: this.metadata
+        };
+    }
+
+    static fromJSON(json) {
+        return new PacketRecord({
+            ...json,
+            data: Buffer.from(json.data, 'base64')
+        });
+    }
+}
+
+export class PacketRecorder extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.records = [];
+        this.isRecording = false;
+        this.isPaused = false;
+        this.startTime = null;
+        this.maxRecords = options.maxRecords || 100000;
+        this.filters = options.filters || {};
+        this.compression = options.compression !== false;
+        
+        this.stats = {
+            totalPackets: 0,
+            totalBytes: 0,
+            packetsByType: new Map(),
+            packetsByDirection: { CLIENTBOUND: 0, SERVERBOUND: 0 },
+            startTime: null,
+            endTime: null
+        };
+    }
+
+    start() {
+        if (this.isRecording) return this;
+        
+        this.isRecording = true;
+        this.isPaused = false;
+        this.startTime = Date.now();
+        this.stats.startTime = this.startTime;
+        
+        this.emit('start', { timestamp: this.startTime });
+        return this;
+    }
+
+    stop() {
+        if (!this.isRecording) return this;
+        
+        this.isRecording = false;
+        this.stats.endTime = Date.now();
+        
+        this.emit('stop', { 
+            timestamp: this.stats.endTime,
+            duration: this.stats.endTime - this.stats.startTime,
+            totalPackets: this.stats.totalPackets
+        });
+        return this;
+    }
+
+    pause() {
+        this.isPaused = true;
+        this.emit('pause');
+        return this;
+    }
+
+    resume() {
+        this.isPaused = false;
+        this.emit('resume');
+        return this;
+    }
+
+    record(packet, direction, state, rawData) {
+        if (!this.isRecording || this.isPaused) return this;
+        if (this.records.length >= this.maxRecords) return this;
+
+        if (this.filters.directions && !this.filters.directions.includes(direction)) return this;
+        if (this.filters.states && !this.filters.states.includes(state)) return this;
+        if (this.filters.packetIds && !this.filters.packetIds.includes(packet.constructor.packetId)) return this;
+        if (this.filters.packetNames && !this.filters.packetNames.includes(packet.constructor.packetName)) return this;
+
+        const record = new PacketRecord({
+            timestamp: Date.now(),
+            direction,
+            state: typeof state === 'object' ? state.name : state,
+            packetId: packet.constructor.packetId,
+            packetName: packet.constructor.packetName,
+            data: rawData,
+            size: rawData.length,
+            metadata: {
+                relativeTime: Date.now() - this.startTime
+            }
+        });
+
+        this.records.push(record);
+        
+        this.stats.totalPackets++;
+        this.stats.totalBytes += rawData.length;
+        this.stats.packetsByDirection[direction]++;
+        
+        const typeName = packet.constructor.packetName;
+        this.stats.packetsByType.set(typeName, (this.stats.packetsByType.get(typeName) || 0) + 1);
+
+        this.emit('record', record);
+        return this;
+    }
+
+    clear() {
+        this.records = [];
+        this.stats = {
+            totalPackets: 0,
+            totalBytes: 0,
+            packetsByType: new Map(),
+            packetsByDirection: { CLIENTBOUND: 0, SERVERBOUND: 0 },
+            startTime: null,
+            endTime: null
+        };
+        this.emit('clear');
+        return this;
+    }
+
+    exportToFile(filePath) {
+        const data = {
+            version: RECORDING_VERSION,
+            exportTime: Date.now(),
+            stats: {
+                ...this.stats,
+                packetsByType: Object.fromEntries(this.stats.packetsByType)
+            },
+            records: this.records.map(r => r.toJSON())
+        };
+
+        const json = JSON.stringify(data);
+        const buffer = this.compression ? gzipSync(json) : Buffer.from(json);
+        
+        writeFileSync(filePath, buffer);
+        this.emit('export', { filePath, size: buffer.length });
+        return this;
+    }
+
+    importFromFile(filePath) {
+        if (!existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+
+        let buffer = readFileSync(filePath);
+        
+        try {
+            buffer = gunzipSync(buffer);
+        } catch (e) {
+        }
+
+        const data = JSON.parse(buffer.toString());
+        
+        if (data.version !== RECORDING_VERSION) {
+            console.warn(`Recording version mismatch: ${data.version} vs ${RECORDING_VERSION}`);
+        }
+
+        this.records = data.records.map(r => PacketRecord.fromJSON(r));
+        this.stats = {
+            ...data.stats,
+            packetsByType: new Map(Object.entries(data.stats.packetsByType || {}))
+        };
+
+        this.emit('import', { filePath, records: this.records.length });
+        return this;
+    }
+
+    getStats() {
+        return {
+            ...this.stats,
+            packetsByType: Object.fromEntries(this.stats.packetsByType),
+            duration: this.stats.endTime ? this.stats.endTime - this.stats.startTime : Date.now() - this.stats.startTime,
+            recordCount: this.records.length,
+            avgPacketSize: this.stats.totalPackets > 0 ? Math.round(this.stats.totalBytes / this.stats.totalPackets) : 0,
+            packetsPerSecond: this.stats.totalPackets > 0 ? 
+                (this.stats.totalPackets / ((this.stats.endTime || Date.now()) - this.stats.startTime) * 1000).toFixed(2) : 0
+        };
+    }
+
+    filter(predicate) {
+        return this.records.filter(predicate);
+    }
+
+    findByName(name) {
+        return this.records.filter(r => r.packetName === name);
+    }
+
+    findByDirection(direction) {
+        return this.records.filter(r => r.direction === direction);
+    }
+
+    getInTimeRange(startMs, endMs) {
+        const baseTime = this.stats.startTime || 0;
+        return this.records.filter(r => {
+            const relTime = r.timestamp - baseTime;
+            return relTime >= startMs && relTime <= endMs;
+        });
+    }
+}
+
+export class PacketReplayer extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.records = options.records || [];
+        this.speed = options.speed || 1.0;
+        this.isPlaying = false;
+        this.isPaused = false;
+        this.currentIndex = 0;
+        this.startTime = null;
+        this.timeouts = [];
+    }
+
+    loadFromRecorder(recorder) {
+        this.records = [...recorder.records];
+        this.currentIndex = 0;
+        return this;
+    }
+
+    async play(callback) {
+        if (this.isPlaying) return;
+        if (this.records.length === 0) return;
+
+        this.isPlaying = true;
+        this.isPaused = false;
+        this.startTime = Date.now();
+        this.currentIndex = 0;
+
+        this.emit('play', { totalRecords: this.records.length });
+
+        const baseTime = this.records[0].timestamp;
+
+        for (let i = 0; i < this.records.length; i++) {
+            if (!this.isPlaying) break;
+            
+            while (this.isPaused) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+                if (!this.isPlaying) break;
+            }
+
+            const record = this.records[i];
+            const nextRecord = this.records[i + 1];
+            
+            this.currentIndex = i;
+            this.emit('packet', record);
+            
+            if (callback) {
+                await callback(record);
+            }
+
+            if (nextRecord) {
+                const delay = (nextRecord.timestamp - record.timestamp) / this.speed;
+                if (delay > 0) {
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+
+        this.isPlaying = false;
+        this.emit('end', { 
+            played: this.currentIndex + 1,
+            duration: Date.now() - this.startTime 
+        });
+    }
+
+    stop() {
+        this.isPlaying = false;
+        this.isPaused = false;
+        this.emit('stop');
+        return this;
+    }
+
+    pause() {
+        this.isPaused = true;
+        this.emit('pause');
+        return this;
+    }
+
+    resume() {
+        this.isPaused = false;
+        this.emit('resume');
+        return this;
+    }
+
+    setSpeed(speed) {
+        this.speed = Math.max(0.1, Math.min(10, speed));
+        return this;
+    }
+
+    seek(index) {
+        this.currentIndex = Math.max(0, Math.min(index, this.records.length - 1));
+        return this;
+    }
+
+    getProgress() {
+        return {
+            current: this.currentIndex,
+            total: this.records.length,
+            percentage: this.records.length > 0 ? (this.currentIndex / this.records.length * 100).toFixed(1) : 0,
+            isPlaying: this.isPlaying,
+            isPaused: this.isPaused,
+            speed: this.speed
+        };
+    }
+}
+
+export default { PacketRecorder, PacketReplayer, PacketRecord };