csterm-server 1.0.0

package/dist/hub/HubServer.js

@@ -0,0 +1,266 @@
+// Hub Server - Central registry and routing for federated game servers
+import { WebSocketServer } from 'ws';
+import { createServer } from 'http';
+import { PoolRegistry } from './PoolRegistry.js';
+import { parsePoolToHubMessage, parseClientToHubMessage, serializeHubToPoolMessage, serializeHubToClientMessage, } from '../protocol.js';
+export class HubServer {
+    wss = null;
+    httpServer = null;
+    poolRegistry;
+    connections = new Map();
+    config;
+    tokenMap = new Map();
+    constructor(config) {
+        this.config = config;
+        this.poolRegistry = new PoolRegistry();
+    }
+    // Start the hub server
+    start() {
+        this.httpServer = createServer();
+        this.wss = new WebSocketServer({ server: this.httpServer });
+        this.wss.on('connection', (ws, req) => {
+            this.handleConnection(ws, req);
+        });
+        this.httpServer.listen(this.config.port, () => {
+            console.log(`[HubServer] Listening on port ${this.config.port}`);
+        });
+        // Clean up expired tokens periodically
+        setInterval(() => this.cleanupExpiredTokens(), 60000);
+    }
+    // Stop the hub server
+    stop() {
+        this.poolRegistry.stop();
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+        }
+        if (this.httpServer) {
+            this.httpServer.close();
+            this.httpServer = null;
+        }
+        this.connections.clear();
+        this.tokenMap.clear();
+    }
+    // Handle new WebSocket connection
+    handleConnection(ws, req) {
+        const connection = {
+            ws,
+            type: 'unknown',
+        };
+        this.connections.set(ws, connection);
+        console.log(`[HubServer] New connection from ${req.socket.remoteAddress}`);
+        ws.on('message', (data) => {
+            this.handleMessage(ws, data.toString());
+        });
+        ws.on('close', () => {
+            this.handleDisconnect(ws);
+        });
+        ws.on('error', (error) => {
+            console.error(`[HubServer] WebSocket error:`, error);
+            this.handleDisconnect(ws);
+        });
+    }
+    // Handle incoming message
+    handleMessage(ws, data) {
+        const connection = this.connections.get(ws);
+        if (!connection)
+            return;
+        // Try to parse as pool server message
+        const poolMsg = parsePoolToHubMessage(data);
+        if (poolMsg) {
+            this.handlePoolMessage(ws, connection, poolMsg);
+            return;
+        }
+        // Try to parse as client message
+        const clientMsg = parseClientToHubMessage(data);
+        if (clientMsg) {
+            this.handleClientMessage(ws, connection, clientMsg);
+            return;
+        }
+        console.warn(`[HubServer] Unknown message type:`, data.substring(0, 100));
+    }
+    // Handle pool server messages
+    handlePoolMessage(ws, connection, msg) {
+        switch (msg.type) {
+            case 'pool_register':
+                this.handlePoolRegister(ws, connection, msg.serverName, msg.endpoint, msg.maxRooms);
+                break;
+            case 'pool_heartbeat':
+                if (connection.poolId) {
+                    this.poolRegistry.updatePoolHeartbeat(connection.poolId, msg.rooms, msg.playerCount, msg.load);
+                }
+                break;
+            case 'pool_room_created':
+                if (connection.poolId) {
+                    this.poolRegistry.handleRoomCreated(connection.poolId, msg.room);
+                    console.log(`[HubServer] Room created on pool ${connection.poolId}: ${msg.room.name}`);
+                }
+                break;
+            case 'pool_room_closed':
+                if (connection.poolId) {
+                    this.poolRegistry.handleRoomClosed(connection.poolId, msg.roomId);
+                    console.log(`[HubServer] Room closed on pool ${connection.poolId}: ${msg.roomId}`);
+                }
+                break;
+            case 'pool_unregister':
+                if (connection.poolId) {
+                    this.poolRegistry.unregisterPool(connection.poolId);
+                    connection.type = 'unknown';
+                    connection.poolId = undefined;
+                }
+                break;
+        }
+    }
+    // Handle pool server registration
+    handlePoolRegister(ws, connection, serverName, endpoint, maxRooms) {
+        // Validate
+        if (!serverName || !endpoint) {
+            ws.send(serializeHubToPoolMessage({
+                type: 'pool_rejected',
+                reason: 'Missing serverName or endpoint',
+            }));
+            return;
+        }
+        // Register the pool
+        const poolId = this.poolRegistry.registerPool(ws, serverName, endpoint, maxRooms);
+        connection.type = 'pool';
+        connection.poolId = poolId;
+        ws.send(serializeHubToPoolMessage({
+            type: 'pool_accepted',
+            poolId,
+        }));
+        console.log(`[HubServer] Pool ${serverName} registered with ID ${poolId}`);
+    }
+    // Handle client messages
+    handleClientMessage(ws, connection, msg) {
+        connection.type = 'client';
+        switch (msg.type) {
+            case 'hub_list_rooms':
+                this.handleListRooms(ws);
+                break;
+            case 'hub_get_endpoint':
+                this.handleGetEndpoint(ws, msg.roomId);
+                break;
+            case 'hub_create_room':
+                this.handleCreateRoom(ws, msg.config, msg.preferredPool);
+                break;
+        }
+    }
+    // Handle room list request
+    handleListRooms(ws) {
+        const rooms = this.poolRegistry.getAggregatedRooms();
+        const pools = this.poolRegistry.getPoolSummaries();
+        ws.send(serializeHubToClientMessage({
+            type: 'hub_room_list',
+            rooms,
+            pools,
+        }));
+    }
+    // Handle get endpoint request (client wants to join a room)
+    handleGetEndpoint(ws, roomId) {
+        const pool = this.poolRegistry.getPoolForRoom(roomId);
+        if (!pool) {
+            ws.send(serializeHubToClientMessage({
+                type: 'hub_room_not_found',
+                roomId,
+            }));
+            return;
+        }
+        // Generate a join token
+        const token = this.generateToken();
+        this.tokenMap.set(token, {
+            roomId,
+            endpoint: pool.info.endpoint,
+            expires: Date.now() + 60000, // 1 minute expiry
+        });
+        ws.send(serializeHubToClientMessage({
+            type: 'hub_room_endpoint',
+            roomId,
+            endpoint: pool.info.endpoint,
+            token,
+        }));
+    }
+    // Handle create room request
+    handleCreateRoom(ws, config, preferredPool) {
+        // Find a pool to create the room on
+        let pool;
+        if (preferredPool) {
+            pool = this.poolRegistry.getPool(preferredPool);
+            // Check if pool has capacity
+            if (pool && pool.info.currentRooms >= pool.info.maxRooms) {
+                pool = undefined;
+            }
+        }
+        if (!pool) {
+            pool = this.poolRegistry.getLeastLoadedPool();
+        }
+        if (!pool) {
+            ws.send(serializeHubToClientMessage({
+                type: 'hub_error',
+                error: 'No available pool servers',
+            }));
+            return;
+        }
+        // For now, we just tell the client to connect to the pool and create there
+        // The pool will report the room back to us via pool_room_created
+        const token = this.generateToken();
+        const roomId = `room_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
+        this.tokenMap.set(token, {
+            roomId,
+            endpoint: pool.info.endpoint,
+            expires: Date.now() + 60000,
+        });
+        ws.send(serializeHubToClientMessage({
+            type: 'hub_room_created',
+            roomId,
+            endpoint: pool.info.endpoint,
+            token,
+        }));
+        console.log(`[HubServer] Directing room creation to pool ${pool.info.name}`);
+    }
+    // Handle disconnection
+    handleDisconnect(ws) {
+        const connection = this.connections.get(ws);
+        if (connection) {
+            if (connection.type === 'pool' && connection.poolId) {
+                this.poolRegistry.unregisterPool(connection.poolId);
+                console.log(`[HubServer] Pool ${connection.poolId} disconnected`);
+            }
+            this.connections.delete(ws);
+        }
+    }
+    // Generate a random token
+    generateToken() {
+        return `token_${Date.now()}_${Math.random().toString(36).substr(2, 16)}`;
+    }
+    // Clean up expired tokens
+    cleanupExpiredTokens() {
+        const now = Date.now();
+        for (const [token, info] of this.tokenMap) {
+            if (info.expires < now) {
+                this.tokenMap.delete(token);
+            }
+        }
+    }
+    // Validate a join token (called by pool servers)
+    validateToken(token) {
+        const info = this.tokenMap.get(token);
+        if (info && info.expires > Date.now()) {
+            this.tokenMap.delete(token); // One-time use
+            return { roomId: info.roomId, endpoint: info.endpoint };
+        }
+        return null;
+    }
+    // Get registry for external access
+    getPoolRegistry() {
+        return this.poolRegistry;
+    }
+    // Get stats
+    getStats() {
+        return {
+            pools: this.poolRegistry.getPoolCount(),
+            rooms: this.poolRegistry.getAggregatedRooms().length,
+            players: this.poolRegistry.getTotalPlayerCount(),
+        };
+    }
+}

package/dist/hub/PoolRegistry.d.ts

@@ -0,0 +1,35 @@
+import { WebSocket } from 'ws';
+import { PoolServerInfo, RoomInfo, AggregatedRoomInfo } from '../protocol.js';
+export interface RegisteredPool {
+    info: PoolServerInfo;
+    ws: WebSocket;
+    isAlive: boolean;
+}
+export declare class PoolRegistry {
+    private pools;
+    private heartbeatInterval;
+    private readonly HEARTBEAT_INTERVAL;
+    private readonly DEAD_POOL_TIMEOUT;
+    constructor();
+    registerPool(ws: WebSocket, serverName: string, endpoint: string, maxRooms: number): string;
+    unregisterPool(poolId: string): void;
+    findPoolByWs(ws: WebSocket): RegisteredPool | undefined;
+    updatePoolHeartbeat(poolId: string, rooms: RoomInfo[], playerCount: number, load: number): void;
+    handleRoomCreated(poolId: string, room: RoomInfo): void;
+    handleRoomClosed(poolId: string, roomId: string): void;
+    getAggregatedRooms(): AggregatedRoomInfo[];
+    getPoolForRoom(roomId: string): RegisteredPool | undefined;
+    getPoolSummaries(): {
+        id: string;
+        name: string;
+        playerCount: number;
+    }[];
+    getLeastLoadedPool(): RegisteredPool | undefined;
+    getPool(poolId: string): RegisteredPool | undefined;
+    getAllPools(): RegisteredPool[];
+    getPoolCount(): number;
+    getTotalPlayerCount(): number;
+    private startHeartbeatChecker;
+    stop(): void;
+    private generatePoolId;
+}

package/dist/hub/PoolRegistry.js

@@ -0,0 +1,185 @@
+// Pool Server Registry - Tracks connected pool servers for the hub
+import { WebSocket } from 'ws';
+import { serializeHubToPoolMessage, } from '../protocol.js';
+export class PoolRegistry {
+    pools = new Map();
+    heartbeatInterval = null;
+    HEARTBEAT_INTERVAL = 10000; // 10 seconds
+    DEAD_POOL_TIMEOUT = 30000; // 30 seconds
+    constructor() {
+        this.startHeartbeatChecker();
+    }
+    // Register a new pool server
+    registerPool(ws, serverName, endpoint, maxRooms) {
+        const poolId = this.generatePoolId();
+        const poolInfo = {
+            id: poolId,
+            name: serverName,
+            endpoint,
+            maxRooms,
+            currentRooms: 0,
+            playerCount: 0,
+            load: 0,
+            lastHeartbeat: Date.now(),
+            rooms: [],
+        };
+        this.pools.set(poolId, {
+            info: poolInfo,
+            ws,
+            isAlive: true,
+        });
+        console.log(`[PoolRegistry] Pool registered: ${serverName} (${poolId}) at ${endpoint}`);
+        return poolId;
+    }
+    // Unregister a pool server
+    unregisterPool(poolId) {
+        const pool = this.pools.get(poolId);
+        if (pool) {
+            console.log(`[PoolRegistry] Pool unregistered: ${pool.info.name} (${poolId})`);
+            this.pools.delete(poolId);
+        }
+    }
+    // Find pool by WebSocket connection
+    findPoolByWs(ws) {
+        for (const pool of this.pools.values()) {
+            if (pool.ws === ws) {
+                return pool;
+            }
+        }
+        return undefined;
+    }
+    // Update pool heartbeat with current state
+    updatePoolHeartbeat(poolId, rooms, playerCount, load) {
+        const pool = this.pools.get(poolId);
+        if (pool) {
+            pool.info.rooms = rooms;
+            pool.info.currentRooms = rooms.length;
+            pool.info.playerCount = playerCount;
+            pool.info.load = load;
+            pool.info.lastHeartbeat = Date.now();
+            pool.isAlive = true;
+        }
+    }
+    // Handle room created event from pool
+    handleRoomCreated(poolId, room) {
+        const pool = this.pools.get(poolId);
+        if (pool) {
+            // Add to pool's room list if not already there
+            const existingIndex = pool.info.rooms.findIndex(r => r.id === room.id);
+            if (existingIndex >= 0) {
+                pool.info.rooms[existingIndex] = room;
+            }
+            else {
+                pool.info.rooms.push(room);
+            }
+            pool.info.currentRooms = pool.info.rooms.length;
+        }
+    }
+    // Handle room closed event from pool
+    handleRoomClosed(poolId, roomId) {
+        const pool = this.pools.get(poolId);
+        if (pool) {
+            pool.info.rooms = pool.info.rooms.filter(r => r.id !== roomId);
+            pool.info.currentRooms = pool.info.rooms.length;
+        }
+    }
+    // Get all rooms aggregated from all pools
+    getAggregatedRooms() {
+        const rooms = [];
+        for (const pool of this.pools.values()) {
+            for (const room of pool.info.rooms) {
+                rooms.push({
+                    ...room,
+                    poolId: pool.info.id,
+                    poolName: pool.info.name,
+                    poolEndpoint: pool.info.endpoint,
+                });
+            }
+        }
+        return rooms;
+    }
+    // Get pool info for a specific room
+    getPoolForRoom(roomId) {
+        for (const pool of this.pools.values()) {
+            if (pool.info.rooms.some(r => r.id === roomId)) {
+                return pool;
+            }
+        }
+        return undefined;
+    }
+    // Get all pool summaries (for client display)
+    getPoolSummaries() {
+        return Array.from(this.pools.values()).map(pool => ({
+            id: pool.info.id,
+            name: pool.info.name,
+            playerCount: pool.info.playerCount,
+        }));
+    }
+    // Get pool with lowest load for room creation
+    getLeastLoadedPool() {
+        let leastLoaded;
+        let lowestLoad = Infinity;
+        for (const pool of this.pools.values()) {
+            // Check if pool has capacity
+            if (pool.info.currentRooms < pool.info.maxRooms && pool.info.load < lowestLoad) {
+                lowestLoad = pool.info.load;
+                leastLoaded = pool;
+            }
+        }
+        return leastLoaded;
+    }
+    // Get specific pool by ID
+    getPool(poolId) {
+        return this.pools.get(poolId);
+    }
+    // Get all pools
+    getAllPools() {
+        return Array.from(this.pools.values());
+    }
+    // Get pool count
+    getPoolCount() {
+        return this.pools.size;
+    }
+    // Get total player count across all pools
+    getTotalPlayerCount() {
+        let total = 0;
+        for (const pool of this.pools.values()) {
+            total += pool.info.playerCount;
+        }
+        return total;
+    }
+    // Start heartbeat checker to detect dead pools
+    startHeartbeatChecker() {
+        this.heartbeatInterval = setInterval(() => {
+            const now = Date.now();
+            for (const [poolId, pool] of this.pools) {
+                // Send ping to pool
+                if (pool.ws.readyState === WebSocket.OPEN) {
+                    pool.ws.send(serializeHubToPoolMessage({ type: 'pool_ping' }));
+                }
+                // Check for dead pools
+                if (now - pool.info.lastHeartbeat > this.DEAD_POOL_TIMEOUT) {
+                    console.log(`[PoolRegistry] Pool ${pool.info.name} (${poolId}) timed out - removing`);
+                    pool.ws.close();
+                    this.pools.delete(poolId);
+                }
+            }
+        }, this.HEARTBEAT_INTERVAL);
+    }
+    // Stop the registry
+    stop() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        // Close all pool connections
+        for (const pool of this.pools.values()) {
+            pool.ws.close();
+        }
+        this.pools.clear();
+    }
+    // Generate unique pool ID
+    generatePoolId() {
+        return `pool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { HubServer } from './hub/HubServer.js';
+import { GameServer } from './pool/GameServer.js';
+declare const config: {
+    mode: "standalone" | "hub-only" | "pool";
+    hubUrl?: string;
+    serverName: string;
+    port: number;
+    hubPort: number;
+    maxRooms: number;
+    publicUrl?: string;
+};
+declare let hubServer: HubServer | null;
+declare let gameServer: GameServer | null;
+export { hubServer, gameServer, config };

package/dist/index.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// CS-CLI Multiplayer Server
+// Supports multiple startup modes:
+//   Default: Hub + built-in pool server (standalone)
+//   --hub-only: Hub only (no games, just routing)
+//   --pool --hub=URL: Pool server that connects to external hub
+import { HubServer } from './hub/HubServer.js';
+import { GameServer } from './pool/GameServer.js';
+import { DEFAULT_SERVER_CONFIG } from './types.js';
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const parsed = {
+        mode: 'standalone',
+        serverName: process.env.SERVER_NAME || 'CS-CLI Server',
+        port: parseInt(process.env.PORT || '8080', 10),
+        hubPort: parseInt(process.env.HUB_PORT || '8081', 10),
+        maxRooms: parseInt(process.env.MAX_ROOMS || '100', 10),
+        publicUrl: process.env.PUBLIC_URL, // e.g., wss://game.example.com
+    };
+    for (const arg of args) {
+        if (arg === '--hub-only') {
+            parsed.mode = 'hub-only';
+        }
+        else if (arg === '--pool') {
+            parsed.mode = 'pool';
+        }
+        else if (arg.startsWith('--hub=')) {
+            parsed.hubUrl = arg.substring(6);
+        }
+        else if (arg.startsWith('--name=')) {
+            parsed.serverName = arg.substring(7);
+        }
+        else if (arg.startsWith('--port=')) {
+            parsed.port = parseInt(arg.substring(7), 10);
+        }
+        else if (arg.startsWith('--hub-port=')) {
+            parsed.hubPort = parseInt(arg.substring(11), 10);
+        }
+        else if (arg.startsWith('--max-rooms=')) {
+            parsed.maxRooms = parseInt(arg.substring(12), 10);
+        }
+        else if (arg.startsWith('--public-url=')) {
+            parsed.publicUrl = arg.substring(13);
+        }
+    }
+    // Pool mode requires hub URL
+    if (parsed.mode === 'pool' && !parsed.hubUrl) {
+        console.error('Error: Pool mode requires --hub=URL');
+        process.exit(1);
+    }
+    return parsed;
+}
+const config = parseArgs();
+// Track servers for shutdown
+let hubServer = null;
+let gameServer = null;
+// Start based on mode
+switch (config.mode) {
+    case 'standalone':
+        // Run hub + built-in pool server
+        console.log(`
+  ╔═══════════════════════════════════════════════════╗
+  ║                                                   ║
+  ║   CS-CLI Server (Standalone Mode)                 ║
+  ║                                                   ║
+  ║   Hub Port: ${config.hubPort.toString().padEnd(37)}║
+  ║   Game Port: ${config.port.toString().padEnd(36)}║
+  ║   Max Rooms: ${config.maxRooms.toString().padEnd(36)}║
+  ║                                                   ║
+  ╚═══════════════════════════════════════════════════╝
+`);
+        // Start hub server
+        hubServer = new HubServer({
+            port: config.hubPort,
+        });
+        hubServer.start();
+        // Start built-in game server that connects to hub
+        // Use PUBLIC_URL if set, otherwise default to localhost
+        const standalonePublicEndpoint = config.publicUrl || `ws://localhost:${config.port}`;
+        gameServer = new GameServer({
+            ...DEFAULT_SERVER_CONFIG,
+            port: config.port,
+            maxRooms: config.maxRooms,
+            serverName: config.serverName,
+            publicEndpoint: standalonePublicEndpoint,
+            hubUrl: `ws://localhost:${config.hubPort}`,
+        });
+        gameServer.start();
+        console.log(`  Public endpoint: ${standalonePublicEndpoint}`);
+        break;
+    case 'hub-only':
+        // Run only the hub server
+        console.log(`
+  ╔═══════════════════════════════════════════════════╗
+  ║                                                   ║
+  ║   CS-CLI Hub Server (Hub-Only Mode)               ║
+  ║                                                   ║
+  ║   Port: ${config.hubPort.toString().padEnd(41)}║
+  ║                                                   ║
+  ║   Waiting for pool servers to connect...          ║
+  ║                                                   ║
+  ╚═══════════════════════════════════════════════════╝
+`);
+        hubServer = new HubServer({
+            port: config.hubPort,
+        });
+        hubServer.start();
+        break;
+    case 'pool':
+        // Run game server that connects to external hub
+        console.log(`
+  ╔═══════════════════════════════════════════════════╗
+  ║                                                   ║
+  ║   CS-CLI Pool Server                              ║
+  ║                                                   ║
+  ║   Name: ${config.serverName.substring(0, 40).padEnd(40)}║
+  ║   Port: ${config.port.toString().padEnd(41)}║
+  ║   Hub: ${config.hubUrl.substring(0, 42).padEnd(42)}║
+  ║   Max Rooms: ${config.maxRooms.toString().padEnd(36)}║
+  ║                                                   ║
+  ╚═══════════════════════════════════════════════════╝
+`);
+        // Use PUBLIC_URL if set, otherwise default to localhost
+        const poolPublicEndpoint = config.publicUrl || `ws://localhost:${config.port}`;
+        gameServer = new GameServer({
+            ...DEFAULT_SERVER_CONFIG,
+            port: config.port,
+            maxRooms: config.maxRooms,
+            serverName: config.serverName,
+            publicEndpoint: poolPublicEndpoint,
+            hubUrl: config.hubUrl,
+        });
+        gameServer.start();
+        console.log(`  Public endpoint: ${poolPublicEndpoint}`);
+        break;
+}
+// Graceful shutdown
+function shutdown() {
+    console.log('\nShutting down server...');
+    if (gameServer) {
+        gameServer.stop();
+    }
+    if (hubServer) {
+        hubServer.stop();
+    }
+    // Force exit after 5 seconds
+    setTimeout(() => {
+        console.log('Force exit');
+        process.exit(1);
+    }, 5000);
+    setTimeout(() => {
+        console.log('Server closed');
+        process.exit(0);
+    }, 1000);
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+// Stats logging
+setInterval(() => {
+    if (hubServer) {
+        const stats = hubServer.getStats();
+        if (stats.pools > 0 || stats.rooms > 0 || stats.players > 0) {
+            console.log(`[Hub] ${stats.pools} pools, ${stats.rooms} rooms, ${stats.players} players`);
+        }
+    }
+    if (gameServer) {
+        const stats = gameServer.getStats();
+        if (stats.clients > 0 || stats.rooms > 0) {
+            console.log(`[Game] ${stats.clients} clients, ${stats.rooms} rooms, hub: ${stats.hubConnected}`);
+        }
+    }
+}, 60000);
+// Export for testing
+export { hubServer, gameServer, config };