@genex-ai/cli-demo 1.11.3-dev.547 → 1.13.0-dev.550

package/dist/{blender-mcp-OXFN3RVI.js → blender-mcp-LLN4FPA4.js}

@@ -1,11 +1,16 @@
 import {
   BLENDER_SETUP_HINT,
+  SHEET_FORMATS,
+  acquireSeat,
   blenderCall,
   blenderEndpoint,
-  getCliVersion,
   isRenderMode,
-  sceneSummary
-} from "./chunk-ZHIP7LCA.js";
+  sceneSummary,
+  sheetOf
+} from "./chunk-WXHTNSFB.js";
+import {
+  getCliVersion
+} from "./chunk-HYCSNWYX.js";
 
 // src/commands/blender-mcp.ts
 import fs from "fs/promises";
@@ -17,7 +22,8 @@ var MODE_SCHEMA = {
   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) {
-  return reply2.contactSheetPng ? [{ type: "image", data: reply2.contactSheetPng, mimeType: "image/png" }] : [];
+  const s = sheetOf(reply2);
+  return s ? [{ type: "image", data: s.b64, mimeType: s.mime }] : [];
 }
 var TOOLS = [
   {
@@ -41,6 +47,7 @@ var TOOLS = [
         // 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 = [];
@@ -55,6 +62,9 @@ ${r.error.trimEnd()}`);
           `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)],
@@ -69,7 +79,10 @@ ${r.error.trimEnd()}`);
     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 } : {});
+      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("  ", " ") },
@@ -163,7 +176,7 @@ async function handle(msg) {
     const args = msg.params?.arguments ?? {};
     const tool = TOOLS.find((t) => t.name === name);
     if (!tool) return fail(id, -32602, `Unknown tool: ${name}`);
-    const base = blenderEndpoint();
+    const base = await mcpEndpoint();
     if (!base) {
       return reply(id, { content: [{ type: "text", text: BLENDER_SETUP_HINT }], isError: true });
     }
@@ -178,6 +191,21 @@ async function handle(msg) {
   }
   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") 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()}
 `);

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
+};

package/dist/{chunk-ZHIP7LCA.js → chunk-HYCSNWYX.js}

@@ -91,67 +91,20 @@ function isDir(p) {
   }
 }
 
-// src/lib/blender-client.ts
-var BLENDER_TIMEOUT_MS = 15 * 60 * 1e3;
-var RENDER_MODES = ["solid", "wireframe", "normals", "lit"];
-function isRenderMode(v) {
-  return typeof v === "string" && RENDER_MODES.includes(v);
-}
-function blenderEndpoint() {
-  const raw = process.env.GENEX_BLENDER_URL?.trim();
-  return raw ? raw.replace(/\/+$/, "") : void 0;
-}
-var BLENDER_SETUP_HINT = [
-  "GENEX_BLENDER_URL is not set \u2014 there is no hosted Blender service yet.",
-  "  Start one locally:",
-  "    docker build --platform=linux/amd64 -t genex-blender:m0 apps/blender-service",
-  "    docker run -d --platform=linux/amd64 -p 8099:8080 genex-blender:m0",
-  "    export GENEX_BLENDER_URL=http://localhost:8099"
-].join("\n");
-async function blenderCall(base, route, body) {
-  const ctl = new AbortController();
-  const timer = setTimeout(() => ctl.abort(), BLENDER_TIMEOUT_MS);
-  try {
-    const res = await fetch(`${base}${route}`, {
-      method: body === void 0 ? "GET" : "POST",
-      headers: {
-        ...body === void 0 ? {} : { "Content-Type": "application/json" },
-        // Sent only when set. The service treats an unset secret as open, which
-        // is right on localhost; the deployed compose makes it mandatory.
-        ...process.env.GENEX_BLENDER_SECRET ? { "x-genex-internal": process.env.GENEX_BLENDER_SECRET } : {}
-      },
-      body: body === void 0 ? void 0 : JSON.stringify(body),
-      signal: ctl.signal
-    });
-    const text = await res.text();
-    let json;
-    try {
-      json = JSON.parse(text);
-    } catch {
-      throw new Error(`${route} answered ${res.status} with non-JSON: ${text.slice(0, 200)}`);
-    }
-    if (!res.ok) {
-      if (res.status === 401) {
-        throw new Error(
-          `${route} refused the request (401) \u2014 set GENEX_BLENDER_SECRET to the service's secret`
-        );
-      }
-      throw new Error(`${route} failed (${res.status}): ${json.error ?? text.slice(0, 200)}`);
-    }
-    return json;
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new Error(`${route} timed out after ${BLENDER_TIMEOUT_MS / 1e3}s`);
-    }
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function sceneSummary(s) {
-  if (!s) return "";
-  return `objects ${s.objectCount}  meshes ${s.meshCount}  tris ${s.totalTris}  materials ${s.materialCount}  radius ${s.bounds.radius}`;
-}
+// src/utils/colors.ts
+var useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+var ESC = String.fromCharCode(27);
+var code = (open, close) => (s) => useColor ? `${ESC}[${open}m${s}${ESC}[${close}m` : s;
+var c = {
+  bold: code(1, 22),
+  dim: code(2, 22),
+  red: code(31, 39),
+  green: code(32, 39),
+  yellow: code(33, 39),
+  blue: code(34, 39),
+  cyan: code(36, 39),
+  gray: code(90, 39)
+};
 
 export {
   CLI_CHANNEL,
@@ -169,10 +122,5 @@ export {
   getTemplatesDir,
   getCliVersion,
   resolveAgentTargets,
-  RENDER_MODES,
-  isRenderMode,
-  blenderEndpoint,
-  BLENDER_SETUP_HINT,
-  blenderCall,
-  sceneSummary
+  c
 };