@genex-ai/cli-demo 1.36.7-dev.908 → 1.36.8-dev.910

package/README.md

@@ -12,6 +12,7 @@ genex list                 # list your games — slug, status, page link (find t
 genex preview              # build + push to the hosted draft URL (unlisted)
 genex publish              # build + push, then list the game in the gallery
 genex cover [file]         # show the game's cover, or make one real frame (PNG/JPEG/WebP) the cover
+genex cover --clip <file> --commit <sha>  # make a recording of real play (MP4/WebM) the cover clip
 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 sfx "<prompt>"       # generate a sound fx  → prints an asset URL

package/dist/index.js

@@ -6344,7 +6344,9 @@ async function fetchOwnerProject(apiUrl, token, slug) {
     return {
       status: project.status ?? "draft",
       coverUrl: project.thumbnailUrl ?? null,
-      coverSource: "coverSource" in project ? project.coverSource ?? null : void 0
+      coverSource: "coverSource" in project ? project.coverSource ?? null : void 0,
+      clipUrl: project.coverClipUrl ?? null,
+      clipSource: project.coverClipSource ?? null
     };
   } catch {
     return null;
@@ -6525,6 +6527,134 @@ async function uploadCover(args) {
   const view = { coverUrl: body?.coverUrl ?? null, coverSource: body?.coverSource ?? null };
   return body?.applied === false ? { kind: "outranked", ...view } : { kind: "applied", ...view };
 }
+var CLIP_MAX_BYTES = 8 * 1024 * 1024;
+var BUILD_COMMIT = /^[0-9a-f]{7,40}$/;
+function sniffClip(bytes) {
+  if (bytes.byteLength < 16) return null;
+  const b = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (b.toString("ascii", 4, 8) === "ftyp") return "video/mp4";
+  if (b.readUInt32BE(0) === 440786851) return "video/webm";
+  return null;
+}
+function normaliseBuildCommit(commit) {
+  const sha = commit?.trim().toLowerCase() ?? "";
+  return BUILD_COMMIT.test(sha) ? sha : null;
+}
+var CLIP_CLOSED = "nothing was uploaded";
+function clipRefusal(res, error, what) {
+  const status2 = res.status;
+  const wait = waitWords(res.headers.get("Retry-After"));
+  if (status2 === 401) return "Genex refused this machine's sign-in \u2014 run `npx genex auth`, then try again.";
+  if (error === "cover_clip_off") return `Cover clips are switched off on this Genex stand \u2014 ${CLIP_CLOSED}.`;
+  if (error === "cover_clip_lane_closed") return `This Genex stand doesn't take cover clips from the CLI yet \u2014 ${CLIP_CLOSED}.`;
+  if (status2 === 403) return "Only the game's owner can set its cover clip, and this machine is signed in as someone else.";
+  if (status2 === 404) return "Genex doesn't know this game under this account \u2014 check `.genex/project.json` (or `npx genex link <slug>`).";
+  if (error === "cover_clip_not_a_game") return "This project is an asset page, not a game \u2014 it takes no cover clip.";
+  if (error === "cover_clip_taken_down") return "This game was taken down \u2014 it takes no cover clip.";
+  if (error === "cover_clip_stale_build") {
+    return "That --commit is not a build this game ships \u2014 record the build on its preview (draft) or live (published) channel and pass that build's commit.";
+  }
+  if (status2 === 413) return `That recording is too big for a cover clip (at most ${CLIP_MAX_BYTES / 1024 / 1024} MB).`;
+  if (error === "cover_clip_rate_limited") {
+    return `Too many cover clip uploads on this account for now (rate limited) \u2014 Genex takes the next one ${wait}.`;
+  }
+  if (error === "cover_clip_capacity") return "Today's cover clips are used up (daily cap) \u2014 Genex takes the next one after midnight UTC.";
+  if (error === "cover_clip_busy") return `Genex is busy encoding another clip for this game \u2014 try again ${wait}.`;
+  if (error === "cover_clip_upload_failed") return "Genex couldn't read the uploaded clip yet \u2014 try again.";
+  if (error === "cover_clip_unavailable" || error === "cover_clip_encode_failed") {
+    return "Genex's clip encoder is unavailable right now \u2014 try again in a few minutes.";
+  }
+  return `Couldn't ${what} (HTTP ${status2}) \u2014 try again.`;
+}
+async function uploadClip(args) {
+  const { apiUrl, token, projectId, bytes, label } = args;
+  const buildCommit = normaliseBuildCommit(args.buildCommit);
+  if (!buildCommit) return { kind: "invalid", message: `--commit must be the build's git sha (7 to 40 hex characters).` };
+  const type = sniffClip(bytes);
+  if (!type) return { kind: "invalid", message: `${label} is not an MP4 or WebM video.` };
+  if (bytes.byteLength > CLIP_MAX_BYTES) {
+    return { kind: "invalid", message: `${label} is ${mb(bytes.byteLength)}; a cover clip recording can be at most ${CLIP_MAX_BYTES / 1024 / 1024} MB.` };
+  }
+  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
+  const base = `${apiUrl}/api/projects/${encodeURIComponent(projectId)}/cover/clip`;
+  const errorOf = async (res) => await res.json().catch(() => null);
+  let minted;
+  try {
+    minted = await apiFetch(`${base}/upload-url`, { method: "POST", headers, body: JSON.stringify({ bytes: bytes.byteLength, contentType: type }) });
+  } catch {
+    return { kind: "failed", message: "Couldn't reach Genex to upload the cover clip." };
+  }
+  if (printedStructuredError(minted)) return { kind: "failed", message: null };
+  if (!minted.ok) return { kind: "failed", message: clipRefusal(minted, (await errorOf(minted))?.error, "start the cover clip upload") };
+  const grant = await minted.json().catch(() => null);
+  if (!grant?.uploadUrl || !grant.key) {
+    return { kind: "failed", message: "Genex answered the cover clip upload unexpectedly \u2014 nothing was uploaded." };
+  }
+  let put;
+  try {
+    put = await fetch(grant.uploadUrl, {
+      method: "PUT",
+      // Both are part of what the URL was signed for; send them back unchanged.
+      headers: { "Content-Type": type, "Content-Length": String(bytes.byteLength) },
+      body: new Uint8Array(bytes)
+    });
+  } catch {
+    return { kind: "failed", message: "The cover clip upload didn't reach storage (network error) \u2014 try again." };
+  }
+  if (!put.ok) return { kind: "failed", message: `The cover clip upload failed (HTTP ${put.status}) \u2014 try again.` };
+  let done;
+  try {
+    done = await apiFetch(`${base}/commit`, { method: "POST", headers, body: JSON.stringify({ key: grant.key, buildCommit }) });
+  } catch {
+    return { kind: "failed", message: "Couldn't reach Genex to finish the cover clip upload." };
+  }
+  if (printedStructuredError(done)) return { kind: "failed", message: null };
+  const body = await done.json().catch(() => null);
+  if (done.status === 422 && body?.error === "cover_clip_rejected") {
+    return { kind: "rejected", reason: body.reason ?? "rejected", stats: body.stats ?? null };
+  }
+  if (!done.ok) return { kind: "failed", message: clipRefusal(done, body?.error, "set the cover clip") };
+  const view = { clipUrl: body?.clipUrl ?? null, clipSource: body?.clipSource ?? null };
+  return body?.applied === false ? { kind: "outranked", ...view } : { kind: "applied", ...view };
+}
+var CLIP_SOURCE_LABEL = {
+  owner: "recorded by the owner",
+  agent: "sent from the build (genex cover --clip)",
+  owner_play: "recorded while the owner played"
+};
+function describeClipSource(source) {
+  if (source === null) return "none";
+  return CLIP_SOURCE_LABEL[source] ?? source;
+}
+var CLIP_REJECTION = {
+  too_dark: "is too dark to read as the game on a card",
+  flat: "is almost one flat colour \u2014 a loading screen or a fade reads as nothing",
+  static: "barely moves \u2014 a frozen or paused screen is not a clip",
+  flashing: "flashes too fast to show anyone (a strobe can hurt whoever watches it)",
+  too_short: "is too short (record 5\u20136 s)",
+  too_long: "is too long (at most 12 s)"
+};
+function reportClipOutcome(log, outcome2, opts) {
+  switch (outcome2.kind) {
+    case "applied":
+      log.success(`Cover clip set \u2014 ${opts.label} is this game's cover clip now.`);
+      if (outcome2.clipUrl) log.dim(`  ${outcome2.clipUrl}`);
+      return;
+    case "outranked":
+      log.info("Cover clip unchanged \u2014 the owner chose this game's clip themselves (or removed it), and that choice stands. Nothing to retry.");
+      return;
+    case "rejected":
+      log.error(`Cover clip not used \u2014 ${opts.label} ${CLIP_REJECTION[outcome2.reason] ?? `was refused (${outcome2.reason})`}.`);
+      log.dim("  Record 5\u20136 s of real, moving, lit gameplay and run this again \u2014 never change the game for a clip.");
+      return;
+    case "invalid":
+      log.error(`Cover clip not used \u2014 ${outcome2.message}`);
+      return;
+    case "failed":
+      if (outcome2.message) log.error(outcome2.message);
+      return;
+  }
+}
 var pct = (n) => `${Math.round(n * 100)}%`;
 function reportCoverOutcome(log, outcome2, opts) {
   const fail5 = (m) => opts.asError ? log.error(m) : log.warn(m);
@@ -8824,6 +8954,11 @@ async function runCover(opts) {
   const apiUrl = getApiUrl(opts.apiUrl ?? meta.apiUrl);
   const token = await readUserToken(opts.envPath, apiUrl);
   if (!token) return fail2("Not signed in. Run `genex auth` first.", opts, log);
+  const clip = opts.clipPath?.trim();
+  if (clip || opts.commit !== void 0) {
+    await sendClip(apiUrl, token, meta.id, clip, opts, log);
+    return;
+  }
   const file = opts.imagePath?.trim();
   if (!file) {
     await showCover(apiUrl, token, meta.slug, opts, log);
@@ -8860,8 +8995,36 @@ async function rememberNomination(bytes, file, outcome2) {
   const stale = await fs24.readFile(scratch).catch(() => null);
   if (stale) await rememberCoverUpload(stale, scratch, outcome2);
 }
+async function sendClip(apiUrl, token, projectId, clip, opts, log) {
+  const file = clip ?? "";
+  const invalid = (message) => finishClip({ kind: "invalid", message }, file, opts, log);
+  if (!clip) return invalid("--commit goes with --clip <file>: pass the recording to send.");
+  if (opts.imagePath?.trim()) return invalid("Pass either an image (the cover) or --clip <file> (the cover clip), not both.");
+  if (!opts.commit?.trim()) return invalid("--clip needs --commit <sha>: the git commit of the build the recording shows.");
+  let bytes;
+  try {
+    const stat = await fs24.stat(clip);
+    if (!stat.isFile()) throw new Error("not a file");
+    if (stat.size > CLIP_MAX_BYTES) {
+      return invalid(`${clip} is ${(stat.size / 1024 / 1024).toFixed(1)} MB; a cover clip recording can be at most ${CLIP_MAX_BYTES / 1024 / 1024} MB.`);
+    }
+    bytes = await fs24.readFile(clip);
+  } catch {
+    return invalid(`Can't read ${clip} \u2014 pass the path of an MP4 or WebM recording.`);
+  }
+  log.step(`Uploading ${path24.basename(clip)} as the cover clip\u2026`);
+  const outcome2 = await uploadClip({ apiUrl, token, projectId, bytes, label: clip, buildCommit: opts.commit });
+  finishClip(outcome2, clip, opts, log);
+}
+function finishClip(outcome2, file, opts, log) {
+  if (opts.json) process.stdout.write(`${JSON.stringify({ file: file || null, ...outcome2 })}
+`);
+  else reportClipOutcome(log, outcome2, { label: file });
+  if (outcome2.kind !== "applied" && outcome2.kind !== "outranked") process.exitCode = 1;
+}
 function fail2(message, opts, log) {
-  if (opts.json) process.stdout.write(`${JSON.stringify({ file: opts.imagePath?.trim() || null, kind: "failed", message })}
+  const file = opts.clipPath?.trim() || opts.imagePath?.trim() || null;
+  if (opts.json) process.stdout.write(`${JSON.stringify({ file, kind: "failed", message })}
 `);
   else log.error(message);
   process.exitCode = 1;
@@ -8884,7 +9047,8 @@ async function showCover(apiUrl, token, slug, opts, log) {
   const view = await fetchOwnerProject(apiUrl, token, slug);
   if (!view) return fail2("Couldn't read this game from Genex \u2014 check the sign-in (`genex doctor`) and try again.", opts, log);
   if (opts.json) {
-    process.stdout.write(`${JSON.stringify({ coverUrl: view.coverUrl, coverSource: view.coverSource ?? null })}
+    const clip = { clipUrl: view.clipUrl, clipSource: view.clipSource };
+    process.stdout.write(`${JSON.stringify({ coverUrl: view.coverUrl, coverSource: view.coverSource ?? null, ...clip })}
 `);
     return;
   }
@@ -8894,6 +9058,10 @@ async function showCover(apiUrl, token, slug, opts, log) {
     log.plain(`  cover:  ${c.cyan(view.coverUrl)}`);
     log.plain(`  source: ${describeCoverSource(view.coverSource)}`);
   }
+  if (view.clipUrl) {
+    log.plain(`  clip:   ${c.cyan(view.clipUrl)}`);
+    log.plain(`  source: ${describeClipSource(view.clipSource)}`);
+  }
   if (!view.coverUrl || coverIsStandIn(view.coverSource)) {
     log.plain("");
     log.dim(`  A cover is ${WHAT_A_COVER_IS}.`);
@@ -27463,6 +27631,9 @@ ${c.bold("Usage")}
                                      on the dashboard is never replaced from here.
                                      'genex preview' also uploads a new
                                      .genex/scratch/cover.png by itself.
+  genex cover --clip <file> --commit <sha>
+                                     Make a 5-6 s recording of real play (MP4/WebM,
+                                     \u22648 MB) of build <sha> the game's cover clip.
   genex make-remixable [options]     Make THIS game remixable by everyone \u2014 migrates a
                                      private source onto a public managed genex repo.
   genex domain <sub> [host]          Play this game on a domain you own:
@@ -27784,7 +27955,10 @@ ${c.bold("Options for `list`")}
 
 ${c.bold("Options for `cover`")}
   <file>               The image to make the cover (positional). Omit it to see
-                       the current cover and where it came from.
+                       the current cover and clip, and where they came from.
+  --clip <file>        A recording of real play (MP4 or WebM, \u22648 MB) to make the
+                       cover clip instead; the server keeps 5 s of it.
+  --commit <sha>       With --clip: the build the recording shows (7-40 hex).
   --json               One machine-readable result object.
   --api-url <url>      Override the API base URL.
   --env <path>         Token env file (default: ~/.genex/env).
@@ -27854,6 +28028,7 @@ ${c.bold("Examples")}
   genex publish --categories games,vfx
   genex cover
   genex cover .genex/scratch/cover.png
+  genex cover --clip .genex/scratch/clip.mp4 --commit 3f9c2ab
   genex make-remixable
   genex domain add play.mygame.com
   genex domain list
@@ -28402,7 +28577,10 @@ function parseArgs(argv) {
     "--tri-band",
     "--holder",
     "--summary",
-    "--tags"
+    "--tags",
+    // `genex cover --clip <file> --commit <sha>`: the clip and the build it shows.
+    "--clip",
+    "--commit"
   ]);
   let i = 0;
   while (i < argv.length) {
@@ -29087,6 +29265,12 @@ function applyValueFlag(options, flag, value) {
     case "--src":
       options.src = value;
       break;
+    case "--clip":
+      options.clipPath = value;
+      break;
+    case "--commit":
+      options.commit = value;
+      break;
   }
 }
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.36.7-dev.908",
+  "version": "1.36.8-dev.910",
   "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-cover/SKILL.md

@@ -351,6 +351,9 @@ must not be there.
    `npx genex cover .genex/scratch/cover.png` sends it now: exit 0 for set or
    outranked, 1 otherwise; `--json` prints one object whose `kind` is
    `applied`, `outranked`, `rejected`, `invalid` or `failed`.
+   A cover clip (5–6 s of real play, MP4 or WebM, at most 8 MB) goes up with
+   `npx genex cover --clip <file> --commit <sha of the build it shows>`, with
+   the same exit codes and kinds; the owner's own clip always outranks it.
 4. **No browser that can capture the game?** Do not set one up just for this;
    tell the owner they can set a cover on the game's page.