@genex-ai/cli-demo 1.15.0-dev.577 → 1.15.1-dev.578

package/dist/{blender-mcp-5NBIVBE6.js → blender-mcp-SBNHGDIX.js}

@@ -7,7 +7,7 @@ import {
   isRenderMode,
   sceneSummary,
   sheetOf
-} from "./chunk-YSX7SJFM.js";
+} from "./chunk-JGX6YRC7.js";
 import {
   getCliVersion
 } from "./chunk-HYCSNWYX.js";

package/dist/{chunk-YSX7SJFM.js → chunk-JGX6YRC7.js}

@@ -4,11 +4,304 @@ import {
   ENV_TOKEN_KEY,
   c,
   getApiUrl,
+  getAuthUrl,
   getCliVersion,
   getGenexEnvPath
 } from "./chunk-HYCSNWYX.js";
 
+// src/lib/terms.ts
+import readline from "readline";
+
+// src/lib/source-sync.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+// src/utils/run.ts
+import { spawn } from "child_process";
+var WIN_SHELL_COMMANDS = /* @__PURE__ */ new Set(["npm", "npx"]);
+function run(cmd, args, env) {
+  const shell = process.platform === "win32" && WIN_SHELL_COMMANDS.has(cmd);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cmd, args, { env: env ? { ...process.env, ...env } : process.env, shell });
+    } catch {
+      resolve({ code: -1, out: "", err: `${cmd} not found` });
+      return;
+    }
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => out += String(d));
+    child.stderr?.on("data", (d) => err += String(d));
+    child.on("error", () => resolve({ code: -1, out, err: `${cmd} not found` }));
+    child.on("close", (code) => resolve({ code: code ?? -1, out, err }));
+  });
+}
+
+// src/lib/source-sync.ts
+async function readRemoteSource(apiUrl, token, projectId) {
+  try {
+    const res = await apiFetch(`${apiUrl}/api/projects/${projectId}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => null);
+    if (!data?.project) return null;
+    return {
+      stagingCommit: data.project.stagingCommitSha ?? null,
+      commit: data.project.commitSha ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function isStale(local, remote) {
+  if (!local || !remote) return false;
+  return local !== remote;
+}
+function inHostedSession() {
+  return process.env.GENEX_HOSTED_SESSION === "1";
+}
+function mayForceOverAnotherDevice() {
+  return !inHostedSession();
+}
+function reportForceRefused(log) {
+  log.error("`--force` is not available inside a Genex chat session.");
+  log.dim("  It would replace work shipped from another machine, and that is not yours to discard here.");
+  log.dim(`  Do this instead \u2014 it keeps both sides:`);
+  log.dim(`    1. ${c.cyan("npx genex pull --force")}   takes the other machine's work (a copy of this folder is kept under .genex/replaced-*)`);
+  log.dim(`    2. redo your change on top of it \u2014 you know what you just changed`);
+  log.dim(`    3. ${c.cyan("npx genex preview")}`);
+  log.dim("  If the user explicitly wants their chat version to win, ask them to run `npx genex preview --force` themselves.");
+}
+function reportStale(log, slug, local, remote) {
+  log.error(`${c.cyan(slug)} was updated from another device \u2014 nothing was deployed.`);
+  if (remote && local) {
+    const short = remote.slice(0, 7) !== local.slice(0, 7);
+    const r = short ? remote.slice(0, 7) : remote;
+    const l = short ? local.slice(0, 7) : local;
+    log.dim(`  the draft is on ${r}, this folder last shipped ${l}`);
+  }
+  log.dim(`  ${c.cyan("npx genex pull")} \u2014 take the other device's work (refuses if you have unshipped changes)`);
+  log.dim(`  ${c.cyan("npx genex preview --force")} \u2014 keep yours and replace theirs`);
+}
+async function sourceTreeHash(cwd) {
+  const gitDir = await fs.mkdtemp(path.join(os.tmpdir(), "genex-tree-"));
+  const base = { GIT_DIR: gitDir };
+  try {
+    if ((await run("git", ["init", "-q"], base)).code !== 0) return null;
+    await fs.writeFile(
+      path.join(gitDir, "info", "exclude"),
+      ["node_modules/", "dist/", ".git/", ".genex/", ".env", ".env.*", "!.env.example", ""].join("\n")
+    );
+    if ((await run("git", ["lfs", "version"], base)).code === 0) {
+      const filters = [
+        ["filter.lfs.clean", "git-lfs clean -- %f"],
+        ["filter.lfs.smudge", "git-lfs smudge -- %f"],
+        ["filter.lfs.process", "git-lfs filter-process"],
+        ["filter.lfs.required", "true"]
+      ];
+      for (const [key, value] of filters) await run("git", ["config", key, value], base);
+    }
+    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path.join(gitDir, "index-tree") };
+    if ((await run("git", ["add", "-A"], env)).code !== 0) return null;
+    const tree = (await run("git", ["write-tree"], env)).out.trim();
+    return /^[0-9a-f]{40}$/.test(tree) ? tree : null;
+  } catch {
+    return null;
+  } finally {
+    await fs.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function urlHasEmbeddedCredentials(url) {
+  return /^[a-z][a-z0-9+.-]*:\/\/[^/@]+@/i.test(url);
+}
+function credentialHelperOff(url) {
+  if (!urlHasEmbeddedCredentials(url)) return {};
+  return { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: "credential.helper", GIT_CONFIG_VALUE_0: "" };
+}
+async function fetchCloneGrant(apiUrl, token, projectId, log) {
+  let res;
+  try {
+    res = await apiFetch(`${apiUrl}/api/projects/${projectId}/push-token`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}`, "X-Genex-Source-Intent": "read" }
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API to authorize the source read: ${String(err)}`);
+    return null;
+  }
+  if (res.status === 401) {
+    log.error("Not authorized \u2014 your token may have expired. Re-run `genex auth`.");
+    return null;
+  }
+  if (!res.ok) {
+    log.error(`Couldn't authorize the source read (HTTP ${res.status}).`);
+    return null;
+  }
+  const data = await res.json().catch(() => null);
+  const url = data?.pushUrl ?? data?.cloneUrl;
+  if (!url) {
+    log.error("The API didn't return a source URL.");
+    return null;
+  }
+  return { cloneUrl: url, sourceRef: data?.sourceRef ?? null };
+}
+async function cloneSource(grant, dest, log) {
+  const args = grant.sourceRef ? ["clone", "--branch", grant.sourceRef, grant.cloneUrl, dest] : ["clone", grant.cloneUrl, dest];
+  const env = {
+    GIT_LFS_SKIP_SMUDGE: "1",
+    GIT_TERMINAL_PROMPT: "0",
+    ...credentialHelperOff(grant.cloneUrl)
+  };
+  const cloned = await run("git", args, env);
+  if (cloned.code !== 0) {
+    log.error("Couldn't download the game's source.");
+    log.dim(`  git clone exited ${cloned.code}`);
+    return false;
+  }
+  const repo = { ...env, GIT_DIR: path.join(dest, ".git"), GIT_WORK_TREE: dest };
+  const filters = [
+    ["filter.lfs.clean", "git-lfs clean -- %f"],
+    ["filter.lfs.smudge", "git-lfs smudge -- %f"],
+    ["filter.lfs.process", "git-lfs filter-process"],
+    ["filter.lfs.required", "true"]
+  ];
+  for (const [key, value] of filters) await run("git", ["config", key, value], repo);
+  const pulled = await run("git", ["lfs", "pull"], repo);
+  if (pulled.code !== 0) {
+    log.warn("Binary assets (models, textures, audio) are still pointer files \u2014 `git lfs pull` failed.");
+    log.dim("  The source is there; run `git lfs pull` in this folder once git-lfs works.");
+  }
+  return true;
+}
+
+// src/lib/terms.ts
+var TERMS_ERROR_CODE = "terms_acceptance_required";
+var TERMS_WAIT_MS = 1e5;
+var TERMS_POLL_MS = 3e3;
+async function isTermsRefusal(res) {
+  if (res.status !== 403) return false;
+  try {
+    const body = await res.clone().json();
+    return body?.error === TERMS_ERROR_CODE;
+  } catch {
+    return false;
+  }
+}
+async function termsRefusalUrl(res) {
+  try {
+    const body = await res.clone().json();
+    return typeof body?.url === "string" && body.url ? body.url : null;
+  } catch {
+    return null;
+  }
+}
+function acceptUrl(fromServer, authUrl) {
+  return fromServer || `${getAuthUrl(authUrl)}/accept`;
+}
+function reportTermsRefusal(log, url) {
+  log.error("Your account needs to accept the updated Terms before it can generate or publish.");
+  log.dim("  Nothing was charged, and nothing on your project changed.");
+  log.dim(`  Open ${c.cyan(acceptUrl(url))} and agree \u2014 one click.`);
+}
+async function waitForAcceptance(opts) {
+  const timeoutMs = opts.timeoutMs ?? TERMS_WAIT_MS;
+  const intervalMs = opts.intervalMs ?? TERMS_POLL_MS;
+  const doFetch = opts.fetchImpl ?? fetch;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = opts.now ?? Date.now;
+  const base = opts.apiUrl.replace(/\/+$/, "");
+  opts.log.dim(`  Waiting for you to accept (up to ${Math.round(timeoutMs / 1e3)}s)\u2026`);
+  const deadline = now() + timeoutMs;
+  let first = true;
+  while (first || now() < deadline) {
+    if (!first) await sleep(Math.min(intervalMs, Math.max(0, deadline - now())));
+    first = false;
+    try {
+      const res = await doFetch(`${base}/api/legal/status`, {
+        headers: { Authorization: `Bearer ${opts.token}` }
+      });
+      if (!res.ok) return false;
+      const body = await res.json().catch(() => null);
+      if (body?.accepted === true) {
+        opts.log.success("Accepted \u2014 continuing.");
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
+  opts.log.error("Still not accepted. Re-run this command once you have agreed.");
+  return false;
+}
+function askOnStdin(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+async function runAccept(opts) {
+  const { token, log } = opts;
+  const interactive = opts.interactive ?? Boolean(process.stdin.isTTY);
+  const apiUrl = getApiUrl(opts.apiUrl);
+  let acceptPage = null;
+  const status = await apiFetch(`${apiUrl}/api/legal/status`, {
+    headers: { Authorization: `Bearer ${token}` }
+  }).catch(() => null);
+  if (status?.ok) {
+    const body = await status.json().catch(() => null);
+    if (body?.accepted) {
+      log.success("Already accepted \u2014 nothing to do.");
+      return true;
+    }
+    acceptPage = typeof body?.acceptUrl === "string" ? body.acceptUrl : null;
+    log.plain("Before generating or publishing, please read and agree to:");
+    for (const doc of body?.documents ?? []) log.plain(`  ${doc.title}  ${c.cyan(doc.url)}`);
+    log.plain("");
+  }
+  if (!interactive) {
+    log.plain("Accepting the Terms needs a person \u2014 an agent cannot agree on your behalf.");
+    log.plain(`  Open ${c.cyan(acceptUrl(acceptPage))} and agree \u2014 one click.`);
+    return waitForAcceptance({ apiUrl, token, log, ...opts.wait ?? {} });
+  }
+  const ask = opts.ask ?? askOnStdin;
+  const answer = (await ask("Type 'agree' to accept: ")).trim().toLowerCase();
+  if (answer !== "agree") {
+    log.error("Not accepted \u2014 nothing was recorded.");
+    return false;
+  }
+  const res = await apiFetch(`${apiUrl}/api/legal/accept`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ surface: "cli" })
+  }).catch(() => null);
+  if (!res?.ok) {
+    log.error(`Couldn't record your acceptance (HTTP ${res?.status ?? "no response"}).`);
+    return false;
+  }
+  log.success("Accepted. Re-run your command.");
+  return true;
+}
+
 // src/lib/api.ts
+var stderrLogger = /* @__PURE__ */ (() => {
+  const err = (s) => void process.stderr.write(s + "\n");
+  return {
+    info: err,
+    success: (m) => err(`${c.green("\u2713")} ${m}`),
+    warn: (m) => err(`${c.yellow("!")} ${m}`),
+    error: (m) => err(`${c.red("\u2717")} ${m}`),
+    step: err,
+    dim: (m) => err(c.dim(m)),
+    plain: err
+  };
+})();
 var CLI_VERSION_HEADER = "x-genex-cli-version";
 var WORKSPACE_HEADER = "x-genex-workspace";
 function workspaceHeaderValue(label) {
@@ -54,13 +347,41 @@ var structuredPrinted = /* @__PURE__ */ new WeakSet();
 function printedStructuredError(res) {
   return structuredPrinted.has(res);
 }
-async function apiFetch(url, init = {}) {
+var termsWaitOverride = null;
+function replayable(body) {
+  if (body === void 0 || body === null) return true;
+  if (typeof body === "string") return true;
+  if (body instanceof Uint8Array || body instanceof ArrayBuffer) return true;
+  if (typeof FormData !== "undefined" && body instanceof FormData) return true;
+  if (body instanceof URLSearchParams) return true;
+  if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+  return false;
+}
+async function apiFetch(url, init = {}, opts = {}) {
   const headers = new Headers(init.headers);
   if (!headers.has(CLI_VERSION_HEADER)) headers.set(CLI_VERSION_HEADER, getCliVersion());
   if (workspaceLabel && !headers.has(WORKSPACE_HEADER)) {
     headers.set(WORKSPACE_HEADER, workspaceLabel);
   }
   const res = await fetch(url, { ...init, headers });
+  if (res.status === 403 && !opts.noTermsWait && await isTermsRefusal(res)) {
+    const log = stderrLogger;
+    reportTermsRefusal(log, await termsRefusalUrl(res));
+    const auth = headers.get("authorization") ?? headers.get("Authorization");
+    const token = auth?.replace(/^Bearer\s+/i, "").trim();
+    let accepted = false;
+    if (token && replayable(init.body)) {
+      accepted = await waitForAcceptance({
+        apiUrl: new URL(url).origin,
+        token,
+        log,
+        ...termsWaitOverride ?? {}
+      });
+    }
+    if (accepted) return apiFetch(url, init, { ...opts, noTermsWait: true });
+    structuredPrinted.add(res);
+    return res;
+  }
   if (res.status === 426) {
     try {
       const body = await res.clone().json();
@@ -119,8 +440,8 @@ async function fetchSignedInEmail(apiUrl, token) {
 }
 
 // src/lib/blender-client.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 var BLENDER_TIMEOUT_MS = 15 * 60 * 1e3;
 var RENDER_MODES = ["solid", "wireframe", "normals", "lit"];
 function isRenderMode(v) {
@@ -153,19 +474,19 @@ function sheetOf(r) {
 function sheetExt(mime) {
   return mime === "image/webp" ? "webp" : "png";
 }
-var SEAT_FILE = path.join(".genex", "blender-seat.json");
+var SEAT_FILE = path2.join(".genex", "blender-seat.json");
 function readSeatGrant(cwd = process.cwd()) {
   try {
-    const raw = JSON.parse(fs.readFileSync(path.join(cwd, SEAT_FILE), "utf8"));
+    const raw = JSON.parse(fs2.readFileSync(path2.join(cwd, SEAT_FILE), "utf8"));
     return typeof raw.url === "string" && typeof raw.token === "string" ? { url: raw.url, token: raw.token } : null;
   } catch {
     return null;
   }
 }
 function writeSeatGrant(grant, cwd = process.cwd()) {
-  const file = path.join(cwd, SEAT_FILE);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify(grant, null, 2) + "\n", { mode: 384 });
+  const file = path2.join(cwd, SEAT_FILE);
+  fs2.mkdirSync(path2.dirname(file), { recursive: true });
+  fs2.writeFileSync(file, JSON.stringify(grant, null, 2) + "\n", { mode: 384 });
 }
 async function blenderCall(base, route, body) {
   const seat = readSeatGrant();
@@ -230,18 +551,18 @@ function sceneSummary(s) {
 }
 
 // src/lib/store.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 
 // src/lib/env.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-import { spawn } from "child_process";
+import fs3 from "fs/promises";
+import path3 from "path";
+import { spawn as spawn2 } from "child_process";
 async function writeEnvVar(envPath, key, value) {
   let content = "";
   let existed = false;
   try {
-    content = await fs2.readFile(envPath, "utf8");
+    content = await fs3.readFile(envPath, "utf8");
     existed = true;
   } catch {
   }
@@ -261,14 +582,14 @@ async function writeEnvVar(envPath, key, value) {
     next = prefix + assignment + "\n";
     mode = existed ? "appended" : "created";
   }
-  await fs2.mkdir(path2.dirname(envPath), { recursive: true });
-  await fs2.writeFile(envPath, next, { mode: 384 });
+  await fs3.mkdir(path3.dirname(envPath), { recursive: true });
+  await fs3.writeFile(envPath, next, { mode: 384 });
   await restrictFilePermissions(envPath);
   return { mode, path: envPath };
 }
 async function restrictFilePermissions(filePath) {
   if (process.platform !== "win32") {
-    await fs2.chmod(filePath, 384).catch(() => {
+    await fs3.chmod(filePath, 384).catch(() => {
     });
     return;
   }
@@ -276,7 +597,7 @@ async function restrictFilePermissions(filePath) {
   if (!user) return;
   await new Promise((resolve) => {
     try {
-      const child = spawn(
+      const child = spawn2(
         "icacls",
         [filePath, "/inheritance:r", "/grant:r", `${user}:F`],
         { stdio: "ignore" }
@@ -300,14 +621,14 @@ function escapeRegExp(s) {
 
 // src/lib/store.ts
 function getProjectMetadataPath(cwd = process.cwd()) {
-  return path3.join(cwd, ".genex", "project.json");
+  return path4.join(cwd, ".genex", "project.json");
 }
 function getWorkspacePath(cwd = process.cwd()) {
-  return path3.join(cwd, ".genex", "workspace.json");
+  return path4.join(cwd, ".genex", "workspace.json");
 }
 async function readWorkspace(cwd = process.cwd()) {
   try {
-    const raw = await fs3.readFile(getWorkspacePath(cwd), "utf8");
+    const raw = await fs4.readFile(getWorkspacePath(cwd), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -315,9 +636,9 @@ async function readWorkspace(cwd = process.cwd()) {
 }
 async function writeWorkspace(meta, cwd = process.cwd()) {
   const file = getWorkspacePath(cwd);
-  await fs3.mkdir(path3.dirname(file), { recursive: true });
-  await fs3.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
-  await fs3.chmod(file, 384).catch(() => {
+  await fs4.mkdir(path4.dirname(file), { recursive: true });
+  await fs4.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
+  await fs4.chmod(file, 384).catch(() => {
   });
   return { path: file };
 }
@@ -330,7 +651,7 @@ async function rotateRejectedEnv(envPath) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const aside = `${file}.rejected-${stamp}`;
   try {
-    await fs3.rename(file, aside);
+    await fs4.rename(file, aside);
     return aside;
   } catch {
     return null;
@@ -340,14 +661,14 @@ async function readUserToken(envPath) {
   const fromGenex = await readTokenFromFile(getGenexEnvPath(envPath));
   if (fromGenex) return fromGenex;
   if (!envPath && !process.env[ENV_FILE_ENV]) {
-    return readTokenFromFile(path3.join(process.cwd(), ".env"));
+    return readTokenFromFile(path4.join(process.cwd(), ".env"));
   }
   return null;
 }
 async function readTokenFromFile(file) {
   let content;
   try {
-    content = await fs3.readFile(file, "utf8");
+    content = await fs4.readFile(file, "utf8");
   } catch {
     return null;
   }
@@ -363,7 +684,7 @@ function stripQuotes(v) {
 }
 async function readProject(cwd = process.cwd()) {
   try {
-    const raw = await fs3.readFile(getProjectMetadataPath(cwd), "utf8");
+    const raw = await fs4.readFile(getProjectMetadataPath(cwd), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -371,9 +692,9 @@ async function readProject(cwd = process.cwd()) {
 }
 async function writeProject(meta, cwd = process.cwd()) {
   const file = getProjectMetadataPath(cwd);
-  await fs3.mkdir(path3.dirname(file), { recursive: true });
-  await fs3.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
-  await fs3.chmod(file, 384).catch(() => {
+  await fs4.mkdir(path4.dirname(file), { recursive: true });
+  await fs4.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
+  await fs4.chmod(file, 384).catch(() => {
   });
   return { path: file };
 }
@@ -429,6 +750,21 @@ async function acquireSeat(opts) {
 }
 
 export {
+  run,
+  readRemoteSource,
+  isStale,
+  inHostedSession,
+  mayForceOverAnotherDevice,
+  reportForceRefused,
+  reportStale,
+  sourceTreeHash,
+  urlHasEmbeddedCredentials,
+  fetchCloneGrant,
+  cloneSource,
+  isTermsRefusal,
+  acceptUrl,
+  reportTermsRefusal,
+  runAccept,
   setWorkspaceHeader,
   printedStructuredError,
   apiFetch,