mcp-3d-printer-server 1.2.20 → 1.2.21

package/dist/index.js

@@ -11,11 +11,15 @@ import fs from "fs";
 import path from "path";
 import os from "node:os";
 import { BlenderMcpBridge } from "./blender-mcp-bridge.js";
+import { resolveFilamentProfile } from "./slicer/filament-profiles.js";
+import { FUSION_CALL_OUTPUT_SCHEMA, FUSION_EXPORT_OUTPUT_SCHEMA, FUSION_MCP_PINNED_COMMIT, FUSION_NEW_DESIGN_OUTPUT_SCHEMA, FUSION_STATUS_OUTPUT_SCHEMA, FusionMcpBridge, } from "./fusion-mcp-bridge.js";
 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";
+import { CounterpartService } from "./counterpart/service.js";
+import { CAMERA_SNAPSHOT_OUTPUT_SCHEMA, CONTROL_OUTPUT_SCHEMA, FILAMENTS_OUTPUT_SCHEMA, PRINT_PROGRESS_OUTPUT_SCHEMA, PRINTER_INFO_OUTPUT_SCHEMA, } from "./counterpart/contract.js";
 import { SlicerError } from "./slicer/slicer-error.js";
 import { inspectSliceSettings, listTemplateRegistry, resolveTemplatePath, resolveTemplateSlicerProfilePath, saveTemplate, } from "./slicer/templates.js";
 import { parse3MF } from './3mf_parser.js';
@@ -25,6 +29,8 @@ import { CONFIRMATION_UNAVAILABLE, confirmationTimedOut, confirmationTimeoutMs }
 import { validateExpectedPeaks } from "./safety/expected-peaks.js";
 // Load environment variables from .env file
 dotenv.config();
+const SERVER_NAME = "mcp-3d-printer-server";
+const SERVER_VERSION = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 // Default values
 const DEFAULT_HOST = process.env.PRINTER_HOST || "localhost";
 const DEFAULT_PORT = process.env.PRINTER_PORT || "80";
@@ -237,7 +243,76 @@ const SLICE_TOOL_PROPERTIES = {
     min_save: { type: "boolean", description: "Bambu-compatible slicing: write a smaller output 3MF (--min-save)." },
     skip_modified_gcodes: { type: "boolean", description: "Bambu-compatible slicing: ignore custom G-code embedded in an input 3MF (--skip-modified-gcodes)." },
     slice_plate: { type: "number", description: "Bambu-compatible slicing: plate number to slice; 0 slices all plates (default)." },
+    layer_height: {
+        type: "number", exclusiveMinimum: 0, maximum: 2,
+        description: "Layer height in mm, written over the selected process profile (Orca/Bambu Studio layer_height; PrusaSlicer --layer-height). Not mapped for Cura.",
+    },
+    wall_loops: {
+        type: "integer", minimum: 0, maximum: 100,
+        description: "Number of walls, written over the selected process profile (Orca/Bambu Studio wall_loops; PrusaSlicer --perimeters). Not mapped for Cura.",
+    },
+    sparse_infill_density: {
+        type: "string",
+        description: "Sparse infill density such as \"15%\" (0–100%), written over the selected process profile (Orca/Bambu Studio sparse_infill_density; PrusaSlicer --fill-density). Not mapped for Cura.",
+    },
+};
+/**
+ * upload_gcode / start_print results name the remote file that was stored or
+ * started (start_print starts a uniquely named checked copy), so a monitor can
+ * match counterpart_print_progress job.name to it.
+ */
+function withJobName(result, requested) {
+    if (!result || typeof result !== "object" || Array.isArray(result))
+        return result;
+    const record = result;
+    if (typeof record.jobName === "string" && record.jobName)
+        return result;
+    const remote = typeof record.remotePath === "string" && record.remotePath ? record.remotePath : requested;
+    return { ...record, jobName: path.posix.basename(remote.replace(/\\/g, "/")) };
+}
+/** Connection overrides shared by the counterpart/1 tools. */
+const PRINTER_TARGET_PROPERTIES = {
+    host: { type: "string", description: "Hostname or IP address of the printer (default: value from env)" },
+    port: { type: "string", description: "Port of the printer API (default: value from env)" },
+    type: { type: "string", description: "Type of printer management system (octoprint, klipper, duet, repetier, bambu, prusa, creality) (default: value from env)" },
+    api_key: { type: "string", description: "API key for authentication (default: value from env)" },
+    bambu_serial: { type: "string", description: "Serial number for Bambu Lab printers (default: value from env)" },
+    bambu_token: { type: "string", description: "Access token for Bambu Lab printers (default: value from env)" },
 };
