homegames-common 1.5.1 → 1.5.3

package/docker-helper.js

@@ -101,7 +101,7 @@ const runGameContainer = async ({
     saveDataPath,
     assetCachePath = null,
     imageName = 'homegames-runner',
-    memoryLimit = '64m',
+    memoryLimit = '128m',
     cpuLimit = '1',
     gameEntryRelative = null,
     noFrame = false,
@@ -180,7 +180,7 @@ const runGameContainer = async ({
             PidsLimit: 64,
             CapDrop: ['ALL'],
             Tmpfs: {
-                '/tmp': 'rw,size=64m',
+                '/tmp': 'rw,size=160m',
             },
             ExtraHosts: extraHosts,
         },

package/game-loader.js

@@ -44,22 +44,13 @@ const DEFAULT_SQUISH_VERSION = '135';
 const parseSquishVersion = (codePath) => {
     const code = fs.readFileSync(codePath, 'utf-8');
 
-    console.log('aiaiaiai');
     const { Parser } = require('acorn');
     const parsed = Parser.parse(code, { ecmaVersion: 'latest', sourceType: 'script' });
-    console.log('balls and ass');
-    console.log(parsed);
-    console.log(parsed.body);
-    console.log(parsed.body.map(n => n.type));
-    console.log(parsed.body.filter(n => n.type === 'ClassDeclaration').superClass);
 
     const foundGameClasses = parsed.body.filter(
         n => n.type === 'ClassDeclaration' && n.superClass && (n.superClass.name === 'Game' || n.superClass.name === 'ViewableGame')
     );
 
-    console.log('found game classes');
-    console.log(foundGameClasses);
-
     if (foundGameClasses.length !== 1) {
         throw new Error('Unable to parse squish version');
     }

package/game-session-manager.js

@@ -84,7 +84,7 @@ class GameSessionManager {
         this.dockerImageName = opts.dockerImageName || 'homegames-runner';
         this.childServerPath = opts.childServerPath || null;
         this.gracePeriodMs = opts.gracePeriodMs || 30000;
-        this.lifecycleCheckMs = opts.lifecycleCheckMs || 10000;
+        this.lifecycleCheckMs = opts.lifecycleCheckMs || 3000;
         this.forgejo = opts.forgejo || {};
         this.saveDataRoot = opts.saveDataRoot || path.join(os.tmpdir(), 'hg-save-data');
         this.assetCachePath = opts.assetCachePath || null;
@@ -368,6 +368,8 @@ class GameSessionManager {
                 execArgv: ['--max-old-space-size=64'],
             });
 
+            this._attachForkLogForwarding(child);
+
             child.send(JSON.stringify({
                 key: input.gameKey || path.basename(gamePath, '.js'),
                 squishVersion,
@@ -433,6 +435,38 @@ class GameSessionManager {
         });
     }
 
+    // -----------------------------------------------------------------------
+    // Forward forked child stdout/stderr to the parent terminal.
+    // Docker sessions are excluded — use GET /sessions/:id/logs or docker logs.
+    // -----------------------------------------------------------------------
+    _attachForkLogForwarding(child) {
+        const emitLine = (line) => {
+            if (!line) return;
+            console.log(`session log: ${line}`);
+        };
+
+        const attachStream = (stream) => {
+            if (!stream) return;
+            let buffer = '';
+            stream.on('data', (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    emitLine(line);
+                }
+            });
+            stream.on('end', () => {
+                if (buffer.length > 0) {
+                    emitLine(buffer);
+                }
+            });
+        };
+
+        attachStream(child.stdout);
+        attachStream(child.stderr);
+    }
+
     // -----------------------------------------------------------------------
     // Find the project root (nearest ancestor with node_modules or package.json)
     // so we mount enough of the tree for relative requires to work.
@@ -525,10 +559,30 @@ class GameSessionManager {
 
             if (s.type === 'docker') {
                 const running = await isContainerRunning(s.containerId);
-                this.log.info(`Session ${sessionId} lifecycle check: container running = ${running}`);
                 if (!running) {
                     this.log.info(`Session ${sessionId} container exited`);
                     this._cleanupSession(sessionId);
+                    return;
+                }
+
+                // Check player count — stop container if empty past grace period
+                try {
+                    const healthData = await this._querySessionHealth(s.port);
+                    const playerCount = healthData && healthData.playerCount !== undefined ? healthData.playerCount : -1;
+                    if (playerCount === 0) {
+                        s._emptyTicks++;
+                        const emptyMs = s._emptyTicks * this.lifecycleCheckMs;
+                        if (emptyMs >= this.gracePeriodMs) {
+                            this.log.info(`Session ${sessionId} empty for ${emptyMs}ms, stopping`);
+                            await stopContainer(s.containerId);
+                            this._cleanupSession(sessionId);
+                            return;
+                        }
+                    } else if (playerCount > 0) {
+                        s._emptyTicks = 0;
+                    }
+                } catch (e) {
+                    // Health check failed — container might be starting up, ignore
                 }
             } else if (s.type === 'fork') {
                 // For fork sessions, send heartbeat. The child_game_server.js
@@ -559,6 +613,28 @@ class GameSessionManager {
         this._cleanupSession(sessionId);
     }
 
+    _querySessionHealth(port) {
+        return new Promise((resolve) => {
+            const req = http.request({
+                hostname: 'localhost',
+                port,
+                path: '/health',
+                method: 'GET',
+                timeout: 2000,
+            }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => { data += chunk; });
+                res.on('end', () => {
+                    try { resolve(JSON.parse(data)); }
+                    catch (e) { resolve(null); }
+                });
+            });
+            req.on('error', () => resolve(null));
+            req.on('timeout', () => { req.destroy(); resolve(null); });
+            req.end();
+        });
+    }
+
     _cleanupSession(sessionId) {
         const session = this.sessions[sessionId];
         if (!session) return;

package/game-session.js

@@ -91,6 +91,7 @@ class GameSession {
         this.squisher.addListener(() => this._broadcastState());
 
         this.gameMetadata = (typeof game.constructor.metadata === 'function') ? game.constructor.metadata() : {};
+        this.maxPlayers = this.gameMetadata.maxPlayers || 64;
         this.aspectRatio = this.gameMetadata.aspectRatio || { x: 16, y: 9 };
 
         // Player / spectator maps  —  values are raw WebSocket objects
@@ -128,6 +129,12 @@ class GameSession {
     // -----------------------------------------------------------------------
 
     addPlayer(playerId, ws, playerOpts = {}) {
+        // Reject if the game is at capacity
+        if (Object.keys(this.players).length >= this.maxPlayers) {
+            try { ws.close(); } catch (e) {}
+            throw new Error('Game is full');
+        }
+
         // If this ID is already connected, disconnect the old one first
         if (this.players[playerId]) {
             this.removePlayer(playerId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homegames-common",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Homegames common tools",
   "main": "index.js",
   "scripts": {