scad-gltf 0.1.4 → 0.2.2

package/bin/scad-mcp.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import fs from "fs";
 import path from "path";
+import os from "os";
+import { spawn, execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -11,6 +13,7 @@ import {
 import puppeteer from "puppeteer";
 import { convertScadToGltf } from "../src/convert.js";
 import { generatePrompt } from "../src/prompt.js";
+import { runGodotAsync } from "../src/godot-utils.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -38,7 +41,7 @@ global.fetch = async (url, options) => {
 const server = new Server(
   {
     name: "scad-mcp-server",
-    version: "1.2.0",
+    version: "1.3.0",
   },
   {
     capabilities: {
@@ -62,6 +65,88 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: "string",
               description: "The description of the object you want to design.",
             },
+            options: {
+              type: "object",
+              description:
+                "Optional feature toggles to customize the generated prompt syntax rules.",
+              properties: {
+                basic: {
+                  type: "boolean",
+                  description:
+                    "Include rules for basic PBR attributes: metalness and roughness. (Default: true)",
+                },
+                transmission: {
+                  type: "boolean",
+                  description:
+                    "Include rules for transparent/glass volumes: transmission, thickness, ior, attenuationColor, and attenuationDistance. (Default: true)",
+                },
+                clearcoat: {
+                  type: "boolean",
+                  description:
+                    "Include rules for clearcoat and clearcoatRoughness. (Default: true)",
+                },
+                sheen: {
+                  type: "boolean",
+                  description:
+                    "Include rules for cloth/velvet sheen: sheen, sheenColor, and sheenRoughness. (Default: true)",
+                },
+                emissive: {
+                  type: "boolean",
+                  description:
+                    "Include rules for glowing materials: emissive and emissiveIntensity. (Default: true)",
+                },
+                specular: {
+                  type: "boolean",
+                  description:
+                    "Include rules for specular reflections: specularColor and specularIntensity. (Default: true)",
+                },
+                iridescence: {
+                  type: "boolean",
+                  description:
+                    "Include rules for thin-film interference: iridescence and iridescenceIOR. (Default: true)",
+                },
+                autoSmoothAngle: {
+                  type: "boolean",
+                  description:
+                    "Include rules for smooth shading vertex normals via $asa. (Default: true)",
+                },
+                animation: {
+                  type: "boolean",
+                  description:
+                    "Include rules for hierarchical node animations using armature() and bone(). (Default: true)",
+                },
+                bakeColors: {
+                  type: "boolean",
+                  description:
+                    "Include rules for baking colors from high-poly onto low-poly meshes. (Default: false)",
+                },
+                bakeNormals: {
+                  type: "boolean",
+                  description:
+                    "Include rules for baking tangent-space normal maps. (Default: false)",
+                },
+                bakeOrm: {
+                  type: "boolean",
+                  description:
+                    "Include rules for baking Occlusion/Roughness/Metallic (ORM) textures. (Default: false)",
+                },
+                bakeUvs: {
+                  type: "boolean",
+                  description:
+                    "Include rules for generating textureless UV coordinates and tangents. (Default: false)",
+                },
+                lazyUnion: {
+                  type: "boolean",
+                  description:
+                    "Include rules for the lazy-union compiler optimization. (Default: false)",
+                },
+                modelName: {
+                  type: "boolean",
+                  description:
+                    "Include output instructions requiring the '/* Model Name: ... */' header comment. (Default: true)",
+                },
+              },
+            },
           },
           required: ["description"],
         },
@@ -104,10 +189,65 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               description:
                 "The index of the animation track to play if multiple exist. Default is 0.",
             },
+            return_images: {
+              type: "boolean",
+              description:
+                "Return image renderings of the model. Set to false for text-only validation (faster). Default is true.",
+            },
           },
           required: ["scad_code"],
         },
       },
