@uzuhq/code-cli 0.3.14

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

@@ -0,0 +1,84 @@
+/**
+ * dev-server 版 RelayRoom (init() 単独 relay mode 用)。
+ *
+ * v3-play-server の `relay-room.ts` (Cloudflare Worker DO 版) と同一プロトコル
+ * (`__room_init` + broadcast) を喋る Node.js 版。 SDK 側の Relay client
+ * (`connectRoom` in `uzuhq-sdk/src/index.ts`) がそのまま接続できる。
+ */
+import { randomUUID } from 'crypto';
+export class RelayRoom {
+    sockets = new Set();
+    attachments = new WeakMap();
+    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(`[RelayRoom] 🔗 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 }));
+    }
+    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;
+        }
+        if (parsed.type === '__ping') {
+            try {
+                ws.send(JSON.stringify({ type: '__pong' }));
+            }
+            catch {
+                /* disconnected */
+            }
+            return;
+        }
+        console.log(`[RelayRoom] ⬅ recv from=${senderId}`, JSON.stringify(parsed));
+        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(`[RelayRoom] ❌ Disconnected: connectionId=${attachment.connectionId}`);
+        }
+        this.sockets.delete(ws);
+        this.attachments.delete(ws);
+    }
+}

package/dist/dev-server/server.js

@@ -0,0 +1,367 @@
+/**
+ * dev-server: harness page HTML/JS を serve しつつ、
+ * `/ws/games/:revisionId/:roomId` / `/ws/sync/:roomId` / `/ws/rooms/:roomId` を
+ * 本番 (v3-play-server) と同一プロトコルで喋る Node.js HTTP + WebSocket server。
+ *
+ * さらに parent frame の `__uzu_dev` 用管理 channel `/dev/admin` を提供する。
+ * game / sync / relay room はいずれも in-memory (CLI 停止で state 消失)。
+ */
+import { Agent, createServer, request as httpRequest, } from 'http';
+import { connect as netConnect } from 'net';
+import { hostname, networkInterfaces } from 'os';
+import { WebSocketServer } from 'ws';
+import { GameRoom } from './game-room.js';
+import { SyncRoom } from './sync-room.js';
+import { RelayRoom } from './relay-room.js';
+const CONTENT_TYPES = {
+    html: 'text/html; charset=utf-8',
+    js: 'application/javascript; charset=utf-8',
+    json: 'application/json; charset=utf-8',
+};
+export function startHarnessServer(opts) {
+    const gameRooms = new Map();
+    const syncRooms = new Map();
+    const relayRooms = new Map();
+    const resolveAdmin = () => {
+        // meta.roomKey に対応する GameRoom を優先。 stale な browser tab が持つ
+        // 古い roomKey に対しては別 GameRoom が作られてしまうが、 admin.reset() は
+        // 現在の meta.roomKey (= fresh page load が接続する room) を対象にしたい。
+        // 見つからなければ Map の最初の room に fallback (sync 系や relay 系用)。
+        const preferredKey = `${opts.meta.revisionId}/${opts.meta.roomKey}`;
+        const gameRoom = gameRooms.get(preferredKey) ?? gameRooms.values().next().value;
+        if (gameRoom)
+            return { kind: 'game', game: gameRoom.admin() };
+        const syncRoom = syncRooms.values().next().value;
+        if (syncRoom)
+            return { kind: 'sync', sync: syncRoom.admin() };
+        return null;
+    };
+    const httpServer = createServer((req, res) => {
+        handleHttpRequest(req, res, opts);
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    httpServer.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        const pathname = url.pathname;
+        const gameMatch = pathname.match(/^\/ws\/games\/([^/]+)\/([^/]+)$/);
+        if (gameMatch) {
+            const revisionId = gameMatch[1];
+            const roomId = gameMatch[2];
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                if (!opts.logic) {
+                    ws.close(1008, 'No server logic loaded (missing serverActionLogicPath in manifest)');
+                    return;
+                }
+                const key = `${revisionId}/${roomId}`;
+                let room = gameRooms.get(key);
+                if (!room) {
+                    room = new GameRoom(opts.logic, opts.meta.seats);
+                    gameRooms.set(key, room);
+                }
+                room.handleConnection(ws, url);
+            });
+            return;
+        }
+        const syncMatch = pathname.match(/^\/ws\/sync\/([^/]+)$/);
+        if (syncMatch) {
+            const roomId = syncMatch[1];
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                let room = syncRooms.get(roomId);
+                if (!room) {
+                    room = new SyncRoom();
+                    syncRooms.set(roomId, room);
+                }
+                room.handleConnection(ws, url);
+            });
+            return;
+        }
+        const relayMatch = pathname.match(/^\/ws\/rooms\/([^/]+)$/);
+        if (relayMatch) {
+            const roomId = relayMatch[1];
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                let room = relayRooms.get(roomId);
+                if (!room) {
+                    room = new RelayRoom();
+                    relayRooms.set(roomId, room);
+                }
+                room.handleConnection(ws, url);
+            });
+            return;
+        }
+        if (pathname === '/dev/admin') {
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                handleAdminConnection(ws, resolveAdmin);
+            });
+            return;
+        }
+        // それ以外の upgrade (vite HMR ws 等) は scenario dev server へ生 TCP で転送する。
+        // 実機 (LAN/mDNS) からのアクセスは harness port だけで完結させ、 scenario 側の
+        // vite に --host / allowedHosts を要求しない。
+        proxyUpgradeToScenario(req, socket, head, opts.meta.scenarioUrl);
+    });
+    httpServer.listen(opts.port, opts.host ?? '127.0.0.1');
+    return {
+        stop: () => new Promise((resolve) => {
+            for (const ws of wss.clients) {
+                try {
+                    ws.close();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            wss.close(() => {
+                httpServer.close(() => resolve());
+            });
+        }),
+    };
+}
+export function currentLanHosts() {
+    const hosts = [];
+    // mDNS (Bonjour) 名を先頭に。 DHCP で IP が変わっても URL が生き続けるので、
+    // スマホの「ホーム画面に追加」やブックマークはこちらを使うのが安定する。
+    const name = hostname();
+    if (name)
+        hosts.push(name.toLowerCase().endsWith('.local') ? name.toLowerCase() : `${name.toLowerCase()}.local`);
+    for (const entries of Object.values(networkInterfaces())) {
+        for (const entry of entries ?? []) {
+            if (entry.family === 'IPv4' && !entry.internal)
+                hosts.push(entry.address);
+        }
+    }
+    return hosts;
+}
+function handleHttpRequest(req, res, opts) {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    const pathname = url.pathname;
+    const writeText = (body, contentType, status = 200) => {
+        res.writeHead(status, {
+            'content-type': contentType,
+            'cache-control': 'no-store',
+            'access-control-allow-origin': '*',
+        });
+        res.end(body);
+    };
+    // `?server=` 付きの `/` は scenario の index.html (iframe の中身)。
+    // それ以外の `/` は harness page。 asset 等の未知 path はすべて scenario へ proxy する
+    // (harness 資産は `_uzu_` prefix / 固定 path なので衝突しない)。
+    const isScenarioIndex = (pathname === '/' || pathname === '/index.html') && url.searchParams.has('server');
+    if ((pathname === '/' || pathname === '/index.html') && !isScenarioIndex) {
+        writeText(opts.harness.html, CONTENT_TYPES.html);
+        return;
+    }
+    if (pathname === '/_uzu_harness.js') {
+        writeText(opts.harness.js, CONTENT_TYPES.js);
+        return;
+    }
+    if (pathname === '/_uzu_meta.json') {
+        // lanHosts は DHCP 再割当で変わり得るため、 起動時の値ではなくリクエスト毎に取り直す
+        writeText(JSON.stringify({ ...opts.meta, lanHosts: currentLanHosts() }), CONTENT_TYPES.json);
+        return;
+    }
+    if (pathname === '/health') {
+        writeText(JSON.stringify({ ok: true }), CONTENT_TYPES.json);
+        return;
+    }
+    proxyHttpToScenario(req, res, opts.meta.scenarioUrl);
+}
+/**
+ * 親 frame `__uzu_dev` からの管理 request を受け取る WebSocket handler。
+ *
+ * message shape:
+ *   Client → Server: `{ type: 'call', id, method, args? }`
+ *                    `{ type: 'subscribe', id, kind: 'snapshot' | 'events' }`
+ *                    `{ type: 'unsubscribe', id }`
+ *   Server → Client: `{ type: 'result', id, value }`
+ *                    `{ type: 'error', id, error }`
+ *                    `{ type: 'event', id, value }`
+ *                    `{ type: 'missing', id }` — method 未提供 (undefined 表現)
+ */
+function handleAdminConnection(ws, resolveAdmin) {
+    const unsubs = new Map();
+    ws.on('message', async (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(raw.toString());
+        }
+        catch {
+            return;
+        }
+        const type = msg.type;
+        const id = msg.id;
+        const admin = resolveAdmin();
+        if (!admin) {
+            ws.send(JSON.stringify({ type: 'error', id, error: 'no_active_room' }));
+            return;
+        }
+        if (type === 'call') {
+            const method = msg.method;
+            const args = msg.args ?? [];
+            try {
+                const value = await invokeAdminMethod(admin, method, args);
+                if (value === undefined && !adminHasMethod(admin, method)) {
+                    ws.send(JSON.stringify({ type: 'missing', id }));
+                }
+                else {
+                    ws.send(JSON.stringify({ type: 'result', id, value }));
+                }
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    id,
+                    error: err instanceof Error ? err.message : String(err),
+                }));
+            }
+            return;
+        }
+        if (type === 'subscribe') {
+            const kind = msg.kind;
+            const unsub = subscribeAdmin(admin, kind, (value) => {
+                try {
+                    ws.send(JSON.stringify({ type: 'event', id, value }));
+                }
+                catch {
+                    /* disconnected */
+                }
+            });
+            if (!unsub) {
+                ws.send(JSON.stringify({ type: 'error', id, error: 'subscription_not_supported' }));
+                return;
+            }
+            unsubs.set(id, unsub);
+            ws.send(JSON.stringify({ type: 'result', id, value: null }));
+            return;
+        }
+        if (type === 'unsubscribe') {
+            const unsub = unsubs.get(id);
+            if (unsub) {
+                unsub();
+                unsubs.delete(id);
+            }
+            return;
+        }
+    });
+    ws.on('close', () => {
+        unsubs.forEach((unsub) => unsub());
+        unsubs.clear();
+    });
+}
+function adminHasMethod(admin, method) {
+    if (admin.kind === 'game' && admin.game) {
+        return typeof admin.game[method] === 'function';
+    }
+    if (admin.kind === 'sync' && admin.sync) {
+        return typeof admin.sync[method] === 'function';
+    }
+    return false;
+}
+async function invokeAdminMethod(admin, method, args) {
+    const target = admin.kind === 'game' ? admin.game : admin.sync;
+    if (!target)
+        return undefined;
+    const fn = target[method];
+    if (typeof fn !== 'function')
+        return undefined;
+    return await fn.apply(target, args);
+}
+function subscribeAdmin(admin, kind, cb) {
+    if (kind === 'snapshot') {
+        const target = admin.kind === 'game' ? admin.game : admin.sync;
+        if (!target)
+            return null;
+        return target.subscribeSnapshot(cb);
+    }
+    if (kind === 'events') {
+        if (admin.kind !== 'game' || !admin.game)
+            return null;
+        return admin.game.subscribeEvents(cb);
+    }
+    return null;
+}
+/**
+ * hop-by-hop ヘッダ。 そのまま転送すると chunked エンコードの二重適用や
+ * 接続管理の不整合で HTTP パイプラインが詰まるため、 proxy では必ず落とす
+ * (Node が自身の接続に合わせて再付与する)。
+ */
+const HOP_BY_HOP_HEADERS = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade',
+]);
+function stripHopByHopHeaders(headers) {
+    const out = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (!HOP_BY_HOP_HEADERS.has(name.toLowerCase()))
+            out[name] = value;
+    }
+    return out;
+}
+// scenario proxy 用の接続 pool。 実機 Safari が画像 / 音声を並列ロードしても
+// vite への接続を使い回し、 ソケットを滞留させない。
+const scenarioProxyAgent = new Agent({ keepAlive: true, maxSockets: 32 });
+/**
+ * HTTP リクエストを scenario dev server (vite 等) へ転送する。
+ * Host ヘッダを scenario 側の localhost origin に書き換えるので、 vite の
+ * allowedHosts 制限 (mDNS 名や LAN IP を拒否する) に触れない。
+ */
+function proxyHttpToScenario(req, res, scenarioUrl) {
+    const target = new URL(scenarioUrl);
+    const proxyReq = httpRequest({
+        agent: scenarioProxyAgent,
+        hostname: target.hostname,
+        port: target.port,
+        path: req.url,
+        method: req.method,
+        headers: { ...stripHopByHopHeaders(req.headers), host: target.host },
+        timeout: 30_000,
+    }, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode ?? 502, stripHopByHopHeaders(proxyRes.headers));
+        proxyRes.pipe(res);
+    });
+    const fail = () => {
+        if (!res.headersSent) {
+            res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
+        }
+        res.end('scenario dev server unreachable');
+    };
+    proxyReq.on('timeout', () => proxyReq.destroy(new Error('proxy timeout')));
+    proxyReq.on('error', fail);
+    // クライアント (実機 Safari 等) が切断したら vite 側への転送も打ち切り、
+    // 接続と stream を残さない。
+    res.on('close', () => proxyReq.destroy());
+    req.pipe(proxyReq);
+}
+/**
+ * WebSocket upgrade (vite HMR 等) を scenario dev server へ生 TCP で転送する。
+ * handshake リクエストの Host だけ書き換えて、 以降は双方向 pipe。
+ */
+function proxyUpgradeToScenario(req, socket, head, scenarioUrl) {
+    const target = new URL(scenarioUrl);
+    const proxySocket = netConnect(Number(target.port), target.hostname, () => {
+        const lines = [`${req.method} ${req.url} HTTP/1.1`];
+        for (let i = 0; i < req.rawHeaders.length; i += 2) {
+            const name = req.rawHeaders[i];
+            const value = name.toLowerCase() === 'host' ? target.host : req.rawHeaders[i + 1];
+            lines.push(`${name}: ${value}`);
+        }
+        proxySocket.write(lines.join('\r\n') + '\r\n\r\n');
+        if (head.length)
+            proxySocket.write(head);
+        proxySocket.pipe(socket);
+        socket.pipe(proxySocket);
+    });
+    const destroyBoth = () => {
+        proxySocket.destroy();
+        socket.destroy();
+    };
+    proxySocket.on('error', destroyBoth);
+    socket.on('error', destroyBoth);
+    proxySocket.on('close', destroyBoth);
+    socket.on('close', destroyBoth);
+}