mcp-3d-printer-server 1.2.24 → 1.2.26

package/src/slicer/bambu-cli.ts

@@ -49,6 +49,8 @@ export interface BambuSliceOptions {
   minSave?: boolean;           // --min-save
   skipModifiedGcodes?: boolean;// --skip-modified-gcodes
   slicePlate?: number;         // --slice N (0 = all plates)
+  pauseAtLayers?: number[];    // pause before each 1-based layer, through the slicer's own custom G-code
+  customGcodesFile?: string;   // internal --load-custom-gcodes file, prepared by sliceSTLWithResult
   /** Process keys written over the resolved process preset (layer_height, wall_loops, sparse_infill_density). */
   processOverrides?: Record<string, string>;
 }
@@ -597,6 +599,9 @@ export interface BambuCliInput {
  */
 export function planBambuCliInput(slicerType: BambuCliSlicerType, is3mf: boolean, options: BambuSliceOptions): BambuCliInput {
   const input = { slicerType, is3mf, meshTransformed: false };
+  if (!is3mf && options.repetitions !== undefined && options.cloneObjects) {
+    throw new Error("Use either repetitions or clone_objects for an STL, not both.");
+  }
   if (slicerType === "bambustudio") return input;
   const tilts = !!options.rotateX || !!options.rotateY;
   if (is3mf) {
@@ -608,9 +613,6 @@ export function planBambuCliInput(slicerType: BambuCliSlicerType, is3mf: boolean
     }
     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 };
 }
 
@@ -641,17 +643,23 @@ const BAMBU_CLI_ERRORS: Record<number, string> = {
 };
 
 /**
- * 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.
+ * The result.json in the run's fresh output directory, parsed verbatim. Bambu
+ * Studio 02.08.02.61 writes it on macOS for successes and failures alike.
  */
-export function bambuCliFailureReason(exitCode: number | null, outputDir: string): string | undefined {
+export function readCliResult(outputDir: string): Record<string, unknown> | 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}]` : ""}`;
-    }
+    const result: unknown = JSON.parse(fs.readFileSync(path.join(outputDir, "result.json"), "utf8"));
+    return result && typeof result === "object" && !Array.isArray(result) ? result as Record<string, unknown> : undefined;
   } catch {
-    // result.json is written only on Linux and only for handled errors.
+    return undefined;
+  }
+}
+
+/** The CLI's own reason for a failed run: its result.json, else the exit-code table. */
+export function bambuCliFailureReason(exitCode: number | null, outputDir: string): string | undefined {
+  const result = readCliResult(outputDir);
+  if (typeof result?.error_string === "string" && result.error_string.trim()) {
+    return `${result.error_string.trim()}${result.return_code !== undefined ? ` [${result.return_code}]` : ""}`;
   }
   if (exitCode === null) return undefined;
   const code = Object.keys(BAMBU_CLI_ERRORS).map(Number).find((value) => value === exitCode || (value & 0xff) === exitCode);
@@ -683,8 +691,8 @@ export function buildBambuCliArgs(
   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) {
-    // 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));
+    // Both Bambu Studio and OrcaSlicer copy standalone STL objects with --clone-objects.
+    if (!input.is3mf) args.push("--clone-objects", String(options.repetitions));
     else args.push("--repetitions", String(options.repetitions));
   }
   if (!input.meshTransformed) {
@@ -700,6 +708,7 @@ export function buildBambuCliArgs(
     args.push("--load-defaultfila");
   }
   if (options.loadFilamentIds) args.push("--load-filament-ids", options.loadFilamentIds);
+  if (options.customGcodesFile) args.push("--load-custom-gcodes", path.resolve(options.customGcodesFile));
   return args;
 }
 

package/src/slicer/layer-pauses.ts

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import JSZip from "jszip";
+
+/**
+ * Pause-at-layer for Bambu-compatible slicer CLIs ("Add pause" in Bambu Studio
+ * and OrcaSlicer). The slicer writes the machine's own machine_pause_gcode
+ * (M400 U1 on Bambu printers) before the chosen layer, so the printer pauses
+ * by itself there and waits for Resume; no remote command is involved.
+ *
+ * The CLI takes these as --load-custom-gcodes <json> (CustomGCode::Info). It
+ * does not apply the pauses a project 3MF already carries in
+ * Metadata/custom_gcode_per_print_z.xml, so those are read here and passed the
+ * same way. A pause's print_z must be the exact top of its layer: a height
+ * between layers lands on the layer below.
+ */
+
+/** CustomGCode::Type, in the order bbs_3mf.cpp writes it as an integer. */
+const CUSTOM_GCODE_TYPES = ["ColorChange", "PausePrint", "ToolChange", "Template", "Custom", "Unknown"] as const;
+export type CustomGcodeType = (typeof CUSTOM_GCODE_TYPES)[number];
+
+export interface CustomGcodeItem {
+  type: CustomGcodeType;
+  print_z: number;
+  color: string;
+  extruder: number;
+  extra: string;
+}
+
+export interface CustomGcodeInfo {
+  mode: string;
+  gcodes: CustomGcodeItem[];
+}
+
+/** 1-based layer numbers, as Bambu Studio's and OrcaSlicer's preview slider count them. */
+export function parsePauseLayers(value: unknown): number[] | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const raw = Array.isArray(value) ? value : String(value).split(/[\s,;]+/).filter(Boolean);
+  const layers = raw.map(entry => Number(entry));
+  for (const layer of layers) {
+    if (!Number.isInteger(layer) || layer < 2) {
+      throw new Error(`pause_at_layers takes whole layer numbers of 2 or more (the printer cannot pause before layer 1), not ${JSON.stringify(value)}.`);
+    }
+  }
+  const unique = [...new Set(layers)].sort((a, b) => a - b);
+  return unique.length ? unique : undefined;
+}
+
+function xmlAttr(tag: string, name: string): string | undefined {
+  const match = new RegExp(`\\b${name}="([^"]*)"`).exec(tag);
+  return match ? match[1].replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&") : undefined;
+}
+
+/**
+ * The custom G-codes (pauses, colour changes, ...) a project 3MF stores for
+ * one plate (1-based), as Bambu Studio and OrcaSlicer save them.
+ */
+export async function readProjectCustomGcodes(threeMfPath: string, plate = 1): Promise<CustomGcodeInfo | undefined> {
+  let zip: JSZip;
+  try {
+    zip = await JSZip.loadAsync(await fs.promises.readFile(threeMfPath));
+  } catch {
+    return undefined;
+  }
+  const file = zip.file(/^Metadata\/custom_gcode_per_print_z\.xml$/i)[0];
+  if (!file) return undefined;
+  const xml = await file.async("string");
+  for (const block of xml.match(/<plate>[\s\S]*?<\/plate>/g) ?? []) {
+    const info = /<plate_info\b[^>]*>/.exec(block)?.[0];
+    if (Number(info ? xmlAttr(info, "id") : NaN) !== plate) continue;
+    const gcodes: CustomGcodeItem[] = [];
+    for (const tag of block.match(/<layer\b[^>]*>/g) ?? []) {
+      const type = CUSTOM_GCODE_TYPES[Number(xmlAttr(tag, "type"))] ?? "Unknown";
+      const printZ = Number(xmlAttr(tag, "top_z"));
+      if (!Number.isFinite(printZ)) continue;
+      gcodes.push({
+        type,
+        print_z: printZ,
+        color: xmlAttr(tag, "color") ?? "",
+        extruder: Number(xmlAttr(tag, "extruder") ?? 1) || 1,
+        // Template and Custom keep their G-code text in "extra" (CustomGCode.hpp).
+        extra: xmlAttr(tag, "extra") ?? "",
+      });
+    }
+    const modeTag = /<mode\b[^>]*>/.exec(block)?.[0];
+    return { mode: (modeTag && xmlAttr(modeTag, "value")) || "SingleExtruder", gcodes };
+  }
+  return undefined;
+}
+
+/** The plate's G-code text inside a sliced 3MF. */
+export async function readPlateGcode(threeMfPath: string, plate = 1): Promise<string | undefined> {
+  const zip = await JSZip.loadAsync(await fs.promises.readFile(threeMfPath));
+  const exact = zip.file(`Metadata/plate_${plate}.gcode`);
+  const file = exact ?? zip.file(/^Metadata\/plate_\d+\.gcode$/)[0];
+  return file ? file.async("string") : undefined;
+}
+
+/** Each layer's top Z in order, from the slicer's "; Z_HEIGHT:" markers. */
+export function layerTops(gcode: string): number[] {
+  const tops: number[] = [];
+  for (const match of gcode.matchAll(/^; Z_HEIGHT: ([0-9.]+)\s*$/gm)) tops.push(Number(match[1]));
+  return tops;
+}
+
+/**
+ * The 1-based layers whose block holds a pause: the slicer's "; PAUSE_PRINTING"
+ * marker or the machine's pause G-code on its own line.
+ */
+export function pausedLayers(gcode: string, pauseGcode = "M400 U1"): number[] {
+  const lines = gcode.split(/\r?\n/);
+  const paused = new Set<number>();
+  let layer = 0;
+  const pauseLine = pauseGcode.trim();
+  for (const line of lines) {
+    if (line.startsWith("; Z_HEIGHT:")) { layer += 1; continue; }
+    if (layer === 0) continue;
+    const trimmed = line.trim();
+    if (trimmed === "; PAUSE_PRINTING" || (pauseLine && trimmed === pauseLine)) paused.add(layer);
+  }
+  return [...paused].sort((a, b) => a - b);
+}
+
+/** The machine_pause_gcode a sliced file was made with (its config block), else Bambu's M400 U1. */
+export function machinePauseGcode(gcode: string): string {
+  const match = /^; machine_pause_gcode = (.*)$/m.exec(gcode);
+  const value = match?.[1]?.split("\\n")[0]?.trim();
+  return value || "M400 U1";
+}
+
+/** Project custom G-codes plus a pause before each requested layer, at that layer's exact top. */
+export function customGcodesWithPauses(tops: number[], layers: number[], project?: CustomGcodeInfo): CustomGcodeInfo {
+  const total = tops.length;
+  const beyond = layers.filter(layer => layer > total);
+  if (beyond.length) {
+    throw new Error(`This print has ${total} layers, so it cannot pause before layer ${beyond.join(", ")}.`);
+  }
+  const pauses: CustomGcodeItem[] = layers.map(layer => ({ type: "PausePrint", print_z: tops[layer - 1], color: "", extruder: 1, extra: "" }));
+  const kept = (project?.gcodes ?? []).filter(item => !(item.type === "PausePrint" && pauses.some(p => Math.abs(p.print_z - item.print_z) < 1e-4)));
+  return {
+    mode: project?.mode || "SingleExtruder",
+    gcodes: [...kept, ...pauses].sort((a, b) => a.print_z - b.print_z),
+  };
+}

