@yyyu-star/arcade-kit 0.13.0 → 0.14.0

package/src/room.ts

@@ -18,7 +18,7 @@
  */
 import { DurableObject } from 'cloudflare:workers';
 import type { RoomEffect, RoomGame, RoomSetup } from './game.js';
-import { type Identity, KIT_HOST, meterStub, parseIdentity } from './internal.js';
+import { type Identity, KIT_HOST, LIMITED_HEADER, MISS_HEADER, meterStub, parseIdentity } from './internal.js';
 import type { MeterEnv, MeterLevel, RoomMeter } from './meter.js';
 import { ENTROPY_WORDS } from './rng.js';
 import {
@@ -60,7 +60,9 @@ export interface RoomLimits {
    * 这些重连同时算进 maxInbound，房间一生的写入总数有上限
    */
   maxJoins: number;
-  /** 没入座的连接最多几条（来看的、还没选座位的），超了 4003。入座的人不占这个数，掉线回来总能进 */
+  /**
+   * 没入座的人最多几个（来看的、还没选座位的），超了 4003。按账号算（0.14.0，以前按连接）；入座的人、房主、开打后绑过座位的人不占这个数，掉线回来总能进
+   */
   extraConnections: number;
   /** 房间最长寿命 */
   maxLifeMs: number;
@@ -119,6 +121,8 @@ export const DEFAULT_LIMITS: RoomLimits = {
 
 /** 闹钟里出错时，过这么久再醒来重试（不用"马上"，免得每次都出错时连着计费）。 */
 const ALARM_RETRY_MS = 60_000;
+/** setAlarm 一次最多试几回（0.13.1）：存储一时出错当场再试一次，不等下一个入口 */
+const SET_ALARM_TRIES = 2;
 /** 每个座位记住最近几个做成的 moveId（0.11.1）：客户端断线时攒着没确认的操作，重连后原样补发 */
 const RECENT_MOVES = 8;
 
@@ -309,7 +313,8 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
   private alarmToSet: number | null = null;
   private pendingInbound = 0;
   private readonly pendingBy = new Map<string, number>();
-  private readonly buckets = new WeakMap<WebSocket, { tokens: number; at: number }>();
+  /** 入站消息的令牌桶，按 userId 记（0.14.0；以前按连接，断开重连就换一个满的桶，第三轮审计） */
+  private readonly buckets = new Map<string, { tokens: number; at: number }>();
   /** 每个座位快捷短语的令牌桶（内存里；被驱逐就重置成满的，驱逐前至少空闲了一阵，本来也该满了） */
   private readonly emoteBuckets = new Map<number, { tokens: number; at: number }>();
   private emoteRateCache: EmoteRate | null = null;
@@ -387,6 +392,8 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     }
     const me = parseIdentity(request.headers.get('x-kit-user'));
     if (!me) return new Response('no identity', { status: 401 });
+    // 猜码超了门槛（0.14.0）：自己人照常进（断线重连不受牵连），别人不管房间在不在都回 1013，说不出房间在不在
+    if (request.headers.has(LIMITED_HEADER) && !this.insider(me.userId)) return this.refuse(CLOSE.tryLater);
     const gate = await this.newcomerGate(me.userId);
     if (gate !== null) return this.refuse(gate);
     return this.entry(() => this.join(me, url.searchParams.get('cv')));
@@ -461,26 +468,56 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     this.totalWrites += this.writes;
     this.unmetered += this.writes;
     this.maxStepWrites = Math.max(this.maxStepWrites, this.writes);
-    if (at !== null && !(await this.setAlarmSafely(at))) this.lastStepFailed = true;
+    if (at !== null && !(await this.setAlarmSafely(at))) {
+      this.lastStepFailed = true;
+      await this.recoverAlarm();
+    }
     await this.afterStep();
     return out;
   }
 
   /**
-   * 设闹钟；失败了不往外抛（0.11.1）。planAlarm 已经把 alarmAt 改成了新时间，失败时它就是错的：
-   * 留着的话以后 planAlarm 看"已经设了更早的"一直不重设，房间就没人收场。改回"不知道"，下一个入口按 getAlarm() 重新读、照常重排
+   * 这一步要设的闹钟两次都没设上（0.13.1，第三轮审计）：按 getAlarm() 核对存储里还有没有闹钟（以前设的更早的那个可能还在）；
+   * 有就以它为准，没有而房间还在，就补一个 ALARM_RETRY_MS 后的，醒来时 onAlarm 按状态重新算（到点的照常处理）。
+   * 以前只靠下一个入口重排：全是电脑、大家都在等时限的房间没人发消息，就一直停着，不关房、结回也不重试。
+   * 补设也失败（存储一直坏着）就只剩浏览器的看门狗（RoomClient）重连来叫醒。读不了存储时不抛（入口里不往外抛）
    */
-  private async setAlarmSafely(at: number): Promise<boolean> {
+  private async recoverAlarm(): Promise<void> {
     try {
-      await this.ctx.storage.setAlarm(at);
-      return true;
+      if (!this.load()) return;
+      const cur = await this.ctx.storage.getAlarm();
+      if (cur !== null) {
+        this.alarmAt = cur;
+        return;
+      }
+      // 不另记一行：这一步的那次 setAlarm 已经记过了，它没写成，补设的这次顶替它
+      this.alarmAt = Date.now() + ALARM_RETRY_MS;
+      await this.setAlarmSafely(this.alarmAt);
     } catch (e) {
-      console.error('room setAlarm failed', e instanceof Error ? e.message : e);
+      console.error('room alarm recovery failed', e instanceof Error ? e.message : e);
       this.alarmAt = undefined;
-      return false;
     }
   }
 
+  /**
+   * 设闹钟；失败了不往外抛（0.11.1）。存储一时出错大多下一次就好，所以当场再试一次（0.13.1）；还不行：
+   * planAlarm 已经把 alarmAt 改成了新时间，失败时它就是错的，留着的话以后 planAlarm 看"已经设了更早的"一直不重设，房间就没人收场。
+   * 改回"不知道"，下一个入口（任何消息、进房、闹钟）按 getAlarm() 重新读、照常重排。
+   * 一直没人发消息（全是电脑在打、大家都在等时限）时，下一个入口由浏览器的看门狗给（RoomClient：时限过了很久还没有新状态就重连一次）
+   */
+  private async setAlarmSafely(at: number): Promise<boolean> {
+    for (let i = 0; i < SET_ALARM_TRIES; i++) {
+      try {
+        await this.ctx.storage.setAlarm(at);
+        return true;
+      } catch (e) {
+        console.error('room setAlarm failed', i + 1, e instanceof Error ? e.message : e);
+      }
+    }
+    this.alarmAt = undefined;
+    return false;
+  }
+
   // ---------- 计量（0.2.0） ----------
 
   /**
@@ -607,7 +644,8 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     const st = this.load();
     if (!st) {
       server.close(CLOSE.noRoom, 'no room');
-      return done();
+      // 告诉 acceptJoin 这是一次"码不存在"（0.14.0，进房猜码按人、按 IP 计数）；它转给浏览器前去掉这个头
+      return new Response(null, { status: 101, webSocket: client, headers: { [MISS_HEADER]: '1' } });
     }
     if (st.ending) {
       server.close(CLOSE.roomClosed, st.ending.reason);
@@ -621,10 +659,12 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     const seat = this.seatOf(me.userId);
     const others = this.sockets().filter((o) => o !== server && attachmentOf(o));
     const mine = others.filter((o) => attachmentOf(o)!.userId === me.userId);
-    if (seat === null) {
-      // 没入座的连接单独封顶；入座的人不占这个数，旁观的再多也挡不住座位的主人回来
-      const watching = others.filter((o) => o !== server && this.seatOf(attachmentOf(o)!.userId) === null && !mine.includes(o));
-      if (watching.length >= this.limits.extraConnections) {
+    if (seat === null && !this.ownsRoom(st, me.userId)) {
+      // 没入座的单独封顶；入座的人不占这个数，旁观的再多也挡不住座位的主人回来。
+      // 0.14.0（第三轮审计）：按账号数不按连接数（一个人开几个标签页只占一个），房主和开打后绑过座位的人（离座去看的）不占也不受这个限，
+      // 不然几个陌生账号就能占满名额，让房主的朋友连进来选座都进不来
+      const watchers = new Set(others.map((o) => attachmentOf(o)!.userId).filter((u) => u !== me.userId && this.seatOf(u) === null && !this.ownsRoom(st, u)));
+      if (watchers.size >= this.limits.extraConnections) {
         server.close(CLOSE.full, 'room full');
         return done();
       }
@@ -686,7 +726,7 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     if (!st || !me || st.ending) return void ws.close(CLOSE.roomClosed, 'room closed');
     const bytes = typeof message === 'string' ? new TextEncoder().encode(message).byteLength : message.byteLength;
     if (bytes > this.limits.maxMessageBytes) return void ws.close(CLOSE.tooBig, 'message too big');
-    if (!this.takeToken(ws)) return void ws.close(CLOSE.policy, 'too fast');
+    if (!this.takeToken(me.userId)) return void ws.close(CLOSE.policy, 'too fast');
     const counted = this.countInbound(st, me.userId);
     if (counted === 'user') return void ws.close(CLOSE.userQuota, 'too many messages');
     if (counted === 'room') return this.closeRoom();
@@ -1568,6 +1608,17 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     };
   }
 
+  /** 这个房间的自己人：房主、坐着的、开打后绑过座位的。猜码超限时只放他们进（0.14.0） */
+  private insider(userId: string): boolean {
+    const st = this.load();
+    return !!st && (st.host === userId || this.seatOf(userId) !== null || this.boundOf(userId) !== null);
+  }
+
+  /** 房主，或者开打后绑过座位的人：旁观名额不算他们（0.14.0） */
+  private ownsRoom(st: Persist<S>, userId: string): boolean {
+    return st.host === userId || st.owners.includes(userId);
+  }
+
   /** 这个人开打后绑定的座位（离座了也还是它）；还没开打、没坐过为 null。 */
   private boundOf(userId: string): number | null {
     const i = this.st!.owners.indexOf(userId);
@@ -1584,6 +1635,7 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
       you: { seat, bound },
       room: this.roomInfo(),
       view: st.game === null ? null : this.game.view(st.game, seat),
+      now: Date.now(),
       // 有短语的游戏告诉页面限速的节奏（0.7.0），RoomClient 按它排队，用户感觉不到限速
       ...(hasEmotes(this.game.emotes) ? { emote: this.emoteRate() } : {}),
     };
@@ -1592,7 +1644,7 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
   private stateMsg(seat: number | null, bound: number | null, frames: { state: S | null; delay: number }[], ack?: string, quiet = false): DownMsg<V> {
     const st = this.st!;
     const out: Frame<V>[] = frames.map((f) => ({ view: (f.state === null ? null : this.game.view(f.state, seat)) as V, delay: f.delay }));
-    return { t: 'state', seq: st.seq, you: { seat, bound }, room: this.roomInfo(), frames: out, ...(ack ? { ack } : {}), ...(quiet ? { quiet: true as const } : {}) };
+    return { t: 'state', seq: st.seq, you: { seat, bound }, room: this.roomInfo(), frames: out, now: Date.now(), ...(ack ? { ack } : {}), ...(quiet ? { quiet: true as const } : {}) };
   }
 
   /** 按座位过滤后广播：同一个座位（加上绑定的座位，没入座的人各自不同）的消息只算一次。只发给已经收到快照（有 attachment）的连接。 */
@@ -1627,15 +1679,18 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     this.send(ws, { t: 'error', code, ...(moveId ? { moveId } : {}) });
   }
 
-  /** 每个连接一个令牌桶（内存里；被驱逐后重置成满的，驱逐前至少空闲了一阵，本来也该满了）。 */
-  private takeToken(ws: WebSocket): boolean {
+  /**
+   * 每个人一个令牌桶（内存里；被驱逐后重置成满的，驱逐前至少空闲了一阵，本来也该满了）。
+   * 按人不按连接（0.14.0）：断开重连、多开几个标签页都还是同一个桶，刷不出新的 burst
+   */
+  private takeToken(userId: string): boolean {
     const now = Date.now();
-    const b = this.buckets.get(ws) ?? { tokens: this.limits.rateBurst, at: now };
+    const b = this.buckets.get(userId) ?? { tokens: this.limits.rateBurst, at: now };
     b.tokens = Math.min(this.limits.rateBurst, b.tokens + ((now - b.at) / 1000) * this.limits.ratePerSec);
     b.at = now;
     if (b.tokens < 1) return false;
     b.tokens -= 1;
-    this.buckets.set(ws, b);
+    this.buckets.set(userId, b);
     return true;
   }
 }

package/src/table-fun.ts

@@ -49,8 +49,20 @@ export interface FunSeat {
   temper?: FunTemper;
 }
 
+/**
+ * storageKey 的检查（0.13.1）：它就是游戏 id，kit 拿它拼 `<id>.hint.fun`、`<id>.fun.blocked`。同站的几个游戏和平台只靠 `<id>.` 前缀分开存储，
+ * 所以只认游戏 id 的写法（小写字母、数字、连字符，字母或数字开头，最多 32 位）；带点（"guandan." 会拼出 "guandan..fun"）、大写、空串、
+ * 平台自己的前缀 arcade 都不行。不合格直接抛错：同一个字符串每次都一样，开发时第一次打开牌桌就看得到，不会带到线上
+ */
+export function checkStorageKey(key: unknown): string {
+  if (typeof key !== 'string' || !/^[a-z0-9][a-z0-9-]{0,31}$/.test(key) || key === 'arcade') {
+    throw new Error(`arcade-kit/table-fun: storageKey 要写游戏 id（比如 "mygame"，存成 "mygame.hint.fun"），收到 ${JSON.stringify(key)}`);
+  }
+  return key;
+}
+
 export interface TableFunOptions {
-  /** 游戏 id：首次提示、屏蔽名单的存储 key 前缀（`<id>.hint.fun`、`<id>.fun.blocked`） */
+  /** 游戏 id：首次提示、屏蔽名单的存储 key 前缀（`<id>.hint.fun`、`<id>.fun.blocked`）；不是游戏 id 的写法构造时就抛错（checkStorageKey） */
   storageKey: string;
   /** 本游戏的短语表（编号 0..P-1，见 fun-logic 的 funItem） */
   phrases: readonly string[];
@@ -165,6 +177,8 @@ export class TableFun {
   private readonly onResize = (): void => this.refresh();
 
   constructor(opts: TableFunOptions) {
+    // 先查 key 再碰 DOM：不合格的不留下半个界面
+    checkStorageKey(opts.storageKey);
     this.o = opts;
     this.P = opts.phrases.length;
     this.doc = document;

package/src/worker.ts

@@ -13,8 +13,9 @@
 import { identify, sameOrigin } from './auth.js';
 import { type GuestOptions, isStandalone, type ModeEnv } from './guest.js';
 import { CLOSE, type CreateError, ROOM_CODE_RE } from './protocol.js';
-import { identityHeader, type Identity, KIT_HOST, newRoomCode, roomStub } from './internal.js';
-import type { MeterEnv } from './meter.js';
+import { identityHeader, type Identity, KIT_HOST, LIMITED_HEADER, meterStub, MISS_HEADER, missStub, newRoomCode, roomStub } from './internal.js';
+// 只引类型：meter.ts 依赖 cloudflare:workers，游戏会在普通 Node 的测试里加载本文件
+import type { MeterEnv, RoomMeter } from './meter.js';
 import type { CreateOutcome } from './room.js';
 
 /**
@@ -119,11 +120,48 @@ export async function acceptJoin(request: Request, env: KitEnv, code: string, op
   const w = await who(request, env, opts, false);
   if ('error' in w) return w.error === 'anonymous' ? refuse(CLOSE.unauthorized, 'login first') : refuse(CLOSE.tryLater, 'try later');
   const me = w.user;
+  // 进房猜码（0.14.0）：这一小时"码不存在"超了门槛的人（或 IP）带上 LIMITED_HEADER，房间只放自己人进，别人不管房间在不在都回 1013，
+  // 说不出房间在不在；在打的人照常重连。计量连不上时同样处理（和开房一样不放新人进来）
+  const guard = missGuard(env, me.userId, request.headers.get('cf-connecting-ip'));
+  let limited = false;
+  try {
+    limited = !!guard && !(await guard.ok());
+  } catch (e) {
+    console.error('join guard failed', e instanceof Error ? e.message : e);
+    limited = true;
+  }
   // 新建请求，只带认好的身份和客户端版本；浏览器带来的 x-kit-user 之类的头一律不转
   const cv = new URL(request.url).searchParams.get('cv') ?? '0';
-  return roomStub(env.ROOM, code).fetch(`https://${KIT_HOST}/ws?cv=${encodeURIComponent(cv)}`, {
-    headers: { upgrade: 'websocket', 'x-kit-user': identityHeader(me) },
+  const res = await roomStub(env.ROOM, code).fetch(`https://${KIT_HOST}/ws?cv=${encodeURIComponent(cv)}`, {
+    headers: { upgrade: 'websocket', 'x-kit-user': identityHeader(me), ...(limited ? { [LIMITED_HEADER]: '1' } : {}) },
   });
+  if (!res.headers.has(MISS_HEADER)) return res;
+  // 房间说"这个码没有房间"：记一次（按人、按 IP 各 1 行，再报进当天的写入），转给浏览器的回话不带这个内部头
+  if (guard) await guard.miss().catch((e: unknown) => console.error('join miss record failed', e instanceof Error ? e.message : e));
+  return new Response(null, { status: 101, webSocket: res.webSocket });
+}
+
+/**
+ * 按人、按 IP 数"码不存在"（0.14.0，第三轮审计：6 位房间码能一个个试）。没绑 METER（单独部署、测试里没配）就不管，和开房额度一样。
+ * 没有 IP 头（本地开发）只按人算
+ */
+function missGuard(env: KitEnv, userId: string, ip: string | null): { ok(): Promise<boolean>; miss(): Promise<void> } | null {
+  const ns = env.METER;
+  if (!ns) return null;
+  const keys: [string, 'user' | 'ip'][] = [[`u:${userId}`, 'user']];
+  if (ip) keys.push([`ip:${ip}`, 'ip']);
+  const stub = (k: string) => missStub(ns, k) as DurableObjectStub<RoomMeter>;
+  return {
+    async ok() {
+      const blocked = await Promise.all(keys.map(([k, kind]) => stub(k).kitMissBlocked(kind)));
+      return !blocked.includes(true);
+    },
+    async miss() {
+      await Promise.all(keys.map(([k]) => stub(k).kitMiss()));
+      // 这几行也记进当天的写入（计量自己的规矩），报一次计量再写 1 行
+      await (meterStub(ns) as DurableObjectStub<RoomMeter>).kitReport(keys.length);
+    },
+  };
 }
 
 function refuse(code: number, reason: string): Response {