csterm-server 1.0.0

package/dist/pool/GameServer.d.ts

@@ -0,0 +1,29 @@
+import { RoomManager } from '../RoomManager.js';
+import { ServerConfig } from '../types.js';
+export interface GameServerConfig extends ServerConfig {
+    serverName: string;
+    publicEndpoint: string;
+    hubUrl?: string;
+}
+export declare class GameServer {
+    private config;
+    private wss;
+    private httpServer;
+    private roomManager;
+    private poolClient;
+    private socketToClientId;
+    constructor(config?: Partial<GameServerConfig>);
+    start(): void;
+    stop(): void;
+    private handleConnection;
+    private connectToHub;
+    private calculateLoad;
+    getRoomManager(): RoomManager;
+    getStats(): {
+        clients: number;
+        rooms: number;
+        hubConnected: boolean;
+    };
+    isHubConnected(): boolean;
+    private printBanner;
+}

package/dist/pool/GameServer.js

@@ -0,0 +1,185 @@
+// Game Server - Handles actual game rooms and client connections
+import { WebSocketServer } from 'ws';
+import { createServer } from 'http';
+import { RoomManager } from '../RoomManager.js';
+import { PoolClient } from './PoolClient.js';
+import { parseClientMessage } from '../protocol.js';
+import { DEFAULT_SERVER_CONFIG } from '../types.js';
+export class GameServer {
+    config;
+    wss = null;
+    httpServer = null;
+    roomManager;
+    poolClient = null;
+    socketToClientId = new WeakMap();
+    constructor(config = {}) {
+        this.config = {
+            ...DEFAULT_SERVER_CONFIG,
+            serverName: 'CS-CLI Server',
+            publicEndpoint: `ws://localhost:${config.port || DEFAULT_SERVER_CONFIG.port}`,
+            ...config,
+        };
+        this.roomManager = new RoomManager(this.config);
+        // Set up room event handlers for hub notifications
+        this.roomManager.onRoomCreated = (room) => {
+            this.poolClient?.notifyRoomCreated(room);
+        };
+        this.roomManager.onRoomClosed = (roomId) => {
+            this.poolClient?.notifyRoomClosed(roomId);
+        };
+    }
+    // Start the game server
+    start() {
+        this.httpServer = createServer();
+        this.wss = new WebSocketServer({ server: this.httpServer });
+        this.wss.on('connection', (socket, request) => {
+            this.handleConnection(socket, request);
+        });
+        this.wss.on('error', (error) => {
+            console.error('[GameServer] WebSocket server error:', error);
+        });
+        this.httpServer.listen(this.config.port, () => {
+            this.printBanner();
+        });
+        // Connect to hub if configured
+        if (this.config.hubUrl) {
+            this.connectToHub();
+        }
+        // Stats logging
+        setInterval(() => {
+            const stats = this.roomManager.getStats();
+            if (stats.clients > 0 || stats.rooms > 0) {
+                console.log(`[GameServer] Stats: ${stats.clients} clients, ${stats.rooms} rooms`);
+            }
+        }, 60000);
+    }
+    // Stop the game server
+    stop() {
+        console.log('[GameServer] Shutting down...');
+        // Disconnect from hub
+        this.poolClient?.disconnect();
+        // Close all client connections
+        if (this.wss) {
+            this.wss.clients.forEach((socket) => {
+                socket.close(1001, 'Server shutting down');
+            });
+            this.wss.close();
+            this.wss = null;
+        }
+        // Stop room manager
+        this.roomManager.shutdown();
+        // Close HTTP server
+        if (this.httpServer) {
+            this.httpServer.close();
+            this.httpServer = null;
+        }
+    }
+    // Handle new client connection
+    handleConnection(socket, request) {
+        const clientIp = request.socket.remoteAddress || 'unknown';
+        const clientId = this.roomManager.addClient(socket);
+        this.socketToClientId.set(socket, clientId);
+        console.log(`[GameServer] New connection from ${clientIp} (${clientId})`);
+        socket.on('message', (data, isBinary) => {
+            try {
+                // Check for binary voice frames (first byte 0x01)
+                if (isBinary || (data.length > 0 && data[0] === 0x01)) {
+                    // Route to room's binary handler
+                    this.roomManager.handleBinaryData(clientId, data);
+                    return;
+                }
+                const message = parseClientMessage(data.toString());
+                if (message) {
+                    this.roomManager.handleMessage(clientId, message);
+                }
+                else {
+                    console.warn(`[GameServer] Invalid message from ${clientId}`);
+                }
+            }
+            catch (error) {
+                console.error(`[GameServer] Error processing message from ${clientId}:`, error);
+            }
+        });
+        socket.on('close', (code) => {
+            console.log(`[GameServer] Connection closed: ${clientId} (code: ${code})`);
+            this.roomManager.removeClient(clientId);
+        });
+        socket.on('error', (error) => {
+            console.error(`[GameServer] Socket error for ${clientId}:`, error.message);
+        });
+        // Send initial room list
+        socket.send(JSON.stringify({
+            type: 'room_list',
+            rooms: this.roomManager.listRooms(),
+        }));
+    }
+    // Connect to hub as a pool server
+    connectToHub() {
+        if (!this.config.hubUrl)
+            return;
+        console.log(`[GameServer] Connecting to hub at ${this.config.hubUrl}`);
+        this.poolClient = new PoolClient({
+            hubUrl: this.config.hubUrl,
+            serverName: this.config.serverName,
+            endpoint: this.config.publicEndpoint,
+            maxRooms: this.config.maxRooms,
+        }, {
+            onStatusChange: (status) => {
+                console.log(`[GameServer] Hub connection status: ${status}`);
+            },
+            onRegistered: (poolId) => {
+                console.log(`[GameServer] Registered with hub as ${poolId}`);
+            },
+            onRejected: (reason) => {
+                console.error(`[GameServer] Hub rejected registration: ${reason}`);
+            },
+            onError: (error) => {
+                console.error(`[GameServer] Hub connection error:`, error.message);
+            },
+        });
+        // Set up state callbacks
+        this.poolClient.setStateCallbacks(() => this.roomManager.listRooms(), () => this.roomManager.getStats().clients, () => this.calculateLoad());
+        this.poolClient.connect();
+    }
+    // Calculate server load (0-100)
+    calculateLoad() {
+        const stats = this.roomManager.getStats();
+        const roomLoad = (stats.rooms / this.config.maxRooms) * 100;
+        return Math.min(100, Math.round(roomLoad));
+    }
+    // Get room manager for external access
+    getRoomManager() {
+        return this.roomManager;
+    }
+    // Get stats
+    getStats() {
+        const stats = this.roomManager.getStats();
+        return {
+            ...stats,
+            hubConnected: this.poolClient?.isRegistered() ?? false,
+        };
+    }
+    // Check if connected to hub
+    isHubConnected() {
+        return this.poolClient?.isRegistered() ?? false;
+    }
+    // Print startup banner
+    printBanner() {
+        const hubStatus = this.config.hubUrl ? `Connecting to ${this.config.hubUrl}` : 'Standalone';
+        console.log(`
+  ╔═══════════════════════════════════════════════════╗
+  ║                                                   ║
+  ║   CS-CLI Game Server                              ║
+  ║                                                   ║
+  ║   Name: ${this.config.serverName.padEnd(40)}║
+  ║   Port: ${this.config.port.toString().padEnd(40)}║
+  ║   Endpoint: ${this.config.publicEndpoint.substring(0, 36).padEnd(36)}║
+  ║   Max Rooms: ${this.config.maxRooms.toString().padEnd(36)}║
+  ║   Hub: ${hubStatus.substring(0, 41).padEnd(41)}║
+  ║                                                   ║
+  ║   Server is running...                            ║
+  ║                                                   ║
+  ╚═══════════════════════════════════════════════════╝
+`);
+    }
+}

