bambu-printer-mcp 1.1.27 → 1.1.29

package/dist/slicer/remote-slicer.js

@@ -0,0 +1,240 @@
+/** AFKFelix/orca-slicer-api contract at a9a28f0a7b0c6f51b9be158509e9e9677532b868. */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { inspectPrintFile } from '../safety/print-file.js';
+import { normalizeMaterial, normalizeModel } from '../safety/limits.js';
+const MAX_BYTES = 100000000;
+const SUPPORTED_OPTIONS = new Set([
+    'arrange', 'orient', 'loadFilaments', 'filamentColours', 'bedType',
+    'nozzleType', 'nozzleVolumeType', 'slicePlate',
+]);
+function configuration() {
+    let url;
+    try {
+        url = new URL(process.env.SLICER_API_URL ?? '');
+    }
+    catch {
+        throw new Error('Remote slicing requires a valid trusted SLICER_API_URL.');
+    }
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+        throw new Error('SLICER_API_URL must use HTTP(S) without embedded credentials, query or fragment.');
+    }
+    const mode = process.env.SLICER_API_MODE || 'sync';
+    if (!['sync', 'async'].includes(mode))
+        throw new Error('SLICER_API_MODE must be sync or async.');
+    const timeout = Number(process.env.SLICER_API_TIMEOUT_MS ?? 600000);
+    if (!Number.isInteger(timeout) || timeout < 1 || timeout > 3600000) {
+        throw new Error('SLICER_API_TIMEOUT_MS must be an integer from 1 to 3600000.');
+    }
+    const headers = {};
+    const token = process.env.SLICER_API_TOKEN;
+    if (token) {
+        const header = process.env.SLICER_API_TOKEN_HEADER || 'Authorization';
+        if (!/^[a-zA-Z0-9!#$%&'*+.^_`|~-]+$/.test(header) ||
+            ['host', 'content-type', 'content-length', 'connection', 'transfer-encoding'].includes(header.toLowerCase()) ||
+            /[^\x20-\x7e]/.test(token)) {
+            throw new Error('Invalid remote slicing authentication configuration.');
+        }
+        headers[header] = header.toLowerCase() === 'authorization' ? `Bearer ${token}` : token;
+    }
+    return { base: url.href.replace(/\/+$/, ''), headers, mode, timeout };
+}
+export function validateRemoteSliceOptions(options = {}) {
+    for (const [key, value] of Object.entries(options)) {
+        if (value !== undefined && !SUPPORTED_OPTIONS.has(key)) {
+            throw new Error(`Remote slicing option ${key} is unsupported by orca-slicer-api; use a local backend for this workflow.`);
+        }
+    }
+    // Upstream evaluates multipart values by truthiness, so the string "false"
+    // becomes true. Never silently turn an explicit false into an enabled flag.
+    if (options.arrange === false || options.orient === false) {
+        throw new Error('Remote arrange=false and orient=false are unsupported by the upstream multipart API.');
+    }
+    const plate = options.slicePlate ?? 1;
+    if (!Number.isInteger(plate) || plate < 1)
+        throw new Error('Remote slicing requires one positive plate number; slicing all plates is unsupported.');
+    return plate;
+}
+/** The remote API forwards this display name to Orca's --curr-bed-type. */
+function remoteBedType(value) {
+    const names = {
+        textured_plate: 'Textured PEI Plate', textured_pei_plate: 'Textured PEI Plate',
+        cool_plate: 'Cool Plate', engineering_plate: 'Engineering Plate',
+        hot_plate: 'High Temp Plate', high_temp_plate: 'High Temp Plate',
+    };
+    const key = typeof value === 'string' ? value.trim().toLowerCase().replace(/[\s-]+/g, '_') : '';
+    if (typeof names[key] !== 'string')
+        throw new Error('Unsupported remote bed type; use textured_plate, cool_plate, engineering_plate, or hot_plate.');
+    return names[key];
+}
+async function readResponse(response, limit) {
+    const size = Number(response.headers.get('content-length'));
+    if (size > limit) {
+        await response.body?.cancel();
+        throw new Error('Remote slicing response exceeds the size limit.');
+    }
+    if (!response.body)
+        throw new Error('Remote slicing returned an empty response.');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            length += value.byteLength;
+            if (length > limit)
+                throw new Error('Remote slicing response exceeds the size limit.');
+            chunks.push(value);
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    return Buffer.concat(chunks);
+}
+async function readJob(response) {
+    try {
+        const job = JSON.parse((await readResponse(response, 65536)).toString('utf8'));
+        if (job && typeof job === 'object' && !Array.isArray(job))
+            return job;
+    }
+    catch { /* Do not echo an untrusted response, which may contain credentials. */ }
+    throw new Error('Remote slicing returned invalid job metadata.');
+}
+/** Upload only locally prepared profiles, then inspect the exact downloaded 3MF. */
+export async function sliceWithOrcaApi(input) {
+    const options = input.options ?? {};
+    const plate = validateRemoteSliceOptions(options);
+    if (input.filamentPaths.length !== 1 || (options.filamentColours && options.filamentColours.length !== 1)) {
+        throw new Error('orca-slicer-api supports exactly one filament slot; multi-slot projects require a local slicer.');
+    }
+    const config = configuration();
+    const machine = JSON.parse(await fs.readFile(input.machinePath, 'utf8'));
+    const filament = JSON.parse(await fs.readFile(input.filamentPaths[0], 'utf8'));
+    const processProfile = JSON.parse(await fs.readFile(input.processPath, 'utf8'));
+    const bedType = remoteBedType(options.bedType ?? processProfile.curr_bed_type ?? 'textured_plate');
+    const model = normalizeModel(machine.printer_model);
+    const nozzles = Array.isArray(machine.nozzle_diameter) ? machine.nozzle_diameter.map(Number) : [];
+    const materialValues = Array.isArray(filament.filament_type) ? filament.filament_type : [];
+    const materials = materialValues.map(normalizeMaterial);
+    if (!model || !nozzles.length || nozzles.some((n) => ![0.2, 0.4, 0.6, 0.8].includes(n)) ||
+        materials.length !== 1 || !materials[0]) {
+        throw new Error('Remote slicing requires explicit model, nozzle and single-material metadata in the prepared profiles.');
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const deadline = setTimeout(() => { timedOut = true; controller.abort(); }, config.timeout);
+    const cancelCheck = setInterval(() => { if (input.isCancelled())
+        controller.abort(); }, 100);
+    let requestId;
+    let terminalJob = false;
+    let wroteOutput = false;
+    const request = async (route, init = {}) => {
+        if (input.isCancelled())
+            controller.abort();
+        // Do not pass multipart data to fetch after cancellation: undici may start
+        // its body producer before checking the signal and close it mid-enqueue.
+        controller.signal.throwIfAborted();
+        let response;
+        try {
+            response = await fetch(config.base + route, { ...init, headers: config.headers, signal: controller.signal, redirect: 'manual' });
+        }
+        catch {
+            throw new Error('Remote slicing HTTP request failed; check the trusted service configuration.');
+        }
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`Remote slicing HTTP ${response.status}.`);
+        }
+        return response;
+    };
+    try {
+        const ext = path.extname(input.inputPath).toLowerCase();
+        if (!['.stl', '.3mf'].includes(ext))
+            throw new Error('Remote slicing supports only STL or 3MF input.');
+        const bytes = await fs.readFile(input.inputPath);
+        if (bytes.length > MAX_BYTES)
+            throw new Error('Remote slicing input exceeds the 100 MB upstream limit.');
+        const form = new FormData();
+        form.set('file', new Blob([new Uint8Array(bytes)], { type: ext === '.3mf' ? 'model/3mf' : 'model/stl' }), `model${ext}`);
+        for (const [field, filePath, type] of [
+            ['printerProfile', input.machinePath, 'machine'],
+            ['presetProfile', input.processPath, 'process'],
+            ['filamentProfile', input.filamentPaths[0], 'filament'],
+        ]) {
+            const profile = JSON.parse(await fs.readFile(filePath, 'utf8'));
+            // The remote validator requires these metadata fields even for standalone
+            // user profiles. They do not change the resolved machine/process settings.
+            const data = { ...profile, type, from: profile.from || 'User' };
+            form.set(field, new Blob([JSON.stringify(data)], { type: 'application/json' }), `${field}.json`);
+        }
+        form.set('exportType', '3mf');
+        form.set('plate', String(plate));
+        form.set('bedType', bedType);
+        form.set('resolveProfileInheritance', 'false');
+        if (options.arrange === true)
+            form.set('arrange', 'true');
+        if (options.orient === true)
+            form.set('orient', 'true');
+        let response = await request(config.mode === 'async' ? '/slice-async' : '/slice', { method: 'POST', body: form });
+        if (config.mode === 'async') {
+            const submitted = await readJob(response);
+            if (typeof submitted.requestId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(submitted.requestId)) {
+                throw new Error('Remote slicing returned an invalid request ID.');
+            }
+            requestId = submitted.requestId;
+            for (;;) {
+                // Construct the documented same-service paths. Returned URLs cannot
+                // redirect authenticated requests to an arbitrary origin or route.
+                const job = await readJob(await request(`/slice-async/${requestId}`));
+                if (job.status === 'completed' || job.status === 'failed') {
+                    terminalJob = true;
+                    if (job.status === 'failed')
+                        throw new Error('Remote slicing job failed; inspect the service logs.');
+                    break;
+                }
+                if (job.status !== 'pending' && job.status !== 'processing')
+                    throw new Error('Remote slicing returned an unknown job state.');
+                await delay(500, undefined, { signal: controller.signal });
+            }
+            response = await request(`/slice-async/${requestId}/result`);
+        }
+        const result = await readResponse(response, MAX_BYTES);
+        await fs.writeFile(input.outputPath, result, { flag: 'wx', mode: 0o600 });
+        wroteOutput = true;
+        const inspection = await inspectPrintFile(input.outputPath, {
+            model, nozzleDiameters: nozzles, plateIndex: plate - 1, bedType,
+        });
+        if (JSON.stringify(inspection.materials) !== JSON.stringify(materials)) {
+            throw new Error('Remote sliced file materials contradict the prepared filament profile.');
+        }
+        if (input.isCancelled())
+            throw new Error('Remote slicing cancelled.');
+        return input.outputPath;
+    }
+    catch (error) {
+        if (wroteOutput)
+            await fs.rm(input.outputPath, { force: true });
+        if (controller.signal.aborted) {
+            throw new Error(`Remote slicing ${timedOut ? 'timed out' : 'cancelled'}; the remote job may continue. No retry was sent.`);
+        }
+        throw error;
+    }
+    finally {
+        // DELETE only removes finished jobs; upstream has no active-job cancellation.
+        // Cleanup never retries submission or masks a valid result / original error.
+        if (requestId && terminalJob && !controller.signal.aborted) {
+            try {
+                await (await request(`/slice-async/${requestId}`, { method: 'DELETE' })).body?.cancel();
+            }
+            catch {
+                console.error('Remote slicing finished-job cleanup failed; service retention applies.');
+            }
+        }
+        clearTimeout(deadline);
+        clearInterval(cancelCheck);
+    }
+}

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

