mcp-3d-printer-server 1.0.2 → 1.2.1

package/dist/index.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 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 { createServer as createHttpServer } from "node:http";
+import { randomUUID } from "node:crypto";
 import * as THREE from 'three';
 import { PrinterFactory } from "./printers/printer-factory.js";
 import { STLManipulator } from "./stl/stl-manipulator.js";
@@ -20,21 +23,108 @@ const DEFAULT_API_KEY = process.env.API_KEY || "";
 const DEFAULT_TYPE = process.env.PRINTER_TYPE || "octoprint"; // Default to OctoPrint
 const TEMP_DIR = process.env.TEMP_DIR || path.join(process.cwd(), "temp");
 // Slicer configuration
-const DEFAULT_SLICER_TYPE = process.env.SLICER_TYPE || "prusaslicer";
-const DEFAULT_SLICER_PATH = process.env.SLICER_PATH || "";
+const DEFAULT_SLICER_TYPE = process.env.SLICER_TYPE || (process.env.PRINTER_TYPE === "bambu" ? "bambustudio" : "prusaslicer");
+const DEFAULT_SLICER_PATH = process.env.SLICER_PATH || (process.env.PRINTER_TYPE === "bambu" ? "/Applications/BambuStudio.app/Contents/MacOS/BambuStudio" : "");
 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 || "";
