npm - @genex-ai/cli-demo - Versions diffs - 0.7.0 → 0.10.0 - Mend

@genex-ai/cli-demo 0.7.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/dist/index.js CHANGED Viewed

@@ -2,11 +2,11 @@
 // src/index.ts
 import { readFileSync } from "fs";
-import path10 from "path";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // src/commands/init.ts
-import path6 from "path";
+import path7 from "path";
 // src/config.ts
 import fs from "fs";
@@ -125,7 +125,7 @@ import http from "http";
 import crypto from "crypto";
 import readline from "readline";
 import { spawn } from "child_process";
-import { URL } from "url";
+import { URL as URL2 } from "url";
 var SUCCESS_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>Genex</title>
 <style>body{font-family:system-ui,sans-serif;background:#0b0b0f;color:#eaeaea;display:grid;place-items:center;height:100vh;margin:0}
 .card{text-align:center;padding:2rem 3rem;border:1px solid #26262e;border-radius:14px;background:#13131a}
@@ -216,7 +216,7 @@ async function authorize(authBaseUrl, options) {
   });
 }
 function buildAuthUrl(authBaseUrl, redirectUri, state) {
-  const url = new URL(`${authBaseUrl}/cli/auth`);
+  const url = new URL2(`${authBaseUrl}/cli/auth`);
   url.searchParams.set("redirect_uri", redirectUri);
   url.searchParams.set("state", state);
   return url.toString();
@@ -225,7 +225,7 @@ async function handleCallback(req, res, expectedState, log) {
   res.setHeader("Access-Control-Allow-Origin", "*");
   res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
   res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-  const reqUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+  const reqUrl = new URL2(req.url ?? "/", "http://127.0.0.1");
   if (req.method === "OPTIONS") {
     res.writeHead(204);
     res.end();
@@ -438,7 +438,10 @@ async function createDraftProject(opts) {
       apiUrl,
       colyseusUrl,
       playUrl: project.playUrl ?? void 0,
-      status: "draft"
+      status: "draft",
+      // Derived client-side from the auth/web origin the CLI just authorized
+      // against (respects --auth-url overrides) — no API contract change.
+      dashboardOrigins: [new URL(dashboardUrl).origin]
     };
   }
   log.warn("Couldn't create a project with a unique name. Try `--name <unique>`.");
@@ -639,6 +642,70 @@ async function writeProject(meta, cwd = process.cwd()) {
   return { path: file };
 }
+// src/lib/game-config.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+var DEFAULT_DASHBOARD_ORIGIN = new URL(DEFAULT_AUTH_URL).origin;
+function renderGenexConfig() {
+  return `// src/genex.config.ts \u2014 written by \`genex init\`. DO NOT hardcode URLs here.
+//
+// Values come from Vite env:
+//   .env                    -> VITE_GENEX_SLUG (this game's identity; committed)
+//   .env.development.local  -> local-stack URL overrides (dev mode ONLY \u2014 a
+//                              production build always uses the defaults below;
+//                              gitignored via *.local, never committed)
+export const GENEX = {
+  slug: import.meta.env.VITE_GENEX_SLUG as string,
+  apiUrl: (import.meta.env.VITE_GENEX_API_URL as string | undefined) ?? "${DEFAULT_API_URL}",
+  colyseusUrl: (import.meta.env.VITE_GENEX_COLYSEUS_URL as string | undefined) ?? "${DEFAULT_COLYSEUS_URL}",
+  dashboardOrigins: ((import.meta.env.VITE_GENEX_DASHBOARD_ORIGINS as string | undefined) ?? "${DEFAULT_DASHBOARD_ORIGIN}").split(","),
+} as const;
+`;
+}
+function renderSlugEnv(slug) {
+  return `# Genex game identity \u2014 committed; environment-independent.
+VITE_GENEX_SLUG=${slug}
+`;
+}
+function renderDevOverrides(meta) {
+  const dashboardOrigins = meta.dashboardOrigins?.join(",") ?? DEFAULT_DASHBOARD_ORIGIN;
+  const overrides = [];
+  if (meta.apiUrl !== DEFAULT_API_URL) overrides.push(`VITE_GENEX_API_URL=${meta.apiUrl}`);
+  if (meta.colyseusUrl !== DEFAULT_COLYSEUS_URL) {
+    overrides.push(`VITE_GENEX_COLYSEUS_URL=${meta.colyseusUrl}`);
+  }
+  if (dashboardOrigins !== DEFAULT_DASHBOARD_ORIGIN) {
+    overrides.push(`VITE_GENEX_DASHBOARD_ORIGINS=${dashboardOrigins}`);
+  }
+  if (overrides.length === 0) return null;
+  return `# Local-stack overrides \u2014 DEV MODE ONLY (vite build ignores this file).
+# Written by \`genex init\` because it ran against a non-default stack.
+${overrides.join("\n")}
+`;
+}
+async function writeIfAbsent(file, content, log) {
+  try {
+    await fs6.writeFile(file, content, { flag: "wx" });
+    log.dim(`  wrote ${c.cyan(file)}`);
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      log.dim(`  kept existing ${c.cyan(file)}`);
+      return false;
+    }
+    throw err;
+  }
+}
+async function writeGameConfigFiles(meta, log, cwd = process.cwd()) {
+  await fs6.mkdir(path6.join(cwd, "src"), { recursive: true });
+  await writeIfAbsent(path6.join(cwd, "src", "genex.config.ts"), renderGenexConfig(), log);
+  await writeIfAbsent(path6.join(cwd, ".env"), renderSlugEnv(meta.slug), log);
+  const overrides = renderDevOverrides(meta);
+  if (overrides) {
+    await writeIfAbsent(path6.join(cwd, ".env.development.local"), overrides, log);
+  }
+}
 // src/utils/logger.ts
 function createLogger(opts = {}) {
   const out = (s) => {
@@ -671,8 +738,8 @@ async function runInit(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const src = t.full ? templatesDir : path6.join(templatesDir, "skills");
-    const dest = t.full ? t.baseDir : path6.join(t.baseDir, "skills");
+    const src = t.full ? templatesDir : path7.join(templatesDir, "skills");
+    const dest = t.full ? t.baseDir : path7.join(t.baseDir, "skills");
     const { copied, updated } = await copyTemplates(src, dest, { force: opts.force });
     const added = copied.length - updated.length;
     totalNew += added;
@@ -716,7 +783,7 @@ async function runInit(opts) {
   }
   const apiUrl = getApiUrl(opts.apiUrl);
   const colyseusUrl = getColyseusUrl(opts.colyseusUrl);
-  const projectName = opts.name?.trim() || path6.basename(process.cwd());
+  const projectName = opts.name?.trim() || path7.basename(process.cwd());
   const meta = await createDraftProject({
     apiUrl,
     token,
@@ -729,16 +796,22 @@ async function runInit(opts) {
   if (meta) {
     const { path: metaPath } = await writeProject(meta);
     log.dim(`  saved ${c.cyan(metaPath)}`);
+    await writeGameConfigFiles(meta, log);
   }
   log.plain("");
   log.success("All set. \u{1F680}");
 }
+// src/commands/publish.ts
+import fs8 from "fs/promises";
+import path9 from "path";
 // src/lib/deploy.ts
 import { spawn as spawn4 } from "child_process";
-import fs6 from "fs/promises";
+import crypto3 from "crypto";
+import fs7 from "fs/promises";
 import os2 from "os";
-import path7 from "path";
+import path8 from "path";
 function run(cmd, args, env) {
   return new Promise((resolve) => {
     let child;
@@ -756,7 +829,8 @@ function run(cmd, args, env) {
     child.on("close", (code2) => resolve({ code: code2 ?? -1, out, err }));
   });
 }
-async function deployGame(sshUrl, opts, log) {
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".genex", "dist"]);
+async function deployGame(ctx, opts, log) {
   const cwd = process.cwd();
   if (!opts.noBuild && await hasBuildScript(cwd)) {
     log.step("Building the production bundle\u2026");
@@ -769,25 +843,164 @@ async function deployGame(sshUrl, opts, log) {
     }
     log.success("Built.");
   }
-  const distDir = path7.join(cwd, "dist");
+  const distDir = path8.join(cwd, "dist");
   const siteDir = await isDir2(distDir) ? distDir : cwd;
-  if (siteDir === cwd) {
-    await writeGitignore(cwd, log);
+  const rel = path8.relative(cwd, siteDir) || ".";
+  if (siteDir === cwd) await writeGitignore(cwd, log);
+  const files = await collectFiles(siteDir);
+  if (files.some((f) => /(^|\/)genex_key(\.pub)?$/.test(f.relPath))) {
+    log.error(`Refusing to deploy: ${KEY_NAME} is in ${rel}. Add it to .gitignore and retry.`);
+    return false;
+  }
+  if (files.length === 0) {
+    log.warn("Nothing to deploy \u2014 the build produced no files.");
+    return false;
+  }
+  if (!files.some((f) => f.relPath === "index.html")) {
+    log.error(`No index.html in ${rel} \u2014 a game needs one to serve. Nothing deployed.`);
+    return false;
+  }
+  const commit = contentCommit(files);
+  log.step("Requesting an upload token\u2026");
+  const grant = await getUploadToken(ctx, commit, log);
+  if (!grant) return false;
+  const totalBytes = files.reduce((n, f) => n + f.bytes.length, 0);
+  const mb = (n) => (n / 1048576).toFixed(n < 1048576 ? 2 : 1);
+  if (files.length > grant.limits.maxFiles) {
+    log.error(`Too many files (${files.length} > ${grant.limits.maxFiles}). Trim the build and retry.`);
+    return false;
+  }
+  const oversized = files.find((f) => f.bytes.length > grant.limits.maxFileBytes);
+  if (oversized) {
+    log.error(`${oversized.relPath} is ${mb(oversized.bytes.length)} MB \u2014 over the ${mb(grant.limits.maxFileBytes)} MB per-file limit.`);
+    return false;
+  }
+  if (totalBytes > grant.limits.maxTotalBytes) {
+    log.error(`Build is ${mb(totalBytes)} MB \u2014 over the ${mb(grant.limits.maxTotalBytes)} MB limit.`);
+    return false;
+  }
+  log.step(`Uploading ${files.length} files\u2026`);
+  if (!await uploadAll(grant.uploadUrl, grant.token, files, log)) {
+    log.error("Couldn't upload your game \u2014 please try again.");
+    return false;
+  }
+  const keyPath = path8.resolve(cwd, KEY_NAME);
+  if (!await fileExists(keyPath)) {
+    log.error(`No deploy key (${KEY_NAME}) here \u2014 run \`genex init\` in this folder first.`);
+    return false;
   }
-  const rel = path7.relative(cwd, siteDir) || ".";
+  if (!await pushSource(cwd, ctx.sshUrl, keyPath, log)) return false;
+  log.step("Publishing\u2026");
+  if (!await callPublish(ctx, commit, log)) return false;
+  const index = files.find((f) => f.relPath === "index.html");
+  await waitUntilLive(grant.playUrl, fingerprintOf(index.bytes.toString("utf8")), opts.liveTimeoutMs ?? 2e4, log);
+  return true;
+}
+async function hasBuildScript(cwd) {
   try {
-    await fs6.access(path7.join(siteDir, "index.html"));
+    const pkg = JSON.parse(await fs7.readFile(path8.join(cwd, "package.json"), "utf8"));
+    return Boolean(pkg.scripts?.build);
   } catch {
-    log.warn(`No index.html in ${rel} \u2014 GitHub Pages needs one to serve the game.`);
+    return false;
   }
-  await warnIfAbsolutePaths(siteDir, log);
-  await fs6.writeFile(path7.join(siteDir, ".nojekyll"), "");
-  const keyPath = path7.resolve(cwd, KEY_NAME);
-  if (!await fileExists(keyPath)) {
-    log.warn(`No deploy key (${KEY_NAME}) here \u2014 run \`genex init\` in this folder first.`);
+}
+async function collectFiles(root) {
+  const out = [];
+  const walk2 = async (dir, prefix) => {
+    for (const e of await fs7.readdir(dir, { withFileTypes: true })) {
+      const relPath = prefix ? `${prefix}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path8.join(dir, e.name), relPath);
+      } else if (e.isFile() && e.name !== KEY_NAME && e.name !== `${KEY_NAME}.pub`) {
+        out.push({ relPath, bytes: await fs7.readFile(path8.join(dir, e.name)) });
+      }
+    }
+  };
+  await walk2(root, "");
+  return out;
+}
+function contentCommit(files) {
+  const h = crypto3.createHash("sha1");
+  for (const f of [...files].sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0)) {
+    h.update(f.relPath, "utf8");
+    h.update("\0");
+    h.update(f.bytes);
+  }
+  return h.digest("hex");
+}
+async function getUploadToken(ctx, commit, log) {
+  let res;
+  try {
+    res = await fetch(`${ctx.apiUrl}/api/games/${ctx.projectId}/upload-token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${ctx.token}` },
+      body: JSON.stringify({ commit })
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${ctx.apiUrl}: ${String(err)}`);
+    return null;
+  }
+  if (!res.ok) {
+    log.error(`Couldn't get an upload token (HTTP ${res.status}).`);
+    return null;
+  }
+  return await res.json();
+}
+async function uploadAll(uploadUrl, uploadToken, files, log) {
+  const base = uploadUrl.replace(/\/+$/, "");
+  let failed = false;
+  let next = 0;
+  const worker = async () => {
+    while (!failed) {
+      const i = next++;
+      if (i >= files.length) return;
+      const f = files[i];
+      const encoded = f.relPath.split("/").map(encodeURIComponent).join("/");
+      let res = null;
+      try {
+        res = await fetch(`${base}/${encoded}`, {
+          method: "PUT",
+          headers: { Authorization: `Bearer ${uploadToken}` },
+          body: f.bytes
+        });
+      } catch {
+        res = null;
+      }
+      if (!res || !res.ok) {
+        failed = true;
+        log.warn(`Upload failed for ${f.relPath}${res ? ` (HTTP ${res.status})` : " (network error)"}.`);
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(8, files.length) }, () => worker()));
+  return !failed;
+}
+async function callPublish(ctx, commit, log) {
+  let res;
+  try {
+    res = await fetch(`${ctx.apiUrl}/api/games/${ctx.projectId}/publish`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${ctx.token}` },
+      body: JSON.stringify({ commit })
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${ctx.apiUrl}: ${String(err)}`);
+    return false;
+  }
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    log.error(`Publish failed (HTTP ${res.status})${detail ? `: ${detail}` : ""}.`);
     return false;
   }
-  const gitDir = await fs6.mkdtemp(path7.join(os2.tmpdir(), "genex-deploy-"));
+  return true;
+}
+async function pushSource(cwd, sshUrl, keyPath, log) {
+  const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+  const failed = () => {
+    log.error("Couldn't save your game's source \u2014 please try again.");
+    return false;
+  };
+  const gitDir = await fs7.mkdtemp(path8.join(os2.tmpdir(), "genex-source-"));
   const base = { GIT_DIR: gitDir };
   const ident = {
     GIT_AUTHOR_NAME: "genex",
@@ -795,121 +1008,65 @@ async function deployGame(sshUrl, opts, log) {
     GIT_COMMITTER_NAME: "genex",
     GIT_COMMITTER_EMAIL: "agent@genex.local"
   };
-  const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   try {
-    if ((await run("git", ["init", "-q"], base)).code !== 0) {
-      log.warn("git init failed \u2014 the game was not pushed.");
-      return false;
-    }
-    await fs6.writeFile(
-      path7.join(gitDir, "info", "exclude"),
+    if ((await run("git", ["init", "-q"], base)).code !== 0) return failed();
+    await fs7.writeFile(
+      path8.join(gitDir, "info", "exclude"),
       ["node_modules/", "dist/", ".git/", KEY_NAME, `${KEY_NAME}.pub`, ".genex/", ""].join("\n")
     );
-    const stage = async (workTree, indexName) => {
-      const env = { ...base, GIT_WORK_TREE: workTree, GIT_INDEX_FILE: path7.join(gitDir, indexName) };
-      await run("git", ["add", "-A"], env);
-      const tracked = await run("git", ["ls-files"], env);
-      if (/(^|\/)genex_key(\.pub)?$/m.test(tracked.out)) throw new Error("KEY_STAGED");
-      if (!tracked.out.trim()) return null;
-      const tree = (await run("git", ["write-tree"], env)).out.trim();
-      return tree || null;
-    };
-    const commitTree = async (tree, message) => (await run("git", ["commit-tree", tree, "-m", message], { ...base, ...ident })).out.trim();
-    let mainTree;
-    try {
-      mainTree = await stage(siteDir, "index-main");
-    } catch {
-      log.error(`Refusing to deploy: ${KEY_NAME} is staged. Add it to .gitignore and retry.`);
+    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path8.join(gitDir, "index-source") };
+    await run("git", ["add", "-A"], env);
+    const tracked = await run("git", ["ls-files"], env);
+    if (/(^|\/)genex_key(\.pub)?$/m.test(tracked.out)) {
+      log.error(`Refusing to publish: ${KEY_NAME} is in your project. Add it to .gitignore and retry.`);
       return false;
     }
-    if (!mainTree || mainTree === EMPTY_TREE) {
-      log.warn("Nothing to commit \u2014 the build produced no files.");
+    const tree = tracked.out.trim() ? (await run("git", ["write-tree"], env)).out.trim() : "";
+    if (!tree || tree === EMPTY_TREE) {
+      log.error("Nothing to publish \u2014 the project has no files.");
       return false;
     }
-    await run("git", ["update-ref", "refs/heads/main", await commitTree(mainTree, "build")], base);
-    let pushSource = false;
-    if (siteDir !== cwd) {
-      try {
-        const srcTree = await stage(cwd, "index-source");
-        if (srcTree && srcTree !== EMPTY_TREE) {
-          await run("git", ["update-ref", "refs/heads/source", await commitTree(srcTree, "source")], base);
-          pushSource = true;
-        }
-      } catch {
-        log.dim("  (Couldn't publish source for remixing \u2014 the deploy key was in the way.)");
-      }
-    }
-    log.step("Pushing your game over SSH\u2026");
-    const refspecs = ["+refs/heads/main:main"];
-    if (pushSource) refspecs.push("+refs/heads/source:source");
-    const push = await run(
-      "git",
-      ["push", "-q", ...pushSource ? ["--atomic"] : [], sshUrl, ...refspecs],
-      {
-        ...base,
-        // Quote the key path: git splits GIT_SSH_COMMAND with shell-like rules, so a
-        // project folder with a space (e.g. "fly drone") otherwise breaks the `-i`
-        // argument and ssh fails with "Could not resolve hostname …".
-        GIT_SSH_COMMAND: `ssh -i "${keyPath}" -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new`
-      }
-    );
-    if (push.code === 0) {
-      log.success("Pushed.");
-      if (opts.playUrl) {
-        await waitUntilLive(opts.playUrl, await buildFingerprint(siteDir), opts.liveTimeoutMs ?? 12e4, log);
-      }
-      return true;
-    }
-    log.warn("git push failed \u2014 your live game was NOT updated.");
-    const tail = push.err.trim().split("\n").slice(-2).join(" ");
-    if (tail) log.dim(`  ${tail}`);
-    return false;
-  } finally {
-    await fs6.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    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", sshUrl, "+refs/heads/main:main"], {
+      ...base,
+      // Quote the key path: git splits GIT_SSH_COMMAND shell-like, so a folder with a
+      // space would otherwise break the `-i` argument.
+      GIT_SSH_COMMAND: `ssh -i "${keyPath}" -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new`
     });
-  }
-}
-async function hasBuildScript(cwd) {
-  try {
-    const pkg = JSON.parse(await fs6.readFile(path7.join(cwd, "package.json"), "utf8"));
-    return Boolean(pkg.scripts?.build);
+    return push.code === 0 ? true : failed();
   } catch {
-    return false;
+    return failed();
+  } finally {
+    await fs7.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    });
   }
 }
 async function isDir2(p) {
   try {
-    return (await fs6.stat(p)).isDirectory();
+    return (await fs7.stat(p)).isDirectory();
   } catch {
     return false;
   }
 }
 async function fileExists(p) {
   try {
-    await fs6.access(p);
+    await fs7.access(p);
     return true;
   } catch {
     return false;
   }
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function buildFingerprint(siteDir) {
-  let html;
-  try {
-    html = await fs6.readFile(path7.join(siteDir, "index.html"), "utf8");
-  } catch {
-    return null;
-  }
+function fingerprintOf(html) {
   const m = html.match(/[A-Za-z0-9_]+-[A-Za-z0-9_-]{8}\.(?:js|css)/);
   return m ? m[0] : null;
 }
 async function waitUntilLive(playUrl, fingerprint, timeoutMs, log) {
   if (!fingerprint) {
-    log.dim(`  ${playUrl}`);
-    log.dim("  (GitHub Pages rebuilds ~30\u201390s after a push.)");
+    log.success(`Live. \u{1F310}  ${playUrl}`);
     return;
   }
-  log.step("Waiting for GitHub Pages to serve the new build\u2026");
   const deadline = Date.now() + timeoutMs;
   let n = 0;
   while (Date.now() < deadline) {
@@ -921,25 +1078,23 @@ async function waitUntilLive(playUrl, fingerprint, timeoutMs, log) {
       }
     } catch {
     }
-    await sleep(4e3);
+    await sleep(1500);
   }
-  log.warn("Still publishing \u2014 GitHub Pages can take a bit longer.");
-  log.dim(`  ${playUrl}`);
-  log.dim("  (Open it in ~30\u201360s; the new build is on its way.)");
+  log.success(`Published. \u{1F310}  ${playUrl}`);
+  log.dim("  (If the previous build shows, hard-refresh in a few seconds.)");
 }
-async function warnIfAbsolutePaths(siteDir, log) {
-  let html;
+// src/commands/publish.ts
+async function detectEmbedSdkVersion(cwd = process.cwd()) {
   try {
-    html = await fs6.readFile(path7.join(siteDir, "index.html"), "utf8");
+    const raw = await fs8.readFile(path9.join(cwd, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    const version = pkg.dependencies?.["@genex-ai/embed-sdk"] ?? pkg.devDependencies?.["@genex-ai/embed-sdk"];
+    return typeof version === "string" && version ? version : null;
   } catch {
-    return;
-  }
-  if (/(?:src|href)="\/(?!\/)/.test(html)) {
-    log.warn("Built index.html uses absolute paths \u2014 set `base: './'` in vite.config so assets load under the Pages subpath.");
+    return null;
   }
 }
-// src/commands/publish.ts
 async function runPublish(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex publish"));
@@ -957,11 +1112,18 @@ async function runPublish(opts) {
     return;
   }
   const apiUrl = getApiUrl(opts.apiUrl ?? meta.apiUrl);
-  let pushed = null;
-  if (opts.noPush) {
-    log.info("Skipping build + git push (--no-push).");
+  if (!opts.noPush) {
+    const ok = await deployGame(
+      { projectId: meta.id, sshUrl: meta.sshUrl, apiUrl, token },
+      { noBuild: opts.noBuild },
+      log
+    );
+    if (!ok) {
+      process.exitCode = 1;
+      return;
+    }
   } else {
-    pushed = await deployGame(meta.sshUrl, { noBuild: opts.noBuild, playUrl: meta.playUrl }, log);
+    log.info("Skipping build + deploy (--no-push).");
   }
   log.step("Listing it in the gallery\u2026");
   let res;
@@ -970,33 +1132,26 @@ async function runPublish(opts) {
     if (opts.title) body.title = opts.title;
     if (opts.description) body.description = opts.description;
     if (opts.regenerateCover) body.regenerateCover = true;
+    const embedSdkVersion = await detectEmbedSdkVersion();
+    if (embedSdkVersion) body.embedSdkVersion = embedSdkVersion;
     res = await fetch(`${apiUrl}/api/projects/${meta.id}/publish`, {
       method: "POST",
       headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
       body: JSON.stringify(body)
     });
-  } catch (err) {
-    log.error(`Couldn't reach the API at ${apiUrl}: ${String(err)}`);
+  } catch {
+    log.error("Couldn't reach Genex \u2014 please try again.");
     process.exitCode = 1;
     return;
   }
   if (!res.ok) {
-    log.error(`Publish failed (HTTP ${res.status}).`);
+    log.error("Publish failed \u2014 please try again.");
     process.exitCode = 1;
     return;
   }
   log.plain("");
-  if (pushed === false) {
-    log.warn(
-      "Listed in the gallery, but the game wasn't pushed \u2014 the play URL won't work until the push succeeds."
-    );
-    log.dim("  Fix the error above and re-run `genex publish`.");
-  } else {
-    log.success("Published. \u{1F389}");
-  }
-  if (meta.playUrl) {
-    log.dim(`  play: ${meta.playUrl}`);
-  }
+  log.success("Published. \u{1F389}");
+  if (meta.playUrl) log.dim(`  play: ${meta.playUrl}`);
 }
 // src/commands/preview.ts
@@ -1010,26 +1165,32 @@ async function runPreview(opts) {
     process.exitCode = 1;
     return;
   }
-  const pushed = await deployGame(
-    meta.sshUrl,
-    { noBuild: opts.noBuild, playUrl: meta.playUrl },
+  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(meta.apiUrl);
+  const ok = await deployGame(
+    { projectId: meta.id, sshUrl: meta.sshUrl, apiUrl, token },
+    { noBuild: opts.noBuild },
     log
   );
-  log.plain("");
-  if (!pushed) {
-    log.warn("Preview not updated \u2014 see the error above.");
+  if (!ok) {
     process.exitCode = 1;
     return;
   }
+  log.plain("");
   log.success("Preview deployed \u2014 unlisted draft (run `genex publish` to list it).");
 }
 // src/commands/generate.ts
-import path9 from "path";
+import path11 from "path";
 // src/lib/assets.ts
-import fs7 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path10 from "path";
 function slugify(input) {
   const s = input.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/g, "");
   return s || "asset";
@@ -1038,11 +1199,50 @@ async function downloadToFile(url, dest, headers) {
   const res = await fetch(url, { headers });
   if (!res.ok) throw new Error(`download failed (HTTP ${res.status}) for ${url}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  await fs7.mkdir(path8.dirname(dest), { recursive: true });
-  await fs7.writeFile(dest, buf);
+  await fs9.mkdir(path10.dirname(dest), { recursive: true });
+  await fs9.writeFile(dest, buf);
   return buf.byteLength;
 }
+// src/lib/sse.ts
+async function* readSSE(body) {
+  const decoder = new TextDecoder();
+  const reader = body.getReader();
+  let buf = "";
+  let event = "";
+  let data = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      while (true) {
+        const nl = buf.search(/[\r\n]/);
+        if (nl === -1) break;
+        if (buf[nl] === "\r" && nl === buf.length - 1) break;
+        const sep = buf[nl] === "\r" && buf[nl + 1] === "\n" ? 2 : 1;
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + sep);
+        if (line === "") {
+          if (data.length > 0) yield { event: event || "message", data: data.join("\n") };
+          event = "";
+          data = [];
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value2 = colon === -1 ? "" : line.slice(colon + 1);
+        if (value2.startsWith(" ")) value2 = value2.slice(1);
+        if (field === "event") event = value2;
+        else if (field === "data") data.push(value2);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
 // src/commands/generate.ts
 var PUBLIC_PREFIX = "public/";
 var KIND_DIR = {
@@ -1112,7 +1312,10 @@ async function runGenerate(kind, opts) {
     return;
   }
   log.step("Generating\u2026 (this can take up to a minute)");
-  const view = await poll(apiUrl, token, id, (p) => log.dim(`  ${p}%`));
+  const onProgress = (p) => log.dim(`  ${p}%`);
+  const deadline = Date.now() + WAIT_TIMEOUT_MS;
+  const streamed = await waitViaSSE(apiUrl, token, id, onProgress, deadline);
+  const view = streamed === "unsupported" ? await poll(apiUrl, token, id, onProgress) : streamed;
   if (!view) {
     log.error("Timed out waiting for the generation.");
     process.exitCode = 1;
@@ -1129,7 +1332,7 @@ async function runGenerate(kind, opts) {
     for (const f of view.files ?? []) {
       const rel = fileDest(kind, slug, f);
       const url = `${apiUrl}/api/generations/${id}/asset/${f.role}`;
-      const bytes = await downloadToFile(url, path9.join(process.cwd(), rel), {
+      const bytes = await downloadToFile(url, path11.join(process.cwd(), rel), {
         Authorization: `Bearer ${token}`
       });
       written.push(rel);
@@ -1143,8 +1346,61 @@ async function runGenerate(kind, opts) {
   log.plain("");
   printHint(kind, written, log);
 }
+var WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
+var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed"]);
+async function waitViaSSE(apiUrl, token, id, onProgress, deadline) {
+  let connectFailures = 0;
+  let last = -1;
+  while (Date.now() < deadline) {
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), deadline - Date.now());
+    try {
+      let res;
+      try {
+        res = await fetch(`${apiUrl}/api/generations/${id}/events`, {
+          headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
+          signal: abort.signal
+        });
+      } catch {
+        if (++connectFailures >= 3) return "unsupported";
+        await sleep2(2e3);
+        continue;
+      }
+      if (res.status === 404 || res.status === 405) return "unsupported";
+      const contentType = res.headers.get("content-type") ?? "";
+      if (!res.ok || !res.body || !contentType.includes("text/event-stream")) {
+        if (++connectFailures >= 3) return "unsupported";
+        await sleep2(2e3);
+        continue;
+      }
+      connectFailures = 0;
+      try {
+        for await (const ev of readSSE(res.body)) {
+          if (ev.event !== "status") continue;
+          let view;
+          try {
+            view = JSON.parse(ev.data);
+          } catch {
+            continue;
+          }
+          if (view.progress !== last) {
+            last = view.progress;
+            onProgress(view.progress);
+          }
+          if (TERMINAL.has(view.status)) return view;
+        }
+      } catch {
+      }
+      await sleep2(1e3);
+    } finally {
+      clearTimeout(timer);
+      abort.abort();
+    }
+  }
+  return null;
+}
 async function poll(apiUrl, token, id, onProgress) {
-  const deadline = Date.now() + 10 * 60 * 1e3;
+  const deadline = Date.now() + WAIT_TIMEOUT_MS;
   let last = -1;
   while (Date.now() < deadline) {
     try {
@@ -1185,9 +1441,9 @@ function printHint(kind, written, log) {
 var GEN_KINDS = /* @__PURE__ */ new Set(["model", "skybox", "sfx", "texture"]);
 function getVersion() {
   try {
-    const here = path10.dirname(fileURLToPath2(import.meta.url));
+    const here = path12.dirname(fileURLToPath2(import.meta.url));
     const pkg = JSON.parse(
-      readFileSync(path10.resolve(here, "..", "package.json"), "utf8")
+      readFileSync(path12.resolve(here, "..", "package.json"), "utf8")
     );
     return pkg.version ?? "0.0.0";
   } catch {