@zaisma/game-server 1.1.0 → 1.2.0

package/bin/node-parts.js

@@ -12,14 +12,29 @@ const MAXIMUM_PROFILE_COUNT = 10_000;
 /** The format the runner's saved room states are written in. A file with another is dropped, and rooms start fresh. */
 const ROOM_STATES_FORMAT_VERSION_NUMBER = 1;
 
-/** Fetch the public keys a JWKS URL publishes, caching them for an hour (fetched again at once when asked to refresh). */
+/** A refresh asked for by a pass with a key ID not in the cache waits this long after the last fetch, so passes with made-up key IDs can't make this fetch on every hello. */
+const MINIMUM_REFRESH_INTERVAL_MS = 30_000;
+
+/**
+ * Fetch the public keys a JWKS URL publishes, caching them for an hour (fetched again at once when asked to refresh,
+ * at most once in MINIMUM_REFRESH_INTERVAL_MS). A fetch that fails keeps answering with the keys already held.
+ */
 function keysFrom(jwksUrl) {
   let cache = null;
+  let fetchedAtMs = 0;
   return async (isRefreshing = false) => {
-    if (cache && !isRefreshing && Date.now() - cache.fetchedAtMs < KEYS_KEPT_MS) return cache.keys;
-    const response = await fetch(jwksUrl);
-    if (!response.ok) throw new Error(`Couldn't load Zaisma's keys from ${jwksUrl}`);
-    cache = { fetchedAtMs: Date.now(), keys: (await response.json()).keys };
+    const nowMs = Date.now();
+    if (cache && !isRefreshing && nowMs - cache.fetchedAtMs < KEYS_KEPT_MS) return cache.keys;
+    if (cache && isRefreshing && nowMs - fetchedAtMs < MINIMUM_REFRESH_INTERVAL_MS) return cache.keys;
+    fetchedAtMs = nowMs;
+    try {
+      const response = await fetch(jwksUrl);
+      if (!response.ok) throw new Error(`Couldn't load Zaisma's keys from ${jwksUrl}`);
+      cache = { fetchedAtMs: nowMs, keys: (await response.json()).keys };
+    } catch (error) {
+      if (cache) return cache.keys;
+      throw error;
+    }
     return cache.keys;
   };
 }

package/bin/node.js

@@ -23,8 +23,12 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { resolve } from "node:path";
 import { realpathSync } from "node:fs";
 import { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, ERROR_TEXT, NO_ANSWER_CLOSE_CODE, PASS_ISSUER_URL, PassError, ReceiptError, REMOVED_CLOSE_CODE, REQUEST_ERROR_HTTP_STATUS, REQUEST_LIMITS, ROOM_LIMITS, ROOM_TUNING, WEBHOOK_LIMITS, GameServerError, RoomCore, restoreInfoOf, passesAreFriends, passesHaveBlockBetween, answerRequest, startSchedules, checkRoomData, clientIdle, defineGameServer, errorMessage, isRoomCode, readRequestBody, relay, requestError, runWebhook, tidyRoomInfo, verifyPass, verifyReceipt, verifyWebhook } from "../src/internal.js";
+import { OutsideCallError } from "../src/outside-calls.js";
 import { checkedStartServerOptions, localDatabase, localRoomStates, passKeysFrom, profilesFrom, receiptKeysFrom, secretsFromEnvironment } from "./node-parts.js";
 
+// Code that names OutsideCallError, as Zaisma's sandbox lets it, moves unchanged: nothing here refuses a call, so instanceof is simply false.
+globalThis.OutsideCallError ??= OutsideCallError;
+
 const HELLO_MS = 5000;
 /**
  * How often rooms check on their players (idle, hidden, held seats, players whose time to reconnect ran
@@ -447,7 +451,7 @@ export function startServer(options) {
     const helloTimer = setTimeout(() => playerId || refuse("no_hello"), HELLO_MS);
     ws.zaismaSeenAtMs = Date.now();
 
-    ws.on("message", async (received, isBinary) => {
+    const onMessage = async (received, isBinary) => {
       const text = isBinary ? null : received.toString();
       ws.zaismaSeenAtMs = Date.now();
       // Games ping every 25 seconds or so, so a connection that stops answering can be dropped.
@@ -518,6 +522,13 @@ export function startServer(options) {
       playerId = player.id;
       room.waiting = false;
       pace(code, room);
+    };
+    // Whatever a message hits, it ends that connection or that message, never the process and the matches on it.
+    ws.on("message", (received, isBinary) => {
+      onMessage(received, isBinary).catch((error) => {
+        console.error("Couldn't handle a message:", error);
+        if (!playerId) refuse("busy");
+      });
     });
 
     // A frame over the size limit (or a broken one) is an error on this one socket: it closes and the close handler below takes it out, the runner keeps going.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaisma/game-server",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Run your Zaisma game server: the same rooms on Zaisma or on your own server.",
   "license": "MIT",
   "homepage": "https://zaisma.com",

package/src/schedules.js

@@ -159,7 +159,9 @@ const MAXIMUM_TIMER_MS = 24 * 3_600_000;
 export function startSchedules(handler, server, onFailure) {
     const timers = new Set();
     let isStopped = false;
-    for (const schedule of handler.schedules ?? []) {
+    // Run from the checked list, so run.cron is the tidied cron on every runtime (get_stats lists it that way too).
+    const read = readSchedules(handler.schedules, typeof handler.onSchedule === "function");
+    for (const schedule of "schedules" in read ? read.schedules : []) {
         const plan = (afterMs) => {
             const atMs = nextRunAtMs(schedule.cron, afterMs);
             if (atMs === null || isStopped)