@aetherframework/websocket 1.0.0 → 1.0.1

package/src/drivers/tcp-driver.js

@@ -1,471 +0,0 @@
-/**
- * @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;