@nexusgame/dev 0.2.0 → 0.4.0

package/dist/index.js

@@ -3,32 +3,2119 @@
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/start.ts
-import { Miniflare } from "miniflare";
+// src/commands/serve.ts
+import { mkdir as mkdir4 } from "fs/promises";
+import path10 from "path";
+
+// src/console-dir.ts
+import { existsSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { readFile } from "fs/promises";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function resolveConsoleDir() {
+  const fallback = path.join(__dirname, "console");
+  const candidates = [
+    process.env.NEXUS_CONSOLE_DIR,
+    fallback,
+    path.resolve(process.cwd(), "engine-console/dist"),
+    path.resolve(process.cwd(), "nexus-playground/engine-console/dist"),
+    path.resolve(process.cwd(), "../engine-console/dist"),
+    path.resolve(__dirname, "../../../engine-console/dist")
+  ].filter((candidate) => Boolean(candidate));
+  return candidates.find((dir) => existsSync(path.join(dir, "index.html")) && existsSync(path.join(dir, "workspace.html"))) ?? fallback;
+}
+
+// src/constants.ts
+var ADMIN_SECRET = "nexus-dev-secret";
+var JWT_SECRET = "nexus-dev-jwt-secret";
+var FIXED_OWNER_ID = "dev-owner";
+var DEFAULT_PORT = 56512;
+var DEFAULT_WORKER_PORT = 8787;
+var DEFAULT_WORKER_URL = `http://127.0.0.1:${DEFAULT_WORKER_PORT}`;
+var DEV_VERSION = "0.4.0";
+
+// src/console-server.ts
+import http from "http";
+import net from "net";
+import path2 from "path";
+import { createReadStream, existsSync as existsSync2 } from "fs";
+import { stat } from "fs/promises";
+import { createHmac } from "crypto";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8"
+};
+function base64url(value) {
+  return Buffer.from(value).toString("base64url");
+}
+function signDevToken(userId, name, roomId) {
+  const now = Math.floor(Date.now() / 1e3);
+  const header = base64url(JSON.stringify({ alg: "HS256", typ: "JWT" }));
+  const payload = base64url(JSON.stringify({
+    sub: userId,
+    name,
+    roomId,
+    iat: now,
+    exp: now + 5 * 60
+  }));
+  const data = `${header}.${payload}`;
+  const signature = createHmac("sha256", JWT_SECRET).update(data).digest("base64url");
+  return `${data}.${signature}`;
+}
+function sendJson(res, status, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body),
+    "Cache-Control": "no-store"
+  });
+  res.end(body);
+}
+async function handleDevToken(url, res, isRoomAllowed) {
+  const roomId = url.searchParams.get("roomId") || "";
+  const userId = url.searchParams.get("userId") || "";
+  const name = url.searchParams.get("name") || userId;
+  if (!roomId || !await isRoomAllowed(roomId)) {
+    sendJson(res, 403, { error: `Room "${roomId}" is not connected to this workspace` });
+    return;
+  }
+  if (!userId.startsWith("dev:") || userId.length <= 4) {
+    sendJson(res, 403, { error: "Only dev:<roleId> users can request a dev token" });
+    return;
+  }
+  if (!/^[\w:.-]{1,128}$/.test(userId)) {
+    sendJson(res, 400, { error: "Invalid userId" });
+    return;
+  }
+  sendJson(res, 200, {
+    token: signDevToken(userId, name, roomId),
+    url: `/connect/${encodeURIComponent(roomId)}`,
+    expiresIn: 300
+  });
+}
+function proxyApi(req, res, enginePort) {
+  const proxyReq = http.request({
+    host: "127.0.0.1",
+    port: enginePort,
+    path: req.url,
+    method: req.method,
+    headers: {
+      ...req.headers,
+      host: `127.0.0.1:${enginePort}`,
+      authorization: `Bearer ${ADMIN_SECRET}`
+    }
+  }, (proxyRes) => {
+    res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+    proxyRes.pipe(res);
+  });
+  proxyReq.on("error", (error) => {
+    if (!res.headersSent) {
+      sendJson(res, 502, { error: `Engine proxy error: ${error.message}` });
+    } else {
+      res.destroy();
+    }
+  });
+  req.pipe(proxyReq);
+}
+function serveFile(req, res, filePath) {
+  const extension = path2.extname(filePath).toLowerCase();
+  const isHashedAsset = filePath.includes(`${path2.sep}assets${path2.sep}`);
+  res.writeHead(200, {
+    "Content-Type": MIME_TYPES[extension] || "application/octet-stream",
+    "Cache-Control": isHashedAsset ? "public, max-age=31536000, immutable" : "no-cache"
+  });
+  if (req.method === "HEAD") {
+    res.end();
+    return;
+  }
+  createReadStream(filePath).on("error", () => res.destroy()).pipe(res);
+}
+function missingConsolePage(appName) {
+  return `<!doctype html>
+<html lang="zh-CN">
+<head><meta charset="utf-8"><title>${appName}</title>
+<style>body{font-family:system-ui,sans-serif;background:#0b1220;color:#e6edf7;padding:40px;line-height:1.6}code{background:#1d2c4a;padding:2px 6px;border-radius:4px}</style>
+</head>
+<body>
+<h1>${appName} \u672A\u6784\u5EFA</h1>
+<p>\u5148\u8FD0\u884C <code>pnpm --filter @nexusgame/engine-console run build</code>\uFF0C\u6216\u4F7F\u7528 <code>make publish-cli</code>\u3002</p>
+<p>API \u4EE3\u7406\u548C <code>/dev/token</code> \u5DF2\u7ECF\u53EF\u7528\uFF0CCLI \u547D\u4EE4\u4E0D\u53D7\u5F71\u54CD\u3002</p>
+</body>
+</html>`;
+}
+function pageForPath(pathname, options) {
+  const rootPage = options.rootPage ?? "index.html";
+  if (pathname === "/" || pathname === "/dashboard" || pathname === "/games" || pathname === "/rooms" || pathname === "/rooms/") {
+    return { page: rootPage, isEntry: true };
+  }
+  if (options.roomPage && /^\/rooms\/[^/]+\/?$/.test(pathname)) {
+    return { page: options.roomPage, isEntry: true };
+  }
+  return null;
+}
+async function serveStatic(req, res, options, url) {
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    sendJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+  let pathname;
+  try {
+    pathname = decodeURIComponent(url.pathname);
+  } catch {
+    sendJson(res, 400, { error: "Invalid path" });
+    return;
+  }
+  const resolvedDir = path2.resolve(options.consoleDir);
+  const rootPage = options.rootPage ?? "index.html";
+  const page = pageForPath(pathname, options);
+  const sendPage = (file, isEntry) => {
+    const pagePath = path2.join(resolvedDir, file);
+    if (existsSync2(pagePath)) {
+      serveFile(req, res, pagePath);
+      return true;
+    }
+    if (isEntry) {
+      res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store"
+      });
+      res.end(missingConsolePage(options.appName ?? "Engine Console"));
+      return true;
+    }
+    return false;
+  };
+  if (page && sendPage(page.page, page.isEntry)) return;
+  const filePath = path2.resolve(resolvedDir, `.${pathname}`);
+  const insideDir = filePath === resolvedDir || filePath.startsWith(`${resolvedDir}${path2.sep}`);
+  if (!insideDir) {
+    sendJson(res, 403, { error: "Forbidden" });
+    return;
+  }
+  try {
+    const info = await stat(filePath);
+    if (info.isFile()) {
+      serveFile(req, res, filePath);
+      return;
+    }
+  } catch {
+  }
+  if (!path2.extname(pathname) && sendPage(rootPage, true)) return;
+  sendJson(res, 404, { error: "Not found" });
+}
+function handleUpgrade(req, socket, head, enginePort) {
+  let pathname = "";
+  try {
+    pathname = new URL(req.url || "/", "http://localhost").pathname;
+  } catch {
+    socket.destroy();
+    return;
+  }
+  if (!pathname.startsWith("/connect/")) {
+    socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+    socket.destroy();
+    return;
+  }
+  const upstream = net.connect({ host: "127.0.0.1", port: enginePort }, () => {
+    const lines = [`${req.method} ${req.url} HTTP/1.1`];
+    for (let index = 0; index < req.rawHeaders.length; index += 2) {
+      lines.push(`${req.rawHeaders[index]}: ${req.rawHeaders[index + 1]}`);
+    }
+    upstream.write(`${lines.join("\r\n")}\r
+\r
+`);
+    if (head.length > 0) upstream.write(head);
+    upstream.pipe(socket);
+    socket.pipe(upstream);
+  });
+  upstream.on("error", () => socket.destroy());
+  socket.on("error", () => upstream.destroy());
+}
+async function startConsoleServer(options) {
+  const host2 = options.host || "127.0.0.1";
+  const enginePort = options.enginePort;
+  const server = http.createServer((req, res) => {
+    void (async () => {
+      const url = new URL(req.url || "/", `http://${req.headers.host || host2}`);
+      if (options.handleApi) {
+        try {
+          if (await options.handleApi(req, res, url)) return;
+        } catch (error) {
+          if (!res.headersSent) {
+            sendJson(res, 500, {
+              error: error instanceof Error ? error.message : "Internal error"
+            });
+          } else {
+            res.destroy();
+          }
+          return;
+        }
+      }
+      if (url.pathname === "/dev/token") {
+        if (req.method !== "GET") {
+          sendJson(res, 405, { error: "Method not allowed" });
+          return;
+        }
+        await handleDevToken(url, res, options.isRoomAllowed);
+        return;
+      }
+      if (url.pathname === "/api/engine" || url.pathname.startsWith("/api/engine/")) {
+        proxyApi(req, res, enginePort);
+        return;
+      }
+      if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
+        sendJson(res, 404, { error: "Not found" });
+        return;
+      }
+      await serveStatic(req, res, options, url);
+    })();
+  });
+  server.on("upgrade", (req, socket, head) => {
+    handleUpgrade(req, socket, head, enginePort);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.publicPort, host2, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  return {
+    url: `http://${host2}:${options.publicPort}`,
+    close: async () => {
+      server.closeAllConnections?.();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+// ../engine-client/src/routes.ts
+var ENGINE_ADMIN_PREFIX = "/api/engine";
+var ENGINE_ROOM_PREFIX = `${ENGINE_ADMIN_PREFIX}/rooms`;
+function engineRoomPath(roomId, suffix = "") {
+  return `${ENGINE_ROOM_PREFIX}/${encodeURIComponent(roomId)}${suffix}`;
+}
+var ENGINE_ROUTES = {
+  createRoom: `${ENGINE_ADMIN_PREFIX}/create`,
+  roomState: (roomId) => engineRoomPath(roomId),
+  roomDebug: (roomId) => engineRoomPath(roomId, "/debug"),
+  roomPerspective: (roomId, roleId) => {
+    const query = roleId ? `?roleId=${encodeURIComponent(roleId)}` : "";
+    return engineRoomPath(roomId, `/perspective${query}`);
+  },
+  roleAction: (roomId) => engineRoomPath(roomId, "/role-action"),
+  setGame: (roomId) => engineRoomPath(roomId, "/set-game"),
+  startGame: (roomId) => engineRoomPath(roomId, "/start-game"),
+  stopGame: (roomId) => engineRoomPath(roomId, "/stop-game"),
+  restartGame: (roomId) => engineRoomPath(roomId, "/restart-game"),
+  pauseGame: (roomId) => engineRoomPath(roomId, "/pause-game"),
+  resumeGame: (roomId) => engineRoomPath(roomId, "/resume-game"),
+  backtrack: (roomId) => engineRoomPath(roomId, "/backtrack"),
+  players: (roomId) => engineRoomPath(roomId, "/players"),
+  player: (roomId, userId) => engineRoomPath(roomId, `/players/${encodeURIComponent(userId)}`),
+  assignRole: (roomId) => engineRoomPath(roomId, "/assign-role"),
+  addBot: (roomId) => engineRoomPath(roomId, "/add-bot")
+};
+
+// ../engine-client/src/admin.ts
+var EngineAdminClient = class {
+  baseUrl;
+  token;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+    this.fetchImpl = options.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  // ─── Room creation ─────────────────────────────────────
+  async createRoom(roomId, ownerId) {
+    return this.request("POST", ENGINE_ROUTES.createRoom, { roomId, ownerId });
+  }
+  // ─── Read endpoints ────────────────────────────────────
+  async getState(roomId) {
+    return this.request("GET", ENGINE_ROUTES.roomState(roomId));
+  }
+  async getDebug(roomId) {
+    return this.request("GET", ENGINE_ROUTES.roomDebug(roomId));
+  }
+  async getPerspective(roomId, roleId) {
+    return this.request("GET", ENGINE_ROUTES.roomPerspective(roomId, roleId));
+  }
+  // ─── Commands ──────────────────────────────────────────
+  async submitAction(roomId, roleId, action) {
+    return this.request("POST", ENGINE_ROUTES.roleAction(roomId), { roleId, action });
+  }
+  async setGame(roomId, request) {
+    return this.request("POST", ENGINE_ROUTES.setGame(roomId), request);
+  }
+  async startGame(roomId) {
+    return this.request("POST", ENGINE_ROUTES.startGame(roomId));
+  }
+  async stopGame(roomId) {
+    return this.request("POST", ENGINE_ROUTES.stopGame(roomId));
+  }
+  async restartGame(roomId) {
+    return this.request("POST", ENGINE_ROUTES.restartGame(roomId));
+  }
+  async pauseGame(roomId) {
+    return this.request("POST", ENGINE_ROUTES.pauseGame(roomId));
+  }
+  async resumeGame(roomId) {
+    return this.request("POST", ENGINE_ROUTES.resumeGame(roomId));
+  }
+  async backtrack(roomId, index) {
+    return this.request("POST", ENGINE_ROUTES.backtrack(roomId), { index });
+  }
+  async createPlayer(roomId, request) {
+    return this.request("POST", ENGINE_ROUTES.players(roomId), request);
+  }
+  async removePlayer(roomId, userId) {
+    return this.request("DELETE", ENGINE_ROUTES.player(roomId, userId));
+  }
+  async assignRole(roomId, roleId, userId) {
+    return this.request("POST", ENGINE_ROUTES.assignRole(roomId), { roleId, userId });
+  }
+  async addBot(roomId, request) {
+    return this.request("POST", ENGINE_ROUTES.addBot(roomId), request);
+  }
+  // ─── Transport ─────────────────────────────────────────
+  async request(method, path18, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const token = typeof this.token === "function" ? await this.token() : this.token;
+    if (token) headers.Authorization = `Bearer ${token}`;
+    let response;
+    try {
+      response = await this.fetchImpl(`${this.baseUrl}${path18}`, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      });
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "Request failed"
+      };
+    }
+    const text = await response.text();
+    let payload = null;
+    try {
+      payload = text ? JSON.parse(text) : null;
+    } catch {
+      payload = text;
+    }
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: payload?.error || `HTTP ${response.status}`,
+        status: response.status,
+        data: payload
+      };
+    }
+    if (payload && typeof payload === "object" && typeof payload.ok === "boolean") {
+      return payload.ok ? { ok: true, data: payload.data } : { ok: false, error: payload.error || "Command failed", data: payload };
+    }
+    return { ok: true, data: payload };
+  }
+};
+
+// src/workspace/config.ts
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import path4 from "path";
+
+// src/workspace/paths.ts
+import path3 from "path";
+var STATE_DIR_NAME = ".nexus";
+var GAME_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+function isSafeGameId(id) {
+  return GAME_ID_PATTERN.test(id) && id !== "." && id !== "..";
+}
+function workspaceStateDir(root) {
+  return path3.join(root, STATE_DIR_NAME);
+}
+function logsDir(root) {
+  return path3.join(workspaceStateDir(root), "logs");
+}
+function workspaceConfigFile(root) {
+  return path3.join(workspaceStateDir(root), "workspace.json");
+}
+function hostRecordFile(root) {
+  return path3.join(workspaceStateDir(root), "host.json");
+}
+function hostLogFile(root) {
+  return path3.join(logsDir(root), "host.log");
+}
+function workersDir(root) {
+  return path3.join(workspaceStateDir(root), "workers");
+}
+function workerRecordFile(root, gameId) {
+  return path3.join(workersDir(root), `${gameId}.json`);
+}
+function workerLogFile(root, gameId) {
+  return path3.join(logsDir(root), `${gameId}.worker.log`);
+}
+function hostEngineStateDir(root) {
+  return path3.join(workspaceStateDir(root), "engine");
+}
+
+// src/workspace/process.ts
+import { open, stat as stat2 } from "fs/promises";
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function fileSize(file) {
+  try {
+    return (await stat2(file)).size;
+  } catch {
+    return 0;
+  }
+}
+async function tailFile(file, lineCount = 200) {
+  try {
+    const info = await stat2(file);
+    if (info.size <= 0) return "";
+    const length = Math.min(info.size, 128 * 1024);
+    const handle = await open(file, "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      await handle.read(buffer, 0, length, info.size - length);
+      const lines = buffer.toString("utf8").split(/\r?\n/);
+      return lines.slice(-Math.max(1, lineCount)).join("\n");
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+async function followLogs(targets, options = {}) {
+  const initialLines = options.initialLines ?? 20;
+  const offsets = /* @__PURE__ */ new Map();
+  const prefix = targets.length > 1;
+  for (const target of targets) {
+    const text = await tailFile(target.file, initialLines);
+    if (text.trim()) {
+      process.stdout.write(`--- ${target.label} \u6700\u8FD1\u65E5\u5FD7 ---
+`);
+      process.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+    }
+    offsets.set(target.file, await fileSize(target.file));
+  }
+  const readGrowth = async (target) => {
+    const size = await fileSize(target.file);
+    let offset = offsets.get(target.file) ?? 0;
+    if (size < offset) offset = 0;
+    if (size === offset) {
+      offsets.set(target.file, size);
+      return;
+    }
+    const length = size - offset;
+    const handle = await open(target.file, "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      await handle.read(buffer, 0, length, offset);
+      const text = buffer.toString("utf8");
+      if (prefix) {
+        for (const line of text.split(/\r?\n/)) {
+          if (line) process.stdout.write(`[${target.label}] ${line}
+`);
+        }
+      } else {
+        process.stdout.write(text);
+      }
+    } finally {
+      await handle.close();
+    }
+    offsets.set(target.file, size);
+  };
+  let busy = false;
+  const timer = setInterval(() => {
+    if (busy) return;
+    busy = true;
+    void Promise.all(targets.map(readGrowth)).catch(() => void 0).finally(() => {
+      busy = false;
+    });
+  }, 400);
+  return () => clearInterval(timer);
+}
+
+// src/workspace/config.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(value, field, source) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${source}: \u5B57\u6BB5 "${field}" \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+  }
+  return value;
+}
+function parseConnection(value, source) {
+  if (!isRecord(value)) throw new Error(`${source}: connection \u5FC5\u987B\u662F\u5BF9\u8C61`);
+  const roleIds = Array.isArray(value.roleIds) ? value.roleIds.filter((role) => typeof role === "string") : [];
+  return {
+    roomId: stringField(value.roomId, "roomId", source),
+    gameId: stringField(value.gameId, "gameId", source),
+    name: typeof value.name === "string" && value.name.trim() ? value.name : stringField(value.gameId, "gameId", source),
+    gameDir: stringField(value.gameDir, "gameDir", source),
+    workerUrl: stringField(value.workerUrl, "workerUrl", source),
+    players: typeof value.players === "number" && Number.isInteger(value.players) && value.players > 0 ? value.players : void 0,
+    roleIds,
+    createdAt: stringField(value.createdAt, "createdAt", source),
+    updatedAt: stringField(value.updatedAt, "updatedAt", source)
+  };
+}
+async function writeJsonAtomic(file, value) {
+  await mkdir(path4.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename(temporary, file);
+}
+function emptyWorkspaceConfig(root) {
+  return {
+    version: 1,
+    root: path4.resolve(root),
+    connections: []
+  };
+}
+async function readWorkspaceConfig(root) {
+  const file = workspaceConfigFile(root);
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return emptyWorkspaceConfig(root);
+    }
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u5DE5\u4F5C\u533A\u914D\u7F6E ${file}: ${error.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`\u5DE5\u4F5C\u533A\u914D\u7F6E ${file} \u4E0D\u662F\u5408\u6CD5 JSON: ${error.message}`);
+  }
+  if (!isRecord(parsed)) throw new Error(`\u5DE5\u4F5C\u533A\u914D\u7F6E ${file} \u5FC5\u987B\u662F JSON \u5BF9\u8C61`);
+  if (parsed.version !== 1) throw new Error(`\u5DE5\u4F5C\u533A\u914D\u7F6E ${file} \u7684 version \u5FC5\u987B\u4E3A 1`);
+  const connections = Array.isArray(parsed.connections) ? parsed.connections.map((connection, index) => parseConnection(connection, `${file} connections[${index}]`)) : [];
+  return {
+    version: 1,
+    root: typeof parsed.root === "string" && parsed.root ? parsed.root : path4.resolve(root),
+    connections
+  };
+}
+async function writeWorkspaceConfig(root, config) {
+  await writeJsonAtomic(workspaceConfigFile(root), {
+    ...config,
+    version: 1,
+    root: path4.resolve(root)
+  });
+}
+async function readHostRecord(root) {
+  const file = hostRecordFile(root);
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 host \u8BB0\u5F55 ${file}: ${error.message}`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || typeof parsed.pid !== "number" || typeof parsed.port !== "number" || typeof parsed.enginePort !== "number" || typeof parsed.root !== "string" || typeof parsed.url !== "string" || typeof parsed.startedAt !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeHostRecord(root, record) {
+  await writeJsonAtomic(hostRecordFile(root), record);
+}
+async function removeHostRecord(root, pid) {
+  if (pid !== void 0) {
+    const existing = await readHostRecord(root);
+    if (existing && existing.pid !== pid) return;
+  }
+  await rm(hostRecordFile(root), { force: true });
+}
+function isHostRecordAlive(record) {
+  return isProcessAlive(record.pid);
+}
+function findConnection(config, selector) {
+  return config.connections.find(
+    (connection) => connection.roomId === selector || connection.gameId === selector
+  );
+}
+
+// src/workspace/scan.ts
+import { readdir, readFile as readFile2, realpath, stat as stat3 } from "fs/promises";
+import path5 from "path";
+var MANIFEST_NAME = "nexus.game.json";
+var GAME_DIR_NAMES = /* @__PURE__ */ new Set(["games", "nexus-games"]);
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "public"
+]);
+async function isDirectory(target) {
+  try {
+    return (await stat3(target)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function childDirs(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && !SKIPPED_DIRS.has(name)).map((name) => path5.join(dir, name));
+  } catch {
+    return [];
+  }
+}
+async function scanGames(rootInput = process.cwd()) {
+  const root = path5.resolve(rootInput);
+  const warnings = [];
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(root);
+  const direct = await childDirs(root);
+  for (const dir of direct) {
+    candidates.add(dir);
+    if (GAME_DIR_NAMES.has(path5.basename(dir))) {
+      for (const nested of await childDirs(dir)) candidates.add(nested);
+    }
+  }
+  const games = [];
+  const seenDirs = /* @__PURE__ */ new Set();
+  for (const dir of candidates) {
+    if (!await isDirectory(dir)) continue;
+    let realDir;
+    try {
+      realDir = await realpath(dir);
+    } catch {
+      realDir = dir;
+    }
+    if (seenDirs.has(realDir)) continue;
+    seenDirs.add(realDir);
+    const manifestPath = path5.join(dir, MANIFEST_NAME);
+    let raw;
+    try {
+      raw = await readFile2(manifestPath, "utf8");
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") continue;
+      warnings.push(`${manifestPath}: \u65E0\u6CD5\u8BFB\u53D6 (${error.message})`);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      warnings.push(`${manifestPath}: JSON \u89E3\u6790\u5931\u8D25 (${error.message})`);
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      warnings.push(`${manifestPath}: \u5185\u5BB9\u5FC5\u987B\u662F JSON \u5BF9\u8C61`);
+      continue;
+    }
+    const manifest = parsed;
+    const id = typeof manifest.id === "string" ? manifest.id.trim() : "";
+    if (!id) {
+      warnings.push(`${manifestPath}: \u7F3A\u5C11\u5B57\u7B26\u4E32\u5B57\u6BB5 "id"`);
+      continue;
+    }
+    if (!isSafeGameId(id)) {
+      warnings.push(`${manifestPath}: id "${id}" \u975E\u6CD5\uFF08\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001. _ -\uFF0C\u4E14\u4E0D\u80FD\u662F . \u6216 ..\uFF09`);
+      continue;
+    }
+    const name = typeof manifest.name === "string" && manifest.name.trim() ? manifest.name.trim() : id;
+    games.push({
+      id,
+      name,
+      dir: path5.resolve(dir),
+      manifestPath,
+      manifest,
+      duplicate: false
+    });
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const game2 of games) counts.set(game2.id, (counts.get(game2.id) ?? 0) + 1);
+  for (const game2 of games) game2.duplicate = (counts.get(game2.id) ?? 0) > 1;
+  for (const [id, count] of counts) {
+    if (count > 1) {
+      warnings.push(`\u6E38\u620F id "${id}" \u51FA\u73B0\u5728 ${count} \u4E2A\u76EE\u5F55\u4E2D\uFF1B\u7528 id \u542F\u52A8\u4F1A\u62A5\u6B67\u4E49\uFF0C\u8BF7\u6539\u7528\u76EE\u5F55\u8DEF\u5F84\u3002`);
+    }
+  }
+  games.sort((a, b) => a.id.localeCompare(b.id) || a.dir.localeCompare(b.dir));
+  return { root, games, warnings };
+}
+function resolveGame(games, selector) {
+  const asPath = path5.resolve(selector);
+  const byPath = games.find(
+    (game2) => path5.resolve(game2.dir) === asPath || path5.resolve(game2.manifestPath) === asPath
+  );
+  if (byPath) return byPath;
+  const byId = games.filter((game2) => game2.id === selector);
+  if (byId.length === 1) return byId[0];
+  if (byId.length > 1) {
+    throw new Error(
+      `\u6E38\u620F id "${selector}" \u5BF9\u5E94\u591A\u4E2A\u76EE\u5F55:
+${byId.map((game2) => `  - ${game2.dir}`).join("\n")}
+\u8BF7\u6539\u7528\u76EE\u5F55\u8DEF\u5F84\u6307\u5B9A\u3002`
+    );
+  }
+  const byName = games.filter((game2) => game2.name === selector);
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) {
+    throw new Error(
+      `\u6E38\u620F\u540D "${selector}" \u5BF9\u5E94\u591A\u4E2A\u76EE\u5F55:
+${byName.map((game2) => `  - ${game2.dir}`).join("\n")}
+\u8BF7\u6539\u7528 id \u6216\u76EE\u5F55\u8DEF\u5F84\u6307\u5B9A\u3002`
+    );
+  }
+  const available = games.map((game2) => game2.id).join(", ") || "(\u65E0)";
+  throw new Error(`\u627E\u4E0D\u5230\u6E38\u620F "${selector}"\u3002\u53EF\u7528\u6E38\u620F: ${available}`);
+}
+
+// src/host/worker-manager.ts
+import { spawn, spawnSync } from "child_process";
+import {
+  appendFile,
+  mkdir as mkdir2,
+  open as open2,
+  readFile as readFile4,
+  readdir as readdir2,
+  rename as rename2,
+  rm as rm2,
+  writeFile as writeFile2
+} from "fs/promises";
+import path7 from "path";
+
+// src/workspace/package.ts
+import { access, readFile as readFile3 } from "fs/promises";
+import path6 from "path";
+async function pathExists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parsePackageManager(value) {
+  if (typeof value !== "string") return void 0;
+  const name = value.split("@")[0]?.trim();
+  return name === "pnpm" || name === "npm" || name === "yarn" || name === "bun" ? name : void 0;
+}
+async function detectPackageManager(dir, pkg) {
+  const declared = parsePackageManager(pkg.packageManager);
+  if (declared) return declared;
+  if (await pathExists(path6.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path6.join(dir, "yarn.lock"))) return "yarn";
+  if (await pathExists(path6.join(dir, "bun.lockb"))) return "bun";
+  if (await pathExists(path6.join(dir, "bun.lock"))) return "bun";
+  if (await pathExists(path6.join(dir, "package-lock.json"))) return "npm";
+  return "pnpm";
+}
+async function readPackageJson(dir) {
+  const file = path6.join(dir, "package.json");
+  const parsed = JSON.parse(await readFile3(file, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${file} \u5FC5\u987B\u662F JSON \u5BF9\u8C61`);
+  }
+  return parsed;
+}
+
+// src/workspace/ports.ts
+import net2 from "net";
+function isPortFree(port, host2 = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const server = net2.createServer();
+    server.unref();
+    server.once("error", () => resolve(false));
+    server.listen({ port, host: host2, exclusive: true }, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+// src/host/worker-manager.ts
+var START_TIMEOUT_MS = 3e4;
+var STOP_TIMEOUT_MS = 5e3;
+var PROBE_TIMEOUT_MS = 2500;
+var PROBE_CACHE_MS = 2e3;
+var CONFIG_CACHE_MS = 5e3;
+var PORT_SEARCH_LIMIT = 50;
+var WorkerManagerError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "WorkerManagerError";
+  }
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function workerUrl(port) {
+  return `http://127.0.0.1:${port}`;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function writeJsonAtomic2(file, value) {
+  await mkdir2(path7.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename2(temporary, file);
+}
+function parseWranglerPort(toml) {
+  let section = "";
+  for (const line of toml.split(/\r?\n/)) {
+    const heading = /^\s*\[([^\]]+)\]\s*$/.exec(line);
+    if (heading) {
+      section = heading[1].trim();
+      continue;
+    }
+    if (section !== "dev") continue;
+    const match = /^\s*port\s*=\s*(\d+)\s*(?:#.*)?$/.exec(line);
+    if (match) return Number.parseInt(match[1], 10);
+  }
+  return void 0;
+}
+function parseScriptPort(script) {
+  const match = /--port(?:=|\s+)(\d+)/.exec(script);
+  return match ? Number.parseInt(match[1], 10) : void 0;
+}
+async function readWranglerPort(dir) {
+  for (const candidate of [
+    path7.join(dir, "worker", "wrangler.toml"),
+    path7.join(dir, "wrangler.toml")
+  ]) {
+    if (!await pathExists(candidate)) continue;
+    try {
+      const port = parseWranglerPort(await readFile4(candidate, "utf8"));
+      if (port) return port;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function readRecord(value) {
+  if (!isRecord2(value) || value.version !== 1) return null;
+  const gameId = typeof value.gameId === "string" ? value.gameId : "";
+  const dir = typeof value.dir === "string" ? value.dir : "";
+  const pid = typeof value.pid === "number" ? value.pid : 0;
+  const port = typeof value.port === "number" ? value.port : 0;
+  const url = typeof value.url === "string" ? value.url : "";
+  const logFile = typeof value.logFile === "string" ? value.logFile : "";
+  const startedAt = typeof value.startedAt === "string" ? value.startedAt : "";
+  const command = typeof value.command === "string" ? value.command : "";
+  if (!isSafeGameId(gameId) || !dir || !Number.isInteger(pid) || pid <= 0) return null;
+  if (!Number.isInteger(port) || port <= 0 || !url || !logFile || !startedAt) return null;
+  return { version: 1, gameId, dir, pid, port, url, logFile, startedAt, command };
+}
+function workerArgs(config, port) {
+  const args = ["run", "dev"];
+  if (!config.wrangler) return args;
+  if (config.packageManager === "npm") {
+    args.push("--", "--port", String(port));
+  } else {
+    args.push("--port", String(port));
+  }
+  return args;
+}
+function killProcessTree(pid, signal) {
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      windowsHide: true,
+      stdio: "ignore"
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+var WorkerManager = class _WorkerManager {
+  constructor(root, logger) {
+    this.root = root;
+    this.logger = logger;
+  }
+  records = /* @__PURE__ */ new Map();
+  children = /* @__PURE__ */ new Map();
+  configCache = /* @__PURE__ */ new Map();
+  probeCache = /* @__PURE__ */ new Map();
+  static async create(root, logger) {
+    const manager = new _WorkerManager(root, logger);
+    await manager.init();
+    return manager;
+  }
+  async status(gameId, dir, force = false) {
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const logFile = workerLogFile(this.root, gameId);
+    const configResult = await this.getConfig(dir);
+    const record = await this.getRecord(gameId);
+    const port = record?.port ?? configResult.config?.basePort ?? DEFAULT_WORKER_PORT;
+    const url = record?.url ?? workerUrl(port);
+    const probe = await this.probe(url, force);
+    if (probe.reachable && (!probe.metadataId || probe.metadataId === gameId)) {
+      const owned = Boolean(record);
+      return {
+        state: owned ? "running" : "external",
+        reachable: true,
+        url,
+        port,
+        pid: owned ? record?.pid : void 0,
+        owned,
+        minPlayers: probe.minPlayers,
+        maxPlayers: probe.maxPlayers,
+        logFile: record?.logFile ?? logFile,
+        startedAt: record?.startedAt,
+        checkedAt
+      };
+    }
+    if (probe.reachable && probe.metadataId && probe.metadataId !== gameId) {
+      return {
+        state: "error",
+        reachable: false,
+        url,
+        port,
+        owned: false,
+        logFile,
+        checkedAt,
+        error: `\u7AEF\u53E3 ${port} \u4E0A\u7684 Worker \u5C5E\u4E8E "${probe.metadataId}"\uFF0C\u4E0D\u662F "${gameId}"\uFF1B\u7528 --worker-port \u6307\u5B9A\u5176\u4ED6\u7AEF\u53E3\u3002`
+      };
+    }
+    if (record) {
+      if (isProcessAlive(record.pid)) {
+        const age = Date.now() - Date.parse(record.startedAt);
+        const state = Number.isFinite(age) && age > START_TIMEOUT_MS + 15e3 ? "error" : "starting";
+        return {
+          state,
+          reachable: false,
+          url,
+          port,
+          pid: record.pid,
+          owned: true,
+          logFile: record.logFile,
+          startedAt: record.startedAt,
+          checkedAt,
+          error: `Worker \u8FDB\u7A0B ${record.pid} \u6B63\u5728\u8FD0\u884C\uFF0C\u4F46 ${url}/metadata \u65E0\u54CD\u5E94\u3002\u67E5\u770B\u65E5\u5FD7\uFF1Anpgame-dev game logs ${gameId}`
+        };
+      }
+      await this.removeRecord(gameId);
+    }
+    return {
+      state: configResult.error ? "error" : "stopped",
+      reachable: false,
+      owned: false,
+      logFile,
+      checkedAt,
+      error: configResult.error
+    };
+  }
+  async probe(url, force = false) {
+    const cached = this.probeCache.get(url);
+    if (!force && cached && Date.now() - cached.at < PROBE_CACHE_MS) {
+      return cached.result;
+    }
+    let result;
+    try {
+      const response = await fetch(`${url}/metadata`, {
+        signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+        headers: { accept: "application/json" }
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const metadata = await response.json();
+      if (typeof metadata?.id !== "string" || !metadata.id) {
+        throw new Error("\u54CD\u5E94\u7F3A\u5C11\u6E38\u620F id");
+      }
+      result = {
+        reachable: true,
+        metadataId: metadata.id,
+        minPlayers: typeof metadata.minPlayers === "number" ? metadata.minPlayers : void 0,
+        maxPlayers: typeof metadata.maxPlayers === "number" ? metadata.maxPlayers : void 0
+      };
+    } catch (error) {
+      result = { reachable: false, error: errorMessage(error) };
+    }
+    this.probeCache.set(url, { at: Date.now(), result });
+    return result;
+  }
+  async start(game2, options = {}) {
+    const configResult = await this.getConfig(game2.dir);
+    if (!configResult.config) {
+      throw new WorkerManagerError(400, configResult.error ?? "\u65E0\u6CD5\u8BFB\u53D6\u6E38\u620F\u7684 dev \u914D\u7F6E");
+    }
+    const config = configResult.config;
+    const existing = await this.status(game2.id, game2.dir, true);
+    if (existing.state === "running" || existing.state === "external") {
+      return existing;
+    }
+    const nodeModules = path7.join(game2.dir, "node_modules");
+    if (!await pathExists(nodeModules)) {
+      throw new WorkerManagerError(
+        400,
+        `\u6E38\u620F\u4F9D\u8D56\u672A\u5B89\u88C5\uFF1A${nodeModules} \u4E0D\u5B58\u5728\u3002
+\u8BF7\u5148\u8FD0\u884C: npgame-dev game init ${game2.id}`
+      );
+    }
+    const record = await this.getRecord(game2.id);
+    if (record && isProcessAlive(record.pid)) {
+      throw new WorkerManagerError(
+        409,
+        `Worker \u8FDB\u7A0B ${record.pid} \u5DF2\u5B58\u5728\u4F46\u5C1A\u672A\u5C31\u7EEA\u3002
+\u67E5\u770B\u65E5\u5FD7: npgame-dev game logs ${game2.id}
+\u9700\u8981\u91CD\u542F\u65F6\u5148\u8FD0\u884C: npgame-dev game stop ${game2.id}`
+      );
+    }
+    const port = await this.choosePort(options.port ?? config.basePort, options.port !== void 0);
+    const url = workerUrl(port);
+    const logFile = workerLogFile(this.root, game2.id);
+    const args = workerArgs(config, port);
+    const command = [config.packageManager, ...args].join(" ");
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await mkdir2(path7.dirname(logFile), { recursive: true });
+    await appendFile(
+      logFile,
+      `
+===== ${startedAt} npgame-dev game start ${game2.id} =====
+$ ${command}   (cwd: ${game2.dir})
+`,
+      "utf8"
+    );
+    const handle = await open2(logFile, "a");
+    let child;
+    try {
+      child = spawn(config.packageManager, args, {
+        cwd: game2.dir,
+        env: {
+          ...process.env,
+          PORT: String(port),
+          FORCE_COLOR: "1"
+        },
+        detached: true,
+        stdio: ["ignore", handle.fd, handle.fd],
+        shell: process.platform === "win32",
+        windowsHide: true
+      });
+    } catch (error) {
+      await handle.close();
+      throw new WorkerManagerError(502, `\u65E0\u6CD5\u542F\u52A8 ${config.packageManager}: ${errorMessage(error)}`);
+    }
+    await handle.close();
+    if (!child.pid) {
+      throw new WorkerManagerError(
+        502,
+        `\u65E0\u6CD5\u542F\u52A8 ${config.packageManager}\uFF08\u627E\u4E0D\u5230\u547D\u4EE4\u6216\u8FDB\u7A0B\u521B\u5EFA\u5931\u8D25\uFF09\u3002
+\u65E5\u5FD7\uFF1A${logFile}`
+      );
+    }
+    const pid = child.pid;
+    const recordValue = {
+      version: 1,
+      gameId: game2.id,
+      dir: game2.dir,
+      pid,
+      port,
+      url,
+      logFile,
+      startedAt,
+      command
+    };
+    await writeJsonAtomic2(workerRecordFile(this.root, game2.id), recordValue);
+    this.records.set(game2.id, recordValue);
+    this.children.set(game2.id, child);
+    this.probeCache.delete(url);
+    child.once("exit", (code, signal) => {
+      this.children.delete(game2.id);
+      this.probeCache.delete(url);
+      const current = this.records.get(game2.id);
+      if (current?.pid !== pid) return;
+      this.records.delete(game2.id);
+      void rm2(workerRecordFile(this.root, game2.id), { force: true });
+      this.logger.info(
+        `worker ${game2.id} exited (pid ${pid}, code ${code ?? "-"}, signal ${signal ?? "-"})`
+      );
+    });
+    child.once("error", (error) => {
+      this.logger.error(`worker ${game2.id} spawn error: ${error.message}`);
+    });
+    this.logger.info(`worker ${game2.id} starting: ${command} (pid ${pid}, ${url})`);
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (!isProcessAlive(pid)) {
+        const tail2 = await tailFile(logFile, 40);
+        await this.removeRecord(game2.id);
+        throw new WorkerManagerError(
+          502,
+          `Worker \u8FDB\u7A0B\u63D0\u524D\u9000\u51FA\u3002
+${tail2.trim() || `\u65E5\u5FD7\uFF1A${logFile}`}`
+        );
+      }
+      const probe = await this.probe(url, true);
+      if (probe.reachable && (!probe.metadataId || probe.metadataId === game2.id)) {
+        this.logger.info(`worker ${game2.id} ready at ${url}`);
+        return this.status(game2.id, game2.dir, true);
+      }
+      await sleep(250);
+    }
+    const tail = await tailFile(logFile, 40);
+    await this.stop(game2.id, game2.dir, true).catch(() => void 0);
+    throw new WorkerManagerError(
+      504,
+      `Worker \u542F\u52A8\u8D85\u65F6\uFF08${START_TIMEOUT_MS / 1e3}s\uFF09\u3002
+${tail.trim() || `\u65E5\u5FD7\uFF1A${logFile}`}`
+    );
+  }
+  async stop(gameId, dir, force = false) {
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const record = await this.getRecord(gameId);
+    if (!record) {
+      const status = await this.status(gameId, dir, true);
+      if (status.state === "external" || status.reachable) {
+        throw new WorkerManagerError(
+          409,
+          `Worker \u4E0D\u662F\u7531 host \u542F\u52A8\u7684\uFF0Chost \u4E0D\u4F1A\u505C\u6B62\u5B83\u3002
+\u8BF7\u5728\u542F\u52A8\u5B83\u7684\u7EC8\u7AEF\u6309 Ctrl+C\uFF1B--force \u53EA\u80FD\u8DF3\u8FC7\u201C\u623F\u95F4\u6B63\u5728\u8FD0\u884C\u201D\u7684\u68C0\u67E5\u3002`
+        );
+      }
+      return {
+        state: "stopped",
+        reachable: false,
+        owned: false,
+        logFile: status.logFile,
+        checkedAt
+      };
+    }
+    if (!isProcessAlive(record.pid)) {
+      await this.removeRecord(gameId);
+      return {
+        state: "stopped",
+        reachable: false,
+        owned: false,
+        logFile: record.logFile,
+        startedAt: record.startedAt,
+        checkedAt
+      };
+    }
+    this.logger.info(`worker ${gameId} stopping (pid ${record.pid})`);
+    killProcessTree(record.pid, "SIGTERM");
+    const deadline = Date.now() + STOP_TIMEOUT_MS;
+    while (Date.now() < deadline && isProcessAlive(record.pid)) {
+      await sleep(100);
+    }
+    if (isProcessAlive(record.pid)) {
+      killProcessTree(record.pid, "SIGKILL");
+      await sleep(200);
+    }
+    await this.removeRecord(gameId);
+    this.probeCache.delete(record.url);
+    if (!force) this.logger.info(`worker ${gameId} stopped`);
+    return {
+      state: "stopped",
+      reachable: false,
+      owned: false,
+      logFile: record.logFile,
+      startedAt: record.startedAt,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async logs(gameId, lines) {
+    const record = await this.getRecord(gameId);
+    const logFile = record?.logFile ?? workerLogFile(this.root, gameId);
+    return { logFile, text: await tailFile(logFile, lines) };
+  }
+  async shutdown() {
+    const records = [...this.records.values()];
+    if (records.length === 0) return;
+    this.logger.info(`stopping ${records.length} host-owned worker(s)`);
+    for (const record of records) {
+      if (isProcessAlive(record.pid)) {
+        killProcessTree(record.pid, "SIGTERM");
+      }
+    }
+    await sleep(400);
+    for (const record of records) {
+      if (isProcessAlive(record.pid)) {
+        killProcessTree(record.pid, "SIGKILL");
+      }
+      await this.removeRecord(record.gameId);
+    }
+    this.children.clear();
+  }
+  async choosePort(basePort, explicit) {
+    if (await isPortFree(basePort)) return basePort;
+    if (explicit) {
+      throw new WorkerManagerError(409, `\u7AEF\u53E3 ${basePort} \u5DF2\u88AB\u5360\u7528`);
+    }
+    for (let offset = 1; offset <= PORT_SEARCH_LIMIT; offset += 1) {
+      const candidate = basePort + offset;
+      if (candidate > 65535) break;
+      if (await isPortFree(candidate)) {
+        this.logger.info(`worker port ${basePort} busy; using ${candidate}`);
+        return candidate;
+      }
+    }
+    throw new WorkerManagerError(
+      409,
+      `\u7AEF\u53E3 ${basePort}-${basePort + PORT_SEARCH_LIMIT} \u5747\u88AB\u5360\u7528\uFF1B\u7528 --worker-port \u6307\u5B9A\u7AEF\u53E3\u3002`
+    );
+  }
+  async getConfig(dir) {
+    const cached = this.configCache.get(dir);
+    if (cached && Date.now() - cached.at < CONFIG_CACHE_MS) return cached.result;
+    const result = await this.readConfig(dir);
+    this.configCache.set(dir, { at: Date.now(), result });
+    return result;
+  }
+  async readConfig(dir) {
+    const packageJsonPath = path7.join(dir, "package.json");
+    let pkg;
+    try {
+      const parsed = JSON.parse(await readFile4(packageJsonPath, "utf8"));
+      if (!isRecord2(parsed)) throw new Error("package.json \u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+      pkg = parsed;
+    } catch (error) {
+      return {
+        error: `\u65E0\u6CD5\u8BFB\u53D6 ${packageJsonPath}: ${errorMessage(error)}`
+      };
+    }
+    const scripts = isRecord2(pkg.scripts) ? pkg.scripts : {};
+    const script = typeof scripts.dev === "string" ? scripts.dev : "";
+    if (!script) {
+      return {
+        error: `${packageJsonPath} \u7F3A\u5C11 "scripts.dev"\uFF0C\u65E0\u6CD5\u542F\u52A8 Worker`
+      };
+    }
+    const wrangler = /\bwrangler\b/.test(script);
+    const wranglerPort = await readWranglerPort(dir);
+    const scriptPort = parseScriptPort(script);
+    return {
+      config: {
+        packageManager: await detectPackageManager(dir, pkg),
+        script,
+        wrangler,
+        basePort: wranglerPort ?? scriptPort ?? DEFAULT_WORKER_PORT
+      }
+    };
+  }
+  async getRecord(gameId) {
+    const cached = this.records.get(gameId);
+    if (cached) {
+      if (isProcessAlive(cached.pid)) return cached;
+      await this.removeRecord(gameId);
+      return null;
+    }
+    const file = workerRecordFile(this.root, gameId);
+    let raw;
+    try {
+      raw = await readFile4(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      this.logger.error(`\u65E0\u6CD5\u8BFB\u53D6 Worker \u8BB0\u5F55 ${file}: ${errorMessage(error)}`);
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      await rm2(file, { force: true });
+      return null;
+    }
+    const record = readRecord(parsed);
+    if (!record || record.gameId !== gameId) {
+      await rm2(file, { force: true });
+      return null;
+    }
+    if (!isProcessAlive(record.pid)) {
+      await rm2(file, { force: true });
+      return null;
+    }
+    this.records.set(gameId, record);
+    return record;
+  }
+  async removeRecord(gameId) {
+    this.records.delete(gameId);
+    this.children.delete(gameId);
+    await rm2(workerRecordFile(this.root, gameId), { force: true });
+  }
+  async init() {
+    await mkdir2(workersDir(this.root), { recursive: true });
+    let entries;
+    try {
+      entries = await readdir2(workersDir(this.root));
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const gameId = entry.slice(0, -".json".length);
+      if (!isSafeGameId(gameId)) continue;
+      const record = await this.getRecord(gameId);
+      if (record) {
+        this.logger.info(
+          `adopted worker ${record.gameId} (pid ${record.pid}, ${record.url})`
+        );
+      }
+    }
+  }
+};
+
+// src/host/service.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+};
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function normalizeWorkerUrl(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new HttpError(400, `\u65E0\u6548\u7684 Worker URL: ${input}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new HttpError(400, "Worker URL \u5FC5\u987B\u662F http(s)");
+  }
+  return input.replace(/\/+$/, "");
+}
+function sameWorkerUrl(left, right) {
+  if (!right) return false;
+  return left.replace(/\/+$/, "") === right.replace(/\/+$/, "");
+}
+function roomStateOf(state, roomId) {
+  if (!state) return void 0;
+  return {
+    roomId: state.roomId || roomId,
+    phase: state.phase ?? "lobby",
+    gameId: state.gameConfig?.gameId,
+    roleIds: state.gameConfig?.roleIds ?? [],
+    playerCount: state.players ? Object.keys(state.players).length : 0,
+    stateIndex: state.stateIndex
+  };
+}
+function capabilitiesFor(connected, worker, phase) {
+  const roomActive = phase === "playing" || phase === "paused";
+  return {
+    startWorker: worker.state === "stopped" || worker.state === "error",
+    stopWorker: worker.owned && !roomActive,
+    logWorker: true,
+    connect: !connected && worker.reachable,
+    disconnect: connected,
+    startRoom: connected && worker.reachable && (phase === "lobby" || phase === "finished"),
+    stopRoom: connected && roomActive,
+    openConsole: connected
+  };
+}
+var WorkspaceService = class _WorkspaceService {
+  constructor(options, config, workers) {
+    this.options = options;
+    this.workers = workers;
+    this.config = config;
+    this.client = new EngineAdminClient({
+      baseUrl: `http://127.0.0.1:${options.enginePort}`,
+      token: ADMIN_SECRET
+    });
+  }
+  config;
+  client;
+  static async create(options) {
+    const config = await readWorkspaceConfig(options.root);
+    const workers = await WorkerManager.create(options.root, options.logger);
+    return new _WorkspaceService(options, config, workers);
+  }
+  get root() {
+    return this.options.root;
+  }
+  meta() {
+    return {
+      root: this.options.root,
+      pid: process.pid,
+      port: this.options.port,
+      enginePort: this.options.enginePort,
+      url: `http://127.0.0.1:${this.options.port}`,
+      startedAt: this.options.startedAt,
+      version: DEV_VERSION
+    };
+  }
+  isRoomAllowed(roomId) {
+    return this.config.connections.some((connection) => connection.roomId === roomId);
+  }
+  async shutdown() {
+    await this.workers.shutdown();
+  }
+  async listGames() {
+    const scan = await scanGames(this.options.root);
+    const byGame = new Map(this.config.connections.map((connection) => [connection.gameId, connection]));
+    const games = await Promise.all(scan.games.map(
+      (game2) => this.describe(game2.id, game2.name, game2.dir, byGame.get(game2.id))
+    ));
+    const scanned = new Set(scan.games.map((game2) => game2.id));
+    for (const connection of this.config.connections) {
+      if (scanned.has(connection.gameId)) continue;
+      games.push(await this.describe(
+        connection.gameId,
+        connection.name,
+        connection.gameDir,
+        connection,
+        "\u6E38\u620F\u76EE\u5F55\u4E0D\u5728\u626B\u63CF\u8303\u56F4"
+      ));
+    }
+    return {
+      root: this.options.root,
+      games: games.sort((a, b) => {
+        if (a.worker.reachable !== b.worker.reachable) return a.worker.reachable ? -1 : 1;
+        if (a.connected !== b.connected) return a.connected ? -1 : 1;
+        return a.id.localeCompare(b.id);
+      }),
+      warnings: scan.warnings
+    };
+  }
+  async listRooms() {
+    const rooms = await Promise.all(this.config.connections.map(async (connection) => {
+      const [worker, roomResult] = await Promise.all([
+        this.workers.status(connection.gameId, connection.gameDir),
+        this.client.getState(connection.roomId)
+      ]);
+      const state = roomResult.ok ? roomResult.data : void 0;
+      const summary = roomStateOf(state, connection.roomId);
+      return {
+        roomId: connection.roomId,
+        gameId: connection.gameId,
+        name: connection.name,
+        gameDir: connection.gameDir,
+        phase: summary?.phase,
+        roleIds: summary?.roleIds ?? connection.roleIds,
+        playerCount: summary?.playerCount,
+        stateIndex: summary?.stateIndex,
+        worker,
+        error: roomResult.ok ? void 0 : roomResult.status === 404 ? `\u623F\u95F4 "${connection.roomId}" \u4E0D\u5B58\u5728\uFF0C\u8BF7\u91CD\u65B0 connect` : `\u8BFB\u53D6\u623F\u95F4\u72B6\u6001\u5931\u8D25: ${roomResult.error}`
+      };
+    }));
+    return {
+      root: this.options.root,
+      rooms: rooms.sort((a, b) => a.roomId.localeCompare(b.roomId)),
+      warnings: []
+    };
+  }
+  async connect(selector, input) {
+    const scan = await scanGames(this.options.root);
+    let game2;
+    try {
+      game2 = resolveGame(scan.games, selector);
+    } catch (error) {
+      throw new HttpError(404, errorMessage2(error));
+    }
+    const existing = this.config.connections.find((connection2) => connection2.gameId === game2.id);
+    const roomId = input.roomId?.trim() || existing?.roomId || game2.id;
+    if (!isSafeGameId(roomId)) {
+      throw new HttpError(400, `\u975E\u6CD5\u623F\u95F4 id "${roomId}"\uFF08\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001. _ -\uFF09`);
+    }
+    const duplicate = this.config.connections.find(
+      (connection2) => connection2.roomId === roomId && connection2.gameId !== game2.id
+    );
+    if (duplicate) {
+      throw new HttpError(409, `\u623F\u95F4 "${roomId}" \u5DF2\u88AB\u6E38\u620F "${duplicate.gameId}" \u4F7F\u7528`);
+    }
+    let workerUrl2;
+    if (input.workerUrl?.trim()) {
+      workerUrl2 = normalizeWorkerUrl(input.workerUrl.trim());
+    } else {
+      const worker = await this.workers.status(game2.id, game2.dir, true);
+      workerUrl2 = normalizeWorkerUrl(
+        worker.reachable && worker.url ? worker.url : existing?.workerUrl ?? DEFAULT_WORKER_URL
+      );
+    }
+    const probe = await this.workers.probe(workerUrl2, true);
+    if (!probe.reachable) {
+      throw new HttpError(
+        502,
+        `Worker \u4E0D\u53EF\u8FBE (${workerUrl2}): ${probe.error ?? "unknown error"}
+\u5148\u8FD0\u884C npgame-dev game start ${game2.id}\uFF0C\u6216\u7528 --worker-url \u6307\u5B9A\u5730\u5740\u3002`
+      );
+    }
+    if (probe.metadataId && probe.metadataId !== game2.id) {
+      throw new HttpError(
+        409,
+        `Worker URL ${workerUrl2} \u4E0A\u7684\u6E38\u620F\u662F "${probe.metadataId}"\uFF0C\u4E0D\u662F "${game2.id}"\u3002`
+      );
+    }
+    let state = await this.getRoomState(roomId);
+    if (!state || !state.roomId) {
+      const created = await this.client.createRoom(roomId, FIXED_OWNER_ID);
+      if (!created.ok) {
+        throw new HttpError(502, `\u521B\u5EFA\u623F\u95F4\u5931\u8D25: ${created.error}`);
+      }
+      state = await this.getRoomState(roomId);
+      if (!state?.roomId) throw new HttpError(502, "\u521B\u5EFA\u623F\u95F4\u540E\u65E0\u6CD5\u8BFB\u53D6\u72B6\u6001");
+    }
+    if (state.phase !== "lobby") {
+      const stopped = await this.client.stopGame(roomId);
+      if (!stopped.ok) {
+        throw new HttpError(409, `\u623F\u95F4\u6B63\u5728 ${state.phase}\uFF0C\u505C\u6B62\u5931\u8D25: ${stopped.error}`);
+      }
+    }
+    const set = await this.client.setGame(roomId, {
+      gameWorkerUrl: workerUrl2,
+      selectedPlayerCount: input.players ?? existing?.players
+    });
+    if (!set.ok) {
+      throw new HttpError(502, `\u8FDE\u63A5\u6E38\u620F\u5931\u8D25: ${set.error}`);
+    }
+    if (existing && existing.roomId !== roomId) {
+      const oldState = await this.getRoomState(existing.roomId);
+      if (oldState?.roomId && oldState.phase !== "lobby") {
+        const stopped = await this.client.stopGame(existing.roomId);
+        if (!stopped.ok) {
+          throw new HttpError(409, `\u505C\u6B62\u65E7\u623F\u95F4 ${existing.roomId} \u5931\u8D25: ${stopped.error}`);
+        }
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const connection = {
+      roomId,
+      gameId: game2.id,
+      name: game2.name,
+      gameDir: game2.dir,
+      workerUrl: workerUrl2,
+      players: input.players ?? existing?.players,
+      roleIds: set.data.roleIds,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now
+    };
+    this.config.connections = [
+      ...this.config.connections.filter(
+        (item) => item.gameId !== game2.id && item.roomId !== roomId
+      ),
+      connection
+    ];
+    await writeWorkspaceConfig(this.options.root, this.config);
+    this.options.logger.info(
+      `connect ${game2.id} -> room ${roomId} (worker ${workerUrl2}, roles ${connection.roleIds.join(", ") || "-"})`
+    );
+    return this.describe(game2.id, game2.name, game2.dir, connection);
+  }
+  async disconnect(selector) {
+    const connection = findConnection(this.config, selector);
+    if (!connection) {
+      throw new HttpError(404, `\u6E38\u620F\u6216\u623F\u95F4 "${selector}" \u672A\u8FDE\u63A5`);
+    }
+    const state = await this.getRoomState(connection.roomId);
+    if (state && state.phase !== "lobby") {
+      const stopped = await this.client.stopGame(connection.roomId);
+      if (!stopped.ok) {
+        throw new HttpError(409, `\u505C\u6B62\u623F\u95F4\u5931\u8D25: ${stopped.error}`);
+      }
+    }
+    this.config.connections = this.config.connections.filter(
+      (item) => item.roomId !== connection.roomId
+    );
+    await writeWorkspaceConfig(this.options.root, this.config);
+    this.options.logger.info(`disconnect ${connection.gameId} (room ${connection.roomId})`);
+  }
+  async startWorker(selector, port) {
+    const game2 = await this.resolveScannedGame(selector);
+    try {
+      const worker = await this.workers.start(game2, { port });
+      return { gameId: game2.id, worker };
+    } catch (error) {
+      throw this.workerHttpError(error);
+    }
+  }
+  async stopWorker(selector, force = false) {
+    const target = await this.resolveWorkerTarget(selector);
+    if (!force && target.connection) {
+      const state = await this.getRoomState(target.connection.roomId);
+      if (state && (state.phase === "playing" || state.phase === "paused")) {
+        throw new HttpError(
+          409,
+          `\u623F\u95F4 "${target.connection.roomId}" \u6B63\u5728 ${state.phase}\uFF0C\u5148\u8FD0\u884C npgame-dev room stop ${target.connection.roomId}\uFF0C\u6216\u52A0 --force\u3002`
+        );
+      }
+    }
+    try {
+      const worker = await this.workers.stop(target.id, target.dir, force);
+      return { gameId: target.id, worker };
+    } catch (error) {
+      throw this.workerHttpError(error);
+    }
+  }
+  async workerLogs(selector, lines) {
+    const target = await this.resolveWorkerTarget(selector);
+    const { logFile, text } = await this.workers.logs(target.id, lines);
+    return { gameId: target.id, logFile, lines, text };
+  }
+  async startRoom(selector) {
+    const connection = findConnection(this.config, selector);
+    if (!connection) {
+      throw new HttpError(404, `\u6E38\u620F\u6216\u623F\u95F4 "${selector}" \u672A\u8FDE\u63A5\uFF0C\u8BF7\u5148\u8FD0\u884C connect`);
+    }
+    let workerUrl2 = connection.workerUrl;
+    let probe = await this.workers.probe(workerUrl2, true);
+    if (!probe.reachable || probe.metadataId && probe.metadataId !== connection.gameId) {
+      const worker = await this.workers.status(connection.gameId, connection.gameDir, true);
+      if (worker.reachable && worker.url) {
+        workerUrl2 = worker.url;
+        probe = await this.workers.probe(workerUrl2, true);
+        if (probe.reachable) {
+          this.options.logger.info(
+            `room start: worker moved ${connection.workerUrl} -> ${workerUrl2}`
+          );
+          connection.workerUrl = workerUrl2;
+        }
+      }
+    }
+    if (!probe.reachable) {
+      throw new HttpError(
+        502,
+        `Worker \u4E0D\u53EF\u8FBE (${workerUrl2}): ${probe.error ?? "unknown error"}
+\u5148\u8FD0\u884C npgame-dev game start ${connection.gameId}\u3002`
+      );
+    }
+    if (probe.metadataId && probe.metadataId !== connection.gameId) {
+      throw new HttpError(
+        409,
+        `Worker URL ${workerUrl2} \u4E0A\u7684\u6E38\u620F\u662F "${probe.metadataId}"\uFF0C\u4E0D\u662F "${connection.gameId}"\u3002`
+      );
+    }
+    let state = await this.getRoomState(connection.roomId);
+    if (!state) {
+      throw new HttpError(409, `\u623F\u95F4 "${connection.roomId}" \u4E0D\u5B58\u5728\uFF0C\u8BF7\u91CD\u65B0 connect`);
+    }
+    if (state.phase !== "lobby") {
+      const stopped = await this.client.stopGame(connection.roomId);
+      if (!stopped.ok) {
+        throw new HttpError(409, `\u505C\u6B62\u5F53\u524D\u6E38\u620F\u5931\u8D25: ${stopped.error}`);
+      }
+      state = await this.getRoomState(connection.roomId);
+    }
+    if (!state?.gameConfig?.roleIds?.length || !sameWorkerUrl(workerUrl2, state.gameConfig.gameWorkerUrl)) {
+      const set = await this.client.setGame(connection.roomId, {
+        gameWorkerUrl: workerUrl2,
+        selectedPlayerCount: connection.players
+      });
+      if (!set.ok) throw new HttpError(502, `\u8BBE\u7F6E\u6E38\u620F\u5931\u8D25: ${set.error}`);
+      state = await this.getRoomState(connection.roomId);
+    }
+    const roleIds = state?.gameConfig?.roleIds ?? connection.roleIds;
+    if (roleIds.length === 0) {
+      throw new HttpError(502, "\u6E38\u620F\u6CA1\u6709\u89D2\u8272\uFF0C\u65E0\u6CD5\u5206\u914D\u73A9\u5BB6");
+    }
+    for (const [index, roleId] of roleIds.entries()) {
+      const player = await this.client.createPlayer(connection.roomId, {
+        roleId,
+        displayName: `dev${index + 1}`
+      });
+      if (!player.ok) throw new HttpError(502, `\u521B\u5EFA\u73A9\u5BB6\u5931\u8D25: ${player.error}`);
+      const assigned = await this.client.assignRole(
+        connection.roomId,
+        roleId,
+        player.data.userId
+      );
+      if (!assigned.ok) throw new HttpError(502, `\u5206\u914D\u89D2\u8272\u5931\u8D25: ${assigned.error}`);
+    }
+    const started = await this.client.startGame(connection.roomId);
+    if (!started.ok) throw new HttpError(502, `\u5F00\u59CB\u6E38\u620F\u5931\u8D25: ${started.error}`);
+    connection.roleIds = roleIds;
+    connection.workerUrl = workerUrl2;
+    connection.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeWorkspaceConfig(this.options.root, this.config);
+    this.options.logger.info(
+      `room start ${connection.roomId} (${connection.gameId}, roles ${roleIds.join(", ")})`
+    );
+    const finalState = await this.getRoomState(connection.roomId);
+    return {
+      roomId: connection.roomId,
+      phase: finalState?.phase ?? "playing",
+      roleIds
+    };
+  }
+  async stopRoom(selector) {
+    const connection = findConnection(this.config, selector);
+    if (!connection) {
+      throw new HttpError(404, `\u6E38\u620F\u6216\u623F\u95F4 "${selector}" \u672A\u8FDE\u63A5`);
+    }
+    const state = await this.getRoomState(connection.roomId);
+    if (!state) {
+      throw new HttpError(409, `\u623F\u95F4 "${connection.roomId}" \u4E0D\u5B58\u5728`);
+    }
+    if (state.phase === "lobby") {
+      return { roomId: connection.roomId, phase: "lobby", roleIds: connection.roleIds };
+    }
+    const stopped = await this.client.stopGame(connection.roomId);
+    if (!stopped.ok) throw new HttpError(409, `\u505C\u6B62\u6E38\u620F\u5931\u8D25: ${stopped.error}`);
+    this.options.logger.info(`room stop ${connection.roomId} (${connection.gameId})`);
+    return {
+      roomId: connection.roomId,
+      phase: "lobby",
+      roleIds: connection.roleIds
+    };
+  }
+  async describe(id, name, dir, connection, orphanError) {
+    const worker = await this.workers.status(id, dir);
+    let room2;
+    let roomError = orphanError;
+    if (connection) {
+      const roomResult = await this.client.getState(connection.roomId);
+      if (roomResult.ok) {
+        room2 = roomStateOf(roomResult.data, connection.roomId);
+      } else {
+        roomError = roomResult.status === 404 ? `\u623F\u95F4 "${connection.roomId}" \u4E0D\u5B58\u5728\uFF0C\u8BF7\u91CD\u65B0 connect` : `\u8BFB\u53D6\u623F\u95F4\u72B6\u6001\u5931\u8D25: ${roomResult.error}`;
+      }
+    }
+    return {
+      id,
+      name,
+      dir,
+      worker,
+      connected: Boolean(connection),
+      connection,
+      room: room2,
+      roomError,
+      capabilities: capabilitiesFor(Boolean(connection), worker, room2?.phase)
+    };
+  }
+  async resolveScannedGame(selector) {
+    const scan = await scanGames(this.options.root);
+    try {
+      return resolveGame(scan.games, selector);
+    } catch (error) {
+      throw new HttpError(404, errorMessage2(error));
+    }
+  }
+  async resolveWorkerTarget(selector) {
+    const scan = await scanGames(this.options.root);
+    try {
+      const game2 = resolveGame(scan.games, selector);
+      return {
+        id: game2.id,
+        name: game2.name,
+        dir: game2.dir,
+        connection: this.config.connections.find((item) => item.gameId === game2.id)
+      };
+    } catch {
+      const connection = findConnection(this.config, selector);
+      if (connection) {
+        return {
+          id: connection.gameId,
+          name: connection.name,
+          dir: connection.gameDir,
+          connection
+        };
+      }
+      throw new HttpError(404, `\u627E\u4E0D\u5230\u6E38\u620F\u6216\u623F\u95F4 "${selector}"`);
+    }
+  }
+  workerHttpError(error) {
+    if (error instanceof HttpError) return error;
+    if (error instanceof WorkerManagerError) {
+      return new HttpError(error.status, error.message);
+    }
+    return new HttpError(500, errorMessage2(error));
+  }
+  async getRoomState(roomId) {
+    const result = await this.client.getState(roomId);
+    if (result.ok) return result.data;
+    if (result.status === 404) return null;
+    throw new HttpError(502, `\u8BFB\u53D6\u623F\u95F4\u72B6\u6001\u5931\u8D25: ${result.error}`);
+  }
+};
 
-// src/constants.ts
-var ADMIN_SECRET = "nexus-dev-secret";
-var JWT_SECRET = "nexus-dev-jwt-secret";
-var FIXED_ROOM_ID = "dev-room";
-var FIXED_OWNER_ID = "dev-owner";
-var DEFAULT_PORT = 56512;
+// src/host/api.ts
+var MAX_BODY_BYTES = 64 * 1024;
+async function readJsonBody(req) {
+  const contentType = String(req.headers["content-type"] ?? "").toLowerCase();
+  if (!contentType.startsWith("application/json")) {
+    throw new HttpError(415, "Content-Type \u5FC5\u987B\u662F application/json");
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > MAX_BODY_BYTES) throw new HttpError(413, "\u8BF7\u6C42\u4F53\u8FC7\u5927");
+    chunks.push(buffer);
+  }
+  if (size === 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new HttpError(400, "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new HttpError(400, "\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+  }
+  return parsed;
+}
+function stringField2(body, field) {
+  const value = body[field];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new HttpError(400, `\u5B57\u6BB5 "${field}" \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+  }
+  return value.trim();
+}
+function positiveIntField(body, field) {
+  const value = body[field];
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new HttpError(400, `\u5B57\u6BB5 "${field}" \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
+  }
+  return value;
+}
+function booleanField(body, field) {
+  const value = body[field];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new HttpError(400, `\u5B57\u6BB5 "${field}" \u5FC5\u987B\u662F\u5E03\u5C14\u503C`);
+  }
+  return value;
+}
+function queryInt(url, field, fallback, max) {
+  const raw = url.searchParams.get(field);
+  if (raw === null) return fallback;
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isInteger(value) || value <= 0 || value > max) {
+    throw new HttpError(400, `\u67E5\u8BE2\u53C2\u6570 "${field}" \u5FC5\u987B\u662F 1-${max} \u7684\u6574\u6570`);
+  }
+  return value;
+}
+function decodeSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    throw new HttpError(400, "\u975E\u6CD5\u8DEF\u5F84\u53C2\u6570");
+  }
+}
+function isLoopbackOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    return url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]", "::1"].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function originAllowed(req) {
+  const origin = req.headers.origin;
+  if (!origin) return true;
+  return isLoopbackOrigin(origin);
+}
+function createWorkspaceApiHandler(service) {
+  return async (req, res, url) => {
+    if (url.pathname !== "/api/workspace" && !url.pathname.startsWith("/api/workspace/")) {
+      return false;
+    }
+    try {
+      if (!originAllowed(req)) {
+        throw new HttpError(403, "Origin not allowed");
+      }
+      const method = req.method ?? "GET";
+      if (url.pathname === "/api/workspace/meta") {
+        if (method !== "GET") throw new HttpError(405, "Method not allowed");
+        sendJson(res, 200, service.meta());
+        return true;
+      }
+      if (url.pathname === "/api/workspace/games") {
+        if (method !== "GET") throw new HttpError(405, "Method not allowed");
+        sendJson(res, 200, await service.listGames());
+        return true;
+      }
+      if (url.pathname === "/api/workspace/rooms") {
+        if (method !== "GET") throw new HttpError(405, "Method not allowed");
+        sendJson(res, 200, await service.listRooms());
+        return true;
+      }
+      let match = /^\/api\/workspace\/games\/([^/]+)\/worker\/(start|stop|logs)$/.exec(url.pathname);
+      if (match) {
+        const gameId = decodeSegment(match[1]);
+        const action = match[2];
+        if (action === "logs") {
+          if (method !== "GET") throw new HttpError(405, "Method not allowed");
+          const lines = queryInt(url, "lines", 200, 5e3);
+          sendJson(res, 200, await service.workerLogs(gameId, lines));
+          return true;
+        }
+        if (method !== "POST") throw new HttpError(405, "Method not allowed");
+        const body = await readJsonBody(req);
+        if (action === "start") {
+          sendJson(res, 200, await service.startWorker(
+            gameId,
+            positiveIntField(body, "port")
+          ));
+          return true;
+        }
+        sendJson(res, 200, await service.stopWorker(
+          gameId,
+          booleanField(body, "force") ?? false
+        ));
+        return true;
+      }
+      match = /^\/api\/workspace\/games\/([^/]+)$/.exec(url.pathname);
+      if (match) {
+        if (method !== "GET") throw new HttpError(405, "Method not allowed");
+        const gameId = decodeSegment(match[1]);
+        const list = await service.listGames();
+        const game2 = list.games.find((item) => item.id === gameId);
+        if (!game2) throw new HttpError(404, `\u627E\u4E0D\u5230\u6E38\u620F "${gameId}"`);
+        sendJson(res, 200, game2);
+        return true;
+      }
+      match = /^\/api\/workspace\/games\/([^/]+)\/connect$/.exec(url.pathname);
+      if (match) {
+        if (method !== "POST") throw new HttpError(405, "Method not allowed");
+        const gameId = decodeSegment(match[1]);
+        const body = await readJsonBody(req);
+        const game2 = await service.connect(gameId, {
+          workerUrl: stringField2(body, "workerUrl"),
+          players: positiveIntField(body, "players"),
+          roomId: stringField2(body, "roomId")
+        });
+        sendJson(res, 200, game2);
+        return true;
+      }
+      match = /^\/api\/workspace\/games\/([^/]+)\/disconnect$/.exec(url.pathname);
+      if (match) {
+        if (method !== "POST") throw new HttpError(405, "Method not allowed");
+        const gameId = decodeSegment(match[1]);
+        await service.disconnect(gameId);
+        sendJson(res, 200, { ok: true });
+        return true;
+      }
+      match = /^\/api\/workspace\/rooms\/([^/]+)\/(start|stop)$/.exec(url.pathname);
+      if (match) {
+        if (method !== "POST") throw new HttpError(405, "Method not allowed");
+        const roomId = decodeSegment(match[1]);
+        const action = match[2];
+        const result = action === "start" ? await service.startRoom(roomId) : await service.stopRoom(roomId);
+        sendJson(res, 200, result);
+        return true;
+      }
+      throw new HttpError(404, "Not found");
+    } catch (error) {
+      if (res.headersSent) {
+        res.destroy();
+        return true;
+      }
+      const status = error instanceof HttpError ? error.status : 500;
+      const message = error instanceof Error ? error.message : "Internal error";
+      sendJson(res, status, { error: message });
+      return true;
+    }
+  };
+}
 
-// src/commands/start.ts
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-async function startCommand(options) {
-  const port = parseInt(options.port || String(DEFAULT_PORT), 10);
-  const persistDir = path.resolve(process.cwd(), ".nexus");
-  console.log("\u{1F680} \u542F\u52A8\u661F\u67A2\u6C99\u76D2\u5F15\u64CE...");
-  const scriptPath = path.join(__dirname, "engine-worker.js");
-  const contents = await readFile(scriptPath, "utf8");
+// src/host/server.ts
+async function startHostServer(options) {
+  return startConsoleServer({
+    publicPort: options.port,
+    enginePort: options.enginePort,
+    consoleDir: options.consoleDir,
+    rootPage: "workspace.html",
+    roomPage: "index.html",
+    isRoomAllowed: (roomId) => options.service.isRoomAllowed(roomId),
+    handleApi: createWorkspaceApiHandler(options.service),
+    appName: "Workspace Host"
+  });
+}
+
+// src/host/logger.ts
+import { appendFile as appendFile2, mkdir as mkdir3 } from "fs/promises";
+import path8 from "path";
+var HostLogger = class _HostLogger {
+  constructor(file) {
+    this.file = file;
+  }
+  queue = Promise.resolve();
+  static async create(file) {
+    await mkdir3(path8.dirname(file), { recursive: true });
+    return new _HostLogger(file);
+  }
+  info(message) {
+    this.write("INFO", message, false);
+  }
+  error(message) {
+    this.write("ERROR", message, true);
+  }
+  async flush() {
+    await this.queue;
+  }
+  write(level, message, toStderr) {
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level} ${message}`;
+    if (toStderr) console.error(line);
+    else console.log(line);
+    this.queue = this.queue.then(() => appendFile2(this.file, `${line}
+`, "utf8")).catch(() => void 0);
+  }
+};
+
+// src/local-engine.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Miniflare } from "miniflare";
+var __dirname2 = path9.dirname(fileURLToPath2(import.meta.url));
+function resolveEngineWorker() {
+  const candidates = [
+    process.env.NEXUS_ENGINE_WORKER,
+    path9.join(__dirname2, "engine-worker.js"),
+    path9.resolve(process.cwd(), "nexus-engine/dist/engine-worker.js"),
+    path9.resolve(process.cwd(), "../nexus-engine/dist/engine-worker.js"),
+    path9.resolve(__dirname2, "../../../nexus-engine/dist/engine-worker.js")
+  ].filter((candidate) => Boolean(candidate));
+  const found = candidates.find((candidate) => existsSync3(candidate));
+  if (!found) {
+    throw new Error(
+      "\u627E\u4E0D\u5230 engine-worker.js\u3002\u8BF7\u5148\u8FD0\u884C make build-cli-engine\uFF0C\u6216\u8BBE\u7F6E NEXUS_ENGINE_WORKER\u3002"
+    );
+  }
+  return found;
+}
+async function createLocalEngine(options) {
+  const contents = await readFile5(resolveEngineWorker(), "utf8");
   const mf = new Miniflare({
     modules: [{ type: "ESModule", path: "engine-worker.js", contents }],
-    port,
+    port: options.enginePort,
     durableObjects: { GAME_DO: "GameDO" },
-    durableObjectsPersist: path.join(persistDir, "do"),
+    durableObjectsPersist: path9.join(options.persistDir, "do"),
     bindings: {
       ADMIN_SECRET,
       JWT_SECRET
@@ -44,258 +2131,1005 @@ async function startCommand(options) {
       });
     }
   });
-  const url = await mf.ready;
-  console.log(`\u2705 Engine \u5DF2\u542F\u52A8: ${url}`);
-  console.log(`\u{1F4C2} \u6301\u4E45\u5316\u76EE\u5F55: ${persistDir}`);
-  console.log(`
-\u6309 Ctrl+C \u505C\u6B62\u5F15\u64CE
-`);
-  const shutdown = async () => {
-    console.log("\n\u{1F6D1} \u6B63\u5728\u5173\u95ED\u5F15\u64CE...");
-    await mf.dispose();
-    console.log("\u{1F44B} \u5F15\u64CE\u5DF2\u5173\u95ED");
+  await mf.ready;
+  return mf;
+}
+
+// src/commands/serve.ts
+function parsePort(value, fallback, flag) {
+  if (value === void 0) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`${flag} \u5FC5\u987B\u662F 1-65535 \u7684\u7AEF\u53E3\uFF0C\u6536\u5230 "${value}"`);
+  }
+  return parsed;
+}
+async function hostResponds(port) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/api/workspace/meta`, {
+      signal: AbortSignal.timeout(1e3),
+      headers: { accept: "application/json" }
+    });
+    await response.body?.cancel().catch(() => void 0);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function serveCommand(options) {
+  const root = path10.resolve(options.root ?? process.cwd());
+  const port = parsePort(options.port, DEFAULT_PORT, "--port");
+  const enginePort = parsePort(options.enginePort, port + 1, "--engine-port");
+  if (port === enginePort) {
+    throw new Error("--port \u548C --engine-port \u4E0D\u80FD\u76F8\u540C");
+  }
+  const existing = await readHostRecord(root);
+  if (existing) {
+    if (isHostRecordAlive(existing)) {
+      if (await hostResponds(existing.port)) {
+        throw new Error(
+          `Workspace host \u5DF2\u5728\u8FD0\u884C: ${existing.url}
+\u7BA1\u7406\u9875: ${existing.url}/`
+        );
+      }
+      throw new Error(
+        `Host \u8BB0\u5F55\u663E\u793A\u8FDB\u7A0B ${existing.pid} \u4ECD\u5B58\u5728\uFF0C\u4F46 ${existing.url} \u65E0\u54CD\u5E94\u3002
+\u5982\u786E\u8BA4\u5DF2\u5361\u6B7B\uFF0C\u5220\u9664 ${hostRecordFile(root)} \u540E\u91CD\u8BD5\u3002`
+      );
+    }
+    await removeHostRecord(root);
+  }
+  if (!await isPortFree(port)) {
+    throw new Error(`\u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528`);
+  }
+  if (!await isPortFree(enginePort)) {
+    throw new Error(`\u5F15\u64CE\u7AEF\u53E3 ${enginePort} \u5DF2\u88AB\u5360\u7528`);
+  }
+  const logger = await HostLogger.create(hostLogFile(root));
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  logger.info(`workspace host starting: root=${root} port=${port} enginePort=${enginePort}`);
+  await mkdir4(hostEngineStateDir(root), { recursive: true });
+  let mf;
+  let server;
+  let service;
+  let shuttingDown = false;
+  const cleanup = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await removeHostRecord(root, process.pid).catch(() => void 0);
+    logger.info("workspace host stopping");
+    await service?.shutdown().catch(() => void 0);
+    await server?.close().catch(() => void 0);
+    await mf?.dispose().catch(() => void 0);
+    await logger.flush();
+  };
+  try {
+    mf = await createLocalEngine({
+      enginePort,
+      persistDir: hostEngineStateDir(root)
+    });
+    service = await WorkspaceService.create({
+      root,
+      port,
+      enginePort,
+      startedAt,
+      logger
+    });
+    const consoleDir = resolveConsoleDir();
+    server = await startHostServer({
+      service,
+      consoleDir,
+      port,
+      enginePort
+    });
+    await writeHostRecord(root, {
+      version: 1,
+      pid: process.pid,
+      root,
+      port,
+      enginePort,
+      url: server.url,
+      startedAt
+    });
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+  if (!server) {
+    await cleanup();
+    throw new Error("Host server \u672A\u80FD\u542F\u52A8");
+  }
+  console.log("");
+  console.log("\u2705 Workspace host \u5DF2\u542F\u52A8");
+  console.log(`   \u7BA1\u7406\u9875: ${server.url}/`);
+  console.log(`   \u5F15\u64CE:   127.0.0.1:${enginePort}`);
+  console.log(`   \u6839\u76EE\u5F55: ${root}`);
+  console.log(`   \u8FDE\u63A5\u914D\u7F6E: ${workspaceConfigFile(root)}`);
+  console.log(`   \u65E5\u5FD7:   ${hostLogFile(root)}`);
+  console.log("");
+  console.log("\u4E0B\u4E00\u6B65\uFF1A");
+  console.log("  1. npgame-dev game start <game>      # \u542F\u52A8\u6E38\u620F Worker");
+  console.log("  2. npgame-dev connect <game>         # \u5199\u5165\u623F\u95F4\u914D\u7F6E");
+  console.log("  3. npgame-dev room start <game>      # \u5206\u914D dev \u73A9\u5BB6\u5E76\u5F00\u5C40");
+  console.log("");
+  console.log("\u6309 Ctrl+C \u505C\u6B62 host \u53CA\u5B83\u542F\u52A8\u7684 Worker\uFF1B\u5916\u90E8\u542F\u52A8\u7684 Worker \u4E0D\u53D7\u5F71\u54CD");
+  console.log("");
+  const shutdown = async (signal) => {
+    logger.info(`received ${signal}`);
+    await cleanup();
     process.exit(0);
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.removeAllListeners("SIGINT");
+  process.removeAllListeners("SIGTERM");
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
   await new Promise(() => {
   });
 }
 
-// src/client.ts
-var EngineClient = class {
+// src/commands/connect.ts
+import path11 from "path";
+import chalk from "chalk";
+
+// ../workspace-client/src/index.ts
+var WorkspaceApiError = class extends Error {
+  status;
+  data;
+  constructor(message, status, data) {
+    super(message);
+    this.name = "WorkspaceApiError";
+    this.status = status;
+    this.data = data;
+  }
+};
+var WorkspaceClient = class {
   baseUrl;
-  constructor(port = DEFAULT_PORT) {
-    this.baseUrl = `http://localhost:${port}`;
+  fetchImpl;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? "").replace(/\/+$/, "");
+    this.fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
   }
-  get headers() {
-    return {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${ADMIN_SECRET}`
-    };
+  meta() {
+    return this.request("GET", "/api/workspace/meta");
   }
-  async createRoom() {
-    const res = await fetch(`${this.baseUrl}/api/engine/create`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({
-        roomId: FIXED_ROOM_ID,
-        ownerId: FIXED_OWNER_ID
-      })
-    });
-    return res.json();
+  listGames() {
+    return this.request("GET", "/api/workspace/games");
   }
-  async getState() {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}`,
-      { headers: this.headers }
+  listRooms() {
+    return this.request("GET", "/api/workspace/rooms");
+  }
+  connect(gameId, request = {}) {
+    return this.request(
+      "POST",
+      `/api/workspace/games/${encodeURIComponent(gameId)}/connect`,
+      request
     );
-    return res.json();
   }
-  async getPerspective(roleId) {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}/perspective?roleId=${encodeURIComponent(roleId)}`,
-      { headers: this.headers }
+  disconnect(gameId) {
+    return this.request(
+      "POST",
+      `/api/workspace/games/${encodeURIComponent(gameId)}/disconnect`
     );
-    return res.json();
   }
-  async submitAction(roleId, action) {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}/action`,
-      {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify({ roleId, action })
-      }
+  startWorker(gameId, request = {}) {
+    return this.request(
+      "POST",
+      `/api/workspace/games/${encodeURIComponent(gameId)}/worker/start`,
+      request
     );
-    return res.json();
   }
-  async setGame(gameWorkerUrl, gameId, players) {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}/set-game`,
-      {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify({ gameWorkerUrl, gameId, selectedPlayerCount: players })
-      }
+  stopWorker(gameId, request = {}) {
+    return this.request(
+      "POST",
+      `/api/workspace/games/${encodeURIComponent(gameId)}/worker/stop`,
+      request
     );
-    return res.json();
   }
-  async startGame() {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}/start-game`,
-      { method: "POST", headers: this.headers, body: "{}" }
+  workerLogs(gameId, lines = 200) {
+    const query = new URLSearchParams({ lines: String(lines) });
+    return this.request(
+      "GET",
+      `/api/workspace/games/${encodeURIComponent(gameId)}/worker/logs?${query}`
     );
-    return res.json();
   }
-  async stopGame() {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}/stop-game`,
-      { method: "POST", headers: this.headers, body: "{}" }
+  startRoom(roomId) {
+    return this.request(
+      "POST",
+      `/api/workspace/rooms/${encodeURIComponent(roomId)}/start`
     );
-    return res.json();
   }
-  async restartGame() {
-    const res = await fetch(
-      `${this.baseUrl}/api/monitor/room/${FIXED_ROOM_ID}/restart-game`,
-      { method: "POST", headers: this.headers, body: "{}" }
+  stopRoom(roomId) {
+    return this.request(
+      "POST",
+      `/api/workspace/rooms/${encodeURIComponent(roomId)}/stop`
     );
-    return res.json();
+  }
+  async request(method, path18, body) {
+    let response;
+    try {
+      response = await this.fetchImpl(`${this.baseUrl}${path18}`, {
+        method,
+        headers: body === void 0 ? { accept: "application/json" } : { accept: "application/json", "content-type": "application/json" },
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      });
+    } catch (error) {
+      throw new WorkspaceApiError(
+        error instanceof Error ? error.message : "Workspace host is unreachable"
+      );
+    }
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = text;
+      }
+    }
+    if (!response.ok) {
+      const message = typeof payload === "object" && payload !== null && typeof payload.error === "string" ? payload.error : `HTTP ${response.status}`;
+      throw new WorkspaceApiError(message, response.status, payload);
+    }
+    return payload;
   }
 };
 
-// src/commands/setup.ts
-async function setupCommand(options) {
-  const port = parseInt(options.port || String(DEFAULT_PORT), 10);
-  const client = new EngineClient(port);
+// src/workspace/util.ts
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var WIDE_CHAR = /[ᄀ-ᅟ⺀-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦]/;
+function displayWidth(value) {
+  let width = 0;
+  for (const char of value) width += WIDE_CHAR.test(char) ? 2 : 1;
+  return width;
+}
+function padDisplay(value, width) {
+  return value + " ".repeat(Math.max(0, width - displayWidth(value)));
+}
+
+// src/host/client.ts
+function parsePortOption(value, flag = "--port") {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`${flag} \u5FC5\u987B\u662F 1-65535 \u7684\u7AEF\u53E3\uFF0C\u6536\u5230 "${value}"`);
+  }
+  return parsed;
+}
+async function resolveHost(root, portOption) {
+  const record = await readHostRecord(root);
+  const explicitPort = parsePortOption(portOption);
+  const port = explicitPort ?? (record && isHostRecordAlive(record) ? record.port : DEFAULT_PORT);
+  const client = new WorkspaceClient({ baseUrl: `http://127.0.0.1:${port}` });
   try {
-    console.log("\u{1F50D} \u68C0\u67E5\u623F\u95F4\u72B6\u6001...");
-    let roomExists = false;
-    let currentPhase = "";
-    try {
-      const stateRes = await client.getState();
-      if (stateRes?.data?.roomId) {
-        roomExists = true;
-        currentPhase = stateRes.data.phase;
-        console.log(`  \u623F\u95F4\u5DF2\u5B58\u5728, phase: ${currentPhase}`);
+    const meta = await client.meta();
+    return { client, meta };
+  } catch (error) {
+    const detail = error instanceof WorkspaceApiError ? error.message : errorMessage3(error);
+    throw new Error(
+      `\u672A\u627E\u5230\u8FD0\u884C\u4E2D\u7684 Workspace host (127.0.0.1:${port})\u3002
+\u5148\u8FD0\u884C: npgame-dev serve -r ${root}
+\u539F\u56E0: ${detail}`
+    );
+  }
+}
+function roomConsoleUrl(hostUrl, roomId) {
+  const encoded = encodeURIComponent(roomId);
+  return `${hostUrl.replace(/\/+$/, "")}/rooms/${encoded}`;
+}
+async function resolveRoomTarget(root, portOption, explicitRoom) {
+  const { client, meta } = await resolveHost(root, portOption);
+  const response = await client.listGames();
+  const connected = response.games.filter((game2) => game2.connection);
+  if (explicitRoom) {
+    const match = connected.find((game2) => game2.connection?.roomId === explicitRoom || game2.id === explicitRoom);
+    if (!match?.connection) {
+      throw new Error(`\u623F\u95F4 "${explicitRoom}" \u672A\u8FDE\u63A5`);
+    }
+    return { roomId: match.connection.roomId, port: meta.port };
+  }
+  const rooms = [...new Set(connected.map((game2) => game2.connection.roomId))];
+  if (rooms.length === 1) return { roomId: rooms[0], port: meta.port };
+  if (rooms.length === 0) {
+    throw new Error("\u6CA1\u6709\u5DF2\u8FDE\u63A5\u623F\u95F4\u3002\u5148\u8FD0\u884C npgame-dev connect <game>");
+  }
+  throw new Error(`\u6709\u591A\u4E2A\u5DF2\u8FDE\u63A5\u623F\u95F4\uFF0C\u8BF7\u7528 --room \u6307\u5B9A: ${rooms.join(", ")}`);
+}
+
+// src/commands/connect.ts
+function optionalPlayers(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`--players \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF0C\u6536\u5230 "${value}"`);
+  }
+  return parsed;
+}
+async function connectCommand(selector, options) {
+  const root = path11.resolve(options.root ?? process.cwd());
+  try {
+    const scan = await scanGames(root);
+    const game2 = resolveGame(scan.games, selector);
+    const { client } = await resolveHost(root, options.port);
+    const entry = await client.connect(game2.id, {
+      workerUrl: options.workerUrl,
+      players: optionalPlayers(options.players),
+      roomId: options.room
+    });
+    if (options.json) {
+      console.log(JSON.stringify(entry, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`\u2705 \u5DF2\u8FDE\u63A5 ${chalk.bold(entry.name)} (${entry.id})`);
+    console.log(`   \u623F\u95F4:   ${entry.connection?.roomId ?? game2.id}`);
+    console.log(`   Worker: ${entry.connection?.workerUrl ?? entry.worker.url ?? "(\u9ED8\u8BA4)"}`);
+    console.log(`   \u89D2\u8272:   ${entry.connection?.roleIds.join(", ") || "(\u65E0)"}`);
+    console.log(`   phase:  ${entry.room?.phase ?? "lobby"}\uFF08\u5C1A\u672A\u5F00\u59CB\uFF09`);
+    console.log("");
+    console.log(`\u4E0B\u4E00\u6B65\u5F00\u59CB\u623F\u95F4: npgame-dev room start ${entry.connection?.roomId ?? game2.id}`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/disconnect.ts
+import path12 from "path";
+import chalk2 from "chalk";
+async function disconnectCommand(selector, options) {
+  const root = path12.resolve(options.root ?? process.cwd());
+  try {
+    const { client } = await resolveHost(root, options.port);
+    const response = await client.listGames();
+    const game2 = response.games.find((item) => item.connection && (item.connection.roomId === selector || item.connection.gameId === selector || item.id === selector));
+    if (!game2?.connection) {
+      throw new Error(`\u6E38\u620F\u6216\u623F\u95F4 "${selector}" \u672A\u8FDE\u63A5`);
+    }
+    await client.disconnect(game2.id);
+    if (options.json) {
+      console.log(JSON.stringify({ ok: true, gameId: game2.id, roomId: game2.connection.roomId }, null, 2));
+      return;
+    }
+    console.log(
+      `\u2705 \u5DF2\u65AD\u5F00 ${chalk2.bold(game2.name)} (${game2.id})\uFF0C\u623F\u95F4 ${game2.connection.roomId} \u7684\u914D\u7F6E\u5DF2\u79FB\u9664`
+    );
+    console.log(chalk2.dim("Worker \u4E0D\u4F1A\u88AB\u505C\u6B62\uFF1B\u9700\u8981\u65F6\u8FD0\u884C npgame-dev game stop " + game2.id));
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/room.ts
+import path14 from "path";
+import chalk4 from "chalk";
+
+// src/commands/ls.ts
+import path13 from "path";
+import chalk3 from "chalk";
+var WORKER_LABEL = {
+  unknown: "\u672A\u77E5",
+  stopped: "\u672A\u542F\u52A8",
+  starting: "\u542F\u52A8\u4E2D",
+  running: "\u8FD0\u884C\u4E2D",
+  external: "\u5916\u90E8\u8FD0\u884C",
+  error: "\u5F02\u5E38"
+};
+function workerMark(state) {
+  switch (state) {
+    case "running":
+      return chalk3.green("\u25CF");
+    case "external":
+      return chalk3.cyan("\u25CF");
+    case "starting":
+      return chalk3.yellow("\u25D0");
+    case "error":
+      return chalk3.red("\u2715");
+    case "stopped":
+      return chalk3.dim("\u25CB");
+    default:
+      return chalk3.dim("?");
+  }
+}
+function workerLabel(state) {
+  switch (state) {
+    case "running":
+      return chalk3.green(WORKER_LABEL[state]);
+    case "external":
+      return chalk3.cyan(WORKER_LABEL[state]);
+    case "starting":
+      return chalk3.yellow(WORKER_LABEL[state]);
+    case "error":
+      return chalk3.red(WORKER_LABEL[state]);
+    default:
+      return chalk3.dim(WORKER_LABEL[state]);
+  }
+}
+function roomPhaseLabel(phase) {
+  switch (phase) {
+    case "playing":
+      return chalk3.green("playing");
+    case "paused":
+      return chalk3.yellow("paused");
+    case "finished":
+      return chalk3.magenta("finished");
+    case "lobby":
+      return chalk3.dim("lobby");
+    default:
+      return chalk3.dim("\u672A\u8FDE\u63A5");
+  }
+}
+function offlineEntry(game2) {
+  return {
+    id: game2.id,
+    name: game2.name,
+    dir: game2.dir,
+    worker: {
+      state: "unknown",
+      reachable: false,
+      owned: false,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    connected: false,
+    capabilities: {
+      startWorker: false,
+      stopWorker: false,
+      logWorker: false,
+      connect: false,
+      disconnect: false,
+      startRoom: false,
+      stopRoom: false,
+      openConsole: false
+    }
+  };
+}
+async function gameLsCommand(options) {
+  const root = path13.resolve(options.root ?? process.cwd());
+  let host2;
+  try {
+    host2 = await resolveHost(root, options.port);
+  } catch {
+  }
+  let games;
+  let warnings = [];
+  if (host2) {
+    const response = await host2.client.listGames();
+    games = response.games;
+    warnings = response.warnings;
+  } else {
+    const scan = await scanGames(root);
+    games = scan.games.map(offlineEntry);
+    warnings = scan.warnings;
+  }
+  for (const warning of warnings) console.warn(`\u26A0\uFE0F  ${warning}`);
+  if (options.json) {
+    console.log(JSON.stringify({
+      root,
+      host: host2 ? host2.meta.url : null,
+      games,
+      warnings
+    }, null, 2));
+    return;
+  }
+  if (games.length === 0) {
+    console.log("\u672A\u53D1\u73B0\u4EFB\u4F55 nexus.game.json\u3002");
+    console.log("");
+    console.log("\u626B\u63CF\u8303\u56F4\uFF1A\u5F53\u524D\u76EE\u5F55\u3001\u76F4\u63A5\u5B50\u76EE\u5F55\u3001games/ \u4E0E nexus-games/ \u7684\u5B50\u76EE\u5F55\u3002");
+    console.log("\u5982\u679C\u6E38\u620F\u5728 ../nexus-games/\uFF0C\u8BF7\u5148 cd \u5230\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\uFF0C\u6216\u4F7F\u7528 --root <\u76EE\u5F55>\u3002");
+    return;
+  }
+  const idWidth = Math.max(2, ...games.map((game2) => game2.id.length)) + 2;
+  const nameWidth = Math.max(4, ...games.map((game2) => displayWidth(game2.name))) + 2;
+  console.log(chalk3.dim(`${" ".repeat(2)}${padDisplay("ID", idWidth)}${padDisplay("\u540D\u79F0", nameWidth)}Worker / \u623F\u95F4`));
+  for (const game2 of games) {
+    const worker = game2.worker.state === "error" ? chalk3.red(game2.worker.error ?? "\u5F02\u5E38") : `${workerLabel(game2.worker.state)}${game2.worker.url ? chalk3.dim(` ${game2.worker.url}`) : ""}`;
+    const room2 = game2.connection ? `${chalk3.dim(" \u2192 ")}${game2.connection.roomId} ${roomPhaseLabel(game2.room?.phase ?? "lobby")}` : "";
+    console.log(
+      `${workerMark(game2.worker.state)} ${padDisplay(game2.id, idWidth)}${padDisplay(game2.name, nameWidth)}${worker}${room2}`
+    );
+  }
+  const workers = games.filter((game2) => game2.worker.state === "running" || game2.worker.state === "external").length;
+  const connected = games.filter((game2) => game2.connected).length;
+  const playing = games.filter((game2) => game2.room?.phase === "playing").length;
+  console.log("");
+  if (host2) {
+    console.log(chalk3.dim(
+      `\u5171 ${games.length} \u4E2A\u6E38\u620F\uFF0CWorker \u8FD0\u884C ${workers} \u4E2A\uFF0C\u5DF2\u8FDE\u63A5\u623F\u95F4 ${connected} \u4E2A\uFF0C\u8FDB\u884C\u4E2D ${playing} \u4E2A\u3002Host: ${host2.meta.url}`
+    ));
+  } else {
+    console.log(chalk3.dim(
+      `\u5171 ${games.length} \u4E2A\u6E38\u620F\u3002Host \u672A\u8FD0\u884C\uFF0CWorker \u72B6\u6001\u672A\u77E5\uFF1B\u8FD0\u884C npgame-dev serve \u540E\u67E5\u770B\u771F\u5B9E\u72B6\u6001\u3002`
+    ));
+  }
+}
+
+// src/commands/room.ts
+function phaseMark(room2) {
+  switch (room2.phase) {
+    case "playing":
+      return chalk4.green("\u25CF");
+    case "paused":
+      return chalk4.yellow("\u25D0");
+    case "finished":
+      return chalk4.magenta("\u2713");
+    case "lobby":
+      return chalk4.dim("\u25CB");
+    default:
+      return chalk4.red("\u2715");
+  }
+}
+function printRoom(room2, hostUrl) {
+  console.log(
+    `${phaseMark(room2)} ${chalk4.bold(room2.roomId)}  ${room2.name}  ${room2.phase ? roomPhaseLabel(room2.phase) : chalk4.red("\u72B6\u6001\u4E0D\u53EF\u7528")}`
+  );
+  console.log(`  \u6E38\u620F:   ${room2.gameId}  ${chalk4.dim(room2.gameDir)}`);
+  console.log(
+    `  Worker: ${room2.worker.url ?? "(\u672A\u77E5)"}  ${workerMark(room2.worker.state)} ${workerLabel(room2.worker.state)}${room2.worker.pid ? ` \xB7 pid ${room2.worker.pid}` : ""}`
+  );
+  if (room2.roleIds.length > 0) {
+    console.log(`  \u89D2\u8272:   ${room2.roleIds.join(", ")}`);
+  }
+  if (room2.playerCount !== void 0) {
+    console.log(`  \u73A9\u5BB6:   ${room2.playerCount}${room2.stateIndex !== void 0 ? ` \xB7 state #${room2.stateIndex}` : ""}`);
+  }
+  console.log(`  \u63A7\u5236\u53F0: ${roomConsoleUrl(hostUrl, room2.roomId)}`);
+  if (room2.error) console.log(`  \u9519\u8BEF:   ${chalk4.yellow(room2.error)}`);
+}
+async function roomStatusCommand(selector, options) {
+  const root = path14.resolve(options.root ?? process.cwd());
+  try {
+    const { client, meta } = await resolveHost(root, options.port);
+    const response = await client.listRooms();
+    if (selector) {
+      const room2 = response.rooms.find((item) => item.roomId === selector || item.gameId === selector || item.name === selector);
+      if (!room2) {
+        throw new Error(`\u627E\u4E0D\u5230\u5DF2\u8FDE\u63A5\u623F\u95F4 "${selector}"`);
       }
-    } catch {
+      if (options.json) {
+        console.log(JSON.stringify(room2, null, 2));
+        return;
+      }
+      printRoom(room2, meta.url);
+      return;
     }
-    if (roomExists && (currentPhase === "playing" || currentPhase === "paused")) {
-      console.log("\u23F9\uFE0F  \u505C\u6B62\u5F53\u524D\u6E38\u620F...");
-      const stopRes = await client.stopGame();
-      if (stopRes.error) {
-        console.error(`\u274C \u505C\u6B62\u5931\u8D25: ${stopRes.error}`);
-        process.exit(1);
-      }
-      console.log("  \u6E38\u620F\u5DF2\u505C\u6B62");
-    }
-    if (!roomExists) {
-      console.log("\u{1F4E6} \u521B\u5EFA\u623F\u95F4...");
-      const createRes = await client.createRoom();
-      if (createRes.error) {
-        console.error(`\u274C \u521B\u5EFA\u5931\u8D25: ${createRes.error}`);
-        process.exit(1);
-      }
-      console.log(`  \u623F\u95F4\u5DF2\u521B\u5EFA: ${createRes.roomId}`);
-    }
-    console.log(`\u{1F3AE} \u8BBE\u7F6E\u6E38\u620F (${options.workerUrl})...`);
-    const players = options.players ? parseInt(options.players, 10) : void 0;
-    const setRes = await client.setGame(options.workerUrl, void 0, players);
-    if (setRes.error) {
-      console.error(`\u274C \u8BBE\u7F6E\u6E38\u620F\u5931\u8D25: ${setRes.error}`);
-      process.exit(1);
-    }
-    console.log(`  \u6E38\u620F: ${setRes.gameId} (\u89D2\u8272: ${setRes.roleIds?.join(", ")})`);
-    console.log("\u25B6\uFE0F  \u5F00\u59CB\u6E38\u620F...");
-    const startRes = await client.startGame();
-    if (startRes.error) {
-      console.error(`\u274C \u542F\u52A8\u5931\u8D25: ${startRes.error}`);
-      process.exit(1);
-    }
-    console.log("  \u6E38\u620F\u5DF2\u5F00\u59CB!");
-    console.log("\n\u53EF\u7528\u547D\u4EE4:");
-    console.log(`  npx @nexusgame/dev state                           \u67E5\u770B\u623F\u95F4\u72B6\u6001`);
-    console.log(`  npx @nexusgame/dev perspective <roleId>             \u67E5\u770B\u89D2\u8272\u89C6\u89D2`);
-    console.log(`  npx @nexusgame/dev action <roleId> '<action_json>'  \u6267\u884C\u884C\u52A8`);
-  } catch (e) {
-    if (e.cause?.code === "ECONNREFUSED") {
-      console.error(`\u274C \u65E0\u6CD5\u8FDE\u63A5\u5230\u5F15\u64CE (localhost:${port})\u3002\u8BF7\u5148\u8FD0\u884C: npx @nexusgame/dev start`);
-    } else {
-      console.error(`\u274C \u9519\u8BEF: ${e.message}`);
+    if (options.json) {
+      console.log(JSON.stringify(response.rooms, null, 2));
+      return;
+    }
+    if (response.rooms.length === 0) {
+      console.log("\u6CA1\u6709\u5DF2\u8FDE\u63A5\u623F\u95F4\u3002");
+      console.log("\u5148\u8FD0\u884C npgame-dev connect <game>\u3002");
+      return;
     }
-    process.exit(1);
+    for (const [index, room2] of response.rooms.entries()) {
+      if (index > 0) console.log("");
+      printRoom(room2, meta.url);
+    }
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+async function roomStartCommand(selector, options) {
+  const root = path14.resolve(options.root ?? process.cwd());
+  try {
+    const { client, meta } = await resolveHost(root, options.port);
+    const result = await client.startRoom(selector);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`\u2705 \u623F\u95F4 ${chalk4.bold(result.roomId)} \u5DF2\u5F00\u59CB (${result.phase})`);
+    console.log(`   \u63A7\u5236\u53F0: ${roomConsoleUrl(meta.url, result.roomId)}`);
+    console.log(`   \u89D2\u8272:   ${result.roleIds.join(", ") || "(\u65E0)"}`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+async function roomStopCommand(selector, options) {
+  const root = path14.resolve(options.root ?? process.cwd());
+  try {
+    const { client } = await resolveHost(root, options.port);
+    const result = await client.stopRoom(selector);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(`\u2705 \u623F\u95F4 ${chalk4.bold(result.roomId)} \u5DF2\u505C\u6B62 (${result.phase})`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
   }
 }
 
+// src/client.ts
+function createEngineClient(port = DEFAULT_PORT) {
+  return new EngineAdminClient({
+    baseUrl: `http://127.0.0.1:${port}`
+  });
+}
+
 // src/commands/state.ts
 async function stateCommand(options) {
-  const port = parseInt(options.port || String(DEFAULT_PORT), 10);
-  const client = new EngineClient(port);
-  try {
-    const result = await client.getState();
-    console.log(JSON.stringify(result, null, 2));
-  } catch (e) {
-    if (e.cause?.code === "ECONNREFUSED") {
-      console.error(`\u274C \u65E0\u6CD5\u8FDE\u63A5\u5230\u5F15\u64CE (localhost:${port})\u3002\u8BF7\u5148\u8FD0\u884C: npx @nexusgame/dev start`);
-    } else {
-      console.error(`\u274C \u9519\u8BEF: ${e.message}`);
+  try {
+    const { roomId, port } = await resolveRoomTarget(process.cwd(), options.port, options.room);
+    const client = createEngineClient(port);
+    const result = await client.getState(roomId);
+    if (!result.ok) {
+      console.error(`\u274C \u83B7\u53D6\u72B6\u6001\u5931\u8D25: ${result.error}`);
+      process.exitCode = 1;
+      return;
     }
-    process.exit(1);
+    console.log(JSON.stringify(result.data, null, 2));
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
   }
 }
 
 // src/commands/perspective.ts
 async function perspectiveCommand(roleId, options) {
-  const port = parseInt(options.port || String(DEFAULT_PORT), 10);
-  const client = new EngineClient(port);
   try {
-    const result = await client.getPerspective(roleId);
-    console.log(JSON.stringify(result, null, 2));
-    try {
-      const stateRes = await client.getState();
-      const uiUrl = stateRes?.data?.gameConfig?.gameWorkerUrl;
-      if (uiUrl) {
-        console.log(`
-\u{1F4FA} \u8C03\u8BD5 GUI \u9875\u9762:`);
-        const ADMIN_SECRET2 = process.env.ADMIN_SECRET || "nexus-dev-secret";
-        const FIXED_ROOM_ID2 = "dev-room";
-        const stateUrl = encodeURIComponent(`http://127.0.0.1:${port}/api/monitor/room/${FIXED_ROOM_ID2}/perspective?roleId=${roleId}`);
-        const actionUrl = encodeURIComponent(`http://127.0.0.1:${port}/api/monitor/room/${FIXED_ROOM_ID2}/action`);
-        const token = encodeURIComponent(ADMIN_SECRET2);
-        console.log(`${uiUrl}/game-ui.html?stateUrl=${stateUrl}&actionUrl=${actionUrl}&token=${token}`);
-      }
-    } catch (ignored) {
-    }
-  } catch (e) {
-    if (e.cause?.code === "ECONNREFUSED") {
-      console.error(`\u274C \u65E0\u6CD5\u8FDE\u63A5\u5230\u5F15\u64CE (localhost:${port})\u3002\u8BF7\u5148\u8FD0\u884C: npx @nexusgame/dev start`);
-    } else {
-      console.error(`\u274C \u9519\u8BEF: ${e.message}`);
+    const { roomId, port } = await resolveRoomTarget(process.cwd(), options.port, options.room);
+    const client = createEngineClient(port);
+    const result = await client.getPerspective(roomId, roleId);
+    if (!result.ok) {
+      console.error(`\u274C \u83B7\u53D6\u89C6\u89D2\u5931\u8D25: ${result.error}`);
+      process.exitCode = 1;
+      return;
     }
-    process.exit(1);
+    console.log(JSON.stringify(result.data, null, 2));
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
   }
 }
 
 // src/commands/action.ts
 async function actionCommand(roleId, actionJson, options) {
-  const port = parseInt(options.port || String(DEFAULT_PORT), 10);
-  const client = new EngineClient(port);
   let action;
   try {
     action = JSON.parse(actionJson);
   } catch {
     console.error(`\u274C \u65E0\u6548\u7684 JSON: ${actionJson}`);
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
   if (!action.action_id) {
-    console.error(`\u274C action_json \u5FC5\u987B\u5305\u542B action_id \u5B57\u6BB5`);
-    process.exit(1);
+    console.error("\u274C action_json \u5FC5\u987B\u5305\u542B action_id \u5B57\u6BB5");
+    process.exitCode = 1;
+    return;
   }
   try {
-    const result = await client.submitAction(roleId, action);
-    if (result.success) {
+    const { roomId, port } = await resolveRoomTarget(process.cwd(), options.port, options.room);
+    const client = createEngineClient(port);
+    const result = await client.submitAction(roomId, roleId, action);
+    if (result.ok) {
       console.log("\u2705 \u884C\u52A8\u6210\u529F");
-      console.log(JSON.stringify(result, null, 2));
+      console.log(JSON.stringify(result.data ?? {}, null, 2));
     } else {
       console.error(`\u274C \u884C\u52A8\u5931\u8D25: ${result.error}`);
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/init.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import path15 from "path";
+import chalk5 from "chalk";
+function runPackageManager(packageManager, args, cwd) {
+  const printable = [packageManager, ...args].join(" ");
+  console.log(chalk5.dim(`$ ${printable}   (cwd: ${cwd})`));
+  const result = spawnSync2(packageManager, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.error) {
+    throw new Error(`\u65E0\u6CD5\u8FD0\u884C ${packageManager}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF08exit ${result.status ?? "-"}\uFF09: ${printable}`);
+  }
+}
+async function gameInitCommand(selector, options) {
+  const root = path15.resolve(options.root ?? process.cwd());
+  try {
+    const scan = await scanGames(root);
+    const game2 = resolveGame(scan.games, selector);
+    const pkg = await readPackageJson(game2.dir);
+    const packageManager = await detectPackageManager(game2.dir, pkg);
+    const scripts = typeof pkg.scripts === "object" && pkg.scripts !== null ? pkg.scripts : {};
+    const nodeModules = path15.join(game2.dir, "node_modules");
+    const uiAsset = path15.join(game2.dir, "worker", "public", "_ui.js");
+    const hasDependencies = await pathExists(nodeModules);
+    const hasUiAsset = await pathExists(uiAsset);
+    console.log(`${chalk5.bold(game2.name)} (${game2.id})`);
+    console.log(`  \u76EE\u5F55:     ${game2.dir}`);
+    console.log(`  \u5305\u7BA1\u7406\u5668: ${packageManager}`);
+    console.log("");
+    let didWork = false;
+    if (options.install === false) {
+      console.log(chalk5.dim("\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5 (--no-install)"));
+    } else if (hasDependencies && !options.force) {
+      console.log(chalk5.dim("\u2713 \u4F9D\u8D56\u5DF2\u5B89\u88C5"));
+    } else {
+      console.log(chalk5.blue(`\u{1F4E6} \u5B89\u88C5\u4F9D\u8D56 (${packageManager})...`));
+      runPackageManager(packageManager, ["install"], game2.dir);
+      didWork = true;
+    }
+    if (options.build === false) {
+      console.log(chalk5.dim("\u8DF3\u8FC7\u6784\u5EFA (--no-build)"));
+    } else if (typeof scripts.build !== "string") {
+      console.log(chalk5.yellow("\u26A0\uFE0F package.json \u7F3A\u5C11 scripts.build\uFF0C\u8DF3\u8FC7\u6784\u5EFA"));
+    } else if (hasUiAsset && !options.force) {
+      console.log(chalk5.dim("\u2713 UI \u8D44\u6E90\u5DF2\u6784\u5EFA (worker/public/_ui.js)"));
+    } else {
+      console.log(chalk5.blue("\u{1F528} \u6784\u5EFA\u6E38\u620F\uFF08\u751F\u6210 worker/public/_ui.js\uFF09..."));
+      runPackageManager(packageManager, ["run", "build"], game2.dir);
+      didWork = true;
+    }
+    console.log("");
+    console.log(chalk5.green(didWork ? "\u2705 \u521D\u59CB\u5316\u5B8C\u6210" : "\u2705 \u6E38\u620F\u5DF2\u7ECF\u5904\u4E8E\u53EF\u8FD0\u884C\u72B6\u6001"));
+    console.log(`\u4E0B\u4E00\u6B65: npgame-dev game start ${game2.id}`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/game.ts
+import path16 from "path";
+import chalk6 from "chalk";
+var resolveRoot = (root) => path16.resolve(root ?? process.cwd());
+function optionalInt(value, flag) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${flag} \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF0C\u6536\u5230 "${value}"`);
+  }
+  return parsed;
+}
+async function findGame(games, selector) {
+  return games.find((game2) => game2.id === selector || game2.name === selector || game2.connection?.roomId === selector);
+}
+function printWorker(game2, hostUrl) {
+  console.log(`${workerMark(game2.worker.state)} ${chalk6.bold(game2.id)}  ${game2.name}  ${workerLabel(game2.worker.state)}`);
+  console.log(`  \u76EE\u5F55:   ${game2.dir}`);
+  if (game2.worker.url) {
+    const owner = game2.worker.owned ? chalk6.dim("host \u6258\u7BA1") : game2.worker.state === "external" ? chalk6.dim("\u5916\u90E8\u8FDB\u7A0B") : "";
+    console.log(`  Worker: ${game2.worker.url}${game2.worker.pid ? ` \xB7 pid ${game2.worker.pid}` : ""} ${owner}`.trimEnd());
+  }
+  if (game2.worker.logFile) console.log(`  \u65E5\u5FD7:   ${game2.worker.logFile}`);
+  if (game2.connected && game2.connection) {
+    console.log(`  \u623F\u95F4:   ${game2.connection.roomId} \xB7 ${roomPhaseLabel(game2.room?.phase ?? "lobby")}`);
+    console.log(`  \u63A7\u5236\u53F0: ${roomConsoleUrl(hostUrl, game2.connection.roomId)}`);
+  } else {
+    console.log("  \u623F\u95F4:   \u672A\u8FDE\u63A5");
+  }
+  if (game2.worker.error) console.log(`  \u9519\u8BEF:   ${chalk6.yellow(game2.worker.error)}`);
+  if (game2.roomError) console.log(`  \u623F\u95F4\u9519\u8BEF: ${chalk6.yellow(game2.roomError)}`);
+}
+async function gameStartCommand(selector, options) {
+  const root = resolveRoot(options.root);
+  try {
+    const scan = await scanGames(root);
+    const game2 = resolveGame(scan.games, selector);
+    const { client } = await resolveHost(root, options.port);
+    const worker = await client.startWorker(game2.id, {
+      port: optionalInt(options.workerPort, "--worker-port")
+    });
+    if (options.json) {
+      console.log(JSON.stringify(worker, null, 2));
+      return;
+    }
+    console.log("");
+    if (worker.worker.state === "external") {
+      console.log(`\u2139\uFE0F  ${chalk6.bold(game2.name)} \u7684 Worker \u5DF2\u7ECF\u5728\u8FD0\u884C\uFF0C\u4F46\u4E0D\u662F\u7531 host \u542F\u52A8\u7684\u3002`);
+    } else {
+      console.log(`\u2705 ${chalk6.bold(game2.name)} (${game2.id}) \u7684 Worker \u5DF2\u542F\u52A8`);
+    }
+    if (worker.worker.url) console.log(`   URL:   ${worker.worker.url}`);
+    if (worker.worker.pid) console.log(`   PID:   ${worker.worker.pid}`);
+    if (worker.worker.logFile) console.log(`   \u65E5\u5FD7:  ${worker.worker.logFile}`);
+    console.log("");
+    console.log(`\u4E0B\u4E00\u6B65: npgame-dev connect ${game2.id}`);
+    console.log(`        npgame-dev room start ${game2.id}`);
+    if (worker.worker.owned) console.log(`\u505C\u6B62:   npgame-dev game stop ${game2.id}`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+async function gameStatusCommand(selector, options) {
+  const root = resolveRoot(options.root);
+  try {
+    const { client, meta } = await resolveHost(root, options.port);
+    const response = await client.listGames();
+    if (selector) {
+      const game2 = await findGame(response.games, selector);
+      if (!game2) {
+        throw new Error(`\u627E\u4E0D\u5230\u6E38\u620F\u6216\u623F\u95F4 "${selector}"`);
+      }
+      if (options.json) {
+        console.log(JSON.stringify(game2, null, 2));
+        return;
+      }
+      printWorker(game2, meta.url);
+      return;
     }
-  } catch (e) {
-    if (e.cause?.code === "ECONNREFUSED") {
-      console.error(`\u274C \u65E0\u6CD5\u8FDE\u63A5\u5230\u5F15\u64CE (localhost:${port})\u3002\u8BF7\u5148\u8FD0\u884C: npx @nexusgame/dev start`);
+    if (options.json) {
+      console.log(JSON.stringify(response.games, null, 2));
+      return;
+    }
+    if (response.games.length === 0) {
+      console.log("\u6CA1\u6709\u53D1\u73B0\u6E38\u620F\u3002");
+      return;
+    }
+    for (const [index, game2] of response.games.entries()) {
+      if (index > 0) console.log("");
+      printWorker(game2, meta.url);
+    }
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+async function gameStopCommand(selector, options) {
+  const root = resolveRoot(options.root);
+  try {
+    const { client } = await resolveHost(root, options.port);
+    const response = await client.listGames();
+    let targets;
+    if (options.all) {
+      targets = response.games.filter((game2) => game2.worker.owned);
+    } else if (selector) {
+      const game2 = await findGame(response.games, selector);
+      if (!game2) throw new Error(`\u627E\u4E0D\u5230\u6E38\u620F\u6216\u623F\u95F4 "${selector}"`);
+      targets = [game2];
     } else {
-      console.error(`\u274C \u9519\u8BEF: ${e.message}`);
+      console.error("\u274C \u8BF7\u6307\u5B9A\u6E38\u620F id\uFF0C\u6216\u4F7F\u7528 --all \u505C\u6B62\u5168\u90E8\u7531 host \u542F\u52A8\u7684 Worker");
+      process.exitCode = 1;
+      return;
+    }
+    if (targets.length === 0) {
+      console.log("\u6CA1\u6709\u7531 host \u542F\u52A8\u7684 Worker\u3002");
+      return;
+    }
+    let failed = 0;
+    for (const game2 of targets) {
+      if (!game2.worker.owned) {
+        console.error(`   ${game2.id}: \u4E0D\u662F\u7531 host \u542F\u52A8\u7684 Worker\uFF0C\u8DF3\u8FC7`);
+        continue;
+      }
+      console.log(`\u{1F6D1} \u505C\u6B62 Worker ${chalk6.bold(game2.id)} ...`);
+      try {
+        const result = await client.stopWorker(game2.id, { force: options.force });
+        console.log(`   ${game2.id}: ${result.worker.state}`);
+      } catch (error) {
+        failed += 1;
+        console.error(`   ${game2.id}: ${errorMessage3(error)}`);
+      }
+    }
+    if (failed > 0) process.exitCode = 1;
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+async function gameLogsCommand(selector, options) {
+  const root = resolveRoot(options.root);
+  const lines = optionalInt(options.lines, "--lines") ?? 200;
+  try {
+    const scan = await scanGames(root);
+    const game2 = resolveGame(scan.games, selector);
+    const file = workerLogFile(root, game2.id);
+    if (options.follow) {
+      console.log(`\u{1F4DC} ${file}\uFF08Ctrl+C \u9000\u51FA\uFF09`);
+      const stop = await followLogs([{ label: game2.id, file }], { initialLines: lines });
+      await new Promise((resolve) => {
+        process.once("SIGINT", () => {
+          stop();
+          resolve();
+        });
+        process.once("SIGTERM", () => {
+          stop();
+          resolve();
+        });
+      });
+      return;
+    }
+    const text = await tailFile(file, lines);
+    if (!text.trim()) {
+      console.log(`(\u65E5\u5FD7\u4E3A\u7A7A: ${file})`);
+      console.log(`\u5148\u8FD0\u884C npgame-dev game start ${game2.id}`);
+      return;
+    }
+    process.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/host.ts
+import path17 from "path";
+function optionalInt2(value, flag) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${flag} \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF0C\u6536\u5230 "${value}"`);
+  }
+  return parsed;
+}
+async function hostLogsCommand(options) {
+  const root = path17.resolve(options.root ?? process.cwd());
+  const file = hostLogFile(root);
+  const lines = optionalInt2(options.lines, "--lines") ?? 200;
+  try {
+    if (options.follow) {
+      console.log(`\u{1F4DC} ${file}\uFF08Ctrl+C \u9000\u51FA\uFF09`);
+      const stop = await followLogs([{ label: "host", file }], { initialLines: lines });
+      await new Promise((resolve) => {
+        process.once("SIGINT", () => {
+          stop();
+          resolve();
+        });
+        process.once("SIGTERM", () => {
+          stop();
+          resolve();
+        });
+      });
+      return;
+    }
+    const text = await tailFile(file, lines);
+    if (!text.trim()) {
+      console.log(`(\u65E5\u5FD7\u4E3A\u7A7A: ${file})`);
+      console.log("\u5148\u8FD0\u884C npgame-dev serve");
+      return;
     }
-    process.exit(1);
+    process.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage3(error)}`);
+    process.exitCode = 1;
   }
 }
 
 // src/index.ts
 var program = new Command();
-program.name("npgame-dev").description("\u661F\u67A2\u6C99\u76D2 \u2014 \u672C\u5730\u6E38\u620F\u5F00\u53D1\u8C03\u8BD5\u5DE5\u5177").version("0.2.0");
-program.command("start").description("\u542F\u52A8\u672C\u5730\u5F15\u64CE (\u524D\u53F0\u8FD0\u884C, Ctrl+C \u505C\u6B62)").option("-p, --port <port>", "\u5F15\u64CE\u7AEF\u53E3", "56512").action(startCommand);
-program.command("setup").description("\u521B\u5EFA\u623F\u95F4 + \u8BBE\u7F6E\u6E38\u620F + \u5F00\u59CB (\u4E00\u6761\u9F99)").requiredOption("-w, --worker-url <url>", "Game Worker URL (\u5982 http://localhost:8788)").option("-p, --port <port>", "\u5F15\u64CE\u7AEF\u53E3", "56512").option("-n, --players <count>", "\u6307\u5B9A\u53C2\u4E0E\u6E38\u620F\u7684\u4EBA\u6570 (\u9002\u7528\u4E8EUNO\u7B49\u53EF\u9009\u4EBA\u6570\u6E38\u620F)").action(setupCommand);
-program.command("state").description("\u67E5\u770B\u623F\u95F4\u5168\u5C40\u72B6\u6001").option("-p, --port <port>", "\u5F15\u64CE\u7AEF\u53E3", "56512").action(stateCommand);
-program.command("perspective").description("\u67E5\u770B\u6307\u5B9A\u89D2\u8272\u7684\u89C6\u89D2").argument("<roleId>", "\u89D2\u8272 ID").option("-p, --port <port>", "\u5F15\u64CE\u7AEF\u53E3", "56512").action(perspectiveCommand);
-program.command("action").description("\u4EE5\u6307\u5B9A\u89D2\u8272\u6267\u884C\u884C\u52A8").argument("<roleId>", "\u89D2\u8272 ID").argument("<actionJson>", `\u884C\u52A8 JSON (\u5982 '{"action_id":"place","params":{"x":7,"y":7}}')`).option("-p, --port <port>", "\u5F15\u64CE\u7AEF\u53E3", "56512").action(actionCommand);
-program.parse();
+program.name("npgame-dev").description("\u661F\u67A2\u6C99\u76D2 \u2014 \u672C\u5730\u6E38\u620F\u5F00\u53D1\u8C03\u8BD5\u5DE5\u5177").version("0.4.0");
+program.command("serve").description("\u542F\u52A8\u5E38\u9A7B Workspace host\uFF08\u7BA1\u7406\u9875 + \u5171\u4EAB\u5F15\u64CE\uFF0C\u9700\u663E\u5F0F\u542F\u52A8\uFF09").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host / \u7BA1\u7406\u9875\u7AEF\u53E3 (\u9ED8\u8BA4 56512)").option("--engine-port <port>", "\u5F15\u64CE\u5185\u90E8\u7AEF\u53E3 (\u9ED8\u8BA4 Host \u7AEF\u53E3 + 1)").action(serveCommand);
+var game = program.command("game").description("\u6E38\u620F\u9879\u76EE\u4E0E\u672C\u5730 Worker \u8FDB\u7A0B");
+game.command("ls").description("\u626B\u63CF\u5DE5\u4F5C\u533A\u4E2D\u7684\u6E38\u620F\u548C Worker \u72B6\u6001").option("-r, --root <dir>", "\u626B\u63CF\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(gameLsCommand);
+game.command("init").description("\u521D\u59CB\u5316\u6E38\u620F\u9879\u76EE\uFF1A\u5B89\u88C5\u4F9D\u8D56\u5E76\u6784\u5EFA UI \u8D44\u6E90").argument("<game>", "\u6E38\u620F id\u3001\u540D\u79F0\u6216\u76EE\u5F55").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("--no-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--no-build", "\u8DF3\u8FC7\u6784\u5EFA").option("-f, --force", "\u5F3A\u5236\u91CD\u65B0\u5B89\u88C5\u4F9D\u8D56\u5E76\u91CD\u65B0\u6784\u5EFA").action(gameInitCommand);
+game.command("start").description("\u5728\u6E38\u620F\u76EE\u5F55\u542F\u52A8\u672C\u5730 Worker\uFF08\u5982 pnpm dev\uFF09").argument("<game>", "\u6E38\u620F id\u3001\u540D\u79F0\u6216\u76EE\u5F55").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--worker-port <port>", "Worker \u7AEF\u53E3 (\u9ED8\u8BA4\u53D6 wrangler \u914D\u7F6E\u6216 8787)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(gameStartCommand);
+game.command("status").description("\u67E5\u770B\u6E38\u620F Worker \u72B6\u6001").argument("[game]", "\u6E38\u620F id\u3001\u540D\u79F0\u6216\u623F\u95F4 id (\u7701\u7565\u5219\u5217\u51FA\u5168\u90E8)").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(gameStatusCommand);
+game.command("stop").description("\u505C\u6B62\u7531 host \u542F\u52A8\u7684 Worker\uFF08\u4E0D\u4F1A\u505C\u6B62\u623F\u95F4\uFF09").argument("[game]", "\u6E38\u620F id\u3001\u540D\u79F0\u6216\u623F\u95F4 id").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--all", "\u505C\u6B62\u5168\u90E8\u7531 host \u542F\u52A8\u7684 Worker").option("--force", "\u5373\u4F7F\u623F\u95F4\u4ECD\u5728\u8FD0\u884C\u4E5F\u505C\u6B62 Worker").action(gameStopCommand);
+game.command("logs").description("\u67E5\u770B\u6E38\u620F Worker \u65E5\u5FD7").argument("<game>", "\u6E38\u620F id\u3001\u540D\u79F0\u6216\u76EE\u5F55").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-n, --lines <count>", "\u663E\u793A\u6700\u540E N \u884C", "200").option("-f, --follow", "\u6301\u7EED\u8DDF\u968F\u8F93\u51FA").action(gameLogsCommand);
+program.command("connect").description("\u628A\u6E38\u620F\u7ED1\u5B9A\u5230\u623F\u95F4\u914D\u7F6E (\u9700\u8981 serve\uFF0C\u4E0D\u542F\u52A8 Worker)").argument("<game>", "\u6E38\u620F id\u3001\u540D\u79F0\u6216\u76EE\u5F55").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("-w, --worker-url <url>", "Game Worker URL (\u9ED8\u8BA4\u4F7F\u7528\u8FD0\u884C\u4E2D\u7684 Worker)").option("-n, --players <count>", "\u53C2\u4E0E\u4EBA\u6570 (\u9002\u7528\u4E8E UNO \u7B49\u53EF\u9009\u4EBA\u6570\u6E38\u620F)").option("--room <roomId>", "\u623F\u95F4 id (\u9ED8\u8BA4\u6E38\u620F id)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(connectCommand);
+program.command("disconnect").description("\u505C\u6B62\u623F\u95F4\u5E76\u79FB\u9664\u7ED1\u5B9A (\u4E0D\u505C\u6B62 Worker)").argument("<game|room>", "\u623F\u95F4 id \u6216\u6E38\u620F id").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(disconnectCommand);
+var room = program.command("room").description("\u542F\u52A8\u3001\u505C\u6B62\u548C\u67E5\u770B\u623F\u95F4");
+room.command("start").description("\u5728\u5F53\u524D\u623F\u95F4\u914D\u7F6E\u4E0A\u5206\u914D dev \u73A9\u5BB6\u5E76\u5F00\u59CB\u6E38\u620F").argument("<room>", "\u623F\u95F4 id \u6216\u6E38\u620F id").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(roomStartCommand);
+room.command("stop").description("\u505C\u6B62\u623F\u95F4\u4E2D\u7684\u6E38\u620F (\u4E0D\u505C\u6B62 Worker)").argument("<room>", "\u623F\u95F4 id \u6216\u6E38\u620F id").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(roomStopCommand);
+room.command("status").description("\u67E5\u770B\u5DF2\u8FDE\u63A5\u623F\u95F4\u7684\u72B6\u6001").argument("[room]", "\u623F\u95F4 id \u6216\u6E38\u620F id (\u7701\u7565\u5219\u5217\u51FA\u5168\u90E8)").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--json", "\u4EE5 JSON \u8F93\u51FA").action(roomStatusCommand);
+var host = program.command("host").description("Workspace host \u65E5\u5FD7");
+host.command("logs").description("\u67E5\u770B host \u65E5\u5FD7").option("-r, --root <dir>", "\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55 (\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55)").option("-n, --lines <count>", "\u663E\u793A\u6700\u540E N \u884C", "200").option("-f, --follow", "\u6301\u7EED\u8DDF\u968F\u8F93\u51FA").action(hostLogsCommand);
+program.command("state").description("\u67E5\u770B\u623F\u95F4\u5168\u5C40\u72B6\u6001").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--room <roomId>", "\u623F\u95F4 id (\u4EC5\u4E00\u4E2A\u5DF2\u8FDE\u63A5\u623F\u95F4\u65F6\u53EF\u7701\u7565)").action(stateCommand);
+program.command("perspective").description("\u67E5\u770B\u6307\u5B9A\u89D2\u8272\u7684\u89C6\u89D2").argument("<roleId>", "\u89D2\u8272 ID").option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--room <roomId>", "\u623F\u95F4 id (\u4EC5\u4E00\u4E2A\u5DF2\u8FDE\u63A5\u623F\u95F4\u65F6\u53EF\u7701\u7565)").action(perspectiveCommand);
+program.command("action").description("\u4EE5\u6307\u5B9A\u89D2\u8272\u6267\u884C\u884C\u52A8").argument("<roleId>", "\u89D2\u8272 ID").argument("<actionJson>", `\u884C\u52A8 JSON (\u5982 '{"action_id":"place","params":{"x":7,"y":7}}')`).option("-p, --port <port>", "Host \u7AEF\u53E3 (\u9ED8\u8BA4\u8BFB\u53D6 .nexus/host.json)").option("--room <roomId>", "\u623F\u95F4 id (\u4EC5\u4E00\u4E2A\u5DF2\u8FDE\u63A5\u623F\u95F4\u65F6\u53EF\u7701\u7565)").action(actionCommand);
+try {
+  await program.parseAsync();
+} catch (error) {
+  console.error(`\u274C ${errorMessage3(error)}`);
+  process.exitCode = 1;
+}