+      {
+        name: "test_godot_project",
+        description:
+          "Runs a specified Godot project for a short duration to detect script errors, missing resources, or runtime crashes. Returns the console output logs and a visual screenshot of the gameplay.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project_dir: {
+              type: "string",
+              description:
+                "The relative or absolute path to the directory containing project.godot. Use this if the project is already extracted on disk.",
+            },
+            nodejs_script: {
+              type: "string",
+              description:
+                "The complete self-contained Node.js script that generates the Godot project. If provided, the tool will execute this script in a temporary directory to extract the project before testing it. Use this during the generation phase to test your code before providing the final answer.",
+            },
+            run_time: {
+              type: "number",
+              description:
+                "Time in seconds to run the project before terminating. Default is 5.0.",
+            },
+            return_images: {
+              type: "boolean",
+              description:
+                "Capture a screenshot of the project. Set to false for text-only logs (faster). Default is true.",
+            },
+          },
+        },
+      },
+      {
+        name: "compile_bevy_project",
+        description:
+          "Compiles a specified Rust Bevy project to detect syntax errors, missing dependencies, or compilation failures. Returns the cargo console output logs.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project_dir: {
+              type: "string",
+              description:
+                "The relative or absolute path to the directory containing Cargo.toml. Use this if the project is already extracted on disk.",
+            },
+            nodejs_script: {
+              type: "string",
+              description:
+                "The complete self-contained Node.js script that generates the Bevy project. If provided, the tool will execute this script in a temporary directory to extract the project before compiling it. Use this during the generation phase to test your code before providing the final answer.",
+            },
+          },
+        },
+      },
     ],
   };
 });
