mcp-3d-printer-server 1.0.2 → 1.2.1

package/dist/stl/stl-manipulator.js

@@ -39,7 +39,8 @@ export class STLManipulator extends EventEmitter {
                 progressCallback(30, "Parsing STL data...");
             // Load the STL data into a Three.js geometry
             const loader = new STLLoader();
-            const geometry = loader.parse(stlData.buffer);
+            const rawArrayBuffer = stlData.buffer.slice(stlData.byteOffset, stlData.byteOffset + stlData.byteLength);
+            const geometry = loader.parse(rawArrayBuffer);
             // Create a mesh from the geometry
             const material = new THREE.MeshStandardMaterial();
             const mesh = new THREE.Mesh(geometry, material);
@@ -643,15 +644,15 @@ export class STLManipulator extends EventEmitter {
         }
     }
     /**
-     * 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)
+     * Slice an STL or 3MF file using the specified slicer
+     * @param stlFilePath Path to the input STL or 3MF file
+     * @param slicerType Type of slicer (prusaslicer, cura, slic3r, orcaslicer, bambustudio)
      * @param slicerPath Path to the slicer executable
      * @param slicerProfile Optional path to the slicer profile/config file
      * @param progressCallback Optional callback for progress updates
-     * @returns Path to the generated G-code file
+     * @returns Path to the generated G-code or sliced 3MF file
      */
