mcp-3d-printer-server 1.2.13 → 1.2.15

package/dist/slicer/run-slicer.js

@@ -33,7 +33,7 @@ function describeOutput(stdoutTail, stderrTail) {
  * cancellation rejects with a SlicerError that includes the evidence.
  */
 export function runSlicerProcess(options) {
-    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();
@@ -87,7 +87,8 @@ export function runSlicerProcess(options) {
                     : signal
                         ? `Slicer was terminated by signal ${signal}`
                         : `Slicer exited with code ${code}`;
-            settle(() => reject(new SlicerError("execution", `${reason} (${slicerType}: ${command}).\n${describeOutput(stdoutTail, stderrTail)}`, {
+            const cliReason = timedOut || cancelled ? undefined : failureReason?.(code);
+            settle(() => reject(new SlicerError("execution", `${reason} (${slicerType}: ${command})${cliReason ? `: ${cliReason}` : ""}.\n${describeOutput(stdoutTail, stderrTail)}`, {
                 slicerType,
                 slicerPath: command,
                 exitCode: code,

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/dist/test/stl-manipulator-test.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { STLManipulator } from '../stl/stl-manipulator.js';
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import * as THREE from 'three';
 // Create a test directory
@@ -8,6 +9,8 @@ const TEST_DIR = path.join(process.cwd(), 'test');
 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');
 // Create a simple cube STL for testing if it doesn't exist
@@ -36,8 +39,8 @@ async function testSTLManipulator() {
     try {
         // 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) => {
             console.log('Operation complete:', data);
@@ -84,7 +87,10 @@ async function testSTLManipulator() {
     }
     catch (error) {
         console.error('An error occurred during testing:', error);
-        process.exit(1);
+        process.exitCode = 1;
+    }
+    finally {
+        fs.rmSync(outputDir, { recursive: true, force: true });
     }
 }
 // Run the tests

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.15",
     "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.15",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "mcp-3d-printer-server",
-      "version": "1.2.13",
+      "version": "1.2.15",
       "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};
 }