package/dist/pool/PoolClient.d.ts

@@ -0,0 +1,48 @@
+import { RoomInfo } from '../protocol.js';
+export interface PoolClientConfig {
+    hubUrl: string;
+    serverName: string;
+    endpoint: string;
+    maxRooms: number;
+    reconnectInterval?: number;
+    heartbeatInterval?: number;
+}
+export type PoolClientStatus = 'disconnected' | 'connecting' | 'connected' | 'registered';
+export interface PoolClientEvents {
+    onStatusChange?: (status: PoolClientStatus) => void;
+    onRegistered?: (poolId: string) => void;
+    onRejected?: (reason: string) => void;
+    onError?: (error: Error) => void;
+}
+export declare class PoolClient {
+    private config;
+    private events;
+    private ws;
+    private status;
+    private poolId;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private getRoomsCallback;
+    private getPlayerCountCallback;
+    private getLoadCallback;
+    constructor(config: PoolClientConfig, events?: PoolClientEvents);
+    setStateCallbacks(getRooms: () => RoomInfo[], getPlayerCount: () => number, getLoad: () => number): void;
+    connect(): void;
+    disconnect(): void;
+    notifyRoomCreated(room: RoomInfo): void;
+    notifyRoomClosed(roomId: string): void;
+    getStatus(): PoolClientStatus;
+    getPoolId(): string | null;
+    isRegistered(): boolean;
+    private handleOpen;
+    private handleMessage;
+    private handleClose;
+    private handleError;
+    private send;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendHeartbeat;
+    private scheduleReconnect;
+    private stopReconnect;
+    private setStatus;
+}

package/dist/pool/PoolClient.js

