scad-gltf 0.1.0

package/bin/scad-serve.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import express from "express";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { execSync } from "child_process";
+import { convertScadToGltf } from "../src/convert.js";
+
+// Resolve the local paths
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const wasmPath = path.resolve(__dirname, "../src/ext/openscad.wasm");
+const editorDir = path.resolve(__dirname, "../editor");
+const editorDistDir = path.join(editorDir, "dist");
+
+// Polyfill fetch so the WASM loader works natively in Node.js
+const originalFetch = global.fetch;
+global.fetch = async (url, options) => {
+  const urlStr = url.toString();
+  if (urlStr.startsWith("file://") || urlStr.endsWith(".wasm")) {
+    const normalizedPath = urlStr.startsWith("file://")
+      ? fileURLToPath(urlStr)
+      : urlStr;
+
+    const buffer = fs.readFileSync(normalizedPath);
+    return new Response(buffer, {
+      status: 200,
+      headers: { "Content-Type": "application/wasm" },
+    });
+  }
+  return originalFetch ? originalFetch(url, options) : undefined;
+};
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+let port = 3000;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--port") {
+    port = parseInt(args[i + 1]) || 3000;
+    i++; // Skip the port number value
+  }
+}
+
+// Target directory is the current working directory where the script is run
+const workDir = process.cwd();
+
+// ========================
+// Editor Build Step (Only if dist is missing)
+// ========================
+if (!fs.existsSync(editorDistDir) && fs.existsSync(editorDir)) {
+  console.log("⚙️  Editor build missing. Attempting to build...");
+  try {
+    if (!fs.existsSync(path.join(editorDir, "node_modules"))) {
+      console.log("📦 Installing editor dependencies...");
+      execSync("npm install", { cwd: editorDir, stdio: "inherit" });
+    }
+
+    console.log("🛠️  Building editor...");
+    execSync("npm run build", { cwd: editorDir, stdio: "inherit" });
+    console.log("✅ Editor built successfully.\n");
+  } catch (err) {
+    console.error("❌ Error building editor:", err.message);
+    console.log("⚠️  Continuing without an editor build...\n");
+  }
+}
+
+const app = express();
+// Increase payload limit in case of very large SCAD files
+app.use(express.json({ limit: "50mb" }));
+
+// Basic CORS middleware for external web clients
+app.use((req, res, next) => {
+  res.header("Access-Control-Allow-Origin", "*");
+  res.header(
+    "Access-Control-Allow-Methods",
+    "GET, PUT, POST, PATCH, DELETE, OPTIONS",
+  );
+  res.header("Access-Control-Allow-Headers", "Content-Type");
+  if (req.method === "OPTIONS") return res.sendStatus(200);
+  next();
+});
+
+// Helper: Sanitize filename to prevent directory traversal attacks
+function sanitizeFilename(filename) {
+  const safeName = path.basename(filename);
+  return safeName.endsWith(".scad") ? safeName : `${safeName}.scad`;
+}
+
+// ========================
+// SCAD File Management API
+// ========================
+
+// 1. List all .scad files in the current directory
+app.get("/api/scads", (req, res) => {
+  try {
+    const files = fs
+      .readdirSync(workDir)
+      .filter(
+        (file) =>
+          file.toLowerCase().endsWith(".scad") &&
+          fs.statSync(path.join(workDir, file)).isFile(),
+      );
+
+    res.json({ files });
+  } catch (err) {
+    console.error("Error reading directory:", err);
+    res.status(500).json({ error: "Failed to list files." });
+  }
+});
+
+// 2. Read specific .scad file content
+app.get("/api/scads/:filename", (req, res) => {
+  const filename = sanitizeFilename(req.params.filename);
+  const filePath = path.join(workDir, filename);
+
+  if (!fs.existsSync(filePath)) {
+    return res.status(404).json({ error: `File '${filename}' not found.` });
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    res.json({ filename, content });
+  } catch (err) {
+    console.error(`Error reading ${filename}:`, err);
+    res.status(500).json({ error: "Failed to read file." });
+  }
+});
+
+// 3. Create or Update a .scad file
+app.post("/api/scads", (req, res) => {
+  const { filename: rawFilename, content } = req.body;
+
+  if (!rawFilename) {
+    return res
+      .status(400)
+      .json({ error: "Missing 'filename' in request body." });
+  }
+
+  const filename = sanitizeFilename(rawFilename);
+  const filePath = path.join(workDir, filename);
+  const isUpdate = fs.existsSync(filePath);
+
+  try {
+    fs.writeFileSync(filePath, content || "", "utf-8");
+    res.json({
+      message: isUpdate
+        ? "File updated successfully"
+        : "File created successfully",
+      filename,
+    });
+  } catch (err) {
+    console.error(`Error writing to ${filename}:`, err);
+    res.status(500).json({ error: "Failed to write file." });
+  }
+});
+
+// 4. Delete a .scad file
+app.delete("/api/scads/:filename", (req, res) => {
+  const filename = sanitizeFilename(req.params.filename);
+  const filePath = path.join(workDir, filename);
+
+  if (!fs.existsSync(filePath)) {
+    return res.status(404).json({ error: `File '${filename}' not found.` });
+  }
+
+  try {
+    fs.unlinkSync(filePath);
+    res.json({ message: "File deleted successfully", filename });
+  } catch (err) {
+    console.error(`Error deleting ${filename}:`, err);
+    res.status(500).json({ error: "Failed to delete file." });
+  }
+});
+
+// 5. Convert SCAD to GLB
+app.post("/api/convert", async (req, res) => {
+  const { content, options } = req.body;
+
+  const additionalFiles = (options && options.additionalFiles) || {};
+
+  if (!content) {
+    return res
+      .status(400)
+      .json({ error: "Missing 'content' in request body." });
+  }
+
+  try {
+    // Pass the raw SCAD directly to the WASM converter entirely in-memory
+    const glbData = await convertScadToGltf(content, {
+      wasmUrl: pathToFileURL(wasmPath).href,
+      additionalFiles,
+      variables: (options && options.variables) || undefined,
+    });
+
+    res.setHeader("Content-Type", "model/gltf-binary");
+    res.send(Buffer.from(glbData));
+  } catch (err) {
+    console.error("SCAD Conversion Error:", err);
+    res
+      .status(500)
+      .json({ error: "Failed to convert SCAD to GLB: " + err.toString() });
+  }
+});
+
+// ========================
+// Serve Built Editor UI
+// ========================
+if (fs.existsSync(editorDistDir)) {
+  // Serve the static files exactly how Vite bundled them
+  app.use(express.static(editorDistDir));
+} else {
+  console.warn(
+    "⚠️  Editor dist directory not found. Editor UI will not be available.",
+  );
+}
+
+// Start Server
+app.listen(port, () => {
+  console.log(`🚀 scad-serve listening on http://localhost:${port}`);
+  if (fs.existsSync(editorDistDir)) {
+    console.log(`🌐 Editor available at: http://localhost:${port}/`);
+  }
+  console.log(`📁 Managing .scad files in directory: ${workDir}`);
+});