+// Printer model and bed type (Bambu safety)
+const DEFAULT_BAMBU_MODEL = process.env.BAMBU_MODEL?.trim().toLowerCase() || "";
+const DEFAULT_BED_TYPE = process.env.BED_TYPE?.trim().toLowerCase() || "textured_plate";
+const DEFAULT_NOZZLE_DIAMETER = process.env.NOZZLE_DIAMETER?.trim() || "0.4";
+const VALID_BAMBU_MODELS = ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"];
+const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"];
+// Map model IDs to BambuStudio --load-machine preset names
+const BAMBU_MODEL_PRESETS = {
+    p1s: (n) => `Bambu Lab P1S ${n} nozzle`,
+    p1p: (n) => `Bambu Lab P1P ${n} nozzle`,
+    x1c: (n) => `Bambu Lab X1 Carbon ${n} nozzle`,
+    x1e: (n) => `Bambu Lab X1E ${n} nozzle`,
+    a1: (n) => `Bambu Lab A1 ${n} nozzle`,
+    a1mini: (n) => `Bambu Lab A1 mini ${n} nozzle`,
+    h2d: (n) => `Bambu Lab H2D ${n} nozzle`,
+};
+function validateBambuModel(model) {
+    const normalized = model.trim().toLowerCase();
+    if (!VALID_BAMBU_MODELS.includes(normalized)) {
+        throw new Error(`Invalid Bambu printer model "${model}". Valid models: ${VALID_BAMBU_MODELS.join(", ")}`);
+    }
+    return normalized;
+}
+function resolveBedType(bedType) {
+    const resolved = (bedType || DEFAULT_BED_TYPE).trim().toLowerCase();
+    if (!VALID_BED_TYPES.includes(resolved)) {
+        throw new Error(`Invalid bed type "${bedType}". Valid types: ${VALID_BED_TYPES.join(", ")}`);
+    }
+    return resolved;
+}
+function parseBooleanEnv(rawValue, fallback) {
+    if (rawValue === undefined) {
+        return fallback;
+    }
+    const value = rawValue.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(value)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(value)) {
+        return false;
+    }
+    return fallback;
+}
+function parsePort(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+        throw new Error(`Invalid MCP_HTTP_PORT value: ${value}`);
+    }
+    return parsed;
+}
+function normalizePath(pathValue) {
+    const value = (pathValue ?? "/mcp").trim();
+    if (!value) {
+        return "/mcp";
+    }
+    return value.startsWith("/") ? value : `/${value}`;
+}
+function parseCsvEnv(value) {
+    if (!value) {
+        return new Set();
+    }
+    const entries = value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return new Set(entries);
+}
+function readRuntimeConfig() {
+    const rawTransport = process.env.MCP_TRANSPORT?.trim().toLowerCase();
+    const transport = rawTransport === "streamable-http" || rawTransport === "http"
+        ? "streamable-http"
+        : "stdio";
+    return {
+        transport,
+        httpHost: process.env.MCP_HTTP_HOST?.trim() || "127.0.0.1",
+        httpPort: parsePort(process.env.MCP_HTTP_PORT, 3000),
+        httpPath: normalizePath(process.env.MCP_HTTP_PATH),
+        statefulSession: parseBooleanEnv(process.env.MCP_HTTP_STATEFUL, true),
+        enableJsonResponse: parseBooleanEnv(process.env.MCP_HTTP_JSON_RESPONSE, true),
+        allowedOrigins: parseCsvEnv(process.env.MCP_HTTP_ALLOWED_ORIGINS),
+        blenderBridgeCommand: process.env.BLENDER_MCP_BRIDGE_COMMAND?.trim() || undefined,
+    };
+}
 // Ensure temp directory exists
 if (!fs.existsSync(TEMP_DIR)) {
     fs.mkdirSync(TEMP_DIR, { recursive: true });
 }
 class ThreeDPrinterMCPServer {
     constructor() {
+        this.runtimeConfig = readRuntimeConfig();
         this.server = new Server({
             name: "mcp-3d-printer-server",
-            version: "1.0.0"
+            version: "1.2.0"
         }, {
             capabilities: {
                 resources: {},
@@ -46,16 +136,58 @@ class ThreeDPrinterMCPServer {
         this.setupHandlers();
         this.setupErrorHandling();
     }
+    async resolveBambuModel(argsModel) {
+        const fromArgs = (argsModel || DEFAULT_BAMBU_MODEL).trim().toLowerCase();
+        if (fromArgs) {
+            return validateBambuModel(fromArgs);
+        }
+        // No model from args or env — ask the user via elicitation
+        try {
+            const result = await this.server.elicitInput({
+                mode: "form",
+                message: "Your Bambu Lab printer model is required for safe operation. " +
+                    "Using the wrong model can cause the bed to crash into the nozzle and damage the printer.",
+                requestedSchema: {
+                    type: "object",
+                    properties: {
+                        bambu_model: {
+                            type: "string",
+                            title: "Printer Model",
+                            description: "Which Bambu Lab printer do you have?",
+                            oneOf: [
+                                { const: "p1s", title: "P1S" },
+                                { const: "p1p", title: "P1P" },
+                                { const: "x1c", title: "X1 Carbon" },
+                                { const: "x1e", title: "X1E" },
+                                { const: "a1", title: "A1" },
+                                { const: "a1mini", title: "A1 Mini" },
+                                { const: "h2d", title: "H2D" },
+                            ],
+                        },
+                    },
+                    required: ["bambu_model"],
+                },
+            });
+            if (result.action === "accept" && result.content?.bambu_model) {
+                return validateBambuModel(String(result.content.bambu_model));
+            }
+            throw new Error("Printer model selection was cancelled. Cannot proceed without knowing the printer model.");
+        }
+        catch (elicitError) {
+            const msg = elicitError?.message || String(elicitError);
+            if (elicitError?.code === -32601 || elicitError?.code === -32600 ||
+                msg.includes("does not support") || msg.includes("elicitation")) {
+                throw new Error("bambu_model is required but your MCP client does not support elicitation. " +
+                    `Set the BAMBU_MODEL environment variable or pass bambu_model in the tool call. ` +
+                    `Valid models: ${VALID_BAMBU_MODELS.join(", ")}`);
+            }
+            throw elicitError;
+        }
+    }
     setupErrorHandling() {
         this.server.onerror = (error) => {
             console.error("[MCP Error]", error);
         };
-        process.on("SIGINT", async () => {
-            // Disconnect all printers
-            await this.printerFactory.disconnectAll();
-            await this.server.close();
-            process.exit(0);
-        });
     }
     setupHandlers() {
         this.setupResourceHandlers();
@@ -198,17 +330,26 @@ class ThreeDPrinterMCPServer {
                     },
                     {
                         name: "slice_stl",
-                        description: "Slice an STL file to generate G-code",
+                        description: "Slice an STL or 3MF file to generate G-code or sliced 3MF",
                         inputSchema: {
                             type: "object",
                             properties: {
                                 stl_path: {
                                     type: "string",
-                                    description: "Path to the STL file to slice"
+                                    description: "Path to the STL or 3MF file to slice"
+                                },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    description: "Bambu Lab printer model — required when using bambustudio slicer to ensure correct G-code."
+                                },
+                                nozzle_diameter: {
+                                    type: "string",
+                                    description: "Nozzle diameter in mm (default: 0.4)."
                                 },
                                 slicer_type: {
                                     type: "string",
-                                    description: "Type of slicer to use (prusaslicer, cura, slic3r, orcaslicer) (default: value from env)"
+                                    description: "Type of slicer to use (prusaslicer, cura, slic3r, orcaslicer, bambustudio) (default: value from env)"
                                 },
                                 slicer_path: {
                                     type: "string",
@@ -475,6 +616,20 @@ class ThreeDPrinterMCPServer {
                                     type: "string",
                                     description: "Path to the 3MF file to print."
                                 },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    description: "REQUIRED: Bambu Lab printer model. Ensures correct G-code generation — wrong model can crash the bed into the nozzle."
+                                },
+                                bed_type: {
+                                    type: "string",
+                                    enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"],
+                                    description: "Bed/plate type installed on the printer (default: textured_plate)."
+                                },
+                                nozzle_diameter: {
+                                    type: "string",
+                                    description: "Nozzle diameter in mm (default: 0.4)."
+                                },
                                 host: {
                                     type: "string",
                                     description: "Hostname or IP address of the Bambu printer (default: value from env)"
@@ -497,7 +652,7 @@ class ThreeDPrinterMCPServer {
                                     additionalProperties: { type: "number" }
                                 }
                             },
-                            required: ["three_mf_path"]
+                            required: ["three_mf_path", "bambu_model"]
                         }
                     },
                     {
@@ -545,6 +700,33 @@ class ThreeDPrinterMCPServer {
                             },
                             required: ["stl_path"]
                         }
+                    },
+                    {
+                        name: "blender_mcp_edit_model",
+                        description: "Optionally send STL-edit instructions to a Blender MCP bridge command. Use for advanced model edits outside built-in STL tools.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                stl_path: {
+                                    type: "string",
+                                    description: "Path to the local STL file."
+                                },
+                                operations: {
+                                    type: "array",
+                                    description: "Ordered edit operations for Blender (e.g. remesh, boolean, decimate).",
+                                    items: { type: "string" }
+                                },
+                                bridge_command: {
+                                    type: "string",
+                                    description: "Optional override command for invoking a local Blender MCP bridge."
+                                },
+                                execute: {
+                                    type: "boolean",
+                                    description: "When true, attempts to execute bridge command; otherwise returns a prepared payload only."
+                                }
+                            },
+                            required: ["stl_path", "operations"]
+                        }
                     }
                 ]
             };
