bambu-printer-mcp 1.1.6 → 1.1.9

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
@@ -174,6 +175,17 @@ export interface BambuSliceOptions {
   slicePlate?: number;         // --slice N: which plate (default: 0 = all)
 }
 
+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> };
+}
+
 export class STLManipulator extends EventEmitter {
   private tempDir: string;
   private activeOperations: Map<string, boolean> = new Map();
@@ -195,18 +207,24 @@ export class STLManipulator extends EventEmitter {
   }
 
   private getAvailableProfileRoots(): string[] {
-    return [...BAMBU_PROFILE_ROOTS, ...configuredBambuProfileDirs()].filter((root) => fs.existsSync(root));
+    const selectedRoot = process.env.BAMBU_PROFILES_ROOT;
+    return [
+      ...(selectedRoot ? [path.join(selectedRoot, 'BBL')] : []),
+      ...configuredBambuProfileDirs(),
+      ...BAMBU_PROFILE_ROOTS,
+    ].filter((root) => fs.existsSync(root));
   }
 
   private findProfileFile(
     category: 'machine' | 'process' | 'filament',
-    profileName?: string
+    profileName?: string,
+    roots = this.getAvailableProfileRoots()
   ): string | undefined {
     if (!profileName) {
       return undefined;
     }
 
-    for (const root of this.getAvailableProfileRoots()) {
+    for (const root of roots) {
       const candidate = path.join(root, category, `${profileName}.json`);
       if (fs.existsSync(candidate)) {
         return candidate;
@@ -216,10 +234,10 @@ export class STLManipulator extends EventEmitter {
     return undefined;
   }
 
-  private buildFilamentIdIndex(): Map<string, string> {
+  private buildFilamentIdIndex(roots = this.getAvailableProfileRoots()): Map<string, string> {
     const index = new Map<string, string>();
 
-    for (const root of this.getAvailableProfileRoots()) {
+    for (const root of roots) {
       const filamentDir = path.join(root, 'filament');
       if (!fs.existsSync(filamentDir)) {
         continue;
@@ -299,8 +317,10 @@ export class STLManipulator extends EventEmitter {
   }
 
   private writeTempJson(outputBase: string, suffix: string, value: any): string {
-    const outPath = path.join(this.tempDir, `${outputBase}_${suffix}.json`);
-    fs.writeFileSync(outPath, JSON.stringify(value, null, 2));
+    const serialized = JSON.stringify(value, null, 2);
+    const hash = crypto.createHash('sha256').update(serialized).digest('hex').slice(0, 16);
+    const outPath = path.join(this.tempDir, `${outputBase}_${suffix}_${hash}.json`);
+    fs.writeFileSync(outPath, serialized);
     return outPath;
   }
 
@@ -309,15 +329,25 @@ export class STLManipulator extends EventEmitter {
     slicerType: 'orcaslicer' | 'orcaslicer-bambulab' | 'bambustudio',
     slicerProfile?: string,
     printerPreset?: string,
-    bambuOptions?: BambuSliceOptions
-  ): { settingsArg?: string; filamentPaths: string[] } {
-    const machinePath = this.findProfileFile('machine', printerPreset);
+    bambuOptions?: BambuSliceOptions,
+    activeProfilesRoot?: string
+  ): BambuSettingsBundle {
+    const roots = activeProfilesRoot
+      ? [path.join(activeProfilesRoot, 'BBL'), ...this.getAvailableProfileRoots()]
+      : this.getAvailableProfileRoots();
+    const findProfile = (kind: 'machine' | 'process' | 'filament', name?: string) =>
+      this.findProfileFile(kind, name, roots);
+    const machinePath = findProfile('machine', printerPreset);
+    if (slicerType === 'bambustudio' && printerPreset && !machinePath) {
+      throw new Error(`Printer profile "${printerPreset}" was not found. Set BAMBU_PROFILES_ROOT to the matching BambuStudio profile tree; refusing to use printer defaults.`);
+    }
     const machineConfig = machinePath ? this.readJsonFile(machinePath) : null;
     const hasSlicerProfile = !!slicerProfile && fs.existsSync(slicerProfile);
     const filamentPaths: string[] = [];
 
     let processPath: string | undefined;
     let parsedProfile: any = null;
+    let processSource: BambuSettingsBundle['processSource'];
 
     if (hasSlicerProfile) {
       try {
@@ -328,6 +358,7 @@ export class STLManipulator extends EventEmitter {
     }
 
     if (parsedProfile && typeof parsedProfile === 'object') {
+      processSource = { filePath: slicerProfile!, profile: parsedProfile };
       const inheritedProcessName =
         (typeof parsedProfile.inherits === 'string' && parsedProfile.inherits) ||
         (typeof parsedProfile.print_settings_id === 'string' &&
@@ -341,7 +372,7 @@ export class STLManipulator extends EventEmitter {
           ? machineConfig.default_print_profile
           : undefined);
 
-      const inheritedProcessPath = this.findProfileFile('process', inheritedProcessName);
+      const inheritedProcessPath = findProfile('process', inheritedProcessName);
       const inheritedProcess =
         inheritedProcessPath && fs.existsSync(inheritedProcessPath)
           ? this.readJsonFile(inheritedProcessPath)
@@ -361,22 +392,26 @@ export class STLManipulator extends EventEmitter {
           : mergedProcess
       );
 
-      const defaultFilamentProfiles = Array.isArray(parsedProfile.default_filament_profile)
+      const defaultFilamentProfiles = !bambuOptions?.loadFilaments && Array.isArray(parsedProfile.default_filament_profile)
         ? parsedProfile.default_filament_profile
         : [];
       for (const profileName of defaultFilamentProfiles) {
-        const filamentPath = this.findProfileFile('filament', String(profileName));
+        const filamentPath = findProfile('filament', String(profileName));
         if (filamentPath) {
           filamentPaths.push(filamentPath);
+        } else {
+          throw new Error(`Filament profile "${String(profileName)}" was not found; refusing to omit its slot.`);
         }
       }
 
-      if (filamentPaths.length === 0 && Array.isArray(parsedProfile.filament_ids)) {
-        const filamentIdIndex = this.buildFilamentIdIndex();
+      if (!bambuOptions?.loadFilaments && filamentPaths.length === 0 && Array.isArray(parsedProfile.filament_ids)) {
+        const filamentIdIndex = this.buildFilamentIdIndex(roots);
         for (const filamentId of parsedProfile.filament_ids) {
           const filamentPath = filamentIdIndex.get(String(filamentId));
           if (filamentPath) {
             filamentPaths.push(filamentPath);
+          } else {
+            throw new Error(`Filament ID "${String(filamentId)}" could not be resolved; refusing to omit its slot.`);
           }
         }
       }
@@ -389,7 +424,7 @@ export class STLManipulator extends EventEmitter {
         typeof machineConfig?.default_print_profile === 'string'
           ? machineConfig.default_print_profile
           : undefined;
-      const defaultProcessPath = this.findProfileFile('process', defaultProcessName);
+      const defaultProcessPath = findProfile('process', defaultProcessName);
       if (defaultProcessPath) {
         processPath =
           slicerType === 'orcaslicer'
@@ -408,9 +443,11 @@ export class STLManipulator extends EventEmitter {
       Array.isArray(machineConfig?.default_filament_profile)
     ) {
       for (const profileName of machineConfig.default_filament_profile) {
-        const filamentPath = this.findProfileFile('filament', String(profileName));
+        const filamentPath = findProfile('filament', String(profileName));
         if (filamentPath) {
           filamentPaths.push(filamentPath);
+        } else {
+          throw new Error(`Filament profile "${String(profileName)}" was not found; refusing to omit its slot.`);
         }
       }
     }
@@ -431,80 +468,139 @@ export class STLManipulator extends EventEmitter {
 
     return {
       settingsArg: settingsParts.length > 0 ? settingsParts.join(';') : undefined,
-      filamentPaths: Array.from(new Set(filamentPaths)),
+      filamentPaths,
+      processSource,
     };
   }
 
-  /**
-   * Optionally rewrite a Bambu-like settings bundle so the paths point at
-   * fully-flattened temp configs instead of the BBL-shipped leaf JSONs.
-   *
-   * BambuStudio's CLI does not resolve the `inherits` chain when loading
-   * profiles via --load-settings / --load-filaments, which causes a
-   * cluster of upstream bugs (see https://github.com/bambulab/BambuStudio/issues/9636
-   * and #9968). Our flattener (src/slicer/profile-flatten.ts) reproduces
-   * what the GUI does at slice time so the CLI accepts the configs.
-   *
-   * Opt-in via `BAMBU_CLI_FLATTEN=true`. When the env var is unset or
-   * not "true"/"1", returns the bundle unchanged so behavior is
-   * backward-compatible. When enabled, only BBL-shipped leaves get
-   * flattened; user-provided custom configs pass through untouched.
-   */
+  /** Resolve BBL dependencies before invoking the CLI; failures stop the slice. */
   private async maybeFlattenBundle(
-    bundle: { settingsArg?: string; filamentPaths: string[] },
+    bundle: BambuSettingsBundle,
     bambuOptions?: BambuSliceOptions,
     activeSlicerPath?: string
-  ): Promise<{ settingsArg?: string; filamentPaths: string[] }> {
-    const flag = process.env.BAMBU_CLI_FLATTEN;
-    if (flag !== 'true' && flag !== '1') return bundle;
-    if (!bundle.settingsArg) return bundle;
-
-    // settingsArg is "machine.json;process.json".
-    const parts = bundle.settingsArg.split(';').filter(Boolean);
-    if (parts.length < 2) return bundle;
-    const [machinePath, processPath] = parts;
-
-    // Pull leaf names from each JSON's `name` field. If any is missing or
-    // looks non-BBL (e.g. a user-saved custom config), bail out and
-    // return the original bundle untouched.
-    const machineLeaf = this.readLeafName(machinePath);
-    const processLeaf = this.readLeafName(processPath);
-    const filamentLeaves = bundle.filamentPaths
-      .map((p) => this.readLeafName(p))
-      .filter((n): n is string => Boolean(n));
-
-    if (!machineLeaf || !processLeaf || filamentLeaves.length === 0) {
-      console.log(
-        '[cli-flatten] skipping: could not derive BBL leaf names from bundle paths'
-      );
-      return bundle;
+  ): Promise<BambuSettingsBundle> {
+    const parts = bundle.settingsArg?.split(';').filter(Boolean) ?? [];
+    const readProfile = (filePath: string): Record<string, unknown> => {
+      try {
+        const data: unknown = this.readJsonFile(filePath);
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+          throw new Error('expected a JSON profile object');
+        }
+        return data as Record<string, unknown>;
+      } catch (err: any) {
+        throw new Error(`Cannot read slicer profile "${filePath}": ${err?.message ?? err}`);
+      }
+    };
+    const settings = parts.map(readProfile);
+    // Read every slot: filtering unreadable names would change positional mapping.
+    const filaments = bundle.filamentPaths.map(readProfile);
+    const profilesRoot = detectProfilesRoot(activeSlicerPath || process.env.SLICER_PATH);
+    const profileRoots = [path.join(profilesRoot, 'BBL'), ...this.getAvailableProfileRoots()];
+    const hasReferences = (profile: Record<string, unknown>) =>
+      (typeof profile.inherits === 'string' && profile.inherits.length > 0) ||
+      (profile.include !== undefined && profile.include !== null);
+    const isBundledFile = (filePath: string) =>
+      profileRoots.some(root => {
+        const relative = path.relative(root, filePath);
+        return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+      });
+    const isBundled = (filePath: string, profile: Record<string, unknown>) =>
+      String(profile.from).toLowerCase() === 'system' || isBundledFile(filePath);
+    const needsResolution = (filePath: string, profile: Record<string, unknown>) =>
+      hasReferences(profile) || isBundled(filePath, profile);
+    if (![...settings, ...filaments].some((profile, i) =>
+      needsResolution([...parts, ...bundle.filamentPaths][i], profile))) return bundle;
+    if (parts.length !== 2) {
+      throw new Error('Resolving BBL profiles requires both a machine and process profile; refusing to slice with unresolved settings.');
     }
 
-    const bedType = this.resolveBambuStudioBedType(bambuOptions?.bedType);
+    const [machinePath, processPath] = parts;
+    const [machine, processProfile] = settings;
+    const leafName = (filePath: string, profile: Record<string, unknown>): string => {
+      // A user preset inherits its system identity, while keeping its own values.
+      const name = !isBundled(filePath, profile) && typeof profile.inherits === 'string' && profile.inherits
+        ? profile.inherits
+        : profile.name;
+      if (typeof name !== 'string' || !name) {
+        if (needsResolution(filePath, profile)) throw new Error(`Cannot determine the profile name for "${filePath}".`);
+        return path.basename(filePath, '.json');
+      }
+      return name;
+    };
+    const flat = await flattenForCli({
+      machineLeaf: leafName(machinePath, machine),
+      // A generated path loses bundled provenance; inherited metadata can also
+      // make a custom preset look like a system profile. Use the original source
+      // only for identity and retain the prepared values in sourceProfiles below.
+      processLeaf: bundle.processSource
+        ? leafName(bundle.processSource.filePath, bundle.processSource.profile)
+        : leafName(processPath, processProfile),
+      filamentLeaves: filaments.map((profile, i) => leafName(bundle.filamentPaths[i], profile)),
+      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 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
+          : 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]
+          : withCliFields(bundle.filamentPaths[i], profile, flat.filamentPaths[i], ['filament_colour'])),
+    };
+  }
 
-    try {
-      const profilesRoot = detectProfilesRoot(activeSlicerPath || process.env.SLICER_PATH);
-      const flat = await flattenForCli({
-        machineLeaf,
-        processLeaf,
-        filamentLeaves,
-        profilesRoot,
-        tempDir: this.tempDir,
-        bedType,
-      });
-      console.log(
-        `[cli-flatten] applied for ${machineLeaf} (cliOverlay=${flat.meta.cliOverlayApplied})`
-      );
-      return {
-        settingsArg: `${flat.machinePath};${flat.processPath}`,
-        filamentPaths: flat.filamentPaths,
-      };
-    } catch (err: any) {
-      console.error(
-        `[cli-flatten] failed, falling back to unflattened bundle: ${err?.message ?? err}`
-      );
-      return bundle;
+  /** --load-filaments is positional; a single override must cover every project slot. */
+  private async expandProjectFilaments(
+    inputPath: string,
+    bundle: BambuSettingsBundle
+  ): Promise<BambuSettingsBundle> {
+    if (!inputPath.toLowerCase().endsWith('.3mf') || bundle.filamentPaths.length === 0) return bundle;
+    const JSZip = (await import('jszip')).default;
+    const zip = await JSZip.loadAsync(await fs.promises.readFile(inputPath));
+    const file = zip.file('Metadata/project_settings.config');
+    // Geometry-only 3MFs have no embedded filament slots.
+    if (!file) return bundle;
+    const config: unknown = JSON.parse(await file.async('string'));
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      throw new Error('Cannot determine project filament slots: invalid project_settings.config.');
+    }
+    const data = config as Record<string, unknown>;
+    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]), 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, filamentColours: colours, projectTowerPosition };
   }
 
   private resolveBambuStudioBedType(bedType?: string): string | undefined {
@@ -518,16 +614,6 @@ export class STLManipulator extends EventEmitter {
     return BAMBU_CLI_BED_TYPES[normalized] || bedType;
   }
 
-  /** Read a profile JSON's top-level `name` field, or null if unreadable. */
-  private readLeafName(filePath: string): string | null {
-    try {
-      const data = this.readJsonFile(filePath);
-      return typeof data?.name === 'string' && data.name.length > 0 ? data.name : null;
-    } catch {
-      return null;
-    }
-  }
-
   /**
    * Load STL file and return geometry and bounding box
    */
@@ -1510,14 +1596,14 @@ export class STLManipulator extends EventEmitter {
               slicerType,
               slicerProfile,
               printerPreset,
-              bambuOptions
+              bambuOptions,
+              slicerType === 'bambustudio' ? detectProfilesRoot(slicerPath) : undefined
             );
-            // Opt-in flatten step: walks the BBL `inherits` chain so the
-            // CLI accepts what we hand it. See maybeFlattenBundle docstring.
-            const settingsBundle =
-              slicerType === 'bambustudio'
-                ? await this.maybeFlattenBundle(rawBundle, bambuOptions, slicerPath)
-                : rawBundle;
+            // Resolve every BBL dependency before launching the slicer.
+            const settingsBundle = slicerType === 'bambustudio'
+              ? await this.maybeFlattenBundle(
+                  await this.expandProjectFilaments(stlFilePath, rawBundle), bambuOptions, slicerPath)
+              : rawBundle;
             args = [
               '--slice', String(bambuOptions?.slicePlate ?? 0),
               '--outputdir', outputDir,