@@ -0,0 +1,204 @@
+// Pool Client - Connects a game server to the central hub
+import WebSocket from 'ws';
+import { serializePoolToHubMessage, } from '../protocol.js';
+export class PoolClient {
+    config;
+    events;
+    ws = null;
+    status = 'disconnected';
+    poolId = null;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    getRoomsCallback = null;
+    getPlayerCountCallback = null;
+    getLoadCallback = null;
+    constructor(config, events = {}) {
+        this.config = {
+            reconnectInterval: 5000,
+            heartbeatInterval: 10000,
+            ...config,
+        };
+        this.events = events;
+    }
+    // Set callbacks for getting current state
+    setStateCallbacks(getRooms, getPlayerCount, getLoad) {
+        this.getRoomsCallback = getRooms;
+        this.getPlayerCountCallback = getPlayerCount;
+        this.getLoadCallback = getLoad;
+    }
+    // Connect to the hub
+    connect() {
+        if (this.ws) {
+            this.ws.close();
+        }
+        this.setStatus('connecting');
+        console.log(`[PoolClient] Connecting to hub at ${this.config.hubUrl}`);
+        this.ws = new WebSocket(this.config.hubUrl);
+        this.ws.on('open', () => {
+            this.handleOpen();
+        });
+        this.ws.on('message', (data) => {
+            this.handleMessage(data.toString());
+        });
+        this.ws.on('close', () => {
+            this.handleClose();
+        });
+        this.ws.on('error', (error) => {
+            this.handleError(error);
+        });
+    }
+    // Disconnect from the hub
+    disconnect() {
+        this.stopHeartbeat();
+        this.stopReconnect();
+        if (this.ws) {
+            // Send unregister message
+            if (this.status === 'registered') {
+                this.send({ type: 'pool_unregister' });
+            }
+            this.ws.close();
+            this.ws = null;
+        }
+        this.poolId = null;
+        this.setStatus('disconnected');
+    }
+    // Notify hub of a new room
+    notifyRoomCreated(room) {
+        if (this.status === 'registered') {
+            this.send({
+                type: 'pool_room_created',
+                room,
+            });
+        }
+    }
+    // Notify hub of a closed room
+    notifyRoomClosed(roomId) {
+        if (this.status === 'registered') {
+            this.send({
+                type: 'pool_room_closed',
+                roomId,
+            });
+        }
+    }
+    // Get current status
+    getStatus() {
+        return this.status;
+    }
+    // Get assigned pool ID
+    getPoolId() {
+        return this.poolId;
+    }
+    // Check if connected and registered
+    isRegistered() {
+        return this.status === 'registered';
+    }
+    // Handle WebSocket open
+    handleOpen() {
+        console.log(`[PoolClient] Connected to hub, registering...`);
+        this.setStatus('connected');
+        // Send registration
+        this.send({
+            type: 'pool_register',
+            serverName: this.config.serverName,
+            endpoint: this.config.endpoint,
+            maxRooms: this.config.maxRooms,
+        });
+    }
+    // Handle incoming message
+    handleMessage(data) {
+        try {
+            const msg = JSON.parse(data);
+            switch (msg.type) {
+                case 'pool_accepted':
+                    this.poolId = msg.poolId;
+                    this.setStatus('registered');
+                    this.startHeartbeat();
+                    console.log(`[PoolClient] Registered with hub as ${msg.poolId}`);
+                    this.events.onRegistered?.(msg.poolId);
+                    break;
+                case 'pool_rejected':
+                    console.error(`[PoolClient] Registration rejected: ${msg.reason}`);
+                    this.events.onRejected?.(msg.reason);
+                    this.ws?.close();
+                    break;
+                case 'pool_ping':
+                    // Hub is checking if we're alive - respond with heartbeat
+                    this.sendHeartbeat();
+                    break;
+            }
+        }
+        catch (error) {
+            console.error(`[PoolClient] Error parsing message:`, error);
+        }
+    }
+    // Handle WebSocket close
+    handleClose() {
+        console.log(`[PoolClient] Disconnected from hub`);
+        this.stopHeartbeat();
+        this.ws = null;
+        this.poolId = null;
+        if (this.status !== 'disconnected') {
+            this.setStatus('disconnected');
+            this.scheduleReconnect();
+        }
+    }
+    // Handle WebSocket error
+    handleError(error) {
+        console.error(`[PoolClient] WebSocket error:`, error.message);
+        this.events.onError?.(error);
+    }
+    // Send a message to the hub
+    send(msg) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(serializePoolToHubMessage(msg));
+        }
+    }
+    // Start heartbeat timer
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.config.heartbeatInterval);
+    }
+    // Stop heartbeat timer
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    // Send heartbeat with current state
+    sendHeartbeat() {
+        const rooms = this.getRoomsCallback?.() ?? [];
+        const playerCount = this.getPlayerCountCallback?.() ?? 0;
+        const load = this.getLoadCallback?.() ?? 0;
+        this.send({
+            type: 'pool_heartbeat',
+            rooms,
+            playerCount,
+            load,
+        });
+    }
+    // Schedule reconnection
+    scheduleReconnect() {
+        this.stopReconnect();
+        console.log(`[PoolClient] Reconnecting in ${this.config.reconnectInterval}ms...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect();
+        }, this.config.reconnectInterval);
+    }
+    // Stop reconnection timer
+    stopReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    // Update status and notify
+    setStatus(status) {
+        if (this.status !== status) {
+            this.status = status;
+            this.events.onStatusChange?.(status);
+        }
+    }
+}