mcp-3d-printer-server 1.2.19 → 1.2.21

package/src/slicer/filament-profiles.ts

@@ -0,0 +1,249 @@
+/**
+ * The installed slicer filament profile for a material, as a path slice_stl's
+ * load_filaments accepts (get_printer_filaments slots[].profile).
+ *
+ * The existing resolvers do not fit: bambu-printer-mcp's inventory resolver
+ * and bambu-cli.ts look up Bambu (BBL) profiles by an AMS tray_info_idx, which
+ * other printers do not report. Here the key is the spool's material, matched
+ * exactly against each profile's filament_type, in the slicer slice_stl uses
+ * by default:
+ * - OrcaSlicer: the app's bundled profiles/<Vendor>/filament, the copies under
+ *   OrcaSlicer/system, and the user's OrcaSlicer/user/<id>/filament presets.
+ *   filament_type and compatible_printers are read through `inherits`.
+ * - PrusaSlicer and Slic3r: the data directory's filament/*.ini presets.
+ *   Vendor bundle INIs hold many presets in one file and cannot be --load-ed.
+ * Profiles whose compatible_printers names other printers are excluded; ones
+ * that name the configured printer (SLICER_PROFILE's machine) come first,
+ * then universal ones. Any failure resolves to undefined: a missing profile
+ * never fails get_printer_filaments.
+ */
+import { existsSync, promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { detectProfilesRoot } from "./profile-flatten.js";
+import { parseLooseSlicerConfig } from "./templates.js";
+
+export interface FilamentProfileContext {
+  /** The canonical slicer type slice_stl uses without a slicer_type argument. */
+  slicerType: string;
+  slicerPath?: string;
+  /** SLICER_PROFILE: Orca "machine.json;process.json[|filament.json]", or PrusaSlicer's exported config. */
+  slicerProfile?: string;
+  /** What slice_stl loads when no filament is passed, in slot order. */
+  configuredFilaments?: string[];
+  /** Tests replace the searched directories. */
+  roots?: { system: string[]; user: string[] };
+}
+
+type Entry = { file: string; name: string; config: Record<string, unknown>; user: boolean };
+type Index = { entries: Entry[]; byName: Map<string, Entry> };
+
+const ORCA = new Set(["orcaslicer"]);
+const PRUSA = new Set(["prusaslicer", "slic3r"]);
+const MAX_FILES = 20_000;
+const MAX_BYTES = 2 * 1024 * 1024;
+const MAX_DEPTH = 5;
+const INDEX_TTL_MS = 60_000;
+const indexes = new Map<string, { at: number; index: Promise<Index> }>();
+
+/** Per-user application data directories, in the order the slicers use them. */
+function appDataDirs(): string[] {
+  const home = os.homedir();
+  return [
+    path.join(home, "Library", "Application Support"),
+    path.join(home, ".config"),
+    ...(process.env.APPDATA ? [process.env.APPDATA] : []),
+  ];
+}
+
+function defaultRoots(context: FilamentProfileContext): { system: string[]; user: string[] } {
+  if (ORCA.has(context.slicerType)) {
+    const system = [detectProfilesRoot(context.slicerPath, "orcaslicer"), ...appDataDirs().map((dir) => path.join(dir, "OrcaSlicer", "system"))];
+    const user = appDataDirs().map((dir) => path.join(dir, "OrcaSlicer", "user"));
+    return { system, user };
+  }
+  const home = os.homedir();
+  const name = context.slicerType === "slic3r" ? "Slic3r" : "PrusaSlicer";
+  const user = [
+    ...appDataDirs().map((dir) => path.join(dir, name)),
+    ...(name === "PrusaSlicer" ? [path.join(home, ".PrusaSlicer"), path.join(home, ".var", "app", "com.prusa3d.PrusaSlicer", "config", "PrusaSlicer")] : [path.join(home, ".Slic3r")]),
+  ];
+  return { system: [], user };
+}
+
+async function listFiles(dir: string, extension: string, depth: number, budget: { left: number }): Promise<string[]> {
+  if (depth > MAX_DEPTH || budget.left <= 0) return [];
+  const items = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const files: string[] = [];
+  for (const item of items.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (budget.left <= 0) break;
+    const full = path.join(dir, item.name);
+    if (item.isDirectory()) files.push(...await listFiles(full, extension, depth + 1, budget));
+    else if (item.isFile() && item.name.toLowerCase().endsWith(extension)) { files.push(full); budget.left -= 1; }
+  }
+  return files;
+}
+
+async function readConfig(file: string): Promise<Record<string, unknown> | undefined> {
+  try {
+    const stat = await fs.stat(file);
+    if (!stat.isFile() || stat.size > MAX_BYTES) return undefined;
+    const parsed = parseLooseSlicerConfig(await fs.readFile(file, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function buildIndex(context: FilamentProfileContext, roots: { system: string[]; user: string[] }): Promise<Index> {
+  const budget = { left: MAX_FILES };
+  const files: { file: string; user: boolean }[] = [];
+  if (ORCA.has(context.slicerType)) {
+    // <root>/<Vendor>/filament/** for system trees; <user>/<id>/filament/** for presets.
+    for (const [list, user] of [[roots.system, false], [roots.user, true]] as const) {
+      for (const root of list) {
+        const groups = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const group of groups.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+          for (const file of await listFiles(path.join(root, group.name, "filament"), ".json", 0, budget)) files.push({ file, user });
+        }
+      }
+    }
+  } else {
+    for (const root of roots.user) {
+      for (const file of await listFiles(path.join(root, "filament"), ".ini", MAX_DEPTH, budget)) files.push({ file, user: true });
+    }
+  }
+  const entries: Entry[] = [];
+  const byName = new Map<string, Entry>();
+  for (const { file, user } of files) {
+    const config = await readConfig(file);
+    if (!config) continue;
+    const name = typeof config.name === "string" && config.name.trim() ? config.name.trim() : path.basename(file, path.extname(file));
+    const entry = { file, name, config, user };
+    entries.push(entry);
+    // System names first: `inherits` points at system presets.
+    if (!byName.has(name)) byName.set(name, entry);
+  }
+  return { entries, byName };
+}
+
+function profileIndex(context: FilamentProfileContext): Promise<Index> {
+  const roots = context.roots ?? defaultRoots(context);
+  const key = JSON.stringify([context.slicerType, roots]);
+  const cached = indexes.get(key);
+  if (cached && Date.now() - cached.at < INDEX_TTL_MS) return cached.index;
+  const index = buildIndex(context, roots);
+  indexes.set(key, { at: Date.now(), index });
+  // A failed build is not cached.
+  index.catch(() => indexes.delete(key));
+  return index;
+}
+
+/** A key's value on the profile or the nearest preset it inherits from. */
+function inherited(index: Index, entry: Entry, key: string): unknown {
+  const seen = new Set<Entry>();
+  let current: Entry | undefined = entry;
+  for (let depth = 0; current && depth < 12 && !seen.has(current); depth += 1) {
+    seen.add(current);
+    if (current.config[key] !== undefined) return current.config[key];
+    const parent: unknown = current.config.inherits;
+    current = typeof parent === "string" && parent.trim() ? index.byName.get(parent.trim()) : undefined;
+  }
+  return undefined;
+}
+
+function textValues(value: unknown): string[] {
+  if (Array.isArray(value)) return value.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  if (typeof value !== "string" || !value.trim()) return [];
+  // PrusaSlicer lists are "a";"b"; Orca's are JSON arrays.
+  const quoted = [...value.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1].trim()).filter(Boolean);
+  return quoted.length ? quoted : value.split(";").map((item) => item.trim()).filter(Boolean);
+}
+
+/** The configured printer's preset names, from SLICER_PROFILE. */
+async function printerNames(context: FilamentProfileContext): Promise<Set<string>> {
+  const names = new Set<string>();
+  const settings = (context.slicerProfile ?? "").split("|", 1)[0].split(";").map((item) => item.trim()).filter(Boolean);
+  for (const file of settings) {
+    const config = await readConfig(file);
+    if (!config) continue;
+    const isMachine = config.type === "machine" || config.printer_settings_id !== undefined || config.printer_model !== undefined;
+    if (!isMachine) continue;
+    for (const key of ["name", "inherits", "printer_settings_id"]) {
+      for (const value of textValues(config[key])) names.add(value);
+    }
+  }
+  return names;
+}
+
+export async function resolveFilamentProfile(material: string | undefined, context: FilamentProfileContext): Promise<string | undefined> {
+  try {
+    const wanted = material?.trim().toUpperCase();
+    if (!wanted) {
+      // No reported material: the profile slice_stl loads by default, when it exists.
+      const configured = context.configuredFilaments?.map((item) => item.trim()).find(Boolean);
+      return configured && existsSync(configured) ? path.resolve(configured) : undefined;
+    }
+    if (!ORCA.has(context.slicerType) && !PRUSA.has(context.slicerType)) return undefined;
+    const [index, printers] = await Promise.all([profileIndex(context), printerNames(context)]);
+    const candidates: { entry: Entry; rank: number }[] = [];
+    for (const entry of index.entries) {
+      if (String(entry.config.instantiation ?? "true").toLowerCase() === "false" || /@base$/i.test(entry.name)) continue;
+      if (!textValues(inherited(index, entry, "filament_type")).some((type) => type.toUpperCase() === wanted)) continue;
+      const compatible = textValues(inherited(index, entry, "compatible_printers"));
+      const condition = inherited(index, entry, "compatible_printers_condition");
+      let rank: number;
+      if (compatible.length) {
+        if (!compatible.some((name) => printers.has(name))) continue;
+        rank = 0;
+      } else {
+        // A condition this server cannot evaluate ranks below a profile for every printer.
+        rank = typeof condition === "string" && condition.trim() ? 2 : 1;
+      }
+      candidates.push({ entry, rank });
+    }
+    candidates.sort((a, b) => a.rank - b.rank || Number(b.entry.user) - Number(a.entry.user) || a.entry.file.localeCompare(b.entry.file));
+    const best = candidates[0]?.entry.file;
+    return best ? path.resolve(best) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * A generic OrcaSlicer filament preset with its `inherits` chain merged in,
+ * parent first, for --load-filaments: the CLI does not resolve inheritance,
+ * so a bundled preset such as "Generic PETG @System" would otherwise slice
+ * without its own temperatures. Undefined when the file inherits nothing, or
+ * when a parent is not installed (the file is then passed as it is).
+ */
+export async function flattenOrcaFilament(file: string, context: Pick<FilamentProfileContext, "slicerPath" | "roots">): Promise<Record<string, unknown> | undefined> {
+  const leaf = await readConfig(file);
+  const parentName = leaf?.inherits;
+  if (!leaf || typeof parentName !== "string" || !parentName.trim()) return undefined;
+  const index = await profileIndex({ slicerType: "orcaslicer", ...context });
+  const chain: Record<string, unknown>[] = [leaf];
+  const seen = new Set<string>();
+  for (let name = parentName.trim(); name; ) {
+    const parent = index.byName.get(name);
+    if (!parent || seen.has(name) || chain.length > 12) return undefined;
+    seen.add(name);
+    chain.push(parent.config);
+    name = typeof parent.config.inherits === "string" ? parent.config.inherits.trim() : "";
+  }
+  const merged: Record<string, unknown> = Object.assign({}, ...chain.reverse());
+  const name = typeof leaf.name === "string" && leaf.name.trim() ? leaf.name.trim() : path.basename(file, path.extname(file));
+  // As the Bambu CLI flattener does: a user-owned, self-contained preset.
+  merged.name = name;
+  merged.inherits = "";
+  merged.from = "User";
+  merged.filament_settings_id = [name];
+  delete merged.instantiation;
+  delete merged.setting_id;
+  return merged;
+}
+
+/** Tests only: forget cached profile indexes. */
+export function clearFilamentProfileCache(): void {
+  indexes.clear();
+}

package/src/stl/stl-manipulator.ts

@@ -8,6 +8,7 @@ import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
 import { detectProfilesRoot } from '../slicer/profile-flatten.js';
+import { flattenOrcaFilament } from '../slicer/filament-profiles.js';
 import {
   BambuCliProfilePreparer,
   assertSlicedProjectOutput,
@@ -21,6 +22,34 @@ import { runSlicerProcess } from '../slicer/run-slicer.js';
 import { SlicerError, asPreparationError } from '../slicer/slicer-error.js';
 
 export type { BambuSliceOptions } from '../slicer/bambu-cli.js';
+
+/** Print-sheet slicing overrides (PRD §8.4), applied on top of the selected profile. */
+export interface ProcessOverrides {
+  /** mm */
+  layerHeight?: number;
+  /** wall (perimeter) count */
+  wallLoops?: number;
+  /** e.g. "15%" */
+  sparseInfillDensity?: string;
+}
+
+/** Orca/Bambu Studio process keys; profile JSON values are strings. */
+export function orcaProcessOverrides(overrides: ProcessOverrides | undefined): Record<string, string> {
+  const keys: Record<string, string> = {};
+  if (overrides?.layerHeight !== undefined) keys.layer_height = String(overrides.layerHeight);
+  if (overrides?.wallLoops !== undefined) keys.wall_loops = String(overrides.wallLoops);
+  if (overrides?.sparseInfillDensity !== undefined) keys.sparse_infill_density = overrides.sparseInfillDensity;
+  return keys;
+}
+
+/** PrusaSlicer/Slic3r command-line options, which override the loaded config. */
+export function prusaSlicerOverrideArgs(overrides: ProcessOverrides | undefined): string[] {
+  const args: string[] = [];
+  if (overrides?.layerHeight !== undefined) args.push('--layer-height', String(overrides.layerHeight));
+  if (overrides?.wallLoops !== undefined) args.push('--perimeters', String(overrides.wallLoops));
+  if (overrides?.sparseInfillDensity !== undefined) args.push('--fill-density', overrides.sparseInfillDensity);
+  return args;
+}
 import { execFile } from 'child_process';
 import { scanGcodeThermal } from '../safety/gcode-thermal.js';
 
@@ -136,6 +165,49 @@ export class STLManipulator extends EventEmitter {
     }
   }
 
+  /**
+   * Generic OrcaSlicer: write the overrides over a copy of the process profile
+   * (the settings file whose type is "process", else the last of two or more).
+   */
+  private withOrcaProcessOverrides(
+    profiles: { settingsProfiles: string[]; filamentProfiles: string[] },
+    overrides: ProcessOverrides | undefined,
+    outputDir: string
+  ): { settingsProfiles: string[]; filamentProfiles: string[] } {
+    const keys = orcaProcessOverrides(overrides);
+    if (!Object.keys(keys).length) return profiles;
+    const parsed = profiles.settingsProfiles.map((profile) => {
+      try { return JSON.parse(fs.readFileSync(profile, 'utf8')); } catch { return undefined; }
+    });
+    let index = parsed.findIndex((profile) => profile?.type === 'process');
+    if (index < 0 && profiles.settingsProfiles.length >= 2) index = profiles.settingsProfiles.length - 1;
+    if (index < 0 || !parsed[index] || typeof parsed[index] !== 'object') {
+      throw new SlicerError('preparation',
+        'layer_height, wall_loops and sparse_infill_density need a readable process profile for generic OrcaSlicer. ' +
+        "Pass slicer_profile as 'machine.json;process.json', or slice with bambu_model.",
+        { slicerType: 'orcaslicer' });
+    }
+    const merged = path.join(outputDir, `process-overrides-${path.basename(profiles.settingsProfiles[index])}`);
+    fs.writeFileSync(merged, JSON.stringify({ ...parsed[index], ...keys }, null, 2));
+    const settingsProfiles = [...profiles.settingsProfiles];
+    settingsProfiles[index] = merged;
+    return { ...profiles, settingsProfiles };
+  }
+
+  /** Bundled and user Orca filament presets inherit their settings; the CLI needs them merged in. */
+  private async withFlattenedOrcaFilaments<T extends { settingsProfiles: string[]; filamentProfiles: string[] }>(
+    profiles: T, slicerPath: string, outputDir: string
+  ): Promise<T> {
+    const filamentProfiles = await Promise.all(profiles.filamentProfiles.map(async (profile, index) => {
+      const flat = await flattenOrcaFilament(profile, { slicerPath }).catch(() => undefined);
+      if (!flat) return profile;
+      const merged = path.join(outputDir, `filament-${index + 1}-${path.basename(profile)}`);
+      fs.writeFileSync(merged, JSON.stringify(flat, null, 2));
+      return merged;
+    }));
+    return { ...profiles, filamentProfiles };
+  }
+
   private appendOrcaProfileArgs(
     args: string[],
     profiles: { settingsProfiles: string[]; filamentProfiles: string[] }
@@ -1022,7 +1094,8 @@ export class STLManipulator extends EventEmitter {
     progressCallback?: ProgressCallback,
     printerPreset?: string,
     filamentProfile?: string,
-    bambuOptions?: BambuSliceOptions
+    bambuOptions?: BambuSliceOptions,
+    processOverrides?: ProcessOverrides
   ): Promise<string> {
     const operationId = this.generateOperationId();
     this.activeOperations.set(operationId, true);
@@ -1076,6 +1149,8 @@ export class STLManipulator extends EventEmitter {
             );
           }
           const options: BambuSliceOptions = { ...bambuOptions };
+          const overrideKeys = orcaProcessOverrides(processOverrides);
+          if (Object.keys(overrideKeys).length) options.processOverrides = overrideKeys;
           if (orcaProfiles.filamentProfiles.length > 0) {
             const legacyFilaments = orcaProfiles.filamentProfiles.join(';');
             if (options.loadFilaments && this.splitProfileList(options.loadFilaments).join(';') !== legacyFilaments) {
@@ -1112,16 +1187,29 @@ export class STLManipulator extends EventEmitter {
       } else {
         switch (slicerType) {
           case 'prusaslicer':
-          case 'slic3r': // PrusaSlicer and Slic3r share similar CLI args
+          case 'slic3r': { // PrusaSlicer and Slic3r share similar CLI args
+            // A filament preset (.ini from the slicer's filament folder) is loaded after the main
+            // config: --load may repeat, and later files override earlier ones.
+            const filaments = this.splitProfileList(filamentProfile);
+            if (filaments.length > 1) {
+              throw new SlicerError('preparation',
+                `${slicerType} takes one filament preset; filament_profile/FILAMENT_PROFILE lists ${filaments.length}.`, { slicerType, slicerPath });
+            }
+            if (filaments.length && !/\.ini$/i.test(filaments[0])) {
+              throw new SlicerError('preparation',
+                `${slicerType} loads filament presets as .ini files (its filament folder, or File > Export > Export Config); ${path.basename(filaments[0])} is not one.`,
+                { slicerType, slicerPath });
+            }
             args = [
               '--slice',
               '--output', outputFilePath,
-              '--load', slicerProfile || '', // Pass profile path
+              ...(slicerProfile ? ['--load', slicerProfile] : []),
+              ...filaments.flatMap((filament) => ['--load', filament]),
+              ...prusaSlicerOverrideArgs(processOverrides),
               stlFilePath
             ];
-            // Remove empty profile arg if not provided
-            args = args.filter(arg => arg !== '');
             break;
+          }
 
           case 'orcaslicer':
             orcaOutputDir = path.join(this.tempDir, `${operationId}-orca-output`);
@@ -1130,11 +1218,17 @@ export class STLManipulator extends EventEmitter {
               '--slice', '0',
               '--outputdir', orcaOutputDir,
             ];
-            this.appendOrcaProfileArgs(args, orcaProfiles);
+            this.appendOrcaProfileArgs(args, await this.withFlattenedOrcaFilaments(
+              this.withOrcaProcessOverrides(orcaProfiles, processOverrides, orcaOutputDir), slicerPath, orcaOutputDir));
             args.push(stlFilePath);
             break;
 
           case 'cura':
+            if (Object.keys(orcaProcessOverrides(processOverrides)).length) {
+              throw new SlicerError('preparation',
+                'layer_height, wall_loops and sparse_infill_density are not mapped for Cura; set them in the Cura definition passed as slicer_profile.',
+                { slicerType, slicerPath });
+            }
             // CuraEngine CLI args are different, often requiring -s for settings
             // Example: curaengine slice -v -j cura_settings.json -s layer_height=0.2 -o output.gcode -l input.stl
             args = [
@@ -1503,24 +1597,25 @@ export class STLManipulator extends EventEmitter {
       if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
       if (progressCallback) progressCallback(75, "Finding largest flat surface...");
 
-      // Find the group with the largest total area (excluding near-vertical faces)
+      // Include already-horizontal faces: excluding Z-aligned normals can
+      // stand a flat model on its edge, including on a repeated layFlat call.
       let largestArea = 0;
       let targetNormal: THREE.Vector3 | null = null;
-      const upVector = new THREE.Vector3(0, 1, 0); // Assuming Y is up for most models initially?
       const downVector = new THREE.Vector3(0, 0, -1); // Target normal (pointing down)
 
+      // Faces are grouped by direction, so a part whose flat faces are all
+      // horizontal has equal up- and down-facing areas. On a tie, keep the
+      // face that already points down so a seated part is not flipped.
       for (const group of normalGroups.values()) {
-          // Check if the normal is reasonably horizontal (not too close to vertical Z)
-          // Angle threshold could be adjusted (e.g., > 5 degrees from Z axis)
-          if (Math.abs(group.representativeNormal.z) < 0.99 && group.totalArea > largestArea) {
+          const tied = targetNormal !== null && Math.abs(group.totalArea - largestArea) <= largestArea * 1e-6;
+          if (tied ? group.representativeNormal.z < targetNormal!.z : group.totalArea > largestArea) {
               largestArea = group.totalArea;
               targetNormal = group.representativeNormal;
           }
       }
 
       if (!targetNormal) {
-          // If no suitable horizontal face found, maybe pick the lowest Z face?
-          // For now, throw an error or return unchanged.
+          // Only a mesh without any face area reaches this.
           console.warn("Could not find a suitable large flat face to lay down. No changes made.");
           this.emit('operationComplete', { operationId, type: 'layFlat', success: true, output: stlFilePath, message: "No suitable flat face found." });
           return stlFilePath;