mcp-3d-printer-server 1.2.20 → 1.2.22

package/src/index.ts

@@ -19,11 +19,28 @@ 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, 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, type BambuSliceOptions } from "./stl/stl-manipulator.js";
+import { STLManipulator, type BambuSliceOptions, type ProcessOverrides } from "./stl/stl-manipulator.js";
+import { CounterpartService, type PrinterTarget } 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,
@@ -44,6 +61,9 @@ import { validateExpectedPeaks, type ExpectedPeakTemperatures, type PrintSafetyO
 // Load environment variables from .env file
 dotenv.config();
 
+const SERVER_NAME = "mcp-3d-printer-server";
+const SERVER_VERSION: string = 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";
@@ -287,8 +307,79 @@ 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: unknown, requested: string): unknown {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return result;
+  const record = result as Record<string, unknown>;
+  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: Record<string, unknown> | undefined): ProcessOverrides {
+  const overrides: ProcessOverrides = {};
+  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: string): string {
   const normalized = model.trim().toLowerCase();
   if (!(SLICE_BAMBU_MODELS as readonly string[]).includes(normalized)) {
@@ -376,6 +467,21 @@ function buildBambuSliceOptions(args: Record<string, unknown> | undefined): Bamb
   return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined)) as BambuSliceOptions;
 }
 
+/** The slicer, printer and filament slice_stl uses when a call names none (get_printer_filaments' profile). */
+function defaultFilamentProfileContext() {
+  const splitList = (value: string) => 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: SlicerType): string {
   if (process.env.SLICER_PATH) return process.env.SLICER_PATH;
   if (slicerType === DEFAULT_SLICER_TYPE) return DEFAULT_SLICER_PATH;
@@ -545,7 +651,9 @@ function credentialSuggestion(): string {
 class ThreeDPrinterMCPServer {
   private server: Server;
   private readonly blender = new BlenderMcpBridge();
+  private readonly fusion = new FusionMcpBridge();
   private printerFactory: PrinterFactory;
+  private readonly counterpart: CounterpartService;
   private stlManipulator: STLManipulator;
   private readonly runtimeConfig: RuntimeConfig;
   private httpRuntime?: { transport: StreamableHTTPServerTransport; httpServer: HttpServer };
@@ -554,8 +662,8 @@ class ThreeDPrinterMCPServer {
     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: {
@@ -566,6 +674,12 @@ 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();
@@ -674,6 +788,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;
@@ -717,7 +832,18 @@ class ThreeDPrinterMCPServer {
 
     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);
 
@@ -729,7 +855,8 @@ class ThreeDPrinterMCPServer {
       undefined, // progressCallback
       printerPreset,
       filamentProfile,
-      options
+      options,
+      processOverrides
     );
   }
 
@@ -1088,6 +1215,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.",
@@ -1823,6 +1999,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,
           }
         ]
       };
@@ -1846,7 +2078,40 @@ class ThreeDPrinterMCPServer {
       try {
         let result;
 
+        const target: PrinterTarget = {
+          type, host, port,
+          apiKey: type.toLowerCase() === "bambu" ? `${bambuSerial}:${bambuToken}` : apiKey,
+        };
+        const structured = (value: object) => ({
+          content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }],
+          structuredContent: value as Record<string, unknown>,
+        });
+
         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 as string | undefined,
+              timeoutMs: args?.timeout_ms as number | undefined,
+            }));
+          }
+
+          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;
@@ -1874,13 +2139,13 @@ 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(
+            result = withJobName(await this.uploadGcode(
               host, port, type, apiKey, bambuSerial, bambuToken,
               uploadFilename,
               uploadGcodeSource,
               Boolean(args.print || false),
               uploadOptions
-            );
+            ), uploadFilename);
             break;
             
           case "start_print":
@@ -1891,7 +2156,10 @@ class ThreeDPrinterMCPServer {
             if (type.toLowerCase() === "bambu") {
               startOptions.bambuModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
             }
-            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":
@@ -2534,6 +2802,18 @@ 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;
@@ -2584,7 +2864,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
         };
       }
@@ -2765,6 +3046,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 };
     }
