mcp-3d-printer-server 0.2.3 → 1.0.0

package/src/stl/stl-manipulator.ts

@@ -1,11 +1,13 @@
 import * as THREE from 'three';
 import { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';
 import { STLExporter } from 'three/examples/jsm/exporters/STLExporter.js';
+import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import fs from 'fs';
 import path from 'path';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
+import { execFile } from 'child_process';
 
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
@@ -837,148 +839,142 @@ export class STLManipulator extends EventEmitter {
   }
 
   /**
-   * Enhanced version of sliceSTL with progress reporting and error handling
-   * @param stlFilePath Path to the STL file
-   * @param slicerType Type of slicer to use ('prusaslicer', 'cura', 'slic3r')
+   * Slice an STL file using the specified slicer
+   * @param stlFilePath Path to the input STL file
+   * @param slicerType Type of slicer (prusaslicer, cura, slic3r, orcaslicer)
    * @param slicerPath Path to the slicer executable
-   * @param slicerProfile Profile to use for slicing
+   * @param slicerProfile Optional path to the slicer profile/config file
    * @param progressCallback Optional callback for progress updates
    * @returns Path to the generated G-code file
    */
   async sliceSTL(
     stlFilePath: string,
-    slicerType: 'prusaslicer' | 'cura' | 'slic3r',
+    slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer',
     slicerPath: string,
     slicerProfile?: string,
     progressCallback?: ProgressCallback
   ): Promise<string> {
     const operationId = this.generateOperationId();
     this.activeOperations.set(operationId, true);
-    
+
+    if (!fs.existsSync(slicerPath)) {
+      throw new Error(`Slicer executable not found at: ${slicerPath}`);
+    }
+    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
+    }
+
+    const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
+    const outputFilePath = path.join(this.tempDir, outputFileName);
+
+    let args: string[] = [];
+
     try {
-      if (progressCallback) progressCallback(0, "Starting slicing operation...");
-      
-      const { exec } = require('child_process');
-      const execAsync = promisify(exec);
-      
-      // Verify the STL file exists
-      if (!fs.existsSync(stlFilePath)) {
-        throw new Error(`STL file not found: ${stlFilePath}`);
-      }
-      
-      // Verify the slicer executable exists if provided
-      if (slicerPath && !fs.existsSync(slicerPath)) {
-        throw new Error(`Slicer executable not found: ${slicerPath}`);
-      }
-      
-      if (progressCallback) progressCallback(10, "Preparing slicing command...");
-      
-      const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
-      const outputFilePath = path.join(this.tempDir, outputFileName);
-      
-      let command = '';
-      
+      if (progressCallback) progressCallback(0, `Starting slicing with ${slicerType}...`);
+
       switch (slicerType) {
         case 'prusaslicer':
-          command = `"${slicerPath}" --export-gcode --output "${outputFilePath}"`;
-          if (slicerProfile) {
-            if (!fs.existsSync(slicerProfile)) {
-              console.warn(`Warning: Slicer profile not found: ${slicerProfile}`);
-            }
-            command += ` --load "${slicerProfile}"`;
-          }
-          command += ` "${stlFilePath}"`;
+        case 'slic3r': // PrusaSlicer and Slic3r share similar CLI args
+          args = [
+            '--slice',
+            '--output', outputFilePath,
+            '--load', slicerProfile || '', // Pass profile path
+            stlFilePath
+          ];
+          // Remove empty profile arg if not provided
+          args = args.filter(arg => arg !== ''); 
           break;
-          
+
+        case 'orcaslicer': // Add OrcaSlicer case
+           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
+           ];
+           // 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 !== '');
+           break;
+
         case 'cura':
-          command = `"${slicerPath}" -o "${outputFilePath}"`;
-          if (slicerProfile) {
-            if (!fs.existsSync(slicerProfile)) {
-              console.warn(`Warning: Slicer profile not found: ${slicerProfile}`);
-            }
-            command += ` -l "${slicerProfile}"`;
-          }
-          command += ` "${stlFilePath}"`;
-          break;
-          
-        case 'slic3r':
-          command = `"${slicerPath}" --output "${outputFilePath}"`;
+          // 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
+          // This requires parsing the profile or passing individual settings.
+          // Keeping it simple for now, assuming profile contains necessary info.
+          args = [
+            'slice', 
+            '-l', stlFilePath,
+            '-o', outputFilePath
+          ];
           if (slicerProfile) {
-            if (!fs.existsSync(slicerProfile)) {
-              console.warn(`Warning: Slicer profile not found: ${slicerProfile}`);
-            }
-            command += ` --load "${slicerProfile}"`;
+            args.push('-j', slicerProfile); // Load settings from profile definition file
           }
-          command += ` "${stlFilePath}"`;
           break;
-          
+
         default:
           throw new Error(`Unsupported slicer type: ${slicerType}`);
       }
-      
-      if (!this.activeOperations.get(operationId)) {
-        throw new Error("Operation cancelled");
-      }
-      
-      if (progressCallback) progressCallback(20, "Running slicer...");
-      console.log(`Slicing STL with command: ${command}`);
-      
-      // Execute the slicing command
+
+      if (progressCallback) progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
+      console.log(`Executing: ${slicerPath} ${args.join(' ')}`);
+
+      // Execute the slicer
       await new Promise<void>((resolve, reject) => {
-        const slicerProcess = exec(command);
-        
-        // Set up a timeout for the slicing operation (15 minutes)
-        const timeout = setTimeout(() => {
-          if (slicerProcess.pid) {
-            process.kill(slicerProcess.pid);
-          }
-          reject(new Error("Slicing operation timed out after 15 minutes"));
-        }, 15 * 60 * 1000);
-        
-        // Handle stdout data
-        slicerProcess.stdout?.on('data', (data: string) => {
-          console.log(`Slicer stdout: ${data}`);
-          // Attempt to extract progress information (varies by slicer)
-          const progressMatch = data.match(/(\d+)%/);
-          if (progressMatch && progressCallback) {
-            const slicerProgress = parseInt(progressMatch[1], 10);
-            // Map slicer's 0-100% to our 20-90% range
-            const mappedProgress = 20 + (slicerProgress * 0.7);
-            progressCallback(mappedProgress, `Slicing: ${slicerProgress}%`);
-          }
-        });
-        
-        // Handle stderr data
-        slicerProcess.stderr?.on('data', (data: string) => {
-          console.error(`Slicer stderr: ${data}`);
-        });
-        
-        // Handle completion
-        slicerProcess.on('close', (code: number) => {
-          clearTimeout(timeout);
-          if (code === 0) {
-            resolve();
+        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 {
-            reject(new Error(`Slicer process exited with code ${code}`));
+            console.log(`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.log(`Slicer stdout: ${data}`); });
+        // process.stderr?.on('data', (data) => { console.log(`Slicer stderr: ${data}`); });
         
-        // Handle errors
-        slicerProcess.on('error', (err: Error) => {
-          clearTimeout(timeout);
-          reject(err);
-        });
+        // 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
+
       });
-      
+
       if (!this.activeOperations.get(operationId)) {
-        throw new Error("Operation cancelled");
+        // This check might be redundant if the promise rejected on kill, but good safety
+        throw new Error("Slicing operation cancelled after process finished");
       }
       
-      // Verify the G-code file was created
       if (!fs.existsSync(outputFilePath)) {
-        throw new Error("Slicing failed: G-code file was not created");
+          throw new Error(`Slicer finished but output file not found: ${outputFilePath}`);
       }
-      
+
       if (progressCallback) progressCallback(100, "Slicing completed successfully");
       
       this.emit('operationComplete', {
@@ -987,18 +983,16 @@ export class STLManipulator extends EventEmitter {
         success: true,
         output: outputFilePath
       });
-      
+
       return outputFilePath;
     } catch (error) {
-      console.error("Error slicing STL:", error);
-      
+      console.error(`Slicing failed for ${stlFilePath}:`, error);
       this.emit('operationError', {
         operationId,
         type: 'slice',
         error: error instanceof Error ? error.message : String(error)
       });
-      
-      throw new Error(`Failed to slice STL: ${error instanceof Error ? error.message : String(error)}`);
+      throw error; 
     } finally {
       this.activeOperations.delete(operationId);
     }
@@ -1112,8 +1106,247 @@ export class STLManipulator extends EventEmitter {
       this.activeOperations.delete(operationId);
     }
   }
-}
 
-// Import BufferGeometryUtils for merging geometries
-// This is a utility module used by Three.js
-import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+  /**
+   * Merge vertices within a specified tolerance.
+   */
+  async mergeVertices(
+    stlFilePath: string,
+    tolerance: number = 0.01, // Default tolerance in mm
+    progressCallback?: ProgressCallback
+  ): Promise<string> {
+    const operationId = this.generateOperationId();
+    this.activeOperations.set(operationId, true);
+
+    try {
+      if (progressCallback) progressCallback(0, "Starting vertex merging...");
+      
+      const { geometry } = await this.loadSTL(stlFilePath, progressCallback); // 10-50% progress
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+      if (progressCallback) progressCallback(60, "Merging vertices...");
+
+      const originalVertexCount = geometry.attributes.position.count;
+      const mergedGeometry = BufferGeometryUtils.mergeVertices(geometry, tolerance);
+      const newVertexCount = mergedGeometry.attributes.position.count;
+
+      console.log(`Merged vertices: ${originalVertexCount} -> ${newVertexCount} (Tolerance: ${tolerance}mm)`);
+      if (progressCallback) progressCallback(70, `Vertices merged: ${originalVertexCount} -> ${newVertexCount}`);
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+
+      const outputFileName = path.basename(stlFilePath, '.stl') + '_merged.stl';
+      const outputFilePath = path.join(this.tempDir, outputFileName);
+
+      await this.saveSTL(mergedGeometry, outputFilePath, progressCallback); // 80-100% progress
+
+      this.emit('operationComplete', { operationId, type: 'mergeVertices', success: true, output: outputFilePath, verticesRemoved: originalVertexCount - newVertexCount });
+      return outputFilePath;
+
+    } catch (error) {
+      this.emit('operationError', { operationId, type: 'mergeVertices', error: error instanceof Error ? error.message : String(error) });
+      throw error;
+    } finally {
+      this.activeOperations.delete(operationId);
+    }
+  }
+
+  /**
+   * Center the model at the origin (0,0,0).
+   */
+  async centerModel(
+    stlFilePath: string,
+    progressCallback?: ProgressCallback
+  ): Promise<string> {
+    const operationId = this.generateOperationId();
+    this.activeOperations.set(operationId, true);
+
+    try {
+      if (progressCallback) progressCallback(0, "Starting centering operation...");
+      
+      const { geometry, boundingBox } = await this.loadSTL(stlFilePath, progressCallback); // 10-50% progress
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+      if (progressCallback) progressCallback(60, "Calculating center...");
+
+      const center = new THREE.Vector3();
+      boundingBox.getCenter(center);
+
+      if (center.lengthSq() < 0.0001) { // Already centered (or very close)
+          if (progressCallback) progressCallback(100, "Model is already centered.");
+          console.log("Model already centered. No changes made.");
+          this.emit('operationComplete', { operationId, type: 'centerModel', success: true, output: stlFilePath, message: "Model already centered." });
+          return stlFilePath; // Return original path
+      }
+
+      if (progressCallback) progressCallback(70, `Applying translation: (${-center.x.toFixed(2)}, ${-center.y.toFixed(2)}, ${-center.z.toFixed(2)})`);
+
+      const translationMatrix = new THREE.Matrix4().makeTranslation(-center.x, -center.y, -center.z);
+      geometry.applyMatrix4(translationMatrix);
+      geometry.computeBoundingBox(); // Recompute bounds after moving
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+
+      const outputFileName = path.basename(stlFilePath, '.stl') + '_centered.stl';
+      const outputFilePath = path.join(this.tempDir, outputFileName);
+
+      await this.saveSTL(geometry, outputFilePath, progressCallback); // 80-100% progress
+
+      this.emit('operationComplete', { operationId, type: 'centerModel', success: true, output: outputFilePath });
+      return outputFilePath;
+
+    } catch (error) {
+      this.emit('operationError', { operationId, type: 'centerModel', error: error instanceof Error ? error.message : String(error) });
+      throw error;
+    } finally {
+      this.activeOperations.delete(operationId);
+    }
+  }
+
+  /**
+   * Rotate the model so its largest flat face lies on the XY plane (Z=0).
+   */
+  async layFlat(
+    stlFilePath: string,
+    progressCallback?: ProgressCallback
+  ): Promise<string> {
+    const operationId = this.generateOperationId();
+    this.activeOperations.set(operationId, true);
+
+    try {
+      if (progressCallback) progressCallback(0, "Starting lay flat operation...");
+
+      const { geometry, boundingBox } = await this.loadSTL(stlFilePath, progressCallback); // 10-50%
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+      if (progressCallback) progressCallback(55, "Analyzing faces...");
+
+      const positionAttribute = geometry.getAttribute('position');
+      if (!positionAttribute) throw new Error("Geometry has no position attribute.");
+
+      const faces: { normal: THREE.Vector3; area: number; vertices: THREE.Vector3[] }[] = [];
+      const vA = new THREE.Vector3();
+      const vB = new THREE.Vector3();
+      const vC = new THREE.Vector3();
+      const faceNormal = new THREE.Vector3();
+      const cb = new THREE.Vector3(), ab = new THREE.Vector3();
+
+      // Iterate through faces (triangles)
+      for (let i = 0; i < positionAttribute.count; i += 3) {
+          vA.fromBufferAttribute(positionAttribute, i);
+          vB.fromBufferAttribute(positionAttribute, i + 1);
+          vC.fromBufferAttribute(positionAttribute, i + 2);
+
+          // Calculate face normal
+          cb.subVectors(vC, vB);
+          ab.subVectors(vA, vB);
+          cb.cross(ab);
+          faceNormal.copy(cb).normalize();
+
+          // Calculate face area (using cross product magnitude / 2)
+          const area = cb.length() / 2;
+          
+          faces.push({
+              normal: faceNormal.clone(),
+              area: area,
+              vertices: [vA.clone(), vB.clone(), vC.clone()] // Store vertices if needed for center calculation
+          });
+      }
+
+      if (faces.length === 0) throw new Error("No faces found in geometry.");
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+      if (progressCallback) progressCallback(65, "Grouping faces by normal...");
+
+      // Group faces by similar normal vectors (tolerance for floating point errors)
+      const normalGroups: Map<string, { totalArea: number; representativeNormal: THREE.Vector3 }> = new Map();
+      const tolerance = 1e-5; 
+
+      for (const face of faces) {
+          let foundGroup = false;
+          for (const [key, group] of normalGroups.entries()) {
+              if (face.normal.distanceToSquared(group.representativeNormal) < tolerance) {
+                  group.totalArea += face.area;
+                  // Optional: Average the normal? For now, just use the first one.
+                  foundGroup = true;
+                  break;
+              }
+          }
+          if (!foundGroup) {
+              const key = `${face.normal.x.toFixed(5)},${face.normal.y.toFixed(5)},${face.normal.z.toFixed(5)}`;
+              if (!normalGroups.has(key)) { // Ensure unique key even if floats slightly differ after toFixed
+                   normalGroups.set(key, { totalArea: face.area, representativeNormal: face.normal });
+              }
+          }
+      }
+      
+      if (normalGroups.size === 0) throw new Error("Could not group faces by normal.");
+
+      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)
+      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)
+
+      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) {
+              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.
+          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;
+      }
+      
+      if (progressCallback) progressCallback(80, "Calculating rotation...");
+      
+      // Calculate the rotation needed to align targetNormal with downVector
+      const quaternion = new THREE.Quaternion().setFromUnitVectors(targetNormal, downVector);
+      const rotationMatrix = new THREE.Matrix4().makeRotationFromQuaternion(quaternion);
+
+      // Rotate around the model's center
+      const center = new THREE.Vector3();
+      boundingBox.getCenter(center);
+      const toOriginMatrix = new THREE.Matrix4().makeTranslation(-center.x, -center.y, -center.z);
+      const fromOriginMatrix = new THREE.Matrix4().makeTranslation(center.x, center.y, center.z);
+
+      // Apply rotation
+      geometry.applyMatrix4(toOriginMatrix);
+      geometry.applyMatrix4(rotationMatrix);
+      geometry.applyMatrix4(fromOriginMatrix);
+
+      // Translate so the new bottom is at Z=0
+      geometry.computeBoundingBox(); // Recompute bounds after rotation
+      const newMinZ = geometry.boundingBox!.min.z;
+      const translateToZeroMatrix = new THREE.Matrix4().makeTranslation(0, 0, -newMinZ);
+      geometry.applyMatrix4(translateToZeroMatrix);
+      geometry.computeBoundingBox(); // Final bounds
+
+      if (!this.activeOperations.get(operationId)) throw new Error("Operation cancelled");
+
+      const outputFileName = path.basename(stlFilePath, '.stl') + '_flat.stl';
+      const outputFilePath = path.join(this.tempDir, outputFileName);
+
+      await this.saveSTL(geometry, outputFilePath, progressCallback); // 90-100% progress
+
+      this.emit('operationComplete', { operationId, type: 'layFlat', success: true, output: outputFilePath });
+      return outputFilePath;
+
+    } catch (error) {
+      this.emit('operationError', { operationId, type: 'layFlat', error: error instanceof Error ? error.message : String(error) });
+      throw error;
+    } finally {
+      this.activeOperations.delete(operationId);
+    }
+  }
+}

package/src/test/stl-manipulator-test.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { STLManipulator } from '../stl/stl-manipulator.ts';
+import fs from 'fs';
+import path from 'path';
+import * as THREE from 'three';
+
+// Create a test directory
+const TEST_DIR = path.join(process.cwd(), 'test');
+if (!fs.existsSync(TEST_DIR)) {
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+}
+
+// Path for a sample STL file
+const sampleStlPath = path.join(TEST_DIR, 'sample_cube.stl');
+
+// Create a simple cube STL for testing if it doesn't exist
+async function createSampleCube() {
+  if (fs.existsSync(sampleStlPath)) {
+    console.log('Sample STL already exists, skipping creation');
+    return sampleStlPath;
+  }
+  
+  console.log('Creating sample cube STL...');
+  
+  // Create a simple cube geometry
+  const geometry = new THREE.BoxGeometry(10, 10, 10);
+  const material = new THREE.MeshStandardMaterial();
+  const mesh = new THREE.Mesh(geometry, material);
+  
+  // Import STLExporter
+  const { STLExporter } = await import('three/examples/jsm/exporters/STLExporter.js');
+  const exporter = new STLExporter();
+  
+  // Export as STL
+  const stlString = exporter.parse(mesh);
+  
+  // Write to file
+  fs.writeFileSync(sampleStlPath, stlString);
+  console.log(`Sample cube saved to ${sampleStlPath}`);
+  
+  return sampleStlPath;
+}
+
+// Test the STL manipulator
+async function testSTLManipulator() {
+  try {
+    // Create a sample STL for testing
+    const stlPath = await createSampleCube();
+    
+    // Create an instance of the STL manipulator with the test directory
+    const manipulator = new STLManipulator(TEST_DIR);
+    
+    // Listen for events from the manipulator
+    manipulator.on('operationComplete', (data) => {
+      console.log('Operation complete:', data);
+    });
+    
+    manipulator.on('operationError', (data) => {
+      console.error('Operation error:', data);
+    });
+    
+    // Test progress callback
+    const progressCallback = (progress, message) => {
+      console.log(`Progress: ${progress}% - ${message || ''}`);
+    };
+    
+    // Test 1: Get information about the STL file
+    console.log('\n=== Test 1: Get STL Info ===');
+    const stlInfo = await manipulator.getSTLInfo(stlPath);
+    console.log('STL Info:', stlInfo);
+    
+    // Test 2: Scale the STL file
+    console.log('\n=== Test 2: Scale STL ===');
+    const scaledStlPath = await manipulator.scaleSTL(stlPath, 2.0, progressCallback);
+    console.log(`Scaled STL saved to: ${scaledStlPath}`);
+    
+    // Test 3: Rotate the STL file
+    console.log('\n=== Test 3: Rotate STL ===');
+    const rotatedStlPath = await manipulator.rotateSTL(stlPath, [45, 0, 0], progressCallback);
+    console.log(`Rotated STL saved to: ${rotatedStlPath}`);
+    
+    // Test 4: Translate the STL file
+    console.log('\n=== Test 4: Translate STL ===');
+    const translatedStlPath = await manipulator.translateSTL(stlPath, [5, 10, 0], progressCallback);
+    console.log(`Translated STL saved to: ${translatedStlPath}`);
+    
+    // Test 5: Extend the base of the STL file
+    console.log('\n=== Test 5: Extend Base ===');
+    const extendedStlPath = await manipulator.extendBase(stlPath, 0.5, progressCallback);
+    console.log(`Extended STL saved to: ${extendedStlPath}`);
+    
+    // Test 6: Modify a section of the STL file
+    console.log('\n=== Test 6: Modify Section (Top) ===');
+    const modifiedStlPath = await manipulator.modifySection(
+      stlPath,
+      'top',
+      {
+        type: 'scale',
+        value: [1.5, 1.5, 1.5]
+      },
+      progressCallback
+    );
+    console.log(`Modified STL saved to: ${modifiedStlPath}`);
+    
+    console.log('\nAll tests completed successfully!');
+  } catch (error) {
+    console.error('An error occurred during testing:', error);
+    process.exit(1);
+  }
+}
+
+// Run the tests
+testSTLManipulator().catch(console.error);