mcp-3d-printer-server 1.0.3 → 1.2.1

package/dist/printers/prusa.js

@@ -1,93 +1,194 @@
+import { isAxiosError } from "axios";
 import { PrinterImplementation } from "../types.js";
 import fs from "fs";
 import FormData from "form-data";
 export class PrusaImplementation extends PrinterImplementation {
-    async getStatus(host, port, apiKey) {
-        const url = `http://${host}:${port}/api/v1/printer`;
-        const response = await this.apiClient.get(url, {
-            headers: {
-                "X-Api-Key": apiKey
+    buildAuthHeaders(apiKey) {
+        return {
+            "X-Api-Key": apiKey,
+            Authorization: `Bearer ${apiKey}`,
+        };
+    }
+    buildBaseUrl(host, port) {
+        return `http://${host}:${port}`;
+    }
+    isFallbackStatus(error) {
+        if (!isAxiosError(error)) {
+            return false;
+        }
+        const status = error.response?.status;
+        return status === 404 || status === 405 || status === 501;
+    }
+    async getWithFallback(host, port, apiKey, routes) {
+        const baseUrl = this.buildBaseUrl(host, port);
+        let lastError;
+        for (const route of routes) {
+            try {
+                return await this.apiClient.get(`${baseUrl}${route}`, {
+                    headers: this.buildAuthHeaders(apiKey),
+                });
             }
-        });
+            catch (error) {
+                lastError = error;
+                if (!this.isFallbackStatus(error)) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError ?? new Error("No compatible Prusa GET endpoint found.");
+    }
+    async postWithFallback(host, port, apiKey, candidates, config) {
+        const baseUrl = this.buildBaseUrl(host, port);
+        let lastError;
+        for (const candidate of candidates) {
+            try {
+                return await this.apiClient.post(`${baseUrl}${candidate.route}`, candidate.data, {
+                    ...(config ?? {}),
+                    headers: {
+                        ...this.buildAuthHeaders(apiKey),
+                        ...(config?.headers ?? {}),
+                    },
+                });
+            }
+            catch (error) {
+                lastError = error;
+                if (!this.isFallbackStatus(error)) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError ?? new Error("No compatible Prusa POST endpoint found.");
+    }
+    async getStatus(host, port, apiKey) {
+        const response = await this.getWithFallback(host, port, apiKey, [
+            "/api/v1/printer",
+            "/api/printer",
+        ]);
         return response.data;
     }
     async getFiles(host, port, apiKey) {
-        const url = `http://${host}:${port}/api/v1/storage`;
-        const response = await this.apiClient.get(url, {
-            headers: {
-                "X-Api-Key": apiKey
-            }
-        });
+        const response = await this.getWithFallback(host, port, apiKey, [
+            "/api/v1/storage",
+            "/api/files",
+            "/api/files/local",
+        ]);
         return response.data;
     }
     async getFile(host, port, apiKey, filename) {
-        const url = `http://${host}:${port}/api/v1/storage/${encodeURIComponent(filename)}`;
-        const response = await this.apiClient.get(url, {
-            headers: {
-                "X-Api-Key": apiKey
-            }
-        });
+        const encodedFile = encodeURIComponent(filename);
+        const response = await this.getWithFallback(host, port, apiKey, [
+            `/api/v1/storage/${encodedFile}`,
+            `/api/files/local/${encodedFile}`,
+        ]);
         return response.data;
     }
     async uploadFile(host, port, apiKey, filePath, filename, print) {
-        const url = `http://${host}:${port}/api/v1/storage`;
         const formData = new FormData();
         formData.append("file", fs.createReadStream(filePath));
         formData.append("filename", filename);
-        const response = await this.apiClient.post(url, formData, {
+        const response = await this.postWithFallback(host, port, apiKey, [
+            { route: "/api/v1/storage", data: formData },
+            { route: "/api/files/local", data: formData },
+        ], {
             headers: {
-                "X-Api-Key": apiKey,
-                ...formData.getHeaders()
-            }
+                ...formData.getHeaders(),
+            },
         });
-        if (print && response.data.success) {
+        if (print) {
             await this.startJob(host, port, apiKey, filename);
         }
         return response.data;
     }
     async startJob(host, port, apiKey, filename) {
-        const url = `http://${host}:${port}/api/v1/job`;
-        const response = await this.apiClient.post(url, {
-            command: "start",
-            file: filename
-        }, {
-            headers: {
-                "X-Api-Key": apiKey,
-                "Content-Type": "application/json"
-            }
-        });
+        const response = await this.postWithFallback(host, port, apiKey, [
+            {
+                route: "/api/v1/job",
+                data: {
+                    command: "start",
+                    file: filename,
+                },
+            },
+            {
+                route: "/api/v1/job",
+                data: {
+                    command: "start",
+                    path: filename,
+                },
+            },
+            {
+                route: "/api/job",
+                data: {
+                    command: "start",
+                    file: filename,
+                },
+            },
+            {
+                route: "/api/job",
+                data: {
+                    command: "start",
+                    path: filename,
+                },
+            },
+        ]);
         return response.data;
     }
     async cancelJob(host, port, apiKey) {
-        const url = `http://${host}:${port}/api/v1/job`;
-        const response = await this.apiClient.post(url, {
-            command: "cancel"
-        }, {
-            headers: {
-                "X-Api-Key": apiKey,
-                "Content-Type": "application/json"
-            }
-        });
+        const response = await this.postWithFallback(host, port, apiKey, [
+            {
+                route: "/api/v1/job",
+                data: {
+                    command: "cancel",
+                },
+            },
+            {
+                route: "/api/job",
+                data: {
+                    command: "cancel",
+                },
+            },
+        ]);
         return response.data;
     }
     async setTemperature(host, port, apiKey, component, temperature) {
-        const url = `http://${host}:${port}/api/v1/printer/temperature`;
-        let data = { command: "set" };
-        if (component === "bed") {
-            data.target = { bed: temperature };
-        }
-        else if (component.startsWith("extruder")) {
-            data.target = { tool0: temperature }; // Prusa typically uses tool0 for the extruder
+        const normalized = component.toLowerCase();
+        if (normalized === "bed") {
+            const response = await this.postWithFallback(host, port, apiKey, [
+                {
+                    route: "/api/v1/printer/temperature",
+                    data: {
+                        command: "set",
+                        target: { bed: temperature },
+                    },
+                },
+                {
+                    route: "/api/printer/bed",
+                    data: {
+                        command: "target",
+                        target: temperature,
+                    },
+                },
+            ]);
+            return response.data;
         }
-        else {
-            throw new Error(`Unsupported component: ${component}`);
+        if (normalized.startsWith("extruder") || normalized === "nozzle" || normalized === "tool0") {
+            const response = await this.postWithFallback(host, port, apiKey, [
+                {
+                    route: "/api/v1/printer/temperature",
+                    data: {
+                        command: "set",
+                        target: { tool0: temperature },
+                    },
+                },
+                {
+                    route: "/api/printer/tool",
+                    data: {
+                        command: "target",
+                        targets: { tool0: temperature },
+                    },
+                },
+            ]);
+            return response.data;
         }
-        const response = await this.apiClient.post(url, data, {
-            headers: {
-                "X-Api-Key": apiKey,
-                "Content-Type": "application/json"
-            }
-        });
-        return response.data;
+        throw new Error(`Unsupported component: ${component}`);
     }
 }

package/dist/sse-server.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+declare class ThreeDPrinterMCPServerSSE {
+    private server;
+    private printerFactory;
+    private stlManipulator;
+    private app;
+    private sessions;
+    constructor();
+    private setupExpressApp;
+    private startSessionCleanup;
+    setupErrorHandling(): void;
+    setupHandlers(): void;
+    setupResourceHandlers(): void;
+    setupToolHandlers(): void;
+    getPrinterStatus(host: string, port?: string, type?: string, apiKey?: string, bambuSerial?: string, bambuToken?: string): Promise<any>;
+    getPrinterFiles(host: string, port?: string, type?: string, apiKey?: string, bambuSerial?: string, bambuToken?: string): Promise<any>;
+    getPrinterFile(host: string, filename: string, port?: string, type?: string, apiKey?: string, bambuSerial?: string, bambuToken?: string): Promise<any>;
+    run(): Promise<void>;
+}
+export default ThreeDPrinterMCPServerSSE;

package/dist/sse-server.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from 'express';
+import cors from 'cors';
+import { v4 as uuidv4 } from 'uuid';
+import { ListResourcesRequestSchema, ReadResourceRequestSchema, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+import dotenv from "dotenv";
+import fs from "fs";
+import path from "path";
+import { PrinterFactory } from "./printers/printer-factory.js";
+import { STLManipulator } from "./stl/stl-manipulator.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 {
+    constructor() {
+        this.sessions = new Map();
+        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();
+    }
+    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, res) => {
+            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, res) => {
+            const sessionId = req.query.session_id;
+            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, res) => {
+            res.json({
+                status: 'ok',
+                server: 'mcp-3d-printer-server',
+                transport: 'sse',
+                sessions: this.sessions.size
+            });
+        });
+        // Root endpoint
+        this.app.get('/', (req, res) => {
+            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'
+            });
+        });
+    }
+    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, 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, 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, filename, 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.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/dist/stl/stl-manipulator.d.ts

@@ -90,15 +90,15 @@ export declare class STLManipulator extends EventEmitter {
      */
     extendBase(stlFilePath: string, extensionInches: number, progressCallback?: ProgressCallback): Promise<string>;
     /**
-     * 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
      */
-    sliceSTL(stlFilePath: string, slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer', slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback): Promise<string>;
+    sliceSTL(stlFilePath: string, slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio', slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string): Promise<string>;
     /**
      * Enhanced version of confirmTemperatures with better error handling
      * @param gcodePath Path to the G-code file