@@ -2828,6 +3118,11 @@ class ThreeDPrinterMCPServer {
   private async connectStdio(): Promise<void> {
     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");
   }
 
@@ -2953,8 +3248,17 @@ class ThreeDPrinterMCPServer {
     return value;
   }
 
-  async close(): Promise<void> {
+  private closing?: Promise<void>;
+
+  /** Idempotent: a signal and stdin EOF can both arrive. */
+  close(): Promise<void> {
+    this.closing ??= this.closeOnce();
+    return this.closing;
+  }
+
+  private async closeOnce(): Promise<void> {
     await this.printerFactory.disconnectAll();
+    await this.fusion.close();
 
     if (this.httpRuntime) {
       await this.httpRuntime.transport.close();

package/src/printers/creality.ts

@@ -1,7 +1,20 @@
-import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+import type { AxiosInstance } from "axios";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import { KlipperImplementation, MACRO_TIMEOUT_MS } from "./klipper.js";
+import type { ConfirmHardware } from "../safety/confirmation.js";
+import type { CounterpartProgress, FilamentSlot, PrinterIdentity } from "../counterpart/contract.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 * 60_000;
+
 const IDLE_STATES = new Set(["idle", "ready", "standby", "operational"]);
 const FINISHED_STATES = new Set(["complete", "completed", "finished", "finish", "cancelled", "canceled", "stopped"]);
 
@@ -13,6 +26,76 @@ const FINISHED_STATES = new Set(["complete", "completed", "finished", "finish",
  */
 export class CrealityImplementation extends GenericPrinterImplementation {
   protected readonly printerLabel = "Creality";
+  private readonly moonraker: KlipperImplementation;
+  private readonly probes = new Map<string, { port?: string; at: number }>();
+  /** Ports probed for Moonraker, in order. */
+  moonrakerPorts: string[] = [...CREALITY_MOONRAKER_PORTS];
+
+  constructor(apiClient: AxiosInstance, confirm?: ConfirmHardware) {
+    super(apiClient, confirm);
+    this.moonraker = new KlipperImplementation(apiClient, confirm);
+  }
+
+  /** The Moonraker port that answers /server/info on this host, if any. */
+  async moonrakerPort(host: string): Promise<string | undefined> {
+    const cached = this.probes.get(host);
+    if (cached && Date.now() - cached.at < MOONRAKER_PROBE_TTL_MS) return cached.port;
+    let found: string | undefined;
+    for (const port of this.moonrakerPorts) {
+      try {
+        const info = (await this.apiClient.get(`http://${host}:${port}/server/info`, { timeout: 2_000 })).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: string, port: string, apiKey: string): Promise<CounterpartProgress> {
+    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: string): Promise<boolean> {
+    return (await this.moonrakerPort(host)) !== undefined;
+  }
+
+  async supportsPauseResume(host: string): Promise<boolean> {
+    return (await this.moonrakerPort(host)) !== undefined;
+  }
+
+  async snapshotCandidates(host: string): Promise<SnapshotCandidate[]> {
+    const moonraker = await this.moonrakerPort(host);
+    return moonraker ? this.moonraker.snapshotCandidates(host, moonraker, "") : [];
+  }
+
+  async counterpartFilaments(host: string, port: string, apiKey: string): Promise<FilamentSlot[]> {
+    const moonraker = await this.moonrakerPort(host);
+    return moonraker ? this.moonraker.counterpartFilaments(host, moonraker, "") : super.counterpartFilaments(host, port, apiKey);
+  }
+
+  async counterpartIdentity(host: string): Promise<PrinterIdentity> {
+    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. */
+  protected async rawPauseJob(host: string) {
+    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 as any, { timeout: MACRO_TIMEOUT_MS })).data;
+  }
+
+  protected async rawResumeJob(host: string) {
+    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 as any, { timeout: MACRO_TIMEOUT_MS })).data;
+  }
 
   protected async readPrinterState(host: string, port: string, apiKey: string): Promise<GenericPrinterState> {
     let data: any;

package/src/printers/duet.ts

@@ -1,5 +1,13 @@
 import fs from "fs";
+import { isAxiosError } from "axios";
 import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+import type { CounterpartProgress, PrinterIdentity } from "../counterpart/contract.js";
+import { nonEmptyText } from "../counterpart/contract.js";
+import { mapDuet } from "../counterpart/progress.js";
+
+function notFound(error: unknown): boolean {
+  return isAxiosError(error) && (error.response?.status === 404 || error.response?.status === 405);
+}
 
 /**
  * Duet Software Framework (DuetWebServer) REST routes, verified against
@@ -25,6 +33,65 @@ 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
+   */
+  private async objectModel(host: string, port: string, keys: string[]): Promise<Record<string, any>> {
+    const base = `http://${host}:${port}`;
+    const model: Record<string, any> = {};
+    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: string, port: string, apiKey: string): Promise<CounterpartProgress> {
+    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(): Promise<boolean> {
+    return true;
+  }
+
+  async counterpartIdentity(host: string, port: string): Promise<PrinterIdentity> {
+    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. */
+  protected async rawPauseJob(host: string, port: string) {
+    return this.sendGcode(host, port, "M25");
+  }
+
+  protected async rawResumeJob(host: string, port: string) {
+    return this.sendGcode(host, port, "M24");
+  }
+
+  private async sendGcode(host: string, port: string, gcode: string) {
+    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: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/machine/status`;
     const response = await this.apiClient.get(url);