+/** Tools that declare an outputSchema: their errors carry no structuredContent, which clients would validate. */
+const OUTPUT_SCHEMA_TOOLS = new Set([
+    "counterpart_printer_info", "counterpart_print_progress", "camera_snapshot", "get_printer_filaments", "pause_print", "resume_print",
+    "fusion_mcp_status", "fusion_mcp_call", "fusion_mcp_new_design", "fusion_mcp_export",
+]);
+/** layer_height / wall_loops / sparse_infill_density (PRD §8.4), validated before slicing. */
+function parseProcessOverrides(args) {
+    const overrides = {};
+    if (args?.layer_height !== undefined) {
+        const value = args.layer_height;
+        if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > 2) {
+            throw new Error("Invalid layer_height: expected a number of millimetres greater than 0 and at most 2.");
+        }
+        overrides.layerHeight = value;
+    }
+    if (args?.wall_loops !== undefined) {
+        const value = args.wall_loops;
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 100) {
+            throw new Error("Invalid wall_loops: expected an integer from 0 to 100.");
+        }
+        overrides.wallLoops = value;
+    }
+    if (args?.sparse_infill_density !== undefined) {
+        const raw = args.sparse_infill_density;
+        const text = typeof raw === "number" ? String(raw) : typeof raw === "string" ? raw.trim() : "";
+        const match = text.match(/^(\d+(?:\.\d+)?)\s*%?$/);
+        const value = match ? Number(match[1]) : NaN;
+        if (!Number.isFinite(value) || value < 0 || value > 100) {
+            throw new Error("Invalid sparse_infill_density: expected a percentage such as \"15%\" from 0% to 100%.");
+        }
+        overrides.sparseInfillDensity = `${value}%`;
+    }
+    return overrides;
+}
 function validateSliceBambuModel(model) {
     const normalized = model.trim().toLowerCase();
     if (!SLICE_BAMBU_MODELS.includes(normalized)) {
@@ -324,6 +399,20 @@ function buildBambuSliceOptions(args) {
     options.nozzleType = resolveNozzleType(args?.nozzle_type);
     return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
 }
+/** The slicer, printer and filament slice_stl uses when a call names none (get_printer_filaments' profile). */
+function defaultFilamentProfileContext() {
+    const splitList = (value) => value.split(";").map((item) => item.trim()).filter(Boolean);
+    const pipeFilaments = DEFAULT_SLICER_PROFILE.includes("|") ? splitList(DEFAULT_SLICER_PROFILE.split("|", 2)[1]) : [];
+    const configuredFilaments = DEFAULT_SLICER_TYPE === "cura" ? []
+        : DEFAULT_SLICER_TYPE === "prusaslicer" || DEFAULT_SLICER_TYPE === "slic3r" ? splitList(DEFAULT_FILAMENT_PROFILE)
+            : [...pipeFilaments, ...splitList(DEFAULT_FILAMENT_PROFILE)];
+    return {
+        slicerType: DEFAULT_SLICER_TYPE,
+        slicerPath: defaultSlicerPathFor(DEFAULT_SLICER_TYPE) || undefined,
+        slicerProfile: DEFAULT_SLICER_PROFILE || undefined,
+        configuredFilaments,
+    };
+}
 function defaultSlicerPathFor(slicerType) {
     if (process.env.SLICER_PATH)
         return process.env.SLICER_PATH;
@@ -453,10 +542,11 @@ function credentialSuggestion() {
 class ThreeDPrinterMCPServer {
     constructor() {
         this.blender = new BlenderMcpBridge();
+        this.fusion = new FusionMcpBridge();
         this.runtimeConfig = readRuntimeConfig();
         this.server = new Server({
-            name: "mcp-3d-printer-server",
-            version: JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version
+            name: SERVER_NAME,
+            version: SERVER_VERSION
         }, {
             capabilities: {
                 resources: {},
@@ -464,6 +554,7 @@ class ThreeDPrinterMCPServer {
             }
         });
         this.printerFactory = new PrinterFactory((message) => this.confirmHardware(message));
+        this.counterpart = new CounterpartService((printerType) => this.printerFactory.getImplementation(printerType), axios.create({ timeout: 10000 }), { name: SERVER_NAME, version: SERVER_VERSION }, (material) => resolveFilamentProfile(material, defaultFilamentProfileContext()));
         this.stlManipulator = new STLManipulator(TEMP_DIR);
         this.setupHandlers();
         this.setupErrorHandling();
@@ -558,6 +649,7 @@ class ThreeDPrinterMCPServer {
         if (!args?.stl_path) {
             throw new Error("Missing required parameter: stl_path");
         }
+        const processOverrides = parseProcessOverrides(args);
         const slicerType = normalizeSlicerType(String(args.slicer_type || DEFAULT_SLICER_TYPE));
         const explicitModel = typeof args.bambu_model === "string" && args.bambu_model.trim() ? args.bambu_model : undefined;
         // Generic OrcaSlicer keeps its user-supplied machine profile unless the
@@ -588,10 +680,20 @@ class ThreeDPrinterMCPServer {
         }
         slicerProfile ?? (slicerProfile = DEFAULT_SLICER_PROFILE || undefined);
         const explicitFilament = typeof args.filament_profile === "string" && args.filament_profile.trim() ? args.filament_profile.trim() : undefined;
-        const filamentProfile = options?.loadFilaments ?? explicitFilament ?? (DEFAULT_FILAMENT_PROFILE || undefined);
+        // Generic slicers take load_filaments too (filament_profile is its alias), as the Bambu CLI path does.
+        const explicitLoad = !bambuCli && typeof args.load_filaments === "string" && args.load_filaments.trim() ? args.load_filaments.trim() : undefined;
+        if (explicitLoad && explicitFilament && explicitLoad !== explicitFilament) {
+            throw new Error("Provide either load_filaments or filament_profile, not conflicting values.");
+        }
+        const filamentProfile = options?.loadFilaments ?? explicitLoad ?? explicitFilament ?? (DEFAULT_FILAMENT_PROFILE || undefined);
+        // A filament chosen for this call replaces the default riding in "machine;process|filament",
+        // or Orca would keep that default as slot 1 and add the chosen one as slot 2.
+        if (!bambuCli && (explicitLoad ?? explicitFilament) && slicerProfile?.includes("|")) {
+            slicerProfile = slicerProfile.split("|", 1)[0];
+        }
         const slicerPath = this.resolveExecutableSelectorArg(args.slicer_path, toolName, "slicer_path") ?? defaultSlicerPathFor(slicerType);
         return this.stlManipulator.sliceSTL(String(args.stl_path), slicerType, slicerPath, slicerProfile, undefined, // progressCallback
-        printerPreset, filamentProfile, options);
+        printerPreset, filamentProfile, options, processOverrides);
     }
     setupErrorHandling() {
         this.server.onerror = (error) => {
@@ -926,6 +1028,55 @@ class ThreeDPrinterMCPServer {
                             }
                         }
                     },
+                    {
+                        name: "counterpart_printer_info",
+                        description: "Describe this printer for the counterpart/1 contract: server name and version, printer kind and identity, and which features work (progress, layers, camera, filaments, pause, resume, cancel, print_3mf, G-code), detected from the firmware. Read-only.",
+                        inputSchema: { type: "object", properties: { ...PRINTER_TARGET_PROPERTIES } },
+                        outputSchema: PRINTER_INFO_OUTPUT_SCHEMA,
+                        annotations: { readOnlyHint: true, openWorldHint: true },
+                    },
+                    {
+                        name: "counterpart_print_progress",
+                        description: "Read the printer's state and current job in the counterpart/1 shape: state, job name, progress (0-100), elapsed and remaining seconds, layers when the firmware reports them, temperatures and problems. job.name matches the jobName that upload_gcode and start_print return. Read-only.",
+                        inputSchema: { type: "object", properties: { ...PRINTER_TARGET_PROPERTIES } },
+                        outputSchema: PRINT_PROGRESS_OUTPUT_SCHEMA,
+                        annotations: { readOnlyHint: true, openWorldHint: true },
+                    },
+                    {
+                        name: "camera_snapshot",
+                        description: "Capture one JPEG frame from the printer's camera: OctoPrint's configured snapshot URL (Classic Webcam on 1.9+, webcam.snapshotUrl on 1.8, then /webcam/?action=snapshot), Moonraker's first enabled webcam, or Repetier's webcam staticUrl. PrusaLink and Duet have no local snapshot API. PRINTER_CAMERA_SNAPSHOT_URL overrides the source for any printer. Returns the JPEG as base64; pass save_path to also write it to disk.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                ...PRINTER_TARGET_PROPERTIES,
+                                save_path: { type: "string", description: "Optional absolute path to write the JPEG to disk. If omitted, only the base64 payload is returned." },
+                                timeout_ms: { type: "number", description: "Max ms to wait for a frame (default 8000, 100 to 120000)." },
+                            },
+                        },
+                        outputSchema: CAMERA_SNAPSHOT_OUTPUT_SCHEMA,
+                        annotations: { readOnlyHint: true, openWorldHint: true },
+                    },
+                    {
+                        name: "get_printer_filaments",
+                        description: "Report the loaded filament as one external slot (id \"ext\"). Moonraker printers with Spoolman report the active spool's material, colour and name; other printers report source \"unknown\". Read-only.",
+                        inputSchema: { type: "object", properties: { ...PRINTER_TARGET_PROPERTIES } },
+                        outputSchema: FILAMENTS_OUTPUT_SCHEMA,
+                        annotations: { readOnlyHint: true, openWorldHint: true },
+                    },
+                    {
+                        name: "pause_print",
+                        description: "Pause the current print (OctoPrint, Klipper/Moonraker, PrusaLink, Duet M25, Repetier, and Creality printers that run Moonraker). Pause is never gated.",
+                        inputSchema: { type: "object", properties: { ...PRINTER_TARGET_PROPERTIES } },
+                        outputSchema: CONTROL_OUTPUT_SCHEMA,
+                        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+                    },
+                    {
+                        name: "resume_print",
+                        description: "Resume a paused print. Resume reheats and moves the printer, so it only resumes a job this server instance inspected and started, and only when the printer freshly reports that job paused. Resume other jobs at the printer.",
+                        inputSchema: { type: "object", properties: { ...PRINTER_TARGET_PROPERTIES } },
+                        outputSchema: CONTROL_OUTPUT_SCHEMA,
+                        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+                    },
                     {
                         name: "set_printer_temperature",
                         description: "Set the temperature of a printer component. Temperature 0 switches a heater off and is never gated. Positive targets are validated before connecting, limited by independent hardware and material ceilings, require a ready printer and a human confirmation.",
@@ -1652,6 +1803,62 @@ class ThreeDPrinterMCPServer {
                             required: ["stl_path", "operations"],
                             additionalProperties: false
                         }
+                    },
+                    {
+                        name: "fusion_mcp_status",
+                        description: `Check the Autodesk Fusion bridge: whether the Fusion MCP server is configured (faust-machines/fusion360-mcp-server@${FUSION_MCP_PINNED_COMMIT}), whether Fusion is running, whether its Fusion360MCP add-in answers on its port, and the server's tools and schemas. connected is true only when the add-in answered. With launch: true and Fusion not running on this Mac, opens Autodesk Fusion and waits up to 90 s for the add-in.`,
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                launch: { type: "boolean", description: "Open Autodesk Fusion when it is not running (macOS), then wait up to 90 s for the add-in (default false)." },
+                                timeout_ms: { type: "integer", minimum: 100, maximum: 600000, description: "Deadline in milliseconds; defaults to FUSION_MCP_TIMEOUT_MS or 180000. The first start downloads the pinned server with uvx." }
+                            },
+                            additionalProperties: false
+                        },
+                        outputSchema: FUSION_STATUS_OUTPUT_SCHEMA,
+                    },
+                    {
+                        name: "fusion_mcp_call",
+                        description: "Call a discovered tool on the Fusion MCP server (create_sketch, extrude, fillet, set_parameter, export_stl, execute_code, and others), preserving its full MCP content and errors. Discover tool schemas with fusion_mcp_status first. Calls change the active Fusion design and are never automatically retried. Most tools need an active design: call fusion_mcp_new_design first.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                tool_name: { type: "string", description: "Exact name advertised by the Fusion MCP server." },
+                                arguments: { type: "object", description: "Arguments matching the remote tool's discovered input schema. Fusion lengths are in centimetres unless a tool says otherwise." },
+                                timeout_ms: { type: "integer", minimum: 100, maximum: 600000, description: "Deadline in milliseconds; defaults to FUSION_MCP_TIMEOUT_MS or 180000." }
+                            },
+                            required: ["tool_name"],
+                            additionalProperties: false
+                        },
+                        outputSchema: FUSION_CALL_OUTPUT_SCHEMA,
+                    },
+                    {
+                        name: "fusion_mcp_new_design",
+                        description: "Open a new parametric design document in Fusion, so the Fusion tools have an active design. Fusion must already have some document open: at the pinned faust-machines commit no tool works from Fusion's home screen (issue #12).",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                timeout_ms: { type: "integer", minimum: 100, maximum: 600000, description: "Deadline in milliseconds; defaults to FUSION_MCP_TIMEOUT_MS or 180000." }
+                            },
+                            additionalProperties: false
+                        },
+                        outputSchema: FUSION_NEW_DESIGN_OUTPUT_SCHEMA,
+                    },
+                    {
+                        name: "fusion_mcp_export",
+                        description: "Export the active Fusion design into output_dir as <name>.stl (export_stl), <name>.f3d (export_f3d) and <name>.parameters.json (the design's user parameters), and return their absolute paths. The STL is checked as a finite triangle mesh and its size compared with the Fusion body to report its units. Existing files are never overwritten. Fusion and this server must share the computer's file system.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                output_dir: { type: "string", description: "Existing absolute directory for the three files." },
+                                name: { type: "string", description: "Base file name without a path or extension, such as \"bracket\"." },
+                                body_name: { type: "string", description: "Body to export as the STL. Optional when the design has exactly one visible solid body." },
+                                timeout_ms: { type: "integer", minimum: 100, maximum: 600000, description: "Deadline in milliseconds; defaults to FUSION_MCP_TIMEOUT_MS or 180000." }
+                            },
+                            required: ["output_dir", "name"],
+                            additionalProperties: false
+                        },
+                        outputSchema: FUSION_EXPORT_OUTPUT_SCHEMA,
                     }
                 ]
             };
