@uzuhq/code-cli 0.3.14

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

@@ -0,0 +1,268 @@
+/**
+ * dev-server 版 SyncRoom (sync() モード用)。
+ *
+ * v3-play-server の `sync-room.ts` (Cloudflare Worker DO 版) と同一プロトコル
+ * (`__state` / `__patch_ack` / `__patch_failed` / `__state_cleared` / `__init_state` /
+ * `__patch` / `__request_state` / `__clear_state` / `__room_init`) を喋る Node.js 版。
+ * SDK 側の `syncOnline` client がそのまま接続できる。
+ */
+import { randomUUID } from 'crypto';
+import { applyPatch, applyJsonMergePatch, applyJsonPatch } from './json-patch.js';
+const SERVER_TIME_SENTINEL = '__SERVER_TIME__';
+function resolveServerTime(ops, now) {
+    for (const op of ops) {
+        if (op.value === SERVER_TIME_SENTINEL) {
+            op.value = now;
+        }
+    }
+}
+export class SyncRoom {
+    cachedState = null;
+    stateInitialized = false;
+    seq = 0;
+    patchesSinceReconciliation = 0;
+    static RECONCILIATION_INTERVAL = 30;
+    sockets = new Set();
+    attachments = new WeakMap();
+    snapshotSubscribers = new Set();
+    broadcastFullState() {
+        if (!this.stateInitialized || this.cachedState === null)
+            return;
+        const stateMsg = JSON.stringify({
+            type: '__state',
+            state: this.cachedState,
+            seq: this.seq,
+            serverTime: Date.now(),
+        });
+        for (const peer of this.sockets) {
+            try {
+                peer.send(stateMsg);
+            }
+            catch {
+                /* disconnected */
+            }
+        }
+        this.notifySnapshotSubscribers();
+    }
+    notifySnapshotSubscribers() {
+        this.snapshotSubscribers.forEach((cb) => {
+            try {
+                cb(this.cachedState);
+            }
+            catch (err) {
+                console.warn('[SyncRoom] snapshot subscriber threw:', err);
+            }
+        });
+    }
+    handleConnection(ws, url) {
+        const playerId = url.searchParams.get('playerId');
+        if (!playerId) {
+            ws.close(1008, 'Missing required query parameter: playerId');
+            return;
+        }
+        const connectionId = randomUUID();
+        console.log(`[SyncRoom] 🔗 New connection: connectionId=${connectionId} playerId=${playerId}`);
+        this.sockets.add(ws);
+        this.attachments.set(ws, { connectionId, playerId });
+        ws.on('message', (raw) => this.handleMessage(ws, raw.toString()));
+        ws.on('close', () => this.handleClose(ws));
+        ws.on('error', () => this.handleClose(ws));
+        ws.send(JSON.stringify({ type: '__room_init', myId: playerId }));
+        if (this.stateInitialized && this.cachedState !== null) {
+            ws.send(JSON.stringify({
+                type: '__state',
+                state: this.cachedState,
+                seq: this.seq,
+                serverTime: Date.now(),
+            }));
+        }
+    }
+    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') {
+            try {
+                ws.send(JSON.stringify({ type: '__pong' }));
+            }
+            catch {
+                /* disconnected */
+            }
+            return;
+        }
+        console.log(`[SyncRoom] ⬅ recv from=${senderId} type=${msgType}`);
+        if (msgType === '__init_state') {
+            if (this.stateInitialized) {
+                console.log(`[SyncRoom] __init_state skipped (already initialized)`);
+                return;
+            }
+            this.stateInitialized = true;
+            this.cachedState = parsed.state;
+            this.seq = 0;
+            this.patchesSinceReconciliation = 0;
+            console.log(`[SyncRoom] ✅ State initialized`);
+            this.broadcastFullState();
+            return;
+        }
+        if (msgType === '__clear_state') {
+            this.cachedState = null;
+            this.stateInitialized = false;
+            this.seq = 0;
+            this.patchesSinceReconciliation = 0;
+            console.log(`[SyncRoom] 🗑 State cleared`);
+            const clearedMsg = JSON.stringify({ type: '__state_cleared' });
+            for (const peer of this.sockets) {
+                try {
+                    peer.send(clearedMsg);
+                }
+                catch {
+                    /* disconnected */
+                }
+            }
+            this.notifySnapshotSubscribers();
+            return;
+        }
+        if (msgType === '__request_state') {
+            if (!this.stateInitialized || this.cachedState === null)
+                return;
+            try {
+                ws.send(JSON.stringify({
+                    type: '__state',
+                    state: this.cachedState,
+                    seq: this.seq,
+                    serverTime: Date.now(),
+                }));
+            }
+            catch {
+                /* disconnected */
+            }
+            return;
+        }
+        if (msgType === '__patch') {
+            if (!this.stateInitialized || this.cachedState === null)
+                return;
+            const ops = parsed.ops;
+            if (!ops || !Array.isArray(ops) || ops.length === 0)
+                return;
+            const serverTime = Date.now();
+            resolveServerTime(ops, serverTime);
+            // applyPatch は in-place かつ非アトミック (途中失敗で前半 ops が残る) なので、
+            // working copy に適用して成功時のみ cachedState へコミットする。
+            const workingCopy = structuredClone(this.cachedState);
+            const ok = applyPatch(workingCopy, ops);
+            if (!ok) {
+                try {
+                    ws.send(JSON.stringify({ type: '__patch_failed', reason: 'apply_error' }));
+                    ws.send(JSON.stringify({
+                        type: '__state',
+                        state: this.cachedState,
+                        seq: this.seq,
+                        serverTime: Date.now(),
+                    }));
+                }
+                catch {
+                    /* disconnected */
+                }
+                return;
+            }
+            this.cachedState = workingCopy;
+            this.seq++;
+            const ackMsg = JSON.stringify({
+                type: '__patch_ack',
+                ops,
+                seq: this.seq,
+                serverTime,
+                senderId,
+            });
+            for (const peer of this.sockets) {
+                try {
+                    peer.send(ackMsg);
+                }
+                catch {
+                    /* disconnected */
+                }
+            }
+            this.notifySnapshotSubscribers();
+            this.patchesSinceReconciliation++;
+            if (this.patchesSinceReconciliation >= SyncRoom.RECONCILIATION_INTERVAL) {
+                this.patchesSinceReconciliation = 0;
+                this.broadcastFullState();
+            }
+            return;
+        }
+        // Relay-compatible fallback (for existing games like tetris/snake).
+        const outData = JSON.stringify({ ...parsed, __from: senderId });
+        if (parsed.__to && typeof parsed.__to === 'string') {
+            for (const peer of this.sockets) {
+                const pa = this.attachments.get(peer);
+                if (pa && pa.playerId === parsed.__to) {
+                    try {
+                        peer.send(outData);
+                    }
+                    catch {
+                        /* disconnected */
+                    }
+                }
+            }
+        }
+        else {
+            for (const peer of this.sockets) {
+                if (peer === ws)
+                    continue;
+                try {
+                    peer.send(outData);
+                }
+                catch {
+                    /* disconnected */
+                }
+            }
+        }
+    }
+    handleClose(ws) {
+        const attachment = this.attachments.get(ws);
+        if (attachment) {
+            console.log(`[SyncRoom] ❌ Disconnected: connectionId=${attachment.connectionId} playerId=${attachment.playerId}`);
+        }
+        this.sockets.delete(ws);
+        this.attachments.delete(ws);
+    }
+    // ─── Admin API (parent frame __uzu_dev から使う) ──────────────────
+    admin() {
+        return {
+            getSnapshot: () => this.cachedState,
+            getRawState: () => this.cachedState,
+            setRawState: (next) => {
+                this.cachedState = next;
+                this.stateInitialized = true;
+                this.broadcastFullState();
+            },
+            mergeRawState: (patch) => {
+                if (!this.cachedState)
+                    return;
+                applyJsonMergePatch(this.cachedState, patch);
+                this.broadcastFullState();
+            },
+            patchRawState: (ops) => {
+                if (!this.cachedState)
+                    return;
+                applyJsonPatch(this.cachedState, ops);
+                this.broadcastFullState();
+            },
+            subscribeSnapshot: (cb) => {
+                this.snapshotSubscribers.add(cb);
+                return () => {
+                    this.snapshotSubscribers.delete(cb);
+                };
+            },
+        };
+    }
+}

