@genex-ai/cli-demo 1.10.3-dev.535 → 1.11.0-dev.538

package/dist/blender-mcp-OXFN3RVI.js

@@ -0,0 +1,210 @@
+import {
+  BLENDER_SETUP_HINT,
+  blenderCall,
+  blenderEndpoint,
+  getCliVersion,
+  isRenderMode,
+  sceneSummary
+} from "./chunk-ZHIP7LCA.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) {
+  return reply2.contactSheetPng ? [{ type: "image", data: reply2.contactSheetPng, mimeType: "image/png" }] : [];
+}
+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 } : {},
+        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.`
+        );
+      }
+      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 } : {});
+      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}`);
+    const base = blenderEndpoint();
+    if (!base) {
+      return reply(id, { content: [{ type: "text", text: BLENDER_SETUP_HINT }], isError: true });
+    }
+    try {
+      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}`);
+}
+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/chunk-ZHIP7LCA.js

@@ -0,0 +1,178 @@
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var RAW_CHANNEL = "dev";
+var CLI_CHANNEL = RAW_CHANNEL === "dev" ? "dev" : "latest";
+var STANDS = {
+  prod: { api: "https://api.genex.games", dashboard: "https://genex.games" },
+  dev: { api: "https://api-dev.genex.games", dashboard: "https://dev.genex.games" }
+};
+var DEFAULT_AUTH_URL = CLI_CHANNEL === "dev" ? STANDS.dev.dashboard : STANDS.prod.dashboard;
+var DEFAULT_API_URL = CLI_CHANNEL === "dev" ? STANDS.dev.api : STANDS.prod.api;
+var DEFAULT_ANIMS_BASE = "https://cdn.genex.technology/anims/ual1/v1/";
+var ANIMS_BASE_ENV = "GENEX_ANIMS_BASE";
+function getAnimsBase(override) {
+  const raw = override || process.env[ANIMS_BASE_ENV] || DEFAULT_ANIMS_BASE;
+  return raw.replace(/\/+$/, "") + "/";
+}
+function getAnimsCacheDir() {
+  return path.join(getGenexDir(), "cache", "anims");
+}
+var ENV_TOKEN_KEY = "GENEX_TOKEN";
+var AUTH_URL_ENV = "GENEX_AUTH_URL";
+var API_URL_ENV = "GENEX_API_URL";
+var ENV_FILE_ENV = "GENEX_ENV_FILE";
+function getAuthUrl(override) {
+  const raw = override || process.env[AUTH_URL_ENV] || DEFAULT_AUTH_URL;
+  return raw.replace(/\/+$/, "");
+}
+function getApiUrl(override) {
+  const raw = override || process.env[API_URL_ENV] || DEFAULT_API_URL;
+  return raw.replace(/\/+$/, "");
+}
+function getGenexDir() {
+  return path.join(os.homedir(), ".genex");
+}
+function getGenexEnvPath(override) {
+  if (override) return path.resolve(override);
+  const fromEnv = process.env[ENV_FILE_ENV];
+  if (fromEnv) return path.resolve(fromEnv);
+  return path.join(getGenexDir(), "env");
+}
+function getTemplatesDir() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..", "templates");
+}
+function getCliVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(
+      fs.readFileSync(path.resolve(here, "..", "package.json"), "utf8")
+    );
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var KNOWN_AGENTS = {
+  claude: { label: "Claude Code", dirName: ".claude", full: true },
+  codex: { label: "Codex", dirName: ".codex", full: false },
+  cursor: { label: "Cursor", dirName: ".cursor", full: false }
+};
+var KNOWN_AGENT_IDS = Object.keys(KNOWN_AGENTS);
+function resolveAgentTargets(opts = {}) {
+  if (opts.dir) {
+    return [{ id: "custom", label: "workspace", baseDir: path.resolve(opts.dir), full: true }];
+  }
+  const home = os.homedir();
+  const projectRoot = process.cwd();
+  let ids;
+  if (opts.agents && opts.agents.length > 0) {
+    ids = opts.agents.filter((id) => KNOWN_AGENTS[id]);
+  } else {
+    ids = KNOWN_AGENT_IDS.filter((id) => {
+      const dirName = KNOWN_AGENTS[id].dirName;
+      return isDir(path.join(home, dirName)) || isDir(path.join(projectRoot, dirName));
+    });
+    if (ids.length === 0) ids = ["claude"];
+  }
+  return ids.map((id) => {
+    const def = KNOWN_AGENTS[id];
+    return { id, label: def.label, baseDir: path.join(projectRoot, def.dirName), full: def.full };
+  });
+}
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// 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}`;
+}
+
+export {
+  CLI_CHANNEL,
+  STANDS,
+  DEFAULT_AUTH_URL,
+  DEFAULT_API_URL,
+  getAnimsBase,
+  getAnimsCacheDir,
+  ENV_TOKEN_KEY,
+  ENV_FILE_ENV,
+  getAuthUrl,
+  getApiUrl,
+  getGenexDir,
+  getGenexEnvPath,
+  getTemplatesDir,
+  getCliVersion,
+  resolveAgentTargets,
+  RENDER_MODES,
+  isRenderMode,
+  blenderEndpoint,
+  BLENDER_SETUP_HINT,
+  blenderCall,
+  sceneSummary
+};