bambu-printer-mcp 1.1.8 → 1.1.10

package/src/printers/bambu.ts

@@ -47,6 +47,7 @@ const MODEL_ID_TO_NAME: Record<string, string> = {
   O1D: "H2D",
   O1E: "H2D Pro",
   O1S: "H2S",
+  N6: "X2D",
   N2S: "A1",
   A1M: "A1 Mini",
   C11: "P1P",
@@ -58,6 +59,15 @@ const MODEL_ID_TO_NAME: Record<string, string> = {
 
 const H2_MODEL_NAMES = new Set(["h2", "h2c", "h2d", "h2dpro", "h2d pro", "h2s"]);
 
+export function assertDirectPrintSupported(model: string | undefined, serial?: string): void {
+  if (model?.trim().toLowerCase() === "x2d" || serial?.trim().toUpperCase().startsWith("20P")) {
+    throw new Error(
+      "X2D direct printing is not supported pending native eMMC transport support. " +
+      "X2D status and slicing remain available; use a supported slicer to print."
+    );
+  }
+}
+
 function isH2ModelName(model: unknown): boolean {
   return H2_MODEL_NAMES.has(String(model ?? "").trim().toLowerCase().replace(/\s+/g, " "));
 }
@@ -151,6 +161,7 @@ class TolerantBambuClient extends BambuClient {
     if (sn.startsWith("094")) return "H2D";
     if (sn.startsWith("239")) return "H2C";
     if (sn.startsWith("31B")) return "H2DPRO";
+    if (sn.startsWith("20P")) return "X2D";
     if (sn.startsWith("00M")) return "X1C";
     if (sn.startsWith("00W")) return "X1";
     if (sn.startsWith("03W")) return "X1E";
@@ -568,6 +579,7 @@ export class BambuImplementation {
     token: string,
     options: BambuPrintOptionsInternal
   ): Promise<any> {
+    assertDirectPrintSupported(options.bambuModel, serial);
     if (!options.filePath.toLowerCase().endsWith(".3mf")) {
       throw new Error("print3mf requires a .3mf input file.");
     }
@@ -1159,8 +1171,10 @@ export class BambuImplementation {
     token: string,
     filePath: string,
     filename: string,
-    print: boolean
+    print: boolean,
+    bambuModel?: string
   ) {
+    if (print) assertDirectPrintSupported(bambuModel, serial);
     await fs.access(filePath);
 
     const normalizedFileName = filename.replace(/^\/+/, "");
@@ -1180,7 +1194,7 @@ export class BambuImplementation {
 
     if (print) {
       if (remotePath.toLowerCase().endsWith(".gcode")) {
-        response.startResult = await this.startJob(host, serial, token, remotePath);
+        response.startResult = await this.startJob(host, serial, token, remotePath, bambuModel);
       } else if (remotePath.toLowerCase().endsWith(".3mf")) {
         response.note =
           "3MF upload complete. Use print_3mf to start a project print with plate and metadata options.";
@@ -1194,7 +1208,8 @@ export class BambuImplementation {
     return response;
   }
 
-  async startJob(host: string, serial: string, token: string, filename: string) {
+  async startJob(host: string, serial: string, token: string, filename: string, bambuModel?: string) {
+    assertDirectPrintSupported(bambuModel, serial);
     const lower = filename.toLowerCase();
     if (lower.endsWith(".3mf") && !lower.endsWith(".gcode.3mf")) {
       throw new Error("Use print_3mf for .3mf project files.");
@@ -1281,7 +1296,7 @@ export class BambuImplementation {
     // P1/A1 series still use the proprietary TCP-on-6000 framed JPEG path
     // (per https://github.com/Doridian/OpenBambuAPI/blob/main/video.md).
     const TCP_CAMERA_MODELS = new Set(["a1", "a1mini", "p1s", "p1p"]);
-    // X1, P2S, AND H2 (H2S/H2D/H2C) all use RTSP on port 322. The
+    // X1, P2S, H2 (H2S/H2D/H2C), AND X2D all use RTSP on port 322. The
     // OpenBambuAPI doc only mentions X1/P2S, but the HA bambulab
     // integration's models.py shows the printer reports its own
     // `ipcam.rtsp_url` for these models, and Parker (H2S) rejects the
@@ -1289,7 +1304,7 @@ export class BambuImplementation {
     // confirmed by local H2 camera transport probes).
     const RTSP_MODELS = new Set([
       "x1", "x1c", "x1carbon", "x1e", "p2s",
-      "h2", "h2s", "h2d", "h2c", "h2dpro",
+      "h2", "h2s", "h2d", "h2c", "h2dpro", "x2d",
     ]);
 
     if (!model) {

package/src/slicer/profile-flatten.ts

@@ -78,6 +78,14 @@ export interface FlattenOptions {
     process?: Record<string, unknown>;
     filaments?: (Record<string, unknown> | undefined)[];
   };
+  /**
+   * Positional `#RRGGBB` colour per filament slot (e.g. from the input 3MF
+   * project or the caller). Missing entries keep the profile's own colour or
+   * fall back to DEFAULT_FILAMENT_COLOUR.
+   */
+  filamentColours?: (string | undefined)[];
+  /** Saved per-plate positions, used only when the process sets no position. */
+  projectTowerPosition?: { wipe_tower_x?: unknown; wipe_tower_y?: unknown };
 }
 
 interface IndexedProfile {
@@ -308,6 +316,91 @@ function enforceMatchingNozzles(arr: unknown[]): void {
 }
 
 /** Best-effort extruder count for fallback nozzle_volume_type sizing. */
+/** BambuStudio's built-in filament_colour default. */
+export const DEFAULT_FILAMENT_COLOUR = "#00AE42";
+const FILAMENT_COLOUR_RE = /^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/;
+
+/**
+ * No BBL filament profile defines `filament_colour`; the GUI fills it from
+ * the AMS. Without it the CLI keeps a single-entry colour vector however many
+ * filaments are loaded and crashes (access violation) as soon as a slice uses
+ * any filament after the first. Give every slot exactly one colour.
+ */
+function ensureFilamentColour(flat: Record<string, unknown>, colour?: string): void {
+  if (colour !== undefined) {
+    if (!FILAMENT_COLOUR_RE.test(colour)) {
+      throw new Error(`Invalid filament colour "${colour}"; expected #RRGGBB.`);
+    }
+    flat["filament_colour"] = [colour];
+    return;
+  }
+  const own = flat["filament_colour"];
+  if (Array.isArray(own) && typeof own[0] === "string" && FILAMENT_COLOUR_RE.test(own[0])) {
+    flat["filament_colour"] = [own[0]];
+    return;
+  }
+  flat["filament_colour"] = [DEFAULT_FILAMENT_COLOUR];
+}
+
+// BambuStudio's defaults when a process sets no prime tower position/width.
+const DEFAULT_WIPE_TOWER_X = 15;
+const DEFAULT_WIPE_TOWER_Y = 220;
+const DEFAULT_PRIME_TOWER_WIDTH = 35;
+// Clearance inside the shared nozzle area for the auto-sized tower brim and
+// the CLI's own safety margin (X2D fails at 5 mm from the edge, passes at 6).
+const WIPE_TOWER_MARGIN = 15;
+
+interface Rect { minX: number; maxX: number; minY: number; maxY: number }
+
+function parseArea(area: string): Rect {
+  const points = area.split(",").map((p) => p.trim().split("x").map(Number));
+  if (points.length < 3 || points.some((p) => p.length !== 2 || p.some((n) => !Number.isFinite(n)))) {
+    throw new Error(`Malformed extruder_printable_area entry "${area}".`);
+  }
+  const xs = points.map((p) => p[0]);
+  const ys = points.map((p) => p[1]);
+  return { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) };
+}
+
+/**
+ * On multi-nozzle machines (H2D, X2D) each nozzle reaches only part of the
+ * bed (`extruder_printable_area`), and the prime tower must be reachable by
+ * every nozzle. The CLI's default tower position (x=15) lies outside the
+ * X2D/H2D right-nozzle area, so slicing fails with "G-code outside of the
+ * printable area". When the process sets no position and the default does
+ * not fit, move the tower inside the area all nozzles share.
+ */
+function placePrimeTowerForAllNozzles(
+  machineFlat: Record<string, unknown>,
+  processFlat: Record<string, unknown>
+): void {
+  if (processFlat["wipe_tower_x"] !== undefined || processFlat["wipe_tower_y"] !== undefined) return;
+  if (["0", "false"].includes(String(processFlat["enable_prime_tower"]).toLowerCase())) return;
+  const areas = machineFlat["extruder_printable_area"];
+  if (!Array.isArray(areas) || areas.length < 2) return;
+  const rects = areas.map((a) => {
+    if (typeof a !== "string") throw new Error("Malformed extruder_printable_area in machine profile.");
+    return parseArea(a);
+  });
+  const shared: Rect = {
+    minX: Math.max(...rects.map((r) => r.minX)) + WIPE_TOWER_MARGIN,
+    maxX: Math.min(...rects.map((r) => r.maxX)) - WIPE_TOWER_MARGIN,
+    minY: Math.max(...rects.map((r) => r.minY)) + WIPE_TOWER_MARGIN,
+    maxY: Math.min(...rects.map((r) => r.maxY)) - WIPE_TOWER_MARGIN,
+  };
+  const width = Number(processFlat["prime_tower_width"] ?? DEFAULT_PRIME_TOWER_WIDTH);
+  const size = Number.isFinite(width) && width > 0 ? width : DEFAULT_PRIME_TOWER_WIDTH;
+  if (shared.maxX - shared.minX < size || shared.maxY - shared.minY < size) {
+    throw new Error("No bed area is reachable by every nozzle for the prime tower.");
+  }
+  const clamp = (v: number, lo: number, hi: number) => Math.min(Math.max(v, lo), hi);
+  const x = clamp(DEFAULT_WIPE_TOWER_X, shared.minX, shared.maxX - size);
+  const y = clamp(DEFAULT_WIPE_TOWER_Y, shared.minY, shared.maxY - size);
+  if (x === DEFAULT_WIPE_TOWER_X && y === DEFAULT_WIPE_TOWER_Y) return;
+  processFlat["wipe_tower_x"] = [String(x)];
+  processFlat["wipe_tower_y"] = [String(y)];
+}
+
 function inferExtruderCount(flat: Record<string, unknown>): number {
   for (const key of ["nozzle_diameter", "extruder_type", "extruder_variant_list"]) {
     const v = flat[key];
@@ -586,7 +679,17 @@ export async function flattenForCli(opts: FlattenOptions): Promise<FlattenedProf
   normalizeForCli(machineFlat, "machine", opts.machineLeaf);
   normalizeForCli(processFlat, "process", opts.processLeaf);
   filamentFlats.forEach((f, i) => normalizeForCli(f, "filament", opts.filamentLeaves[i]));
+  if (opts.filamentColours && opts.filamentColours.length !== filamentFlats.length) {
+    throw new Error(
+      `${opts.filamentColours.length} filament colours were supplied for ${filamentFlats.length} filament slots.`
+    );
+  }
+  filamentFlats.forEach((f, i) => ensureFilamentColour(f, opts.filamentColours?.[i]));
   applyBedType(processFlat, opts.bedType);
+  if (processFlat["wipe_tower_x"] === undefined && processFlat["wipe_tower_y"] === undefined) {
+    Object.assign(processFlat, opts.projectTowerPosition);
+  }
+  placePrimeTowerForAllNozzles(machineFlat, processFlat);
 
   // Mirror the GUI's auto-extend behavior: when the caller explicitly
   // chose a process or filament that wasn't pre-declared compatible with

package/src/stl/stl-manipulator.ts

@@ -162,6 +162,7 @@ export interface BambuSliceOptions {
   skipObjects?: string;        // --skip-objects "3,5,10": skip specific objects
   loadFilaments?: string;      // --load-filaments "f1.json;f2.json": filament profiles
   loadFilamentIds?: string;    // --load-filament-ids "1,2,3,1": filament-to-object mapping
+  filamentColours?: string[];  // positional #RRGGBB per loaded filament slot
   bedType?: string;            // Bambu bed type, e.g. textured_plate or cool_plate
   enableTimelapse?: boolean;   // --enable-timelapse: timelapse-aware slicing
   allowMixTemp?: boolean;      // --allow-mix-temp: allow mixed-temp filaments
@@ -177,6 +178,10 @@ export interface BambuSliceOptions {
 interface BambuSettingsBundle {
   settingsArg?: string;
   filamentPaths: string[];
+  /** Positional slot colours declared by the input 3MF project. */
+  filamentColours?: string[];
+  /** Saved per-plate tower coordinates must survive default process loading. */
+  projectTowerPosition?: { wipe_tower_x?: unknown; wipe_tower_y?: unknown };
   /** Identity provenance before the process is merged into a generated file. */
   processSource?: { filePath: string; profile: Record<string, unknown> };
 }
@@ -534,21 +539,32 @@ export class STLManipulator extends EventEmitter {
       profilesRoot,
       tempDir: this.tempDir,
       bedType: this.resolveBambuStudioBedType(bambuOptions?.bedType),
+      filamentColours: bambuOptions?.filamentColours ?? bundle.filamentColours,
+      projectTowerPosition: bundle.projectTowerPosition,
       sourceProfiles: {
         machine: isBundledFile(machinePath) ? undefined : machine,
         process: isBundledFile(processPath) ? undefined : processProfile,
         filaments: filaments.map((profile, i) => isBundledFile(bundle.filamentPaths[i]) ? undefined : profile),
       },
     });
-    // Standalone custom files have no BBL dependencies; preserve their identity
-    // and content. Other profiles retain user values through sourceProfiles.
+    // Standalone files retain their own identity and settings, but still need
+    // the CLI colour/tower fields. Do not discard those required overlays when
+    // choosing the original profile instead of the normalized BBL output.
+    const withCliFields = (filePath: string, profile: Record<string, unknown>, flatPath: string, keys: string[]): string => {
+      const flattened = readProfile(flatPath);
+      const fields = Object.fromEntries(keys.filter(key => flattened[key] !== undefined).map(key => [key, flattened[key]]));
+      if (Object.entries(fields).every(([key, value]) => JSON.stringify(profile[key]) === JSON.stringify(value))) return filePath;
+      return this.writeTempJson(path.basename(filePath, '.json'), 'cli', { ...profile, ...fields });
+    };
     return {
       settingsArg: [
         needsResolution(machinePath, machine) ? flat.machinePath : machinePath,
-        needsResolution(processPath, processProfile) ? flat.processPath : processPath,
+        needsResolution(processPath, processProfile) ? flat.processPath
+          : withCliFields(processPath, processProfile, flat.processPath, ['wipe_tower_x', 'wipe_tower_y']),
       ].join(';'),
       filamentPaths: filaments.map((profile, i) =>
-        needsResolution(bundle.filamentPaths[i], profile) ? flat.filamentPaths[i] : bundle.filamentPaths[i]),
+        needsResolution(bundle.filamentPaths[i], profile) ? flat.filamentPaths[i]
+          : withCliFields(bundle.filamentPaths[i], profile, flat.filamentPaths[i], ['filament_colour'])),
     };
   }
 
@@ -571,13 +587,20 @@ export class STLManipulator extends EventEmitter {
     const count = Math.max(0, ...['filament_settings_id', 'filament_type', 'filament_colour', 'filament_diameter']
       .map(key => Array.isArray(data[key]) ? data[key].length : 0));
     if (count === 0) throw new Error('Cannot determine project filament slots from project_settings.config.');
+    // Keep the project's slot colours; loaded profiles carry none of their own.
+    const colours = Array.isArray(data.filament_colour) && data.filament_colour.length === count &&
+      data.filament_colour.every(c => typeof c === 'string' && /^#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/.test(c))
+      ? data.filament_colour as string[]
+      : undefined;
+    const projectTowerPosition = Object.fromEntries(['wipe_tower_x', 'wipe_tower_y']
+      .filter(key => data[key] !== undefined).map(key => [key, data[key]]));
     if (bundle.filamentPaths.length === 1) {
-      return { ...bundle, filamentPaths: Array(count).fill(bundle.filamentPaths[0]) };
+      return { ...bundle, filamentPaths: Array(count).fill(bundle.filamentPaths[0]), filamentColours: colours, projectTowerPosition };
     }
     if (bundle.filamentPaths.length !== count) {
       throw new Error(`Project declares ${count} filament slots, but ${bundle.filamentPaths.length} profiles were supplied. Provide one profile for all slots or one per slot.`);
     }
-    return bundle;
+    return { ...bundle, filamentColours: colours, projectTowerPosition };
   }
 
   private resolveBambuStudioBedType(bedType?: string): string | undefined {