package/bin/scad-web.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+import readline from "node:readline";
+
+// Safely resolve symlinks to find the actual package directory
+const __filename = fs.realpathSync(url.fileURLToPath(import.meta.url));
+const __dirname = path.dirname(__filename);
+const DIR = path.resolve(__dirname, "..");
+
+// Safely detect if actual data is being piped into the script via STDIN
+function hasStdinData() {
+  try {
+    const stat = fs.fstatSync(0); // 0 is the file descriptor for STDIN
+    // isFIFO means piped (echo "foo" | script)
+    // isFile means redirected (script < foo.txt)
+    return stat.isFIFO() || stat.isFile();
+  } catch (e) {
+    return false;
+  }
+}
+
+// Writes text to system clipboard
+async function writeToClipboard(text) {
+  const clipboardy = (await import("clipboardy")).default;
+  await clipboardy.write(text);
+}
+
+function waitForEnter(message) {
+  return new Promise((resolve) => {
+    // If standard input was piped/redirected, we need to bypass it and read from the actual terminal
+    if (!process.stdin.isTTY) {
+      try {
+        const tty = process.platform === "win32" ? "CONIN$" : "/dev/tty";
+        const fd = fs.openSync(tty, "rs");
+        process.stdout.write(message);
+        const buf = Buffer.alloc(1);
+        fs.readSync(fd, buf, 0, 1, null);
+        fs.closeSync(fd);
+        console.log();
+        resolve();
+        return;
+      } catch (e) {
+        console.log(
+          message +
+            " (Auto-continuing due to non-interactive terminal environment)",
+        );
+        resolve();
+        return;
+      }
+    }
+
+    // For standard TTY terminals
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(message, () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+async function main() {
+  let task = "";
+  let optionsStr = "{}";
+
+  // 1. Read TASK and OPTIONS
+  if (hasStdinData()) {
+    try {
+      task = fs.readFileSync(0, "utf-8").trim();
+    } catch (e) {
+      console.error("Error reading from STDIN:", e);
+    }
+    if (process.argv[2]) optionsStr = process.argv[2];
+  } else {
+    if (process.argv[2]) task = process.argv[2];
+    if (process.argv[3]) optionsStr = process.argv[3];
+  }
+
+  if (!task) {
+    console.error("Error: Task parameter is required.");
+    console.error(
+      'Usage: scad-web "<description of the web app to generate>" [options_json]',
+    );
+    console.error('   or: echo "<description>" | scad-web [options_json]');
+    console.error("");
+    console.error("Example with JSON options:");
+    console.error(
+      '  scad-web "3D Car Configurator Web App" \'{"animation": false}\'',
+    );
+    process.exit(1);
+  }
+
+  // 2. Parse Options JSON
+  let options = {};
+  if (optionsStr) {
+    try {
+      options = JSON.parse(optionsStr);
+    } catch (e) {
+      console.error(`Invalid JSON options: ${optionsStr}`);
+      process.exit(1);
+    }
+  }
+
+  // Disable the modelName instructions specifically for this wrapper context
+  options.modelName = false;
+
+  // 3. Dynamically import and generate prompt rules from src/prompt.js
+  let generatePrompt;
+  try {
+    const promptJsPath = path.join(DIR, "src", "prompt.js");
+    const promptModuleUrl = url.pathToFileURL(promptJsPath).href;
+    const m = await import(promptModuleUrl);
+    generatePrompt = m.generatePrompt;
+  } catch (e) {
+    console.error(`Error loading ${path.join("src", "prompt.js")}:`, e);
+    process.exit(1);
+  }
+
+  let promptRules = "";
+  try {
+    promptRules = generatePrompt("the 3D assets for the web app", options);
+  } catch (e) {
+    console.error("Error generating prompt rules from prompt.js:");
+    console.error(e);
+    process.exit(1);
+  }
+
+  // 4. Construct the Main Web Prompt System Text (System Instructions)
+  const systemPrompt = `You are an expert Web 3D developer and procedural 3D technical artist.
+
+What to generate:
+1. 3D Web Assets (.scad):
+   - Generate procedural 3D models for the web app using OpenSCAD.
+   - CRITICAL: The SCAD to glTF converter automatically converts OpenSCAD's Z-up coordinate system to the standard glTF Y-up coordinate system. Design your models naturally in OpenSCAD.
+   - CRITICAL: You must use the custom OpenSCAD glTF extensions for PBR materials (e.g., \`roughness\`, \`metalness\`, \`emissive\`) and Skeletal Animations (\`armature()\`, \`bone()\`). The rules and syntax for these features are provided below:
+
+=== OPENSCAD SYNTAX RULES ===
+${promptRules}
+=============================
+
+2. Vite Web Project Files (npm based):
+   - Create the necessary files for a modern web application (e.g., \`package.json\`, \`index.html\`, \`main.js\`).
+   - You can use ANY web 3D library with glTF support (e.g., Three.js, Babylon.js, @google/model-viewer, PlayCanvas, A-Frame, etc.) that fits the app's requirements.
+   - In \`package.json\`, you MUST include the scad to gltf converter tool as a dev dependency:
+     \`"scad-gltf": "^0.1.0"\`
+   - In \`package.json\`, add npm scripts to automatically compile the \`.scad\` files into \`.glb\` format inside the \`public/\` folder before Vite runs its dev or build steps.
+     For example:
+     \`"predev": "scad-convert ./scad ./public/models --cache"\`
+     \`"prebuild": "scad-convert ./scad ./public/models --cache"\`
+   - Write the core application logic to load and display the converted \`.glb\` files interactively.
+
+3. Delivery Format (Single Node.js Script):
+   - Output exactly ONE self-contained Node.js script. Do not output manual setup instructions.
+   - CRITICAL: The generated Node.js script MUST first create a root project folder (named using a slugified version of the project name) and output all files and folders inside this newly created project folder.
+   - When executed, this script must programmatically create the entire project directory structure and write all the files to disk using the \`fs\` module.
+   - The script must embed and write:
+     - Your generated \`.scad\` 3D assets.
+     - Your generated Vite web project files.
+   - Ensure all string file contents inside the Node.js script are properly escaped.`;
+
+  // 5. Format the unified system instructions clipboard output
+  let systemClipboardOutput = `### SYSTEM_PROMPT\n---\n\`\`\`\n${systemPrompt}\n\`\`\`\n\n`;
+
+  // 6. Format the input request output
+  const inputRequestOutput = `Input Task:\nDesign and implement a web-based 3D glTF app using Vite for the following concept: "${task}"`;
+
+  // 7. Write to System Clipboard (Part 1: System Instructions)
+  try {
+    await writeToClipboard(systemClipboardOutput);
+    console.log("✔️  System instructions have been copied to the clipboard.");
+  } catch (err) {
+    console.error(
+      "Error: Failed to copy system instructions to the clipboard.",
+    );
+    console.error(err.message);
+    process.exit(1);
+  }
+
+  // 8. Await user confirmation
+  await waitForEnter(
+    "Please paste the system instructions into your LLM, then press ENTER to copy your input request...",
+  );
+
+  // 9. Write to System Clipboard (Part 2: Input Request)
+  try {
+    await writeToClipboard(inputRequestOutput);
+    console.log(
+      "✔️  Input request has been copied to the clipboard. You can now paste it into your LLM.",
+    );
+  } catch (err) {
+    console.error("Error: Failed to copy input request to the clipboard.");
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+// Execute and handle unhandled runtime errors
+main().catch((err) => {
+  console.error("An unexpected error occurred:", err);
+  process.exit(1);
+});