csterm-server 1.0.0

package/dist/RoomManager.js

@@ -0,0 +1,277 @@
+// Room lifecycle management for CS-CLI multiplayer server
+import { v4 as uuidv4 } from 'uuid';
+import { WebSocket } from 'ws';
+import { Room } from './Room.js';
+import { serializeServerMessage, } from './protocol.js';
+import { DEFAULT_SERVER_CONFIG } from './types.js';
+export class RoomManager {
+    rooms = new Map();
+    clients = new Map();
+    config;
+    // Cleanup interval
+    cleanupInterval = null;
+    // Event callbacks (for hub notification)
+    onRoomCreated;
+    onRoomClosed;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_SERVER_CONFIG, ...config };
+        // Start cleanup interval (every 30 seconds)
+        this.cleanupInterval = setInterval(() => this.cleanup(), 30000);
+    }
+    // ============ Client Management ============
+    addClient(socket) {
+        const clientId = uuidv4();
+        const client = {
+            id: clientId,
+            socket,
+            name: null,
+            roomId: null,
+            isReady: false,
+            lastActivity: Date.now(),
+            pendingInputs: [],
+        };
+        this.clients.set(clientId, client);
+        console.log(`Client connected: ${clientId}`);
+        return clientId;
+    }
+    removeClient(clientId) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        // Leave room if in one
+        if (client.roomId) {
+            this.leaveRoom(clientId);
+        }
+        this.clients.delete(clientId);
+        console.log(`Client disconnected: ${clientId}`);
+    }
+    getClient(clientId) {
+        return this.clients.get(clientId);
+    }
+    // ============ Room Management ============
+    createRoom(clientId, config) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return null;
+        // Check room limit
+        if (this.rooms.size >= this.config.maxRooms) {
+            this.sendToClient(clientId, {
+                type: 'room_error',
+                error: 'Server is full. Cannot create more rooms.',
+            });
+            return null;
+        }
+        // Validate config
+        if (config.maxPlayers > this.config.maxPlayersPerRoom) {
+            config.maxPlayers = this.config.maxPlayersPerRoom;
+        }
+        if (config.maxPlayers < 1)
+            config.maxPlayers = 1;
+        if (config.botCount < 0)
+            config.botCount = 0;
+        if (config.botCount > 8)
+            config.botCount = 8;
+        const roomId = uuidv4().substring(0, 8);
+        const room = new Room(roomId, config, clientId, this.config);
+        this.rooms.set(roomId, room);
+        console.log(`Room created: ${roomId} by ${clientId} (${config.name})`);
+        // Notify hub if callback is set
+        this.onRoomCreated?.(room.getInfo());
+        // Auto-join the creator
+        this.joinRoom(clientId, roomId, client.name || 'Host');
+        return roomId;
+    }
+    joinRoom(clientId, roomId, playerName, password) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return false;
+        // Leave current room first
+        if (client.roomId) {
+            this.leaveRoom(clientId);
+        }
+        const room = this.rooms.get(roomId);
+        if (!room) {
+            this.sendToClient(clientId, {
+                type: 'room_error',
+                error: 'Room not found.',
+            });
+            return false;
+        }
+        // Check password
+        if (room.config.password && room.config.password !== password) {
+            this.sendToClient(clientId, {
+                type: 'room_error',
+                error: 'Incorrect password.',
+            });
+            return false;
+        }
+        // Check capacity
+        if (room.getPlayerCount() >= room.config.maxPlayers) {
+            this.sendToClient(clientId, {
+                type: 'room_error',
+                error: 'Room is full.',
+            });
+            return false;
+        }
+        // Join the room
+        client.name = playerName;
+        client.roomId = roomId;
+        client.isReady = false;
+        // IMPORTANT: Send join confirmation BEFORE addPlayer
+        // addPlayer sends existing player info, and client resets lobby on room_joined
+        // So room_joined must come first, otherwise existing players get cleared
+        this.sendToClient(clientId, {
+            type: 'room_joined',
+            roomId,
+            playerId: clientId,
+            room: room.getInfo(),
+        });
+        // Now add player - this sends existing player info to new joiner
+        room.addPlayer(clientId, client);
+        // Notify other players (this is also done in room.addPlayer, so remove duplicate)
+        // Note: room.addPlayer already broadcasts to other clients
+        console.log(`${playerName} (${clientId}) joined room ${roomId}`);
+        return true;
+    }
+    leaveRoom(clientId) {
+        const client = this.clients.get(clientId);
+        if (!client || !client.roomId)
+            return;
+        const room = this.rooms.get(client.roomId);
+        if (room) {
+            const playerName = client.name || 'Unknown';
+            room.removePlayer(clientId);
+            // Notify remaining players
+            room.broadcast({
+                type: 'player_left',
+                playerId: clientId,
+                playerName,
+            });
+            console.log(`${playerName} (${clientId}) left room ${room.id}`);
+            // Remove room if empty
+            if (room.getPlayerCount() === 0) {
+                this.removeRoom(room.id);
+            }
+        }
+        client.roomId = null;
+        client.isReady = false;
+    }
+    removeRoom(roomId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            return;
+        room.stop();
+        this.rooms.delete(roomId);
+        console.log(`Room removed: ${roomId}`);
+        // Notify hub if callback is set
+        this.onRoomClosed?.(roomId);
+    }
+    listRooms() {
+        const rooms = [];
+        for (const room of this.rooms.values()) {
+            // Don't list private rooms
+            if (!room.config.isPrivate) {
+                rooms.push(room.getInfo());
+            }
+        }
+        return rooms;
+    }
+    // ============ Message Handling ============
+    handleMessage(clientId, message) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        client.lastActivity = Date.now();
+        switch (message.type) {
+            case 'list_rooms':
+                this.sendToClient(clientId, {
+                    type: 'room_list',
+                    rooms: this.listRooms(),
+                });
+                break;
+            case 'create_room':
+                this.createRoom(clientId, message.config);
+                break;
+            case 'join_room':
+                this.joinRoom(clientId, message.roomId, message.playerName, message.password);
+                break;
+            case 'leave_room':
+                this.leaveRoom(clientId);
+                break;
+            default:
+                // Forward game messages to the room
+                if (client.roomId) {
+                    const room = this.rooms.get(client.roomId);
+                    if (room) {
+                        room.handleMessage(clientId, message);
+                    }
+                }
+                break;
+        }
+    }
+    // ============ Binary Data (Voice) ============
+    handleBinaryData(clientId, data) {
+        const client = this.clients.get(clientId);
+        if (!client || !client.roomId)
+            return;
+        const room = this.rooms.get(client.roomId);
+        if (room) {
+            room.handleBinaryData(clientId, data);
+        }
+    }
+    // ============ Utility ============
+    sendToClient(clientId, message) {
+        const client = this.clients.get(clientId);
+        if (!client || client.socket.readyState !== WebSocket.OPEN)
+            return;
+        try {
+            client.socket.send(serializeServerMessage(message));
+        }
+        catch (e) {
+            console.error(`Failed to send to client ${clientId}:`, e);
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        // Remove idle rooms
+        for (const [roomId, room] of this.rooms) {
+            if (room.getPlayerCount() === 0) {
+                const idleTime = now - room.lastActivity;
+                if (idleTime > this.config.roomIdleTimeout) {
+                    this.removeRoom(roomId);
+                }
+            }
+        }
+        // Note: Client cleanup handled by WebSocket close events
+    }
+    shutdown() {
+        // Stop cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        // Stop all rooms
+        for (const room of this.rooms.values()) {
+            room.stop();
+        }
+        this.rooms.clear();
+        // Close all client connections
+        for (const client of this.clients.values()) {
+            try {
+                client.socket.close(1001, 'Server shutting down');
+            }
+            catch (e) {
+                // Ignore close errors
+            }
+        }
+        this.clients.clear();
+        console.log('RoomManager shutdown complete');
+    }
+    // ============ Stats ============
+    getStats() {
+        return {
+            rooms: this.rooms.size,
+            clients: this.clients.size,
+        };
+    }
+}

