@genex-ai/cli-demo 1.31.2 → 1.32.0-dev.653

package/README.md

@@ -5,6 +5,8 @@ This is the `cli` app of the [genex monorepo](../../README.md).
 
 ```bash
 genex init <name>          # authorize + create the draft project
+genex remix <slug>         # make a new draft from a source snapshot
+genex remix <slug> --source-only  # download a reference into .genex/refs without linking
 genex link <slug>          # re-link this folder to an existing game of yours (recovery)
 genex list                 # list your games — slug, status, page link (find the slug to link)
 genex preview              # build + push to the hosted draft URL (unlisted)
@@ -34,6 +36,22 @@ genex ui <tool>            # local pixel toolbox for generated UI art: extract |
 > never a different global `genex`). `genex <cmd>` works too if you install it
 > globally. The bare command forms below name the command; prefix with `npx` to run.
 
+`genex remix <slug-or-Genex-page-URL> [directory]` prepares an independent draft
+from a source snapshot. It downloads the real asset bytes, gives the copy its own
+project identity and CLI dependency, and installs concise remix guidance. Your
+request decides whether to make a small change, borrow a system, restyle the game,
+or redesign it completely. An existing destination is refused unless it belongs
+to the same interrupted setup; retry the command to resume it. `--preview` opts
+into publishing a baseline draft. The default prepares the workspace first.
+
+`--source-only` downloads reference source under `.genex/refs/` (or into a named
+empty directory), without creating a project, installing dependencies or changing
+the current project's identity. Keep required credits and license notices with
+reused source; Genex does not require a new in-game credit overlay. Owners can use
+their private source; other users can use eligible public games. When an exact
+release-to-source match is unavailable, the command explicitly labels the source
+as the latest available snapshot.
+
 `genex init` does four things:
 
 1. **Installs the skills for your coding agents** — copies the bundled templates

package/dist/blender-mcp-Q6PSFYSE.js

@@ -0,0 +1,241 @@
+import {
+  SHEET_FORMATS,
+  acquireSeat,
+  blenderCall,
+  blenderEndpoint,
+  blenderSetupHint,
+  isRenderMode,
+  sceneSummary,
+  sheetOf
+} from "./chunk-2COG4P3T.js";
+import {
+  getCliVersion
+} from "./chunk-HYCSNWYX.js";
+
+// src/commands/blender-mcp.ts
+import fs from "fs/promises";
+import path from "path";
+var FALLBACK_PROTOCOL = "2025-06-18";
+var MODE_SCHEMA = {
+  type: "string",
+  enum: ["solid", "wireframe", "normals", "lit"],
+  description: "solid = material colours; wireframe = topology; normals = matcap that exposes inverted faces; lit = EEVEE, real lighting and shadows \u2014 GPU tier only, and it errors on the CPU tier rather than quietly falling back."
+};
+function sheet(reply2) {
+  const s = sheetOf(reply2);
+  return s ? [{ type: "image", data: s.b64, mimeType: s.mime }] : [];
+}
+var TOOLS = [
+  {
+    name: "blender_exec",
+    description: "Run Python (bpy) against the live Blender scene and get back a 4-view contact sheet plus the scene's numeric truths. The scene PERSISTS between calls, so you can build incrementally and a helper defined in one call is available in the next. Assert on the numbers; use the picture to decide what to change next.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        script: { type: "string", description: "Python source. `bpy`, `bmesh`, `mathutils`, `math`, `random` are in scope." },
+        mode: MODE_SCHEMA,
+        verify: {
+          type: "boolean",
+          description: "Set false to skip the render for a bulk sub-step. Defaults true \u2014 you should almost always look."
+        }
+      },
+      required: ["script"]
+    },
+    run: async (a, base) => {
+      const r = await blenderCall(base, "/exec", {
+        script: String(a.script ?? ""),
+        // Omitted rather than defaulted: the server picks per tier (`lit` on
+        // GPU, `solid` on CPU) and echoes what it used.
+        ...isRenderMode(a.mode) ? { mode: a.mode } : {},
+        sheet: { formats: SHEET_FORMATS },
+        verify: a.verify !== false
+      });
+      const lines = [];
+      if (r.stdout?.trim()) lines.push(r.stdout.trimEnd());
+      if (r.stderr?.trim()) lines.push(r.stderr.trimEnd());
+      if (r.error) {
+        lines.push(`ERROR:
+${r.error.trimEnd()}`);
+      }
+      if (r.sceneRestored?.restored) {
+        lines.push(
+          `NOTE: the service restarted (${r.sceneRestored.reason ?? "unknown"}) and the scene was restored from a checkpoint. Your most recent step may be missing \u2014 check the scene before continuing.`
+        );
+      }
+      if (r.contactSheetUnchanged) {
+        lines.push("The scene is unchanged since the last render, so no new image was produced.");
+      }
+      lines.push(sceneSummary(r.scene));
+      return {
+        content: [{ type: "text", text: lines.filter(Boolean).join("\n") }, ...sheet(r)],
+        // A raised script is a failed call, even though HTTP said 200 and the
+        // sheet came back. Without this the model reads "ERROR:" as prose.
+        isError: Boolean(r.error)
+      };
+    }
+  },
+  {
+    name: "blender_render",
+    description: "Re-render the current scene without changing it. Use `normals` to check for inverted faces and `wireframe` to check topology.",
+    inputSchema: { type: "object", properties: { mode: MODE_SCHEMA } },
+    run: async (a, base) => {
+      const r = await blenderCall(base, "/render", {
+        ...isRenderMode(a.mode) ? { mode: a.mode } : {},
+        sheet: { formats: SHEET_FORMATS }
+      });
+      return {
+        content: [
+          { type: "text", text: `rendered ${String(r.mode ?? "")} in ${r.ms ?? "?"}ms`.replace("  ", " ") },
+          ...sheet(r)
+        ]
+      };
+    }
+  },
+  {
+    name: "blender_scene_info",
+    description: "The scene graph as JSON \u2014 every object with its type, triangle count, location, dimensions and materials, plus scene bounds. This is the gate: a render judge is unreliable for pass/fail, so verify structure here.",
+    inputSchema: { type: "object", properties: {} },
+    run: async (_a, base) => {
+      const r = await blenderCall(base, "/scene");
+      return { content: [{ type: "text", text: JSON.stringify(r, null, 2) }] };
+    }
+  },
+  {
+    name: "blender_import_model",
+    description: "Import a GLB into the current scene by URL, so a generated asset can be composed with the rest.",
+    inputSchema: {
+      type: "object",
+      properties: { url: { type: "string", description: "Public URL of a .glb" } },
+      required: ["url"]
+    },
+    run: async (a, base) => {
+      const r = await blenderCall(base, "/import", { url: String(a.url ?? "") });
+      return { content: [{ type: "text", text: `imported ${r.count ?? 0}: ${(r.imported ?? []).join(", ")}` }] };
+    }
+  },
+  {
+    name: "blender_export_glb",
+    description: "Export the scene as a GLB. With `savePath` the bytes are written to that local file, which is how the result gets into a game.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        savePath: { type: "string", description: "Local path to write, e.g. public/assets/scene.glb" }
+      }
+    },
+    run: async (a, base) => {
+      const r = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
+      let where = "(not saved locally \u2014 pass savePath to write it)";
+      if (typeof a.savePath === "string" && a.savePath.trim()) {
+        const target = path.resolve(a.savePath.trim());
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, Buffer.from(r.glbBase64 ?? "", "base64"));
+        where = target;
+      }
+      return { content: [{ type: "text", text: `exported ${r.bytes ?? 0} bytes \u2192 ${where}` }] };
+    }
+  },
+  {
+    name: "blender_reset",
+    description: "Empty the scene and the Python namespace. Start here when beginning something unrelated.",
+    inputSchema: { type: "object", properties: {} },
+    run: async (_a, base) => {
+      const r = await blenderCall(base, "/reset", {});
+      return { content: [{ type: "text", text: `reset. ${sceneSummary(r.scene)}` }] };
+    }
+  }
+];
+function write(msg) {
+  process.stdout.write(`${JSON.stringify(msg)}
+`);
+}
+function reply(id, result) {
+  write({ jsonrpc: "2.0", id, result });
+}
+function fail(id, code, message) {
+  write({ jsonrpc: "2.0", id, error: { code, message } });
+}
+async function handle(msg) {
+  const { method, id } = msg;
+  if (id === void 0 || id === null) return;
+  if (method === "initialize") {
+    const asked = msg.params?.protocolVersion ?? FALLBACK_PROTOCOL;
+    return reply(id, {
+      protocolVersion: asked,
+      capabilities: { tools: {} },
+      serverInfo: { name: "genex-blender", version: getCliVersion() }
+    });
+  }
+  if (method === "ping") return reply(id, {});
+  if (method === "tools/list") {
+    return reply(id, {
+      tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }))
+    });
+  }
+  if (method === "tools/call") {
+    const name = msg.params?.name;
+    const args = msg.params?.arguments ?? {};
+    const tool = TOOLS.find((t) => t.name === name);
+    if (!tool) return fail(id, -32602, `Unknown tool: ${name}`);
+    try {
+      const base = await mcpEndpoint();
+      if (!base) {
+        return reply(id, { content: [{ type: "text", text: blenderSetupHint() }], isError: true });
+      }
+      return reply(id, await tool.run(args, base));
+    } catch (err) {
+      return reply(id, {
+        content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+        isError: true
+      });
+    }
+  }
+  fail(id, -32601, `Method not found: ${method}`);
+}
+var stderrLog = {
+  step: (m) => process.stderr.write(`[genex-blender-mcp] ${m}
+`),
+  warn: (m) => process.stderr.write(`[genex-blender-mcp] ${m}
+`),
+  error: (m) => process.stderr.write(`[genex-blender-mcp] ${m}
+`)
+};
+async function mcpEndpoint() {
+  const seat = await acquireSeat({ log: stderrLog });
+  if (seat.kind === "granted") {
+    await blenderCall(seat.grant.url, "/health");
+    return seat.grant.url;
+  }
+  if (seat.kind === "refused") stderrLog.error(`no Blender seat: ${seat.reason}`);
+  if (seat.kind === "warming") stderrLog.warn("the Blender seat is still warming \u2014 the next call will try again");
+  return blenderEndpoint();
+}
+async function runBlenderMcp() {
+  process.stderr.write(`[genex-blender-mcp] ${TOOLS.length} tools, cli ${getCliVersion()}
+`);
+  if (!blenderEndpoint()) {
+    process.stderr.write("[genex-blender-mcp] GENEX_BLENDER_URL unset \u2014 tools will explain setup\n");
+  }
+  let buf = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        fail(null, -32700, "Parse error");
+        continue;
+      }
+      await handle(msg);
+    }
+  }
+  return 0;
+}
+export {
+  runBlenderMcp
+};

package/dist/blender-serve-BF4FZ55Z.js

@@ -0,0 +1,244 @@
+import {
+  c,
+  getTemplatesDir
+} from "./chunk-HYCSNWYX.js";
+
+// src/lib/blender-serve.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+import "url";
+
+// src/lib/blender-local.ts
+import { spawnSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var CANDIDATES = {
+  darwin: [
+    "/Applications/Blender.app/Contents/MacOS/Blender",
+    path.join(os.homedir(), "Applications/Blender.app/Contents/MacOS/Blender")
+  ],
+  win32: [
+    "C:\\Program Files\\Blender Foundation\\Blender 5.0\\blender.exe",
+    "C:\\Program Files\\Blender Foundation\\Blender 4.5\\blender.exe",
+    "C:\\Program Files\\Blender Foundation\\Blender 4.2\\blender.exe"
+  ],
+  linux: ["/usr/bin/blender", "/usr/local/bin/blender", "/snap/bin/blender"]
+};
+function probe(bin) {
+  if (!fs.existsSync(bin)) return null;
+  const r = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 2e4 });
+  const m = /Blender\s+(\d+)\.(\d+)(?:\.(\d+))?/.exec(r.stdout ?? "");
+  if (!m) return null;
+  const major = Number(m[1]);
+  const minor = Number(m[2]);
+  return { version: `${major}.${minor}${m[3] ? `.${m[3]}` : ""}`, major, minor };
+}
+function findBlender() {
+  const pinned = process.env.GENEX_BLENDER_BIN?.trim();
+  if (pinned) {
+    const v = probe(pinned);
+    return v ? { bin: pinned, ...v, source: "env" } : null;
+  }
+  const onPath = spawnSync(process.platform === "win32" ? "where" : "which", ["blender"], {
+    encoding: "utf8",
+    timeout: 1e4
+  });
+  const first = (onPath.stdout ?? "").split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+  if (first) {
+    const v = probe(first);
+    if (v) return { bin: first, ...v, source: "path" };
+  }
+  for (const bin of CANDIDATES[process.platform] ?? []) {
+    const v = probe(bin);
+    if (v) return { bin, ...v, source: "install" };
+  }
+  return null;
+}
+function vetBlender(info) {
+  const warnings = [];
+  if (info.major < 4 || info.major === 4 && info.minor < 2) {
+    return {
+      ok: false,
+      warnings,
+      reason: `Blender ${info.version} is too old \u2014 this needs 4.2 or newer (EEVEE Next). Install a current Blender, or point GENEX_BLENDER_BIN at one.`
+    };
+  }
+  if (info.major > 5) {
+    warnings.push(
+      `Blender ${info.version} is newer than anything this has been tested against (4.2\u20135.x). If renders look wrong, that is the first thing to suspect.`
+    );
+  }
+  return { ok: true, warnings };
+}
+
+// src/lib/blender-serve.ts
+function serviceDir() {
+  return path2.join(getTemplatesDir(), "blender-service");
+}
+var POLL_MS = 1e3;
+var TERM_GRACE_MS = 5e3;
+async function serveLocalBlender(opts) {
+  const { log } = opts;
+  const info = findBlender();
+  if (!info) {
+    log.error("No Blender found on this machine.");
+    log.plain(
+      [
+        "  Install Blender 4.2 or newer, then re-run. Or point at one you already have:",
+        `    ${c.cyan("export GENEX_BLENDER_BIN=/path/to/blender")}`,
+        "",
+        `  ${c.dim("macOS:")}   https://www.blender.org/download/  (or: brew install --cask blender)`,
+        `  ${c.dim("Linux:")}   your distro's blender package, or the tarball from blender.org`,
+        `  ${c.dim("Windows:")} https://www.blender.org/download/`
+      ].join("\n")
+    );
+    return 1;
+  }
+  const verdict = vetBlender(info);
+  if (!verdict.ok) {
+    log.error(verdict.reason ?? "This Blender cannot be used.");
+    return 1;
+  }
+  for (const w of verdict.warnings) log.warn(w);
+  const server = path2.join(serviceDir(), "server.py");
+  if (!fs2.existsSync(server)) {
+    log.error(`Service files are missing: ${server}`);
+    log.plain(`  ${c.dim("From a source checkout, run:")} node apps/cli/scripts/sync-blender-service.mjs`);
+    return 1;
+  }
+  const stateDir = opts.stateDir ?? path2.join(os2.homedir(), ".genex", "blender");
+  fs2.mkdirSync(stateDir, { recursive: true });
+  const deadlineFile = path2.join(stateDir, "deadline");
+  try {
+    fs2.unlinkSync(deadlineFile);
+  } catch {
+  }
+  log.step(`Blender ${info.version} ${c.dim(`(${info.source}: ${info.bin})`)}`);
+  log.plain(
+    `  ${c.dim("This runs on YOUR machine and YOUR GPU. Nothing is uploaded, nothing is rented.")}`
+  );
+  let stopping = false;
+  let child = null;
+  const stop = (signal) => {
+    stopping = true;
+    if (child) child.kill(signal);
+  };
+  process.on("SIGINT", () => stop("SIGINT"));
+  process.on("SIGTERM", () => stop("SIGTERM"));
+  while (!stopping) {
+    const started = Date.now();
+    child = spawnBlender(info, server, stateDir, opts.port);
+    const exit = await superviseUntilExit(child, deadlineFile, log);
+    child = null;
+    if (stopping) return 0;
+    if (exit.code === 0 && !exit.killed) {
+      if (fs2.existsSync(path2.join(stateDir, "destroy-requested"))) {
+        log.info("Blender exited cleanly.");
+        return 0;
+      }
+      log.warn("Blender exited 0 without being asked to (a script called sys.exit()?). Restarting; the scene is restored from its checkpoint.");
+    }
+    if (!exit.killed && Date.now() - started < 15e3) {
+      log.error(`Blender exited ${exit.code} almost immediately \u2014 not restarting.`);
+      log.plain(`  ${c.dim("Run with GENEX_BLENDER_DEBUG=1 to see its output.")}`);
+      return 1;
+    }
+    log.warn(
+      exit.killed ? `Killed ${exit.route ?? "a request"} \u2014 it exceeded its ${exit.budget ?? "?"}s budget. Restarting; the scene is restored from its checkpoint.` : `Blender exited ${exit.code}. Restarting.`
+    );
+    try {
+      fs2.writeFileSync(
+        path2.join(stateDir, "restart-reason"),
+        JSON.stringify({ at: Date.now() / 1e3, reason: exit.killed ? "deadline_exceeded" : "crashed", route: exit.route })
+      );
+    } catch {
+    }
+  }
+  return 0;
+}
+function spawnBlender(info, server, stateDir, port) {
+  return spawn(
+    info.bin,
+    [
+      "--background",
+      "--factory-startup",
+      "-noaudio",
+      // Without this a script that raises exits 0 and the failure looks healthy.
+      "--python-exit-code",
+      "1",
+      "--python",
+      server,
+      "--",
+      "--port",
+      String(port)
+    ],
+    {
+      env: {
+        ...process.env,
+        // The local lane is a GPU lane when the machine has one, but it must not
+        // REFUSE when it does not — unlike the pod, where software rendering
+        // means paying GPU rates for CPU work.
+        // Blender writes __pycache__ beside whatever it imports, and the
+        // service lives inside the installed package — so without this a user's
+        // node_modules accumulates .pyc files, and in a source checkout they
+        // land in templates/ and get vendored into the next publish. Caught by
+        // blender-parity.test.ts after exactly that happened.
+        PYTHONDONTWRITEBYTECODE: "1",
+        GENEX_BLENDER_REQUIRE_GPU: "detect",
+        GENEX_BLENDER_RUN_DIR: stateDir,
+        GENEX_BLENDER_CHECKPOINT: path2.join(stateDir, "checkpoint.blend")
+      },
+      stdio: process.env.GENEX_BLENDER_DEBUG === "1" ? "inherit" : ["ignore", "ignore", "pipe"]
+    }
+  );
+}
+function superviseUntilExit(child, deadlineFile, log) {
+  return new Promise((resolve) => {
+    let done = false;
+    let tail = "";
+    child.stderr?.on("data", (d) => {
+      tail = (tail + String(d)).slice(-2e3);
+    });
+    const timer = setInterval(() => {
+      let d = null;
+      try {
+        d = JSON.parse(fs2.readFileSync(deadlineFile, "utf8"));
+      } catch {
+        return;
+      }
+      if (typeof d.deadline === "number" && Date.now() / 1e3 > d.deadline) {
+        clearInterval(timer);
+        if (done) return;
+        done = true;
+        const route = d.route;
+        const budget = d.budget;
+        child.kill("SIGTERM");
+        const hard = setTimeout(() => child.kill("SIGKILL"), TERM_GRACE_MS);
+        child.once("exit", () => {
+          clearTimeout(hard);
+          try {
+            fs2.unlinkSync(deadlineFile);
+          } catch {
+          }
+          resolve({ code: null, killed: true, route, budget });
+        });
+      }
+    }, POLL_MS);
+    child.once("exit", (code) => {
+      clearInterval(timer);
+      if (done) return;
+      done = true;
+      if (code !== 0 && tail.trim() && process.env.GENEX_BLENDER_DEBUG !== "1") {
+        log.plain(c.dim(tail.trim().split("\n").slice(-6).join("\n")));
+      }
+      resolve({ code, killed: false });
+    });
+  });
+}
+export {
+  serveLocalBlender,
+  serviceDir
+};