packet-events-js 1.0.0 → 1.0.1

package/README.md

@@ -12,9 +12,15 @@ A robust protocol library for **Minecraft Java Edition** written entirely in **p
 - **Encryption** - Complete AES-128-CFB8 encryption support for online mode
 - **Online Mode** - Full Mojang/Microsoft authentication support
 - **Offline Mode** - Offline player UUID generation (version 3)
+- **BungeeCord Forwarding** - Legacy IP forwarding support
+- **Velocity Forwarding** - Modern forwarding with HMAC verification
 - **Complete NBT** - Named Binary Tag read/write
 - **Chat Components** - JSON Text Component with colors, formatting, and events
 - **Multi-version** - Support for Minecraft 1.7.2 to 1.21.11 (66 versions)
+- **Packet Recorder** - Record, export, import, and replay packet streams
+- **Protocol Analyzer** - Deep packet inspection, metrics, and traffic analysis
+- **Middleware System** - Plugin-based packet processing pipeline
+- **Connection Manager** - AutoReconnect, HealthMonitor, ConnectionPool, CircuitBreaker
 
 ## Requirements
 
@@ -55,8 +61,14 @@ console.log(`Latency: ${status.latency}ms`);
 ### Connect to Server (Offline Mode)
 
 ```javascript
-import { MinecraftClient, ProtocolVersion, Logger, LogLevel } from 'packet-events-js';
-import { KeepAliveClientboundPacket, KeepAliveServerboundPacket } from 'packet-events-js/protocol/packets';
+import { 
+    MinecraftClient, 
+    ProtocolVersion, 
+    Logger, 
+    LogLevel,
+    KeepAliveClientboundPacket, 
+    KeepAliveServerboundPacket 
+} from 'packet-events-js';
 
 Logger.setGlobalLevel(LogLevel.DEBUG);
 
@@ -81,7 +93,7 @@ console.log(`Connected as ${client.playerName}`);
 ### Encryption API
 
 ```javascript
-import { MinecraftEncryption, EncryptedConnection } from 'packet-events-js/crypto/Encryption';
+import { MinecraftEncryption, EncryptedConnection } from 'packet-events-js';
 
 const keyPair = MinecraftEncryption.generateKeyPair();
 console.log('Public Key:', keyPair.publicKey);