package/dist/VoiceRelay.d.ts

@@ -0,0 +1,62 @@
+/**
+ * VoiceRelay - Server-side voice frame relay
+ *
+ * Relays binary voice frames between clients in a room.
+ * Handles team filtering and position tracking for spatial audio.
+ */
+import { TeamId } from './protocol.js';
+import { ConnectedClient } from './types.js';
+/**
+ * Check if data is a voice frame
+ */
+export declare function isVoiceFrame(data: Buffer | ArrayBuffer | Uint8Array): boolean;
+/**
+ * Voice relay state for a room
+ */
+export declare class VoiceRelay {
+    private positions;
+    private senderIdToPlayerId;
+    private playerIdToSenderId;
+    /**
+     * Register a player's sender ID
+     */
+    registerPlayer(playerId: string, senderId: number): void;
+    /**
+     * Unregister a player
+     */
+    unregisterPlayer(playerId: string): void;
+    /**
+     * Update a player's position (for spatial audio)
+     */
+    updatePosition(playerId: string, x: number, y: number, z: number): void;
+    /**
+     * Get player ID from sender ID
+     */
+    getPlayerId(senderId: number): string | undefined;
+    private debugRelayCount;
+    /**
+     * Relay a voice frame to room members
+     *
+     * @param data Binary voice frame
+     * @param senderClientId Client ID of sender
+     * @param clients Map of all clients in room
+     * @param teamAssignments Map of client ID to team
+     */
+    relayVoiceFrame(data: Uint8Array, senderClientId: string, clients: Map<string, ConnectedClient>, teamAssignments: Map<string, TeamId>): void;
+    /**
+     * Cleanup old positions
+     */
+    cleanup(maxAgeMs?: number): void;
+    /**
+     * Clear all state
+     */
+    clear(): void;
+}
+/**
+ * Get or create voice relay for a room
+ */
+export declare function getVoiceRelay(roomId: string): VoiceRelay;
+/**
+ * Remove voice relay for a room
+ */
+export declare function removeVoiceRelay(roomId: string): void;

