@genex-ai/cli-demo 0.33.0 → 0.35.0

package/README.md

@@ -8,6 +8,7 @@ genex init <name>          # authorize + create the draft project
 genex link <slug>          # re-link this folder to an existing game of yours (recovery)
 genex preview              # build + push to the hosted draft URL (unlisted)
 genex publish              # build + push, then list the game in the gallery
+genex make-remixable          # make this game remixable — migrate a private source to a public repo
 genex model "<prompt>"     # generate a 3D model  → prints an asset URL
 genex skybox "<prompt>"    # generate a 360° sky  → prints an asset URL
 genex sfx "<prompt>"       # generate a sound fx  → prints an asset URL

package/dist/index.js

@@ -659,7 +659,12 @@ async function createDraftProject(opts) {
           "Content-Type": "application/json",
           Authorization: `Bearer ${token}`
         },
-        body: JSON.stringify(opts.repoUrl ? { name, repoUrl: opts.repoUrl } : { name })
+        body: JSON.stringify({
+          name,
+          ...opts.repoUrl ? { repoUrl: opts.repoUrl } : {},
+          ...opts.private ? { private: true } : {},
+          ...opts.remixedFromSlug ? { remixedFromSlug: opts.remixedFromSlug } : {}
+        })
       });
     } catch (err) {
       log.warn(`Couldn't reach the API at ${apiUrl} to create the project.`);
@@ -990,6 +995,8 @@ async function runInit(opts) {
     token,
     name: projectName,
     repoUrl: opts.repo?.trim() || void 0,
+    private: opts.private,
+    remixedFromSlug: opts.remixedFrom?.trim() || void 0,
     colyseusUrl,
     dashboardUrl: authBaseUrl,
     log
@@ -1328,10 +1335,12 @@ async function callPublish(ctx, commit, opts, log) {
   return true;
 }
 async function pushSource(cwd, ctx, log) {
-  const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   const target = await fetchPushUrl(ctx, log);
   if (!target) return false;
-  const { pushUrl, managed } = target;
+  return pushWorktree(cwd, target.pushUrl, target.managed, log);
+}
+async function pushWorktree(cwd, pushUrl, managed, log) {
+  const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   const failed = () => {
     log.error("Couldn't save your game's source \u2014 please try again.");
     return false;
@@ -1440,6 +1449,75 @@ async function waitUntilLive(playUrl, fingerprint, timeoutMs, log) {
   log.dim("  (If the previous build shows, hard-refresh in a few seconds.)");
 }
 
+// src/commands/make-remixable.ts
+async function runMakeRemixable(opts) {
+  const log = createLogger({ quiet: opts.quiet });
+  log.plain(c.bold("genex make-remixable"));
+  log.plain("");
+  const meta = await readProject();
+  if (!meta) {
+    log.error("No genex project here. Run `genex init` in this directory first.");
+    process.exitCode = 1;
+    return;
+  }
+  const token = await readUserToken(opts.envPath);
+  if (!token) {
+    log.error("Not authorized. Run `genex init` first to sign in.");
+    process.exitCode = 1;
+    return;
+  }
+  const apiUrl = getApiUrl(opts.apiUrl ?? meta.apiUrl);
+  log.step("Preparing a public repo for your game\u2026");
+  let res;
+  try {
+    res = await apiFetch(`${apiUrl}/api/projects/${meta.id}/make-remixable`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` }
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${apiUrl}: ${String(err)}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (res.status === 401) {
+    log.error("Not authorized \u2014 your token may have expired. Re-run `genex init`.");
+    process.exitCode = 1;
+    return;
+  }
+  if (res.status === 404) {
+    log.error("That game wasn't found on your account. Re-run `genex init` or `genex link <slug>`.");
+    process.exitCode = 1;
+    return;
+  }
+  if (!res.ok) {
+    log.error(`Couldn't make the game public (HTTP ${res.status}).`);
+    process.exitCode = 1;
+    return;
+  }
+  const data = await res.json().catch(() => null);
+  if (!data?.pushUrl) {
+    log.error("The API didn't return a push URL.");
+    process.exitCode = 1;
+    return;
+  }
+  log.step("Copying your game's source to the public repo\u2026");
+  if (!await pushWorktree(process.cwd(), data.pushUrl, true, log)) {
+    process.exitCode = 1;
+    return;
+  }
+  const newCloneUrl = data.project?.cloneUrl;
+  if (newCloneUrl && newCloneUrl !== meta.cloneUrl) {
+    await writeProject({ ...meta, cloneUrl: newCloneUrl });
+  }
+  log.plain("");
+  log.success("Your game is public \u2014 anyone can remix it now. \u{1F310}");
+  const dashboard = meta.dashboardOrigins?.[0];
+  if (dashboard) {
+    const page = meta.status === "published" ? "world" : "draft";
+    log.plain(`  your game's page: ${c.cyan(`${dashboard}/${page}/${meta.slug}`)}`);
+  }
+}
+
 // src/lib/detect-features.ts
 import fs10 from "fs/promises";
 import path11 from "path";
@@ -2128,6 +2206,8 @@ ${c.bold("Usage")}
                                      update the same live game. Never creates a project.
   genex preview [options]            Build + push to the hosted draft URL (unlisted).
   genex publish [options]            Build + push, then list the game in the gallery.
+  genex make-remixable [options]     Make THIS game remixable by everyone \u2014 migrates a
+                                     private source onto a public managed genex repo.
   genex model "<prompt>" [options]   Generate a 3D model (GLB) into public/assets/models.
   genex skybox "<prompt>" [options]  Generate a skybox (equirect) into public/assets/skybox.
   genex sfx "<prompt>" [options]     Generate a sound effect (mp3) into public/assets/sfx.
@@ -2150,6 +2230,8 @@ ${c.bold("Options for `init`")}
   --name <name>        Same as the positional name.
   --repo <url>         Host the source in your own git repo (https/ssh) instead of a managed one;
                        preview/publish push there with your git credentials.
+  --private            Create the game private \u2014 only you can remix it (managed repos only).
+  --remixed-from <slug> Record the game this one was remixed from (lineage).
   --agents <list>      Agents to install skills for (claude,codex,cursor; default: auto-detect).
   --dir <path>         Single destination workspace (overrides --agents).
   --env <path>         Token env file (default: ~/.genex/env).
@@ -2207,6 +2289,7 @@ ${c.bold("Examples")}
   genex preview
   genex publish
   genex publish --categories games,vfx
+  genex make-remixable
   genex publish --no-push --title "My Game"
   genex model "weathered wooden barrel with iron bands"
   genex skybox "golden hour over a misty mountain range"
@@ -2232,6 +2315,7 @@ function parseArgs(argv) {
     "--agents",
     "--name",
     "--repo",
+    "--remixed-from",
     "--title",
     "--description",
     "--categories",
@@ -2275,6 +2359,9 @@ function parseArgs(argv) {
       case "--regenerate-cover":
         parsed.options.regenerateCover = true;
         break;
+      case "--private":
+        parsed.options.private = true;
+        break;
       case "--quiet":
         parsed.options.quiet = true;
         break;
@@ -2334,6 +2421,9 @@ function applyValueFlag(options, flag, value) {
     case "--repo":
       options.repo = value;
       break;
+    case "--remixed-from":
+      options.remixedFrom = value;
+      break;
     case "--title":
       options.title = value;
       break;
@@ -2412,6 +2502,9 @@ async function main() {
       case "link":
         await runLink(parsed.options);
         break;
+      case "make-remixable":
+        await runMakeRemixable(parsed.options);
+        break;
       case "controller":
         await runController({ ...parsed.options, kind: parsed.options.name });
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "Set up your ~/.claude workspace, authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

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

@@ -85,17 +85,71 @@ owns the queue, roles, winner-stays, forfeit, timeout, and the win condition.
 ```jsonc
 "genex": {
   "matchmaking": {
-    "preset": "arena",                 // duel | arena | teams | private
+    "preset": "arena",                 // open | duel | arena | teams | private
     "winCondition": "firstToScore",    // lastStanding | firstToScore | highScoreInTime | firstToFinish
     "config": { "scoreTarget": 20, "maxPlayers": 8 }   // numeric knobs, optional
   }
 }
 ```
 
-Presets: **duel** (1v1 winner-stays), **arena** (N-player FFA, join-anytime), **teams** (balanced
-N-v-N), **private** (invite-code lobby). Win conditions: **lastStanding** (last one alive),
-**firstToScore** (first to the score target), **highScoreInTime** (top score at the time cap),
-**firstToFinish** (first to finish). A round that hits the time cap undecided is a draw.
+**Choosing a preset — your own rules → `open`; a ready-made match loop → `duel`/`arena`/`teams`.**
+Presets: **open** (a room of N players — the server owns only seating/capacity/refill, you write
+everything else), **duel** (1v1 winner-stays), **arena** (N-player FFA, join-anytime), **teams**
+(balanced N-v-N), **private** (invite-code lobby). Win conditions (batteries-included presets only):
+**lastStanding** (last one alive), **firstToScore** (first to the score target), **highScoreInTime**
+(top score at the time cap), **firstToFinish** (first to finish). A round that hits the time cap
+undecided is a draw. (`open` has no win condition — it never ends a round for you.)
+
+### `open` — the default building block (bring your own rules)
+
+Reach for **`open`** first: a room of up to `maxPlayers` that the queue seats and (optionally)
+refills, and NOTHING else — no rounds, no scores, no win condition, no winner-stays eviction. You
+build teams/rounds/scoring/win-logic in game code on the primitives you already have (host election,
+`shared`, per-player state, the `players` list). Config knobs (all numbers):
+
+```jsonc
+"genex": { "matchmaking": { "preset": "open", "config": {
+  "maxPlayers": 10,   // seat cap (clamped 2..64)
+  "minPlayers": 2,    // quorum to flip waiting→playing (default 1)
+  "fill": 1           // 1 = keep full: grow to max + refill freed seats (default); 0 = lock for good once simultaneously full (no substitutes)
+} } } }
+```
+
+With `open`, `mm.matchmaking.status` only goes `searching`→`waiting`→`playing` (never `countdown`/
+`ended`), `players` is the live roster, and `scores`/`winnerId` stay empty — watch `players` and
+`status`, not `matchStart`/`matchEnded` (they never fire). Nobody is ever evicted. Build the rest:
+
+| Want… | Do it in game code on top of `open` |
+| --- | --- |
+| Room formation & refill | Nothing — the server owns it via `minPlayers`/`maxPlayers`/`fill`. |
+| Duel (1v1) | `maxPlayers: 2, minPlayers: 2`, then start when `mm.matchmaking.players.length === 2`. |
+| Team assignment | The **host** splits `players` deterministically (sort ids, round-robin) and writes the map to `shared` (`session.shared.set('teams', …)`); everyone renders from it. Survives host migration because it lives in shared state. |
+| Rounds / countdown | Host writes `{ phase, deadline }` into `shared`; clients render the countdown from the timestamp (no server clock — approximate fairness is fine at this trust tier). |
+| Scores | A host-owned entry in `shared` (or per-player state); you define what a point means. |
+| Win condition | Your code checks its own condition (you already compute the signals) and the host writes the result to `shared`. |
+| Winner-stays / rotation | The losing **client** leaves voluntarily — `mm.cancel()` then `matchmake()` again; the freed seat refills (`fill: 1`). There is NO forced kick (a server-only power, deliberately not exposed) — a modified client can squat its seat, so if you need *enforced* rotation use `duel`/`arena`/`teams` instead. |
+| Forfeit on disconnect | React to the `players` list shrinking (the SDK surfaces leaves after the reconnect grace). |
+| Spectators | A game-level role: keep a "dead"/observing player seated and just render them as a watcher. There is no server spectator concept — everyone in a room is a player. |
+
+#### Waiting room / lobby — two patterns
+
+`open` seats you into a LIVE shared room the moment you're matched (`session` goes live, players sync)
+but doesn't "start" anything — so the pre-game lobby is simply **your room before it's grown to the
+size you want**. Set `minPlayers` to your target (so `status` stays `waiting` until enough arrive) and
+let the **host** own the "go" moment by writing a start signal to `shared` (it survives host migration).
+The lobby and the game are ONE `open` room — never spin up a second room for it. Two ways to present it:
+
+- **A) UI lobby (Dota-style).** While waiting, render an OVERLAY from `mm.matchmaking` instead of the
+  game: the roster + count (`players.length` / target), each player's name, and optionally a per-player
+  "ready" toggle (store it in per-player state or a `shared` map). The host begins when all are ready
+  (or `players.length >= N`) by writing e.g. `session.shared.set('phase', { started: true, at: <ts> })`;
+  every client sees it and swaps the overlay for the game.
+- **B) Physical lobby (Roblox-style).** The waiting area IS a 3D scene in the SAME room: render a lobby
+  and let players walk their avatars around, syncing position with `me.set` on the tick exactly like
+  in-game. Show a "N / target — starting soon" sign driven by `players.length`. A "ready pad" is a nice
+  affordance: players stand on it, the host counts how many are on it (from their synced positions) and
+  writes a `shared` countdown; when it elapses everyone moves their camera/scene into the match — no
+  re-matchmaking, they're already together.
 
 **Private lobbies** (for `preset: 'private'`) don't use `matchmake()` — a host makes an invite code
 and friends join it; the lobby is persistent (rounds replay, nobody is evicted):