@@ -102,7 +114,7 @@ const serverHash = MinecraftEncryption.computeServerIdHash('', sharedSecret, key
 ### Auth Handler
 
 ```javascript
-import { AuthHandler, ClientAuthHandler, AuthMode } from 'packet-events-js/auth/AuthHandler';
+import { AuthHandler, ClientAuthHandler, AuthMode } from 'packet-events-js';
 
 const serverAuth = new AuthHandler({ mode: AuthMode.ONLINE });
 serverAuth.initialize();
@@ -118,10 +130,57 @@ const clientAuth = new ClientAuthHandler({
 });
 ```
 
+### BungeeCord Forwarding
+
+```javascript
+import { BungeeCordForwarding, UUID } from 'packet-events-js';
+
+const uuid = UUID.randomUUID();
+const handshakeAddress = BungeeCordForwarding.create(
+    'play.example.com',
+    '192.168.1.100',
+    uuid,
+    [{ name: 'textures', value: '...' }]
+);
+
+const result = BungeeCordForwarding.parse(handshakeAddress);
+if (result.success) {
+    console.log(`Client IP: ${result.clientIP}`);
+    console.log(`UUID: ${result.uuid.toString()}`);
+}
+```
+
+### Velocity Modern Forwarding
+
+```javascript
+import { VelocityForwarding, AuthHandler, AuthMode, UUID } from 'packet-events-js';
+
+const auth = new AuthHandler({ 
+    mode: AuthMode.VELOCITY, 
+    velocitySecret: 'your-secret-key' 
+});
+
+const result = auth.handleVelocityForwarding(forwardingData);
+if (result.success) {
+    console.log(`Player: ${result.username}`);
+    console.log(`UUID: ${result.uuid.toString()}`);
+    console.log(`IP: ${result.clientIP}`);
+}
+
+const uuid = UUID.randomUUID();
+const data = VelocityForwarding.create(
+    'your-secret-key',
+    '10.0.0.1',
+    uuid,
+    'PlayerName',
+    [{ name: 'textures', value: '...', signature: '...' }]
+);
+```
+
 ### Intercept Packets
 
 ```javascript
-import { EventPriority } from 'packet-events-js/events/EventEmitter';
+import { EventPriority } from 'packet-events-js';
 
 client.packetManager.on('packetSend', (event) => {
     if (event.packet.packetName === 'SetPlayerPosition') {
@@ -137,10 +196,12 @@ client.packetManager.on('packetSend', (event) => {
 ### Create Custom Packets
 
 ```javascript
-import { Packet } from 'packet-events-js/protocol/packets/Packet';
-import { defaultRegistry } from 'packet-events-js/protocol/packets/PacketRegistry';
-import { ConnectionState } from 'packet-events-js/protocol/ConnectionState';
-import { PacketDirection } from 'packet-events-js/protocol/PacketDirection';
+import { 
+    Packet, 
+    defaultRegistry, 
+    ConnectionState, 
+    PacketDirection 
+} from 'packet-events-js';
 
 class MyCustomPacket extends Packet {
     static get packetId() { return 0x50; }
@@ -168,6 +229,263 @@ defaultRegistry.register({
 });
 ```
 
+## Advanced Features
+
+### Packet Recorder
+
+Record, export, import, and replay complete packet streams:
+
+```javascript
+import { PacketRecorder, PacketReplayer, PacketRecord } from 'packet-events-js';
+
+const recorder = new PacketRecorder({
+    includeRaw: true,
+    maxRecords: 10000,
+    filter: (packet) => true
+});
+
+recorder.start();
+
+client.packetManager.on('packetReceive', (event) => {
+    recorder.record(event.packet, 'CLIENTBOUND', 'PLAY', event.rawData);
+});
+
+const stats = recorder.getStats();
+console.log(`Recorded: ${stats.totalPackets} packets, ${stats.totalBytes} bytes`);
+console.log(`Duration: ${stats.duration}ms`);
+console.log(`Packets by type:`, stats.packetsByType);
+
+const exported = recorder.export();
+const json = JSON.stringify(exported, null, 2);
+
+const imported = recorder.import(JSON.parse(json));
+
+const replayer = new PacketReplayer(recorder.records, {
+    speed: 1.0,
+    loop: false,
+    onPacket: (record) => {
+        console.log(`Replaying: ${record.packetName}`);
+    }
+});
+
+await replayer.start();
+replayer.pause();
+replayer.resume();
+replayer.stop();
+```
+
+### Protocol Analyzer
+
+Deep protocol analysis with metrics and traffic visualization:
+
+```javascript
+import { ProtocolAnalyzer, ProtocolMetrics, PacketInspector } from 'packet-events-js';
+
+const analyzer = new ProtocolAnalyzer({
+    trackHistory: true,
+    historySize: 1000,
+    alertThresholds: {
+        latency: 500,
+        packetLoss: 0.1,
+        throughputMin: 1000
+    }
+});
+
+analyzer.on('alert', (alert) => {
+    console.log(`Alert: ${alert.type} - ${alert.message}`);
+});
+
+analyzer.start();
+
+client.packetManager.on('packetReceive', (event) => {
+    analyzer.analyzePacket(event.packet, 'CLIENTBOUND', 'PLAY', event.rawData);
+});
+
+analyzer.recordLatency(50);
+
+const report = analyzer.getReport();
+console.log(`Packets: ${report.packets.total}`);
+console.log(`Bytes: ${report.bytes.total}`);
+console.log(`Avg Latency: ${report.latency.average}ms`);
+
+const graph = analyzer.getTrafficGraph();
+console.log(graph);
+
+const metrics = new ProtocolMetrics();
+metrics.recordLatency(100);
+metrics.recordPacketLoss(1, 100);
+console.log(`Avg Latency: ${metrics.getAverageLatency()}ms`);
+console.log(`Packet Loss: ${metrics.getPacketLoss() * 100}%`);
+
+const inspector = new PacketInspector();
+
+const hexDump = inspector.hexDump(packetBuffer);
+console.log(hexDump);
+
+const structure = inspector.analyzeStructure(packet);
+console.log(structure);
+```
+
+### Middleware System
+
+Plugin-based packet processing pipeline with built-in middleware:
+
+```javascript
+import { 
+    MiddlewarePipeline,
+    LoggingMiddleware,
+    RateLimitMiddleware,
+    ValidationMiddleware,
+    TransformMiddleware,
+    CacheMiddleware,
+    MetricsMiddleware
+} from 'packet-events-js';
+
+const pipeline = new MiddlewarePipeline();
+
+pipeline.use(new LoggingMiddleware({
+    logLevel: 'debug',
+    includePayload: true,
+    filter: (ctx) => ctx.packet.constructor.packetName !== 'KeepAlive'
+}));
+
+pipeline.use(new RateLimitMiddleware({
+    maxPackets: 100,
+    windowMs: 1000,
+    onLimit: (ctx) => console.log('Rate limited!')
+}));
+
+pipeline.use(new ValidationMiddleware({
+    rules: {
+        'ChatMessage': (packet) => packet.message.length <= 256,
+        'SetPlayerPosition': (packet) => Math.abs(packet.y) < 320
+    },
+    onInvalid: (ctx, rule) => console.log(`Invalid: ${rule}`)
+}));
+
+pipeline.use(new TransformMiddleware({
+    transforms: {
+        'ChatMessage': (packet) => {
+            packet.message = packet.message.trim();
+            return packet;
+        }
+    }
+}));
+
+const metricsMiddleware = new MetricsMiddleware();
+pipeline.use(metricsMiddleware);
+
+pipeline.use(async (ctx, next) => {
+    console.log(`Before: ${ctx.packet.constructor.packetName}`);
+    await next();
+    console.log(`After: processing time ${ctx.processingTime}ms`);
+});
+
+client.packetManager.on('packetReceive', async (event) => {
+    const ctx = await pipeline.process({
+        packet: event.packet,
+        direction: 'CLIENTBOUND',
+        state: 'PLAY'
+    });
+    
+    if (ctx.cancelled) {
+        event.cancel();
+    }
+});
+
+const metrics = metricsMiddleware.getMetrics();
+console.log(`Processed: ${metrics.processed} packets`);
+console.log(`Blocked: ${metrics.blocked} packets`);
+```
+
+### Connection Manager
+
+Advanced connection management with auto-reconnect, health monitoring, and connection pooling:
+
+```javascript
+import { 
+    AutoReconnect, 
+    ReconnectStrategy,
+    HealthMonitor,
+    HealthStatus,
+    ConnectionPool,
+    CircuitBreaker
+} from 'packet-events-js';
+
+const reconnect = new AutoReconnect({
+    strategy: ReconnectStrategy.EXPONENTIAL,
+    baseDelay: 1000,
+    maxDelay: 30000,
+    maxAttempts: 10,
+    jitter: true,
+    onReconnect: (attempt) => console.log(`Reconnecting... attempt ${attempt}`),
+    onMaxAttempts: () => console.log('Max reconnect attempts reached'),
+    onSuccess: () => console.log('Reconnected!')
+});
+
+client.on('disconnect', async () => {
+    await reconnect.attempt(async () => {
+        await client.connect();
+        await client.login();
+    });
+});
+
+const healthMonitor = new HealthMonitor({
+    latencyThreshold: 200,
+    packetLossThreshold: 0.05,
+    checkInterval: 5000
+});
+
+healthMonitor.on('statusChange', (status, previousStatus) => {
+    console.log(`Health: ${previousStatus} -> ${status}`);
+});
+
+healthMonitor.on('alert', (alert) => {
+    console.log(`${alert.type}: ${alert.message}`);
+});
+
+client.packetManager.on('packetReceive', (event) => {
+    if (event.packet.constructor.packetName === 'KeepAliveClientbound') {
+        healthMonitor.recordLatency(Date.now() - event.timestamp);
+    }
+});
+
+const pool = new ConnectionPool({
+    minConnections: 2,
+    maxConnections: 10,
+    strategy: 'least-loaded',
+    healthCheck: async (conn) => conn.isConnected,
+    healthCheckInterval: 30000
+});
+
+await pool.add('lobby', createClient('lobby.server.com'));
+await pool.add('game1', createClient('game1.server.com'));
+await pool.add('game2', createClient('game2.server.com'));
+
+const { id, connection } = pool.get();
+await connection.sendPacket(packet);
+pool.release(id);
+
+const breaker = new CircuitBreaker({
+    failureThreshold: 5,
+    successThreshold: 3,
+    timeout: 30000,
+    onOpen: () => console.log('Circuit OPEN - requests blocked'),
+    onClose: () => console.log('Circuit CLOSED - requests allowed'),
+    onHalfOpen: () => console.log('Circuit HALF-OPEN - testing')
+});
+
+try {
+    await breaker.execute(async () => {
+        await client.sendPacket(packet);
+    });
+} catch (error) {
+    if (breaker.isOpen) {
+        console.log('Circuit is open, request blocked');
+    }
+}
+```
+
 ## Project Structure
 
 ```
@@ -203,10 +521,27 @@ PacketEvents-JS/
 │   │       ├── status/
 │   │       ├── login/
 │   │       └── play/
+│   ├── advanced/
+│   │   ├── PacketRecorder.js
+│   │   ├── ProtocolAnalyzer.js
+│   │   ├── MiddlewareSystem.js
+│   │   └── ConnectionManager.js
 │   └── utils/
 │       ├── PacketBuffer.js
 │       └── Logger.js
 └── examples/
+    ├── authentication.js
+    ├── basic-client.js
+    ├── connection-flows.js
+    ├── custom-packets.js
+    ├── data-types.js
+    ├── encryption.js
+    ├── event-system.js
+    ├── packet-buffer.js
+    ├── packet-interception.js
+    ├── packet-types.js
+    ├── protocol-versions.js
+    └── server-ping.js
 ```
 
 ## Main API
@@ -240,7 +575,7 @@ client.playerName;
 ### PacketBuffer
 
 ```javascript
-import { PacketBuffer } from 'packet-events-js/utils/PacketBuffer';
+import { PacketBuffer } from 'packet-events-js';
 
 const buffer = PacketBuffer.writer();
 
@@ -268,7 +603,7 @@ const str = reader.readString();
 ### MinecraftEncryption
 
 ```javascript
-import { MinecraftEncryption, EncryptedConnection } from 'packet-events-js/crypto/Encryption';
+import { MinecraftEncryption, EncryptedConnection } from 'packet-events-js';
 
 const keyPair = MinecraftEncryption.generateKeyPair();
 
@@ -292,7 +627,7 @@ const decrypted = conn.decrypt(data);
 ### AuthHandler
 
 ```javascript
-import { AuthHandler, ClientAuthHandler, AuthMode } from 'packet-events-js/auth/AuthHandler';
+import { AuthHandler, ClientAuthHandler, AuthMode, BungeeCordForwarding, VelocityForwarding } from 'packet-events-js';
 
 AuthMode.ONLINE;
 AuthMode.OFFLINE;
@@ -304,12 +639,21 @@ handler.initialize();
 handler.getPublicKey();
 handler.generateVerifyToken();
 handler.generateOfflineUUID(username);
+
+const bungeAuth = new AuthHandler({ mode: AuthMode.BUNGEECORD });
+const result = bungeAuth.handleBungeeCordForwarding(serverAddress);
+
+const velocityAuth = new AuthHandler({ 
+    mode: AuthMode.VELOCITY, 
+    velocitySecret: 'your-secret' 
+});
+const result2 = velocityAuth.handleVelocityForwarding(loginPluginData);
 ```
 
 ### EventEmitter
 
 ```javascript
-import { EventPriority } from 'packet-events-js/events/EventEmitter';
+import { EventPriority } from 'packet-events-js';
 
 EventPriority.LOWEST;
 EventPriority.LOW;
@@ -330,7 +674,7 @@ await emitter.emitAsync('event', data);
 ### TextComponent
 
 ```javascript
-import { TextComponent, ChatColor } from 'packet-events-js/protocol/types/TextComponent';
+import { TextComponent, ChatColor } from 'packet-events-js';
 
 const message = TextComponent.text('Hello!')
     .color(ChatColor.GREEN)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "packet-events-js",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A protocol library for Minecraft Java Edition in pure JavaScript",
   "main": "src/index.js",
   "type": "module",
@@ -9,8 +9,7 @@
   ],
   "scripts": {
     "start": "node src/index.js",
-    "example": "node examples/basic-client.js",
-    "test": "node examples/packet-types.js && node examples/data-types.js && node examples/encryption.js"
+    "example": "node examples/basic-client.js"
   },
   "keywords": [
     "minecraft",