package/dist/VoiceRelay.js

@@ -0,0 +1,167 @@
+/**
+ * VoiceRelay - Server-side voice frame relay
+ *
+ * Relays binary voice frames between clients in a room.
+ * Handles team filtering and position tracking for spatial audio.
+ */
+import { WebSocket } from 'ws';
+// Voice protocol constants (matching client)
+const VOICE_FRAME_TYPE = 0x01;
+const VOICE_FLAG_TEAM_ONLY = 0x02;
+/**
+ * Extract sender ID from voice frame (bytes 2-5)
+ */
+function getSenderIdFromFrame(data) {
+    if (data.length < 6)
+        return 0;
+    return data[2] | (data[3] << 8) | (data[4] << 16) | (data[5] << 24);
+}
+/**
+ * Get flags from voice frame (byte 1)
+ */
+function getFrameFlags(data) {
+    if (data.length < 2)
+        return 0;
+    return data[1];
+}
+/**
+ * Check if data is a voice frame
+ */
+export function isVoiceFrame(data) {
+    if (data instanceof ArrayBuffer) {
+        data = new Uint8Array(data);
+    }
+    else if (Buffer.isBuffer(data)) {
+        data = new Uint8Array(data.buffer, data.byteOffset, data.length);
+    }
+    return data.length >= 1 && data[0] === VOICE_FRAME_TYPE;
+}
+/**
+ * Voice relay state for a room
+ */
+export class VoiceRelay {
+    positions = new Map();
+    senderIdToPlayerId = new Map();
+    playerIdToSenderId = new Map();
+    /**
+     * Register a player's sender ID
+     */
+    registerPlayer(playerId, senderId) {
+        this.senderIdToPlayerId.set(senderId, playerId);
+        this.playerIdToSenderId.set(playerId, senderId);
+    }
+    /**
+     * Unregister a player
+     */
+    unregisterPlayer(playerId) {
+        const senderId = this.playerIdToSenderId.get(playerId);
+        if (senderId !== undefined) {
+            this.senderIdToPlayerId.delete(senderId);
+        }
+        this.playerIdToSenderId.delete(playerId);
+        this.positions.delete(playerId);
+    }
+    /**
+     * Update a player's position (for spatial audio)
+     */
+    updatePosition(playerId, x, y, z) {
+        this.positions.set(playerId, {
+            x, y, z,
+            lastUpdate: Date.now(),
+        });
+    }
+    /**
+     * Get player ID from sender ID
+     */
+    getPlayerId(senderId) {
+        return this.senderIdToPlayerId.get(senderId);
+    }
+    // Debug counter
+    debugRelayCount = 0;
+    /**
+     * Relay a voice frame to room members
+     *
+     * @param data Binary voice frame
+     * @param senderClientId Client ID of sender
+     * @param clients Map of all clients in room
+     * @param teamAssignments Map of client ID to team
+     */
+    relayVoiceFrame(data, senderClientId, clients, teamAssignments) {
+        const flags = getFrameFlags(data);
+        const teamOnly = (flags & VOICE_FLAG_TEAM_ONLY) !== 0;
+        const senderTeam = teamAssignments.get(senderClientId);
+        const senderId = getSenderIdFromFrame(data);
+        this.debugRelayCount++;
+        if (this.debugRelayCount % 50 === 1) {
+            console.log(`[VoiceRelay] Relaying frame #${this.debugRelayCount} from ${senderClientId.slice(0, 8)} (sender ${senderId.toString(16)}), ${clients.size} clients in room`);
+        }
+        let relayedTo = 0;
+        // Relay to all other clients (optionally filtered by team)
+        for (const [clientId, client] of clients) {
+            // Don't send back to sender
+            if (clientId === senderClientId)
+                continue;
+            // Check team filter
+            if (teamOnly && senderTeam) {
+                const clientTeam = teamAssignments.get(clientId);
+                if (clientTeam !== senderTeam)
+                    continue;
+            }
+            // Send binary frame
+            if (client.socket.readyState === WebSocket.OPEN) {
+                try {
+                    client.socket.send(data);
+                    relayedTo++;
+                }
+                catch {
+                    // Ignore send errors
+                }
+            }
+        }
+        if (this.debugRelayCount % 50 === 1) {
+            console.log(`[VoiceRelay] Relayed to ${relayedTo} clients`);
+        }
+    }
+    /**
+     * Cleanup old positions
+     */
+    cleanup(maxAgeMs = 10000) {
+        const now = Date.now();
+        for (const [playerId, pos] of this.positions) {
+            if (now - pos.lastUpdate > maxAgeMs) {
+                this.positions.delete(playerId);
+            }
+        }
+    }
+    /**
+     * Clear all state
+     */
+    clear() {
+        this.positions.clear();
+        this.senderIdToPlayerId.clear();
+        this.playerIdToSenderId.clear();
+    }
+}
+// Room voice relays
+const roomRelays = new Map();
+/**
+ * Get or create voice relay for a room
+ */
+export function getVoiceRelay(roomId) {
+    let relay = roomRelays.get(roomId);
+    if (!relay) {
+        relay = new VoiceRelay();
+        roomRelays.set(roomId, relay);
+    }
+    return relay;
+}
+/**
+ * Remove voice relay for a room
+ */
+export function removeVoiceRelay(roomId) {
+    const relay = roomRelays.get(roomId);
+    if (relay) {
+        relay.clear();
+        roomRelays.delete(roomId);
+    }
+}

package/dist/hub/HubServer.d.ts

@@ -0,0 +1,37 @@
+import { PoolRegistry } from './PoolRegistry.js';
+export interface HubServerConfig {
+    port: number;
+    builtInPoolEndpoint?: string;
+}
+export declare class HubServer {
+    private wss;
+    private httpServer;
+    private poolRegistry;
+    private connections;
+    private config;
+    private tokenMap;
+    constructor(config: HubServerConfig);
+    start(): void;
+    stop(): void;
+    private handleConnection;
+    private handleMessage;
+    private handlePoolMessage;
+    private handlePoolRegister;
+    private handleClientMessage;
+    private handleListRooms;
+    private handleGetEndpoint;
+    private handleCreateRoom;
+    private handleDisconnect;
+    private generateToken;
+    private cleanupExpiredTokens;
+    validateToken(token: string): {
+        roomId: string;
+        endpoint: string;
+    } | null;
+    getPoolRegistry(): PoolRegistry;
+    getStats(): {
+        pools: number;
+        rooms: number;
+        players: number;
+    };
+}