@@ -22,7 +22,7 @@ export type TransformationParams = {
     relative?: boolean;
     selectionBounds?: THREE.Box3;
 };
-export declare const SLICER_TYPES: readonly ["bambustudio", "orcaslicer", "orcaslicer-bambulab", "prusaslicer", "cura", "slic3r"];
+export declare const SLICER_TYPES: readonly ["bambustudio", "orcaslicer", "orcaslicer-bambulab", "orca-slicer-api", "prusaslicer", "cura", "slic3r"];
 export type SlicerType = typeof SLICER_TYPES[number];
 export declare function normalizeSlicerType(rawSlicerType: string): SlicerType;
 export declare function isBambuCompatibleSlicer(slicerType: SlicerType): boolean;
@@ -39,6 +39,7 @@ export interface BambuSliceOptions {
     filamentColours?: string[];
     bedType?: string;
     nozzleType?: string;
+    nozzleVolumeType?: 'Standard' | 'High Flow';
     enableTimelapse?: boolean;
     allowMixTemp?: boolean;
     scale?: number;

package/dist/stl/stl-manipulator.js

@@ -11,6 +11,7 @@ import * as crypto from 'crypto';
 import { execFile } from 'child_process';
 import { flattenForCli, detectProfilesRoot, resolveBblMachineProfile } from '../slicer/profile-flatten.js';
 import { profileJsonFiles } from '../slicer/profile-files.js';
+import { sliceWithOrcaApi, validateRemoteSliceOptions } from '../slicer/remote-slicer.js';
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
 const BAMBU_PROFILE_ROOTS = [
@@ -27,6 +28,7 @@ export const SLICER_TYPES = [
     'bambustudio',
     'orcaslicer',
     'orcaslicer-bambulab',
+    'orca-slicer-api',
     'prusaslicer',
     'cura',
     'slic3r',
@@ -48,6 +50,8 @@ const SLICER_TYPE_ALIASES = {
     orcastudio: 'orcaslicer-bambulab',
     'orcaslicer-bmcu': 'orcaslicer-bambulab',
     'orca-bmcu': 'orcaslicer-bambulab',
+    'orca-slicer-api': 'orca-slicer-api',
+    'orcaslicer-api': 'orca-slicer-api',
     prusaslicer: 'prusaslicer',
     'prusa-slicer': 'prusaslicer',
     cura: 'cura',
@@ -65,7 +69,8 @@ export function normalizeSlicerType(rawSlicerType) {
 export function isBambuCompatibleSlicer(slicerType) {
     return (slicerType === 'bambustudio' ||
         slicerType === 'orcaslicer' ||
-        slicerType === 'orcaslicer-bambulab');
+        slicerType === 'orcaslicer-bambulab' ||
+        slicerType === 'orca-slicer-api');
 }
 function isPathLikeExecutable(slicerPath) {
     return (path.isAbsolute(slicerPath) ||
@@ -405,6 +410,7 @@ export class STLManipulator extends EventEmitter {
             userProfileRoots: configuredBambuProfileDirs(),
             tempDir: this.tempDir,
             bedType: this.resolveBambuStudioBedType(bambuOptions?.bedType),
+            nozzleVolumeType: bambuOptions?.nozzleVolumeType,
             filamentColours: bambuOptions?.filamentColours ?? bundle.filamentColours,
             projectTowerPosition: bundle.projectTowerPosition,
             sourceProfiles: {
@@ -1224,7 +1230,7 @@ export class STLManipulator extends EventEmitter {
     async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, bambuOptions) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
-        if (isPathLikeExecutable(slicerPath) && !fs.existsSync(slicerPath)) {
+        if (slicerType !== 'orca-slicer-api' && isPathLikeExecutable(slicerPath) && !fs.existsSync(slicerPath)) {
             throw new Error(`Slicer executable not found at: ${slicerPath}`);
         }
         if (slicerProfile && !fs.existsSync(slicerProfile)) {
@@ -1266,6 +1272,7 @@ export class STLManipulator extends EventEmitter {
                 case 'bambustudio':
                 case 'orcaslicer':
                 case 'orcaslicer-bambulab':
+                case 'orca-slicer-api':
                     // Bambu-compatible CLI: slice and export as 3MF with embedded gcode.
                     // FULU's OrcaSlicer-bambulab fork keeps this Bambu-style path.
                     // For 3MF input: slice in place and export sliced 3MF
@@ -1273,10 +1280,19 @@ export class STLManipulator extends EventEmitter {
                     {
                         const is3mf = stlFilePath.toLowerCase().endsWith('.3mf');
                         const outputBase = path.basename(stlFilePath, is3mf ? '.3mf' : '.stl');
-                        const bambuOutputPath = path.join(this.tempDir, outputBase + '_sliced.3mf');
+                        const remote = slicerType === 'orca-slicer-api';
+                        if (remote) {
+                            validateRemoteSliceOptions(bambuOptions);
+                            if (!process.env.BAMBU_PROFILES_ROOT)
+                                throw new Error('Remote slicing requires BAMBU_PROFILES_ROOT pointing to the matching Orca profile tree (a read-only mount is sufficient).');
+                            if (slicerProfile && !fs.existsSync(slicerProfile))
+                                throw new Error('Remote slicing process profile does not exist.');
+                        }
+                        const profileSlicerType = remote ? 'orcaslicer' : slicerType;
+                        const bambuOutputPath = path.join(this.tempDir, outputBase + (remote ? `_${operationId}` : '') + '_sliced.3mf');
                         const outputDir = path.dirname(bambuOutputPath);
-                        const profilesRoot = detectProfilesRoot(slicerPath, slicerType);
-                        const rawBundle = await this.resolveBambuLikeSettingsBundle(outputBase, slicerType, slicerProfile, printerPreset, bambuOptions, profilesRoot);
+                        const profilesRoot = detectProfilesRoot(remote ? undefined : slicerPath, profileSlicerType);
+                        const rawBundle = await this.resolveBambuLikeSettingsBundle(outputBase, profileSlicerType, slicerProfile, printerPreset, bambuOptions, profilesRoot);
                         // Resolve every BBL dependency before launching the slicer.
                         const settingsBundle = await this.maybeFlattenBundle(await this.expandProjectFilaments(stlFilePath, rawBundle), bambuOptions, profilesRoot);
                         // The machine preset assumes the stock hotend; record the installed one so
@@ -1296,7 +1312,7 @@ export class STLManipulator extends EventEmitter {
                         // absolute-extrusion normalization after resolving those ancestors.
                         // The machine owns the extrusion mode and layer G-code once process
                         // files lose machine keys, so normalize it there as well.
-                        if (slicerType === 'orcaslicer' && settingsBundle.settingsArg) {
+                        if (profileSlicerType === 'orcaslicer' && settingsBundle.settingsArg) {
                             const [machinePath, processPath] = settingsBundle.settingsArg.split(';');
                             settingsBundle.settingsArg = [
                                 this.writeTempJson(outputBase, 'machine_orca_resolved', this.useAbsoluteExtrusionForOrca(this.readJsonFile(machinePath))),
@@ -1304,6 +1320,17 @@ export class STLManipulator extends EventEmitter {
                             ].join(';');
                         }
                         const cliBundle = this.isolateMachineSettings(settingsBundle);
+                        if (remote) {
+                            const [machinePath, processPath] = cliBundle.settingsArg?.split(';') ?? [];
+                            if (!machinePath || !processPath)
+                                throw new Error('Remote slicing requires complete prepared machine and process profiles.');
+                            outputFilePath = await sliceWithOrcaApi({
+                                inputPath: stlFilePath, machinePath, processPath,
+                                filamentPaths: cliBundle.filamentPaths, outputPath: bambuOutputPath,
+                                options: bambuOptions, isCancelled: () => !this.activeOperations.get(operationId),
+                            });
+                            break;
+                        }
                         args = [
                             '--slice', String(bambuOptions?.slicePlate ?? 0),
                             '--outputdir', outputDir,
@@ -1359,45 +1386,47 @@ export class STLManipulator extends EventEmitter {
                 default:
                     throw new Error(`Unsupported slicer type: ${slicerType}`);
             }
-            if (progressCallback)
-                progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
-            console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
-            // Execute the slicer
-            await new Promise((resolve, reject) => {
-                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}`));
-                    }
-                    else {
-                        console.error(`Slicer Stdout: ${stdout}`);
-                        if (stderr) {
-                            console.warn(`Slicer Stderr: ${stderr}`); // Log stderr even on success
+            if (slicerType !== 'orca-slicer-api') {
+                if (progressCallback)
+                    progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
+                console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
+                // Execute the slicer
+                await new Promise((resolve, reject) => {
+                    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}`));
                         }
-                        resolve();
-                    }
-                });
-                // Optional: Add listeners for stdout/stderr for real-time progress if slicer provides it
-                // process.stdout?.on('data', (data) => { console.error(`Slicer stdout: ${data}`); });
-                // process.stderr?.on('data', (data) => { console.error(`Slicer stderr: ${data}`); });
-                // Check for cancellation periodically
-                const checkCancel = setInterval(() => {
-                    if (!this.activeOperations.get(operationId)) {
-                        clearInterval(checkCancel);
-                        try {
-                            process.kill(); // Attempt to kill the slicer process
-                            reject(new Error("Slicing operation cancelled"));
+                        else {
+                            console.error(`Slicer Stdout: ${stdout}`);
+                            if (stderr) {
+                                console.warn(`Slicer Stderr: ${stderr}`); // Log stderr even on success
+                            }
+                            resolve();
                         }
-                        catch (killError) {
-                            console.error("Error attempting to kill slicer process:", killError);
-                            reject(new Error("Slicing operation cancelled, but failed to kill process."));
+                    });
+                    // Optional: Add listeners for stdout/stderr for real-time progress if slicer provides it
+                    // process.stdout?.on('data', (data) => { console.error(`Slicer stdout: ${data}`); });
+                    // process.stderr?.on('data', (data) => { console.error(`Slicer stderr: ${data}`); });
+                    // Check for cancellation periodically
+                    const checkCancel = setInterval(() => {
+                        if (!this.activeOperations.get(operationId)) {
+                            clearInterval(checkCancel);
+                            try {
+                                process.kill(); // Attempt to kill the slicer process
+                                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."));
+                            }
                         }
-                    }
-                }, 500);
-                process.on('exit', () => clearInterval(checkCancel));
-                process.on('error', () => clearInterval(checkCancel)); // Ensure interval cleared on process error too
-            });
+                    }, 500);
+                    process.on('exit', () => clearInterval(checkCancel));
+                    process.on('error', () => clearInterval(checkCancel)); // Ensure interval cleared on process error too
+                });
+            }
             if (!this.activeOperations.get(operationId)) {
                 // This check might be redundant if the promise rejected on kill, but good safety
                 throw new Error("Slicing operation cancelled after process finished");