stereoframe 0.2.2 → 0.2.4

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFileSync, existsSync as existsSync4 } from "node:fs";
-import { join as join4, resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync2, existsSync as existsSync5 } from "node:fs";
+import { join as join5, resolve as resolve7 } from "node:path";
 
 // src/blocks.ts
 import { copyFileSync, existsSync, mkdirSync } from "node:fs";
@@ -58,6 +58,122 @@ ${listBlocks()}`);
 `);
 }
 
+// src/gen.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+var MESHY_BASE = "https://api.meshy.ai";
+var TEST_KEY = "msy_dummy_api_key_for_test_mode_12345678";
+function resolveKey(projectDir, explicit) {
+  if (explicit)
+    return { key: explicit, isTest: false };
+  if (process.env.MESHY_API_KEY)
+    return { key: process.env.MESHY_API_KEY, isTest: false };
+  const envPath = join2(resolve2(projectDir), ".env");
+  if (existsSync2(envPath)) {
+    const line = readFileSync(envPath, "utf8").split(`
+`).find((l) => l.startsWith("MESHY_API_KEY="));
+    const v = line?.slice("MESHY_API_KEY=".length).trim();
+    if (v)
+      return { key: v, isTest: false };
+  }
+  return { key: TEST_KEY, isTest: true };
+}
+function slug(prompt) {
+  return prompt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "model";
+}
+async function meshy(path, key, init) {
+  const res = await fetch(MESHY_BASE + path, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Meshy ${init?.method ?? "GET"} ${path} → ${res.status}: ${text.slice(0, 300)}`);
+  }
+  return text ? JSON.parse(text) : {};
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollTask(taskId, key, label) {
+  const deadline = Date.now() + 8 * 60000;
+  let lastProgress = -1;
+  while (Date.now() < deadline) {
+    const task = await meshy(`/openapi/v2/text-to-3d/${taskId}`, key);
+    const status = task.status;
+    const progress = Number(task.progress ?? 0);
+    if (progress !== lastProgress) {
+      process.stdout.write(`\r  ${label}: ${status} ${progress}%   `);
+      lastProgress = progress;
+    }
+    if (status === "SUCCEEDED") {
+      process.stdout.write(`
+`);
+      return task;
+    }
+    if (status === "FAILED" || status === "CANCELED") {
+      process.stdout.write(`
+`);
+      throw new Error(`${label} ${status}: ${task.task_error?.message ?? "unknown error"}`);
+    }
+    await sleep(3000);
+  }
+  throw new Error(`${label} timed out after 8 minutes`);
+}
+async function genModel(opts) {
+  const projectDir = resolve2(opts.projectDir);
+  const { key, isTest } = resolveKey(projectDir, opts.key);
+  if (isTest) {
+    console.log(`⚠ no MESHY_API_KEY found — using Meshy test mode (returns a SAMPLE model, ignores the prompt).
+` + "  Set MESHY_API_KEY in your shell or project .env for real generations (https://www.meshy.ai/settings/api).");
+  }
+  const out = resolve2(projectDir, opts.out ?? join2("assets", `${slug(opts.prompt)}.glb`));
+  mkdirSync2(join2(out, ".."), { recursive: true });
+  console.log(`generating "${opts.prompt}" → ${out}`);
+  const preview = await meshy("/openapi/v2/text-to-3d", key, {
+    method: "POST",
+    body: JSON.stringify({
+      mode: "preview",
+      prompt: opts.prompt,
+      ai_model: "latest",
+      target_formats: ["glb"],
+      should_remesh: true,
+      ...opts.polycount ? { target_polycount: opts.polycount } : {}
+    })
+  });
+  const previewId = preview.result;
+  const previewTask = await pollTask(previewId, key, "preview");
+  let finalTask = previewTask;
+  if (opts.texture) {
+    const refine = await meshy("/openapi/v2/text-to-3d", key, {
+      method: "POST",
+      body: JSON.stringify({
+        mode: "refine",
+        preview_task_id: previewId,
+        enable_pbr: true,
+        target_formats: ["glb"]
+      })
+    });
+    finalTask = await pollTask(refine.result, key, "texture");
+  }
+  const glbUrl = finalTask.model_urls?.glb;
+  if (!glbUrl)
+    throw new Error("Meshy returned no GLB url");
+  const glb = await fetch(glbUrl);
+  if (!glb.ok)
+    throw new Error(`downloading GLB → ${glb.status}`);
+  writeFileSync(out, Buffer.from(await glb.arrayBuffer()));
+  const rel = out.startsWith(projectDir) ? out.slice(projectDir.length + 1) : out;
+  console.log(`
+✓ saved ${rel}`);
+  console.log(`  use it:  <sf-model src="${rel}" scale="1"></sf-model>`);
+  if (isTest)
+    console.log("  (sample model — set MESHY_API_KEY to generate from your prompt)");
+  return out;
+}
+
 // src/lint.ts
 import { ASSET_ATTRS, EASE_NAMES, ELEMENT_NAMES, VERB_NAMES } from "stereoframe-runtime/vocab";
 function readAttr(attrs, name) {
@@ -125,6 +241,8 @@ function lintHtml(html, opts) {
       const value = readAttr(tag.attrs, attr);
       if (!value)
         continue;
+      if (attr === "environment" && (value === "room" || value === "studio"))
+        continue;
       if (/^https?:\/\//i.test(value)) {
         findings.push({
           rule: "remote_asset",
@@ -253,16 +371,16 @@ function lintHtml(html, opts) {
 
 // src/render.ts
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname, resolve as resolve3 } from "node:path";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname, resolve as resolve4 } from "node:path";
 
 // src/session.ts
 import puppeteer from "puppeteer";
 
 // src/serve.ts
 import { createServer } from "node:http";
-import { createReadStream, existsSync as existsSync2, statSync } from "node:fs";
-import { extname, join as join2, normalize, resolve as resolve2 } from "node:path";
+import { createReadStream, existsSync as existsSync3, statSync } from "node:fs";
+import { extname, join as join3, normalize, resolve as resolve3 } from "node:path";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -290,7 +408,7 @@ var MIME = {
   ".otf": "font/otf"
 };
 function serveProject(projectDir, fixedPort = 0) {
-  const root = resolve2(projectDir);
+  const root = resolve3(projectDir);
   const server = createServer((req, res) => {
     const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0] ?? "/");
     if (urlPath === "/favicon.ico") {
@@ -298,15 +416,15 @@ function serveProject(projectDir, fixedPort = 0) {
       return;
     }
     const rel = normalize(urlPath).replace(/^(\.\.[/\\])+/, "");
-    let filePath = join2(root, rel);
+    let filePath = join3(root, rel);
     if (!filePath.startsWith(root)) {
       res.writeHead(403).end("forbidden");
       return;
     }
-    if (existsSync2(filePath) && statSync(filePath).isDirectory()) {
-      filePath = join2(filePath, "index.html");
+    if (existsSync3(filePath) && statSync(filePath).isDirectory()) {
+      filePath = join3(filePath, "index.html");
     }
-    if (!existsSync2(filePath)) {
+    if (!existsSync3(filePath)) {
       res.writeHead(404).end(`not found: ${urlPath}`);
       return;
     }
@@ -395,10 +513,10 @@ async function renderProject(opts) {
   const fps = opts.fps ?? 30;
   const crf = opts.draft ? 28 : opts.crf ?? 18;
   const preset = opts.draft ? "veryfast" : "medium";
-  const projectDir = resolve3(opts.projectDir);
+  const projectDir = resolve4(opts.projectDir);
   const stamp = new Date().toISOString().replace(/[:T]/g, "-").slice(0, 19);
-  const out = resolve3(projectDir, opts.out ?? `renders/render_${stamp}.mp4`);
-  mkdirSync2(dirname(out), { recursive: true });
+  const out = resolve4(projectDir, opts.out ?? `renders/render_${stamp}.mp4`);
+  mkdirSync3(dirname(out), { recursive: true });
   const session = await openSession(projectDir, { echoErrors: true });
   try {
     const { page, info } = session;
@@ -463,9 +581,9 @@ async function renderProject(opts) {
 }
 
 // src/scaffold.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync } from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname2, join as join3, resolve as resolve4 } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolve5 } from "node:path";
 var TEMPLATE = `<!doctype html>
 <html lang="en">
   <head>
@@ -508,34 +626,34 @@ function resolveRuntimeBundle() {
   return require2.resolve("stereoframe-runtime");
 }
 function scaffoldProject(name, cwd = process.cwd()) {
-  const dir = resolve4(cwd, name);
-  if (existsSync3(join3(dir, "index.html"))) {
+  const dir = resolve5(cwd, name);
+  if (existsSync4(join4(dir, "index.html"))) {
     throw new Error(`refusing to overwrite existing project at ${dir}`);
   }
-  mkdirSync3(join3(dir, "assets"), { recursive: true });
-  writeFileSync(join3(dir, "index.html"), TEMPLATE);
-  writeFileSync(join3(dir, ".gitignore"), `renders/
+  mkdirSync4(join4(dir, "assets"), { recursive: true });
+  writeFileSync2(join4(dir, "index.html"), TEMPLATE);
+  writeFileSync2(join4(dir, ".gitignore"), `renders/
 `);
-  copyFileSync2(resolveRuntimeBundle(), join3(dir, "assets", "stereoframe.js"));
+  copyFileSync2(resolveRuntimeBundle(), join4(dir, "assets", "stereoframe.js"));
   return dir;
 }
 function updateRuntime(projectDir) {
-  if (!existsSync3(join3(resolve4(projectDir), "index.html"))) {
+  if (!existsSync4(join4(resolve5(projectDir), "index.html"))) {
     throw new Error(`no index.html in ${projectDir} — not a stereoframe project`);
   }
-  const target = join3(resolve4(projectDir), "assets", "stereoframe.js");
-  mkdirSync3(dirname2(target), { recursive: true });
+  const target = join4(resolve5(projectDir), "assets", "stereoframe.js");
+  mkdirSync4(dirname2(target), { recursive: true });
   copyFileSync2(resolveRuntimeBundle(), target);
   return target;
 }
 
 // src/validate.ts
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 async function validateProject(projectDir) {
   const findings = [];
   let session;
   try {
-    session = await openSession(resolve5(projectDir));
+    session = await openSession(resolve6(projectDir));
   } catch (err) {
     return [
       {
@@ -660,6 +778,12 @@ USAGE
       --draft          fast low-quality render for iteration
   stereoframe preview [dir]            serve with looping wall-clock playback
       --port <n>       fixed port (default: random)
+  stereoframe gen "<prompt>"           generate a 3D model (GLB) from text via Meshy
+      --dir <dir>      project dir (default .)
+      --out <path>     output path (default assets/<slug>.glb)
+      --no-texture     skip the PBR texture pass (faster, untextured mesh)
+      --polycount <n>  target polygon count
+      --key <key>      Meshy API key (else MESHY_API_KEY / .env / test mode)
   stereoframe add <block> [dir]        install a visual block's assets + print usage
   stereoframe blocks                   list available blocks
   stereoframe update [dir]             refresh assets/stereoframe.js from the CLI's bundled runtime
@@ -679,11 +803,11 @@ async function main() {
       return;
     }
     case "lint": {
-      const htmlPath = join4(resolve6(dir), "index.html");
-      if (!existsSync4(htmlPath))
-        throw new Error(`no index.html in ${resolve6(dir)}`);
-      const findings = lintHtml(readFileSync(htmlPath, "utf8"), {
-        fileExists: (rel) => existsSync4(join4(resolve6(dir), rel))
+      const htmlPath = join5(resolve7(dir), "index.html");
+      if (!existsSync5(htmlPath))
+        throw new Error(`no index.html in ${resolve7(dir)}`);
+      const findings = lintHtml(readFileSync2(htmlPath, "utf8"), {
+        fileExists: (rel) => existsSync5(join5(resolve7(dir), rel))
       });
       reportFindings("lint", findings, options.get("json") === true);
       return;
@@ -711,6 +835,20 @@ async function main() {
       console.log("press ctrl-c to stop");
       return;
     }
+    case "gen": {
+      const prompt = positional.join(" ").trim();
+      if (!prompt)
+        throw new Error('usage: stereoframe gen "<prompt>"');
+      await genModel({
+        prompt,
+        projectDir: typeof options.get("dir") === "string" ? options.get("dir") : ".",
+        out: typeof options.get("out") === "string" ? options.get("out") : undefined,
+        texture: options.get("no-texture") !== true,
+        polycount: options.has("polycount") ? Number(options.get("polycount")) : undefined,
+        key: typeof options.get("key") === "string" ? options.get("key") : undefined
+      });
+      return;
+    }
     case "add": {
       const name = positional[0];
       if (!name)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stereoframe",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Declarative, deterministic 3D video on three.js — scaffold, lint, validate, and render compositions built for AI agents.",
   "license": "MIT",
   "repository": {
@@ -25,7 +25,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "stereoframe-runtime": "0.2.2",
+    "stereoframe-runtime": "0.2.4",
     "puppeteer": "^24.0.0"
   },
   "devDependencies": {