bambu-printer-mcp 1.1.28 → 1.1.29

package/src/slicer/remote-slicer.ts

@@ -0,0 +1,216 @@
+/** 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';
+import type { BambuSliceOptions } from '../stl/stl-manipulator.js';
+
+const MAX_BYTES = 100_000_000;
+const SUPPORTED_OPTIONS = new Set([
+  'arrange', 'orient', 'loadFilaments', 'filamentColours', 'bedType',
+  'nozzleType', 'nozzleVolumeType', 'slicePlate',
+]);
+
+function configuration(): { base: string; headers: Record<string, string>; mode: string; timeout: number } {
+  let url: 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: Record<string, string> = {};
+  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: BambuSliceOptions = {}): number {
+  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: unknown): string {
+  const names: Record<string, string> = {
+    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: Response, limit: number): Promise<Buffer> {
+  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: Uint8Array[] = [];
+  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: Response): Promise<Record<string, unknown>> {
+  try {
+    const job: unknown = JSON.parse((await readResponse(response, 65536)).toString('utf8'));
+    if (job && typeof job === 'object' && !Array.isArray(job)) return job as Record<string, unknown>;
+  } 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: {
+  inputPath: string;
+  machinePath: string;
+  processPath: string;
+  filamentPaths: string[];
+  outputPath: string;
+  options?: BambuSliceOptions;
+  isCancelled: () => boolean;
+}): Promise<string> {
+  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: unknown[] = Array.isArray(filament.filament_type) ? filament.filament_type : [];
+  const materials = materialValues.map(normalizeMaterial);
+  if (!model || !nozzles.length || nozzles.some((n: number) => ![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: string | undefined;
+  let terminalJob = false;
+  let wroteOutput = false;
+  const request = async (route: string, init: RequestInit = {}): Promise<Response> => {
+    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: 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/src/stl/stl-manipulator.ts

@@ -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);
@@ -57,6 +58,7 @@ export const SLICER_TYPES = [
   'bambustudio',
   'orcaslicer',
   'orcaslicer-bambulab',
+  'orca-slicer-api',
   'prusaslicer',
   'cura',
   'slic3r',
@@ -81,6 +83,8 @@ const SLICER_TYPE_ALIASES: Record<string, SlicerType> = {
   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',
@@ -105,7 +109,8 @@ export function isBambuCompatibleSlicer(slicerType: SlicerType): boolean {
   return (
     slicerType === 'bambustudio' ||
     slicerType === 'orcaslicer' ||
-    slicerType === 'orcaslicer-bambulab'
+    slicerType === 'orcaslicer-bambulab' ||
+    slicerType === 'orca-slicer-api'
   );
 }
 
@@ -1591,7 +1596,7 @@ export class STLManipulator extends EventEmitter {
     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)) {
@@ -1638,6 +1643,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
@@ -1645,12 +1651,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 profilesRoot = detectProfilesRoot(remote ? undefined : slicerPath, profileSlicerType);
             const rawBundle = await this.resolveBambuLikeSettingsBundle(
               outputBase,
-              slicerType,
+              profileSlicerType,
               slicerProfile,
               printerPreset,
               bambuOptions,
@@ -1676,7 +1689,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',
@@ -1686,6 +1699,16 @@ 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,
@@ -1729,47 +1752,49 @@ export class STLManipulator extends EventEmitter {
           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<void>((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
-             }
-            resolve();
-          }
-        });
+      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<void>((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
+               }
+              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}`); });
+          // 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); 
+          // 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
+         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