@genex-ai/cli-demo 1.36.8 → 1.36.9

package/dist/index.js

@@ -876,6 +876,90 @@ async function writeGameConfigFiles(meta, log, cwd = process.cwd()) {
     await writeIfAbsent(path3.join(cwd, ".env.development.local"), overrides, log);
   }
 }
+var SLUG_CONFIG_FILES = ["src/genex.config.ts", "src/genex.config.js"];
+var SLUG_ENV_FILES = [".env.production.local", ".env.production", ".env.local", ".env"];
+var SLUG_LITERAL = /^(["'`])([a-z0-9][a-z0-9-]*)\1$/;
+function topLevelFields(code, start) {
+  const fields = [];
+  let field = "";
+  let depth = 0;
+  for (let i = start; i < code.length; i++) {
+    const ch = code[i];
+    if (ch === "/" && code[i + 1] === "/") {
+      const end = code.indexOf("\n", i);
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "*") {
+      const end = code.indexOf("*/", i + 2);
+      if (end === -1) return null;
+      i = end + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      let j = i + 1;
+      while (j < code.length && code[j] !== ch) j += code[j] === "\\" ? 2 : 1;
+      if (j >= code.length) return null;
+      field += code.slice(i, j + 1);
+      i = j;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (ch === "}") {
+      if (depth === 0) {
+        fields.push(field);
+        return fields;
+      }
+      depth--;
+    } else if (ch === "," && depth === 0) {
+      fields.push(field);
+      field = "";
+      continue;
+    }
+    field += ch;
+  }
+  return null;
+}
+function bakedConfigSlug(content) {
+  const object = /export\s+const\s+GENEX(?:\s*:[^=]+)?\s*=\s*\{/.exec(content);
+  if (!object) return null;
+  const fields = topLevelFields(content, object.index + object[0].length);
+  const value = fields?.map((f) => /^\s*(?:slug|["']slug["'])\s*:([\s\S]*)$/.exec(f)?.[1]?.trim()).find((v) => v !== void 0);
+  if (!value) return null;
+  const fallback = value.includes("??") ? value.slice(value.lastIndexOf("??") + 2).trim() : value;
+  return SLUG_LITERAL.exec(fallback)?.[2] ?? null;
+}
+function envFileSlug(content) {
+  let found = null;
+  for (const line of content.split(/\r?\n/)) {
+    const match = /^[ \t]*(?:export[ \t]+)?VITE_GENEX_SLUG[ \t]*=[ \t]*(.*)$/.exec(line);
+    if (!match) continue;
+    const raw = match[1].trim();
+    const quote2 = raw[0] === '"' || raw[0] === "'" ? raw[0] : null;
+    const value = quote2 ? raw.slice(1, raw.indexOf(quote2, 1) === -1 ? void 0 : raw.indexOf(quote2, 1)) : raw.replace(/[ \t]+#.*$/, "");
+    if (value.trim()) found = value.trim();
+  }
+  return found;
+}
+async function findForeignSlug(cwd, slug, env = process.env) {
+  const read = (rel) => fs2.readFile(path3.join(cwd, rel), "utf8").catch(() => null);
+  const judge = (file, found) => found === slug ? null : { file, found };
+  const fromShell = env.VITE_GENEX_SLUG?.trim();
+  if (fromShell) return judge("VITE_GENEX_SLUG (environment)", fromShell);
+  for (const rel of SLUG_ENV_FILES) {
+    const content = await read(rel);
+    const found = content === null ? null : envFileSlug(content);
+    if (found) return judge(rel, found);
+  }
+  for (const rel of SLUG_CONFIG_FILES) {
+    const content = await read(rel);
+    const found = content === null ? null : bakedConfigSlug(content);
+    if (found !== null) return judge(rel, found);
+  }
+  return null;
+}
 
 // src/lib/ssh.ts
 import fs3 from "fs/promises";
@@ -2630,6 +2714,26 @@ async function detectEmbedSdkVersion(cwd = process.cwd()) {
     return null;
   }
 }
+var MIN_MULTIPLAYER_SDK = { major: 0, minor: 17 };
+async function outdatedMultiplayerSdk(cwd = process.cwd()) {
+  const readJson = async (rel) => {
+    try {
+      return JSON.parse(await fs13.readFile(path14.join(cwd, rel), "utf8"));
+    } catch {
+      return null;
+    }
+  };
+  const pkg = await readJson("package.json");
+  const range = pkg?.dependencies?.["@genex-ai/multiplayer"] ?? pkg?.devDependencies?.["@genex-ai/multiplayer"];
+  if (!range) return null;
+  const installed = (await readJson("node_modules/@genex-ai/multiplayer/package.json"))?.version;
+  const version = typeof installed === "string" ? installed : range;
+  const match = /^[\^~>=v\s]*(\d+)\.(\d+)/.exec(version);
+  if (!match || /[|<]|\s-\s/.test(version)) return null;
+  const [major, minor] = [Number(match[1]), Number(match[2])];
+  const old = major < MIN_MULTIPLAYER_SDK.major || major === MIN_MULTIPLAYER_SDK.major && minor < MIN_MULTIPLAYER_SDK.minor;
+  return old ? version : null;
+}
 async function detectMultiplayer(cwd = process.cwd()) {
   try {
     const raw = await fs13.readFile(path14.join(cwd, "package.json"), "utf8");
@@ -5690,6 +5794,23 @@ async function deployGame(ctx, opts, log) {
       return false;
     }
   }
+  const expectedSlug = ctx.slug ?? meta?.slug;
+  if (expectedSlug) {
+    const foreign = await findForeignSlug(cwd, expectedSlug);
+    if (foreign) {
+      log.error(
+        `${foreign.file} names the game "${foreign.found}", but this folder is the Genex game "${expectedSlug}". The build would sign players into "${foreign.found}". Set it to "${expectedSlug}" and deploy again. Nothing was deployed.`
+      );
+      return false;
+    }
+  }
+  const oldSdk = await outdatedMultiplayerSdk(cwd);
+  if (oldSdk) {
+    log.error(
+      `This game uses @genex-ai/multiplayer ${oldSdk}, which Genex's multiplayer server no longer accepts. Run \`npm i @genex-ai/multiplayer@^0.17.0\` and deploy again. Nothing was deployed.`
+    );
+    return false;
+  }
   if (!opts.noBuild && await hasBuildScript(cwd)) {
     log.step("Building the production bundle\u2026");
     const built = await run("npm", ["run", "build"]);
@@ -6813,6 +6934,12 @@ async function runPreview(opts) {
     log.plain("");
     log.plain(nudge);
   }
+  if (detections.multiplayer) {
+    log.plain("");
+    log.plain(
+      "Multiplayer on this preview runs in rooms of its own, apart from the live game. Test it as two different players: open the preview-- address printed above in a normal and an incognito window, or send it to a friend. The game's page is yours only."
+    );
+  }
 }
 
 // src/commands/remix.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.36.8",
+  "version": "1.36.9",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/skills/genex-threejs-embed-auth/SKILL.md

@@ -469,8 +469,9 @@ Rules:
   `[::1]` — not https, not a LAN IP), the page is not inside an iframe, and
   `@genex-ai/embed-sdk` is 0.5.0+ (older: apply the pending platform update).
 - **Multiplayer `connect()` fails in local test mode** — by design: no relay
-  credential exists there. Validate multiplayer on the hosted draft (the
-  owner's session) or the published game, and say plainly when it wasn't.
+  credential exists there. Validate multiplayer on the preview link (it plays in
+  rooms of its own; a normal and a private window are two players), and say
+  plainly when it wasn't.
 - **Multiplayer join rejected with 401** — the join ran before
   `waitForPlayer()` resolved, without `auth: () => getColyseusAuth()`, or with a
   stale cached token on reconnect (read it fresh each call).

package/templates/skills/genex-threejs-multiplayer/SKILL.md

@@ -33,23 +33,42 @@ example, the shared-object/ball code, rotation, and host usage. Read
 calling multiplayer done, run the mandatory
 [netcode feel gate](references/genex-netcode-feel-checklist.md).
 
+## Testing multiplayer: on the preview link, with two different players
+
+**A preview build is multiplayer in rooms of its own.** `npx genex preview` (the
+`preview--<slug>` address) plays in rooms the relay keeps apart from the live game: testers on the
+preview link meet each other and never meet real players, and a published game's players never see
+an untested build. Anyone with the preview link can join, as a guest or signed in, even before the
+game is published. You do nothing for this: the game always passes its plain slug; the relay picks
+the room.
+
+- **Test it on the preview, as two DIFFERENT players:** the preview link is the `preview--<slug>`
+  address `npx genex preview` prints on its "Live" line (the dashboard's draft page is the owner's
+  only). Open it in a normal window and an incognito window (the incognito one plays as a guest),
+  or send it to a friend.
+  Two tabs on one account are ONE seat: the newer tab takes it (close code 4409).
+- Until two players have played it, tell the user multiplayer is built but not yet verified, give
+  them the preview link and say exactly that: open it in a normal and an incognito window.
+- Nobody can save or buy on a preview, the owner included. Test progression saves and purchases
+  after publishing.
+
 ## Install
 
 ```bash
-npm i @genex-ai/multiplayer@^0.16.0
+npm i @genex-ai/multiplayer@^0.17.0
 ```
 
-> Pin `@^0.16.0` (not a bare `npm i`, and not an older range): automatic TURN — the thing that
+> Pin `@^0.17.0` (not a bare `npm i`, and not an older range): 0.17 speaks the relay's current
+> wire protocol, and the relay **refuses every older SDK** — a game built on 0.16 or earlier
+> cannot join a room at all (its joins fail with `unsupported protocol`). 0.17 also added a
+> relay-stamped per-game player id (`p.uid`), relay-assigned teams for the `open` preset
+> (`p.team`) and the `room:open` event. Earlier floors still hold: automatic TURN — the thing that
 > lets players behind symmetric NAT or carrier CGNAT be heard at all — landed in 0.16, mesh voice
-> in 0.15, room text chat in 0.14, host-only `setRoomOpen()` in 0.13; cross-region invites can
-> select the inviter's exact relay with the optional `url` override since 0.11; unowned object
-> writes warn instead of failing silently, live connected-player presence, supplier-form
-> `connect()` auth and regional relay selection (`getColyseusUrls()` + `urls`) landed in 0.10;
-> confirmed object controls, snaps, host-tick teardown, and reconnect rebasing in 0.9. An older
-> resolve does not have those — and because this package is still `0.x`, a caret range is
-> minor-locked, so `^0.12.0` would resolve to 0.12.x and give you no voice at all.
-
-This skill targets `@genex-ai/multiplayer` **≥ 0.16.0** (`objects`/`host` since 0.4; verified per-player `avatarUrl` since 0.12;
+> in 0.15, room text chat in 0.14, host-only `setRoomOpen()` in 0.13. Because this package is
+> still `0.x`, a caret range is minor-locked, so `^0.16.0` would resolve to 0.16.x and never join.
+
+This skill targets `@genex-ai/multiplayer` **≥ 0.17.0** (relay protocol 3, `p.uid`/`p.team` and
+`room:open` since 0.17; `objects`/`host` since 0.4; verified per-player `avatarUrl` since 0.12;
 room text chat via `room.chat` since 0.14; mesh voice via `room.voice` since 0.15;
 automatic TURN (voice connects behind symmetric NAT with no configuration) since 0.16;
 `matchmake()` since 0.5; private lobbies since 0.7; auto-reconnect + `inputs`/`onHostTick`
@@ -132,6 +151,8 @@ mm.on("matched", () => syncSession());
 mm.on("matchStart", () => syncSession()); // duel/arena/teams only
 mm.on("matchEnded", (result) => showResult(result)); // duel/arena/teams only
 mm.on("error", (e) => showQueueError(e)); // after SDK retries; fix, then mm.retry()
+// 4409 = opened in another tab/device, 4401 = signed out: the handle stops, never requeues.
+mm.on("disconnect", () => showMenu("This game is open somewhere else.")); // mm.retry() only on a click
 
 // Every frame AND a low-rate timer: the handle swaps in a new Session after
 // seating, terminal drop/requeue, and the next match.
@@ -330,8 +351,9 @@ halves of this rule are non-negotiable:
    is never written (host bug, host left), every player is stuck on the waiting screen forever.
    A ready-check or countdown is fine as an ADDITION layered on top of `status === 'playing'`
    (host writes it to `shared` so it survives host migration), never as a replacement for it.
-2. **Verify it for real before calling multiplayer done**: open the game in two browser windows
-   (one regular + one incognito, so they're two players), join with both, and watch the waiting
+2. **Verify it for real before calling multiplayer done**: on the preview link (see "Testing
+   multiplayer"), open it in two browser windows (one regular + one incognito, so they're two
+   players), join with both, and watch the waiting
    screen disappear on BOTH the moment the count reaches `minPlayers` (with
    `minPlayers: 2, maxPlayers: 2`: the instant the second player joins). If it doesn't close on
    both, the lobby is broken — fix it; do not ship a waiting room you haven't watched close.
@@ -669,7 +691,8 @@ fights (many writers). A ball on `objects` glides and has one owner. That's the
   - `ids()` — all object ids seen.
 - `room.isHost` / `room.host` — you are (or who is) the elected authority. Use to pick the single
   writer of `shared` scores/rounds and the single simulator of host-owned objects. Settles within
-  the first patch after connect — read in your loop / react to `on('host')`, not once.
+  the first patch after connect — read in your loop / react to `on('host')`, not once. `isHost` is
+  false while reconnecting (until the fresh snapshot lands), so gating a write on it is safe.
   `room.host === undefined` before that patch means **authority is not ready**:
   do not start host-owned simulation and do not synthesize an "acting host" from
   a locally sorted roster. Clients can briefly observe different rosters, so
@@ -930,11 +953,11 @@ function awardOnce(scorerUid: string, name: string, marker: `__${string}`, seq:
 ```
 
 **Key scores by a STABLE identity, never the session id.** A session id dies on every reload —
-the points orphan into a duplicate row and the player's color changes. Publish a short `uid` in
-each player's state (from the embed identity: `const { user } = await waitForPlayer()`,
-`uid = user.id` — stable for signed-in players AND guests; see `$genex-threejs-embed-auth`), and
-key `scores`/colors/`isMe` by that uid. When an event only carries a session id, map it via
-`room.players.get(sid)?.stateRaw.uid`.
+the points orphan into a duplicate row and the player's color changes. The relay stamps every
+player with `uid` — their stable id **in this game**, the same across reloads, never their account
+id — so key `scores`/colors/`isMe` by it. When an event only carries a session id, map it via
+`room.players.get(sid)?.uid`. Never publish the account id (`user.id`) in player state yourself:
+every peer reads it.
 
 For host-simulated NPCs, the host claims and drives each enemy as an `object`; when the host
 leaves, its enemies are reassigned to the new host, which reads their `stateRaw` and keeps
@@ -985,10 +1008,11 @@ from any still capture whether movement feels smooth.** Don't try — it leads t
    other (and the ball, if any). That's all a capture can prove. Local test mode (what the dev
    server boots into — the embed-auth skill) can NOT do this: it mints no relay credential, so `connect()`
    fails there by design and two local-test tabs never see each other — run the two-client check
-   on the published game (or have the owner open their draft), and if multiplayer wasn't
-   exercised, say exactly that in your handoff instead of implying it was.
+   on the preview link (see "Testing multiplayer"), and if multiplayer wasn't exercised, say
+   exactly that in your handoff instead of implying it was.
 3. **Then say plainly:** *"Multiplayer smoothness depends on your network and can only be felt by a
-   person — open it in two tabs or with a friend and tell me how it feels."* Stop there.
+   person — open the preview link in a normal and a private window, or send it to a friend, and
+   tell me how it feels."* Stop there.
 
 ### When the human reports a problem, match the symptom (don't guess)
 
@@ -1062,7 +1086,7 @@ host-driven saving works as long as ANY account is in the room.
 
 ## Checklist
 
-- [ ] `npm i @genex-ai/multiplayer@^0.16.0` (automatic TURN, mesh voice, room text chat, connected presence, supplier auth, confirmed controls, snap epochs, reconnect-safe host ticks, unowned-write warnings, cross-region exact-relay overrides); config wired into the build.
+- [ ] `npm i @genex-ai/multiplayer@^0.17.0` (the only range the relay accepts; per-game `p.uid`, automatic TURN, mesh voice, room text chat, connected presence, supplier auth, confirmed controls, snap epochs, reconnect-safe host ticks, unowned-write warnings, cross-region exact-relay overrides); config wired into the build.
 - [ ] The plan names one net model, the player-experience reason, start/quorum, late-join/backfill,
       and below-quorum/end behavior. The agent inferred it unless the experience was genuinely ambiguous.
 - [ ] `reconnecting`/`reconnected`/`disconnect` render an overlay (don't tear the scene down).
@@ -1081,7 +1105,7 @@ host-driven saving works as long as ANY account is in the room.
       dedupe keys, the victim applies its own damage, respawn publishes via `me.snap`, and
       projectiles are hard-capped objects removed with `removeConfirmed`.
 - [ ] Host score writes are exactly-once (marker in the same `shared` write) and keyed by the
-      stable embed `uid`, never the session id.
+      relay-stamped `p.uid`, never the session id.
 - [ ] Host renders objects OWNED BY OTHERS from the stream (authority follows ownership).
 - [ ] `connect()` runs AFTER `await waitForPlayer()` (never `waitForAuth()` — guests would
       hang) and passes `auth: () => getColyseusAuth()` (the relay rejects tokenless joins —

package/templates/skills/genex-threejs-multiplayer/references/genex-netcode-feel-checklist.md

@@ -44,8 +44,9 @@ suite for the game.
 
 ## One focused proof with two distinct identities
 
-Use regular + incognito guest identities, two accounts/devices, or ask the user to perform the exact
-sequence. Two tabs sharing one identity are one enforced seat.
+Run it on the preview link (`npx genex preview`): a preview plays in rooms of its own, apart from
+the live game. Use regular + incognito guest identities, two accounts/devices, or ask the user to
+perform the exact sequence. Two tabs sharing one identity are one enforced seat.
 
 1. Enter online using real clicks. Then press Space/Enter/the main action using real key input; confirm
    focus did not re-trigger Play/Leave and both sessions remain live.

package/templates/skills/genex-threejs-multiplayer/references/genre-recipes.md

@@ -169,7 +169,7 @@ SKILL.md is the assignment story, verbatim. Everything else is Recipe 1/2 mechan
 
 | Thing | Channel | Authority |
 | --- | --- | --- |
-| Each player's avatar (+ `uid`, hp, `life`) | `me.set` / `players` | each player |
+| Each player's avatar (hp, `life`; the relay stamps `uid`) | `me.set` / `players` | each player |
 | The team map (`id → red/blue`) | `shared` (`"teams"`) | the **host** — the SKILL.md reconciler, every tick |
 | Team scores | `shared` (exactly-once marker — SKILL.md host section) | `room.isHost` |
 | Attacks / defeats | `send` (Recipe 2 rules verbatim) | attacker / victim |