mcp-3d-printer-server 1.2.2 → 1.2.4

package/dist/printers/prusa.d.ts

@@ -2,6 +2,9 @@ import { PrinterImplementation } from "../types.js";
 export declare class PrusaImplementation extends PrinterImplementation {
     private buildAuthHeaders;
     private buildBaseUrl;
+    private defaultProtocolFor;
+    private isDefaultPort;
+    private isPrusaConnectCloudHost;
     private isFallbackStatus;
     private getWithFallback;
     private postWithFallback;

package/dist/printers/prusa.js

@@ -5,12 +5,43 @@ import FormData from "form-data";
 export class PrusaImplementation extends PrinterImplementation {
     buildAuthHeaders(apiKey) {
         return {
+            Accept: "application/json",
             "X-Api-Key": apiKey,
             Authorization: `Bearer ${apiKey}`,
         };
     }
     buildBaseUrl(host, port) {
-        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(/\/$/, "");
+    }
+    defaultProtocolFor(host, port) {
+        if (port === "443" || this.isPrusaConnectCloudHost(host)) {
+            return "https";
+        }
+        return "http";
+    }
+    isDefaultPort(protocol, port) {
+        return (protocol === "https:" && port === "443") || (protocol === "http:" && port === "80");
+    }
+    isPrusaConnectCloudHost(host) {
+        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";
+        }
     }
     isFallbackStatus(error) {
         if (!isAxiosError(error)) {
@@ -61,6 +92,7 @@ export class PrusaImplementation extends PrinterImplementation {
     }
     async getStatus(host, port, apiKey) {
         const response = await this.getWithFallback(host, port, apiKey, [
+            "/api/v1/status",
             "/api/v1/printer",
             "/api/printer",
         ]);

package/dist/stl/stl-manipulator.d.ts

@@ -7,6 +7,7 @@ export type OperationResult = {
     error?: string;
     operationId: string;
 };
+export type SlicerType = 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'orcaslicer-bambulab' | 'bambustudio';
 export type TransformationType = 'scale' | 'rotate' | 'translate' | 'extendBase' | 'customModify';
 export type TransformationAxis = 'x' | 'y' | 'z' | 'all';
 export type BoundingBox = {
@@ -30,6 +31,14 @@ export declare class STLManipulator extends EventEmitter {
      * Generate a unique operation ID
      */
     private generateOperationId;
+    private validateSlicerExecutable;
+    private splitProfileList;
+    private parseOrcaProfileArgs;
+    private warnForMissingProfiles;
+    private appendOrcaProfileArgs;
+    private resolveOrcaGcodeOutput;
+    private resolveBambuMachinePresetPath;
+    private resolveSlicerTimeoutMs;
     /**
      * Load STL file and return geometry and bounding box
      */
@@ -92,13 +101,13 @@ export declare 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
      * @returns Path to the generated G-code or sliced 3MF file
      */
-    sliceSTL(stlFilePath: string, slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio', slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string): Promise<string>;
+    sliceSTL(stlFilePath: string, slicerType: SlicerType, slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string, filamentProfile?: string): Promise<string>;
     /**
      * Enhanced version of confirmTemperatures with better error handling
      * @param gcodePath Path to the G-code file

package/dist/stl/stl-manipulator.js

@@ -10,6 +10,7 @@ import * as crypto from 'crypto';
 import { execFile } from 'child_process';
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
+const DEFAULT_SLICER_TIMEOUT_MS = 10 * 60 * 1000;
 export class STLManipulator extends EventEmitter {
     constructor(tempDir = path.join(process.cwd(), 'temp')) {
         super();
@@ -26,6 +27,97 @@ export class STLManipulator extends EventEmitter {
     generateOperationId() {
         return crypto.randomUUID();
     }
+    validateSlicerExecutable(slicerPath) {
+        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}`);
+        }
+    }
+    splitProfileList(profileList) {
+        return (profileList || "")
+            .split(";")
+            .map((profile) => profile.trim())
+            .filter((profile) => profile.length > 0);
+    }
+    parseOrcaProfileArgs(slicerProfile, filamentProfile) {
+        const [settingsSegment = "", filamentSegment = ""] = (slicerProfile || "").split("|", 2);
+        return {
+            settingsProfiles: this.splitProfileList(settingsSegment),
+            filamentProfiles: [
+                ...this.splitProfileList(filamentSegment),
+                ...this.splitProfileList(filamentProfile),
+            ],
+        };
+    }
+    warnForMissingProfiles(profiles, label) {
+        for (const profile of profiles) {
+            if (!fs.existsSync(profile)) {
+                console.warn(`${label} specified but not found: ${profile}. Slicer might use defaults.`);
+            }
+        }
+    }
+    appendOrcaProfileArgs(args, profiles) {
+        for (const profile of profiles.settingsProfiles) {
+            args.push('--load-settings', profile);
+        }
+        for (const profile of profiles.filamentProfiles) {
+            args.push('--load-filaments', profile);
+        }
+    }
+    resolveOrcaGcodeOutput(outputDir) {
+        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]);
+    }
+    resolveBambuMachinePresetPath(slicerPath, printerPreset) {
+        if (fs.existsSync(printerPreset)) {
+            return printerPreset;
+        }
+        const presetFile = printerPreset.endsWith(".json") ? printerPreset : `${printerPreset}.json`;
+        const candidateDirs = [];
+        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.");
+    }
+    resolveSlicerTimeoutMs() {
+        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
      */
@@ -646,24 +738,31 @@ 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
      * @returns Path to the generated G-code or sliced 3MF file
      */
-    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset) {
+    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile) {
         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');
         }
-        if (slicerProfile && !fs.existsSync(slicerProfile)) {
+        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 (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;
         let args = [];
         try {
             if (progressCallback)
@@ -681,22 +780,14 @@ export class STLManipulator extends EventEmitter {
                     args = args.filter(arg => arg !== '');
                     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':
                     // CuraEngine CLI args are different, often requiring -s for settings
@@ -712,8 +803,10 @@ export class STLManipulator extends EventEmitter {
                         args.push('-j', slicerProfile); // Load settings from profile definition file
                     }
                     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
                     {
@@ -724,13 +817,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;
@@ -744,20 +840,47 @@ export class STLManipulator extends EventEmitter {
             console.log(`Executing: ${slicerPath} ${args.join(' ')}`);
             // Execute the slicer
             await new Promise((resolve, reject) => {
+                const timeoutMs = this.resolveSlicerTimeoutMs();
+                let settled = false;
+                let slicerProcessKilledByTimeout = false;
+                let timeoutHandle;
+                const settle = (callback) => {
+                    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}`); });
@@ -767,11 +890,11 @@ 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);
@@ -782,6 +905,16 @@ 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}`);
             }
@@ -805,6 +938,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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcp-3d-printer-server",
-    "version": "1.2.2",
+    "version": "1.2.4",
     "description": "MCP server for connecting Claude with 3D printer management systems",
     "main": "dist/index.js",
     "repository": "https://github.com/DMontgomery40/mcp-3D-printer-server",
@@ -18,8 +18,28 @@
         "mcp-3d-printer-server": "./dist/index.js"
     },
     "files": [
-        "dist",
-        "src",
+        "dist/3mf_parser.d.ts",
+        "dist/3mf_parser.js",
+        "dist/fulu-orca.d.ts",
+        "dist/fulu-orca.js",
+        "dist/index.d.ts",
+        "dist/index.js",
+        "dist/index.js.map",
+        "dist/printers",
+        "dist/stl",
+        "dist/test",
+        "dist/types.d.ts",
+        "dist/types.js",
+        "src/3mf_parser.ts",
+        "src/fulu-orca.ts",
+        "src/index.ts",
+        "src/printers",
+        "src/stl",
+        "src/test/3DBenchy.3mf",
+        "src/test/stl-manipulator-test.js",
+        "src/test/stl-manipulator-test.ts",
+        "src/test/tsconfig.json",
+        "src/types.ts",
         "README.md",
         "LICENSE"
     ],