mcp-3d-printer-server 0.2.3 → 1.0.1

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { STLManipulator } from '../stl/stl-manipulator.js';
+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}`);
+        // Test 7: Generate visualization of the STL file
+        console.log('\n=== Test 7: Generate Visualization ===');
+        const visualizationPath = await manipulator.generateVisualization(stlPath, 400, 400, progressCallback);
+        console.log(`Visualization saved to: ${visualizationPath}`);
+        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);

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+import { AxiosInstance } from "axios";
+import { BambuPrinter } from "bambu-js";
+export type BambuFTP = {
+    readDir: (path: string) => Promise<string[]>;
+    sendFile: (sourcePath: string, destinationPath: string, progressCallback?: (progress: number) => void) => Promise<void>;
+    removeFile: (path: string) => Promise<void>;
+};
+export declare abstract class PrinterImplementation {
+    protected apiClient: AxiosInstance;
+    constructor(apiClient: AxiosInstance);
+    abstract getStatus(host: string, port: string, apiKey: string): Promise<any>;
+    abstract getFiles(host: string, port: string, apiKey: string): Promise<any>;
+    abstract getFile(host: string, port: string, apiKey: string, filename: string): Promise<any>;
+    abstract uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean): Promise<any>;
+    abstract startJob(host: string, port: string, apiKey: string, filename: string): Promise<any>;
+    abstract cancelJob(host: string, port: string, apiKey: string): Promise<any>;
+    abstract setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number): Promise<any>;
+}
+export declare class BambuPrinterStore {
+    private printers;
+    get(host: string, serial: string, token: string): InstanceType<typeof BambuPrinter>;
+    disconnectAll(): Promise<void>;
+}
+export interface SectionBounds {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+}
+export interface ThreeMFMetadata {
+    [key: string]: string;
+}
+export interface ThreeMFObject {
+    id: string;
+    name?: string;
+    type?: string;
+    mesh?: any;
+}
+export interface ThreeMFBuildItem {
+    objectId: string;
+    transform?: string;
+}
+export interface AMSFilamentMapping {
+    [filamentId: string]: number;
+}
+export interface BambuSlicerConfig {
+    layer_height?: number;
+    first_layer_height?: number;
+    sparse_infill_density?: number;
+    sparse_infill_pattern?: string;
+    support_enabled?: boolean;
+    support_type?: string;
+    support_threshold_angle?: number;
+    raft_layers?: number;
+    brim_width?: number;
+    wall_loops?: number;
+    top_shell_layers?: number;
+    bottom_shell_layers?: number;
+    nozzle_temperature?: number[];
+    bed_temperature?: number;
+    filament_type?: string[];
+    flow_ratio?: number[];
+    ams_mapping?: AMSFilamentMapping;
+    [key: string]: any;
+}
+export interface ThreeMFData {
+    metadata: ThreeMFMetadata;
+    objects: ThreeMFObject[];
+    build: {
+        items: ThreeMFBuildItem[];
+    };
+    slicerConfig?: Partial<BambuSlicerConfig>;
+}

package/dist/types.js

@@ -0,0 +1,26 @@
+import { BambuPrinter } from "bambu-js";
+// Base class for printer implementations
+export class PrinterImplementation {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+}
+// Store for Bambu printers
+export class BambuPrinterStore {
+    constructor() {
+        this.printers = new Map();
+    }
+    get(host, serial, token) {
+        const key = `${host}-${serial}`;
+        if (!this.printers.has(key)) {
+            const printer = new BambuPrinter(host, serial, token);
+            this.printers.set(key, printer);
+        }
+        return this.printers.get(key);
+    }
+    async disconnectAll() {
+        for (const printer of this.printers.values()) {
+            await printer.disconnect();
+        }
+    }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "mcp-3d-printer-server",
-    "version": "0.2.3",
+    "version": "1.0.1",
     "description": "MCP server for connecting Claude with 3D printer management systems",
-    "main": "src/index.js",
+    "main": "dist/index.js",
     "repository": "https://github.com/DMontgomery40/mcp-3D-printer-server",
     "type": "module",
     "scripts": {
@@ -12,8 +12,14 @@
         "test": "npm run build && node dist/test/stl-manipulator-test.js"
     },
     "bin": {
-        "mcp-3d-printer-server": "./src/index.js"
+        "mcp-3d-printer-server": "./dist/index.js"
     },
+    "files": [
+        "dist",
+        "src",
+        "README.md",
+        "LICENSE"
+    ],
     "keywords": [
         "mcp",
         "3d-printer",
@@ -34,11 +40,15 @@
         "bambu-js": "^2.2.2",
         "dotenv": "^16.3.1",
         "form-data": "^4.0.0",
-        "three": "^0.173.0"
+        "jszip": "^3.10.1",
+        "three": "^0.173.0",
+        "xml2js": "^0.6.2"
     },
     "devDependencies": {
+        "@types/jszip": "^3.4.0",
         "@types/node": "^18.0.0",
         "@types/three": "^0.173.0",
+        "@types/xml2js": "^0.4.14",
         "nodemon": "^2.0.22"
     }
 }

package/src/3mf_parser.ts

@@ -0,0 +1,223 @@
+import JSZip from 'jszip';
+import { parseStringPromise } from 'xml2js';
+import { ThreeMFData, BambuSlicerConfig, ThreeMFMetadata, ThreeMFObject, ThreeMFBuildItem, AMSFilamentMapping } from './types.js';
+import * as fs from 'fs/promises';
+
+// Parses Bambu Studio's JSON config data
+function parseBambuJSONConfig(jsonData: any): Partial<BambuSlicerConfig> {
+    const config: Partial<BambuSlicerConfig> = {};
+    const amsMapping: AMSFilamentMapping = {};
+
+    // Map known keys, converting types as needed
+    if (jsonData.layer_height !== undefined) config.layer_height = parseFloat(jsonData.layer_height);
+    if (jsonData.initial_layer_print_height !== undefined) config.first_layer_height = parseFloat(jsonData.initial_layer_print_height);
+    if (jsonData.sparse_infill_density !== undefined) config.sparse_infill_density = parseFloat(jsonData.sparse_infill_density);
+    if (jsonData.sparse_infill_pattern !== undefined) config.sparse_infill_pattern = String(jsonData.sparse_infill_pattern);
+    if (jsonData.enable_support !== undefined) config.support_enabled = String(jsonData.enable_support) === '1' || String(jsonData.enable_support).toLowerCase() === 'true';
+    if (jsonData.support_type !== undefined) config.support_type = String(jsonData.support_type);
+    if (jsonData.support_angle !== undefined) config.support_threshold_angle = parseFloat(jsonData.support_angle);
+    if (jsonData.raft_layers !== undefined) config.raft_layers = parseInt(String(jsonData.raft_layers), 10);
+    if (jsonData.brim_width !== undefined) config.brim_width = parseFloat(jsonData.brim_width);
+    if (jsonData.wall_loops !== undefined) config.wall_loops = parseInt(String(jsonData.wall_loops), 10);
+    if (jsonData.top_shell_layers !== undefined) config.top_shell_layers = parseInt(String(jsonData.top_shell_layers), 10);
+    if (jsonData.bottom_shell_layers !== undefined) config.bottom_shell_layers = parseInt(String(jsonData.bottom_shell_layers), 10);
+
+    // Temperatures (handle potential arrays)
+    if (Array.isArray(jsonData.nozzle_temperature) && jsonData.nozzle_temperature.length > 0) {
+        config.nozzle_temperature = jsonData.nozzle_temperature.map((t: string | number) => parseFloat(String(t)));
+    } else if (jsonData.nozzle_temperature !== undefined) {
+         config.nozzle_temperature = [parseFloat(String(jsonData.nozzle_temperature))];
+    }
+    // Bed Temp (prefer initial layer temp)
+    let bedTempKey = jsonData.hot_plate_temp_initial_layer !== undefined ? 'hot_plate_temp_initial_layer' : 'hot_plate_temp';
+    if (jsonData[bedTempKey] !== undefined) {
+         if (Array.isArray(jsonData[bedTempKey]) && jsonData[bedTempKey].length > 0) {
+              config.bed_temperature = parseFloat(String(jsonData[bedTempKey][0]));
+         } else {
+             config.bed_temperature = parseFloat(String(jsonData[bedTempKey]));
+         }
+    }
+    
+    // Filaments and Flow (handle potential arrays)
+    if (Array.isArray(jsonData.filament_type) && jsonData.filament_type.length > 0) {
+        config.filament_type = jsonData.filament_type.map(String);
+    }
+    if (Array.isArray(jsonData.filament_flow_ratio) && jsonData.filament_flow_ratio.length > 0) {
+        config.flow_ratio = jsonData.filament_flow_ratio.map((f: string | number) => parseFloat(String(f)));
+    }
+
+    // AMS Mapping (derive from filament_settings_id order)
+    if (Array.isArray(jsonData.filament_settings_id) && jsonData.filament_settings_id.length > 0) {
+        jsonData.filament_settings_id.forEach((filamentId: string, index: number) => {
+            // Map filament ID (e.g., "Generic PLA @BBL P1P") to its index (assumed AMS slot)
+            if (filamentId) { // Ensure filamentId is not empty
+                 amsMapping[filamentId] = index;
+            }
+        });
+        if (Object.keys(amsMapping).length > 0) {
+             config.ams_mapping = amsMapping;
+        }
+    }
+
+    // Store remaining keys found in the config
+    for (const key in jsonData) {
+        if (!config.hasOwnProperty(key)) {
+            // Simple assignment for remaining keys, preserving original type if possible
+            config[key] = jsonData[key]; 
+        }
+    }
+
+    return config;
+}
+
+async function parseBambuConfig(zip: JSZip): Promise<Partial<BambuSlicerConfig>> {
+    // Look for common Bambu config file names
+    const potentialFiles = ['Metadata/project_settings.config', 'Metadata/model_settings.config', 'Metadata/slice_info.config'];
+    let configFile = null;
+    let configContent = '';
+
+    for (const name of potentialFiles) {
+        const file = zip.file(name);
+        if (file) {
+            configFile = file;
+            configContent = await file.async('string');
+            console.log(`Found Bambu config file: ${configFile.name}`);
+            break; // Use the first one found (project usually has the most)
+        }
+    }
+
+    if (configFile && configContent) {
+        try {
+            // Attempt to parse as JSON
+            const jsonData = JSON.parse(configContent);
+            const parsedConfig = parseBambuJSONConfig(jsonData);
+            console.log('Bambu config parsed successfully as JSON.');
+            return parsedConfig;
+        } catch (jsonError: any) {
+            console.warn(`Failed to parse ${configFile.name} as JSON: ${jsonError.message}. Attempting INI parse as fallback...`);
+            // Fallback: Try parsing as INI if JSON fails (though unlikely based on sample)
+            try {
+                 const parsedConfig = parseFallbackINIConfig(configContent); // Keep a simple INI parser as fallback
+                 console.log('Bambu config parsed successfully as INI (fallback).');
+                 return parsedConfig;
+            } catch (iniError: any) {
+                 console.error(`Error parsing Bambu config ${configFile.name} as INI (fallback):`, iniError);
+                 return {};
+            }
+        }
+    } else {
+        console.log('No Bambu-specific config file found in Metadata directory.');
+        return {};
+    }
+}
+
+// Fallback INI parser (Simplified version of the previous one)
+function parseFallbackINIConfig(configContent: string): Partial<BambuSlicerConfig> {
+     const config: Partial<BambuSlicerConfig> = {};
+     const lines = configContent.split(/\r?\n/);
+     for (const line of lines) {
+         const trimmedLine = line.trim();
+         if (!trimmedLine || trimmedLine.startsWith('#') || trimmedLine.startsWith(';')) continue;
+         const equalsIndex = trimmedLine.indexOf('=');
+         if (equalsIndex === -1) continue;
+         const key = trimmedLine.substring(0, equalsIndex).trim();
+         const value = trimmedLine.substring(equalsIndex + 1).trim();
+         // Simple assignment - no type conversion here for fallback
+         config[key] = value;
+     }
+     return config;
+ }
+
+async function parse3DModelConfig(zip: JSZip): Promise<{ metadata: ThreeMFMetadata, objects: ThreeMFObject[], build: { items: ThreeMFBuildItem[] } }> {
+    const modelFile = zip.file('3D/3dmodel.model');
+    if (!modelFile) {
+        throw new Error('3D/3dmodel.model not found in 3MF archive');
+    }
+
+    const modelContent = await modelFile.async('string');
+    try {
+        const parsedXml = await parseStringPromise(modelContent, {
+            explicitArray: false, 
+            mergeAttrs: true,
+            charkey: 'value'
+        });
+
+        const modelData = parsedXml.model;
+        if (!modelData) {
+            throw new Error('Invalid 3dmodel.model format: <model> tag not found.');
+        }
+
+        const metadata: ThreeMFMetadata = { unit: modelData.unit || 'millimeter' };
+        if (modelData.metadata) {
+            const metas = Array.isArray(modelData.metadata) ? modelData.metadata : [modelData.metadata];
+            metas.forEach((meta: any) => {
+                if (meta.name && meta.value !== undefined) {
+                    metadata[meta.name] = String(meta.value);
+                }
+            });
+        }
+
+        const objects: ThreeMFObject[] = [];
+        if (modelData.resources?.object) {
+            const resources = Array.isArray(modelData.resources.object) ? modelData.resources.object : [modelData.resources.object];
+            resources.forEach((objResource: any) => {
+                objects.push({
+                    id: objResource.id, 
+                    name: objResource.name,
+                    type: objResource.type || 'model'
+                    // Actual mesh data (vertices, triangles) is nested deeper if needed
+                });
+            });
+        }
+
+        const buildItems: ThreeMFBuildItem[] = [];
+        if (modelData.build?.item) {
+            const items = Array.isArray(modelData.build.item) ? modelData.build.item : [modelData.build.item];
+            items.forEach((item: any) => {
+                buildItems.push({
+                    objectId: item.objectid,
+                    transform: item.transform
+                });
+            });
+        }
+
+        console.log('3dmodel.model parsed successfully.');
+        return { metadata, objects, build: { items: buildItems } };
+
+    } catch (error: any) {
+        console.error('Error parsing 3dmodel.model XML:', error);
+        throw new Error(`Failed to parse 3dmodel.model: ${error.message}`);
+    }
+}
+
+export { ThreeMFData };
+
+export async function parse3MF(filePath: string): Promise<ThreeMFData> {
+    console.log(`Parsing 3MF file: ${filePath}`);
+    try {
+        const data = await fs.readFile(filePath);
+        const zip = await JSZip.loadAsync(data);
+
+        // List files for debugging
+        // const fileList = Object.keys(zip.files);
+        // console.log('Files in 3MF:', fileList);
+
+        const { metadata, objects, build } = await parse3DModelConfig(zip);
+        const bambuConfig = await parseBambuConfig(zip);
+
+        // Combine data into the final structure
+        const combinedData: ThreeMFData = {
+            metadata,
+            objects,
+            build,
+            slicerConfig: bambuConfig
+        };
+
+        console.log('3MF parsing completed.');
+        return combinedData;
+
+    } catch (error: any) {
+        console.error(`Error parsing 3MF file ${filePath}:`, error);
+        throw new Error(`Failed to parse 3MF file: ${error.message}`);
+    }
+}