@genex-ai/cli-demo 0.30.0 → 0.33.0

package/dist/index.js

@@ -567,6 +567,34 @@ function formatUpdateRequired(body) {
   const message = body.message ?? `Genex CLI ${body.clientVersion ?? getCliVersion()} is below the minimum supported version${body.minVersion ? ` ${body.minVersion}` : ""}.`;
   return [`${c.red("\u2717")} ${message}`, `  Update now \u2014 run: ${action}  (then re-run this command)`];
 }
+function shortDate(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function formatInsufficientCredits(body) {
+  const message = body.message ?? `this generation costs ${body.price ?? "?"} credits; your balance is ${body.balance ?? 0}.`;
+  const lines = [`${c.red("\u2717")} Out of credits \u2014 ${lowerFirst(message)}`];
+  if (body.refillAt && body.refillTo) {
+    lines.push(`  Credits refill to ${body.refillTo} on ${shortDate(body.refillAt)}.`);
+  }
+  if (body.url) lines.push(`  Get more or check your balance: ${body.url}`);
+  return lines;
+}
+function formatVerificationRequired(body) {
+  const lines = [
+    `${c.red("\u2717")} Email not verified \u2014 verify your email to unlock your free generation credits.`
+  ];
+  if (body.url) lines.push(`  Verify here: ${body.url}  (then re-run this command)`);
+  return lines;
+}
+function lowerFirst(s) {
+  return s ? s[0].toLowerCase() + s.slice(1) : s;
+}
+var structuredPrinted = /* @__PURE__ */ new WeakSet();
+function printedStructuredError(res) {
+  return structuredPrinted.has(res);
+}
 async function apiFetch(url, init = {}) {
   const headers = new Headers(init.headers);
   if (!headers.has(CLI_VERSION_HEADER)) headers.set(CLI_VERSION_HEADER, getCliVersion());
@@ -580,6 +608,39 @@ async function apiFetch(url, init = {}) {
     } catch {
     }
   }
+  if (res.status === 402) {
+    try {
+      const body = await res.clone().json();
+      if (body?.error === "insufficient_credits") {
+        for (const line of formatInsufficientCredits(body)) process.stderr.write(line + "\n");
+        structuredPrinted.add(res);
+      }
+    } catch {
+    }
+  }
+  if (res.status === 403) {
+    try {
+      const body = await res.clone().json();
+      if (body?.error === "email_verification_required") {
+        for (const line of formatVerificationRequired(body)) process.stderr.write(line + "\n");
+        structuredPrinted.add(res);
+      }
+    } catch {
+    }
+  }
+  if (res.status === 503) {
+    try {
+      const body = await res.clone().json();
+      if (body?.error === "generation_paused") {
+        process.stderr.write(
+          `${c.red("\u2717")} ${body.message ?? "Generation is temporarily paused platform-wide. Try again later."}
+`
+        );
+        structuredPrinted.add(res);
+      }
+    } catch {
+    }
+  }
   return res;
 }
 
@@ -1299,7 +1360,11 @@ async function pushSource(cwd, ctx, log) {
     }
     const commit = (await run("git", ["commit-tree", tree, "-m", "source"], { ...base, ...ident })).out.trim();
     await run("git", ["update-ref", "refs/heads/main", commit], base);