@@ -599,12 +781,21 @@ class ThreeDPrinterMCPServer {
                         }
                         result = await this.stlManipulator.extendBase(String(args.stl_path), Number(args.extension_inches));
                         break;
-                    case "slice_stl":
+                    case "slice_stl": {
                         if (!args?.stl_path) {
                             throw new Error("Missing required parameter: stl_path");
                         }
-                        result = await this.stlManipulator.sliceSTL(String(args.stl_path), slicerType, slicerPath, slicerProfile || undefined);
+                        // Resolve printer model for BambuStudio slicer
+                        let slicePreset;
+                        if (slicerType === 'bambustudio') {
+                            const sliceModel = await this.resolveBambuModel(args?.bambu_model);
+                            const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                            slicePreset = BAMBU_MODEL_PRESETS[sliceModel]?.(nozzleDiam);
+                        }
+                        result = await this.stlManipulator.sliceSTL(String(args.stl_path), slicerType, slicerPath, slicerProfile || undefined, undefined, // progressCallback
+                        slicePreset);
                         break;
+                    }
                     case "confirm_temperatures":
                         if (!args?.gcode_path) {
                             throw new Error("Missing required parameter: gcode_path");
@@ -625,7 +816,13 @@ class ThreeDPrinterMCPServer {
                         // 1. Extend the base of the STL file
                         const extendedStlPath = await this.stlManipulator.extendBase(String(args.stl_path), Number(args.extension_inches), processProgressCallback);
                         // 2. Slice the extended STL file
-                        const gcodePath = await this.stlManipulator.sliceSTL(extendedStlPath, slicerType, slicerPath, slicerProfile || undefined, processProgressCallback);
+                        let processPreset;
+                        if (slicerType === 'bambustudio') {
+                            const processModel = await this.resolveBambuModel(args?.bambu_model);
+                            const processNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                            processPreset = BAMBU_MODEL_PRESETS[processModel]?.(processNozzle);
+                        }
+                        const gcodePath = await this.stlManipulator.sliceSTL(extendedStlPath, slicerType, slicerPath, slicerProfile || undefined, processProgressCallback, processPreset);
                         // 3. Confirm temperatures if specified
                         if (args.extruder_temp !== undefined || args.bed_temp !== undefined) {
                             const tempConfirmation = await this.stlManipulator.confirmTemperatures(gcodePath, {
@@ -781,7 +978,7 @@ class ThreeDPrinterMCPServer {
                         const height = args.height !== undefined ? Number(args.height) : 300;
                         result = await this.stlManipulator.generateVisualization(String(args.stl_path), width, height, visualizationProgressCallback);
                         break;
-                    case "print_3mf":
+                    case "print_3mf": {
                         if (!args?.three_mf_path) {
                             throw new Error("Missing required parameter: three_mf_path");
                         }
@@ -791,7 +988,27 @@ class ThreeDPrinterMCPServer {
                         if (!bambuSerial || !bambuToken) {
                             throw new Error("Bambu serial number and access token are required for print_3mf.");
                         }
-                        const threeMFPath = String(args.three_mf_path);
+                        const printModel = await this.resolveBambuModel(args?.bambu_model);
+                        const printBedType = resolveBedType(args?.bed_type);
+                        const printNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        const printPreset = BAMBU_MODEL_PRESETS[printModel]?.(printNozzle);
+                        let threeMFPath = String(args.three_mf_path);
+                        // Auto-slice if the 3MF doesn't contain gcode
+                        try {
+                            const JSZip = (await import('jszip')).default;
+                            const zipData = fs.readFileSync(threeMFPath);
+                            const zip = await JSZip.loadAsync(zipData);
+                            const hasGcode = Object.keys(zip.files).some(f => f.match(/Metadata\/plate_\d+\.gcode/i) || f.endsWith('.gcode'));
+                            if (!hasGcode) {
+                                console.log(`3MF has no gcode — auto-slicing with ${slicerType} for ${printModel}`);
+                                threeMFPath = await this.stlManipulator.sliceSTL(threeMFPath, slicerType, slicerPath, slicerProfile || undefined, undefined, // progressCallback
+                                printPreset);
+                                console.log("Auto-sliced to: " + threeMFPath);
+                            }
+                        }
+                        catch (sliceCheckErr) {
+                            console.warn("Could not check/slice 3MF, proceeding with original:", sliceCheckErr.message);
+                        }
                         // Define variables needed outside the parse try block
                         let implementation;
                         let threeMfFilename;
@@ -862,12 +1079,13 @@ class ThreeDPrinterMCPServer {
                             printOptions = {
                                 useAMS: useAMS,
                                 amsMapping: finalAmsMapping,
+                                bedType: printBedType,
                                 bedLeveling: args?.bed_leveling !== undefined ? Boolean(args.bed_leveling) : undefined,
                                 flowCalibration: args?.flow_calibration !== undefined ? Boolean(args.flow_calibration) : undefined,
                                 vibrationCalibration: args?.vibration_calibration !== undefined ? Boolean(args.vibration_calibration) : undefined,
                                 layerInspect: args?.layer_inspect !== undefined ? Boolean(args.layer_inspect) : undefined,
                                 timelapse: args?.timelapse !== undefined ? Boolean(args.timelapse) : undefined,
-                                // md5: parsed3MFData?.metadata?.md5 
+                                // md5: parsed3MFData?.metadata?.md5
                             };
                         }
                         catch (error) { // Catch parsing or setup errors
@@ -889,6 +1107,7 @@ class ThreeDPrinterMCPServer {
                             throw new Error(`Failed to start print: ${printError.message}`);
                         }
                         break;
+                    }
                     case "merge_vertices":
                         if (!args?.stl_path) {
                             throw new Error("Missing required parameter: stl_path");
@@ -908,6 +1127,17 @@ class ThreeDPrinterMCPServer {
                         }
                         result = await this.stlManipulator.layFlat(String(args.stl_path));
                         break;
+                    case "blender_mcp_edit_model":
+                        if (!args?.stl_path || !Array.isArray(args.operations)) {
+                            throw new Error("Missing required parameters: stl_path and operations");
+                        }
+                        result = await this.invokeBlenderBridge({
+                            stlPath: String(args.stl_path),
+                            operations: args.operations.map((entry) => String(entry)),
+                            execute: Boolean(args.execute ?? false),
+                            bridgeCommand: args.bridge_command !== undefined ? String(args.bridge_command) : undefined,
+                        });
+                        break;
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -923,13 +1153,15 @@ class ThreeDPrinterMCPServer {
             catch (error) {
                 console.error(`Error calling tool ${name}:`, error);
                 const errorMessage = error instanceof Error ? error.message : String(error);
+                const structuredError = this.toStructuredToolError(name, errorMessage);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Error: ${errorMessage}`
+                            text: `Error: ${errorMessage}\nSuggestion: ${structuredError.suggestion}`
                         }
                     ],
+                    structuredContent: structuredError,
                     isError: true
                 };
             }
@@ -955,7 +1187,8 @@ class ThreeDPrinterMCPServer {
     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);
+            const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+            return implementation.getFile(host, port, bambuApiKey, filename);
         }
         return implementation.getFile(host, port, apiKey, filename);
     }
@@ -966,7 +1199,8 @@ class ThreeDPrinterMCPServer {
         try {
             const implementation = this.printerFactory.getImplementation(type);
             if (type.toLowerCase() === "bambu") {
-                return await implementation.uploadFile(host, port, apiKey, bambuSerial, bambuToken, tempFilePath, filename, print);
+                const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+                return await implementation.uploadFile(host, port, bambuApiKey, tempFilePath, filename, print);
             }
             return await implementation.uploadFile(host, port, apiKey, tempFilePath, filename, print);
         }
@@ -980,39 +1214,230 @@ class ThreeDPrinterMCPServer {
     async startPrint(host, port, type, apiKey, bambuSerial, bambuToken, gcodeFilename) {
         const implementation = this.printerFactory.getImplementation(type);
         if (type.toLowerCase() === "bambu") {
-            // Bambu startJob likely uses G-code filename, not 3MF. 
-            // Keep this as is for starting pre-sliced G-code files.
-            // The print_3mf tool handles starting 3MF prints.
-            return await implementation.startJob(host, port, apiKey, bambuSerial, bambuToken, gcodeFilename);
+            const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+            return await implementation.startJob(host, port, bambuApiKey, gcodeFilename);
         }
         return await implementation.startJob(host, port, apiKey, gcodeFilename);
     }
     async cancelPrint(host, port, type, apiKey, bambuSerial, bambuToken) {
         const implementation = this.printerFactory.getImplementation(type);
         if (type.toLowerCase() === "bambu") {
-            return await implementation.cancelJob(host, port, apiKey, bambuSerial, bambuToken);
+            const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+            return await implementation.cancelJob(host, port, bambuApiKey);
         }
         return await implementation.cancelJob(host, port, apiKey);
     }
     async setPrinterTemperature(host, port, type, apiKey, bambuSerial, bambuToken, component, temperature) {
         const implementation = this.printerFactory.getImplementation(type);
         if (type.toLowerCase() === "bambu") {
-            const bambuImplementation = this.printerFactory.getImplementation('bambu');
-            if (bambuImplementation instanceof BambuImplementation && typeof bambuImplementation.setTemperature === 'function') {
-                return await bambuImplementation.setTemperature(host, bambuSerial, bambuToken, component, temperature);
-            }
-            else {
-                console.warn('setTemperature not fully implemented for Bambu via direct commands yet.');
-                return { status: 'Command sent (implementation pending)' }; // Avoid throwing error if method doesn't exist
-            }
+            const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+            return implementation.setTemperature(host, port, bambuApiKey, component, temperature);
         }
         return implementation.setTemperature(host, port, apiKey, component, temperature);
     }
-    async run() {
+    toStructuredToolError(tool, message) {
+        const isInputError = message.toLowerCase().includes("missing required") ||
+            message.toLowerCase().includes("invalid") ||
+            message.toLowerCase().includes("unsupported");
+        return {
+            status: "error",
+            retryable: !isInputError,
+            suggestion: isInputError
+                ? "Fix tool arguments and retry."
+                : "Retry the call. If it keeps failing, verify printer connectivity and credentials.",
+            message,
+            tool,
+        };
+    }
+    async parseHttpRequestBody(req) {
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        if (chunks.length === 0) {
+            return undefined;
+        }
+        const rawBody = Buffer.concat(chunks).toString("utf8").trim();
+        if (!rawBody) {
+            return undefined;
+        }
+        return JSON.parse(rawBody);
+    }
+    isAllowedOrigin(req) {
+        const origin = req.headers.origin;
+        if (!origin) {
+            return true;
+        }
+        if (this.runtimeConfig.allowedOrigins.size === 0) {
+            return false;
+        }
+        return this.runtimeConfig.allowedOrigins.has(origin);
+    }
+    async connectStdio() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error("3D Printer MCP server running on stdio transport");
     }
+    async connectStreamableHttp() {
+        if (this.httpRuntime) {
+            return;
+        }
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: this.runtimeConfig.statefulSession ? () => randomUUID() : undefined,
+            enableJsonResponse: this.runtimeConfig.enableJsonResponse
+        });
+        await this.server.connect(transport);
+        const requestHandler = async (req, res) => {
+            try {
+                const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+                if (url.pathname !== this.runtimeConfig.httpPath) {
+                    res.statusCode = 404;
+                    res.setHeader("content-type", "application/json");
+                    res.end(JSON.stringify({ error: "Not Found" }));
+                    return;
+                }
+                if (!this.isAllowedOrigin(req)) {
+                    res.statusCode = 403;
+                    res.setHeader("content-type", "application/json");
+                    res.end(JSON.stringify({ error: "Forbidden origin" }));
+                    return;
+                }
+                const method = req.method?.toUpperCase() ?? "GET";
+                if (!["POST", "GET", "DELETE"].includes(method)) {
+                    res.statusCode = 405;
+                    res.setHeader("allow", "POST, GET, DELETE");
+                    res.setHeader("content-type", "application/json");
+                    res.end(JSON.stringify({ error: "Method Not Allowed" }));
+                    return;
+                }
+                let parsedBody;
+                if (method === "POST") {
+                    try {
+                        parsedBody = await this.parseHttpRequestBody(req);
+                    }
+                    catch {
+                        res.statusCode = 400;
+                        res.setHeader("content-type", "application/json");
+                        res.end(JSON.stringify({ error: "Invalid JSON body" }));
+                        return;
+                    }
+                }
+                await transport.handleRequest(req, res, parsedBody);
+            }
+            catch (error) {
+                console.error("Error handling streamable-http request:", error);
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                    res.setHeader("content-type", "application/json");
+                    res.end(JSON.stringify({
+                        jsonrpc: "2.0",
+                        error: { code: -32603, message: "Internal server error" },
+                        id: null
+                    }));
+                }
+            }
+        };
+        const httpServer = createHttpServer((req, res) => {
+            void requestHandler(req, res);
+        });
+        await new Promise((resolve, reject) => {
+            httpServer.once("error", reject);
+            httpServer.listen(this.runtimeConfig.httpPort, this.runtimeConfig.httpHost, () => resolve());
+        });
+        this.httpRuntime = { transport, httpServer };
+        console.error(`3D Printer MCP server running on streamable-http at http://${this.runtimeConfig.httpHost}:${this.runtimeConfig.httpPort}${this.runtimeConfig.httpPath}`);
+    }
+    async invokeBlenderBridge(params) {
+        const command = params.bridgeCommand ?? this.runtimeConfig.blenderBridgeCommand;
+        const payload = {
+            modelPath: params.stlPath,
+            operations: params.operations,
+            source: "mcp-3d-printer-server"
+        };
+        if (!params.execute) {
+            return {
+                status: "prepared",
+                message: "Prepared Blender MCP payload. Set execute=true to run bridge command.",
+                bridgeCommand: command ?? null,
+                payload
+            };
+        }
+        if (!command) {
+            throw new Error("execute=true requires bridge_command or BLENDER_MCP_BRIDGE_COMMAND env var.");
+        }
+        const { spawn } = await import("node:child_process");
+        const result = await new Promise((resolve, reject) => {
+            const child = spawn(command, {
+                shell: true,
+                stdio: ["pipe", "pipe", "pipe"]
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk;
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk;
+            });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                if (code === 0) {
+                    resolve({ stdout, stderr });
+                    return;
+                }
+                reject(new Error(`Blender bridge command exited with code ${code ?? "unknown"}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+            });
+            child.stdin.write(JSON.stringify(payload));
+            child.stdin.end();
+        });
+        return {
+            status: "executed",
+            bridgeCommand: command,
+            stdout: result.stdout?.toString() ?? "",
+            stderr: result.stderr?.toString() ?? ""
+        };
+    }
+    async close() {
+        await this.printerFactory.disconnectAll();
+        if (this.httpRuntime) {
+            await this.httpRuntime.transport.close();
+            await new Promise((resolve, reject) => {
+                this.httpRuntime?.httpServer.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            this.httpRuntime = undefined;
+        }
+        else {
+            await this.server.close();
+        }
+    }
+    async run() {
+        if (this.runtimeConfig.transport === "streamable-http") {
+            await this.connectStreamableHttp();
+            return;
+        }
+        await this.connectStdio();
+    }
 }
 const server = new ThreeDPrinterMCPServer();
-server.run().catch(console.error);
+const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+};
+process.once("SIGINT", () => {
+    void shutdown();
+});
+process.once("SIGTERM", () => {
+    void shutdown();
+});
+server.run().catch((error) => {
+    console.error("[mcp-3d-printer-server] startup failed:", error);
+    process.exit(1);
+});