bambu-printer-mcp 1.1.13 → 1.1.15

package/src/printers/bambu.ts

@@ -62,13 +62,13 @@ const MODEL_ID_TO_NAME: Record<string, string> = {
   C13: "X1E",
 };
 
-const H2_MODEL_NAMES = new Set(["h2", "h2c", "h2d", "h2dpro", "h2d pro", "h2s"]);
+const H2_MODEL_NAMES = new Set(["h2", "h2c", "h2d", "h2dpro", "h2d pro", "h2s", "x2d"]);
 
 export function assertDirectPrintSupported(model: string | undefined, serial?: string): void {
   if (model?.trim().toLowerCase() === "x2d" || serial?.trim().toUpperCase().startsWith("20P")) {
     throw new Error(
-      "X2D direct printing is not supported pending native eMMC transport support. " +
-      "X2D status and slicing remain available; use a supported slicer to print."
+      "X2D direct printing is not supported through legacy MQTT/FTPS. Use the macOS native eMMC route via print_3mf. " +
+      "X2D status and slicing remain available on all supported platforms."
     );
   }
 }
@@ -251,9 +251,18 @@ class TolerantBambuClient extends BambuClient {
   }
 }
 
-/** Build FTPS secureOptions that include the client cert+key when available. */
-function ftpsSecureOptions(): Record<string, unknown> {
-  const opts: Record<string, unknown> = { rejectUnauthorized: false };
+/**
+ * Build FTPS secureOptions that include the client cert+key when available.
+ *
+ * `host` must be included: basic-ftp opens each data connection by wrapping
+ * a plain socket with tls.connect(tlsOptions), and without a host Node can bind
+ * the resumable session to "localhost" instead of the printer host. Printers
+ * that require TLS session reuse (vsftpd require_ssl_reuse, e.g. X2D) refuse
+ * to resume the session and reply "522 SSL connection failed: session reuse
+ * required", failing every LIST, STOR and RETR.
+ */
+function ftpsSecureOptions(host: string): Record<string, unknown> {
+  const opts: Record<string, unknown> = { rejectUnauthorized: false, host };
   if (CLIENT_CREDS) {
     opts.cert = CLIENT_CREDS.cert;
     opts.key = CLIENT_CREDS.key;
@@ -882,13 +891,14 @@ export class BambuImplementation {
     };
   }
 
-  async cancelJob(host: string, serial: string, token: string): Promise<any> {
+  async cancelJob(host: string, serial: string, token: string, dispatch?: () => Promise<any>): Promise<any> {
     cancelPendingPrinterOperations(host, serial);
     this.checkedJobs.delete(`${host}\n${serial}`);
-    const printer = await this.getPrinter(host, serial, token);
+    const printer = dispatch ? undefined : await this.getPrinter(host, serial, token);
 
     try {
-      await invokeWithoutAck(printer, new UpdateStateCommand({ state: "stop" }));
+      if (dispatch) return await dispatch();
+      else await invokeWithoutAck(printer!, new UpdateStateCommand({ state: "stop" }));
       this.checkedJobs.delete(`${host}\n${serial}`);
       return { status: "success", message: "Cancel command sent successfully." };
     } catch (error) {
@@ -896,34 +906,41 @@ export class BambuImplementation {
     }
   }
 
-  async pauseJob(host: string, serial: string, token: string): Promise<any> {
-    const printer = await this.getPrinter(host, serial, token);
+  async pauseJob(host: string, serial: string, token: string, dispatch?: () => Promise<any>): Promise<any> {
+    const printer = dispatch ? undefined : await this.getPrinter(host, serial, token);
     try {
-      await invokeWithoutAck(printer, new UpdateStateCommand({ state: "pause" }));
+      if (dispatch) return await dispatch();
+      else await invokeWithoutAck(printer!, new UpdateStateCommand({ state: "pause" }));
       return { status: "success", message: "Pause command sent successfully." };
     } catch (error) {
       throw new Error(`Failed to pause print: ${(error as Error).message}`);
     }
   }
 
-  async resumeJob(host: string, serial: string, token: string): Promise<any> {
+  async resumeJob(host: string, serial: string, token: string, dispatch?: (assertActive: () => void, beforeDispatch: () => Promise<void>) => Promise<any>): Promise<any> {
     return withPrinterOperation(host, serial, async assertActive => {
       const checked = this.checkedJobs.get(`${host}\n${serial}`);
       if (!checked) throw new Error("Resume requires a job inspected and started by this server instance. Verify other jobs on the printer before resuming them there.");
-      const status = await this.getSafetyStatus(host, serial, token);
-      validatePrinterState(status, { ...checked.requirements, requireIdle: false });
-      if (status.raw.gcode_state !== "PAUSE") throw new Error("Resume requires a freshly reported paused job.");
-      const stem = (value: string) => path.posix.basename(value).replace(/(?:\.gcode)?\.3mf$|\.gcode$/i, "");
-      const names = [status.raw.gcode_file, status.raw.subtask_name].filter(value => typeof value === "string");
-      if (!names.some(value => stem(value) === stem(checked.remotePath))) throw new Error("Paused job identity does not match this server's inspected artifact.");
-      const printer = await this.getPrinter(host, serial, token);
+      const beforeDispatch = async () => {
+        assertActive();
+        const status = await this.getSafetyStatus(host, serial, token);
+        validatePrinterState(status, { ...checked.requirements, requireIdle: false });
+        if (status.raw.gcode_state !== "PAUSE") throw new Error("Resume requires a freshly reported paused job.");
+        const stem = (value: string) => path.posix.basename(value).replace(/(?:\.gcode)?\.3mf$|\.gcode$/i, "");
+        const names = [status.raw.gcode_file, status.raw.subtask_name].filter(value => typeof value === "string");
+        if (!names.some(value => stem(value) === stem(checked.remotePath))) throw new Error("Paused job identity does not match this server's inspected artifact.");
+        assertActive();
+      };
+      await beforeDispatch();
+      const printer = dispatch ? undefined : await this.getPrinter(host, serial, token);
       assertActive();
-      await invokeWithoutAck(printer, new UpdateStateCommand({ state: "resume" }));
+      if (dispatch) await dispatch(assertActive, beforeDispatch);
+      else await invokeWithoutAck(printer!, new UpdateStateCommand({ state: "resume" }));
       return { status: "success", message: "Resume command sent successfully." };
     });
   }
 
-  async clearHmsErrors(host: string, serial: string, token: string): Promise<any> {
+  async clearHmsErrors(host: string, serial: string, token: string, dispatch?: (assertActive: () => void, beforeDispatch: () => Promise<void>) => Promise<any>): Promise<any> {
     return withPrinterOperation(host, serial, async assertActive => {
       const codesFor = (status: any): string[] => {
         if (!Array.isArray(status.raw?.hms) || status.raw?.print_error === undefined) throw new Error("Fresh error codes are required before clearing hardware errors.");
@@ -931,11 +948,17 @@ export class BambuImplementation {
       };
       const codes = codesFor(await this.getSafetyStatus(host, serial, token));
       await this.confirmHardwareAction(`Clear reported hardware errors on ${serial}: ${codes.join(", ")}? Inspect the printer and resolve the physical cause first. Confirm only after removing obstructions and correcting the fault.`, true);
-      const current = codesFor(await this.getSafetyStatus(host, serial, token));
-      if (JSON.stringify(current) !== JSON.stringify(codes)) throw new Error("Hardware errors changed during confirmation. Inspect the new report before retrying.");
-      const printer = await this.getPrinter(host, serial, token);
+      const beforeDispatch = async () => {
+        assertActive();
+        const current = codesFor(await this.getSafetyStatus(host, serial, token));
+        if (JSON.stringify(current) !== JSON.stringify(codes)) throw new Error("Hardware errors changed before clearing. Inspect the new report before retrying.");
+        assertActive();
+      };
+      await beforeDispatch();
+      const printer = dispatch ? undefined : await this.getPrinter(host, serial, token);
       assertActive();
-      await printer.publish({ print: { command: "clean_print_error", sequence_id: "0" } });
+      if (dispatch) await dispatch(assertActive, beforeDispatch);
+      else await printer!.publish({ print: { command: "clean_print_error", sequence_id: "0" } });
       this.clearedErrors.set(serial, codes);
       await sleep(COMMAND_SETTLE_MS);
       return { status: "success", message: "Confirmed HMS clear command sent. The next print requires acknowledgment of these cleared codes.", cleared_codes: codes };
@@ -1004,9 +1027,8 @@ export class BambuImplementation {
     amsId: number,
     slotId: number
   ): Promise<any> {
-    const printer = await this.getPrinter(host, serial, token);
-    const normalizedAmsId = Math.trunc(amsId);
-    const normalizedSlotId = Math.trunc(slotId);
+    const normalizedAmsId = amsId;
+    const normalizedSlotId = slotId;
 
     if (!Number.isInteger(normalizedAmsId) || normalizedAmsId < 0 || normalizedAmsId > 3) {
       throw new Error("ams_id must be an integer from 0 to 3.");
@@ -1015,6 +1037,7 @@ export class BambuImplementation {
       throw new Error("slot_id must be an integer from 0 to 3.");
     }
 
+    const printer = await this.getPrinter(host, serial, token);
     await printer.publish({
       print: {
         command: "ams_get_rfid",
@@ -1040,7 +1063,8 @@ export class BambuImplementation {
     temperature: unknown,
     bambuModel?: string,
     material?: string,
-    nozzleDiameter = 0.4
+    nozzleDiameter = 0.4,
+    dispatch?: (heater: "bed" | "nozzle", target: number, assertActive: () => void, beforeDispatch?: () => Promise<void>) => Promise<any>
   ) {
     const normalizedComponent = component.toLowerCase();
     const heater = normalizedComponent === "bed" ? "bed" :
@@ -1061,20 +1085,26 @@ export class BambuImplementation {
     const targetTemperature = temperature === 0 ? 0 : validateTemperature(heater, temperature, model!, material ? [material] : undefined);
     const gcode = `${heater === "bed" ? "M140" : "M104"}${heater === "nozzle" && targetTemperature > 0 ? " T0" : ""} S${targetTemperature}`;
     const send = async (assertActive: () => void) => {
+      let beforeDispatch: (() => Promise<void>) | undefined;
       if (targetTemperature > 0) {
         const status = await this.getSafetyStatus(host, serial, token);
-        validatePrinterState(status, heater === "nozzle"
-          ? manualHeatingRequirements(status, model!, nozzleDiameter, material!)
+        const validateHeatingStatus = (current: any) => validatePrinterState(current, heater === "nozzle"
+          ? manualHeatingRequirements(current, model!, nozzleDiameter, material!)
           : { model: model!, nozzleDiameters: [] });
+        validateHeatingStatus(status);
         await this.confirmHardwareAction(`Heat ${heater} on ${model!.toUpperCase()} (${serial}) to ${targetTemperature}°C?${material ? ` Declared material: ${material}. Confirm the physical spool label.` : ""}`);
-        const confirmedStatus = await this.getSafetyStatus(host, serial, token);
-        validatePrinterState(confirmedStatus, heater === "nozzle"
-          ? manualHeatingRequirements(confirmedStatus, model!, nozzleDiameter, material!)
-          : { model: model!, nozzleDiameters: [] });
+        beforeDispatch = async () => {
+          assertActive();
+          const confirmedStatus = await this.getSafetyStatus(host, serial, token);
+          validateHeatingStatus(confirmedStatus);
+          assertActive();
+        };
+        await beforeDispatch();
       }
-      const printer = await this.getPrinter(host, serial, token);
+      const printer = dispatch ? undefined : await this.getPrinter(host, serial, token);
       assertActive();
-      await invokeWithoutAck(printer, new GCodeLineCommand({ gcodes: [gcode] }));
+      if (dispatch) await dispatch(heater, targetTemperature, assertActive, beforeDispatch);
+      else await invokeWithoutAck(printer!, new GCodeLineCommand({ gcodes: [gcode] }));
       return { status: "success", message: `Temperature command sent for ${normalizedComponent}.`, command: gcode };
     };
     if (targetTemperature === 0) {
@@ -1164,18 +1194,18 @@ export class BambuImplementation {
     action: string,
     amsId: number
   ): Promise<any> {
-    const printer = await this.getPrinter(host, serial, token);
     const normalizedAction = action.trim().toLowerCase();
     if (normalizedAction !== "start" && normalizedAction !== "stop") {
       throw new Error("AMS drying action must be one of: start, stop.");
     }
 
-    const normalizedAmsId = Math.trunc(amsId);
+    const normalizedAmsId = amsId;
     if (!Number.isInteger(normalizedAmsId) || normalizedAmsId < 0 || normalizedAmsId > 3) {
       throw new Error("ams_id must be an integer from 0 to 3.");
     }
 
     const param = normalizedAction === "start" ? "start_drying" : "stop_drying";
+    const printer = await this.getPrinter(host, serial, token);
     await printer.publish({
       print: {
         command: "ams_control",
@@ -1227,19 +1257,32 @@ export class BambuImplementation {
   }
 
   async getFiles(host: string, serial: string, token: string) {
-    const printer = new BambuPrinter(host, serial, token);
+    const client = new FTPClient(15_000);
     const directories = ["cache", "timelapse", "logs"];
     const filesByDirectory: Record<string, string[]> = {};
 
-    await printer.manipulateFiles(async (context) => {
+    try {
+      await client.access({
+        host,
+        port: 990,
+        user: "bblp",
+        password: token,
+        secure: "implicit",
+        secureOptions: ftpsSecureOptions(host),
+      });
+      await this.waitForTlsSession(client);
+      // Discover absent optional directories without creating them or treating
+      // ambiguous FTP 550 responses (including permission errors) as emptiness.
+      const root = await client.list("/");
       for (const directory of directories) {
-        try {
-          filesByDirectory[directory] = await context.readDir(directory);
-        } catch {
-          filesByDirectory[directory] = [];
-        }
+        const present = root.some(entry => entry.name === directory && (entry.isDirectory || entry.isSymbolicLink));
+        filesByDirectory[directory] = present
+          ? (await client.list(`/${directory}`)).map(entry => entry.name)
+          : [];
       }
-    });
+    } finally {
+      client.close();
+    }
 
     const files = Object.entries(filesByDirectory).flatMap(([directory, names]) =>
       names.map((name) => `${directory}/${name}`)
@@ -1273,7 +1316,8 @@ export class BambuImplementation {
 
   async uploadFile(
     host: string, serial: string, token: string, filePath: string,
-    filename: string, print: boolean, bambuModel?: string
+    filename: string, print: boolean, bambuModel?: string,
+    upload?: (snapshot: string, destination: string, assertActive: () => void) => Promise<void>
   ) {
     const remotePath = normalizedRemotePath(filename);
     if (!print) {
@@ -1315,7 +1359,8 @@ export class BambuImplementation {
         }
         assertActive();
         const destination = path.posix.join(path.posix.dirname(remotePath), uniquePrintName(remotePath));
-        await this.ftpUpload(host, token, snapshot, `/${destination}`);
+        if (upload) await upload(snapshot, destination, assertActive);
+        else await this.ftpUpload(host, token, snapshot, `/${destination}`);
         return { status: "success", uploaded: true, remotePath: destination, printRequested: false, inspected: printable };
       }));
     }
@@ -1374,7 +1419,7 @@ export class BambuImplementation {
   private async ftpDownload(host: string, token: string, remotePath: string, localPath: string): Promise<void> {
     const client = new FTPClient(15_000);
     try {
-      await client.access({ host, port: 990, user: "bblp", password: token, secure: "implicit", secureOptions: ftpsSecureOptions() });
+      await client.access({ host, port: 990, user: "bblp", password: token, secure: "implicit", secureOptions: ftpsSecureOptions(host) });
       await this.waitForTlsSession(client);
       const size = await client.size(`/${remotePath}`);
       if (!Number.isFinite(size) || size <= 0 || size > 512 * 1024 * 1024) throw new Error("Remote print file is empty or exceeds the 512 MiB inspection limit.");
@@ -1404,8 +1449,8 @@ export class BambuImplementation {
    *     [16..16+payloadSize] JPEG (FF D8 ... FF D9)
    *
    * Verified models per upstream docs: A1, A1 mini, P1S, P1P. X1/X1C/X1E
-   * and P2S use RTSP on port 322 instead. H2/H2S/H2D/H2C
-   * are not documented; we fail fast rather than guess at the protocol.
+   * and P2S use RTSP on port 322 instead. H2/H2S/H2D/H2C/X2D
+   * use the same RTSP path.
    *
    * Read-only; no confirm gate. Default 8s timeout for cold-start latency.
    */
@@ -1508,18 +1553,21 @@ export class BambuImplementation {
 
   /**
    * Pull a single JPEG frame from the printer's RTSP/RTSPS stream using
-   * ffmpeg. Used for X1, P2S, and H2 series.
+   * ffmpeg. Used for X1, P2S, H2-family printers, and X2D.
    *
    * URL pattern verified against HA bambulab's models.py example:
    *   rtsps://bblp:<access_code>@<host>:322/streaming/live/1
    *
    * ffmpeg invocation:
-   *   ffmpeg -rtsp_transport tcp -i <url> -frames:v 1 -f image2 -c:v mjpeg -y <out>
+   *   ffmpeg -tls_verify 0 -rtsp_transport tcp -i <url> -frames:v 1 -f image2 -c:v mjpeg -y <out>
    *
-   * -rtsp_transport tcp avoids UDP NAT/firewall issues. -frames:v 1
-   * makes ffmpeg exit as soon as one frame lands. -y overwrites the temp
-   * file. The Bambu printer presents a self-signed cert; ffmpeg's TLS
-   * layer accepts that by default (no host verification).
+   * -tls_verify 0 accepts the printer's self-signed certificate. This is
+   * consistent with the existing local-device TLS/FTPS paths, which do not
+   * have a public CA chain or hostname that ffmpeg can validate. The
+   * connection is still encrypted and remains scoped to the configured
+   * printer host. -rtsp_transport tcp avoids UDP NAT/firewall issues.
+   * -frames:v 1 makes ffmpeg exit as soon as one frame lands. -y overwrites
+   * the temp file.
    */
   private async fetchRtspCameraFrame(
     host: string,
@@ -1540,6 +1588,7 @@ export class BambuImplementation {
     // have to detect ffmpeg version. -rtsp_transport tcp avoids UDP NAT
     // headaches; -frames:v 1 makes ffmpeg exit on first frame.
     const args = [
+      "-tls_verify", "0",
       "-rtsp_transport", "tcp",
       "-i", url,
       "-frames:v", "1",
@@ -1768,7 +1817,7 @@ export class BambuImplementation {
         user: "bblp",
         password: token,
         secure: "implicit",
-        secureOptions: ftpsSecureOptions(),
+        secureOptions: ftpsSecureOptions(host),
       });
       await this.waitForTlsSession(client);
       const absoluteRemote = remotePath.startsWith("/") ? remotePath : `/${remotePath}`;
@@ -1798,7 +1847,7 @@ export class BambuImplementation {
         user: "bblp",
         password: token,
         secure: "implicit",
-        secureOptions: ftpsSecureOptions(),
+        secureOptions: ftpsSecureOptions(host),
       });
       // With TLS 1.3 the session ticket arrives asynchronously; basic-ftp calls
       // getSession() when opening the data channel and gets undefined if the