-    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback) {
+    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
         if (!fs.existsSync(slicerPath)) {
@@ -662,7 +663,7 @@ export class STLManipulator extends EventEmitter {
             // Allow proceeding without profile, slicer might handle it
         }
         const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
-        const outputFilePath = path.join(this.tempDir, outputFileName);
+        let outputFilePath = path.join(this.tempDir, outputFileName);
         let args = [];
         try {
             if (progressCallback)
@@ -711,6 +712,30 @@ export class STLManipulator extends EventEmitter {
                         args.push('-j', slicerProfile); // Load settings from profile definition file
                     }
                     break;
+                case 'bambustudio':
+                    // Bambu Studio CLI: slice and export as 3MF with embedded gcode
+                    // For 3MF input: slice in place and export sliced 3MF
+                    // For STL input: slice and export as 3MF
+                    {
+                        const is3mf = stlFilePath.toLowerCase().endsWith('.3mf');
+                        const outputBase = path.basename(stlFilePath, is3mf ? '.3mf' : '.stl');
+                        const bambuOutputPath = path.join(this.tempDir, outputBase + '_sliced.3mf');
+                        args = [
+                            '--slice', '0', // Slice all plates
+                            '--export-3mf', bambuOutputPath,
+                        ];
+                        // --load-machine ensures correct G-code for the specific printer model
+                        if (printerPreset && !slicerProfile) {
+                            args.push('--load-machine', printerPreset);
+                        }
+                        if (slicerProfile) {
+                            args.push('--load-settings', slicerProfile);
+                        }
+                        args.push(stlFilePath);
+                        // Override outputFilePath for bambustudio since it produces 3MF, not gcode
+                        outputFilePath = bambuOutputPath;
+                    }
+                    break;
                 default:
                     throw new Error(`Unsupported slicer type: ${slicerType}`);
             }

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 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>;
@@ -16,11 +15,6 @@ export declare abstract class PrinterImplementation {
     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;

package/dist/types.js

@@ -1,26 +1,6 @@
-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,15 +1,18 @@
 {
     "name": "mcp-3d-printer-server",
-    "version": "1.0.2",
+    "version": "1.2.1",
     "description": "MCP server for connecting Claude with 3D printer management systems",
     "main": "dist/index.js",
     "repository": "https://github.com/DMontgomery40/mcp-3D-printer-server",
     "type": "module",
     "scripts": {
         "start": "node dist/index.js",
+        "start:stdio": "MCP_TRANSPORT=stdio node dist/index.js",
+        "start:http": "MCP_TRANSPORT=streamable-http node dist/index.js",
         "dev": "nodemon src/index.ts --exec \"npm run build && npm start\"",
         "build": "tsc",
-        "test": "npm run build && node dist/test/stl-manipulator-test.js"
+        "test": "npm run build && node dist/test/stl-manipulator-test.js && node --test tests/**/*.test.mjs",
+        "inspect": "npm run build && npx @modelcontextprotocol/inspector dist/index.js"
     },
     "bin": {
         "mcp-3d-printer-server": "./dist/index.js"
@@ -35,14 +38,17 @@
     "author": "David Montgomery",
     "license": "GPL-2.0",
     "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.6.0",
+        "@modelcontextprotocol/sdk": "^1.27.0",
         "axios": "^1.6.2",
         "bambu-js": "^2.2.2",
+        "bambu-node": "^3.22.21",
+        "basic-ftp": "^5.2.0",
         "dotenv": "^16.3.1",
         "form-data": "^4.0.0",
         "jszip": "^3.10.1",
         "three": "^0.173.0",
-        "xml2js": "^0.6.2"
+        "xml2js": "^0.6.2",
+        "zod": "^3.25.76"
     },
     "devDependencies": {
         "@types/jszip": "^3.4.0",

package/src/http-server.ts

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ErrorCode,
+  McpError,
+  JSONRPCRequest,
+  JSONRPCResponse,
+  JSONRPCError
+} from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+import dotenv from "dotenv";
+import fs from "fs";
+import path from "path";
+import * as THREE from 'three';
+import { PrinterFactory } from "./printers/printer-factory.js";
+import { STLManipulator } from "./stl/stl-manipulator.js";
+import { parse3MF, ThreeMFData } from './3mf_parser.js';
+import { BambuImplementation } from "./printers/bambu.js";
+
+// Load environment variables from .env file
+dotenv.config();
+
+// Default values
+const DEFAULT_HOST = process.env.PRINTER_HOST || "localhost";
+const DEFAULT_PORT = process.env.PRINTER_PORT || "80";
+const DEFAULT_API_KEY = process.env.API_KEY || "";
+const DEFAULT_TYPE = process.env.PRINTER_TYPE || "octoprint";
+const TEMP_DIR = process.env.TEMP_DIR || path.join(process.cwd(), "temp");
+
+// HTTP Server configuration
+const HTTP_PORT = parseInt(process.env.HTTP_PORT || "3001");
+
+// Slicer configuration
+const DEFAULT_SLICER_TYPE = process.env.SLICER_TYPE || "prusaslicer";
+const DEFAULT_SLICER_PATH = process.env.SLICER_PATH || "";
+const DEFAULT_SLICER_PROFILE = process.env.SLICER_PROFILE || "";
+
+// Bambu-specific default values
+const DEFAULT_BAMBU_SERIAL = process.env.BAMBU_SERIAL || "";
+const DEFAULT_BAMBU_TOKEN = process.env.BAMBU_TOKEN || "";
+
+// Ensure temp directory exists
+if (!fs.existsSync(TEMP_DIR)) {
+  fs.mkdirSync(TEMP_DIR, { recursive: true });
+}
+
+class ThreeDPrinterMCPServerHTTP {
+  private server: Server;
+  private printerFactory: PrinterFactory;
+  private stlManipulator: STLManipulator;
+  private app: express.Application;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "mcp-3d-printer-server",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {},
+          prompts: {}
+        }
+      }
+    );
+
+    this.printerFactory = new PrinterFactory();
+    this.stlManipulator = new STLManipulator(TEMP_DIR);
+
+    this.app = express();
+    this.setupExpressApp();
+    this.setupHandlers();
+    this.setupErrorHandling();
+  }
+
+  private setupExpressApp() {
+    // Enable CORS for all origins
+    this.app.use(cors({
+      origin: '*',
+      methods: ['GET', 'POST', 'OPTIONS'],
+      allowedHeaders: ['Content-Type', 'Accept'],
+      credentials: true
+    }));
+
+    // Parse JSON bodies
+    this.app.use(express.json({ limit: '50mb' }));
+
+    // Main MCP endpoint - supports both standard and streaming responses
+    this.app.post('/mcp', async (req: Request, res: Response) => {
+      const acceptHeader = req.get('Accept') || '';
+      const wantsStream = acceptHeader.includes('text/event-stream');
+      
+      try {
+        const requests = Array.isArray(req.body) ? req.body : [req.body];
+        const responses: JSONRPCResponse[] = [];
+
+        for (const request of requests) {
+          const response = await this.handleJSONRPCRequest(request);
+          if (response) {
+            responses.push(response);
+          }
+        }
+
+        // If client wants streaming and we have responses, use SSE format
+        if (wantsStream && responses.length > 0) {
+          res.setHeader('Content-Type', 'text/event-stream');
+          res.setHeader('Cache-Control', 'no-cache');
+          res.setHeader('Connection', 'keep-alive');
+
+          for (const response of responses) {
+            res.write(`data: ${JSON.stringify(response)}\n\n`);
+          }
+          
+          res.end();
+        } else if (responses.length > 0) {
+          // Standard JSON response
+          res.json(responses.length === 1 ? responses[0] : responses);
+        } else {
+          // No responses (notifications)
+          res.status(202).send();
+        }
+      } catch (error) {
+        console.error('Error handling request:', error);
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal error",
+            data: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+    });
+
+    // GET endpoint for establishing SSE stream (Streamable HTTP)
+    this.app.get('/mcp', async (req: Request, res: Response) => {
+      const acceptHeader = req.get('Accept') || '';
+      
+      if (!acceptHeader.includes('text/event-stream')) {
+        res.status(405).json({
+          error: 'Method not allowed. Use POST for non-streaming requests.'
+        });
+        return;
+      }
+
+      // Set SSE headers
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+      res.setHeader('X-Accel-Buffering', 'no');
+
+      // Send initial connection event
+      res.write(`event: open\ndata: {"type": "connection", "status": "connected"}\n\n`);
+
+      // Keep connection alive with periodic pings
+      const pingInterval = setInterval(() => {
+        if (!res.writableEnded) {
+          res.write(`event: ping\ndata: ${new Date().toISOString()}\n\n`);
+        }
+      }, 30000);
+
+      // Handle client disconnect
+      req.on('close', () => {
+        clearInterval(pingInterval);
+        res.end();
+      });
+    });
+
+    // Health check endpoint
+    this.app.get('/health', (req: Request, res: Response) => {
+      res.json({
+        status: 'ok',
+        server: 'mcp-3d-printer-server',
+        transport: 'streamable-http',
+        version: '1.0.0'
+      });
+    });
+
+    // Root endpoint
+    this.app.get('/', (req: Request, res: Response) => {
+      res.json({
+        name: 'MCP 3D Printer Server (HTTP)',
+        version: '1.0.0',
+        endpoints: {
+          mcp: '/mcp',
+          health: '/health'
+        },
+        transport: 'streamable-http',
+        features: ['stdio', 'sse', 'http'],
+        documentation: 'https://github.com/DMontgomery40/mcp-3D-printer-server'
+      });
+    });
+  }
+
+  private async handleJSONRPCRequest(request: JSONRPCRequest): Promise<JSONRPCResponse | null> {
+    try {
+      // Route based on method
+      switch (request.method) {
+        case 'initialize':
+          return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+              protocolVersion: "2025-03-26",
+              capabilities: this.server.capabilities,
+              serverInfo: {
+                name: "mcp-3d-printer-server",
+                version: "1.0.0"
+              }
+            }
+          };
+
+        case 'resources/list':
+          const resourcesResult = await this.server.handleRequest(request);
+          return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: resourcesResult
+          };
+
+        case 'resources/read':
+          const readResult = await this.server.handleRequest(request);
+          return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: readResult
+          };
+
+        case 'tools/list':
+          const toolsResult = await this.server.handleRequest(request);
+          return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: toolsResult
+          };
+
+        case 'tools/call':
+          const callResult = await this.server.handleRequest(request);
+          return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: callResult
+          };
+
+        default:
+          if (request.id) {
+            return {
+              jsonrpc: "2.0",
+              id: request.id,
+              error: {
+                code: -32601,
+                message: `Method not found: ${request.method}`
+              }
+            };
+          }
+          return null; // Notification
+      }
+    } catch (error) {
+      if (request.id) {
+        return {
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32603,
+            message: "Internal error",
+            data: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+      return null;
+    }
+  }
+
+  setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+
+    process.on("SIGINT", async () => {
+      console.log("\nShutting down HTTP server...");
+      await this.printerFactory.disconnectAll();
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupHandlers() {
+    this.setupResourceHandlers();
+    this.setupToolHandlers();
+  }
+
+  // Copy all handlers from original index.ts
+  setupResourceHandlers() {
+    // ... (copy from original)
+  }
+
+  setupToolHandlers() {
+    // ... (copy from original)
+  }
+
+  // Copy all delegating methods from original index.ts
+  // ... (copy all printer methods)
+
+  async run() {
+    // Start Express server
+    this.app.listen(HTTP_PORT, () => {
+      console.log(`🚀 MCP 3D Printer Server (HTTP) running on http://localhost:${HTTP_PORT}`);
+      console.log(`📡 MCP endpoint: http://localhost:${HTTP_PORT}/mcp`);
+      console.log(`✨ Supports both standard HTTP and Server-Sent Events`);
+    });
+  }
+}
+
+// Check if running as main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = new ThreeDPrinterMCPServerHTTP();
+  server.run().catch(console.error);
+}
+
+export default ThreeDPrinterMCPServerHTTP;