mcp-3d-printer-server 1.2.13 → 1.2.14

package/dist/stl/stl-manipulator.d.ts

@@ -46,6 +46,14 @@ export declare class STLManipulator extends EventEmitter {
     private appendOrcaProfileArgs;
     private resolveOrcaGcodeOutput;
     private resolveSlicerTimeoutMs;
+    /**
+     * 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 transformMeshForCli;
     /**
      * Load STL file and return geometry and bounding box
      */

package/dist/stl/stl-manipulator.js

@@ -8,7 +8,7 @@ import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
 import { detectProfilesRoot } from '../slicer/profile-flatten.js';
-import { BambuCliProfilePreparer, assertSlicedProjectOutput, buildBambuCliArgs, } from '../slicer/bambu-cli.js';
+import { BambuCliProfilePreparer, assertSlicedProjectOutput, bambuCliFailureReason, buildBambuCliArgs, planBambuCliInput, } from '../slicer/bambu-cli.js';
 import { runSlicerProcess } from '../slicer/run-slicer.js';
 import { SlicerError, asPreparationError } from '../slicer/slicer-error.js';
 import { scanGcodeThermal } from '../safety/gcode-thermal.js';
@@ -110,6 +110,30 @@ 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.
+     */
+    async transformMeshForCli(stlFilePath, options, outputDir) {
+        const { geometry, boundingBox } = await this.loadSTL(stlFilePath);
+        const center = new THREE.Vector3();
+        boundingBox.getCenter(center);
+        const radians = (degrees) => 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
      */
@@ -806,11 +830,14 @@ 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(stlFilePath, outputBase, cliType, profilesRoot, printerPreset, orcaProfiles.settingsProfiles[0], 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
@@ -871,12 +898,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)) {
                 throw new SlicerError('execution', 'Slicing operation cancelled after process finished', { slicerType, slicerPath });

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mcp-3d-printer-server",
     "mcpName": "io.github.DMontgomery40/mcp-3d-printer-server",
-    "version": "1.2.13",
+    "version": "1.2.14",
     "description": "MCP server for connecting Claude with 3D printer management systems",
     "main": "dist/index.js",
     "repository": "https://github.com/DMontgomery40/mcp-3D-printer-server",
@@ -88,7 +88,7 @@
         "jszip": "^3.10.2",
         "three": "^0.173.0",
         "xml2js": "^0.6.2",
-        "zod": "^3.25.76"
+        "zod": "^4.6.7"
     },
     "devDependencies": {
         "@types/jszip": "^3.4.0",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/DMontgomery40/mcp-3D-printer-server",
     "source": "github"
   },
-  "version": "1.2.13",
+  "version": "1.2.14",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "mcp-3d-printer-server",
-      "version": "1.2.13",
+      "version": "1.2.14",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/src/fulu-orca.ts

@@ -99,6 +99,46 @@ export function isFuluPrintRpcMethod(method: string): boolean {
   return FULU_PRINT_RPC_METHODS.has(method.trim());
 }
 
+const FULU_LINUX_DOCS = "https://github.com/DMontgomery40/mcp-3D-printer-server/blob/main/docs/FULU.md#linux";
+
+/**
+ * FULU's Linux host opens its network and source libraries by bare name from
+ * its working directory instead of PJARCZAK_BAMBU_PLUGIN_DIR
+ * (FULU-Foundation/OrcaSlicer-bambulab#51), so name them in that directory
+ * unless they are already set. macOS wrappers run the host in a Linux guest
+ * that may not see host paths, so they are left alone.
+ */
+export function linuxPluginLibraryEnv(env: NodeJS.ProcessEnv, platform: NodeJS.Platform): Record<string, string> {
+  const pluginDir = env.PJARCZAK_BAMBU_PLUGIN_DIR?.trim();
+  if (platform !== "linux" || !pluginDir) return {};
+  const libraries: Record<string, string> = {};
+  if (!env.PJARCZAK_BAMBU_NETWORK_SO?.trim()) libraries.PJARCZAK_BAMBU_NETWORK_SO = path.resolve(pluginDir, "libbambu_networking.so");
+  if (!env.PJARCZAK_BAMBU_SOURCE_SO?.trim()) libraries.PJARCZAK_BAMBU_SOURCE_SO = path.resolve(pluginDir, "libBambuSource.so");
+  return libraries;
+}
+
+/** FULU's Linux host exits 101 when it cannot reopen a socket stdout (FULU-Foundation/OrcaSlicer-bambulab#50). */
+const STDOUT_SOCKET_HINT =
+  "Exit code 101 means FULU's Linux host could not reopen its stdout, which fails when stdout is a socket, as Node.js provides " +
+  "(https://github.com/FULU-Foundation/OrcaSlicer-bambulab/issues/50). Launch the host through a wrapper that pipes its output through cat: " +
+  FULU_LINUX_DOCS;
+
+/** Actionable hints for a bridge run: the exit-101 socket bug and a host that cannot open the plug-in libraries. */
+function bridgeHints(exitCode: number | null, responses: Record<string, unknown>): string[] {
+  const hints: string[] = [];
+  if (exitCode === 101) hints.push(STDOUT_SOCKET_HINT);
+  const fileOpenFailure = (Object.values(responses) as Array<{ network_status?: unknown; error?: unknown } | null>)
+    .find((value) => [value?.network_status, value?.error].some((text) => typeof text === "string" && /file open failed/i.test(text)));
+  if (fileOpenFailure) {
+    hints.push(
+      `FULU BambuNetwork bridge could not open its networking library (${String(fileOpenFailure.network_status ?? fileOpenFailure.error)}). ` +
+      "Set PJARCZAK_BAMBU_PLUGIN_DIR to the directory containing libbambu_networking.so and libBambuSource.so, " +
+      `or set PJARCZAK_BAMBU_NETWORK_SO and PJARCZAK_BAMBU_SOURCE_SO to their absolute paths: ${FULU_LINUX_DOCS}`
+    );
+  }
+  return hints;
+}
+
 function normalizePlatform(value: string | undefined): SupportedPlatform {
   const normalized = (value || process.platform).trim().toLowerCase();
   if (normalized === "mac" || normalized === "macos" || normalized === "darwin") {
@@ -284,7 +324,7 @@ function setupCommands(platform: SupportedPlatform, pluginDir: string, runtimeDi
     const verify = path.join(pluginDir, "verify_runtime_macos.sh");
     const bridgeHost = path.join(runtimeDir || "", "pjarczak_bambu_linux_host");
     const wrapper = path.join(pluginDir, "pjarczak-bambu-linux-host-wrapper");
-    return [
+    const commands = [
       {
         label: "install macOS Lima runtime",
         command: `bash ${quoteShell(install)} -PackageDir ${quoteShell(pluginDir)} -PluginDir ${quoteShell(pluginDir)}`,
@@ -297,11 +337,15 @@ function setupCommands(platform: SupportedPlatform, pluginDir: string, runtimeDi
         label: "verify macOS Lima runtime core before Linux plugin payload is present",
         command: `bash ${quoteShell(verify)} -PackageDir ${quoteShell(pluginDir)} -PluginDir ${quoteShell(pluginDir)} -AllowMissingLinuxPlugin`,
       },
-      {
+    ];
+    // The wrapper ships in FULU's macOS bundle; suggest it only where it exists.
+    if (fs.existsSync(wrapper)) {
+      commands.push({
         label: "bridge command for FULU BambuNetwork runtime",
         command: `${quoteShell(wrapper)} ${quoteShell(bridgeHost)}`,
-      },
-    ];
+      });
+    }
+    return commands;
   }
 
   if (platform === "win32") {
@@ -336,6 +380,11 @@ function setupCommands(platform: SupportedPlatform, pluginDir: string, runtimeDi
       label: "configure MCP slicer path",
       command: "SLICER_TYPE=orcaslicer-bambulab SLICER_PATH=/path/to/orcaslicer",
     },
+    {
+      label: "bridge command for FULU's Linux host, piped through cat (FULU #50)",
+      command: `FULU_BAMBU_BRIDGE_COMMAND="${quoteShell(path.join(pluginDir, "pjarczak_bambu_linux_host"))} | cat" ` +
+        "PJARCZAK_BAMBU_PLUGIN_DIR=\"$HOME/.config/OrcaSlicer/plugins\"",
+    },
   ];
 }
 
@@ -350,6 +399,7 @@ function defaultBridgeCommand(platform: SupportedPlatform, pluginDir: string, ru
 
   if (platform === "darwin") {
     const wrapper = path.join(pluginDir, "pjarczak-bambu-linux-host-wrapper");
+    if (!fs.existsSync(wrapper)) return undefined;
     const runtimeHost = path.join(
       runtimeDir || defaultRuntimeDir(platform) || "",
       "pjarczak_bambu_linux_host"
@@ -358,8 +408,10 @@ function defaultBridgeCommand(platform: SupportedPlatform, pluginDir: string, ru
   }
 
   if (platform === "linux") {
+    // The v1.0.0 host exits 101 on the socket stdout Node.js gives a child
+    // (FULU-Foundation/OrcaSlicer-bambulab#50); a shell pipe through cat avoids it.
     const host = path.join(pluginDir, "pjarczak_bambu_linux_host");
-    return fs.existsSync(host) ? quoteShell(host) : undefined;
+    return fs.existsSync(host) ? `${quoteShell(host)} | cat` : undefined;
   }
 
   return undefined;
@@ -417,6 +469,7 @@ async function runBridgeRequests(
   return await new Promise((resolve, reject) => {
     const child = spawn(command, {
       shell: true,
+      env: { ...process.env, ...linuxPluginLibraryEnv(process.env, process.platform) },
       stdio: ["pipe", "pipe", "pipe"],
     });
 
@@ -433,13 +486,35 @@ async function runBridgeRequests(
       callback();
     };
 
+    const unanswered = new Set(requests.map((request) => request.id));
     const timer = setTimeout(() => {
+      child.stdin?.end();
       child.kill("SIGKILL");
-      settle(() => reject(new Error(`FULU bridge request timed out after ${timeoutMs}ms.`)));
+      // Keep what the host did say: a hung host is diagnosed from its stderr and partial answers.
+      const responses = Object.fromEntries(parseBridgeFrames(Buffer.concat(stdoutChunks))
+        .filter((frame) => frame.type === FRAME_TYPE_JSON_RESPONSE)
+        .map((frame) => [String(frame.id), (() => { try { return JSON.parse(frame.payload.toString("utf8")); } catch { return null; } })()]));
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim().slice(-1000);
+      const hints = bridgeHints(null, responses);
+      settle(() => reject(new Error(
+        `FULU bridge request timed out after ${timeoutMs}ms with ${unanswered.size} of ${requests.length} request(s) unanswered.` +
+        (stderr ? ` Host stderr: ${stderr}` : "") + (hints.length ? ` ${hints.join(" ")}` : "")
+      )));
     }, timeoutMs);
 
-    child.stdout?.on("data", (chunk: Buffer) => stdoutChunks.push(chunk));
+    // FULU's host exits on stdin EOF without answering requests still in
+    // flight, so stdin closes only once every request has a response.
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdoutChunks.push(chunk);
+      if (!unanswered.size) return;
+      for (const frame of parseBridgeFrames(Buffer.concat(stdoutChunks))) {
+        if (frame.type === FRAME_TYPE_JSON_RESPONSE) unanswered.delete(frame.id);
+      }
+      if (!unanswered.size) child.stdin?.end();
+    });
     child.stderr?.on("data", (chunk: Buffer) => stderrChunks.push(chunk));
+    // A host that exits early (exit code 101) closes the pipe; close reports the result.
+    child.stdin?.on("error", () => {});
     child.on("error", (error) => {
       settle(() => reject(error));
     });
@@ -478,7 +553,7 @@ async function runBridgeRequests(
     for (const request of requests) {
       child.stdin?.write(writeJsonRequestFrame(request.id, request.method, request.payload));
     }
-    child.stdin?.end();
+    if (!unanswered.size) child.stdin?.end();
   });
 }
 
@@ -493,9 +568,13 @@ async function probeFuluBridge(command: string, timeoutMs: number): Promise<Reco
     timeoutMs
   );
 
+  const handshake = probe.responses["1"] as { ok?: unknown; network_loaded?: unknown } | undefined;
+  const hints = bridgeHints(probe.exitCode, probe.responses);
   return {
     exitCode: probe.exitCode,
-    ok: probe.ok && Boolean(probe.responses["1"]),
+    // A handshake from a host that could not load the networking plug-in is not a ready bridge.
+    ok: probe.ok && Boolean(handshake) && handshake?.ok !== false && handshake?.network_loaded !== false,
+    ...(hints.length ? { hints } : {}),
     stderr: probe.stderr,
     logs: probe.logs,
     handshake: probe.responses["1"] || null,
@@ -546,6 +625,7 @@ export async function invokeFuluBridgeRpc(options: FuluBridgeRpcOptions): Promis
     options.timeoutMs || 5000
   );
 
+  const hints = bridgeHints(bridgeResult.exitCode, bridgeResult.responses);
   return {
     method,
     readOnly,
@@ -554,6 +634,7 @@ export async function invokeFuluBridgeRpc(options: FuluBridgeRpcOptions): Promis
     bambuModel: options.bambuModel || undefined,
     exitCode: bridgeResult.exitCode,
     ok: bridgeResult.ok,
+    ...(hints.length ? { hints } : {}),
     stderr: bridgeResult.stderr,
     logs: bridgeResult.logs,
     response: bridgeResult.responses["1"] || null,
@@ -601,6 +682,12 @@ export async function inspectFuluOrcaSetup(options: FuluOrcaSetupOptions): Promi
     pluginDir: pluginDir || null,
     runtimeDir: runtimeDir || null,
     bridgeCommand: bridgeCommand || null,
+    // Linux only: absolute plug-in library paths passed to FULU's host (FULU #51).
+    ...(platform === "linux" ? { pluginLibraries: {
+      ...Object.fromEntries(["PJARCZAK_BAMBU_NETWORK_SO", "PJARCZAK_BAMBU_SOURCE_SO"]
+        .filter((name) => process.env[name]?.trim()).map((name) => [name, process.env[name]!.trim()])),
+      ...linuxPluginLibraryEnv(process.env, process.platform),
+    } } : {}),
     fileChecks,
     missingRequiredFiles,
     optionalMissingFiles,
@@ -626,7 +713,12 @@ export async function inspectFuluOrcaSetup(options: FuluOrcaSetupOptions): Promi
       "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.",
+      ...(platform === "darwin"
+        ? ["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."]
+        : []),
+      ...(platform === "linux"
+        ? ["FULU's v1.0.0 Linux host exits 101 when its stdout is a Node.js socket (FULU #50) and opens the plug-in libraries from its working directory (FULU #51). Pipe the host through cat and set PJARCZAK_BAMBU_PLUGIN_DIR; the server then passes the absolute library paths."]
+        : []),
     ],
   };
 }

package/src/index.ts

@@ -270,11 +270,11 @@ const SLICE_TOOL_PROPERTIES = {
     description: "Template directory override when resolving template_name (default: BAMBU_TEMPLATE_DIR or ~/Sync/bambu/templates).",
   },
   uptodate: { type: "boolean", description: "Bambu-compatible slicing: refresh 3MF preset configs to the installed slicer version (--uptodate)." },
-  repetitions: { type: "number", description: "Bambu-compatible slicing: print N identical copies (--repetitions)." },
+  repetitions: { type: "number", description: "Bambu-compatible slicing: print N identical copies (--repetitions). OrcaSlicer copies an STL with --clone-objects; do not combine with clone_objects." },
   orient: { type: "boolean", description: "Bambu-compatible slicing: auto-orient for printability (--orient)." },
-  arrange: { type: "boolean", description: "Bambu-compatible slicing: auto-arrange objects on the plate (--arrange). Set false to keep an existing layout." },
+  arrange: { type: "boolean", description: "Bambu-compatible slicing: auto-arrange objects on the plate (--arrange); STL input is arranged by default. Set false to keep an existing layout: an STL that is not already on the plate then fails to slice." },
   ensure_on_bed: { type: "boolean", description: "Bambu-compatible slicing: lower floating models onto the bed (--ensure-on-bed)." },
-  clone_objects: { type: "string", description: "Bambu-compatible slicing: comma-separated clone counts per object index, e.g. '1,3,1,10'." },
+  clone_objects: { type: "string", description: "Bambu-compatible slicing: clone the loaded model, total copies as a single integer, e.g. '3' (--clone-objects). The Bambu-style CLIs count copies per input file and this tool loads one file, so a comma-separated list is rejected by the slicer." },
   skip_objects: { type: "string", description: "Bambu-compatible slicing: comma-separated object indices to skip, e.g. '3,5,10'." },
   enable_timelapse: { type: "boolean", description: "Bambu-compatible slicing: insert timelapse parking moves (--enable-timelapse)." },
   allow_mix_temp: { type: "boolean", description: "Bambu-compatible slicing: allow filaments with different temperature requirements on one plate." },

package/src/printers/bambu.ts

@@ -12,6 +12,7 @@ import {
   manualHeatingRequirements,
   publishBambuCommand,
   readFreshPrinterStatus,
+  unchippedNozzles,
   validatePrinterState,
   type PrinterStateRequirements,
 } from "../safety/printer-state.js";
@@ -184,11 +185,14 @@ export class BambuImplementation extends PrinterImplementation {
 
   async confirmPrintPreflight(serial: string, status: any, inspection: PrintFileInspection): Promise<string | undefined> {
     const finishedJob = this.finishedJobIdentity(status);
+    const unchipped = unchippedNozzles(status?.raw);
     await this.confirmHardwareAction(
       `Start a checked print on ${inspection.model.toUpperCase()} (${serial})? Nozzles: ${inspection.nozzleDiameters.join(", ")} mm. ` +
       `Materials: ${inspection.materials.join(", ")}. Peak targets: nozzle ${inspection.maxNozzleTemperature}°C, bed ${inspection.maxBedTemperature}°C, chamber ${inspection.maxChamberTemperature}°C. ` +
       `File SHA-256: ${inspection.sha256}. Confirm the physical spool labels and that the build plate is clear.` +
-      (finishedJob !== undefined ? " The printer reports FINISH: remove the previous part and debris before confirming." : ""),
+      (finishedJob !== undefined ? " The printer reports FINISH: remove the previous part and debris before confirming." : "") +
+      (unchipped.length ? ` Printer ${unchipped.length === 1 ? `nozzle ${unchipped[0]} reports` : `nozzles ${unchipped.join(" and ")} report`} no identity chip, ` +
+        `so ${unchipped.length === 1 ? "its" : "their"} diameter and type are the printer's configured settings; confirm they match the installed ${unchipped.length === 1 ? "hotend" : "hotends"}.` : ""),
       finishedJob !== undefined
     );
     return finishedJob;
@@ -261,8 +265,12 @@ export class BambuImplementation extends PrinterImplementation {
         console.warn("PushAllCommand failed, continuing with cached status", error);
       }
 
-      if (!printer.data || Object.keys(printer.data).length === 0) {
-        await new Promise((resolve) => setTimeout(resolve, 1500));
+      // The first push after connecting can be a sparse hello (model and
+      // modules); the full status follows. Returning before it merges reported
+      // status UNKNOWN, so wait for gcode_state within the same 1.5 s bound.
+      const deadline = Date.now() + 1500;
+      while (typeof printer.data?.gcode_state !== "string" && Date.now() < deadline) {
+        await sleep(50);
       }
 
       const data = printer.data;

package/src/safety/confirmation.ts

@@ -50,7 +50,13 @@ export async function requireHumanConfirmation(
   physicalCheck = false
 ): Promise<void> {
   if (!physicalCheck && confirmationOptOut(scope)) return;
-  if (!confirm || !(await confirm(message))) {
-    throw new Error("Hardware safety confirmation was declined or unavailable. Use an MCP client with elicitation support. No command was sent.");
+  if (!confirm) throw new Error(CONFIRMATION_UNAVAILABLE);
+  if (!(await confirm(message))) {
+    throw new Error("Hardware safety confirmation was declined or cancelled in the MCP client. No command was sent. " + (physicalCheck
+      ? "This confirmation covers a physical check at the printer and always needs a person to accept it."
+      : "Some clients decline prompts automatically, for example in a non-interactive permission mode. A deliberately headless " +
+        `setup that approves jobs another way can set ${scope === "bambu"
+          ? "PRINT_REQUIRE_CONFIRMATION=0 (or BAMBU_REQUIRE_CONFIRMATION=0)"
+          : "PRINT_REQUIRE_CONFIRMATION=0"} to skip ordinary print and heating prompts.`));
   }
 }

package/src/safety/printer-state.ts

@@ -148,6 +148,43 @@ function nozzleTypeAndFlow(value: unknown): {type?: string; flow?: string} {
   const type = token(value);
   return {type: ["stainlesssteel","hardenedsteel","tungstencarbide","brass"].includes(type) ? type : undefined};
 }
+/**
+ * A nozzle without an identity chip reports serial "N/A" and keeps the
+ * unreliable bit set permanently (stock H2D HS01 nozzles), so its diameter
+ * and type are configured settings, as on single-nozzle printers.
+ */
+function hasNoIdentityChip(entry: any): boolean {
+  return typeof entry?.sn === "string" && entry.sn.trim().toUpperCase() === "N/A";
+}
+
+/** Bit 0 (information unreliable) is accepted only from a nozzle without an identity chip. */
+function unreliableWithoutChip(entry: any, stat: number): boolean {
+  return (stat & 1) !== 0 && hasNoIdentityChip(entry);
+}
+
+/** Nozzles whose reported diameter and type are configured settings rather than chip readings. */
+export function unchippedNozzles(raw: unknown): number[] {
+  const info = (raw as any)?.device?.nozzle?.info;
+  if (!Array.isArray(info)) return [];
+  return info.flatMap(entry => {
+    const index = finiteNumber(entry?.id);
+    const stat = finiteNumber(entry?.stat);
+    return index !== undefined && Number.isInteger(index) && index >= 0 && index < 16 &&
+      stat !== undefined && Number.isInteger(stat) && stat >= 0 && unreliableWithoutChip(entry, stat) ? [index] : [];
+  });
+}
+
+const loggedUnchippedNozzles = new Set<string>();
+/** Name each unchipped nozzle a check accepted once per printer on stderr, so headless runs still record it. */
+function logUnchippedNozzles(raw: Record<string, any>, serial: string): void {
+  for (const index of unchippedNozzles(raw)) {
+    const key = `${serial}:${index}`;
+    if (loggedUnchippedNozzles.has(key)) continue;
+    loggedUnchippedNozzles.add(key);
+    console.error(`Printer ${serial || "(unknown serial)"} nozzle ${index} reports no identity chip; its diameter and type are the printer's configured settings.`);
+  }
+}
+
 function reportedNozzles(raw: Record<string,any>): ReportedNozzle[] {
   const info = raw.device?.nozzle?.info;
   const output: ReportedNozzle[] = [];
@@ -159,8 +196,11 @@ function reportedNozzles(raw: Record<string,any>): ReportedNozzle[] {
       const diameter = finiteNumber(entry?.diameter);
       if (index === undefined || !Number.isInteger(index) || index < 0 || diameter === undefined || diameter <= 0) throw new Error("Printer reported malformed nozzle identity or diameter.");
       if (entry.stat !== undefined) {
+        // BambuStudio DevNozzle: bit 0 set means the information is unreliable;
+        // bits 1-2 are 0 normal, 1 abnormal, 2 unknown.
         const stat = finiteNumber(entry.stat);
-        if (stat === undefined || !Number.isInteger(stat) || stat < 0 || (stat & 7) !== 0) throw new Error(`Printer nozzle ${index} information is unreliable, abnormal or unknown.`);
+        if (stat === undefined || !Number.isInteger(stat) || stat < 0 || (stat & 6) !== 0) throw new Error(`Printer nozzle ${index} information is unreliable, abnormal or unknown.`);
+        if ((stat & 1) !== 0 && !unreliableWithoutChip(entry, stat)) throw new Error(`Printer nozzle ${index} information is unreliable; refresh the nozzle information on the printer.`);
       }
       if (output.some(nozzle => nozzle.index === index)) throw new Error("Printer reported ambiguous duplicate nozzle indices.");
       output.push({index,diameter,...nozzleTypeAndFlow(entry.type)});
@@ -316,6 +356,7 @@ export function validatePrinterState(status: any, requirements: PrinterStateRequ
       filaments.push({position,material,trayIndex,nozzleMin,nozzleMax});
     }
   }
+  if (nozzles.length) logUnchippedNozzles(raw, identity.observedSerial ?? String(status.serial ?? ""));
   return {model,reportedNozzles:nozzles,filaments};
 }
 

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,