@aetherframework/websocket 1.0.1 → 1.0.3

package/src/drivers/tcp-driver.js

@@ -0,0 +1,471 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/src/drivers/tcp-driver
+ */
+
+import net from 'net';
+import crypto from 'crypto';
+import EventEmitter from 'events';
+import FrameEncoder from '../utils/frame-encoder.js';
+
+class TCPDriver extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.config = config;
+    this.server = null;
+    this.connections = new Map();
+  }
+  
+  /**
+   * Create a TCP WebSocket server
+   * @param {Object} options - Server options
+   * @returns {Promise<Object>} Server instance
+   */
+  async createServer(options = {}) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = net.createServer((socket) => {
+          this._handleConnection(socket);
+        });
+        
+        const serverOptions = {
+          host: options.host || '0.0.0.0',
+          port: options.port || 8080,
+          ...options
+        };
+        
+        this.server.listen(serverOptions, () => {
+          const address = this.server.address();
+          this.emit('server:listening', {
+            host: address.address,
+            port: address.port,
+            family: address.family
+          });
+          resolve({
+            type: 'tcp',
+            address: address,
+            close: () => this.closeServer()
+          });
+        });
+        
+        this.server.on('error', (error) => {
+          this.emit('error', {
+            type: 'server_error',
+            message: 'Server error',
+            error
+          });
+          reject(error);
+        });
+        
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  
+  /**
+   * Handle new TCP connection
+   * @param {net.Socket} socket - TCP socket
+   * @private
+   */
+  _handleConnection(socket) {
+    const connectionId = crypto.randomUUID();
+    let buffer = Buffer.alloc(0);
+    let handshakeComplete = false;
+    
+    // Set socket options
+    socket.setNoDelay(true);
+    socket.setKeepAlive(true, 10000);
+    socket.setTimeout(this.config.socketTimeout || 30000);
+    
+    // Handle incoming data
+    socket.on('data', (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      
+      if (!handshakeComplete) {
+        this._handleHandshake(socket, buffer, connectionId)
+          .then((handshakeResult) => {
+            if (handshakeResult.success) {
+              handshakeComplete = true;
+              buffer = buffer.slice(handshakeResult.bytesRead);
+              this._setupWebSocketConnection(socket, connectionId, handshakeResult);
+            }
+          })
+          .catch((error) => {
+            this.emit('error', {
+              type: 'handshake_error',
+              message: 'WebSocket handshake failed',
+              error,
+              connectionId
+            });
+            socket.end();
+          });
+      } else {
+        this._handleWebSocketData(socket, buffer, connectionId);
+      }
+    });
+    
+    // Handle socket errors
+    socket.on('error', (error) => {
+      this.emit('error', {
+        type: 'socket_error',
+        message: 'Socket error',
+        error,
+        connectionId
+      });
+      this._removeConnection(connectionId);
+    });
+    
+    // Handle socket close
+    socket.on('close', (hadError) => {
+      this.emit('close', this.connections.get(connectionId), 1006, 'Connection closed');
+      this._removeConnection(connectionId);
+    });
+    
+    // Handle socket timeout
+    socket.on('timeout', () => {
+      socket.end();
+      this._removeConnection(connectionId);
+    });
+  }
+  
+  /**
+   * Handle WebSocket handshake
+   * @param {net.Socket} socket - TCP socket
+   * @param {Buffer} buffer - Received data buffer
+   * @param {string} connectionId - Connection ID
+   * @returns {Promise<Object>} Handshake result
+   * @private
+   */
+  async _handleHandshake(socket, buffer, connectionId) {
+    const request = buffer.toString('utf8');
+    
+    // Check if we have a complete HTTP request
+    if (!request.includes('\r\n\r\n')) {
+      return { success: false, bytesRead: 0 };
+    }
+    
+    const lines = request.split('\r\n');
+    const requestLine = lines[0];
+    const headers = {};
+    
+    // Parse headers
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === '') break; // End of headers
+      
+      const colonIndex = line.indexOf(':');
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim().toLowerCase();
+        const value = line.slice(colonIndex + 1).trim();
+        headers[key] = value;
+      }
+    }
+    
+    // Check if this is a WebSocket upgrade request
+    if (!requestLine.includes('GET') || 
+        headers['upgrade'] !== 'websocket' ||
+        !headers['sec-websocket-key']) {
+      // Not a WebSocket request
+      socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
+      socket.end();
+      return { success: false, bytesRead: buffer.length };
+    }
+    
+    // Calculate accept key
+    const acceptKey = crypto
+      .createHash('sha1')
+      .update(headers['sec-websocket-key'] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+      .digest('base64');
+    
+    // Build response headers
+    const responseHeaders = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${acceptKey}`
+    ];
+    
+    // Add optional headers
+    if (headers['sec-websocket-protocol']) {
+      responseHeaders.push(`Sec-WebSocket-Protocol: ${headers['sec-websocket-protocol']}`);
+    }
+    
+    if (this.config.compression && headers['sec-websocket-extensions']) {
+      responseHeaders.push('Sec-WebSocket-Extensions: permessage-deflate');
+    }
+    
+    // Send handshake response
+    socket.write(responseHeaders.join('\r\n') + '\r\n\r\n');
+    
+    // Create connection object
+    const connection = {
+      id: connectionId,
+      socket: socket,
+      readyState: 1, // OPEN
+      protocol: headers['sec-websocket-protocol'] || null,
+      extensions: headers['sec-websocket-extensions'] || null,
+      remoteAddress: socket.remoteAddress,
+      remotePort: socket.remotePort,
+      headers: headers
+    };
+    
+    this.connections.set(connectionId, connection);
+    
+    return {
+      success: true,
+      bytesRead: buffer.length,
+      connection: connection
+    };
+  }
+  
+  /**
+   * Set up WebSocket connection after handshake
+   * @param {net.Socket} socket - TCP socket
+   * @param {string} connectionId - Connection ID
+   * @param {Object} handshakeResult - Handshake result
+   * @private
+   */
+  _setupWebSocketConnection(socket, connectionId, handshakeResult) {
+    const connection = handshakeResult.connection;
+    
+    // Emit connection event
+    this.emit('connection', connection);
+    
+    // Set up ping/pong heartbeat
+    if (this.config.pingInterval) {
+      const pingInterval = setInterval(() => {
+        if (connection.readyState === 1) {
+          this._sendPing(socket);
+        } else {
+          clearInterval(pingInterval);
+        }
+      }, this.config.pingInterval);
+      
+      connection.pingInterval = pingInterval;
+    }
+  }
+  
+  /**
+   * Handle WebSocket data frames
+   * @param {net.Socket} socket - TCP socket
+   * @param {Buffer} buffer - Data buffer
+   * @param {string} connectionId - Connection ID
+   * @private
+   */
+  _handleWebSocketData(socket, buffer, connectionId) {
+    const connection = this.connections.get(connectionId);
+    if (!connection) return;
+    
+    try {
+      const frames = FrameEncoder.parseFrames(buffer, this.config.maxPayload);
+      
+      for (const frame of frames) {
+        switch (frame.opcode) {
+          case 0x1: // Text frame
+            const text = frame.payload.toString('utf8');
+            this.emit('message', connection, text, false);
+            break;
+            
+          case 0x2: // Binary frame
+            this.emit('message', connection, frame.payload, true);
+            break;
+            
+          case 0x8: // Close frame
+            const code = frame.payload.length >= 2 ? 
+              frame.payload.readUInt16BE(0) : 1000;
+            const reason = frame.payload.length > 2 ? 
+              frame.payload.slice(2).toString('utf8') : '';
+            this._sendCloseFrame(socket, code, reason);
+            connection.readyState = 3; // CLOSED
+            this.emit('close', connection, code, reason);
+            socket.end();
+            break;
+            
+          case 0x9: // Ping frame
+            this._sendPong(socket, frame.payload);
+            break;
+            
+          case 0xA: // Pong frame
+            this.emit('pong', connection);
+            break;
+        }
+      }
+    } catch (error) {
+      this.emit('error', {
+        type: 'frame_parse_error',
+        message: 'Failed to parse WebSocket frame',
+        error,
+        connectionId
+      });
+      this._sendCloseFrame(socket, 1002, 'Protocol error');
+      socket.end();
+    }
+  }
+  
+  /**
+   * Send ping frame
+   * @param {net.Socket} socket - TCP socket
+   * @private
+   */
+  _sendPing(socket) {
+    const pingFrame = Buffer.from([0x89, 0x00]); // FIN + Ping opcode
+    socket.write(pingFrame);
+  }
+  
+  /**
+   * Send pong frame
+   * @param {net.Socket} socket - TCP socket
+   * @param {Buffer} payload - Ping payload to echo back
+   * @private
+   */
+  _sendPong(socket, payload) {
+    const pongFrame = FrameEncoder.createFrame(0xA, payload); // Pong opcode
+    socket.write(pongFrame);
+  }
+  
+  /**
+   * Send close frame
+   * @param {net.Socket} socket - TCP socket
+   * @param {number} code - Close code
+   * @param {string} reason - Close reason
+   * @private
+   */
+  _sendCloseFrame(socket, code, reason) {
+    const payload = Buffer.alloc(2 + Buffer.byteLength(reason));
+    payload.writeUInt16BE(code, 0);
+    if (reason) {
+      payload.write(reason, 2, 'utf8');
+    }
+    const closeFrame = FrameEncoder.createFrame(0x8, payload); // Close opcode
+    socket.write(closeFrame);
+  }
+  
+  /**
+   * Remove connection
+   * @param {string} connectionId - Connection ID
+   * @private
+   */
+  _removeConnection(connectionId) {
+    const connection = this.connections.get(connectionId);
+    if (connection) {
+      if (connection.pingInterval) {
+        clearInterval(connection.pingInterval);
+      }
+      this.connections.delete(connectionId);
+    }
+  }
+  
+  /**
+   * Create a WebSocket client
+   * @param {string} url - WebSocket URL
+   * @param {Object} options - Client options
+   * @returns {Promise<Object>} Client connection
+   */
+  async createClient(url, options = {}) {
+    // Parse URL
+    const urlObj = new URL(url);
+    const host = urlObj.hostname;
+    const port = parseInt(urlObj.port) || (urlObj.protocol === 'wss:' ? 443 : 80);
+    const path = urlObj.pathname + urlObj.search;
+    
+    return new Promise((resolve, reject) => {
+      const socket = net.createConnection({ host, port }, () => {
+        // Send WebSocket handshake
+        const key = crypto.randomBytes(16).toString('base64');
+        const handshake = [
+          `GET ${path} HTTP/1.1`,
+          `Host: ${host}:${port}`,
+          'Upgrade: websocket',
+          'Connection: Upgrade',
+          `Sec-WebSocket-Key: ${key}`,
+          'Sec-WebSocket-Version: 13'
+        ].join('\r\n') + '\r\n\r\n';
+        
+        socket.write(handshake);
+        
+        let buffer = Buffer.alloc(0);
+        
+        const onData = (chunk) => {
+          buffer = Buffer.concat([buffer, chunk]);
+          
+          // Check for handshake response
+          const response = buffer.toString('utf8');
+          if (response.includes('\r\n\r\n')) {
+            socket.removeListener('data', onData);
+            
+            if (response.includes('101 Switching Protocols')) {
+              const connection = {
+                id: crypto.randomUUID(),
+                socket: socket,
+                readyState: 1,
+                send: (data) => this._sendData(socket, data),
+                close: (code, reason) => {
+                  this._sendCloseFrame(socket, code, reason);
+                  socket.end();
+                }
+              };
+              
+              // Set up message handling
+              socket.on('data', (data) => {
+                this._handleWebSocketData(socket, data, connection.id);
+              });
+              
+              resolve(connection);
+            } else {
+              reject(new Error('Handshake failed'));
+            }
+          }
+        };
+        
+        socket.on('data', onData);
+      });
+      
+      socket.on('error', reject);
+      socket.on('timeout', () => reject(new Error('Connection timeout')));
+    });
+  }
+  
+  /**
+   * Send data through socket
+   * @param {net.Socket} socket - TCP socket
+   * @param {string|Buffer} data - Data to send
+   * @private
+   */
+  _sendData(socket, data) {
+    const frame = FrameEncoder.createFrame(
+      0x1, // Text frame opcode
+      Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8')
+    );
+    socket.write(frame);
+  }
+  
+  /**
+   * Close the server
+   * @returns {Promise<void>}
+   */
+  async closeServer() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        // Close all connections
+        this.connections.forEach((connection) => {
+          if (connection.readyState === 1) {
+            this._sendCloseFrame(connection.socket, 1001, 'Server going away');
+            connection.socket.end();
+          }
+        });
+        
+        this.server.close(() => {
+          this.connections.clear();
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+export default TCPDriver;