mcp-3d-printer-server 1.0.3 → 1.2.1

package/README.md

@@ -1,3 +1,5 @@
+
+
 # MCP 3D Printer Server
 
 [![npm version](https://img.shields.io/npm/v/mcp-3d-printer-server.svg)](https://www.npmjs.com/package/mcp-3d-printer-server)
@@ -9,6 +11,7 @@
 [![Downloads](https://img.shields.io/npm/dm/mcp-3d-printer-server.svg)](https://www.npmjs.com/package/mcp-3d-printer-server)
 [![GitHub stars](https://img.shields.io/github/stars/dmontgomery40/mcp-3d-printer-server.svg?style=social&label=Star)](https://github.com/yourusername/mcp-3d-printer-server)
 
+
 <a href="https://glama.ai/mcp/servers/7f6v2enbgk">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/7f6v2enbgk/badge" alt="3D Printer Server MCP server" />
 </a>
@@ -16,14 +19,11 @@
 <details>
 <summary><strong>✨ What's New / Significant Updates (as of last session)</strong></summary>
 
-- **Bambu `.3mf` Printing:** Added the `print_3mf` tool specifically for Bambu Lab printers. This uploads the `.3mf` file and sends the print command directly via MQTT based on OpenBambuAPI specs.
-- **Direct MQTT Communication (Bambu):** Refactored Bambu command handling (`print_3mf`, `cancelJob`) to use direct MQTT (TLS port 8883) instead of relying solely on `bambu-js` for commands.
-- **`.3mf` File Parsing:** Implemented a parser (`src/3mf_parser.ts`) to read metadata and Bambu-specific slicer settings (from `project_settings.config`) within `.3mf` files.
-- **Bambu Preset Resources:** Added support for reading Bambu Studio preset files (`machine`, `filament`, `process`) as MCP resources (e.g., `preset://bambu/process/MyPreset`) if `BAMBU_STUDIO_CONFIG_PATH` is set.
-- **OrcaSlicer Integration:** Added support for using OrcaSlicer via its command-line interface for the `slice_stl` tool.
-- **New STL Manipulation Tools:** Added `merge_vertices`, `center_model`, and `lay_flat` tools for basic model preparation using `three.js`.
-- **Configuration Update:** Added `BAMBU_STUDIO_CONFIG_PATH` environment variable for preset loading.
-- **FTP Usage Note:** Acknowledged in documentation that file operations for Bambu currently use potentially unsecured FTP via `bambu-js`.
+- **Dual Local Transports:** Added explicit `stdio` and `streamable-http` runtime modes with environment-based transport selection.
+- **Bambu Reliability Pass:** Fixed Bambu argument wiring bugs, added FTP-backed file operations, improved status refresh behavior, and implemented practical command paths for `startJob`, `setTemperature`, and `print_3mf`.
+- **Blender Bridge Tooling:** Added `blender_mcp_edit_model` with optional execution mode for model-edit collaboration workflows.
+- **Transport Behavior Tests:** Added real behavior tests for both transports (`initialize`, `tools/list`, success + failing `tools/call`, origin rejection).
+- **Docker Modernization:** Updated Docker build flow to work without BuildKit-specific features and verified streamable HTTP initialization in container smoke testing.
 
 </details>
 
@@ -85,6 +85,7 @@
   - [Visualization Limitations](#visualization-limitations)
   - [Performance Considerations](#performance-considerations)
   - [Testing Recommendations](#testing-recommendations)
+- [Appendix: MCP in Practice (Code Execution, Scale, and Safety)](#appendix-mcp-in-practice-code-execution-scale-and-safety)
 - [Badges](#badges)
 - [License](#license)
 
@@ -210,9 +211,12 @@ TEMP_DIR=/path/to/temp/dir
 # Bambu Labs specific configuration
 BAMBU_SERIAL=your_printer_serial # REQUIRED for Bambu
 BAMBU_TOKEN=your_access_token    # REQUIRED for Bambu
+BAMBU_MODEL=p1s                  # REQUIRED for Bambu: p1s, p1p, x1c, x1e, a1, a1mini, h2d
+BED_TYPE=textured_plate          # Bed plate: textured_plate, cool_plate, engineering_plate, hot_plate
+NOZZLE_DIAMETER=0.4              # Nozzle diameter in mm (default: 0.4)
 
 # Slicer configuration (for slice_stl tool)
-SLICER_TYPE=prusaslicer  # Options: prusaslicer, cura, slic3r, orcaslicer
+SLICER_TYPE=prusaslicer  # Options: prusaslicer, cura, slic3r, orcaslicer, bambustudio
 SLICER_PATH=/path/to/slicer/executable
 SLICER_PROFILE=/path/to/slicer/profile
 
@@ -221,6 +225,18 @@ SLICER_PROFILE=/path/to/slicer/profile
 # Example Windows: C:\Users\your_user\AppData\Roaming\BambuStudio\user\YOUR_USER_ID
 # Example Linux: /home/your_user/.config/BambuStudio/user/YOUR_USER_ID
 BAMBU_STUDIO_CONFIG_PATH=
+
+# MCP transport configuration
+MCP_TRANSPORT=stdio             # Options: stdio, streamable-http
+MCP_HTTP_HOST=127.0.0.1
+MCP_HTTP_PORT=3000
+MCP_HTTP_PATH=/mcp
+MCP_HTTP_STATEFUL=true
+MCP_HTTP_JSON_RESPONSE=true
+MCP_HTTP_ALLOWED_ORIGINS=http://localhost
+
+# Optional bridge command for blender_mcp_edit_model execute=true mode
+BLENDER_MCP_BRIDGE_COMMAND=
 ```
 
 ## Usage with Claude Desktop
@@ -253,7 +269,8 @@ BAMBU_STUDIO_CONFIG_PATH=
         "PRINTER_HOST": "your_printer_ip",
         "PRINTER_TYPE": "bambu",
         "BAMBU_SERIAL": "your_printer_serial",
-        "BAMBU_TOKEN": "your_access_token"
+        "BAMBU_TOKEN": "your_access_token",
+        "BAMBU_MODEL": "p1s"
       }
     }
   }
@@ -298,8 +315,9 @@ Repetier-Server is a host software for 3D printers.
 Bambu Lab printers use MQTT for status and control and FTP for file operations.
 
 - Authentication: Serial number and access token required (set `BAMBU_SERIAL` and `BAMBU_TOKEN`)
-- Requirements: Printer must be on the same network or have cloud connection enabled
-- Compatible with: X1C, P1S, P1P, A1, and other Bambu Lab printers
+- Printer model: **Required** (set `BAMBU_MODEL`). Valid values: `p1s`, `p1p`, `x1c`, `x1e`, `a1`, `a1mini`, `h2d`. This ensures the slicer generates correct G-code for your specific printer.
+- Requirements: Printer must be on the same network with Developer Mode and LAN Only Mode enabled
+- Compatible with: X1C, X1E, P1S, P1P, A1, A1 Mini, H2D
 
 #### Finding Your Bambu Printer's Serial Number and Access Token
 
@@ -658,19 +676,22 @@ Set the temperature of a printer component.
 
 Uploads a `.3mf` file to a Bambu printer via FTP and initiates the print job via an MQTT command. Allows overriding some print parameters like AMS mapping.
 
+**`bambu_model` is required** -- it ensures the slicer generates G-code for the correct printer. Using the wrong model can cause the bed to crash into the nozzle and damage the printer. If not provided in the tool call and `BAMBU_MODEL` is not set in the environment, the server will ask interactively via MCP elicitation (if supported by your client) or return a clear error.
+
 ```json
 {
   "three_mf_path": "/path/to/your_model.3mf",
-  "host": "your_bambu_ip", // Optional if default is set
-  "bambu_serial": "YOUR_SERIAL", // Optional if default is set
-  "bambu_token": "YOUR_TOKEN", // Optional if default is set
-  // Optional Overrides:
-  "use_ams": true, // Default: true
-  "ams_mapping": [0, 1, 2, 3], // Array of AMS slot indices to use
-  "bed_leveling": true, // Default: true
-  "flow_calibration": false, // Default: false
-  "vibration_calibration": false, // Default: false
-  "timelapse": false // Default: false
+  "bambu_model": "p1s",
+  "bed_type": "textured_plate",
+  "host": "your_bambu_ip",
+  "bambu_serial": "YOUR_SERIAL",
+  "bambu_token": "YOUR_TOKEN",
+  "use_ams": true,
+  "ams_mapping": [0, 1, 2, 3],
+  "bed_leveling": true,
+  "flow_calibration": false,
+  "vibration_calibration": false,
+  "timelapse": false
 }
 ```
 
@@ -746,17 +767,17 @@ Here are some example commands you can give to Claude after connecting the MCP s
 
 Due to the nature of the Bambu Lab printer API, there are some limitations:
 
-1. **Starting prints**: Starting a print requires the 3MF project file path, gcode file name, print name, and MD5 hash. The simplified API in this server doesn't support this fully yet.
+1. **Printable 3MF requirement:** `print_3mf` requires a sliced 3MF that includes at least one `Metadata/plate_<n>.gcode` entry so the server can compute MD5 and start the job correctly.
 
-2. **Temperature control**: The Bambu API doesn't provide direct methods to set temperatures. This would require custom G-code commands.
+2. **AMS behavior caveat:** The current `bambu-js` project-file command path always sends `use_ams=true`; passing `use_ams=false` is treated as best-effort and surfaced with a warning.
 
-3. **File management**: Files must be uploaded to the "gcodes" directory on the printer.
+3. **Temperature control path:** Temperature updates are implemented through G-code command dispatch (`M104`/`M140`) over MQTT, so effective behavior still depends on printer firmware acceptance and current printer state.
 
-4. **FTP Security:** File operations currently use the printer's FTP server, which may be unsecured (plain FTP).
+4. **File transfer channel:** File operations use Bambu's FTPS path (port 990) via `bambu-js`. This is more secure than plain FTP, but still assumes a trusted local network environment and library-managed TLS behavior.
 
-5. **Parameter Overrides:** Only parameters supported by the MQTT `project_file` command can be overridden via the `print_3mf` tool (e.g., AMS usage, calibration flags). Slicer settings like layer height or temperature cannot be changed at print time via this command.
+5. **Direct start path scope:** `startJob` currently targets `.gcode` files on printer storage; `.3mf` jobs should be initiated through `print_3mf` so metadata and plate selection are handled.
 
-6. **Status Updates:** Full real-time status monitoring via MQTT needs further implementation.
+6. **Status consistency:** Status reads force a `pushall` refresh when possible, but complete real-time, event-stream status semantics across all Bambu models still need deeper hardening.
 
 ## Limitations and Considerations
 
@@ -784,6 +805,57 @@ Due to the nature of the Bambu Lab printer API, there are some limitations:
 - Test modifications on simple geometries before attempting complex ones
 - Consider running on a system with at least 4GB of available RAM for larger operations
 
+## Appendix: MCP in Practice (Code Execution, Scale, and Safety)
+
+Last updated: 2026-02-24
+
+### State of MCP Right Now
+MCP remains a high-value protocol for interoperability, but large tool surfaces have a real downside: tool schemas, retries, and tool-call traces can flood the context window. More tools often means more token overhead unless the execution model is disciplined.
+
+### Why Code Mode / Code Execution Has Become Important
+Recent production workflows increasingly move orchestration out of conversational turns and into executable code loops. This keeps context leaner, makes behavior easier to audit, and improves reproducibility.
+
+Core reading:
+- Cloudflare: https://blog.cloudflare.com/code-mode/
+- Cloudflare: https://blog.cloudflare.com/code-execution-with-mcp/
+- Anthropic: https://www.anthropic.com/engineering/code-execution-with-mcp
+
+### Setup Guidance for Users
+For practical day-to-day use, start with a codemode-oriented gateway and keep direct tool exposure narrow:
+- `codemode-mcp`: https://github.com/jx-codes/codemode-mcp
+- UTCP routing guidance: https://www.utcp.io
+
+Even with strong setup, model/tool usage can still be inconsistent across client versions and model releases, so retries and deterministic fallbacks are still required.
+
+### Peter Steinberger Workflow Pattern
+A high-signal pattern is converting broad MCP toolsets into targeted CLIs so the model calls fewer, better-defined commands:
+- MCPorter: https://github.com/steipete/mcporter
+- OpenClaw: https://github.com/steipete/openclaw
+
+### What Works Best With Which Clients
+- Claude Code, Codex CLI, and Cursor agent modes: strong fit for direct MCP and code-execution workflows.
+- Thin hosted chat clients: usually better when MCP servers are wrapped behind narrower CLIs/gateways.
+- Large multi-tool servers: best when grouped into task-specific wrappers instead of exposing every tool directly.
+
+This ecosystem changes quickly; if you are reading this later, parts of this section may already be stale.
+
+### Prompt Injection: Risks, Consequences, and Mitigations
+Prompt injection is still an open problem for tool-using agents. It is manageable, but not solved.
+
+Primary risks:
+- Hidden malicious instructions in remote content or tool output.
+- Secret exfiltration via unintended network/tool calls.
+- Unauthorized state changes (filesystem, infrastructure, or printer actions).
+
+Practical mitigations:
+- Least-privilege credentials and short-lived tokens.
+- Strict schema validation and explicit allowlists for actions/hosts.
+- Human confirmation gates for destructive operations.
+- Execution sandboxing with resource/time limits.
+- Structured logs and replayable runs for incident response.
+
+Treat tool output as untrusted input by default.
+
 ## Badges
 
 | Badge | Description |

package/dist/http-server.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+declare class ThreeDPrinterMCPServerHTTP {
+    private server;
+    private printerFactory;
+    private stlManipulator;
+    private app;
+    constructor();
+    private setupExpressApp;
+    private handleJSONRPCRequest;
+    setupErrorHandling(): void;
+    setupHandlers(): void;
+    setupResourceHandlers(): void;
+    setupToolHandlers(): void;
+    run(): Promise<void>;
+}
+export default ThreeDPrinterMCPServerHTTP;

package/dist/http-server.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import express from 'express';
+import cors from 'cors';
+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");
+// 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 {
+    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();
+    }
+    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, res) => {
+            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 = [];
+                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, res) => {
+            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, res) => {
+            res.json({
+                status: 'ok',
+                server: 'mcp-3d-printer-server',
+                transport: 'streamable-http',
+                version: '1.0.0'
+            });
+        });
+        // Root endpoint
+        this.app.get('/', (req, res) => {
+            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'
+            });
+        });
+    }
+    async handleJSONRPCRequest(request) {
+        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;