@@ -1671,7 +1878,35 @@ class ThreeDPrinterMCPServer {
             const filamentProfile = String(args?.filament_profile || DEFAULT_FILAMENT_PROFILE);
             try {
                 let result;
+                const target = {
+                    type, host, port,
+                    apiKey: type.toLowerCase() === "bambu" ? `${bambuSerial}:${bambuToken}` : apiKey,
+                };
+                const structured = (value) => ({
+                    content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+                    structuredContent: value,
+                });
                 switch (name) {
+                    case "counterpart_printer_info":
+                        return structured(await this.counterpart.printerInfo(target));
+                    case "counterpart_print_progress":
+                        return structured(await this.counterpart.printProgress(target));
+                    case "camera_snapshot": {
+                        if (args?.save_path !== undefined && typeof args.save_path !== "string")
+                            throw new Error("Invalid save_path: expected a string.");
+                        if (args?.timeout_ms !== undefined && typeof args.timeout_ms !== "number")
+                            throw new Error("Invalid timeout_ms: expected a number.");
+                        return structured(await this.counterpart.cameraSnapshot(target, {
+                            savePath: args?.save_path,
+                            timeoutMs: args?.timeout_ms,
+                        }));
+                    }
+                    case "get_printer_filaments":
+                        return structured(await this.counterpart.filaments(target));
+                    case "pause_print":
+                        return structured(await this.counterpart.pause(target));
+                    case "resume_print":
+                        return structured(await this.counterpart.resume(target));
                     case "get_printer_status":
                         result = await this.getPrinterStatus(host, port, type, apiKey, bambuSerial, bambuToken);
                         break;
@@ -1697,7 +1932,7 @@ class ThreeDPrinterMCPServer {
                         }
                         const uploadFilename = String(args?.filename || path.basename(String(args.gcode_path)));
                         const uploadGcodeSource = String(args?.gcode_path || args.gcode);
-                        result = await this.uploadGcode(host, port, type, apiKey, bambuSerial, bambuToken, uploadFilename, uploadGcodeSource, Boolean(args.print || false), uploadOptions);
+                        result = withJobName(await this.uploadGcode(host, port, type, apiKey, bambuSerial, bambuToken, uploadFilename, uploadGcodeSource, Boolean(args.print || false), uploadOptions), uploadFilename);
                         break;
                     case "start_print":
                         if (!args?.filename) {
@@ -1707,7 +1942,7 @@ class ThreeDPrinterMCPServer {
                         if (type.toLowerCase() === "bambu") {
                             startOptions.bambuModel = await this.resolveBambuModel(args?.bambu_model);
                         }
-                        result = await this.startPrint(host, port, type, apiKey, bambuSerial, bambuToken, String(args.filename), startOptions);
+                        result = withJobName(await this.startPrint(host, port, type, apiKey, bambuSerial, bambuToken, String(args.filename), startOptions), String(args.filename));
                         break;
                     case "cancel_print":
                         result = await this.cancelPrint(host, port, type, apiKey, bambuSerial, bambuToken);
@@ -2155,6 +2390,14 @@ class ThreeDPrinterMCPServer {
                         }
                         result = await this.stlManipulator.layFlat(String(args.stl_path));
                         break;
+                    case "fusion_mcp_status":
+                        return structured(await this.fusion.status(args ?? {}, extra.signal));
+                    case "fusion_mcp_call":
+                        return await this.fusion.call(args ?? {}, extra.signal);
+                    case "fusion_mcp_new_design":
+                        return structured(await this.fusion.newDesign(args ?? {}, extra.signal));
+                    case "fusion_mcp_export":
+                        return structured(await this.fusion.export(args ?? {}, extra.signal));
                     case "blender_mcp_status":
                         result = await this.blender.status(args ?? {}, extra.signal);
                         break;
@@ -2189,7 +2432,8 @@ class ThreeDPrinterMCPServer {
                             text: `Error: ${errorMessage}\nSuggestion: ${structuredError.suggestion}`
                         }
                     ],
-                    structuredContent: structuredError,
+                    // Clients validate structuredContent against a declared outputSchema even on errors.
+                    ...(OUTPUT_SCHEMA_TOOLS.has(name) ? {} : { structuredContent: structuredError }),
                     isError: true
                 };
             }
@@ -2290,6 +2534,15 @@ class ThreeDPrinterMCPServer {
                 tool,
             };
         }
+        if (tool.startsWith("fusion_mcp_")) {
+            return {
+                status: "error",
+                retryable: false,
+                suggestion: "Check that Autodesk Fusion is open with the Fusion360MCP add-in running and the FUSION_MCP_* settings, then ask again. Fusion requests are never replayed; inspect the design before repeating a change.",
+                message,
+                tool,
+            };
+        }
         if (isCredentialRejection(message)) {
             return { status: "error", retryable: false, suggestion: credentialSuggestion(), message, tool };
         }
@@ -2343,6 +2596,11 @@ class ThreeDPrinterMCPServer {
     async connectStdio() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
+        // A host that disconnects by closing stdin sends no signal. Shut down then,
+        // so the server and its persistent Fusion MCP child do not outlive it.
+        const disconnected = () => { void this.close().finally(() => process.exit(0)); };
+        process.stdin.once("end", disconnected);
+        process.stdin.once("close", disconnected);
         console.error("3D Printer MCP server running on stdio transport");
     }
     async connectStreamableHttp() {
@@ -2441,8 +2699,14 @@ class ThreeDPrinterMCPServer {
         }
         return value;
     }
-    async close() {
+    /** Idempotent: a signal and stdin EOF can both arrive. */
+    close() {
+        this.closing ?? (this.closing = this.closeOnce());
+        return this.closing;
+    }
+    async closeOnce() {
         await this.printerFactory.disconnectAll();
+        await this.fusion.close();
         if (this.httpRuntime) {
             await this.httpRuntime.transport.close();
             await new Promise((resolve, reject) => {

package/dist/printers/creality.d.ts

@@ -1,4 +1,13 @@
-import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+import type { AxiosInstance } from "axios";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import type { ConfirmHardware } from "../safety/confirmation.js";
+import type { CounterpartProgress, FilamentSlot, PrinterIdentity } from "../counterpart/contract.js";
+/**
+ * K1/K2-series printers can run Moonraker: 7125 is Moonraker's own port and
+ * 4408 the Fluidd nginx front end that proxies its API. Neither is documented
+ * by Creality; stock firmware may run neither, so this is probed, never assumed.
+ */
+export declare const CREALITY_MOONRAKER_PORTS: string[];
 /**
  * Note: this adapter's /api/device, /api/storage and /api/job routes are not a
  * documented Creality API. Readiness fails closed unless the response carries
@@ -7,6 +16,22 @@ import { GenericPrinterImplementation, type GenericPrinterState } from "./generi
  */
 export declare class CrealityImplementation extends GenericPrinterImplementation {
     protected readonly printerLabel = "Creality";
+    private readonly moonraker;
+    private readonly probes;
+    /** Ports probed for Moonraker, in order. */
+    moonrakerPorts: string[];
+    constructor(apiClient: AxiosInstance, confirm?: ConfirmHardware);
+    /** The Moonraker port that answers /server/info on this host, if any. */
+    moonrakerPort(host: string): Promise<string | undefined>;
+    counterpartProgress(host: string, port: string, apiKey: string): Promise<CounterpartProgress>;
+    reportsLayers(host: string): Promise<boolean>;
+    supportsPauseResume(host: string): Promise<boolean>;
+    snapshotCandidates(host: string): Promise<SnapshotCandidate[]>;
+    counterpartFilaments(host: string, port: string, apiKey: string): Promise<FilamentSlot[]>;
+    counterpartIdentity(host: string): Promise<PrinterIdentity>;
+    /** Pause and resume only through a detected Moonraker; the device API has no verified route. */
+    protected rawPauseJob(host: string): Promise<any>;
+    protected rawResumeJob(host: string): Promise<any>;
     protected readPrinterState(host: string, port: string, apiKey: string): Promise<GenericPrinterState>;
     getStatus(host: string, port: string, apiKey: string): Promise<any>;
     getFiles(host: string, port: string, apiKey: string): Promise<any>;

package/dist/printers/creality.js

@@ -1,6 +1,15 @@
 import { GenericPrinterImplementation } from "./generic-base.js";
+import { KlipperImplementation, MACRO_TIMEOUT_MS } from "./klipper.js";
+import { mapCrealityDevice } from "../counterpart/progress.js";
 import fs from "fs";
 import FormData from "form-data";
+/**
+ * K1/K2-series printers can run Moonraker: 7125 is Moonraker's own port and
+ * 4408 the Fluidd nginx front end that proxies its API. Neither is documented
+ * by Creality; stock firmware may run neither, so this is probed, never assumed.
+ */
+export const CREALITY_MOONRAKER_PORTS = ["7125", "4408"];
+const MOONRAKER_PROBE_TTL_MS = 5 * 60000;
 const IDLE_STATES = new Set(["idle", "ready", "standby", "operational"]);
 const FINISHED_STATES = new Set(["complete", "completed", "finished", "finish", "cancelled", "canceled", "stopped"]);
 /**
@@ -10,9 +19,73 @@ const FINISHED_STATES = new Set(["complete", "completed", "finished", "finish",
  * route is verified.
  */
 export class CrealityImplementation extends GenericPrinterImplementation {
-    constructor() {
-        super(...arguments);
+    constructor(apiClient, confirm) {
+        super(apiClient, confirm);
         this.printerLabel = "Creality";
+        this.probes = new Map();
+        /** Ports probed for Moonraker, in order. */
+        this.moonrakerPorts = [...CREALITY_MOONRAKER_PORTS];
+        this.moonraker = new KlipperImplementation(apiClient, confirm);
+    }
+    /** The Moonraker port that answers /server/info on this host, if any. */
+    async moonrakerPort(host) {
+        const cached = this.probes.get(host);
+        if (cached && Date.now() - cached.at < MOONRAKER_PROBE_TTL_MS)
+            return cached.port;
+        let found;
+        for (const port of this.moonrakerPorts) {
+            try {
+                const info = (await this.apiClient.get(`http://${host}:${port}/server/info`, { timeout: 2000 })).data;
+                if (info?.result && typeof info.result === "object") {
+                    found = port;
+                    break;
+                }
+            }
+            catch {
+                // Try the next port.
+            }
+        }
+        this.probes.set(host, { port: found, at: Date.now() });
+        return found;
+    }
+    async counterpartProgress(host, port, apiKey) {
+        const moonraker = await this.moonrakerPort(host);
+        if (moonraker)
+            return this.moonraker.counterpartProgress(host, moonraker, "");
+        const data = (await this.apiClient.get(`http://${host}:${port}/api/device/status`, { headers: { "Authorization": `Bearer ${apiKey}` } })).data;
+        return mapCrealityDevice(data, new Date().toISOString());
+    }
+    async reportsLayers(host) {
+        return (await this.moonrakerPort(host)) !== undefined;
+    }
+    async supportsPauseResume(host) {
+        return (await this.moonrakerPort(host)) !== undefined;
+    }
+    async snapshotCandidates(host) {
+        const moonraker = await this.moonrakerPort(host);
+        return moonraker ? this.moonraker.snapshotCandidates(host, moonraker, "") : [];
+    }
+    async counterpartFilaments(host, port, apiKey) {
+        const moonraker = await this.moonrakerPort(host);
+        return moonraker ? this.moonraker.counterpartFilaments(host, moonraker, "") : super.counterpartFilaments(host, port, apiKey);
+    }
+    async counterpartIdentity(host) {
+        const moonraker = await this.moonrakerPort(host);
+        return moonraker ? this.moonraker.counterpartIdentity(host, moonraker, "") : {};
+    }
+    /** Pause and resume only through a detected Moonraker; the device API has no verified route. */
+    async rawPauseJob(host) {
+        const moonraker = await this.moonrakerPort(host);
+        if (!moonraker)
+            throw new Error("Unsupported: this Creality printer has no Moonraker API for pause.");
+        return (await this.apiClient.post(`http://${host}:${moonraker}/printer/print/pause`, null, { timeout: MACRO_TIMEOUT_MS })).data;
+    }
+    async rawResumeJob(host) {
+        const moonraker = await this.moonrakerPort(host);
+        if (!moonraker)
+            throw new Error("Unsupported: this Creality printer has no Moonraker API for resume.");
+        // The Creality adapter already checked the job identity; send the raw resume.
+        return (await this.apiClient.post(`http://${host}:${moonraker}/printer/print/resume`, null, { timeout: MACRO_TIMEOUT_MS })).data;
     }
     async readPrinterState(host, port, apiKey) {
         let data;

package/dist/printers/duet.d.ts

@@ -1,7 +1,23 @@
 import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+import type { CounterpartProgress, PrinterIdentity } from "../counterpart/contract.js";
 export declare class DuetImplementation extends GenericPrinterImplementation {
     protected readonly printerLabel = "Duet";
     private code;
+    /**
+     * Object model keys for counterpart_print_progress and identity. Standalone
+     * RepRapFirmware and DSF 3.5+ answer rr_model; older DSF only /machine/status
+     * (an alias of /machine/model). 'v' (verbose) is required: 'f' omits job.file.
+     * Without a machine password no rr_connect is needed; with one, requests get 401.
+     * https://github.com/Duet3D/RepRapFirmware/wiki/HTTP-requests
+     */
+    private objectModel;
+    counterpartProgress(host: string, port: string, apiKey: string): Promise<CounterpartProgress>;
+    reportsLayers(): Promise<boolean>;
+    counterpartIdentity(host: string, port: string): Promise<PrinterIdentity>;
+    /** M25 pauses and M24 resumes: rr_gcode on standalone/DSF 3.5+, POST /machine/code on older DSF. */
+    protected rawPauseJob(host: string, port: string): Promise<any>;
+    protected rawResumeJob(host: string, port: string): Promise<any>;
+    private sendGcode;
     getStatus(host: string, port: string, apiKey: string): Promise<any>;
     getFiles(host: string, port: string, apiKey: string): Promise<any>;
     getFile(host: string, port: string, apiKey: string, filename: string): Promise<any>;

package/dist/printers/duet.js

@@ -1,5 +1,11 @@
 import fs from "fs";
+import { isAxiosError } from "axios";
 import { GenericPrinterImplementation } from "./generic-base.js";
+import { nonEmptyText } from "../counterpart/contract.js";
+import { mapDuet } from "../counterpart/progress.js";
+function notFound(error) {
+    return isAxiosError(error) && (error.response?.status === 404 || error.response?.status === 405);
+}
 /**
  * Duet Software Framework (DuetWebServer) REST routes, verified against
  * DuetSoftwareFramework src/DuetWebServer/Controllers/MachineController.cs:
@@ -26,6 +32,64 @@ export class DuetImplementation extends GenericPrinterImplementation {
         });
         return response.data;
     }
+    /**
+     * Object model keys for counterpart_print_progress and identity. Standalone
+     * RepRapFirmware and DSF 3.5+ answer rr_model; older DSF only /machine/status
+     * (an alias of /machine/model). 'v' (verbose) is required: 'f' omits job.file.
+     * Without a machine password no rr_connect is needed; with one, requests get 401.
+     * https://github.com/Duet3D/RepRapFirmware/wiki/HTTP-requests
+     */
+    async objectModel(host, port, keys) {
+        const base = `http://${host}:${port}`;
+        const model = {};
+        try {
+            // Sequential: standalone boards serve few concurrent HTTP connections.
+            for (const key of keys) {
+                model[key] = (await this.apiClient.get(`${base}/rr_model?key=${encodeURIComponent(key)}&flags=d99v`)).data?.result;
+            }
+            return model;
+        }
+        catch (error) {
+            if (!notFound(error))
+                throw error;
+        }
+        const full = (await this.apiClient.get(`${base}/machine/status`)).data;
+        const root = full?.result && typeof full.result === "object" ? full.result : full;
+        for (const key of keys)
+            model[key] = root?.[key];
+        return model;
+    }
+    async counterpartProgress(host, port, apiKey) {
+        const model = await this.objectModel(host, port, ["state", "job"]);
+        if (!model.state || typeof model.state !== "object")
+            throw new Error("Duet did not return state from its object model.");
+        return mapDuet(model.state, model.job ?? {}, new Date().toISOString());
+    }
+    async reportsLayers() {
+        return true;
+    }
+    async counterpartIdentity(host, port) {
+        const model = await this.objectModel(host, port, ["network", "boards"]);
+        const board = Array.isArray(model.boards) ? model.boards[0] : undefined;
+        return { name: nonEmptyText(model.network?.name), model: nonEmptyText(board?.name) ?? nonEmptyText(board?.shortName) };
+    }
+    /** M25 pauses and M24 resumes: rr_gcode on standalone/DSF 3.5+, POST /machine/code on older DSF. */
+    async rawPauseJob(host, port) {
+        return this.sendGcode(host, port, "M25");
+    }
+    async rawResumeJob(host, port) {
+        return this.sendGcode(host, port, "M24");
+    }
+    async sendGcode(host, port, gcode) {
+        try {
+            return (await this.apiClient.get(`http://${host}:${port}/rr_gcode?gcode=${encodeURIComponent(gcode)}`)).data;
+        }
+        catch (error) {
+            if (!notFound(error))
+                throw error;
+        }
+        return this.code(host, port, gcode);
+    }
     async getStatus(host, port, apiKey) {
         const url = `http://${host}:${port}/machine/status`;
         const response = await this.apiClient.get(url);