package/dist/dev.js

@@ -0,0 +1,235 @@
+/**
+ * `uzu dev` サブコマンドの本体。
+ *
+ * 概要:
+ *   1. `manifest.json` を読み、 `dev.command` (default `pnpm run dev`) を子 process で spawn
+ *   2. child stdout/stderr を line-by-line で監視し、 `dev.readyPattern` (default vite 向け)
+ *      の regex match をトリガに scenario dev server の URL を確定
+ *   3. harness http+WebSocket server を立て、 iframe grid + HUD を親 frame に描画
+ *   4. `?server=ws://localhost:<port>&roomId=<key>&seatId=dev_N&seats=<json>&revisionId=dev`
+ *      を子 iframe URL に組み立てて mount。 SDK は既存 online mode でそのまま接続する
+ *   5. `window.__uzu_dev` は harness page が dev-server の管理 channel と WS で会話して expose
+ */
+import { spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { createInterface } from 'readline';
+import { currentLanHosts, startHarnessServer } from './dev-server/server.js';
+import { loadLogicFromPath } from './dev-server/load-logic.js';
+import { harnessHtml, buildHarnessClientJs } from './harness/page.js';
+const DEFAULT_DEV_COMMAND = 'pnpm run dev';
+const DEFAULT_READY_PATTERN = 'Local:\\s+(https?://[^\\s]+)';
+const DEFAULT_MIN_IFRAME_SHORT_EDGE = 360;
+export async function runDevCommand() {
+    const cwd = process.cwd();
+    const manifestPath = resolve(cwd, 'manifest.json');
+    if (!existsSync(manifestPath)) {
+        console.error('manifest.json が見つかりません。 scenario ディレクトリで実行してください。');
+        process.exit(1);
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    const playerCount = manifest.characters?.length ?? manifest.playerCount ?? 2;
+    const orientation = manifest.orientation ?? 'portrait';
+    const devCommand = manifest.dev?.command ?? DEFAULT_DEV_COMMAND;
+    const readyPattern = new RegExp(manifest.dev?.readyPattern ?? DEFAULT_READY_PATTERN);
+    // 1. server logic を build & import (`serverActionLogicPath` があるときのみ)
+    let loaded = null;
+    if (manifest.serverActionLogicPath) {
+        console.log(`[uzu dev] Building server logic from ${manifest.serverActionLogicPath}...`);
+        const logicPath = resolve(cwd, manifest.serverActionLogicPath);
+        loaded = await loadLogicFromPath(logicPath);
+        console.log('[uzu dev] Server logic ready');
+    }
+    // 2. harness client bundle を build
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const clientEntryJs = resolve(thisDir, 'harness', 'client-entry.js');
+    const clientEntryTs = resolve(thisDir, 'harness', 'client-entry.ts');
+    const clientEntry = existsSync(clientEntryJs)
+        ? clientEntryJs
+        : existsSync(clientEntryTs)
+            ? clientEntryTs
+            : null;
+    if (!clientEntry) {
+        console.error(`harness client entry が見つかりません: ${clientEntryJs}`);
+        process.exit(1);
+    }
+    console.log('[uzu dev] Bundling harness client...');
+    const harnessJs = await buildHarnessClientJs(clientEntry);
+    console.log(`[uzu dev] Harness client ready (${harnessJs.length} bytes)`);
+    // 3. scenario dev server を spawn
+    console.log(`[uzu dev] Spawning: ${devCommand}`);
+    const child = spawn(devCommand, {
+        cwd,
+        shell: true,
+        env: { ...process.env, FORCE_COLOR: '1' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const scenarioUrl = await watchForReady(child, readyPattern);
+    console.log(`[uzu dev] Scenario ready at ${scenarioUrl}`);
+    // 4. harness server を起動 (free port)
+    // roomKey は固定値。 過去は Math.random() だったが、 uzu dev restart で roomKey が
+    // 変わると browser tab に残った古い roomKey で reconnect → 新 GameRoom 作成、
+    // admin.reset() が意図しない room を対象にする問題があった。 固定にすることで
+    // restart 後の reconnect も同じ GameRoom に collapse する。
+    // roster は dev-server が manifest から組んで GameRoom に注入する (server 権威)
+    // ため、 旧世代 page の残タブが reconnect しても roster は汚染されない。
+    const roomKey = 'devroom';
+    const harnessPort = await findFreePort();
+    const lanHosts = currentLanHosts();
+    // 完全な roster をここで一度だけ組む。 grid・iframe URL・GameRoom 注入の単一の源。
+    const seats = [
+        ...Array.from({ length: playerCount }, (_, i) => ({
+            id: `dev_${i}`,
+            nickname: manifest.characters?.[i]?.name ?? `Player ${i + 1}`,
+            iconUrl: manifest.characters?.[i]?.icon ?? '',
+            characterId: manifest.characters?.[i]?.id,
+            kind: 'player',
+        })),
+        ...(manifest.spectator
+            ? [{ id: 'spec_0', nickname: '観戦', iconUrl: '', kind: 'spectator' }]
+            : []),
+        ...(manifest.admin
+            ? [{ id: 'admin_0', nickname: 'Admin', iconUrl: '', kind: 'admin' }]
+            : []),
+    ];
+    const meta = {
+        scenarioUrl,
+        playerCount,
+        orientation,
+        seats,
+        roomKey,
+        serverBaseUrl: `ws://localhost:${harnessPort}`,
+        revisionId: 'dev',
+        devMinIframeShortEdge: DEFAULT_MIN_IFRAME_SHORT_EDGE,
+    };
+    const server = startHarnessServer({
+        port: harnessPort,
+        // 同一 LAN の実機 (スマホ等) から harness / 単一プレイヤー画面を開けるよう
+        // 全 interface で listen する。 GameRoom は in-memory の dev 専用 state のみ。
+        host: '0.0.0.0',
+        logic: loaded?.logic ?? null,
+        harness: { html: harnessHtml(), js: harnessJs },
+        meta,
+    });
+    const harnessUrl = `http://localhost:${harnessPort}/`;
+    console.log('');
+    console.log(`  🎮  UZU dev harness: ${harnessUrl}`);
+    console.log(`      scenario: ${scenarioUrl}`);
+    console.log(`      players: ${playerCount}  orientation: ${orientation}  roomKey: ${roomKey}`);
+    const extraSeats = seats.filter((seat) => seat.kind !== 'player');
+    if (extraSeats.length > 0) {
+        console.log(`      extra seats: ${extraSeats.map((s) => `${s.kind} (${s.id})`).join(', ')}`);
+    }
+    if (lanHosts.length) {
+        console.log('');
+        console.log(`  📱  同一 Wi-Fi の実機から (LAN に公開されています):`);
+        for (const host of lanHosts) {
+            console.log(`      http://${host}:${harnessPort}/            (5人グリッド)`);
+            console.log(`      http://${host}:${harnessPort}/?player=0   (Player 1 単体, ?player=0..${playerCount - 1})`);
+        }
+        console.log(`      ※ scenario への通信は harness が proxy するため vite 側の設定は不要です`);
+    }
+    console.log('');
+    // 5. process cleanup
+    const cleanup = async () => {
+        console.log('\n[uzu dev] Shutting down...');
+        try {
+            await server.stop();
+        }
+        catch {
+            /* ignore */
+        }
+        if (child.pid && !child.killed) {
+            child.kill('SIGTERM');
+        }
+        if (loaded)
+            loaded.dispose();
+    };
+    process.on('SIGINT', () => {
+        void cleanup().then(() => process.exit(0));
+    });
+    process.on('SIGTERM', () => {
+        void cleanup().then(() => process.exit(0));
+    });
+    child.on('exit', (code) => {
+        console.log(`[uzu dev] scenario dev server exited (code=${code})`);
+        void cleanup().then(() => process.exit(code ?? 0));
+    });
+}
+/** ANSI escape sequences (color / bold 等) を除去する。 vite 等が FORCE_COLOR=1 で
+ * 出す stdout を regex match する前に噛ませる。 */
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+function watchForReady(child, pattern) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error('Timed out waiting for scenario dev server to become ready (30s)'));
+        }, 30_000);
+        let resolved = false;
+        const onLine = (line) => {
+            process.stdout.write(line + '\n');
+            if (resolved)
+                return;
+            const clean = stripAnsi(line);
+            const m = pattern.exec(clean);
+            if (!m)
+                return;
+            const captured = m[1];
+            if (!captured)
+                return;
+            const url = /^https?:\/\//i.test(captured) ? captured : `http://localhost:${captured}`;
+            resolved = true;
+            clearTimeout(timeout);
+            resolve(url.replace(/\/$/, ''));
+        };
+        if (child.stdout) {
+            const rl = createInterface({ input: child.stdout });
+            rl.on('line', onLine);
+        }
+        if (child.stderr) {
+            const rl = createInterface({ input: child.stderr });
+            rl.on('line', onLine);
+        }
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+        child.on('exit', (code) => {
+            if (!resolved) {
+                clearTimeout(timeout);
+                reject(new Error(`scenario dev server exited before ready (code=${code})`));
+            }
+        });
+    });
+}
+const DEFAULT_HARNESS_PORT = 10001;
+const MAX_HARNESS_PORT_ATTEMPTS = 100;
+async function findFreePort() {
+    const net = await import('net');
+    const tryPort = (port) => new Promise((resolve) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', () => resolve(null));
+        server.listen(port, () => {
+            // listen(0) は OS が空きポートを動的割当するため、引数ではなく実際に割り当てられた
+            // 番号を読む必要がある。close 後は address() が null を返すので閉じる前に取る。
+            const address = server.address();
+            const assigned = typeof address === 'object' && address !== null ? address.port : port;
+            server.close(() => resolve(assigned));
+        });
+    });
+    // 10001 から順に空きを探す。 100 回試して見つからなければ OS 自動割当に fallback。
+    for (let i = 0; i < MAX_HARNESS_PORT_ATTEMPTS; i++) {
+        const candidate = DEFAULT_HARNESS_PORT + i;
+        const ok = await tryPort(candidate);
+        if (ok != null)
+            return ok;
+    }
+    const ok = await tryPort(0);
+    if (ok != null)
+        return ok;
+    throw new Error('could not determine free port');
+}