package/src/slicer/slicer-error.ts

@@ -41,16 +41,35 @@ export function slicerSuggestion(phase: SlicerFailurePhase, slicerType?: string)
   }
 }
 
+/** Bambu Studio's or OrcaSlicer's own result.json, parsed verbatim. */
+export type SlicerResult = Record<string, unknown>;
+
+/**
+ * The slicer's own words: its error_string when it reports a failing
+ * return_code (not "Success."), then each plate's warning_message.
+ */
+export function slicerResultText(result: SlicerResult): string {
+  const plates = Array.isArray(result.sliced_plates) ? result.sliced_plates : [];
+  return [
+    result.return_code === 0 ? undefined : result.error_string,
+    ...plates.map((plate) => plate && typeof plate === "object" ? (plate as Record<string, unknown>).warning_message : undefined),
+  ].filter((text): text is string => typeof text === "string" && text.trim() !== "").map((text) => text.trim()).join("\n");
+}
+
 export class SlicerError extends Error {
   readonly phase: SlicerFailurePhase;
   readonly suggestion: string;
   readonly details: SlicerFailureDetails;
+  /** The slicer's own words from `slicerResult`; the message starts with them. */
+  readonly slicerText: string;
 
-  constructor(phase: SlicerFailurePhase, message: string, details: SlicerFailureDetails = {}) {
-    super(message);
+  constructor(phase: SlicerFailurePhase, message: string, details: SlicerFailureDetails = {}, readonly slicerResult?: SlicerResult) {
+    const slicerText = slicerResult ? slicerResultText(slicerResult) : "";
+    super(slicerText ? `${slicerText}\n${message}` : message);
     this.name = "SlicerError";
     this.phase = phase;
     this.details = details;
+    this.slicerText = slicerText;
     this.suggestion = slicerSuggestion(phase, details.slicerType);
   }
 }