@uzuhq/code-cli 0.3.14

package/dist/dev-server/game-room.js

@@ -0,0 +1,436 @@
+/**
+ * dev-server 版 GameRoom (ServerAction / run() モード用)。
+ *
+ * v3-play-server の `game-worker-template/game-room.ts` (Cloudflare Worker DO 版)
+ * と同一プロトコル (`__game_start` / `__tick` / `__tick_delta` / `__action_result` /
+ * `__action_result_delta` / `__state` / `__room_init` / `__action_error`) を喋る
+ * Node.js 版。 SDK 側の `runOnlineServerAction` client がそのまま接続できる。
+ *
+ * 本番との差分:
+ * - Durable Object storage / hibernation なし (in-memory only)。CLI restart で state 消失。
+ * - WebSocketPair / acceptWebSocket → `ws` package の raw WebSocket + Set 管理
+ * - setWebSocketAutoResponse (__ping/__pong) → message handler で直接返す
+ */
+import { randomUUID } from 'crypto';
+import { compare, applyJsonMergePatch, applyJsonPatch } from './json-patch.js';
+import { SeededRandomImpl } from './random.js';
+export class GameRoom {
+    logic;
+    tickRate;
+    gameState = null;
+    stateInitialized = false;
+    random = null;
+    seed = 0;
+    tickCount = 0;
+    tickTimer = null;
+    tickPaused = false;
+    playerInputs = {};
+    /**
+     * roster (kind 付き)。 spectator / admin 席も含む — logic.setup にはこれを渡す。
+     * dev harness では manifest から組んだ roster を constructor で注入する
+     * (server 権威)。 その場合、 接続クエリの roster 申告は一切採用しないので、
+     * 旧世代 harness page の残タブが reconnect しても roster を汚染できない。
+     * 本番 DO は backend 由来の roster を全 client が同一申告するため接続時
+     * 登録で成立している — 権威が platform 側にある点は同じ。
+     */
+    seats = [];
+    seq = 0;
+    prevBroadcastState = null;
+    static SNAPSHOT_INTERVAL = 20;
+    sockets = new Set();
+    attachments = new WeakMap();
+    snapshotSubscribers = new Set();
+    eventSubscribers = new Set();
+    constructor(logic, seats) {
+        this.logic = logic;
+        this.tickRate = logic.tickRate ?? 0;
+        if (seats && seats.length > 0) {
+            this.seats = seats;
+            console.log(`[GameRoom] 📋 Seats (server-authoritative): ${seats
+                .map((p) => `${p.id}(${p.kind ?? 'player'})`)
+                .join(', ')}`);
+        }
+    }
+    // ─── Broadcast ─────────────────────────────────────────
+    broadcastAll(msg) {
+        const data = JSON.stringify(msg);
+        for (const ws of this.sockets) {
+            try {
+                ws.send(data);
+            }
+            catch {
+                /* disconnected */
+            }
+        }
+    }
+    sendTo(ws, msg) {
+        try {
+            ws.send(JSON.stringify(msg));
+        }
+        catch {
+            /* disconnected */
+        }
+    }
+    broadcastStateDelta(events, extra) {
+        this.seq++;
+        const fullType = extra.ack !== undefined ? '__action_result' : '__tick';
+        const deltaType = extra.ack !== undefined ? '__action_result_delta' : '__tick_delta';
+        const needFull = this.prevBroadcastState === null || this.seq % GameRoom.SNAPSHOT_INTERVAL === 0;
+        if (needFull) {
+            this.broadcastAll({
+                type: fullType,
+                state: this.gameState,
+                events,
+                seq: this.seq,
+                ...extra,
+            });
+        }
+        else {
+            const patches = compare(this.prevBroadcastState, this.gameState);
+            const deltaPayload = JSON.stringify({
+                type: deltaType,
+                patches,
+                events,
+                seq: this.seq,
+                ...extra,
+            });
+            const fullPayload = JSON.stringify({
+                type: fullType,
+                state: this.gameState,
+                events,
+                seq: this.seq,
+                ...extra,
+            });
+            const data = deltaPayload.length < fullPayload.length ? deltaPayload : fullPayload;
+            for (const ws of this.sockets) {
+                try {
+                    ws.send(data);
+                }
+                catch {
+                    /* disconnected */
+                }
+            }
+        }
+        this.prevBroadcastState = structuredClone(this.gameState);
+        this.notifySnapshotSubscribers();
+        if (events.length > 0)
+            this.notifyEventSubscribers(events);
+    }
+    notifySnapshotSubscribers() {
+        this.snapshotSubscribers.forEach((cb) => {
+            try {
+                cb(this.gameState);
+            }
+            catch (err) {
+                console.warn('[GameRoom] snapshot subscriber threw:', err);
+            }
+        });
+    }
+    notifyEventSubscribers(events) {
+        const frozen = Object.freeze(events.slice());
+        this.eventSubscribers.forEach((cb) => {
+            try {
+                cb(frozen);
+            }
+            catch (err) {
+                console.warn('[GameRoom] event subscriber threw:', err);
+            }
+        });
+    }
+    // ─── Game Lifecycle ────────────────────────────────────
+    maybeStartGame() {
+        if (this.gameState !== null)
+            return;
+        if (this.seats.length === 0)
+            return;
+        this.seed = Date.now() & 0xffffffff;
+        this.random = new SeededRandomImpl(this.seed);
+        this.gameState = this.logic.setup(this.seats, this.random);
+        this.stateInitialized = true;
+        this.tickCount = 0;
+        this.seq = 0;
+        this.prevBroadcastState = structuredClone(this.gameState);
+        console.log(`[GameRoom] ✅ Game started with ${this.seats.filter((p) => p.kind === 'player').length} players (${this.seats.length} seats)`);
+        this.broadcastAll({
+            type: '__game_start',
+            state: this.gameState,
+            seed: this.seed,
+            seq: 0,
+        });
+        if (this.tickRate > 0)
+            this.startTickLoop();
+        this.notifySnapshotSubscribers();
+    }
+    startTickLoop() {
+        if (this.tickTimer)
+            clearInterval(this.tickTimer);
+        this.tickTimer = setInterval(() => this.tick(), 1000 / this.tickRate);
+    }
+    // 全クライアント切断で tickTimer は止まる (handleClose) が gameState は残るため、
+    // 再接続や reset で「動いているべきなのに止まっている」状態を復旧する。
+    ensureTickLoop() {
+        if (this.tickRate > 0 &&
+            this.gameState !== null &&
+            this.sockets.size > 0 &&
+            !this.tickPaused &&
+            !this.tickTimer) {
+            this.startTickLoop();
+        }
+    }
+    tick() {
+        if (this.tickPaused)
+            return;
+        this.runOneTick();
+    }
+    runOneTick() {
+        if (!this.gameState || !this.random)
+            return;
+        const events = [];
+        const emit = (name, data) => events.push({ name, data: data ?? {} });
+        try {
+            this.logic.update(this.gameState, {
+                random: this.random,
+                tick: this.tickCount,
+                emit,
+                playerInputs: this.playerInputs,
+            });
+        }
+        catch (err) {
+            console.error(`[GameRoom] tick error at tick=${this.tickCount}:`, err);
+            this.tickCount++;
+            return;
+        }
+        this.tickCount++;
+        this.broadcastStateDelta(events, { tick: this.tickCount });
+    }
+    // ─── Connection ────────────────────────────────────────
+    handleConnection(ws, url) {
+        const playerId = url.searchParams.get('seatId');
+        if (!playerId) {
+            ws.close(1008, 'Missing required query parameter: seatId');
+            return;
+        }
+        const nickname = url.searchParams.get('nickname') ?? 'Guest';
+        const connectionId = randomUUID();
+        if (this.seats.length === 0) {
+            // constructor 注入 (server 権威) が無い場合のみ、 接続クエリの申告 roster に
+            // fallback する (本番 DO と同じ経路)。 dev harness では常に注入済みなので
+            // ここは通らない。
+            const rosterParam = url.searchParams.get('seats');
+            if (rosterParam) {
+                try {
+                    const raw = JSON.parse(rosterParam);
+                    if (Array.isArray(raw)) {
+                        this.seats = raw.map((p) => ({
+                            id: p.id,
+                            nickname: p.name ?? 'Guest',
+                            iconUrl: p.iconUrl ?? '',
+                            characterId: p.characterId,
+                            kind: p.kind,
+                        }));
+                        console.log(`[GameRoom] 📋 Seats registered: ${this.seats
+                            .map((p) => `${p.id}(${p.kind})`)
+                            .join(', ')}`);
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        console.log(`[GameRoom] 🔗 New connection: connectionId=${connectionId} playerId=${playerId} nickname=${nickname}`);
+        this.sockets.add(ws);
+        this.attachments.set(ws, { connectionId, playerId, nickname });
+        ws.on('message', (raw) => {
+            void this.handleMessage(ws, raw.toString());
+        });
+        ws.on('close', () => this.handleClose(ws));
+        ws.on('error', () => this.handleClose(ws));
+        this.sendTo(ws, {
+            type: '__room_init',
+            myId: playerId,
+        });
+        if (this.stateInitialized && this.gameState !== null) {
+            this.sendTo(ws, {
+                type: '__state',
+                state: this.gameState,
+                tick: this.tickCount,
+                seq: this.seq,
+            });
+        }
+        this.maybeStartGame();
+        // 既存ゲームへの再接続では maybeStartGame は early-return するので、
+        // 全切断で止まった tick loop をここで復旧する。
+        this.ensureTickLoop();
+    }
+    async handleMessage(ws, msg) {
+        const attachment = this.attachments.get(ws);
+        if (!attachment)
+            return;
+        const senderId = attachment.playerId;
+        let parsed;
+        try {
+            parsed = JSON.parse(msg);
+        }
+        catch {
+            return;
+        }
+        const msgType = parsed.type;
+        if (msgType === '__ping') {
+            this.sendTo(ws, { type: '__pong' });
+            return;
+        }
+        console.log(`[GameRoom] ⬅ recv from=${senderId} type=${msgType}`);
+        if (msgType === '__action') {
+            if (!this.gameState) {
+                this.sendTo(ws, {
+                    type: '__action_error',
+                    error: 'Game not started',
+                    seq: parsed.seq,
+                });
+                return;
+            }
+            const actionName = parsed.action;
+            const payload = parsed.payload ?? {};
+            const seq = parsed.seq;
+            try {
+                await this.dispatchAction(actionName, payload, senderId, seq);
+            }
+            catch (err) {
+                this.sendTo(ws, {
+                    type: '__action_error',
+                    error: `Action failed: ${err instanceof Error ? err.message : 'unknown'}`,
+                    seq,
+                });
+            }
+            return;
+        }
+        if (msgType === '__request_state') {
+            if (this.gameState !== null) {
+                this.sendTo(ws, {
+                    type: '__state',
+                    state: this.gameState,
+                    tick: this.tickCount,
+                    seq: this.seq,
+                });
+            }
+            return;
+        }
+        if (msgType === '__input') {
+            const inputData = parsed.data;
+            if (inputData)
+                this.playerInputs[senderId] = inputData;
+            return;
+        }
+    }
+    async dispatchAction(actionName, payload, senderId, ackSeq) {
+        const handler = this.logic.actions[actionName];
+        if (!handler) {
+            throw new Error(`Unknown action: ${actionName}`);
+        }
+        if (!this.gameState) {
+            throw new Error('Game not started');
+        }
+        const events = [];
+        const emit = (name, data) => events.push({ name, data: data ?? {} });
+        await handler(this.gameState, payload ?? {}, senderId, emit, { tick: this.tickCount });
+        this.broadcastStateDelta(events, { ack: ackSeq, from: senderId });
+    }
+    handleClose(ws) {
+        const attachment = this.attachments.get(ws);
+        if (!attachment)
+            return;
+        console.log(`[GameRoom] ❌ Disconnected: connectionId=${attachment.connectionId} playerId=${attachment.playerId}`);
+        this.sockets.delete(ws);
+        this.attachments.delete(ws);
+        delete this.playerInputs[attachment.playerId];
+        if (this.sockets.size === 0 && this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+    }
+    // ─── Admin API (parent frame __uzu_dev から使う) ──────────────────
+    admin() {
+        return {
+            getSnapshot: () => this.gameState,
+            getRawState: () => this.gameState,
+            setRawState: (next) => {
+                this.gameState = next;
+                this.broadcastStateDelta([], { tick: this.tickCount });
+            },
+            mergeRawState: (patch) => {
+                if (!this.gameState)
+                    return;
+                applyJsonMergePatch(this.gameState, patch);
+                this.broadcastStateDelta([], { tick: this.tickCount });
+            },
+            patchRawState: (ops) => {
+                if (!this.gameState)
+                    return;
+                applyJsonPatch(this.gameState, ops);
+                this.broadcastStateDelta([], { tick: this.tickCount });
+            },
+            sendAction: async ({ as, type, payload }) => {
+                await this.dispatchAction(type, payload, as);
+            },
+            getSeed: () => this.seed,
+            pauseTick: () => {
+                if (this.tickRate <= 0)
+                    return;
+                this.tickPaused = true;
+            },
+            resumeTick: () => {
+                if (this.tickRate <= 0)
+                    return;
+                this.tickPaused = false;
+            },
+            stepTick: (n = 1) => {
+                if (this.tickRate <= 0)
+                    return;
+                if (!Number.isInteger(n) || n < 0) {
+                    throw new RangeError(`stepTick: n must be a non-negative integer (got ${n})`);
+                }
+                for (let i = 0; i < n; i++)
+                    this.runOneTick();
+            },
+            getCurrentTick: () => this.tickCount,
+            isTickPaused: () => this.tickPaused,
+            reset: (opts) => {
+                if (opts?.seed === 'random') {
+                    this.seed = Math.floor(Math.random() * 0xffffffff);
+                }
+                else if (typeof opts?.seed === 'number') {
+                    this.seed = opts.seed;
+                }
+                this.random = new SeededRandomImpl(this.seed);
+                this.gameState = this.logic.setup(this.seats, this.random);
+                this.tickCount = 0;
+                // reset は新規ゲーム = 実行可能状態を意味するので pause も解除する。
+                this.tickPaused = false;
+                this.seq = 0;
+                this.prevBroadcastState = structuredClone(this.gameState);
+                this.broadcastAll({
+                    type: '__game_start',
+                    state: this.gameState,
+                    seed: this.seed,
+                    seq: 0,
+                });
+                this.notifySnapshotSubscribers();
+                // 全切断中に reset された後の再接続でも tick が回るよう復旧する。
+                this.ensureTickLoop();
+            },
+            subscribeSnapshot: (cb) => {
+                this.snapshotSubscribers.add(cb);
+                return () => {
+                    this.snapshotSubscribers.delete(cb);
+                };
+            },
+            subscribeEvents: (cb) => {
+                this.eventSubscribers.add(cb);
+                return () => {
+                    this.eventSubscribers.delete(cb);
+                };
+            },
+        };
+    }
+}

package/dist/dev-server/game-types.js

@@ -0,0 +1,11 @@
+/**
+ * @docs
+ * - ServerAction仕様: docs/docs/play_screen_v3/connection-method/arch3-authority.md
+ *
+ * Node 側 dev-server 用の game type 定義。
+ * SDK `src/types.ts` および v3-play-server `game-worker-template/game-types.ts` と
+ * 同一 shape。 CLI は browser 依存 (window etc) を持たない Node 環境で走るので、
+ * SDK を直接 import できず、game-worker-template と同じく copy を持つ。
+ * 3 か所いずれかを変更したら他 2 か所も同期させること。
+ */
+export {};

package/dist/dev-server/json-patch.js

@@ -0,0 +1,114 @@
+/**
+ * JSON Patch ユーティリティ。
+ * SDK `src/json-patch.ts` および v3-play-server `game-worker-template/json-patch.ts`
+ * と同一。 3 か所いずれかを変更したら他 2 か所も同期させること。
+ */
+function escapePointer(key) {
+    return key.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function unescapePointer(token) {
+    return token.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+export function compare(oldObj, newObj, basePath = '') {
+    if (oldObj === newObj)
+        return [];
+    if (oldObj === null ||
+        newObj === null ||
+        typeof oldObj !== 'object' ||
+        typeof newObj !== 'object') {
+        return [{ op: 'replace', path: basePath || '/', value: newObj }];
+    }
+    if (Array.isArray(oldObj) || Array.isArray(newObj)) {
+        if (JSON.stringify(oldObj) === JSON.stringify(newObj))
+            return [];
+        return [{ op: 'replace', path: basePath || '/', value: newObj }];
+    }
+    const ops = [];
+    const oldKeys = Object.keys(oldObj);
+    const newKeys = Object.keys(newObj);
+    for (const key of oldKeys) {
+        if (!(key in newObj)) {
+            ops.push({ op: 'remove', path: `${basePath}/${escapePointer(key)}` });
+        }
+    }
+    for (const key of newKeys) {
+        const childPath = `${basePath}/${escapePointer(key)}`;
+        if (!(key in oldObj)) {
+            ops.push({ op: 'add', path: childPath, value: newObj[key] });
+        }
+        else {
+            const childOps = compare(oldObj[key], newObj[key], childPath);
+            ops.push(...childOps);
+        }
+    }
+    return ops;
+}
+export function applyPatch(doc, ops) {
+    for (const op of ops) {
+        const tokens = op.path.split('/').slice(1).map(unescapePointer);
+        if (tokens.length === 0)
+            return false;
+        if (op.op === 'replace' || op.op === 'add') {
+            let target = doc;
+            for (let i = 0; i < tokens.length - 1; i++) {
+                target = target?.[tokens[i]];
+                if (target === undefined || target === null)
+                    return false;
+            }
+            const lastKey = tokens[tokens.length - 1];
+            target[lastKey] = op.value;
+        }
+        else if (op.op === 'remove') {
+            let target = doc;
+            for (let i = 0; i < tokens.length - 1; i++) {
+                target = target?.[tokens[i]];
+                if (target === undefined || target === null)
+                    return false;
+            }
+            const lastKey = tokens[tokens.length - 1];
+            if (Array.isArray(target)) {
+                target.splice(Number(lastKey), 1);
+            }
+            else {
+                delete target[lastKey];
+            }
+        }
+    }
+    return true;
+}
+const MERGE_PATCH_ARRAY_REJECT = '[applyJsonMergePatch] cannot merge a non-array patch into an array target';
+export function applyJsonMergePatch(target, patch) {
+    if (patch === null || typeof patch !== 'object' || Array.isArray(patch))
+        return;
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            continue;
+        if (value === null) {
+            target[key] = null;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            target[key] = value;
+            continue;
+        }
+        if (typeof value === 'object') {
+            const existing = target[key];
+            if (Array.isArray(existing)) {
+                throw new Error(MERGE_PATCH_ARRAY_REJECT);
+            }
+            if (existing === null || typeof existing !== 'object') {
+                target[key] = value;
+                continue;
+            }
+            applyJsonMergePatch(existing, value);
+            continue;
+        }
+        target[key] = value;
+    }
+}
+export function applyJsonPatch(target, ops) {
+    const ok = applyPatch(target, ops);
+    if (!ok) {
+        throw new Error('[applyJsonPatch] failed to apply one or more operations');
+    }
+}

package/dist/dev-server/load-logic.js

@@ -0,0 +1,70 @@
+/**
+ * scenario の `serverActionLogicPath` (TS ファイル) を esbuild で bundle し、
+ * Node 側で dynamic import して `GameLogic` を返す。
+ *
+ * `@uzuhq/code-sdk` は browser 依存 (window global 参照) を top-level に持つため
+ * Node runtime で直接 import すると `ReferenceError: window is not defined` で落ちる。
+ * esbuild の virtual module plugin で SDK を server-safe な stub に置換して bundle に
+ * inline する (`serverOnly` / `isServerOnlyAction` / `SERVER_TIME` だけを提供)。
+ */
+import { build } from 'esbuild';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
+const uzuSdkServerStub = {
+    name: 'uzu-sdk-server-stub',
+    setup(build) {
+        // @uzupj/uzu-sdk は旧パッケージ名。移行が済んでいない scenario でも動くよう両対応する
+        build.onResolve({ filter: /^(@uzuhq\/code-sdk|@uzupj\/uzu-sdk)$/ }, (args) => ({
+            path: args.path,
+            namespace: 'uzu-sdk-stub',
+        }));
+        build.onLoad({ filter: /.*/, namespace: 'uzu-sdk-stub' }, () => ({
+            contents: `
+        export function serverOnly(fn) {
+          fn.__serverOnly = true;
+          return fn;
+        }
+        export function isServerOnlyAction(handler) {
+          return handler && handler.__serverOnly === true;
+        }
+        export const SERVER_TIME = '__SERVER_TIME__';
+        export const DEFAULT_ICON_URLS = [];
+      `,
+            loader: 'js',
+        }));
+    },
+};
+export async function loadLogicFromPath(logicPath) {
+    const absPath = resolve(logicPath);
+    const tempDir = mkdtempSync(join(tmpdir(), 'uzu-dev-logic-'));
+    const outPath = join(tempDir, 'logic.mjs');
+    await build({
+        entryPoints: [absPath],
+        outfile: outPath,
+        bundle: true,
+        format: 'esm',
+        target: 'es2022',
+        platform: 'neutral',
+        plugins: [uzuSdkServerStub],
+    });
+    const mod = (await import(pathToFileURL(outPath).href));
+    const logic = mod.default ?? mod.logic;
+    if (!logic) {
+        throw new Error(`${logicPath} must export a GameLogic object.\n` +
+            `  Use either: export default logic\n` +
+            `  Or:         export const logic: GameLogic<State> = { ... }`);
+    }
+    return {
+        logic,
+        dispose: () => {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore */
+            }
+        },
+    };
+}

package/dist/dev-server/random.js

@@ -0,0 +1,35 @@
+export class SeededRandomImpl {
+    _state;
+    constructor(seed) {
+        this._state = seed | 0;
+    }
+    get state() {
+        return this._state;
+    }
+    static fromState(state) {
+        const r = new SeededRandomImpl(0);
+        r._state = state;
+        return r;
+    }
+    float() {
+        this._state |= 0;
+        this._state = (this._state + 0x6d2b79f5) | 0;
+        let t = Math.imul(this._state ^ (this._state >>> 15), 1 | this._state);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    int(max) {
+        return Math.floor(this.float() * max);
+    }
+    pick(array) {
+        return array[this.int(array.length)];
+    }
+    shuffle(array) {
+        const a = [...array];
+        for (let i = a.length - 1; i > 0; i--) {
+            const j = this.int(i + 1);
+            [a[i], a[j]] = [a[j], a[i]];
+        }
+        return a;
+    }
+}