@@ -121,7 +261,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   // ------------------------------------------
   if (name === "get_scad_prompt") {
     try {
-      const promptText = generatePrompt(args.description, {});
+      const promptText = generatePrompt(args.description, args.options || {});
       return {
         content: [
           {
@@ -153,12 +293,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           : ["front", "top", "isometric"];
       const animTime = args.animation_time || 0.0;
       const animIndex = args.animation_index || 0;
+      const returnImages = args.return_images !== false;
 
       // 1. Convert SCAD to GLB ArrayBuffer
       const glbDataArray = await convertScadToGltf(scadCode, {
         wasmUrl: `file://${wasmPath}`,
       });
 
+      if (!returnImages) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully compiled SCAD without syntax errors. (Visual rendering skipped because return_images is false).`,
+            },
+          ],
+        };
+      }
+
       // Convert Uint8Array to base64
       const glbBase64 = Buffer.from(glbDataArray).toString("base64");
 
@@ -492,6 +644,493 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
   }
 
+  // ------------------------------------------
+  // TOOL 3: test_godot_project
+  // ------------------------------------------
+  if (name === "test_godot_project") {
+    let cleanupDir = null;
+    try {
+      let projectDir = null;
+      const runTime = args.run_time || 5.0;
+
+      if (args.nodejs_script) {
+        // Create a unique temporary directory
+        const tempBase = fs.mkdtempSync(
+          path.join(os.tmpdir(), "scad-godot-test-"),
+        );
+        cleanupDir = tempBase;
+
+        const scriptPath = path.join(tempBase, "generate.js");
+        fs.writeFileSync(scriptPath, args.nodejs_script, "utf-8");
+
+        try {
+          execSync(`node generate.js`, {
+            cwd: tempBase,
+            stdio: "pipe",
+            timeout: 15000, // Time out after 15 seconds if it hangs
+          });
+        } catch (err) {
+          const stderr = err.stderr ? err.stderr.toString() : "";
+          const stdout = err.stdout ? err.stdout.toString() : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: The Node.js script failed to execute properly.\n\nSTDERR:\n${stderr}\n\nSTDOUT:\n${stdout}\n\nException: ${err.message}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // Find the generated folder containing project.godot
+        const items = fs.readdirSync(tempBase);
+        for (const item of items) {
+          const itemPath = path.join(tempBase, item);
+          if (
+            fs.statSync(itemPath).isDirectory() &&
+            fs.existsSync(path.join(itemPath, "project.godot"))
+          ) {
+            projectDir = itemPath;
+            break;
+          }
+        }
+
+        if (!projectDir) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: The Node.js script finished running, but NO Godot project was found. A valid Godot project requires a 'project.godot' file. Ensure your script creates a root project directory and places 'project.godot' inside it.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      } else if (args.project_dir) {
+        projectDir = path.resolve(process.cwd(), args.project_dir);
+      } else {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Invalid arguments. You must provide either 'project_dir' or 'nodejs_script'.`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      if (!fs.existsSync(path.join(projectDir, "project.godot"))) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: The specified directory is not a valid Godot project. 'project.godot' was not found in: ${projectDir}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const returnImages = args.return_images !== false;
+
+      // 1. Headless Editor Import Step (Wait for Godot to import .scad and other assets)
+      const importResult = await runGodotAsync(
+        ["--headless", "--editor", "--quit", "--path", projectDir],
+        projectDir,
+        30000,
+      );
+
+      const projectGodotPath = path.join(projectDir, "project.godot");
+      const originalProjectGodot = fs.readFileSync(projectGodotPath, "utf8");
+      let playResult;
+
+      if (returnImages) {
+        // 1.5 Prepare Screenshot Autoload Script
+        const snapTime = Math.max(0.5, runTime - 0.5);
+
+        const screenshotScript = `extends Node
+func _ready():
+\tprint("[ScreenshotMCP] Autoload ready. Waiting ${snapTime} seconds...")
+\tawait get_tree().create_timer(${snapTime}).timeout
+\tvar ds = DisplayServer.get_name()
+\tprint("[ScreenshotMCP] DisplayServer is: ", ds)
+\tif ds != "headless":
+\t\tawait RenderingServer.frame_post_draw
+\t\tvar tex = get_viewport().get_texture()
+\t\tif tex != null:
+\t\t\tvar img = tex.get_image()
+\t\t\tif img != null and not img.is_empty():
+\t\t\t\tvar w = img.get_width()
+\t\t\t\tvar h = img.get_height()
+\t\t\t\tvar size = mini(w, h)
+\t\t\t\tvar x = (w - size) / 2
+\t\t\t\tvar y = (h - size) / 2
+\t\t\t\tvar cropped = img.get_region(Rect2i(x, y, size, size))
+\t\t\t\tvar path = ProjectSettings.globalize_path("res://screenshot_mcp.png")
+\t\t\t\tvar err = cropped.save_png(path)
+\t\t\t\tprint("[ScreenshotMCP] Save PNG to ", path, " returned error code: ", err)
+\t\t\telse:
+\t\t\t\tprint("[ScreenshotMCP] Error: Image is null or empty.")
+\t\telse:
+\t\t\tprint("[ScreenshotMCP] Error: Viewport texture is null.")
+\tget_tree().quit()
+`;
+        fs.writeFileSync(
+          path.join(projectDir, "screenshot_mcp.gd"),
+          screenshotScript,
+        );
+
+        let tempProjectGodot = originalProjectGodot;
+        if (tempProjectGodot.includes("[autoload]")) {
+          tempProjectGodot = tempProjectGodot.replace(
+            "[autoload]",
+            '[autoload]\nScreenshotMCP="*res://screenshot_mcp.gd"',
+          );
+        } else {
+          tempProjectGodot += `\n[autoload]\nScreenshotMCP="*res://screenshot_mcp.gd"\n`;
+        }
+        fs.writeFileSync(projectGodotPath, tempProjectGodot, "utf8");
+
+        // 2. Play Game Step
+        // Always try windowed first to get the screenshot.
+        // If the environment lacks a display server, we'll catch the error and fallback.
+        let playArgs = [
+          "--windowed", // Use windowed instead of headless to ensure rendering works for screenshot
+          "--resolution",
+          "512x512",
+          "--audio-driver",
+          "Dummy",
+          "--path",
+          projectDir,
+        ];
+
+        playResult = await runGodotAsync(
+          playArgs,
+          projectDir,
+          // Give Godot extra buffer time to boot, take the shot, and quit gracefully
+          runTime * 1000 + 5000,
+        );
+
+        let windowedOutput = playResult.output;
+
+        // Fallback if windowed mode fails due to display server issues
+        if (
+          playResult.code !== 0 &&
+          (playResult.output.includes("Unable to create DisplayServer") ||
+            playResult.output.includes("Display driver"))
+        ) {
+          playResult = await runGodotAsync(
+            ["--headless", "--audio-driver", "Dummy", "--path", projectDir],
+            projectDir,
+            runTime * 1000,
+          );
+          // Explicitly inject the display error into the final output so we aren't flying blind!
+          playResult.output =
+            "--- WINDOWED LAUNCH FAILED (Display Error) ---\n" +
+            windowedOutput.trim() +
+            "\n\n--- FALLBACK HEADLESS LAUNCH ---\n" +
+            playResult.output;
+        }
+
+        // 3. Cleanup Autoloads
+        fs.writeFileSync(projectGodotPath, originalProjectGodot, "utf8");
+        if (fs.existsSync(path.join(projectDir, "screenshot_mcp.gd"))) {
+          fs.unlinkSync(path.join(projectDir, "screenshot_mcp.gd"));
+        }
+      } else {
+        // Text-only mode: Run headless immediately
+        playResult = await runGodotAsync(
+          ["--headless", "--audio-driver", "Dummy", "--path", projectDir],
+          projectDir,
+          runTime * 1000,
+        );
+      }
+
+      // 4. Read Screenshot
+      let screenshotBase64 = null;
+      if (returnImages) {
+        const screenshotPath = path.join(projectDir, "screenshot_mcp.png");
+        if (fs.existsSync(screenshotPath)) {
+          screenshotBase64 = fs.readFileSync(screenshotPath).toString("base64");
+          fs.unlinkSync(screenshotPath); // Remove the image after reading
+        }
+      }
+
+      // Format Text Output
+      const fullOutput =
+        "--- IMPORT PHASE ---\n" +
+        importResult.output +
+        "\n\n--- PLAY PHASE ---\n" +
+        playResult.output;
+
+      const errorLines = fullOutput
+        .split("\n")
+        .filter(
+          (line) =>
+            line.includes("ERROR:") ||
+            line.includes("SCRIPT ERROR:") ||
+            line.includes("Parse Error:"),
+        );
+
+      let responseText = `Godot Import Exit Code: ${importResult.code}\nGodot Play Exit Code: ${playResult.code}\n\n`;
+
+      if (errorLines.length > 0) {
+        responseText +=
+          "🚨 Errors detected in Godot output:\n" +
+          errorLines.join("\n") +
+          "\n\n";
+      } else {
+        responseText +=
+          "✅ No obvious errors detected in the Godot output log.\n\n";
+      }
+
+      const maxOutputLen = 4000;
+      let truncatedOutput = fullOutput;
+      if (fullOutput.length > maxOutputLen) {
+        truncatedOutput = fullOutput.substring(
+          fullOutput.length - maxOutputLen,
+        );
+        responseText += `...[truncated]...\n`;
+      }
+      responseText += truncatedOutput;
+
+      // 5. Construct Final MCP Response
+      const responseContent = [
+        {
+          type: "text",
+          text: responseText,
+        },
+      ];
+
+      // If screenshot was captured successfully, attach it
+      if (returnImages) {
+        if (screenshotBase64) {
+          responseContent.push({
+            type: "image",
+            data: screenshotBase64,
+            mimeType: "image/png",
+          });
+        } else {
+          responseContent.push({
+            type: "text",
+            text: "⚠️ A visual screenshot could not be captured (Godot may have crashed immediately or rendering failed).",
+          });
+        }
+      }
+
+      return {
+        content: responseContent,
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error testing Godot project: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    } finally {
+      // Clean up temporary directory if we created one
+      if (cleanupDir && fs.existsSync(cleanupDir)) {
+        try {
+          fs.rmSync(cleanupDir, { recursive: true, force: true });
+        } catch (e) {
+          console.error(`Failed to clean up temp dir: ${cleanupDir}`, e);
+        }
+      }
+    }
+  }
+
+  // ------------------------------------------
+  // TOOL 4: compile_bevy_project
+  // ------------------------------------------
+  if (name === "compile_bevy_project") {
+    let cleanupDir = null;
+    try {
+      let projectDir = null;
+
+      if (args.nodejs_script) {
+        // Create a unique temporary directory
+        const tempBase = fs.mkdtempSync(
+          path.join(os.tmpdir(), "scad-bevy-compile-"),
+        );
+        cleanupDir = tempBase;
+
+        const scriptPath = path.join(tempBase, "generate.js");
+        fs.writeFileSync(scriptPath, args.nodejs_script, "utf-8");
+
+        try {
+          execSync(`node generate.js`, {
+            cwd: tempBase,
+            stdio: "pipe",
+            timeout: 15000, // Time out after 15 seconds if it hangs
+          });
+        } catch (err) {
+          const stderr = err.stderr ? err.stderr.toString() : "";
+          const stdout = err.stdout ? err.stdout.toString() : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: The Node.js script failed to execute properly.\n\nSTDERR:\n${stderr}\n\nSTDOUT:\n${stdout}\n\nException: ${err.message}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // Find the generated folder containing Cargo.toml
+        const items = fs.readdirSync(tempBase);
+        for (const item of items) {
+          const itemPath = path.join(tempBase, item);
+          if (
+            fs.statSync(itemPath).isDirectory() &&
+            fs.existsSync(path.join(itemPath, "Cargo.toml"))
+          ) {
+            projectDir = itemPath;
+            break;
+          }
+        }
+
+        if (!projectDir) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: The Node.js script finished running, but NO Bevy project was found. A valid Rust Bevy project requires a 'Cargo.toml' file. Ensure your script creates a root project directory and places 'Cargo.toml' inside it.`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      } else if (args.project_dir) {
+        projectDir = path.resolve(process.cwd(), args.project_dir);
+      } else {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Invalid arguments. You must provide either 'project_dir' or 'nodejs_script'.`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      if (!fs.existsSync(path.join(projectDir, "Cargo.toml"))) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: The specified directory is not a valid Rust Bevy project. 'Cargo.toml' was not found in: ${projectDir}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const runCargoAsync = () =>
+        new Promise((resolve) => {
+          const cargoCmd = process.platform === "win32" ? "cargo.exe" : "cargo";
+          const child = spawn(cargoCmd, ["check"], {
+            cwd: projectDir,
+          });
+
+          let output = "";
+          if (child.stdout)
+            child.stdout.on("data", (data) => (output += data.toString()));
+          if (child.stderr)
+            child.stderr.on("data", (data) => (output += data.toString()));
+
+          child.on("error", (error) => {
+            output += `\nError launching cargo: ${error.message}`;
+            resolve({ code: 1, output });
+          });
+
+          child.on("close", (code) => {
+            resolve({ code, output });
+          });
+
+          // 2-minute timeout for Bevy compilation (can be slow as dependencies download)
+          setTimeout(() => {
+            try {
+              child.kill();
+            } catch (e) {}
+            output += "\n--- COMPILATION TIMED OUT (2 minutes) ---";
+            resolve({ code: 1, output });
+          }, 120000);
+        });
+
+      const compileResult = await runCargoAsync();
+      const compileOutput = compileResult.output;
+      const compileCode = compileResult.code;
+
+      const fullOutput = "--- CARGO CHECK ---\n" + compileOutput.trim();
+
+      const errorLines = fullOutput
+        .split("\n")
+        .filter(
+          (line) =>
+            line.includes("error:") ||
+            line.includes("error[E") ||
+            line.includes("could not compile"),
+        );
+
+      let responseText = `Cargo Check Exit Code: ${compileCode}\n\n`;
+
+      if (compileCode !== 0 || errorLines.length > 0) {
+        responseText +=
+          "🚨 Errors detected in Cargo output:\n" +
+          errorLines.join("\n") +
+          "\n\n";
+      } else {
+        responseText +=
+          "✅ No obvious errors detected. Project checked successfully.\n\n";
+      }
+
+      const maxOutputLen = 4000;
+      let truncatedOutput = fullOutput;
+      if (fullOutput.length > maxOutputLen) {
+        truncatedOutput = fullOutput.substring(
+          fullOutput.length - maxOutputLen,
+        );
+        responseText += `...[truncated]...\n`;
+      }
+      responseText += truncatedOutput;
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: responseText,
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error compiling Bevy project: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    } finally {
+      if (cleanupDir && fs.existsSync(cleanupDir)) {
+        try {
+          fs.rmSync(cleanupDir, { recursive: true, force: true });
+        } catch (e) {
+          console.error(`Failed to clean up temp dir: ${cleanupDir}`, e);
+        }
+      }
+    }
+  }
+
   throw new Error(`Tool not found: ${name}`);
 });