packet-events-js 1.0.0

package/src/events/EventEmitter.js

@@ -0,0 +1,267 @@
+export const EventPriority = Object.freeze({
+    LOWEST: 0,
+    LOW: 1,
+    NORMAL: 2,
+    HIGH: 3,
+    HIGHEST: 4,
+    MONITOR: 5 
+});
+
+export class CancellableEvent {
+    constructor() {
+        this._cancelled = false;
+    }
+
+    get cancelled() {
+        return this._cancelled;
+    }
+
+    cancel() {
+        this._cancelled = true;
+    }
+
+    setCancelled(cancelled) {
+        this._cancelled = cancelled;
+    }
+}
+
+export class PacketEvent extends CancellableEvent {
+    
+    constructor(packet, user) {
+        super();
+        this.packet = packet;
+        this.user = user;
+        this._timestamp = Date.now();
+    }
+
+    get timestamp() {
+        return this._timestamp;
+    }
+
+    withPacket(newPacket) {
+        const event = new PacketEvent(newPacket, this.user);
+        event._cancelled = this._cancelled;
+        return event;
+    }
+}
+
+class EventListener {
+    constructor(callback, priority, once = false) {
+        this.callback = callback;
+        this.priority = priority;
+        this.once = once;
+        this.removed = false;
+    }
+}
+
+export class EventEmitter {
+    constructor() {
+        
+        this._listeners = new Map();
+
+        this._wildcardListeners = new Map();
+
+        this._maxListeners = 100;
+    }
+
+    setMaxListeners(n) {
+        this._maxListeners = n;
+        return this;
+    }
+
+    on(event, callback, options = {}) {
+        const { priority = EventPriority.NORMAL, once = false } = options;
+
+        if (!this._listeners.has(event)) {
+            this._listeners.set(event, []);
+        }
+
+        const listeners = this._listeners.get(event);
+
+        if (listeners.length >= this._maxListeners) {
+            console.warn(`MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ` +
+                `${listeners.length} ${event} listeners added.`);
+        }
+
+        const listener = new EventListener(callback, priority, once);
+        listeners.push(listener);
+
+        listeners.sort((a, b) => b.priority - a.priority);
+
+        return this;
+    }
+
+    once(event, callback, options = {}) {
+        return this.on(event, callback, { ...options, once: true });
+    }
+
+    off(event, callback) {
+        if (!this._listeners.has(event)) return this;
+
+        const listeners = this._listeners.get(event);
+        const index = listeners.findIndex(l => l.callback === callback);
+
+        if (index !== -1) {
+            listeners[index].removed = true;
+            listeners.splice(index, 1);
+        }
+
+        return this;
+    }
+
+    removeListener(event, callback) {
+        return this.off(event, callback);
+    }
+
+    removeAllListeners(event) {
+        if (event) {
+            this._listeners.delete(event);
+        } else {
+            this._listeners.clear();
+        }
+        return this;
+    }
+
+    emit(event, ...args) {
+        if (!this._listeners.has(event)) return false;
+
+        const listeners = this._listeners.get(event);
+        const toRemove = [];
+
+        for (const listener of listeners) {
+            if (listener.removed) continue;
+
+            try {
+                listener.callback(...args);
+            } catch (error) {
+                this._handleError(error, event);
+            }
+
+            if (listener.once) {
+                toRemove.push(listener);
+            }
+
+            if (args[0] instanceof CancellableEvent && 
+                args[0].cancelled && 
+                listener.priority !== EventPriority.MONITOR) {
+                break;
+            }
+        }
+
+        for (const listener of toRemove) {
+            const index = listeners.indexOf(listener);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+        }
+
+        return listeners.length > 0;
+    }
+
+    async emitAsync(event, ...args) {
+        if (!this._listeners.has(event)) return false;
+
+        const listeners = [...this._listeners.get(event)];
+        const toRemove = [];
+
+        for (const listener of listeners) {
+            if (listener.removed) continue;
+
+            try {
+                await listener.callback(...args);
+            } catch (error) {
+                this._handleError(error, event);
+            }
+
+            if (listener.once) {
+                toRemove.push(listener);
+            }
+
+            if (args[0] instanceof CancellableEvent && 
+                args[0].cancelled && 
+                listener.priority !== EventPriority.MONITOR) {
+                break;
+            }
+        }
+
+        const currentListeners = this._listeners.get(event);
+        if (currentListeners) {
+            for (const listener of toRemove) {
+                const index = currentListeners.indexOf(listener);
+                if (index !== -1) {
+                    currentListeners.splice(index, 1);
+                }
+            }
+        }
+
+        return listeners.length > 0;
+    }
+
+    listenerCount(event) {
+        return this._listeners.get(event)?.length || 0;
+    }
+
+    eventNames() {
+        return Array.from(this._listeners.keys());
+    }
+
+    listeners(event) {
+        return (this._listeners.get(event) || []).map(l => l.callback);
+    }
+
+    waitFor(event, timeout) {
+        return new Promise((resolve, reject) => {
+            const handler = (...args) => {
+                if (timeoutId) clearTimeout(timeoutId);
+                resolve(args.length === 1 ? args[0] : args);
+            };
+
+            let timeoutId;
+            if (timeout) {
+                timeoutId = setTimeout(() => {
+                    this.off(event, handler);
+                    reject(new Error(`Timeout waiting for event: ${event}`));
+                }, timeout);
+            }
+
+            this.once(event, handler);
+        });
+    }
+
+    pipe(target, events) {
+        const handlers = new Map();
+
+        for (const event of events) {
+            const handler = (...args) => target.emit(event, ...args);
+            handlers.set(event, handler);
+            this.on(event, handler);
+        }
+
+        return () => {
+            for (const [event, handler] of handlers) {
+                this.off(event, handler);
+            }
+        };
+    }
+
+    _handleError(error, event) {
+        if (this._listeners.has('error')) {
+            this.emit('error', error, event);
+        } else {
+            console.error(`Error in event listener for "${event}":`, error);
+        }
+    }
+}
+
+export class TypedEventEmitter extends EventEmitter {
+    
+    on(event, callback, options) {
+        return super.on(event, callback, options);
+    }
+
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+}
+
+export default EventEmitter;

