mcp-3d-printer-server 1.0.2 → 1.2.1

package/src/sse-server.ts

@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import { v4 as uuidv4 } from 'uuid';
+import { Readable } from 'stream';
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ErrorCode,
+  McpError
+} 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");
+
+// SSE Server configuration
+const SSE_PORT = parseInt(process.env.SSE_PORT || "3000");
+
+// 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 ThreeDPrinterMCPServerSSE {
+  private server: Server;
+  private printerFactory: PrinterFactory;
+  private stlManipulator: STLManipulator;
+  private app: express.Application;
+  private sessions: Map<string, { transport: SSEServerTransport, lastActivity: number }> = new Map();
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "mcp-3d-printer-server",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {}
+        }
+      }
+    );
+
+    this.printerFactory = new PrinterFactory();
+    this.stlManipulator = new STLManipulator(TEMP_DIR);
+
+    this.app = express();
+    this.setupExpressApp();
+    this.setupHandlers();
+    this.setupErrorHandling();
+    this.startSessionCleanup();
+  }
+
+  private setupExpressApp() {
+    // Enable CORS for all origins
+    this.app.use(cors({
+      origin: '*',
+      methods: ['GET', 'POST', 'OPTIONS'],
+      allowedHeaders: ['Content-Type', 'Accept', 'Last-Event-ID'],
+      credentials: true
+    }));
+
+    // Parse JSON bodies
+    this.app.use(express.json({ limit: '50mb' }));
+
+    // SSE endpoint - establishes the event stream
+    this.app.get('/sse', async (req: Request, res: Response) => {
+      const sessionId = uuidv4();
+      const messagesPath = `/messages?session_id=${sessionId}`;
+
+      // 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 endpoint event
+      res.write(`event: endpoint\ndata: ${messagesPath}\n\n`);
+
+      // Create transport for this session
+      const transport = new SSEServerTransport(messagesPath);
+      this.sessions.set(sessionId, { transport, lastActivity: Date.now() });
+
+      // Send periodic ping events to keep connection alive
+      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);
+        this.sessions.delete(sessionId);
+        res.end();
+      });
+
+      // Handle transport errors
+      transport.onerror = (error) => {
+        console.error(`SSE Transport error for session ${sessionId}:`, error);
+        clearInterval(pingInterval);
+        this.sessions.delete(sessionId);
+        res.end();
+      };
+    });
+
+    // Messages endpoint - handles JSON-RPC messages
+    this.app.post('/messages', async (req: Request, res: Response) => {
+      const sessionId = req.query.session_id as string;
+      
+      if (!sessionId || !this.sessions.has(sessionId)) {
+        res.status(400).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32600,
+            message: "Invalid or missing session ID"
+          }
+        });
+        return;
+      }
+
+      const session = this.sessions.get(sessionId)!;
+      session.lastActivity = Date.now();
+
+      try {
+        // Handle the message through the transport
+        const result = await session.transport.handleMessage(req.body);
+        
+        if (result) {
+          res.json(result);
+        } else {
+          res.status(202).send(); // Accepted, no response needed
+        }
+      } catch (error) {
+        console.error('Error handling message:', error);
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal error",
+            data: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+    });
+
+    // Health check endpoint
+    this.app.get('/health', (req: Request, res: Response) => {
+      res.json({
+        status: 'ok',
+        server: 'mcp-3d-printer-server',
+        transport: 'sse',
+        sessions: this.sessions.size
+      });
+    });
+
+    // Root endpoint
+    this.app.get('/', (req: Request, res: Response) => {
+      res.json({
+        name: 'MCP 3D Printer Server (SSE)',
+        version: '1.0.0',
+        endpoints: {
+          sse: '/sse',
+          messages: '/messages',
+          health: '/health'
+        },
+        transport: 'sse',
+        documentation: 'https://github.com/DMontgomery40/mcp-3D-printer-server'
+      });
+    });
+  }
+
+  private startSessionCleanup() {
+    // Clean up inactive sessions every 5 minutes
+    setInterval(() => {
+      const now = Date.now();
+      const timeout = 10 * 60 * 1000; // 10 minutes
+
+      for (const [sessionId, session] of this.sessions.entries()) {
+        if (now - session.lastActivity > timeout) {
+          console.log(`Cleaning up inactive session: ${sessionId}`);
+          this.sessions.delete(sessionId);
+        }
+      }
+    }, 5 * 60 * 1000);
+  }
+
+  setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+
+    process.on("SIGINT", async () => {
+      console.log("\nShutting down SSE server...");
+      // Disconnect all printers
+      await this.printerFactory.disconnectAll();
+      // Close all sessions
+      for (const [sessionId, _] of this.sessions.entries()) {
+        this.sessions.delete(sessionId);
+      }
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupHandlers() {
+    this.setupResourceHandlers();
+    this.setupToolHandlers();
+  }
+
+  setupResourceHandlers() {
+    // List available resources
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: [
+          {
+            uri: `printer://${DEFAULT_HOST}/status`,
+            name: "3D Printer Status",
+            mimeType: "application/json",
+            description: "Current status of the 3D printer including temperatures, print progress, and more"
+          },
+          {
+            uri: `printer://${DEFAULT_HOST}/files`,
+            name: "3D Printer Files",
+            mimeType: "application/json",
+            description: "List of files available on the 3D printer"
+          }
+        ],
+        templates: [
+          {
+            uriTemplate: "printer://{host}/status",
+            name: "3D Printer Status",
+            mimeType: "application/json"
+          },
+          {
+            uriTemplate: "printer://{host}/files",
+            name: "3D Printer Files",
+            mimeType: "application/json"
+          },
+          {
+            uriTemplate: "printer://{host}/file/{filename}",
+            name: "3D Printer File Content",
+            mimeType: "application/gcode"
+          }
+        ]
+      };
+    });
+
+    // Read resource
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const match = uri.match(/^printer:\/\/([^\/]+)\/(.+)$/);
+
+      if (!match) {
+        throw new McpError(ErrorCode.InvalidRequest, `Invalid resource URI: ${uri}`);
+      }
+
+      const [, host, resource] = match;
+      let content;
+
+      try {
+        if (resource === "status") {
+          content = await this.getPrinterStatus(host);
+        } else if (resource === "files") {
+          content = await this.getPrinterFiles(host);
+        } else if (resource.startsWith("file/")) {
+          const filename = resource.substring(5);
+          content = await this.getPrinterFile(host, filename);
+        } else {
+          throw new McpError(ErrorCode.InvalidRequest, `Unknown resource: ${resource}`);
+        }
+
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: resource.startsWith("file/") ? "application/gcode" : "application/json",
+              text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (axios.isAxiosError(error)) {
+          throw new McpError(
+            ErrorCode.InternalError,
+            `API error: ${error.response?.data?.error || error.message}`
+          );
+        }
+        throw error;
+      }
+    });
+  }
+
+  setupToolHandlers() {
+    // Tool handlers remain the same as in the stdio version
+    // ... (copy all tool handlers from the original index.ts)
+  }
+
+  // Delegating methods to printer implementations (same as original)
+  
+  async getPrinterStatus(
+    host: string, 
+    port = DEFAULT_PORT, 
+    type = DEFAULT_TYPE, 
+    apiKey = DEFAULT_API_KEY,
+    bambuSerial = DEFAULT_BAMBU_SERIAL,
+    bambuToken = DEFAULT_BAMBU_TOKEN
+  ) {
+    const implementation = this.printerFactory.getImplementation(type);
+    
+    if (type.toLowerCase() === "bambu") {
+      const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+      return implementation.getStatus(host, port, bambuApiKey);
+    }
+    
+    return implementation.getStatus(host, port, apiKey);
+  }
+
+  async getPrinterFiles(
+    host: string, 
+    port = DEFAULT_PORT, 
+    type = DEFAULT_TYPE, 
+    apiKey = DEFAULT_API_KEY,
+    bambuSerial = DEFAULT_BAMBU_SERIAL,
+    bambuToken = DEFAULT_BAMBU_TOKEN
+  ) {
+    const implementation = this.printerFactory.getImplementation(type);
+    
+    if (type.toLowerCase() === "bambu") {
+      const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+      return implementation.getFiles(host, port, bambuApiKey);
+    }
+    
+    return implementation.getFiles(host, port, apiKey);
+  }
+
+  async getPrinterFile(
+    host: string, 
+    filename: string, 
+    port = DEFAULT_PORT, 
+    type = DEFAULT_TYPE, 
+    apiKey = DEFAULT_API_KEY,
+    bambuSerial = DEFAULT_BAMBU_SERIAL,
+    bambuToken = DEFAULT_BAMBU_TOKEN
+  ) {
+    const implementation = this.printerFactory.getImplementation(type);
+    
+    if (type.toLowerCase() === "bambu") {
+      return (implementation as any).getFile(host, port, apiKey, bambuSerial, bambuToken, filename);
+    }
+    
+    return implementation.getFile(host, port, apiKey, filename);
+  }
+
+  // ... (copy all other delegating methods from original index.ts)
+
+  async run() {
+    // Connect SSE transports to the server
+    for (const [sessionId, session] of this.sessions.entries()) {
+      await this.server.connect(session.transport);
+    }
+
+    // Start Express server
+    this.app.listen(SSE_PORT, () => {
+      console.log(`🚀 MCP 3D Printer Server (SSE) running on http://localhost:${SSE_PORT}`);
+      console.log(`📡 SSE endpoint: http://localhost:${SSE_PORT}/sse`);
+      console.log(`💬 Messages endpoint: http://localhost:${SSE_PORT}/messages`);
+    });
+  }
+}
+
+// Check if running as main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = new ThreeDPrinterMCPServerSSE();
+  server.run().catch(console.error);
+}
+
+export default ThreeDPrinterMCPServerSSE;