-    const push = await run("git", ["push", "-q", pushUrl, "+refs/heads/main:main"], base);
+    const push = await run(
+      "git",
+      ["-c", "http.postBuffer=536870912", "push", "-q", pushUrl, "+refs/heads/main:main"],
+      base
+    );
     if (push.code === 0) return true;
     if (!managed) {
       log.error(
@@ -1660,6 +1725,10 @@ async function runGenerate(kind, opts) {
       process.exitCode = 1;
       return;
     }
+    if (printedStructuredError(res)) {
+      process.exitCode = 1;
+      return;
+    }
     if (!res.ok) {
       log.error(`Generation request failed (HTTP ${res.status}).`);
       process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "0.30.0",
+  "version": "0.33.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-ai-model/SKILL.md

@@ -106,5 +106,14 @@ scene is a ghost: players and objects pass straight through it.
 ## Troubleshooting
 
 - **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
+- **"Out of credits" (`insufficient_credits`)** — the account has no credits left for
+  this model generation. Tell the user the facts the CLI printed: their balance, this
+  generation's cost, and when their credits refill. Then offer to continue the build
+  with a procedurally-coded placeholder (a simple Three.js primitive-based stand-in
+  mesh) and mark the spot with `// TODO(genex): regenerate when credits refill` so
+  the real asset is one command away later. Do not stop the session over this.
+- **"Email not verified" (`email_verification_required`)** — generation credits
+  unlock after the account's email is verified. Give the user the verify link the
+  CLI printed, wait for them to confirm, then re-run the command.
 - **The mesh looks low-detail / wrong** — make the prompt more specific
   (materials, style, parts) and regenerate; each run is a fresh asset.

package/templates/skills/genex-ai-sfx/SKILL.md

@@ -73,6 +73,15 @@ Reuse one loaded `buffer` across many plays; create a fresh `Audio`/`PositionalA
 ## Troubleshooting
 
 - **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
+- **"Out of credits" (`insufficient_credits`)** — the account has no credits left for
+  this sound generation. Tell the user the facts the CLI printed: their balance, this
+  generation's cost, and when their credits refill. Then offer to continue the build
+  with a procedurally-coded placeholder (a small WebAudio-synthesized stub sound)
+  and mark the spot with `// TODO(genex): regenerate when credits refill` so the
+  real asset is one command away later. Do not stop the session over this.
+- **"Email not verified" (`email_verification_required`)** — generation credits
+  unlock after the account's email is verified. Give the user the verify link the
+  CLI printed, wait for them to confirm, then re-run the command.
 - **No sound** — the `AudioContext` is suspended until a user gesture; trigger the
   first play from a click/keydown. Confirm the camera has an `AudioListener`.
 - **Too quiet/loud** — `sound.setVolume(0..1)`; for positional, tune

package/templates/skills/genex-ai-skybox/SKILL.md

@@ -77,6 +77,16 @@ scene.background = texture; // keep the raw texture for the visible sky
 ## Troubleshooting
 
 - **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
+- **"Out of credits" (`insufficient_credits`)** — the account has no credits left for
+  this skybox generation. Tell the user the facts the CLI printed: their balance, this
+  generation's cost, and when their credits refill. Then offer to continue the build
+  with a procedurally-coded placeholder (a gradient/procedural sky or a plain
+  `scene.background` color) and mark the spot with
+  `// TODO(genex): regenerate when credits refill` so the real asset is one command
+  away later. Do not stop the session over this.
+- **"Email not verified" (`email_verification_required`)** — generation credits
+  unlock after the account's email is verified. Give the user the verify link the
+  CLI printed, wait for them to confirm, then re-run the command.
 - **Sky looks too dark/bright** — adjust `renderer.toneMappingExposure`, or scale
   `scene.environment` influence via material `envMapIntensity`.
 - **Seam/pole artifacts** — that's inherent to equirect images; keep the camera

package/templates/skills/genex-ai-texture/SKILL.md

@@ -82,6 +82,16 @@ scene.add(ground);
 ## Troubleshooting
 
 - **"Not authorized"** — run `npx @genex-ai/cli-demo@latest init` first (it writes your `GENEX_TOKEN`).
+- **"Out of credits" (`insufficient_credits`)** — the account has no credits left for
+  this texture generation. Tell the user the facts the CLI printed: their balance,
+  this generation's cost, and when their credits refill. Then offer to continue the
+  build with a procedurally-coded placeholder (a procedural Three.js material in a
+  matching color) and mark the spot with
+  `// TODO(genex): regenerate when credits refill` so the real asset is one command
+  away later. Do not stop the session over this.
+- **"Email not verified" (`email_verification_required`)** — generation credits
+  unlock after the account's email is verified. Give the user the verify link the
+  CLI printed, wait for them to confirm, then re-run the command.
 - **Visible tiling seams** — use `--terrain` (tuned for seamless edges), lower the
   `repeat`, or blend two textures. Perfect seamlessness is a known v1 limitation.
 - **Colors look washed/dark** — ensure `map.colorSpace = THREE.SRGBColorSpace`.

package/templates/skills/genex-threejs-multiplayer/references/host-physics.md

@@ -34,24 +34,43 @@ body; when you don't you draw the smoothed stream and park the kinematic body on
 
 ```ts
 import RAPIER from "@dimforge/rapier3d-compat";
-// Proxy body: kinematic to start (owned by nobody, or by someone else).
-const body = physics.createBody({ type: "kinematicPosition", position: [x, y, z], ccd: true });
+const r2 = (n: number) => Math.round(n * 100) / 100;
+interface BallState { x: number; y: number; z: number; q?: number[]; vx?: number; vy?: number; vz?: number }
+
+// Proxy body: kinematic to start (owned by nobody, or by someone else). `excludeCharacterRay` keeps the
+// character's GROUND query from treating it as walkable, so players can't stand on / ride the ball (the
+// solver collision that drives claim-by-bump + the shove is unaffected).
+const body = physics.createBody({
+  type: "kinematicPosition", position: [x, y, z], ccd: true,
+  userData: { controller: { excludeCharacterRay: true } },
+});
 ballCollider(physics.world, body, RADIUS, { friction: 0.5, restitution: 0.35, density: 0.6 });
 let wasTouching = false, wasMine = false, claimCd = 0;
+const MAX_SPEED = 24;
+
+// The host seeds the canonical spawn ONCE so the object exists on `objects` for late joiners.
+function ensureInit() {
+  if (room.isHost && room.objects.get("ball") === undefined) {
+    room.objects.claim("ball");
+    room.objects.set("ball", { x, y, z, q: [0, 0, 0, 1], vx: 0, vy: 0, vz: 0 });
+  }
+}
 
 // Per-frame, BEFORE physics.step (so the kinematic proxy is in place for the character to hit it):
 function updateBall(dt: number) {
-  let v = room.objects.get("ball");
+  let v = room.objects.get<BallState>("ball");
   let mine = !!v?.isMine;
 
-  // Rising-EDGE claim: sustained contact yields NO new rising edge, so ONE owner holds it
-  // (no per-frame ownership ping-pong). A short cooldown throttles a steal-war.
-  const touching = onFoot && feet.distanceTo(ballMesh.position) < RADIUS + REACH;
+  // Rising-EDGE claim: sustained contact yields NO new rising edge, so ONE owner holds it (no per-frame
+  // ownership ping-pong). A short cooldown throttles a steal-war. Use HORIZONTAL distance — the feet sit
+  // at ground level while the ball centre is at y≈RADIUS, so a 3D distance would eat into your reach.
+  const dx = ballMesh.position.x - feet.x, dz = ballMesh.position.z - feet.z;
+  const touching = onFoot && Math.hypot(dx, dz) < RADIUS + REACH;
   if (claimCd > 0) claimCd -= dt;
   if (touching && !wasTouching && !mine && claimCd <= 0) {
     room.objects.claim("ball");            // optimistic: isMine flips true locally THIS frame
     claimCd = 0.25;
-    v = room.objects.get("ball"); mine = !!v?.isMine;
+    v = room.objects.get<BallState>("ball"); mine = !!v?.isMine;
   }
   wasTouching = touching;
 
@@ -67,22 +86,37 @@ function updateBall(dt: number) {
   wasMine = mine;
 
   if (mine) {
+    // Cap the owned body's speed: CCD stops single-step tunnelling, the cap stops runaway speed
+    // (a hard shove into a wall) from flinging the ball across the map.
+    const lv = body.linvel(), sp = Math.hypot(lv.x, lv.y, lv.z);
+    if (sp > MAX_SPEED) { const k = MAX_SPEED / sp; body.setLinvel({ x: lv.x * k, y: lv.y * k, z: lv.z * k }, true); }
     ballMesh.position.copy(body.translation());          // draw the dynamic body I simulate
     ballMesh.quaternion.copy(body.rotation());
   } else if (v?.state) {
     ballMesh.position.set(v.state.x, v.state.y, v.state.z); // draw the smoothed stream
     body.setNextKinematicTranslation(ballMesh.position);    // keep the proxy on it → I can bump → claim
+    if (Array.isArray(v.state.q)) {
+      // Rotate the collider too, or a tumbled cube collides as an axis-aligned box and pops on claim.
+      ballMesh.quaternion.set(v.state.q[0], v.state.q[1], v.state.q[2], v.state.q[3]);
+      body.setNextKinematicRotation({ x: v.state.q[0], y: v.state.q[1], z: v.state.q[2], w: v.state.q[3] });
+    }
   }
 }
 
-// Owner-gated publish on your fixed tick (30Hz for a fast ball) — moved-only + a ~2Hz keepalive.
-// Publish VELOCITY too, so the next owner seeds from it and the handoff doesn't stall.
-if (room.objects.get("ball")?.isMine) {
+// Owner-gated publish on your fixed tick (30Hz for a fast ball). Publish MOVED-ONLY + a ~2Hz keepalive —
+// NEVER every tick (a resting owned object republished each tick is the #1 budget-blower; it matters the
+// moment you own more than one prop). Include VELOCITY so the next owner seeds from it without stalling.
+let lastSent = "", lastAt = 0;
+function publishBall() {
+  if (!room.objects.get<BallState>("ball")?.isMine) return;
   const t = body.translation(), q = body.rotation(), lv = body.linvel();
-  room.objects.set("ball", { x: r2(t.x), y: r2(t.y), z: r2(t.z),
-    q: [r2(q.x), r2(q.y), r2(q.z), r2(q.w)], vx: r2(lv.x), vy: r2(lv.y), vz: r2(lv.z) });
+  const net = { x: r2(t.x), y: r2(t.y), z: r2(t.z),
+    q: [r2(q.x), r2(q.y), r2(q.z), r2(q.w)], vx: r2(lv.x), vy: r2(lv.y), vz: r2(lv.z) };
+  const json = JSON.stringify(net), nowMs = Date.now();
+  if (json === lastSent && nowMs - lastAt < 500) return;   // unchanged + within keepalive window → skip
+  lastSent = json; lastAt = nowMs;
+  room.objects.set("ball", net);
 }
-const r2 = (v: number) => Math.round(v * 100) / 100;
 ```
 
 Rules that make it correct:
@@ -101,6 +135,14 @@ Rules that make it correct:
   budget spreads across players instead of funnelling every object through one host's send budget. This
   is why Tier 1 scales to many pushable objects where a host-authoritative fleet (Tier 2) would blow one
   client's rate cap.
+- **Publish moved-only + a low-rate keepalive**, never every tick — a resting owned object republished at
+  full rate is the classic budget-blower, and it bites the moment one player owns several props.
+- **Exclude the proxy from the character's ground query** (`userData.controller.excludeCharacterRay`), or
+  players stand on the ball/cube and it squirts out from under them the instant they claim it.
+- **Rotate the follower, not just its position** (`setNextKinematicRotation`) — a cube another player
+  tumbled otherwise collides as an axis-aligned box (wrong contact) and pops to identity on claim.
+- **Cap the owned body's speed** — CCD stops single-step tunnelling; the cap stops runaway speed (a hard
+  shove into a wall) from flinging the object across the map.
 - **Do NOT `registerBody(proxy, mesh)`** — drive the mesh yourself (from the body when you own it, from
   the stream when you don't). Registering it fights the SDK's smoothing on the stream half.
 

package/templates/skills/genex-updates/SKILL.md

@@ -9,13 +9,15 @@ Genex ships improvements continuously. The `genex` CLI tells you when something
 is stale; you (the agent) apply the update at the right moment and tell the
 user what happened. The user never manages versions themselves.
 
-## The three signals in `genex` output
+## The signals in `genex` output
 
 | Line | Meaning | What you do |
 | -- | -- | -- |
 | `🔄 Genex skills updated to X.Y.Z` | Skills were auto-refreshed to match the installed CLI. | Nothing — informational. Skills stay in sync on their own. |
 | `⬆ Genex <package> X.Y.Z available (installed A.B.C) — run: <command>` | A newer npm package exists. | Run the printed command at a **safe moment** (below), then tell the user. |
 | `✗ … below the minimum supported version … Update now — run: <command>` | The API refuses this CLI version (HTTP 426, `cli_update_required`). | Run the printed command **now**, then re-run the refused genex command. |
+| `✗ Out of credits — … costs N credits; your balance is M.` | The account can't cover this generation (HTTP 402, `insufficient_credits`). | Relay the printed facts (balance, cost, refill date, link) to the user; offer a procedural placeholder so the build continues — see the generation skill's Troubleshooting. |
+| `✗ Email not verified — …` | Generation credits are locked until the email is verified (HTTP 403, `email_verification_required`). | Give the user the printed verify link, wait for them to confirm, then re-run the command. |
 
 ## Safe moments — when to apply a nudge