package/src/events/PacketEvent.js

@@ -0,0 +1,78 @@
+import { CancellableEvent } from './EventEmitter.js';
+
+export class BasePacketEvent extends CancellableEvent {
+    
+    constructor(connection, packet) {
+        super();
+        this.connection = connection;
+        this.packet = packet;
+        this._timestamp = Date.now();
+        this._lastUsedPacket = packet;
+    }
+
+    get timestamp() {
+        return this._timestamp;
+    }
+
+    get user() {
+        return this.connection?.user || null;
+    }
+
+    get packetId() {
+        return this.packet?.packetId ?? -1;
+    }
+
+    get packetName() {
+        return this.packet?.packetName ?? 'Unknown';
+    }
+
+    markDirty() {
+        this._lastUsedPacket = this.packet;
+    }
+
+    get lastUsedPacket() {
+        return this._lastUsedPacket;
+    }
+}
+
+export class PacketReceiveEvent extends BasePacketEvent {
+    constructor(connection, packet) {
+        super(connection, packet);
+        this.direction = 'SERVERBOUND';
+    }
+
+    getPacket(packetClass) {
+        if (this.packet instanceof packetClass) {
+            return this.packet;
+        }
+        return null;
+    }
+}
+
+export class PacketSendEvent extends BasePacketEvent {
+    constructor(connection, packet) {
+        super(connection, packet);
+        this.direction = 'CLIENTBOUND';
+    }
+
+    getPacket(packetClass) {
+        if (this.packet instanceof packetClass) {
+            return this.packet;
+        }
+        return null;
+    }
+}
+
+export const PacketEventType = Object.freeze({
+    RECEIVE: 'packet_receive',
+    SEND: 'packet_send',
+    PRE_PROCESS: 'packet_pre_process',
+    POST_PROCESS: 'packet_post_process'
+});
+
+export default {
+    BasePacketEvent,
+    PacketReceiveEvent,
+    PacketSendEvent,
+    PacketEventType
+};

package/src/index.js

@@ -0,0 +1,18 @@
+export { MinecraftClient } from './client/MinecraftClient.js';
+export { PacketManager } from './manager/PacketManager.js';
+export { EventEmitter, EventPriority } from './events/EventEmitter.js';
+export { PacketReceiveEvent, PacketSendEvent } from './events/PacketEvent.js';
+export { ProtocolVersion } from './protocol/ProtocolVersion.js';
+export { ConnectionState } from './protocol/ConnectionState.js';
+export { PacketDirection } from './protocol/PacketDirection.js';
+
+export * from './protocol/types/index.js';
+
+export * from './protocol/packets/index.js';
+
+export { PacketBuffer } from './utils/PacketBuffer.js';
+export { Logger, LogLevel } from './utils/Logger.js';
+
+export { MinecraftEncryption, EncryptedConnection } from './crypto/Encryption.js';
+export { MojangAPI } from './auth/MojangAPI.js';
+export { AuthHandler, ClientAuthHandler, AuthMode } from './auth/AuthHandler.js';

