mcp-3d-printer-server 1.2.9 → 1.2.12

package/dist/3mf_parser.js

@@ -85,7 +85,7 @@ async function parseBambuConfig(zip) {
         if (file) {
             configFile = file;
             configContent = await file.async('string');
-            console.log(`Found Bambu config file: ${configFile.name}`);
+            console.error(`Found Bambu config file: ${configFile.name}`);
             break; // Use the first one found (project usually has the most)
         }
     }
@@ -94,7 +94,7 @@ async function parseBambuConfig(zip) {
             // Attempt to parse as JSON
             const jsonData = JSON.parse(configContent);
             const parsedConfig = parseBambuJSONConfig(jsonData);
-            console.log('Bambu config parsed successfully as JSON.');
+            console.error('Bambu config parsed successfully as JSON.');
             return parsedConfig;
         }
         catch (jsonError) {
@@ -102,7 +102,7 @@ async function parseBambuConfig(zip) {
             // Fallback: Try parsing as INI if JSON fails (though unlikely based on sample)
             try {
                 const parsedConfig = parseFallbackINIConfig(configContent); // Keep a simple INI parser as fallback
-                console.log('Bambu config parsed successfully as INI (fallback).');
+                console.error('Bambu config parsed successfully as INI (fallback).');
                 return parsedConfig;
             }
             catch (iniError) {
@@ -112,7 +112,7 @@ async function parseBambuConfig(zip) {
         }
     }
     else {
-        console.log('No Bambu-specific config file found in Metadata directory.');
+        console.error('No Bambu-specific config file found in Metadata directory.');
         return {};
     }
 }
@@ -181,7 +181,7 @@ async function parse3DModelConfig(zip) {
                 });
             });
         }
