mcp-3d-printer-server 1.0.2 → 1.2.1

package/src/index.ts

@@ -2,6 +2,7 @@
 
 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,
@@ -14,6 +15,8 @@ import axios from "axios";
 import dotenv from "dotenv";
 import fs from "fs";
 import path from "path";
+import { createServer as createHttpServer, type IncomingMessage, type Server as HttpServer, type ServerResponse } 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";
@@ -31,14 +34,139 @@ const DEFAULT_TYPE = process.env.PRINTER_TYPE || "octoprint"; // Default to Octo
 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"] as const;
+type BambuModel = typeof VALID_BAMBU_MODELS[number];
+
+const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"] as const;
+
+// Map model IDs to BambuStudio --load-machine preset names
+const BAMBU_MODEL_PRESETS: Record<string, (nozzle: string) => string> = {
+  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: string): BambuModel {
+  const normalized = model.trim().toLowerCase();
+  if (!(VALID_BAMBU_MODELS as readonly string[]).includes(normalized)) {
+    throw new Error(
+      `Invalid Bambu printer model "${model}". Valid models: ${VALID_BAMBU_MODELS.join(", ")}`
+    );
+  }
+  return normalized as BambuModel;
+}
+
+function resolveBedType(bedType: string | undefined): string {
+  const resolved = (bedType || DEFAULT_BED_TYPE).trim().toLowerCase();
+  if (!(VALID_BED_TYPES as readonly string[]).includes(resolved)) {
+    throw new Error(
+      `Invalid bed type "${bedType}". Valid types: ${VALID_BED_TYPES.join(", ")}`
+    );
+  }
+  return resolved;
+}
+
+type RuntimeConfig = {
+  transport: "stdio" | "streamable-http";
+  httpHost: string;
+  httpPort: number;
+  httpPath: string;
+  statefulSession: boolean;
+  enableJsonResponse: boolean;
+  allowedOrigins: Set<string>;
+  blenderBridgeCommand?: string;
+};
+
+function parseBooleanEnv(rawValue: string | undefined, fallback: boolean): boolean {
+  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: string | undefined, fallback: number): number {
+  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: string | undefined): string {
+  const value = (pathValue ?? "/mcp").trim();
+  if (!value) {
+    return "/mcp";
+  }
+  return value.startsWith("/") ? value : `/${value}`;
+}
+
+function parseCsvEnv(value: string | undefined): Set<string> {
+  if (!value) {
+    return new Set();
+  }
+  const entries = value
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+  return new Set(entries);
+}
+
+function readRuntimeConfig(): RuntimeConfig {
+  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,
+  };
+}
+
+type StructuredToolError = {
+  status: "error";
+  retryable: boolean;
+  suggestion: string;
+  message: string;
+  tool: string;
+};
+
 // Ensure temp directory exists
 if (!fs.existsSync(TEMP_DIR)) {
   fs.mkdirSync(TEMP_DIR, { recursive: true });
@@ -48,12 +176,15 @@ class ThreeDPrinterMCPServer {
   private server: Server;
   private printerFactory: PrinterFactory;
   private stlManipulator: STLManipulator;
+  private readonly runtimeConfig: RuntimeConfig;
+  private httpRuntime?: { transport: StreamableHTTPServerTransport; httpServer: HttpServer };
 
   constructor() {
+    this.runtimeConfig = readRuntimeConfig();
     this.server = new Server(
       {
         name: "mcp-3d-printer-server",
-        version: "1.0.0"
+        version: "1.2.0"
       },
       {
         capabilities: {
@@ -70,17 +201,68 @@ class ThreeDPrinterMCPServer {
     this.setupErrorHandling();
   }
 
+  private async resolveBambuModel(argsModel: string | undefined): Promise<string> {
+    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" as const,
+        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: any) {
+      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() {
@@ -230,17 +412,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",
@@ -507,6 +698,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)"
@@ -529,7 +734,7 @@ class ThreeDPrinterMCPServer {
                   additionalProperties: { type: "number" }
                 }
               },
-              required: ["three_mf_path"]
+              required: ["three_mf_path", "bambu_model"]
             }
           },
           {
@@ -577,6 +782,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"]
+            }
           }
         ]
       };
@@ -593,7 +825,7 @@ class ThreeDPrinterMCPServer {
       const apiKey = String(args?.api_key || DEFAULT_API_KEY);
       const bambuSerial = String(args?.bambu_serial || DEFAULT_BAMBU_SERIAL);
       const bambuToken = String(args?.bambu_token || DEFAULT_BAMBU_TOKEN);
-      const slicerType = String(args?.slicer_type || DEFAULT_SLICER_TYPE) as 'prusaslicer' | 'cura' | 'slic3r';
+      const slicerType = String(args?.slicer_type || DEFAULT_SLICER_TYPE) as 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio';
       const slicerPath = String(args?.slicer_path || DEFAULT_SLICER_PATH);
       const slicerProfile = String(args?.slicer_profile || DEFAULT_SLICER_PROFILE);
 
@@ -654,17 +886,27 @@ class ThreeDPrinterMCPServer {
             );
             break;
             
-          case "slice_stl":
+          case "slice_stl": {
             if (!args?.stl_path) {
               throw new Error("Missing required parameter: stl_path");
             }
+            // Resolve printer model for BambuStudio slicer
+            let slicePreset: string | undefined;
+            if (slicerType === 'bambustudio') {
+              const sliceModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+              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
+              slicerProfile || undefined,
+              undefined, // progressCallback
+              slicePreset
             );
             break;
+          }
             
           case "confirm_temperatures":
             if (!args?.gcode_path) {
@@ -697,12 +939,19 @@ class ThreeDPrinterMCPServer {
             );
             
             // 2. Slice the extended STL file
+            let processPreset: string | undefined;
+            if (slicerType === 'bambustudio') {
+              const processModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+              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
+              processProgressCallback,
+              processPreset
             );
             
             // 3. Confirm temperatures if specified
@@ -928,7 +1177,7 @@ class ThreeDPrinterMCPServer {
             );
             break;
             
-          case "print_3mf":
+          case "print_3mf": {
             if (!args?.three_mf_path) {
               throw new Error("Missing required parameter: three_mf_path");
             }
@@ -938,9 +1187,38 @@ 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 as string | undefined);
+            const printBedType = resolveBedType(args?.bed_type as string | undefined);
+            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: any) {
+              console.warn("Could not check/slice 3MF, proceeding with original:", sliceCheckErr.message);
+            }
+
             // Define variables needed outside the parse try block
             let implementation: BambuImplementation;
             let threeMfFilename: string;
@@ -1013,12 +1291,13 @@ class ThreeDPrinterMCPServer {
                 printOptions = { // Assign to outer scope variable
                     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
@@ -1041,7 +1320,8 @@ class ThreeDPrinterMCPServer {
             }
 
             break;
-            
+          }
+
           case "merge_vertices":
             if (!args?.stl_path) {
                 throw new Error("Missing required parameter: stl_path");
@@ -1065,6 +1345,19 @@ 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}`);
@@ -1082,14 +1375,16 @@ class ThreeDPrinterMCPServer {
         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
         };
       }
@@ -1146,7 +1441,8 @@ class ThreeDPrinterMCPServer {
     const implementation = this.printerFactory.getImplementation(type);
     
     if (type.toLowerCase() === "bambu") {
-      return (implementation as any).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);
@@ -1172,9 +1468,8 @@ class ThreeDPrinterMCPServer {
       const implementation = this.printerFactory.getImplementation(type);
       
       if (type.toLowerCase() === "bambu") {
-        return await (implementation as any).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);
@@ -1198,12 +1493,8 @@ class ThreeDPrinterMCPServer {
     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 as any).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);
@@ -1220,9 +1511,8 @@ class ThreeDPrinterMCPServer {
     const implementation = this.printerFactory.getImplementation(type);
     
     if (type.toLowerCase() === "bambu") {
-      return await (implementation as any).cancelJob(
-        host, port, apiKey, bambuSerial, bambuToken
-      );
+      const bambuApiKey = `${bambuSerial}:${bambuToken}`;
+      return await implementation.cancelJob(host, port, bambuApiKey);
     }
     
     return await implementation.cancelJob(host, port, apiKey);
@@ -1241,27 +1531,269 @@ class ThreeDPrinterMCPServer {
     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() {
+  private toStructuredToolError(tool: string, message: string): StructuredToolError {
+    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,
+    };
+  }
+
+  private async parseHttpRequestBody(req: IncomingMessage): Promise<unknown> {
+    const chunks: Buffer[] = [];
+    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);
+  }
+
+  private isAllowedOrigin(req: IncomingMessage): boolean {
+    const origin = req.headers.origin;
+    if (!origin) {
+      return true;
+    }
+
+    if (this.runtimeConfig.allowedOrigins.size === 0) {
+      return false;
+    }
+
+    return this.runtimeConfig.allowedOrigins.has(origin);
+  }
+
+  private async connectStdio(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
     console.error("3D Printer MCP server running on stdio transport");
   }
+
+  private async connectStreamableHttp(): Promise<void> {
+    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: IncomingMessage, res: ServerResponse) => {
+      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: unknown;
+        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<void>((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}`
+    );
+  }
+
+  private async invokeBlenderBridge(params: {
+    stlPath: string;
+    operations: string[];
+    execute: boolean;
+    bridgeCommand?: string;
+  }): Promise<Record<string, unknown>> {
+    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<{ stdout: string; stderr: string }>((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: string) => {
+        stdout += chunk;
+      });
+      child.stderr.on("data", (chunk: string) => {
+        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(): Promise<void> {
+    await this.printerFactory.disconnectAll();
+
+    if (this.httpRuntime) {
+      await this.httpRuntime.transport.close();
+      await new Promise<void>((resolve, reject) => {
+        this.httpRuntime?.httpServer.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+      this.httpRuntime = undefined;
+    } else {
+      await this.server.close();
+    }
+  }
+
+  async run(): Promise<void> {
+    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);
+});