@fzgame/cli 0.0.0-stage → 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,1077 @@
+#!/usr/bin/env node
+"use strict";
+
+// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.16.1_@swc+helpers@0.5.15__jiti@2.7.0_postcss@8.5.26_tsx@4.23.13_typescript@5.9.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/env.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function loadEnvFile(dir = process.cwd()) {
+  let raw;
+  try {
+    raw = (0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, ".env"), "utf8");
+  } catch {
+    return false;
+  }
+  for (const line of raw.split("\n")) {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line);
+    if (!match) continue;
+    const key = match[1];
+    let value = match[2];
+    const quoted = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'");
+    if (quoted) value = value.slice(1, -1);
+    if (process.env[key] === void 0) process.env[key] = value;
+  }
+  return true;
+}
+
+// src/program.ts
+var import_commander = require("commander");
+
+// src/dev.ts
+var import_node_fs3 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_http = require("http");
+var import_node_path4 = require("path");
+
+// src/kit-path.ts
+var import_node_fs2 = require("fs");
+var import_node_module = require("module");
+var import_node_path2 = require("path");
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var KIT_HINT = "Run `pnpm --filter @fzgame/kit build` (monorepo) or `npm install` (installed CLI)";
+function resolveTarget(target) {
+  if (typeof target === "string") return target;
+  if (!target) return void 0;
+  return resolveTarget(target.import) ?? resolveTarget(target.default);
+}
+function resolveKitFile() {
+  const manifestPath = require2.resolve("@fzgame/kit/package.json");
+  const manifest = JSON.parse((0, import_node_fs2.readFileSync)(manifestPath, "utf8"));
+  const entry = manifest.module ?? resolveTarget(manifest.exports?.["."]) ?? manifest.main ?? "./dist/index.js";
+  return (0, import_node_path2.join)((0, import_node_path2.dirname)(manifestPath), entry);
+}
+
+// src/pack.ts
+var import_promises = require("fs/promises");
+var import_node_path3 = require("path");
+
+// src/manifest.ts
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var DEFAULT_ENTRY = {
+  game: "game/index.html",
+  editor: "editor/index.html",
+  handler: "handler/index.js"
+};
+function toStoredConfigSchema(manifest) {
+  return {
+    formSchema: manifest.formSchema ?? { type: "object", properties: {} },
+    ...manifest.formUiSchema ? { formUiSchema: manifest.formUiSchema } : {},
+    ...manifest.resultSchema ? { resultSchema: manifest.resultSchema } : {},
+    ...manifest.snapshotSchema ? { snapshotSchema: manifest.snapshotSchema } : {},
+    ...manifest.gameDataSchema ? { gameDataSchema: manifest.gameDataSchema } : {},
+    ...manifest.info.author ? { author: manifest.info.author } : {},
+    ...manifest.info.gitUrl ? { git_url: manifest.info.gitUrl } : {},
+    ...manifest.info.image ? { image: manifest.info.image } : {}
+  };
+}
+function parseFzGameManifest(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("fzgame.json must be an object");
+  }
+  const raw = input;
+  const info = parseInfo(raw);
+  const formSchema = readObject(raw.formSchema, "formSchema") ?? readObject(raw.configSchema, "configSchema");
+  const manifest = {
+    info,
+    entry: parseEntry(raw.entry),
+    formSchema,
+    formUiSchema: readObject(raw.formUiSchema, "formUiSchema"),
+    resultSchema: readObject(raw.resultSchema, "resultSchema"),
+    snapshotSchema: readObject(raw.snapshotSchema, "snapshotSchema"),
+    gameDataSchema: readObject(raw.gameDataSchema, "gameDataSchema"),
+    name: info.name,
+    slug: info.slug,
+    version: info.version,
+    description: info.description
+  };
+  manifest.configSchema = toStoredConfigSchema(manifest);
+  return manifest;
+}
+function parseInfo(raw) {
+  const nested = raw.info && typeof raw.info === "object" && !Array.isArray(raw.info) ? raw.info : {};
+  const name = pickString(nested.name, raw.name);
+  const slug = pickString(nested.slug, raw.slug);
+  if (!name || name.trim().length < 2) {
+    throw new Error("fzgame.json must include a name (min 2 characters)");
+  }
+  if (!slug || !SLUG_RE.test(slug)) {
+    throw new Error(
+      "fzgame.json slug must be kebab-case (lowercase letters, digits, hyphens)"
+    );
+  }
+  const versionRaw = nested.version ?? raw.version;
+  const version = versionRaw === void 0 || versionRaw === null ? 1 : versionRaw;
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
+    throw new Error("fzgame.json version must be a positive integer");
+  }
+  const gitUrl = optionalString(nested.git_url ?? nested.gitUrl);
+  if (gitUrl && !/^https?:\/\//i.test(gitUrl)) {
+    throw new Error("fzgame.json info.git_url must be an http(s) URL");
+  }
+  const image = optionalString(nested.image);
+  const description = optionalString(nested.description ?? raw.description);
+  const author = optionalString(nested.author);
+  return {
+    name: name.trim(),
+    slug,
+    version,
+    ...image ? { image } : {},
+    ...description ? { description } : {},
+    ...author ? { author } : {},
+    ...gitUrl ? { gitUrl } : {}
+  };
+}
+function parseEntry(input) {
+  if (input === void 0 || input === null) return { ...DEFAULT_ENTRY };
+  if (typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("fzgame.json entry must be an object");
+  }
+  const raw = input;
+  return {
+    game: readPath(raw.game, DEFAULT_ENTRY.game),
+    editor: readPath(raw.editor, DEFAULT_ENTRY.editor),
+    handler: readPath(raw.handler, DEFAULT_ENTRY.handler)
+  };
+}
+function readPath(value, fallback) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("fzgame.json entry paths must be relative");
+  }
+  const path = value.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (path.startsWith("/") || path.includes("..")) {
+    throw new Error("fzgame.json entry paths must be relative without ..");
+  }
+  return path;
+}
+function readObject(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`fzgame.json ${field} must be a JSON Schema object`);
+  }
+  return value;
+}
+function pickString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return void 0;
+}
+function optionalString(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return String(value);
+}
+
+// src/zip.ts
+var import_node_zlib = require("zlib");
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+var CRC_TABLE = new Uint32Array(256);
+for (let n = 0; n < 256; n++) {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+  CRC_TABLE[n] = c;
+}
+function crc32(buf) {
+  let c = 4294967295;
+  for (let i = 0; i < buf.length; i++) {
+    c = CRC_TABLE[(c ^ buf[i]) & 255] ^ c >>> 8;
+  }
+  return (c ^ 4294967295) >>> 0;
+}
+function buildZip(files) {
+  const records = [];
+  const parts = [];
+  let offset = 0;
+  for (const [name, content] of Object.entries(files)) {
+    const data = Buffer.isBuffer(content) ? content : Buffer.from(content);
+    const compressed = (0, import_node_zlib.deflateRawSync)(data);
+    const crc = crc32(data);
+    const nameBuf = Buffer.from(name.replace(/\\/g, "/"), "utf8");
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(8, 8);
+    local.writeUInt16LE(DOS_TIME, 10);
+    local.writeUInt16LE(DOS_DATE, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(compressed.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    parts.push(local, nameBuf, compressed);
+    records.push({ name: nameBuf, data, compressed, crc, offset });
+    offset += local.length + nameBuf.length + compressed.length;
+  }
+  const centralStart = offset;
+  for (const record of records) {
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(8, 10);
+    central.writeUInt16LE(DOS_TIME, 12);
+    central.writeUInt16LE(DOS_DATE, 14);
+    central.writeUInt32LE(record.crc, 16);
+    central.writeUInt32LE(record.compressed.length, 20);
+    central.writeUInt32LE(record.data.length, 24);
+    central.writeUInt16LE(record.name.length, 28);
+    central.writeUInt32LE(record.offset, 42);
+    parts.push(central, record.name);
+    offset += central.length + record.name.length;
+  }
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(records.length, 8);
+  eocd.writeUInt16LE(records.length, 10);
+  eocd.writeUInt32LE(offset - centralStart, 12);
+  eocd.writeUInt32LE(centralStart, 16);
+  parts.push(eocd);
+  return Buffer.concat(parts);
+}
+
+// src/pack.ts
+async function loadManifest(root) {
+  const manifestPath = (0, import_node_path3.join)(root, "fzgame.json");
+  let text;
+  try {
+    text = await (0, import_promises.readFile)(manifestPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`No fzgame.json in ${root}. Run fzgame dev from a game root.`);
+    }
+    throw error;
+  }
+  try {
+    return parseFzGameManifest(JSON.parse(text));
+  } catch (error) {
+    throw new Error(`Invalid fzgame.json in ${root}: ${error.message}`);
+  }
+}
+async function collectGameFiles(root, options = {}) {
+  const manifest = await loadManifest(root);
+  const files = {
+    "fzgame.json": await (0, import_promises.readFile)((0, import_node_path3.join)(root, "fzgame.json"))
+  };
+  for (const dir of ["game", "editor", "handler"]) {
+    const abs = (0, import_node_path3.join)(root, dir);
+    if (!await exists(abs)) {
+      throw new Error(`Missing required directory: ${dir}/`);
+    }
+    await walk(abs, async (file) => {
+      const rel = (0, import_node_path3.relative)(root, file).replace(/\\/g, "/");
+      files[rel] = await (0, import_promises.readFile)(file);
+    });
+  }
+  for (const path of [manifest.entry.game, manifest.entry.editor, manifest.entry.handler]) {
+    if (!files[path]) throw new Error(`Missing required entrypoint: ${path}`);
+  }
+  await vendorKit(files, options);
+  return files;
+}
+async function buildGame(root, outFile, options = {}) {
+  const manifest = await loadManifest(root);
+  const files = await collectGameFiles(root, options);
+  const zip = buildZip(files);
+  const dest = outFile || (0, import_node_path3.join)(root, "dist", `${manifest.slug}-v${manifest.version}.zip`);
+  await (0, import_promises.mkdir)((0, import_node_path3.dirname)(dest), { recursive: true });
+  await (0, import_promises.writeFile)(dest, zip);
+  return { dest, manifest, files: Object.keys(files) };
+}
+async function vendorKit(files, options) {
+  if (files["game/vendor/kit.js"]) return;
+  if (options.kitFile === null) return;
+  let kitFile;
+  if (options.kitFile) {
+    kitFile = options.kitFile;
+  } else {
+    try {
+      kitFile = resolveKitFile();
+    } catch (error) {
+      throw new Error(
+        `Cannot vendor the game runtime: @fzgame/kit is not installed (${error.message}). ${KIT_HINT}`
+      );
+    }
+  }
+  if (!await exists(kitFile)) {
+    throw new Error(`Cannot vendor the game runtime: ${kitFile} does not exist. ${KIT_HINT}`);
+  }
+  files["game/vendor/kit.js"] = await (0, import_promises.readFile)(kitFile);
+}
+async function walk(dir, visit) {
+  const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store") continue;
+    const abs = (0, import_node_path3.join)(dir, entry.name);
+    if (entry.isDirectory()) await walk(abs, visit);
+    else await visit(abs);
+  }
+}
+async function exists(path) {
+  try {
+    await (0, import_promises.stat)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/dev.ts
+var DEFAULT_HOST = "127.0.0.1";
+function applyCors(res) {
+  res.setHeader("access-control-allow-origin", "*");
+  res.setHeader("access-control-allow-headers", "*");
+  res.setHeader("access-control-allow-methods", "GET,POST,PUT,OPTIONS");
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml"
+};
+async function startDevServer(root, port, options = {}) {
+  const host = options.host || DEFAULT_HOST;
+  const manifest = await loadManifest(root);
+  const sessions = /* @__PURE__ */ new Map();
+  const server = (0, import_node_http.createServer)(async (req, res) => {
+    applyCors(res);
+    applySecurityHeaders(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+      if (url.pathname === "/health") {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: true, name: manifest.name, port }));
+        return;
+      }
+      if (url.pathname.startsWith("/games/runtime") || url.pathname.startsWith("/pub/game-instances")) {
+        await handleRuntime(req, res, url, sessions, manifest);
+        return;
+      }
+      if (url.pathname === "/@fzgame/kit.js") {
+        await serveKit(res);
+        return;
+      }
+      if (url.pathname === "/" || url.pathname === "/index.html") {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(launcherHtml(requestOrigin(req, host, port), manifest.name));
+        return;
+      }
+      await serveStatic(root, url.pathname, res);
+    } catch (error) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({ message: error.message }));
+    }
+  });
+  await new Promise((resolveReady, reject) => {
+    server.once("error", (error) => {
+      reject(
+        error.code === "EADDRINUSE" ? new Error(`Port ${port} is already in use. Pass --port to pick another one.`) : new Error(`Cannot serve on ${host}:${port} (${error.code || error.message}).`)
+      );
+    });
+    server.listen(port, host, () => resolveReady());
+  });
+  const address = server.address();
+  return {
+    server,
+    host,
+    port: typeof address === "object" && address ? address.port : port,
+    manifest
+  };
+}
+function applySecurityHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With");
+  res.setHeader("Content-Security-Policy", "frame-ancestors *");
+  res.removeHeader("X-Frame-Options");
+}
+async function serveKit(res) {
+  try {
+    const body = await (0, import_promises2.readFile)(resolveKitFile());
+    res.writeHead(200, { "content-type": "application/javascript; charset=utf-8" });
+    res.end(body);
+  } catch (error) {
+    res.writeHead(404, { "content-type": "text/plain" });
+    res.end(`Cannot serve @fzgame/kit: ${error.message}
+${KIT_HINT}`);
+  }
+}
+async function serveStatic(root, pathname, res) {
+  const rel = decodeURIComponent(pathname).replace(/^\//, "") || "index.html";
+  const abs = (0, import_node_path4.resolve)(root, rel);
+  const rootAbs = (0, import_node_path4.resolve)(root);
+  if (abs !== rootAbs && !abs.startsWith(rootAbs + import_node_path4.sep)) {
+    res.writeHead(403);
+    res.end("Forbidden");
+    return;
+  }
+  try {
+    const info = await (0, import_promises2.stat)(abs);
+    const file = info.isDirectory() ? (0, import_node_path4.join)(abs, "index.html") : abs;
+    res.writeHead(200, {
+      "content-type": MIME[(0, import_node_path4.extname)(file)] || "application/octet-stream"
+    });
+    (0, import_node_fs3.createReadStream)(file).pipe(res);
+  } catch {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+}
+async function handleRuntime(req, res, url, sessions, manifest) {
+  res.setHeader("content-type", "application/json");
+  res.setHeader("access-control-allow-origin", "*");
+  res.setHeader("access-control-allow-headers", "content-type");
+  res.setHeader("access-control-allow-methods", "GET,POST,PUT,OPTIONS");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  if (req.method === "GET" && (url.pathname.startsWith("/pub/game-instances/") || url.pathname.startsWith("/games/runtime/instances/"))) {
+    res.end(
+      JSON.stringify({
+        id: url.pathname.split("/").pop(),
+        name: manifest.name,
+        status: "PUBLISHED",
+        overrides: {},
+        game: { name: manifest.name, configSchema: manifest.configSchema ?? {} }
+      })
+    );
+    return;
+  }
+  if (req.method === "POST" && url.pathname === "/games/runtime/sessions") {
+    const body = await readJson(req);
+    const existing = [...sessions.values()].find(
+      (s) => s.gameInstanceId === body.gameInstanceId && s.status !== "FINISHED"
+    );
+    if (existing) {
+      res.end(JSON.stringify(existing));
+      return;
+    }
+    const session = {
+      id: `dev-${sessions.size + 1}`,
+      token: `dev-token-${sessions.size + 1}`,
+      status: "CREATED",
+      score: null,
+      result: null,
+      metadata: { snapshot: {} },
+      gameInstanceId: String(body.gameInstanceId || "dev-instance")
+    };
+    sessions.set(session.token, session);
+    res.end(JSON.stringify(session));
+    return;
+  }
+  const emitMatch = url.pathname.match(/^\/games\/runtime\/sessions\/([^/]+)\/emit$/);
+  if (req.method === "POST" && emitMatch) {
+    const session = sessions.get(emitMatch[1]);
+    if (!session) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ message: "Session not found" }));
+      return;
+    }
+    const body = await readJson(req);
+    applyDevEmit(
+      session,
+      String(body.type || ""),
+      body.payload
+    );
+    res.end(JSON.stringify(session));
+    return;
+  }
+  const snapMatch = url.pathname.match(/^\/games\/runtime\/sessions\/([^/]+)\/snapshot$/);
+  if (req.method === "PUT" && snapMatch) {
+    const session = sessions.get(snapMatch[1]);
+    if (!session) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ message: "Session not found" }));
+      return;
+    }
+    const body = await readJson(req);
+    session.metadata.snapshot = body.state ?? body;
+    res.end(JSON.stringify(session));
+    return;
+  }
+  const getMatch = url.pathname.match(/^\/games\/runtime\/sessions\/([^/]+)$/);
+  if (req.method === "GET" && getMatch) {
+    const session = sessions.get(getMatch[1]);
+    if (!session) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ message: "Session not found" }));
+      return;
+    }
+    res.end(JSON.stringify(session));
+    return;
+  }
+  res.writeHead(404);
+  res.end(JSON.stringify({ message: "Not found" }));
+}
+function applyDevEmit(session, type, payload) {
+  if (type === "ready") session.status = "READY";
+  if (type === "start") session.status = "PLAYING";
+  if (type === "pause") session.status = "PAUSED";
+  if (type === "finish") {
+    session.status = "FINISHED";
+    if (typeof payload?.score === "number") session.score = payload.score;
+    if (payload?.result) session.result = payload.result;
+  }
+  if (type === "abort") session.status = "ABORTED";
+  if (type === "score" && typeof payload?.score === "number") session.score = payload.score;
+  if (type === "snapshot") session.metadata.snapshot = payload?.state ?? payload;
+}
+function readJson(req) {
+  return new Promise((resolveJson, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      if (chunks.length === 0) return resolveJson({});
+      try {
+        resolveJson(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function requestOrigin(req, host, port) {
+  if (req.headers.host) return `http://${req.headers.host}`;
+  const shown = host === "0.0.0.0" || host === "::" ? DEFAULT_HOST : host;
+  return `http://${shown}:${port}`;
+}
+function launcherHtml(origin, name) {
+  const kit = `kit=${encodeURIComponent("/@fzgame/kit.js")}`;
+  const play = `/game/index.html?gameInstanceId=dev-instance&playerToken=dev-player&apiUrl=${encodeURIComponent(origin)}&${kit}`;
+  const preview = `/game/index.html?preview=true&${kit}`;
+  const editor = `/editor/index.html?gameInstanceId=dev-instance&apiUrl=${encodeURIComponent(origin)}&${kit}`;
+  return `<!doctype html>
+<html>
+  <head><meta charset="utf-8"><title>${name} \u2014 fzgame dev</title></head>
+  <body style="font-family:system-ui;padding:24px">
+    <h1>${name}</h1>
+    <p>Local game developer mode.</p>
+    <p><a href="${play}">Open game</a></p>
+    <p><a href="${preview}">Open preview</a> (no play session; pass <code>gameSetting</code> JSON to try config)</p>
+    <p><a href="${editor}">Open editor</a></p>
+  </body>
+</html>`;
+}
+
+// src/init.ts
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_node_url = require("url");
+var here = (0, import_node_path5.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+var EXAMPLE_DIR = (0, import_node_path5.join)(here, "..", "example", "click-counter");
+async function initGame(targetDir, options = {}) {
+  const dest = (0, import_node_path5.resolve)(targetDir);
+  const template = await (0, import_promises3.stat)(EXAMPLE_DIR).then(
+    (info) => info.isDirectory(),
+    () => false
+  );
+  if (!template) {
+    throw new Error(
+      `Game template missing at ${EXAMPLE_DIR}. Reinstall @fzgame/cli, the "example" folder must ship with it.`
+    );
+  }
+  await (0, import_promises3.mkdir)(dest, { recursive: true });
+  const existing = (await (0, import_promises3.readdir)(dest)).filter((name) => name !== ".DS_Store" && name !== ".git");
+  if (existing.length > 0 && !options.force) {
+    throw new Error(
+      `${dest} is not empty (${existing.slice(0, 5).join(", ")}${existing.length > 5 ? ", ..." : ""}). Pass --force to write into it.`
+    );
+  }
+  const hasGitignore = await (0, import_promises3.stat)((0, import_node_path5.join)(dest, ".gitignore")).then(
+    () => true,
+    () => false
+  );
+  await (0, import_promises3.cp)(EXAMPLE_DIR, dest, {
+    recursive: true,
+    filter: (source) => keep(source) && !(hasGitignore && source.endsWith(`${import_node_path5.sep}.gitignore`))
+  });
+  await ensureGitignore(dest);
+  const files = [];
+  await walk2(dest, (file) => {
+    files.push((0, import_node_path5.relative)(dest, file).split(import_node_path5.sep).join("/"));
+  });
+  files.sort();
+  return { dir: dest, files };
+}
+function keep(source) {
+  const name = source.split(import_node_path5.sep).pop() ?? "";
+  return name !== "dist" && name !== "node_modules" && name !== ".DS_Store";
+}
+async function ensureGitignore(dest) {
+  const path = (0, import_node_path5.join)(dest, ".gitignore");
+  let current = "";
+  try {
+    current = await (0, import_promises3.readFile)(path, "utf8");
+  } catch {
+  }
+  if (/(^|\n)\s*dist\/?\s*(\n|$)/.test(current)) return;
+  const next = current && !current.endsWith("\n") ? `${current}
+` : current;
+  await (0, import_promises3.writeFile)(path, `${next}dist/
+`);
+}
+async function walk2(dir, visit) {
+  for (const entry of await (0, import_promises3.readdir)(dir, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const abs = (0, import_node_path5.join)(dir, entry.name);
+    if (entry.isDirectory()) await walk2(abs, visit);
+    else visit(abs);
+  }
+}
+
+// src/publish.ts
+var import_promises4 = require("fs/promises");
+
+// src/fetch.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function request(url, options = {}) {
+  const { timeoutMs = DEFAULT_TIMEOUT_MS, ...init } = options;
+  try {
+    return await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+  } catch (error) {
+    throw new Error(`${url} ${describeFailure(error, timeoutMs)}`);
+  }
+}
+function describeFailure(error, timeoutMs) {
+  const name = error?.name;
+  if (name === "TimeoutError" || name === "AbortError") {
+    return `did not respond within ${Math.round(timeoutMs / 1e3)}s`;
+  }
+  const cause = error?.cause;
+  const detail = cause instanceof AggregateError ? cause.errors.map(codeOf).join(", ") : codeOf(cause) ?? error?.message ?? String(error);
+  return `failed: ${detail}`;
+}
+function codeOf(error) {
+  if (error instanceof Error) return error.code ?? error.message;
+  return String(error);
+}
+
+// src/publish.ts
+var UPLOAD_TIMEOUT_MS = 12e4;
+async function publishGame(options) {
+  const { dest, manifest } = await buildGame(options.cwd);
+  const zip = await (0, import_promises4.readFile)(dest);
+  const api2 = options.api.replace(/\/$/, "");
+  const path = options.spaceId ? "/portal/games/publishing" : "/games/publishing";
+  const url = `${api2}${path}`;
+  const form = new FormData();
+  form.append(
+    "file",
+    new Blob([new Uint8Array(zip)], { type: "application/zip" }),
+    `${manifest.slug}.zip`
+  );
+  if (options.spaceId) form.set("spaceId", options.spaceId);
+  const res = await request(url, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${options.token}`,
+      cookie: `better-auth.session_token=${options.token}`,
+      ...options.spaceId ? { "x-space-id": options.spaceId } : {}
+    },
+    body: form,
+    timeoutMs: UPLOAD_TIMEOUT_MS
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Publish failed (${res.status}): ${text.slice(0, 500)}`);
+  }
+  const contentType = res.headers.get("content-type") || "";
+  if (!contentType.includes("json")) {
+    throw new Error(
+      `Publish returned ${res.status} ${contentType || "without a content type"} instead of JSON: ${text.slice(0, 200)}`
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Publish returned invalid JSON: ${text.slice(0, 200)}`);
+  }
+}
+
+// src/runner.ts
+var import_node_child_process = require("child_process");
+var import_promises5 = require("fs/promises");
+var import_node_os = require("os");
+var import_node_os2 = require("os");
+var import_node_path7 = require("path");
+
+// src/runner-pipeline.ts
+function planPipeline(scripts) {
+  const stages = ["fetch", "build"];
+  if (scripts?.test) stages.push("test");
+  stages.push("publish");
+  return stages;
+}
+function installCommand(files) {
+  if (!files.includes("package.json")) return null;
+  if (files.includes("pnpm-lock.yaml")) {
+    return ["pnpm", ["install", "--frozen-lockfile"]];
+  }
+  if (files.includes("yarn.lock")) {
+    return ["yarn", ["install", "--frozen-lockfile"]];
+  }
+  if (files.includes("package-lock.json")) return ["npm", ["ci"]];
+  return ["npm", ["install"]];
+}
+function buildCommand(files, scripts) {
+  if (!scripts?.build) return null;
+  const [manager] = installCommand(files.includes("package.json") ? files : ["package.json", ...files]) ?? [
+    "npm",
+    []
+  ];
+  return [manager, ["run", "build"]];
+}
+function testCommand(files, scripts) {
+  if (!scripts?.test) return null;
+  const [manager] = installCommand(files.includes("package.json") ? files : ["package.json", ...files]) ?? [
+    "npm",
+    []
+  ];
+  return [manager, ["run", "test"]];
+}
+
+// src/version.ts
+var import_node_fs4 = require("fs");
+var import_node_path6 = require("path");
+var import_node_url2 = require("url");
+var here2 = (0, import_node_path6.dirname)((0, import_node_url2.fileURLToPath)(importMetaUrl));
+function readVersion() {
+  try {
+    const raw = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path6.join)(here2, "..", "package.json"), "utf8"));
+    return raw.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = readVersion();
+
+// src/runner.ts
+var EXAMPLE = "fzgame runner start --server http://localhost:3020 --key <key> --pass <pass>";
+var CLAIM_TIMEOUT_MS = 3e4;
+var IDLE_SLEEP_MS = 2e3;
+var MIN_BACKOFF_MS = 2e3;
+var MAX_BACKOFF_MS = 3e4;
+var UPLOAD_TIMEOUT_MS2 = 12e4;
+var LOG_FLUSH_MS = 250;
+var LOG_MAX_CHARS = 8e3;
+async function startRunner(opts) {
+  const server = (opts.server || "").replace(/\/$/, "");
+  const key = opts.key || "";
+  const pass = opts.pass || "";
+  if (!server || !key || !pass) {
+    throw new Error(`Pass --server, --key, and --pass. Example: ${EXAMPLE}`);
+  }
+  const headers = {
+    "x-runner-key": key,
+    "x-runner-pass": pass
+  };
+  const connected = await api(server, "/internal/ci-runners/connect", {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      key,
+      pass,
+      hostname: (0, import_node_os.hostname)(),
+      version: VERSION
+    })
+  });
+  console.log(`Runner ${connected.name || key} connected to ${server}`);
+  console.log("Waiting for queued git deploys (fetch \u2192 build \u2192 test \u2192 publish)");
+  let stopping = false;
+  const beat = setInterval(() => {
+    api(server, "/internal/ci-runners/heartbeat", {
+      method: "POST",
+      headers
+    }).catch(() => void 0);
+  }, 15e3);
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    clearInterval(beat);
+    api(server, "/internal/ci-runners/disconnect", {
+      method: "POST",
+      headers
+    }).catch(() => void 0).finally(() => process.exit(0));
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  let backoff = MIN_BACKOFF_MS;
+  const retry = async (message) => {
+    console.error(`${message}; retrying in ${Math.round(backoff / 1e3)}s`);
+    await sleep(backoff);
+    backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+  };
+  while (!stopping) {
+    let res;
+    try {
+      res = await request(`${server}/internal/ci-runners/jobs/next`, {
+        headers,
+        timeoutMs: CLAIM_TIMEOUT_MS
+      });
+    } catch (error) {
+      await retry(`claim failed: ${error.message}`);
+      continue;
+    }
+    backoff = MIN_BACKOFF_MS;
+    if (res.status === 204) {
+      await sleep(IDLE_SLEEP_MS);
+      continue;
+    }
+    const text = await res.text();
+    if (!res.ok) {
+      await retry(`claim failed (${res.status}): ${text.slice(0, 200)}`);
+      continue;
+    }
+    if (!text) {
+      await sleep(IDLE_SLEEP_MS);
+      continue;
+    }
+    let job;
+    try {
+      job = JSON.parse(text);
+    } catch {
+      await retry(`claim returned invalid JSON: ${text.slice(0, 200)}`);
+      continue;
+    }
+    console.log(`Job ${job.deploymentId} ${job.owner}/${job.repo}@${job.commitSha.slice(0, 7)}`);
+    try {
+      await runJob(server, headers, job);
+      console.log(`Job ${job.deploymentId} ready`);
+    } catch (err) {
+      const message = err.message;
+      console.error(`Job ${job.deploymentId} failed: ${message}`);
+      await api(server, `/internal/ci-runners/jobs/${job.deploymentId}/fail`, {
+        method: "POST",
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: JSON.stringify({ message })
+      }).catch(() => void 0);
+    }
+  }
+}
+async function runJob(server, headers, job) {
+  const work = await (0, import_promises5.mkdtemp)((0, import_node_path7.join)((0, import_node_os2.tmpdir)(), "fzgame-run-"));
+  let pending = "";
+  let flushTimer;
+  const flushLogs = async () => {
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = void 0;
+    }
+    if (!pending) return;
+    const chunk = pending;
+    pending = "";
+    await api(server, `/internal/ci-runners/jobs/${job.deploymentId}/logs`, {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify({ chunk })
+    }).catch(() => void 0);
+  };
+  const log = (chunk) => {
+    process.stdout.write(chunk);
+    pending += chunk;
+    if (pending.length >= LOG_MAX_CHARS) {
+      void flushLogs();
+      return;
+    }
+    if (!flushTimer) {
+      flushTimer = setTimeout(() => void flushLogs(), LOG_FLUSH_MS);
+      flushTimer.unref();
+    }
+  };
+  const stage = async (name, status, error) => {
+    await flushLogs();
+    await api(server, `/internal/ci-runners/jobs/${job.deploymentId}/stage`, {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify({ name, status, error })
+    });
+  };
+  try {
+    await stage("fetch", "running");
+    log(`fetch ${job.owner}/${job.repo} ${job.commitSha}
+`);
+    await runCmd("git", ["init"], work, log);
+    const origin = `https://x-access-token:${job.cloneToken}@github.com/${job.owner}/${job.repo}.git`;
+    await runCmd("git", ["remote", "add", "origin", origin], work, () => void 0);
+    await runCmd("git", ["fetch", "--depth", "1", "origin", job.commitSha], work, log);
+    await runCmd("git", ["checkout", "--force", "FETCH_HEAD"], work, log);
+    await stage("fetch", "ok");
+    const packRoot = job.rootDirectory ? (0, import_node_path7.join)(work, job.rootDirectory) : work;
+    const files = await (0, import_promises5.readdir)(packRoot);
+    const scripts = await readScripts(packRoot);
+    const planned = planPipeline(scripts);
+    await stage("build", "running");
+    const install = installCommand(files);
+    if (install) await runCmd(install[0], install[1], packRoot, log);
+    const build = buildCommand(files, scripts);
+    if (build) await runCmd(build[0], build[1], packRoot, log);
+    await stage("build", "ok");
+    if (planned.includes("test")) {
+      await stage("test", "running");
+      const test = testCommand(files, scripts);
+      if (test) await runCmd(test[0], test[1], packRoot, log);
+      await stage("test", "ok");
+    } else {
+      await stage("test", "skipped");
+    }
+    await stage("publish", "running");
+    const packed = await buildGame(packRoot);
+    log(`packed ${packed.dest}
+`);
+    const zip = await (0, import_promises5.readFile)(packed.dest);
+    const form = new FormData();
+    form.append(
+      "file",
+      new Blob([new Uint8Array(zip)], { type: "application/zip" }),
+      "game.zip"
+    );
+    const published = await request(
+      `${server}/internal/ci-runners/jobs/${job.deploymentId}/artifact`,
+      { method: "POST", headers, body: form, timeoutMs: UPLOAD_TIMEOUT_MS2 }
+    );
+    if (!published.ok) {
+      throw new Error(`publish failed (${published.status}): ${await published.text()}`);
+    }
+    await stage("publish", "ok");
+  } finally {
+    await flushLogs();
+    await (0, import_promises5.rm)(work, { recursive: true, force: true });
+  }
+}
+async function readScripts(root) {
+  try {
+    const raw = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path7.join)(root, "package.json"), "utf8"));
+    return raw.scripts ?? {};
+  } catch {
+    return null;
+  }
+}
+function runCmd(cmd, args, cwd, onLog) {
+  return new Promise((resolve3, reject) => {
+    const useShell = process.platform === "win32";
+    const child = (0, import_node_child_process.spawn)(cmd, useShell ? args.map(quoteForShell) : args, {
+      cwd,
+      env: process.env,
+      shell: useShell
+    });
+    child.stdout.on("data", (buf) => onLog(buf.toString()));
+    child.stderr.on("data", (buf) => onLog(buf.toString()));
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (code === 0) resolve3();
+      else if (signal) reject(new Error(`${cmd} ${args.join(" ")} killed by ${signal}`));
+      else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}`));
+    });
+  });
+}
+function quoteForShell(arg) {
+  return /[\s"&|<>^()]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
+}
+async function api(server, path, init) {
+  const res = await request(`${server}${path}`, init);
+  const text = await res.text();
+  if (!res.ok) throw new Error(`${path} failed (${res.status}): ${text.slice(0, 500)}`);
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${path} returned invalid JSON: ${text.slice(0, 200)}`);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/program.ts
+var DEFAULT_API = "http://localhost:3020";
+function buildProgram() {
+  const program = new import_commander.Command();
+  program.name("fzgame").description("Build, publish, and develop FZ games").version(VERSION).addHelpText(
+    "after",
+    `
+Environment (a .env file in the working directory is read too, shell values win):
+  FZGAME_API        GameHub API for publish and runner (default ${DEFAULT_API})
+  FZGAME_SERVER     Alias for FZGAME_API
+  FZGAME_TOKEN      Session token for publish
+  FZGAME_SPACE_ID   Space id, publishes a private game
+  FZGAME_RUNNER_KEY Runner key from the BO receipt
+  FZGAME_RUNNER_PASS Runner pass from the BO receipt`
+  );
+  program.command("init [dir]").description("Scaffold a game from the bundled click-counter example").option("-f, --force", "write into a directory that already has files").action(async (dir, opts) => {
+    const result = await initGame(dir || ".", { force: opts.force });
+    console.log(`Scaffolded ${result.files.length} files in ${result.dir}`);
+    for (const file of result.files) console.log(`  ${file}`);
+    console.log("Next: fzgame dev");
+  });
+  program.command("build").description("Validate fzgame.json and pack game/editor/handler into a zip").option("--cwd <dir>", "game root", process.cwd()).option("-o, --out <file>", "output zip path").action(async (opts) => {
+    const result = await buildGame(opts.cwd, opts.out);
+    console.log(
+      `Built ${result.manifest.slug}@${result.manifest.version} -> ${result.dest}`
+    );
+  });
+  program.command("publish").description("Build and upload the zip to /games/publishing").option("--cwd <dir>", "game root", process.cwd()).option("--api <url>", "GameHub API", process.env.FZGAME_API || DEFAULT_API).option("--token <token>", "session token", process.env.FZGAME_TOKEN).option("--space <id>", "space id for private games", process.env.FZGAME_SPACE_ID).action(async (opts) => {
+    if (!opts.token) {
+      throw new Error("Pass --token or set FZGAME_TOKEN");
+    }
+    const game = await publishGame({
+      cwd: opts.cwd,
+      api: opts.api,
+      token: opts.token,
+      spaceId: opts.space
+    });
+    console.log(`Published ${game.slug}@${game.version} (${game.id})`);
+    if (game.entryPointUrl) console.log(game.entryPointUrl);
+  });
+  program.command("dev").description("Serve the game locally with a mock runtime kit API").option("--cwd <dir>", "game root", process.cwd()).option("-p, --port <port>", "port", "3400").option("--host <host>", "bind address (use 0.0.0.0 to expose on the LAN)", "127.0.0.1").action(async (opts) => {
+    const { port, manifest } = await startDevServer(opts.cwd, Number(opts.port), {
+      host: opts.host
+    });
+    const shown = opts.host === "0.0.0.0" || opts.host === "::" ? "127.0.0.1" : opts.host;
+    console.log(`${manifest.name} dev server http://${shown}:${port}`);
+    if (shown !== opts.host) console.log(`Bound to ${opts.host}, reachable from the LAN`);
+  });
+  const runner = program.command("runner").description("Self-hosted GameHub CI runner");
+  runner.command("start").description("Connect to the API and run fetch \u2192 build \u2192 test \u2192 publish jobs").option(
+    "--server <url>",
+    "GameHub API",
+    process.env.FZGAME_API || process.env.FZGAME_SERVER || DEFAULT_API
+  ).option("--key <key>", "runner key from the BO receipt", process.env.FZGAME_RUNNER_KEY).option("--pass <pass>", "runner pass from the BO receipt", process.env.FZGAME_RUNNER_PASS).action(async (opts) => {
+    await startRunner({
+      server: opts.server,
+      key: opts.key || "",
+      pass: opts.pass || ""
+    });
+  });
+  return program;
+}
+
+// src/cli.ts
+loadEnvFile();
+buildProgram().parseAsync(process.argv).catch((error) => {
+  console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map