package/src/manager/PacketManager.js

@@ -0,0 +1,258 @@
+import { createInflate, createDeflate } from 'zlib';
+import { promisify } from 'util';
+import { PacketBuffer } from '../utils/PacketBuffer.js';
+import { PacketRegistry, defaultRegistry } from '../protocol/packets/PacketRegistry.js';
+import { ConnectionState } from '../protocol/ConnectionState.js';
+import { PacketDirection } from '../protocol/PacketDirection.js';
+import { EventEmitter, EventPriority } from '../events/EventEmitter.js';
+import { PacketReceiveEvent, PacketSendEvent } from '../events/PacketEvent.js';
+import { Logger } from '../utils/Logger.js';
+import { encodeVarInt, decodeVarInt, getVarIntSize } from '../protocol/types/VarInt.js';
+
+const logger = Logger.getLogger('PacketManager');
+
+export class PacketManager extends EventEmitter {
+    
+    constructor(options = {}) {
+        super();
+
+        this.registry = options.registry || defaultRegistry;
+        this.state = ConnectionState.HANDSHAKING;
+        this.compressionThreshold = -1; 
+        this.encryptionEnabled = false;
+
+        this._cipher = null;
+        this._decipher = null;
+
+        this._receiveBuffer = Buffer.alloc(0);
+    }
+
+    setState(state) {
+        const oldState = this.state;
+        this.state = state;
+        logger.debug(`State changed: ${oldState.name} -> ${state.name}`);
+        this.emit('stateChange', { oldState, newState: state });
+    }
+
+    setCompression(threshold) {
+        this.compressionThreshold = threshold;
+        logger.debug(`Compression enabled with threshold: ${threshold}`);
+    }
+
+    setEncryption(cipher, decipher) {
+        this._cipher = cipher;
+        this._decipher = decipher;
+        this.encryptionEnabled = true;
+        logger.debug('Encryption enabled');
+    }
+
+    encrypt(data) {
+        if (!this.encryptionEnabled || !this._cipher) {
+            return data;
+        }
+        return this._cipher.update(data);
+    }
+
+    decrypt(data) {
+        if (!this.encryptionEnabled || !this._decipher) {
+            return data;
+        }
+        return this._decipher.update(data);
+    }
+
+    async compress(data) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            const deflate = createDeflate();
+            
+            deflate.on('data', chunk => chunks.push(chunk));
+            deflate.on('end', () => resolve(Buffer.concat(chunks)));
+            deflate.on('error', reject);
+            
+            deflate.end(data);
+        });
+    }
+
+    async decompress(data) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            const inflate = createInflate();
+            
+            inflate.on('data', chunk => chunks.push(chunk));
+            inflate.on('end', () => resolve(Buffer.concat(chunks)));
+            inflate.on('error', reject);
+            
+            inflate.end(data);
+        });
+    }
+
+    async encodePacket(packet, context = {}) {
+        
+        const packetData = packet.encode(context);
+
+        if (this.compressionThreshold >= 0) {
+            if (packetData.length >= this.compressionThreshold) {
+                
+                const compressed = await this.compress(packetData);
+
+                const dataLengthVarInt = encodeVarInt(packetData.length);
+                const totalLength = dataLengthVarInt.length + compressed.length;
+                const lengthVarInt = encodeVarInt(totalLength);
+                
+                return Buffer.concat([lengthVarInt, dataLengthVarInt, compressed]);
+            } else {
+                
+                const dataLengthVarInt = encodeVarInt(0); 
+                const totalLength = dataLengthVarInt.length + packetData.length;
+                const lengthVarInt = encodeVarInt(totalLength);
+                
+                return Buffer.concat([lengthVarInt, dataLengthVarInt, packetData]);
+            }
+        } else {
+            
+            const lengthVarInt = encodeVarInt(packetData.length);
+            return Buffer.concat([lengthVarInt, packetData]);
+        }
+    }
+
+    addReceivedData(data) {
+        
+        const decrypted = this.decrypt(data);
+
+        this._receiveBuffer = Buffer.concat([this._receiveBuffer, decrypted]);
+    }
+
+    async readPackets(direction = PacketDirection.SERVERBOUND, context = {}) {
+        const packets = [];
+        
+        while (this._receiveBuffer.length > 0) {
+            try {
+                
+                const { value: packetLength, bytesRead: lengthBytes } = 
+                    decodeVarInt(this._receiveBuffer, 0);
+
+                if (this._receiveBuffer.length < lengthBytes + packetLength) {
+                    break; 
+                }
+
+                let packetData = this._receiveBuffer.subarray(
+                    lengthBytes, 
+                    lengthBytes + packetLength
+                );
+
+                if (this.compressionThreshold >= 0) {
+                    const { value: dataLength, bytesRead: dataLengthBytes } = 
+                        decodeVarInt(packetData, 0);
+                    
+                    if (dataLength > 0) {
+                        
+                        packetData = await this.decompress(
+                            packetData.subarray(dataLengthBytes)
+                        );
+                    } else {
+                        
+                        packetData = packetData.subarray(dataLengthBytes);
+                    }
+                }
+
+                const { value: packetId, bytesRead: idBytes } = 
+                    decodeVarInt(packetData, 0);
+
+                const payloadData = packetData.subarray(idBytes);
+
+                const packet = this.registry.createPacket(
+                    this.state,
+                    direction,
+                    packetId,
+                    payloadData,
+                    context
+                );
+                
+                if (packet) {
+                    packets.push(packet);
+
+                    const event = new PacketReceiveEvent(context.connection, packet);
+                    await this.emitAsync('packet', event);
+                    await this.emitAsync(`packet:${packet.packetName}`, event);
+                } else {
+                    
+                    logger.trace(
+                        `Unknown packet: 0x${packetId.toString(16)} in state ${this.state.name}`
+                    );
+
+                    this.emit('unknownPacket', {
+                        state: this.state,
+                        direction,
+                        packetId,
+                        data: payloadData
+                    });
+                }
+
+                this._receiveBuffer = this._receiveBuffer.subarray(lengthBytes + packetLength);
+                
+            } catch (error) {
+                if (error.message.includes('underflow')) {
+                    break; 
+                }
+                throw error;
+            }
+        }
+        
+        return packets;
+    }
+
+    async sendPacket(packet, writeFn, context = {}) {
+        
+        const event = new PacketSendEvent(context.connection, packet);
+        await this.emitAsync('packetSend', event);
+        await this.emitAsync(`packetSend:${packet.packetName}`, event);
+        
+        if (event.cancelled) {
+            logger.trace(`Packet cancelled: ${packet.packetName}`);
+            return false;
+        }
+
+        let data = await this.encodePacket(event.packet, context);
+
+        data = this.encrypt(data);
+
+        await writeFn(data);
+        
+        logger.trace(`Sent packet: ${packet.packetName}`);
+        return true;
+    }
+
+    onPacket(packetClass, callback, options = {}) {
+        const packetName = packetClass.packetName || packetClass.name;
+        
+        this.on(`packet:${packetName}`, (event) => {
+            if (event.packet instanceof packetClass) {
+                callback(event);
+            }
+        }, options);
+        
+        return this;
+    }
+
+    onPacketSend(packetClass, callback, options = {}) {
+        const packetName = packetClass.packetName || packetClass.name;
+        
+        this.on(`packetSend:${packetName}`, (event) => {
+            if (event.packet instanceof packetClass) {
+                callback(event);
+            }
+        }, options);
+        
+        return this;
+    }
+
+    clearBuffer() {
+        this._receiveBuffer = Buffer.alloc(0);
+    }
+
+    get bufferSize() {
+        return this._receiveBuffer.length;
+    }
+}
+
+export default PacketManager;

package/src/protocol/ConnectionState.js

@@ -0,0 +1,37 @@
+export const ConnectionState = Object.freeze({
+    
+    HANDSHAKING: {
+        id: -1,
+        name: 'HANDSHAKING'
+    },
+
+    STATUS: {
+        id: 1,
+        name: 'STATUS'
+    },
+
+    LOGIN: {
+        id: 2,
+        name: 'LOGIN'
+    },
+
+    CONFIGURATION: {
+        id: 3,
+        name: 'CONFIGURATION'
+    },
+
+    PLAY: {
+        id: 4,
+        name: 'PLAY'
+    }
+});
+
+export function getStateById(id) {
+    return Object.values(ConnectionState).find(state => state.id === id);
+}
+
+export function getStateByName(name) {
+    return ConnectionState[name.toUpperCase()];
+}
+
+export default ConnectionState;

package/src/protocol/PacketDirection.js

@@ -0,0 +1,8 @@
+export const PacketDirection = Object.freeze({
+    
+    SERVERBOUND: 'SERVERBOUND',
+
+    CLIENTBOUND: 'CLIENTBOUND'
+});
+
+export default PacketDirection;