-        console.log('3dmodel.model parsed successfully.');
+        console.error('3dmodel.model parsed successfully.');
         return { metadata, objects, build: { items: buildItems } };
     }
     catch (error) {
@@ -190,13 +190,13 @@ async function parse3DModelConfig(zip) {
     }
 }
 export async function parse3MF(filePath) {
-    console.log(`Parsing 3MF file: ${filePath}`);
+    console.error(`Parsing 3MF file: ${filePath}`);
     try {
         const data = await fs.readFile(filePath);
         const zip = await JSZip.loadAsync(data);
         // List files for debugging
         // const fileList = Object.keys(zip.files);
-        // console.log('Files in 3MF:', fileList);
+        // console.error('Files in 3MF:', fileList);
         const { metadata, objects, build } = await parse3DModelConfig(zip);
         const bambuConfig = await parseBambuConfig(zip);
         // Combine data into the final structure
@@ -206,7 +206,7 @@ export async function parse3MF(filePath) {
             build,
             slicerConfig: bambuConfig
         };
-        console.log('3MF parsing completed.');
+        console.error('3MF parsing completed.');
         return combinedData;
     }
     catch (error) {

package/dist/blender-mcp-bridge.d.ts

@@ -4,6 +4,7 @@ export declare class BlenderMcpBridge {
     private session;
     private invoke;
     status(args: Arguments, signal?: AbortSignal): Promise<unknown>;
+    exportStl(args: Arguments, signal?: AbortSignal): Promise<unknown>;
     call(args: Arguments, signal?: AbortSignal): Promise<CallToolResult>;
     edit(args: Arguments, legacyCommand?: string, signal?: AbortSignal): Promise<unknown>;
 }

package/dist/blender-mcp-bridge.js

@@ -13,6 +13,7 @@ const execAsync = promisify(exec);
 const MAX_STL_BYTES = 256 * 1024 * 1024;
 const MAX_ASCII_STL_BYTES = 4 * 1024 * 1024;
 const RECEIPT_PREFIX = "BAMBU_STL_RESULT:";
+const EXPORT_RECEIPT_PREFIX = "MCP3D_STL_EXPORT:";
 class BlenderError extends Error {
 }
 function editDeadline(timeout, signal) {
@@ -65,7 +66,7 @@ function timeoutMilliseconds(value) {
 function standardConfiguration() {
     const command = process.env.BLENDER_MCP_COMMAND?.trim();
     if (!command)
-        throw new BlenderError("No Blender MCP server configured. Set BLENDER_MCP_COMMAND to an executable and BLENDER_MCP_ARGS to a JSON string array (for example uvx and [\"blender-mcp\"]). Start the matching addon in Blender.");
+        throw new BlenderError("No Blender MCP server configured. Set BLENDER_MCP_COMMAND to an executable and BLENDER_MCP_ARGS to a JSON string array (for example uvx and [\"mcp-for-blender\"]; the older blender-mcp package name still works). Open Blender with the matching addon connected; the addon does not run in background mode.");
     let args;
     try {
         args = JSON.parse(process.env.BLENDER_MCP_ARGS?.trim() || "[]");
@@ -109,6 +110,14 @@ function normalizeToolFailure(result) {
     });
     return failed ? { ...result, isError: true } : result;
 }
+function boundingBox(min, max) {
+    const round = (value) => Math.round(value * 1e4) / 1e4;
+    return {
+        min: [round(min[0]), round(min[1]), round(min[2])],
+        max: [round(max[0]), round(max[1]), round(max[2])],
+        dimensions: [round(max[0] - min[0]), round(max[1] - min[1]), round(max[2] - min[2])],
+    };
+}
 async function regularStl(filePath, deadline) {
     deadline.check();
     const stat = await fs.lstat(filePath).catch(() => { throw new BlenderError("STL file does not exist or is not readable."); });
@@ -140,18 +149,26 @@ async function regularStl(filePath, deadline) {
             // Validate binary records directly; constructing a Three.js geometry would
             // expand a 256 MiB input into hundreds of MiB of positions/normals/colors.
             const chunk = Buffer.alloc(50 * 1024);
+            const min = [Infinity, Infinity, Infinity];
+            const max = [-Infinity, -Infinity, -Infinity];
             for (let position = 84; position < stat.size; position += chunk.length) {
                 const length = Math.min(chunk.length, stat.size - position);
                 await read(chunk, position, length);
                 for (let face = 0; face < length; face += 50) {
                     for (let coordinate = 12; coordinate < 48; coordinate += 4) {
-                        if (!Number.isFinite(chunk.readFloatLE(face + coordinate)))
+                        const value = chunk.readFloatLE(face + coordinate);
+                        if (!Number.isFinite(value))
                             throw new Error("invalid vertices");
+                        const axis = ((coordinate - 12) / 4) % 3;
+                        if (value < min[axis])
+                            min[axis] = value;
+                        if (value > max[axis])
+                            max[axis] = value;
                     }
                 }
             }
             deadline.check();
-            return { bytes: stat.size, triangles };
+            return { bytes: stat.size, triangles, bounding_box: boundingBox(min, max) };
         }
         // Reject malformed binary headers before a parser can allocate arrays from
         // an untrusted triangle count. ASCII parsing has its own smaller bound.
@@ -169,8 +186,10 @@ async function regularStl(filePath, deadline) {
         const positions = geometry.getAttribute("position");
         if (!positions || positions.count < 3 || positions.count % 3 !== 0 || !positions.array.every(Number.isFinite))
             throw new Error("invalid vertices");
+        geometry.computeBoundingBox();
+        const box = geometry.boundingBox;
         deadline.check();
-        return { bytes: stat.size, triangles: positions.count / 3 };
+        return { bytes: stat.size, triangles: positions.count / 3, bounding_box: boundingBox(box.min.toArray(), box.max.toArray()) };
     }
     catch (error) {
         if (error instanceof BlenderError)
@@ -193,20 +212,7 @@ async function inputPath(value, label, deadline) {
 }
 async function editPlan(args, deadline) {
     const stlPath = await inputPath(args.stl_path, "stl_path", deadline);
-    const requestedOutput = args.output_path === undefined
-        ? path.join(path.dirname(stlPath), `model-edited-${randomUUID()}.stl`)
-        : path.resolve(textArgument(args.output_path, "output_path"));
-    if (path.extname(requestedOutput).toLowerCase() !== ".stl")
-        throw new BlenderError("output_path must name a new STL file.");
-    const directory = await fs.realpath(path.dirname(requestedOutput)).catch(() => { throw new BlenderError("output_path parent directory must already exist."); });
-    const outputPath = path.join(directory, path.basename(requestedOutput));
-    const existing = await fs.lstat(outputPath).catch((error) => {
-        if (error.code !== "ENOENT")
-            throw new BlenderError("output_path cannot be accessed.");
-        return undefined;
-    });
-    if (existing)
-        throw new BlenderError("output_path already exists; choose a new file. Input files are never overwritten.");
+    const { outputPath, directory } = await newStlOutput(args.output_path ?? path.join(path.dirname(stlPath), `model-edited-${randomUUID()}.stl`), deadline);
     const operations = [];
     for (const operation of args.operations) {
         deadline.check();
@@ -229,6 +235,120 @@ async function editPlan(args, deadline) {
     const requestId = randomUUID();
     return { requestId, stlPath, outputPath, stagedOutputPath: path.join(directory, `.bambu-${requestId}.stl`), operations };
 }
+async function newStlOutput(value, deadline) {
+    deadline.check();
+    const requestedOutput = path.resolve(textArgument(value, "output_path"));
+    if (path.extname(requestedOutput).toLowerCase() !== ".stl")
+        throw new BlenderError("output_path must name a new STL file.");
+    const directory = await fs.realpath(path.dirname(requestedOutput)).catch(() => { throw new BlenderError("output_path parent directory must already exist."); });
+    const outputPath = path.join(directory, path.basename(requestedOutput));
+    const existing = await fs.lstat(outputPath).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw new BlenderError("output_path cannot be accessed.");
+        return undefined;
+    });
+    if (existing)
+        throw new BlenderError("output_path already exists; choose a new file. Existing files are never overwritten.");
+    return { outputPath, directory };
+}
+async function exportPlan(args, deadline) {
+    const names = args.object_names;
+    if (!Array.isArray(names) || names.length === 0 || names.length > 64 ||
+        names.some((name) => typeof name !== "string" || !name.trim() || name.length > 256 || name.includes("\0")) ||
+        new Set(names).size !== names.length) {
+        throw new BlenderError("object_names must list 1 to 64 distinct Blender object names.");
+    }
+    const scale = args.scale ?? 1;
+    if (typeof scale !== "number" || !Number.isFinite(scale) || scale <= 0 || scale > 1000000)
+        throw new BlenderError("scale must be a finite number greater than 0.");
+    const { outputPath, directory } = await newStlOutput(args.output_path, deadline);
+    const requestId = randomUUID();
+    return { requestId, objectNames: names, outputPath, stagedOutputPath: path.join(directory, `.mcp3d-${requestId}.stl`),
+        applyModifiers: booleanArgument(args.apply_modifiers, "apply_modifiers", true), scale };
+}
+function exportScript(plan) {
+    // Writes world-space triangles directly instead of calling an exporter, so the
+    // user's selection, active object and mode are never changed. JSON is data only.
+    return `# MCP3D_EXPORT_PLAN ${JSON.stringify(plan)}
+import bpy
+import json
+import math
+import os
+import struct
+
+def _mcp3d_export():
+    plan = json.loads(${JSON.stringify(JSON.stringify(plan))})
+    if bpy.context.mode != 'OBJECT':
+        raise RuntimeError('Switch Blender to Object Mode before exporting an STL')
+    objects = []
+    for name in plan['objectNames']:
+        obj = bpy.data.objects.get(name)
+        if obj is None:
+            raise RuntimeError('No Blender object named ' + json.dumps(name))
+        if obj.type not in {'MESH', 'CURVE', 'SURFACE', 'META', 'FONT'}:
+            raise RuntimeError(json.dumps(name) + ' is a ' + obj.type + ' object, not printable geometry')
+        if not plan['applyModifiers'] and obj.type != 'MESH':
+            raise RuntimeError(json.dumps(name) + ' needs apply_modifiers to be converted to a mesh')
+        objects.append(obj)
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    scale = float(plan['scale'])
+    lower = [math.inf] * 3
+    upper = [-math.inf] * 3
+    triangles = 0
+    exported = []
+    finished = False
+    try:
+        with open(plan['stagedOutputPath'], 'xb') as handle:
+            handle.write(b'mcp-3d-printer-server Blender STL export'.ljust(80, b' '))
+            handle.write(struct.pack('<I', 0))
+            for obj in objects:
+                evaluated = obj.evaluated_get(depsgraph)
+                matrix = evaluated.matrix_world
+                owner = evaluated if plan['applyModifiers'] else None
+                mesh = evaluated.to_mesh() if owner else obj.data.copy()
+                try:
+                    mesh.calc_loop_triangles()
+                    mirrored = matrix.determinant() < 0
+                    count = 0
+                    for tri in mesh.loop_triangles:
+                        points = [matrix @ mesh.vertices[index].co * scale for index in tri.vertices]
+                        if mirrored:
+                            points = [points[0], points[2], points[1]]
+                        for point in points:
+                            for axis in range(3):
+                                value = point[axis]
+                                if not math.isfinite(value):
+                                    raise RuntimeError('Non-finite vertex in ' + json.dumps(obj.name))
+                                lower[axis] = min(lower[axis], value)
+                                upper[axis] = max(upper[axis], value)
+                        normal = (points[1] - points[0]).cross(points[2] - points[0])
+                        normal = normal.normalized() if normal.length > 0 else normal
+                        handle.write(struct.pack('<12fH', *normal, *points[0], *points[1], *points[2], 0))
+                        count += 1
+                    triangles += count
+                    exported.append({'name': obj.name, 'type': obj.type, 'triangles': count})
+                finally:
+                    if owner:
+                        owner.to_mesh_clear()
+                    else:
+                        bpy.data.meshes.remove(mesh)
+            if triangles == 0:
+                raise RuntimeError('The selected objects contain no triangles')
+            handle.seek(80)
+            handle.write(struct.pack('<I', triangles))
+        finished = True
+    finally:
+        if not finished and os.path.exists(plan['stagedOutputPath']):
+            os.remove(plan['stagedOutputPath'])
+    units = bpy.context.scene.unit_settings
+    print('${EXPORT_RECEIPT_PREFIX}' + json.dumps({'requestId': plan['requestId'], 'outputPath': plan['stagedOutputPath'],
+        'triangles': triangles, 'min': lower, 'max': upper, 'objects': exported,
+        'sceneUnits': {'system': units.system, 'scaleLength': units.scale_length, 'lengthUnit': units.length_unit}}))
+
+_mcp3d_export()
+del _mcp3d_export
+`;
+}
 function editScript(plan) {
     // JSON is data, never interpolated Python syntax. The comment is also useful in dry runs.
     return `# BAMBU_EDIT_PLAN ${JSON.stringify(plan)}
@@ -381,17 +501,85 @@ export class BlenderMcpBridge {
             throw new BlenderError("Blender MCP advertised an unsupported input schema for this tool.");
         }
         if (!valid)
-            throw new BlenderError("Blender tool arguments do not match its advertised input schema. Inspect blender_mcp_status before calling the tool.");
+            throw new BlenderError("Blender tool arguments do not match its advertised input schema. Call blender_mcp_status with connect: true and tool_names: [\"<tool>\"] to read the schema.");
         session.markDispatched();
         return normalizeToolFailure(await session.client.callTool({ name, arguments: args }, undefined, session.options()));
     }
     async status(args, signal) {
-        allowedArguments(args, ["connect", "timeout_ms"]);
+        allowedArguments(args, ["connect", "timeout_ms", "tool_names", "include_schemas"]);
         const connect = booleanArgument(args.connect, "connect");
         const timeout = timeoutMilliseconds(args.timeout_ms);
+        const includeSchemas = booleanArgument(args.include_schemas, "include_schemas");
+        const requested = args.tool_names;
+        if (requested !== undefined && (!Array.isArray(requested) || requested.length > 64 || requested.some((name) => typeof name !== "string" || !name.trim()))) {
+            throw new BlenderError("tool_names must be an array of up to 64 tool names.");
+        }
         if (!connect)
             return { configured: Boolean(process.env.BLENDER_MCP_COMMAND?.trim()), legacy_configured: Boolean(process.env.BLENDER_MCP_BRIDGE_COMMAND?.trim()), connected: false, transport: "stdio" };
-        return this.session(timeout, signal, async ({ client, tools }) => ({ configured: true, connected: true, transport: "stdio", server: client.getServerVersion(), capabilities: client.getServerCapabilities(), tools }));
+        return this.session(timeout, signal, async ({ client, tools }) => {
+            // Full Blender MCP schemas are tens of kilobytes; list names by default and
+            // return complete definitions only for the tools an agent is about to call.
+            const wanted = new Set(requested);
+            const unknown = [...wanted].filter((name) => !tools.some((tool) => tool.name === name));
+            const summary = (tool) => ({ name: tool.name, description: tool.description?.trim().split(/\n\s*\n/)[0].replace(/\s+/g, " ").slice(0, 300) });
+            return {
+                configured: true, connected: true, transport: "stdio", server: client.getServerVersion(), capabilities: client.getServerCapabilities(),
+                tools: tools.map((tool) => includeSchemas || wanted.has(tool.name) ? tool : summary(tool)),
+                schemas_included: includeSchemas ? "all" : [...wanted].filter((name) => !unknown.includes(name)),
+                ...(unknown.length ? { unknown_tool_names: unknown } : {}),
+                note: "Pass tool_names (or include_schemas: true) to receive full input schemas. Verified STL export: blender_mcp_export_stl.",
+            };
+        });
+    }
+    async exportStl(args, signal) {
+        allowedArguments(args, ["object_names", "output_path", "apply_modifiers", "scale", "user_prompt", "timeout_ms"]);
+        const timeout = timeoutMilliseconds(args.timeout_ms);
+        const deadline = editDeadline(timeout, signal);
+        if (args.user_prompt !== undefined && typeof args.user_prompt !== "string")
+            throw new BlenderError("user_prompt must be a string.");
+        standardConfiguration();
+        const plan = await exportPlan(args, deadline);
+        const code = exportScript(plan);
+        try {
+            const result = await this.session(deadline.remaining(), signal, (session) => this.invoke(session, "execute_blender_code", { code, user_prompt: args.user_prompt ?? "" }));
+            if (result.isError) {
+                const detail = result.content.filter((entry) => entry.type === "text").map((entry) => entry.text).join("\n");
+                // mcp-for-blender wraps the Python exception as JSON; lead with its message.
+                let reason = "";
+                try {
+                    reason = JSON.parse(`"${detail.match(/"message":\s*"((?:[^"\\]|\\.)*)"/)?.[1] ?? ""}"`);
+                }
+                catch { /* Fall back to the raw text. */ }
+                throw new BlenderError(`Blender could not export the requested objects: ${reason || detail.slice(0, 600) || "no details"}. No output was published.`);
+            }
+            const text = result.content.filter((entry) => entry.type === "text").map((entry) => entry.text).join("\n");
+            const receipts = [...text.matchAll(/MCP3D_STL_EXPORT:(\{[^\n]*\})/g)];
+            let receipt;
+            try {
+                receipt = JSON.parse(receipts.at(-1)?.[1] ?? "null");
+            }
+            catch { /* Invalid receipt is a failure. */ }
+            if (receipt?.requestId !== plan.requestId || receipt?.outputPath !== plan.stagedOutputPath)
+                throw new BlenderError("Blender did not return a matching export receipt. Inspect its connection and tool result; no output was published.");
+            const metadata = await regularStl(plan.stagedOutputPath, deadline);
+            if (metadata.triangles !== receipt.triangles)
+                throw new BlenderError("The exported STL does not match Blender's export receipt; no output was published.");
+            deadline.check();
+            await fs.link(plan.stagedOutputPath, plan.outputPath).catch(() => { throw new BlenderError("Cannot publish the exported STL; output_path may already exist or be unwritable."); });
+            const largest = Math.max(...metadata.bounding_box.dimensions);
+            const warnings = [];
+            if (largest < 1)
+                warnings.push("The model is under 1 unit across. Slicers read STL coordinates as millimetres; if it was modelled in metres, export again with scale: 1000.");
+            if (largest > 2000)
+                warnings.push("The model is over 2000 units across. Slicers read STL coordinates as millimetres; check the scene units and scale.");
+            return {
+                status: "success", mode: "mcp", output_path: plan.outputPath, ...metadata, units: "STL coordinates (slicers treat 1 unit as 1 mm)",
+                scale: plan.scale, objects: receipt.objects, scene_units: receipt.sceneUnits, output_verified: true, ...(warnings.length ? { warnings } : {}),
+            };
+        }
+        finally {
+            await fs.rm(plan.stagedOutputPath, { force: true }).catch(() => { });
+        }
     }
     async call(args, signal) {
         allowedArguments(args, ["tool_name", "arguments", "timeout_ms"]);

package/dist/fulu-orca.js

@@ -28,6 +28,22 @@ const FULU_PRINT_RPC_METHODS = new Set([
     "net.start_send_gcode_to_sdcard",
     "net.start_sdcard_print",
 ]);
+/**
+ * Agent/session/account bootstrap methods. They do not address a printer, so
+ * they remain available with allow_mutating_method=true. Every other method
+ * outside the read-only allowlist is refused: raw print starts, raw MQTT
+ * messages, file transfers and unknown methods would bypass the inspected
+ * print, heating and printer-state gate.
+ */
+const SESSION_MUTATING_METHODS = new Set([
+    "net.create_agent",
+    "net.start",
+    "net.init_log",
+    "net.set_config_dir",
+    "net.set_country_code",
+    "net.connect_server",
+    "net.change_user",
+]);
 export function isFuluPrintRpcMethod(method) {
     return FULU_PRINT_RPC_METHODS.has(method.trim());
 }
@@ -370,13 +386,18 @@ export async function invokeFuluBridgeRpc(options) {
     }
     const readOnly = isReadOnlyBridgeMethod(method);
     const printMethod = isFuluPrintRpcMethod(method);
+    if (printMethod) {
+        throw new Error(`Print safety: raw FULU bridge print method "${method}" is disabled because it would start an uninspected job ` +
+            "without the thermal, model, nozzle, printer-state and human-confirmation checks. Use print_3mf for a checked LAN print.");
+    }
+    if (!readOnly && !SESSION_MUTATING_METHODS.has(method)) {
+        throw new Error(`Print safety: raw FULU bridge method "${method}" is not in the verified allowlist. Raw printer messages, ` +
+            "file transfers and unknown methods could bypass the print and heating safety gate. Use the dedicated printer tools instead.");
+    }
     if (!readOnly && !options.allowMutatingMethod) {
-        throw new Error(`FULU bridge method "${method}" may mutate printer, account, or cloud state. ` +
+        throw new Error(`FULU bridge method "${method}" may mutate account, session, or cloud state. ` +
             "Pass allow_mutating_method=true only when you intend to perform that action.");
     }
-    if (printMethod && !options.bambuModel?.trim()) {
-        throw new Error("bambu_model is required for FULU BambuNetwork print RPC methods.");
-    }
     const command = options.bridgeCommand || process.env.FULU_BAMBU_BRIDGE_COMMAND || "";
     const bridgeResult = await runBridgeRequests(command, [{ id: 1, method, payload: options.payload || {} }], options.timeoutMs || 5000);
     return {
@@ -441,11 +462,14 @@ export async function inspectFuluOrcaSetup(options) {
             safeByDefault: true,
             readOnlyMethods: Array.from(READ_ONLY_BRIDGE_METHODS),
             readOnlyNetPrefixes: READ_ONLY_NET_PREFIXES,
-            printMethodsRequireBambuModel: Array.from(FULU_PRINT_RPC_METHODS),
+            sessionMethodsRequireAllowMutating: Array.from(SESSION_MUTATING_METHODS),
+            disabledPrintMethods: Array.from(FULU_PRINT_RPC_METHODS),
+            otherMethods: "disabled: raw printer messages, file transfers and unknown methods bypass the safety gate",
         },
         notes: [
             "Slicing support uses FULU OrcaSlicer-bambulab CLI output as a sliced 3MF.",
             "Bambu print start still enforces BAMBU_MODEL before generating or sending project G-code.",
+            "Raw bridge print methods are disabled; print_3mf inspects the exact plate, checks the live printer and asks for human confirmation.",
             "The FULU BambuNetwork bridge is a separate runtime from the LAN MQTT/FTPS path; use bridge probing to verify that runtime before relying on cloud behavior.",
             "FULU macOS release bundles may ship the bridge dylib and host shims before the Linux plugin .so payload is present; missing linux-plugin entries mean the slicer can still be tested, but the BambuNetwork bridge is not fully ready.",
         ],