mcp-3d-printer-server 1.2.1 → 1.2.4

package/src/printers/prusa.ts

@@ -11,13 +11,49 @@ type RequestCandidate = {
 export class PrusaImplementation extends PrinterImplementation {
   private buildAuthHeaders(apiKey: string): Record<string, string> {
     return {
+      Accept: "application/json",
       "X-Api-Key": apiKey,
       Authorization: `Bearer ${apiKey}`,
     };
   }
 
   private buildBaseUrl(host: string, port: string): string {
-    return `http://${host}:${port}`;
+    const trimmedHost = host.trim();
+    const trimmedPort = port.trim();
+    if (!trimmedHost) {
+      throw new Error("Prusa host is required.");
+    }
+
+    const rawBaseUrl = /^[a-z][a-z\d+.-]*:\/\//i.test(trimmedHost)
+      ? trimmedHost
+      : `${this.defaultProtocolFor(trimmedHost, trimmedPort)}://${trimmedHost}`;
+    const parsed = new URL(rawBaseUrl);
+
+    if (trimmedPort && !parsed.port && !this.isDefaultPort(parsed.protocol, trimmedPort)) {
+      parsed.port = trimmedPort;
+    }
+
+    return parsed.toString().replace(/\/$/, "");
+  }
+
+  private defaultProtocolFor(host: string, port: string): "http" | "https" {
+    if (port === "443" || this.isPrusaConnectCloudHost(host)) {
+      return "https";
+    }
+    return "http";
+  }
+
+  private isDefaultPort(protocol: string, port: string): boolean {
+    return (protocol === "https:" && port === "443") || (protocol === "http:" && port === "80");
+  }
+
+  private isPrusaConnectCloudHost(host: string): boolean {
+    try {
+      const parsed = new URL(/^[a-z][a-z\d+.-]*:\/\//i.test(host) ? host : `https://${host}`);
+      return parsed.hostname.toLowerCase() === "connect.prusa3d.com";
+    } catch {
+      return host.toLowerCase().split(":")[0] === "connect.prusa3d.com";
+    }
   }
 
   private isFallbackStatus(error: unknown): boolean {
@@ -86,6 +122,7 @@ export class PrusaImplementation extends PrinterImplementation {
 
   async getStatus(host: string, port: string, apiKey: string) {
     const response = await this.getWithFallback(host, port, apiKey, [
+      "/api/v1/status",
       "/api/v1/printer",
       "/api/printer",
     ]);

package/src/stl/stl-manipulator.ts

@@ -11,6 +11,7 @@ import { execFile } from 'child_process';
 
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
+const DEFAULT_SLICER_TIMEOUT_MS = 10 * 60 * 1000;
 
 // Define types for progress tracking
 export type ProgressCallback = (progress: number, message?: string) => void;
@@ -21,6 +22,14 @@ export type OperationResult = {
   operationId: string;
 };
 
+export type SlicerType =
+  | 'prusaslicer'
+  | 'cura'
+  | 'slic3r'
+  | 'orcaslicer'
+  | 'orcaslicer-bambulab'
+  | 'bambustudio';
+
 // Define possible transformation operations
 export type TransformationType = 'scale' | 'rotate' | 'translate' | 'extendBase' | 'customModify';
 export type TransformationAxis = 'x' | 'y' | 'z' | 'all';
@@ -60,6 +69,138 @@ export class STLManipulator extends EventEmitter {
     return crypto.randomUUID();
   }
 
+  private validateSlicerExecutable(slicerPath: string): void {
+    if (!slicerPath.trim()) {
+      throw new Error("Slicer executable path is required.");
+    }
+
+    const looksLikePath = path.isAbsolute(slicerPath) || /[\\/]/.test(slicerPath);
+    if (looksLikePath && !fs.existsSync(slicerPath)) {
+      throw new Error(`Slicer executable not found at: ${slicerPath}`);
+    }
+  }
+
+  private splitProfileList(profileList?: string): string[] {
+    return (profileList || "")
+      .split(";")
+      .map((profile) => profile.trim())
+      .filter((profile) => profile.length > 0);
+  }
+
+  private parseOrcaProfileArgs(
+    slicerProfile?: string,
+    filamentProfile?: string
+  ): { settingsProfiles: string[]; filamentProfiles: string[] } {
+    const [settingsSegment = "", filamentSegment = ""] = (slicerProfile || "").split("|", 2);
+
+    return {
+      settingsProfiles: this.splitProfileList(settingsSegment),
+      filamentProfiles: [
+        ...this.splitProfileList(filamentSegment),
+        ...this.splitProfileList(filamentProfile),
+      ],
+    };
+  }
+
+  private warnForMissingProfiles(profiles: string[], label: string): void {
+    for (const profile of profiles) {
+      if (!fs.existsSync(profile)) {
+        console.warn(`${label} specified but not found: ${profile}. Slicer might use defaults.`);
+      }
+    }
+  }
+
+  private appendOrcaProfileArgs(
+    args: string[],
+    profiles: { settingsProfiles: string[]; filamentProfiles: string[] }
+  ): void {
+    for (const profile of profiles.settingsProfiles) {
+      args.push('--load-settings', profile);
+    }
+    for (const profile of profiles.filamentProfiles) {
+      args.push('--load-filaments', profile);
+    }
+  }
+
+  private resolveOrcaGcodeOutput(outputDir: string): string {
+    const preferredPath = path.join(outputDir, 'plate_1.gcode');
+    if (fs.existsSync(preferredPath)) {
+      return preferredPath;
+    }
+
+    const plateOutputs = fs.readdirSync(outputDir)
+      .filter((entry) => /^plate_\d+\.gcode$/i.test(entry))
+      .sort((a, b) => {
+        const aNumber = Number(a.match(/\d+/)?.[0] || 0);
+        const bNumber = Number(b.match(/\d+/)?.[0] || 0);
+        return aNumber - bNumber;
+      });
+
+    if (plateOutputs.length === 0) {
+      throw new Error(`OrcaSlicer finished but no plate_N.gcode file was found in: ${outputDir}`);
+    }
+
+    return path.join(outputDir, plateOutputs[0]);
+  }
+
+  private resolveBambuMachinePresetPath(slicerPath: string, printerPreset: string): string {
+    if (fs.existsSync(printerPreset)) {
+      return printerPreset;
+    }
+
+    const presetFile = printerPreset.endsWith(".json") ? printerPreset : `${printerPreset}.json`;
+    const candidateDirs: string[] = [];
+    const macAppMarker = `${path.sep}Contents${path.sep}MacOS${path.sep}`;
+    const macAppIndex = slicerPath.indexOf(macAppMarker);
+
+    if (macAppIndex >= 0) {
+      candidateDirs.push(
+        path.join(
+          slicerPath.slice(0, macAppIndex + `${path.sep}Contents`.length),
+          "Resources",
+          "profiles",
+          "BBL",
+          "machine"
+        )
+      );
+    }
+
+    const executableDir = path.dirname(slicerPath);
+    candidateDirs.push(
+      path.join(executableDir, "..", "Resources", "profiles", "BBL", "machine"),
+      path.join(executableDir, "..", "share", "OrcaSlicer", "resources", "profiles", "BBL", "machine"),
+      path.join(executableDir, "..", "resources", "profiles", "BBL", "machine"),
+      path.join(executableDir, "resources", "profiles", "BBL", "machine")
+    );
+
+    for (const candidateDir of candidateDirs) {
+      const candidate = path.resolve(candidateDir, presetFile);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+
+    throw new Error(
+      `Could not find Bambu machine preset "${presetFile}" near slicer executable ${slicerPath}. ` +
+      "Pass slicer_profile with an explicit machine/process settings file, or use a slicer bundle that includes Resources/profiles/BBL/machine."
+    );
+  }
+
+  private resolveSlicerTimeoutMs(): number {
+    const rawTimeout = process.env.SLICER_TIMEOUT_MS?.trim();
+    if (!rawTimeout) {
+      return DEFAULT_SLICER_TIMEOUT_MS;
+    }
+
+    const timeoutMs = Number(rawTimeout);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      console.warn(`Invalid SLICER_TIMEOUT_MS value "${rawTimeout}", using ${DEFAULT_SLICER_TIMEOUT_MS}.`);
+      return DEFAULT_SLICER_TIMEOUT_MS;
+    }
+
+    return timeoutMs;
+  }
+
   /**
    * Load STL file and return geometry and bounding box
    */
@@ -845,7 +986,7 @@ export class STLManipulator extends EventEmitter {
   /**
    * Slice an STL or 3MF file using the specified slicer
    * @param stlFilePath Path to the input STL or 3MF file
-   * @param slicerType Type of slicer (prusaslicer, cura, slic3r, orcaslicer, bambustudio)
+   * @param slicerType Type of slicer (prusaslicer, cura, slic3r, orcaslicer, orcaslicer-bambulab, bambustudio)
    * @param slicerPath Path to the slicer executable
    * @param slicerProfile Optional path to the slicer profile/config file
    * @param progressCallback Optional callback for progress updates
@@ -853,25 +994,32 @@ export class STLManipulator extends EventEmitter {
    */
   async sliceSTL(
     stlFilePath: string,
-    slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio',
+    slicerType: SlicerType,
     slicerPath: string,
     slicerProfile?: string,
     progressCallback?: ProgressCallback,
-    printerPreset?: string
+    printerPreset?: string,
+    filamentProfile?: string
   ): Promise<string> {
     const operationId = this.generateOperationId();
     this.activeOperations.set(operationId, true);
 
-    if (!fs.existsSync(slicerPath)) {
-      throw new Error(`Slicer executable not found at: ${slicerPath}`);
+    this.validateSlicerExecutable(slicerPath);
+    const orcaProfiles = this.parseOrcaProfileArgs(slicerProfile, filamentProfile);
+    if (slicerType === 'orcaslicer') {
+      this.warnForMissingProfiles(orcaProfiles.settingsProfiles, 'Slicer profile');
+      this.warnForMissingProfiles(orcaProfiles.filamentProfiles, 'Filament profile');
+    } else if (slicerProfile && !fs.existsSync(slicerProfile)) {
+      console.warn(`Slicer profile specified but not found: ${slicerProfile}. Slicer might use defaults.`);
+      // Allow proceeding without profile, slicer might handle it
     }
-    if (slicerProfile && !fs.existsSync(slicerProfile)) {
-        console.warn(`Slicer profile specified but not found: ${slicerProfile}. Slicer might use defaults.`);
-        // Allow proceeding without profile, slicer might handle it
+    if (slicerType !== 'orcaslicer' && filamentProfile && !fs.existsSync(filamentProfile)) {
+      console.warn(`Filament profile specified but not found: ${filamentProfile}. Slicer might use defaults.`);
     }
 
     const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
     let outputFilePath = path.join(this.tempDir, outputFileName);
+    let orcaOutputDir: string | undefined;
 
     let args: string[] = [];
 
@@ -892,22 +1040,14 @@ export class STLManipulator extends EventEmitter {
           break;
 
         case 'orcaslicer': // Add OrcaSlicer case
+           orcaOutputDir = path.join(this.tempDir, `${operationId}-orca-output`);
+           fs.mkdirSync(orcaOutputDir, { recursive: true });
            args = [
-               // OrcaSlicer might use --load-settings like Bambu, or --load like Prusa
-               // Assuming --load-settings based on discussion, adjust if needed.
-               // Also assuming profile path points to the main .ini or .json config.
-               '--load-settings', slicerProfile || '',
-               '--output', outputFilePath, // Assuming --output works like PrusaSlicer
-               stlFilePath
+               '--slice', '0',
+               '--outputdir', orcaOutputDir,
            ];
-           // Alternative if --output doesn't specify filename:
-           // args = [
-           //    '--load-settings', slicerProfile || '',
-           //    '--outputdir', this.tempDir,
-           //    stlFilePath
-           // ];
-           // Remove empty profile arg if not provided
-           args = args.filter(arg => arg !== '');
+           this.appendOrcaProfileArgs(args, orcaProfiles);
+           args.push(stlFilePath);
            break;
 
         case 'cura':
@@ -925,8 +1065,10 @@ export class STLManipulator extends EventEmitter {
           }
           break;
 
+        case 'orcaslicer-bambulab':
         case 'bambustudio':
-          // Bambu Studio CLI: slice and export as 3MF with embedded gcode
+          // Bambu project slicers: slice and export as 3MF with embedded gcode.
+          // orcaslicer-bambulab is the FULU fork that restores BambuNetwork support.
           // For 3MF input: slice in place and export sliced 3MF
           // For STL input: slice and export as 3MF
           {
@@ -937,13 +1079,16 @@ export class STLManipulator extends EventEmitter {
               '--slice', '0',  // Slice all plates
               '--export-3mf', bambuOutputPath,
             ];
-            // --load-machine ensures correct G-code for the specific printer model
+            // FULU Orca/Bambu Studio load machine presets as JSON settings files.
             if (printerPreset && !slicerProfile) {
-              args.push('--load-machine', printerPreset);
+              args.push('--load-settings', this.resolveBambuMachinePresetPath(slicerPath, printerPreset));
             }
             if (slicerProfile) {
               args.push('--load-settings', slicerProfile);
             }
+            if (filamentProfile) {
+              args.push('--load-filaments', filamentProfile);
+            }
             args.push(stlFilePath);
             // Override outputFilePath for bambustudio since it produces 3MF, not gcode
             outputFilePath = bambuOutputPath;
@@ -959,20 +1104,49 @@ export class STLManipulator extends EventEmitter {
 
       // Execute the slicer
       await new Promise<void>((resolve, reject) => {
+        const timeoutMs = this.resolveSlicerTimeoutMs();
+        let settled = false;
+        let slicerProcessKilledByTimeout = false;
+        let timeoutHandle: NodeJS.Timeout | undefined;
+
+        const settle = (callback: () => void) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+          callback();
+        };
+
         const process = execFile(slicerPath, args, (error, stdout, stderr) => {
           if (error) {
             console.error(`Slicer Error: ${error.message}`);
             console.error(`Slicer Stderr: ${stderr}`);
-            reject(new Error(`Slicer failed: ${error.message}. Stderr: ${stderr}`));
+            const timeoutMessage = slicerProcessKilledByTimeout
+              ? ` Slicer exceeded timeout ${timeoutMs}ms.`
+              : "";
+            settle(() => reject(new Error(`Slicer failed: ${error.message}.${timeoutMessage} Stderr: ${stderr}`)));
           } else {
             console.log(`Slicer Stdout: ${stdout}`);
              if (stderr) {
                  console.warn(`Slicer Stderr: ${stderr}`); // Log stderr even on success
              }
-            resolve();
+            settle(() => resolve());
           }
         });
 
+        timeoutHandle = setTimeout(() => {
+          slicerProcessKilledByTimeout = true;
+          try {
+            process.kill("SIGKILL");
+          } catch (killError) {
+            console.error("Error attempting to kill timed-out slicer process:", killError);
+          }
+          settle(() => reject(new Error(`Slicer exceeded timeout ${timeoutMs}ms.`)));
+        }, timeoutMs);
+
         // Optional: Add listeners for stdout/stderr for real-time progress if slicer provides it
         // process.stdout?.on('data', (data) => { console.log(`Slicer stdout: ${data}`); });
         // process.stderr?.on('data', (data) => { console.log(`Slicer stderr: ${data}`); });
@@ -983,10 +1157,10 @@ export class STLManipulator extends EventEmitter {
                clearInterval(checkCancel);
                try {
                    process.kill(); // Attempt to kill the slicer process
-                   reject(new Error("Slicing operation cancelled"));
+                   settle(() => reject(new Error("Slicing operation cancelled")));
                } catch (killError) {
                    console.error("Error attempting to kill slicer process:", killError);
-                   reject(new Error("Slicing operation cancelled, but failed to kill process."));
+                   settle(() => reject(new Error("Slicing operation cancelled, but failed to kill process.")));
                }
            }
        }, 500); 
@@ -1000,6 +1174,17 @@ export class STLManipulator extends EventEmitter {
         // This check might be redundant if the promise rejected on kill, but good safety
         throw new Error("Slicing operation cancelled after process finished");
       }
+
+      if (slicerType === 'orcaslicer') {
+        if (!orcaOutputDir) {
+          throw new Error("Internal error: OrcaSlicer output directory was not initialized.");
+        }
+        const orcaGcodePath = this.resolveOrcaGcodeOutput(orcaOutputDir);
+        if (fs.existsSync(outputFilePath)) {
+          fs.unlinkSync(outputFilePath);
+        }
+        fs.renameSync(orcaGcodePath, outputFilePath);
+      }
       
       if (!fs.existsSync(outputFilePath)) {
           throw new Error(`Slicer finished but output file not found: ${outputFilePath}`);
@@ -1024,6 +1209,9 @@ export class STLManipulator extends EventEmitter {
       });
       throw error; 
     } finally {
+      if (orcaOutputDir && fs.existsSync(orcaOutputDir)) {
+        fs.rmSync(orcaOutputDir, { recursive: true, force: true });
+      }
       this.activeOperations.delete(operationId);
     }
   }

package/dist/http-server.d.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-declare class ThreeDPrinterMCPServerHTTP {
-    private server;
-    private printerFactory;
-    private stlManipulator;
-    private app;
-    constructor();
-    private setupExpressApp;
-    private handleJSONRPCRequest;
-    setupErrorHandling(): void;
-    setupHandlers(): void;
-    setupResourceHandlers(): void;
-    setupToolHandlers(): void;
-    run(): Promise<void>;
-}
-export default ThreeDPrinterMCPServerHTTP;