package/src/stl/stl-manipulator.ts

@@ -79,7 +79,11 @@ export class STLManipulator extends EventEmitter {
       
       // 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
+      ) as ArrayBuffer;
+      const geometry = loader.parse(rawArrayBuffer);
       
       // Create a mesh from the geometry
       const material = new THREE.MeshStandardMaterial();
@@ -839,20 +843,21 @@ 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: string,
-    slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer',
+    slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio',
     slicerPath: string,
     slicerProfile?: string,
-    progressCallback?: ProgressCallback
+    progressCallback?: ProgressCallback,
+    printerPreset?: string
   ): Promise<string> {
     const operationId = this.generateOperationId();
     this.activeOperations.set(operationId, true);
@@ -866,7 +871,7 @@ export class STLManipulator extends EventEmitter {
     }
 
     const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
-    const outputFilePath = path.join(this.tempDir, outputFileName);
+    let outputFilePath = path.join(this.tempDir, outputFileName);
 
     let args: string[] = [];
 
@@ -920,6 +925,31 @@ export class STLManipulator extends EventEmitter {
           }
           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/src/types.ts

@@ -1,5 +1,4 @@
 import { AxiosInstance } from "axios";
-import { BambuPrinter } from "bambu-js";
 
 // Define shared types for the printer implementations
 export type BambuFTP = {
@@ -25,25 +24,7 @@ export abstract class PrinterImplementation {
   abstract setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number): Promise<any>;
 }
 
-// Store for Bambu printers
-export class BambuPrinterStore {
-  private printers: Map<string, InstanceType<typeof BambuPrinter>> = new Map();
 
-  get(host: string, serial: string, token: string): InstanceType<typeof BambuPrinter> {
-    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(): Promise<void> {
-    for (const printer of this.printers.values()) {
-      await printer.disconnect();
-    }
-  }
-}
 
 export interface SectionBounds {
     minX: number; minY: number; minZ: number;