mcp-3d-printer-server 1.2.13 → 1.2.15

package/src/slicer/bambu-cli.ts

@@ -33,7 +33,7 @@ export interface BambuSliceOptions {
   orient?: boolean;            // --orient 1: auto-orient for printability
   arrange?: boolean;           // --arrange 1: auto-arrange objects on plate
   ensureOnBed?: boolean;       // --ensure-on-bed: lift floating models onto bed
-  cloneObjects?: string;       // --clone-objects "1,3,1,10": clone counts per object
+  cloneObjects?: string;       // --clone-objects N: total copies of the loaded model
   skipObjects?: string;        // --skip-objects "3,5,10": skip specific objects
   loadFilaments?: string;      // "f1.json;f2.json": positional filament profiles
   loadFilamentIds?: string;    // --load-filament-ids "1,2,3,1": filament-to-object mapping
@@ -567,12 +567,91 @@ const PROFILE_METADATA_KEYS = new Set([
   "compatible_printers", "compatible_printers_condition", "compatible_prints", "compatible_prints_condition",
 ]);
 
+/** How the CLI receives the model: Orca STL transforms are applied to a mesh copy first. */
+export interface BambuCliInput {
+  slicerType: BambuCliSlicerType;
+  is3mf: boolean;
+  /** scale and rotations are already applied to the mesh passed to the CLI. */
+  meshTransformed: boolean;
+}
+
+/**
+ * Decide how the CLI receives the model. OrcaSlicer's CLI (upstream and FULU)
+ * crashes with SIGSEGV in PartPlate::check_outside, which needs the GUI's
+ * Plater, when --scale or --rotate-x/-y move an object below the bed while it
+ * arranges, the default for STL input. An Orca STL's transforms are therefore
+ * applied to a mesh copy; combinations the CLI cannot handle are refused.
+ */
+export function planBambuCliInput(slicerType: BambuCliSlicerType, is3mf: boolean, options: BambuSliceOptions): BambuCliInput {
+  const input = { slicerType, is3mf, meshTransformed: false };
+  if (slicerType === "bambustudio") return input;
+  const tilts = !!options.rotateX || !!options.rotateY;
+  if (is3mf) {
+    if (options.arrange === true && ((options.scale ?? 1) > 1 || tilts)) {
+      throw new Error(
+        "OrcaSlicer's CLI crashes when scale above 1, rotate_x or rotate_y moves a 3MF object below the bed while arranging. " +
+        "Set arrange to false, or apply the transform in the slicer and export the project."
+      );
+    }
+    return input;
+  }
+  if (options.repetitions !== undefined && options.cloneObjects) {
+    throw new Error("Use either repetitions or clone_objects for an STL with OrcaSlicer, not both.");
+  }
+  return { ...input, meshTransformed: options.scale !== undefined || tilts };
+}
+
+/**
+ * Bambu Studio and OrcaSlicer CLI errors (libslic3r/Utils.hpp). The process
+ * exits with the low byte of the code; on Linux result.json names the error.
+ */
+const BAMBU_CLI_ERRORS: Record<number, string> = {
+  [-2]: "invalid parameters to the slicer",
+  [-3]: "input files not found",
+  [-5]: "preset file cannot be parsed",
+  [-6]: "model file cannot be parsed",
+  [-9]: "copying objects failed",
+  [-17]: "printer is not compatible with the process preset",
+  [-21]: "auto-arranging objects failed",
+  [-22]: "auto-orienting objects failed",
+  [-50]: "a plate is empty or has no object fully inside it; arrange the model or place it on the plate",
+  [-51]: "incorrect slicing parameters",
+  [-52]: "objects extend over the bed boundary",
+  [-60]: "no printable objects remain after skipping",
+  [-61]: "filaments are not compatible with the plate type",
+  [-62]: "the filaments' temperatures differ too much",
+  [-63]: "objects collide in print-by-object mode",
+  [-64]: "objects collide",
+  [-100]: "slicing the model failed",
+  [-101]: "G-code conflicts after slicing",
+  [-102]: "G-code in an unprintable area",
+};
+
+/**
+ * The CLI's own reason for a failed run: result.json in the run's fresh output
+ * directory (written on Linux for handled errors), else the exit-code table.
+ */
+export function bambuCliFailureReason(exitCode: number | null, outputDir: string): string | undefined {
+  try {
+    const result = JSON.parse(fs.readFileSync(path.join(outputDir, "result.json"), "utf8"));
+    if (typeof result?.error_string === "string" && result.error_string.trim()) {
+      return `${result.error_string.trim()}${result.return_code !== undefined ? ` [${result.return_code}]` : ""}`;
+    }
+  } catch {
+    // result.json is written only on Linux and only for handled errors.
+  }
+  if (exitCode === null) return undefined;
+  const code = Object.keys(BAMBU_CLI_ERRORS).map(Number).find((value) => value === exitCode || (value & 0xff) === exitCode);
+  return code === undefined ? undefined : `${BAMBU_CLI_ERRORS[code]} [${code}]`;
+}
+
 /** CLI flags for the prepared bundle and caller options (input path appended by the caller). */
 export function buildBambuCliArgs(
   bundle: BambuSettingsBundle,
   outputDir: string,
   exportName: string,
-  options: BambuSliceOptions
+  options: BambuSliceOptions,
+  input: BambuCliInput
 ): string[] {
   const args = [
     "--slice", String(options.slicePlate ?? 0),
@@ -590,11 +669,17 @@ export function buildBambuCliArgs(
   if (options.skipModifiedGcodes) args.push("--skip-modified-gcodes");
   if (options.orient !== undefined) args.push("--orient", options.orient ? "1" : "0");
   if (options.arrange !== undefined) args.push("--arrange", options.arrange ? "1" : "0");
-  if (options.repetitions !== undefined) args.push("--repetitions", String(options.repetitions));
-  if (options.scale !== undefined) args.push("--scale", String(options.scale));
-  if (options.rotate !== undefined) args.push("--rotate", String(options.rotate));
-  if (options.rotateX !== undefined) args.push("--rotate-x", String(options.rotateX));
-  if (options.rotateY !== undefined) args.push("--rotate-y", String(options.rotateY));
+  if (options.repetitions !== undefined) {
+    // OrcaSlicer rejects --repetitions for one STL; it copies the loaded model with --clone-objects.
+    if (input.slicerType !== "bambustudio" && !input.is3mf) args.push("--clone-objects", String(options.repetitions));
+    else args.push("--repetitions", String(options.repetitions));
+  }
+  if (!input.meshTransformed) {
+    if (options.scale !== undefined) args.push("--scale", String(options.scale));
+    if (options.rotate !== undefined) args.push("--rotate", String(options.rotate));
+    if (options.rotateX !== undefined) args.push("--rotate-x", String(options.rotateX));
+    if (options.rotateY !== undefined) args.push("--rotate-y", String(options.rotateY));
+  }
   if (options.cloneObjects) args.push("--clone-objects", options.cloneObjects);
   if (options.skipObjects) args.push("--skip-objects", options.skipObjects);
   if (bundle.filamentPaths.length > 0) {

package/src/slicer/run-slicer.ts

@@ -11,6 +11,8 @@ export interface SlicerRunOptions {
   slicerType: string;
   /** Polled while the slicer runs; returning true kills it. */
   isCancelled?: () => boolean;
+  /** The slicer's own reason for a nonzero exit, read before its output directory is removed. */
+  failureReason?: (exitCode: number | null) => string | undefined;
 }
 
 export interface SlicerRunResult {
@@ -51,7 +53,7 @@ function describeOutput(stdoutTail: string, stderrTail: string): string {
  * cancellation rejects with a SlicerError that includes the evidence.
  */
 export function runSlicerProcess(options: SlicerRunOptions): Promise<SlicerRunResult> {
-  const { command, args, timeoutMs, slicerType, isCancelled } = options;
+  const { command, args, timeoutMs, slicerType, isCancelled, failureReason } = options;
   return new Promise((resolve, reject) => {
     const stdout = new TailBuffer();
     const stderr = new TailBuffer();
@@ -107,9 +109,10 @@ export function runSlicerProcess(options: SlicerRunOptions): Promise<SlicerRunRe
           : signal
             ? `Slicer was terminated by signal ${signal}`
             : `Slicer exited with code ${code}`;
+      const cliReason = timedOut || cancelled ? undefined : failureReason?.(code);
       settle(() => reject(new SlicerError(
         "execution",
-        `${reason} (${slicerType}: ${command}).\n${describeOutput(stdoutTail, stderrTail)}`,
+        `${reason} (${slicerType}: ${command})${cliReason ? `: ${cliReason}` : ""}.\n${describeOutput(stdoutTail, stderrTail)}`,
         {
           slicerType,
           slicerPath: command,

package/src/stl/stl-manipulator.ts

@@ -11,7 +11,9 @@ import { detectProfilesRoot } from '../slicer/profile-flatten.js';
 import {
   BambuCliProfilePreparer,
   assertSlicedProjectOutput,
+  bambuCliFailureReason,
   buildBambuCliArgs,
+  planBambuCliInput,
   type BambuCliSlicerType,
   type BambuSliceOptions,
 } from '../slicer/bambu-cli.js';
@@ -182,6 +184,27 @@ export class STLManipulator extends EventEmitter {
     return timeoutMs;
   }
 
+  /**
+   * Apply slice_stl's scale and rotations to a copy of the mesh as OrcaSlicer's
+   * CLI would, about the model's centre. Orca adds each --rotate* to the
+   * object's Euler angles (ModelVolume::rotate), so the result rotates about X,
+   * then Y, then Z whatever the argument order, after scaling. The slicer then
+   * places the result on the plate.
+   */
+  private async transformMeshForCli(stlFilePath: string, options: BambuSliceOptions, outputDir: string): Promise<string> {
+    const { geometry, boundingBox } = await this.loadSTL(stlFilePath);
+    const center = new THREE.Vector3();
+    boundingBox.getCenter(center);
+    const radians = (degrees: number) => degrees * Math.PI / 180;
+    geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(-center.x, -center.y, -center.z));
+    if (options.scale !== undefined) geometry.applyMatrix4(new THREE.Matrix4().makeScale(options.scale, options.scale, options.scale));
+    if (options.rotateX) geometry.applyMatrix4(new THREE.Matrix4().makeRotationX(radians(options.rotateX)));
+    if (options.rotateY) geometry.applyMatrix4(new THREE.Matrix4().makeRotationY(radians(options.rotateY)));
+    if (options.rotate) geometry.applyMatrix4(new THREE.Matrix4().makeRotationZ(radians(options.rotate)));
+    geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(center.x, center.y, center.z));
+    return this.saveSTL(geometry, path.join(outputDir, `${path.basename(stlFilePath, path.extname(stlFilePath))}_transformed.stl`));
+  }
+
   /**
    * Load STL file and return geometry and bounding box
    */
@@ -1060,6 +1083,7 @@ export class STLManipulator extends EventEmitter {
             }
             options.loadFilaments = legacyFilaments;
           }
+          const cliInput = planBambuCliInput(cliType, is3mf, options);
           const profilesRoot = detectProfilesRoot(slicerPath, cliType);
           const preparer = new BambuCliProfilePreparer(path.join(this.tempDir, 'slicer-profiles'));
           const bundle = await preparer.prepare(
@@ -1072,7 +1096,9 @@ export class STLManipulator extends EventEmitter {
             options
           );
           bambuOutputDir = fs.mkdtempSync(path.join(this.tempDir, `${operationId}-bambu-output-`));
-          args = [...buildBambuCliArgs(bundle, bambuOutputDir, exportName, options), stlFilePath];
+          // The transformed copy lives in the run's output directory, which is removed afterwards.
+          const inputPath = cliInput.meshTransformed ? await this.transformMeshForCli(stlFilePath, options, bambuOutputDir) : stlFilePath;
+          args = [...buildBambuCliArgs(bundle, bambuOutputDir, exportName, options, cliInput), inputPath];
           bambuExport = {
             producedPath: path.join(bambuOutputDir, exportName),
             // One folder per operation: concurrent slices of same-named inputs
@@ -1135,12 +1161,14 @@ export class STLManipulator extends EventEmitter {
       if (progressCallback) progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
       console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
 
+      const cliOutputDir = bambuOutputDir;
       await runSlicerProcess({
         command: slicerPath,
         args,
         timeoutMs: this.resolveSlicerTimeoutMs(),
         slicerType,
         isCancelled: () => !this.activeOperations.get(operationId),
+        failureReason: cliOutputDir ? (exitCode) => bambuCliFailureReason(exitCode, cliOutputDir) : undefined,
       });
 
       if (!this.activeOperations.get(operationId)) {

package/src/test/stl-manipulator-test.ts

@@ -2,6 +2,7 @@
 
 import { STLManipulator, ProgressCallback } from '../stl/stl-manipulator.js';
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import * as THREE from 'three';
 
@@ -11,6 +12,9 @@ if (!fs.existsSync(TEST_DIR)) {
   fs.mkdirSync(TEST_DIR, { recursive: true });
 }
 
+// Operation outputs go to a scratch folder removed after the run
+const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'stl-manipulator-test-'));
+
 // Path for a sample STL file
 const sampleStlPath = path.join(TEST_DIR, 'sample_cube.stl');
 
@@ -48,8 +52,8 @@ async function testSTLManipulator() {
     // Create a sample STL for testing
     const stlPath = await createSampleCube();
     
-    // Create an instance of the STL manipulator with the test directory
-    const manipulator = new STLManipulator(TEST_DIR);
+    // Write operation outputs to a scratch folder, not the tracked test directory
+    const manipulator = new STLManipulator(outputDir);
     
     // Listen for events from the manipulator
     manipulator.on('operationComplete', (data) => {
@@ -116,7 +120,9 @@ async function testSTLManipulator() {
     console.log('\nAll tests completed successfully!');
   } catch (error) {
     console.error('An error occurred during testing:', error);
-    process.exit(1);
+    process.exitCode = 1;
+  } finally {
+    fs.rmSync(outputDir, { recursive: true, force: true });
   }
 }