mcp-3d-printer-server 1.0.2 → 1.2.1

package/src/printers/bambu.ts

@@ -1,356 +1,509 @@
-import { PrinterImplementation, BambuPrinterStore, BambuFTP } from "../types.js";
-import { BambuPrinter } from "bambu-js"; // Keep for FTP manipulation
-import * as mqtt from 'mqtt'; // Import MQTT library
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as tls from 'tls'; // Needed for TLS connection
-
-// Define interface for MQTT client store if needed
-interface MqttClientStore {
-    [key: string]: mqtt.MqttClient;
+import { PrinterImplementation } from "../types.js";
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import JSZip from "jszip";
+import { Client as FTPClient } from "basic-ftp";
+import { BambuPrinter } from "bambu-js";
+import {
+  BambuClient,
+  GCodeFileCommand,
+  GCodeLineCommand,
+  PushAllCommand,
+  UpdateStateCommand,
+} from "bambu-node";
+
+interface BambuPrintOptionsInternal {
+  projectName: string;
+  filePath: string;
+  useAMS?: boolean;
+  plateIndex?: number;
+  bedType?: string;
+  bedLeveling?: boolean;
+  flowCalibration?: boolean;
+  vibrationCalibration?: boolean;
+  layerInspect?: boolean;
+  timelapse?: boolean;
+  amsMapping?: number[];
+  md5?: string;
 }
 
-// Define interface for print options matching OpenBambuAPI spec
-interface BambuPrintCommandOptions {
-    sequence_id: string;
-    command: "project_file";
-    param: string; // Path on printer, e.g., gcodes/filename.3mf
-    project_name: string; // Name of the project (often derived from filename)
-    project_id?: string; // Default "0" for local
-    profile_id?: string; // Default "0"
-    task_id?: string; // Default "0"
-    subtask_id?: string; // Default "0"
-    subtask_name?: string; // Default ""
-    url?: string; // Optional: file:///mnt/sdcard/gcodes/filename.3mf (can override param?)
-    md5?: string; // MD5 hash of the file (optional but recommended)
-    timelapse?: boolean;
-    bed_type?: string; // Default "auto"
-    bed_levelling?: boolean;
-    flow_cali?: boolean;
-    vibration_cali?: boolean;
-    layer_inspect?: boolean;
-    ams_mapping?: number[]; // Array of AMS slot indices (e.g., [0, 1, 2, 3]) - Needs verification how this maps to filaments
-    use_ams?: boolean;
-    plate_idx?: number; // Add missing property
+interface ProjectFileMetadata {
+  plateFileName: string;
+  plateInternalPath: string;
+  md5: string;
 }
 
-// Define interface for print options including overrides passed from index.ts
-interface BambuPrintOptionsInternal {
-    projectName: string;
-    filePath: string; // Path to the local .3mf file
-    // Base options from OpenBambuAPI spec
-    useAMS?: boolean;
-    plateIndex?: number;
-    bedLeveling?: boolean;
-    flowCalibration?: boolean;
-    vibrationCalibration?: boolean;
-    layerInspect?: boolean;
-    timelapse?: boolean;
-    // Overrides / parsed data
-    amsMapping?: number[]; // Explicit mapping (from user override or parsed 3MF)
-    md5?: string; // Optional MD5 hash of the file
+class BambuClientStore {
+  private printers: Map<string, BambuClient> = new Map();
+  private initialConnectionPromises: Map<string, Promise<void>> = new Map();
+
+  async getPrinter(host: string, serial: string, token: string): Promise<BambuClient> {
+    const key = `${host}-${serial}`;
+
+    if (this.printers.has(key)) {
+      return this.printers.get(key)!;
+    }
+
+    if (this.initialConnectionPromises.has(key)) {
+      await this.initialConnectionPromises.get(key);
+      if (this.printers.has(key)) {
+        return this.printers.get(key)!;
+      }
+      throw new Error(`Existing Bambu client connection for ${key} failed.`);
+    }
+
+    const printer = new BambuClient({
+      host,
+      serialNumber: serial,
+      accessToken: token,
+    });
+
+    printer.on("client:connect", () => {
+      this.printers.set(key, printer);
+      this.initialConnectionPromises.delete(key);
+    });
+
+    printer.on("client:error", () => {
+      this.printers.delete(key);
+      this.initialConnectionPromises.delete(key);
+    });
+
+    printer.on("client:disconnect", () => {
+      this.printers.delete(key);
+      this.initialConnectionPromises.delete(key);
+    });
+
+    const connectPromise = printer.connect().then(() => {});
+    this.initialConnectionPromises.set(key, connectPromise);
+
+    try {
+      await connectPromise;
+      return printer;
+    } catch (error) {
+      this.initialConnectionPromises.delete(key);
+      throw error;
+    }
+  }
+
+  async disconnectAll(): Promise<void> {
+    const disconnectPromises: Promise<void>[] = [];
+
+    for (const printer of this.printers.values()) {
+      disconnectPromises.push(
+        (async () => {
+          try {
+            await printer.disconnect();
+          } catch (error) {
+            console.error("Failed to disconnect Bambu client", error);
+          }
+        })()
+      );
+    }
+
+    await Promise.allSettled(disconnectPromises);
+    this.printers.clear();
+    this.initialConnectionPromises.clear();
+  }
 }
 
 export class BambuImplementation extends PrinterImplementation {
-  private bambuPrinterStore: BambuPrinterStore;
-  private mqttClients: MqttClientStore = {}; // Store connected MQTT clients
-  private mqttConnectionPromises: { [key: string]: Promise<mqtt.MqttClient> } = {}; // Track connection attempts
+  private printerStore: BambuClientStore;
 
-  constructor(apiClient: any, bambuPrinterStore: BambuPrinterStore) {
+  constructor(apiClient: any) {
     super(apiClient);
-    this.bambuPrinterStore = bambuPrinterStore;
+    this.printerStore = new BambuClientStore();
   }
 
-  // Get BambuPrinter instance for FTP
-  private getBambuPrinterForFTP(host: string, serial: string, token: string): InstanceType<typeof BambuPrinter> {
-    // This still uses bambu-js just for the FTP part
-    return this.bambuPrinterStore.get(host, serial, token);
+  private async getPrinter(host: string, serial: string, token: string): Promise<BambuClient> {
+    return this.printerStore.getPrinter(host, serial, token);
   }
 
-  // Get or establish MQTT connection
-  private async getMqttClient(host: string, serial: string, token: string): Promise<mqtt.MqttClient> {
-      const clientKey = `${host}-${serial}`;
-      
-      if (this.mqttClients[clientKey] && this.mqttClients[clientKey].connected) {
-          return this.mqttClients[clientKey];
-      }
+  private async resolveProjectFileMetadata(
+    localThreeMfPath: string,
+    plateIndex?: number
+  ): Promise<ProjectFileMetadata> {
+    const archive = await fs.readFile(localThreeMfPath);
+    const zip = await JSZip.loadAsync(archive);
+
+    const plateEntries = Object.values(zip.files).filter(
+      (entry) => !entry.dir && /^Metadata\/plate_\d+\.gcode$/i.test(entry.name)
+    );
+
+    if (plateEntries.length === 0) {
+      throw new Error(
+        "3MF does not contain any Metadata/plate_<n>.gcode entries. Re-slice and export a printable 3MF."
+      );
+    }
 
-      // If a connection attempt is already in progress, wait for it
-      if (this.mqttConnectionPromises[clientKey] !== undefined) {
-            console.log(`Waiting for existing MQTT connection attempt to ${clientKey}...`);
-            return this.mqttConnectionPromises[clientKey];
+    let selectedEntry = plateEntries.sort((a, b) => a.name.localeCompare(b.name))[0];
+
+    if (plateIndex !== undefined) {
+      const expectedEntryName = `Metadata/plate_${plateIndex + 1}.gcode`;
+      const matchedEntry = plateEntries.find(
+        (entry) => entry.name.toLowerCase() === expectedEntryName.toLowerCase()
+      );
+
+      if (!matchedEntry) {
+        const available = plateEntries.map((entry) => entry.name).join(", ");
+        throw new Error(
+          `Requested plateIndex=${plateIndex} (${expectedEntryName}) not present in 3MF. Available: ${available}`
+        );
       }
 
-      console.log(`Attempting to establish new MQTT connection to ${host} for ${serial}...`);
-      const connectPromise = new Promise<mqtt.MqttClient>((resolve, reject) => {
-            // Use port 8883 and TLS
-            const mqttOptions: mqtt.IClientOptions = {
-                port: 8883,
-                host: host,
-                protocol: 'mqtts',
-                username: 'bblp', // As per OpenBambuAPI docs
-                password: token,
-                clientId: `mcp_client_${serial}_${Date.now()}`,
-                rejectUnauthorized: false, // Might be needed for self-signed certs? Test carefully.
-                // ca: [fs.readFileSync('path/to/ca_cert.pem')], // Add CA cert if needed
-                connectTimeout: 10000, // 10 seconds
-                reconnectPeriod: 5000 // Try reconnecting every 5 seconds
-            };
-
-            const client = mqtt.connect(mqttOptions);
-
-            client.on('connect', () => {
-                console.log(`MQTT connected successfully to ${host} for ${serial}`);
-                this.mqttClients[clientKey] = client;
-                // Subscribe to necessary topics (e.g., responses/status)
-                client.subscribe(`device/${serial}/report`, (err) => {
-                    if (err) {
-                        console.error(`Failed to subscribe to report topic for ${serial}:`, err);
-                    }
-                });
-                delete this.mqttConnectionPromises[clientKey]; // Clear promise tracker on success
-                resolve(client);
-            });
-
-            client.on('error', (err) => {
-                console.error(`MQTT connection error for ${serial} on ${host}:`, err);
-                delete this.mqttClients[clientKey]; // Remove potentially bad client
-                delete this.mqttConnectionPromises[clientKey]; // Clear promise tracker on error
-                reject(err);
-            });
-
-            client.on('close', () => {
-                 console.log(`MQTT connection closed for ${serial} on ${host}`);
-                 delete this.mqttClients[clientKey]; // Remove client on close
-            });
-            
-            // Handle status messages from the report topic
-            client.on('message', (topic, message) => {
-                try {
-                    const data = JSON.parse(message.toString());
-                    // Processing logic for status updates would go here
-                    // For now, we just acknowledge receiving it (optional logging)
-                    // console.log(`MQTT message received on ${topic}:`, data?.print?.subtask_name ?? data?.print?.command ?? 'Unknown message type');
-                } catch(e) {
-                    console.error('Failed to parse MQTT message:', e);
-                }
-            });
-      });
-      
-      this.mqttConnectionPromises[clientKey] = connectPromise; // Store the promise
-      return connectPromise;
+      selectedEntry = matchedEntry;
+    }
+
+    const gcodeBuffer = await selectedEntry.async("nodebuffer");
+    const md5 = createHash("md5").update(gcodeBuffer).digest("hex");
+
+    return {
+      plateFileName: path.posix.basename(selectedEntry.name),
+      plateInternalPath: selectedEntry.name,
+      md5,
+    };
   }
 
-  // Disconnect MQTT clients on shutdown
-  async disconnectAllMqtt(): Promise<void> {
-       console.log("Disconnecting all MQTT clients...");
-       for (const key in this.mqttClients) {
-           const client = this.mqttClients[key];
-           if (client) {
-               await new Promise<void>((resolve, reject) => {
-                    client.end(false, {}, (err) => {
-                        if (err) {
-                             console.error(`Error ending MQTT client ${key}:`, err);
-                             reject(err);
-                        } else {
-                             console.log(`MQTT client ${key} disconnected.`);
-                             resolve();
-                        }
-                    });
-               });
-           }
-       }
-       this.mqttClients = {};
-       this.mqttConnectionPromises = {};
-   }
-
-  // --- getStatus (Limited Implementation) ---
   async getStatus(host: string, port: string, apiKey: string): Promise<any> {
     const [serial, token] = this.extractBambuCredentials(apiKey);
+
     try {
-        // Ensure MQTT connection is attempted/established
-        const client = await this.getMqttClient(host, serial, token);
-        // Return minimal status indicating connection success
-        // Full status requires implementing state storage based on /report topic messages
-        return { 
-            status: client.connected ? "connected" : "connecting", 
-            serial: serial, 
-            note: "Full status details require MQTT state tracking implementation."
-        }; 
+      const printer = await this.getPrinter(host, serial, token);
+
+      try {
+        await printer.executeCommand(new PushAllCommand());
+      } catch (error) {
+        console.warn("PushAllCommand failed, continuing with cached status", error);
+      }
+
+      if (!printer.data || Object.keys(printer.data).length === 0) {
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+      }
+
+      const data = printer.data;
+
+      return {
+        status: data.gcode_state || "UNKNOWN",
+        connected: true,
+        temperatures: {
+          nozzle: {
+            actual: data.nozzle_temper || 0,
+            target: data.nozzle_target_temper || 0,
+          },
+          bed: {
+            actual: data.bed_temper || 0,
+            target: data.bed_target_temper || 0,
+          },
+          chamber: data.chamber_temper || data.frame_temper || 0,
+        },
+        print: {
+          filename: data.subtask_name || data.gcode_file || "None",
+          progress: data.mc_percent || 0,
+          timeRemaining: data.mc_remaining_time || 0,
+          currentLayer: data.layer_num || 0,
+          totalLayers: data.total_layer_num || 0,
+        },
+        ams: data.ams || null,
+        model: data.model || "Unknown",
+        serial,
+        raw: data,
+      };
     } catch (error) {
-         console.error(`Failed to get MQTT client/status for ${serial}:`, error);
-         return { status: "error", error: (error as Error).message };
+      console.error(`Failed to get Bambu status for ${serial}:`, error);
+      return { status: "error", connected: false, error: (error as Error).message };
     }
   }
-  
-  // --- Refactored print3mf using direct MQTT ---
-  async print3mf(host: string, serial: string, token: string, options: BambuPrintOptionsInternal): Promise<any> {
-
-    // Still use bambu-js for FTP upload
-    const printerFTP = this.getBambuPrinterForFTP(host, serial, token);
-    const remoteFilename = path.basename(options.filePath);
-    // Ensure path uses forward slashes for printer consistency
-    const remotePath = `gcodes/${remoteFilename}`.replace(/\\/g, '/'); 
-
-    // 1. Connect FTP if necessary (via bambu-js helper)
-    if (!printerFTP.isConnected) {
-      console.log(`Connecting Bambu FTP ${host} (${serial}) on port 990 (assumed) before uploading...`);
-      try {
-           await printerFTP.connect(); // Connects MQTT and FTP
-           console.log(`Connected Bambu FTP successfully.`);
-      } catch (ftpConnectError) {
-           console.error(`Bambu FTP Connection Error:`, ftpConnectError);
-           throw new Error(`Failed to connect to Bambu FTP: ${(ftpConnectError as Error).message}`);
-      }
-      // await printerFTP.awaitInitialState(10000); // Might not be needed just for FTP
+
+  async print3mf(
+    host: string,
+    serial: string,
+    token: string,
+    options: BambuPrintOptionsInternal
+  ): Promise<any> {
+    if (!options.filePath.toLowerCase().endsWith(".3mf")) {
+      throw new Error("print3mf requires a .3mf input file.");
     }
 
-    // 2. Upload the file via FTP
-    console.log(`Uploading ${options.filePath} to ${remotePath} via FTP...`);
-    try {
-        await printerFTP.manipulateFiles(async (context: BambuFTP) => {
-            await context.sendFile(options.filePath, remotePath);
-        });
-        console.log(`File ${remoteFilename} uploaded successfully.`);
-    } catch (uploadError) {
-        console.error(`FTP Upload Error:`, uploadError);
-        throw new Error(`Failed to upload 3MF file via FTP: ${(uploadError as Error).message}`);
+    const projectMetadata = await this.resolveProjectFileMetadata(
+      options.filePath,
+      options.plateIndex
+    );
+
+    const remoteFileName = path.basename(options.filePath);
+    const remoteProjectPath = `cache/${remoteFileName}`;
+
+    // Upload via basic-ftp directly (bypasses bambu-js double-path bug)
+    await this.ftpUpload(host, token, options.filePath, `/cache/${remoteFileName}`);
+
+    // Send project_file command via bambu-node MQTT (bypasses bambu-js
+    // hardcoded use_ams=true and missing ams_mapping support)
+    const printer = await this.getPrinter(host, serial, token);
+    const md5 = options.md5 ?? projectMetadata.md5;
+
+    // Build AMS mapping per OpenBambuAPI spec: 5-element array
+    // [-1,-1,-1,-1,0] means slot 0 only; pad unused slots with -1
+    let amsMapping: number[];
+    if (options.amsMapping && options.amsMapping.length > 0) {
+      amsMapping = Array.from({ length: 5 }, (_, i) =>
+        i < options.amsMapping!.length ? options.amsMapping![i] : -1
+      );
+    } else {
+      amsMapping = [-1, -1, -1, -1, 0];
     }
-    
-    // 3. Get MQTT Client
-    const mqttClient = await this.getMqttClient(host, serial, token);
 
-    // 4. Construct the MQTT Print Command Payload based on OpenBambuAPI
-    const commandPayload: BambuPrintCommandOptions = {
-        sequence_id: Date.now().toString(),
+    const projectFileCmd = {
+      print: {
         command: "project_file",
-        param: remotePath, // Path on SD card
-        project_name: options.projectName,
-        use_ams: options.amsMapping && options.amsMapping.length > 0 ? true : (options.useAMS ?? false),
-        plate_idx: options.plateIndex ?? 0,
-        bed_levelling: options.bedLeveling ?? true,
-        flow_cali: options.flowCalibration ?? false,
-        vibration_cali: options.vibrationCalibration ?? false,
-        layer_inspect: options.layerInspect ?? false,
+        param: `Metadata/${projectMetadata.plateFileName}`,
+        url: `file:///sdcard/${remoteProjectPath}`,
+        subtask_name: options.projectName,
+        md5,
+        flow_cali: options.flowCalibration ?? true,
+        layer_inspect: options.layerInspect ?? true,
+        vibration_cali: options.vibrationCalibration ?? true,
+        bed_leveling: options.bedLeveling ?? true,
+        bed_type: options.bedType || "textured_plate",
         timelapse: options.timelapse ?? false,
-        ams_mapping: options.amsMapping,
-        md5: options.md5
+        use_ams: options.useAMS !== false,
+        ams_mapping: amsMapping,
+        profile_id: "0",
+        project_id: "0",
+        sequence_id: "0",
+        subtask_id: "0",
+        task_id: "0",
+      },
     };
-    
-    // Remove ams_mapping if not provided or empty
-    if (!commandPayload.ams_mapping || commandPayload.ams_mapping.length === 0) {
-        delete commandPayload.ams_mapping;
-        // Also ensure use_ams is false if no mapping exists
-        commandPayload.use_ams = false; 
-    }
-    // Remove md5 if not provided
-     if (!commandPayload.md5) {
-         delete commandPayload.md5;
-     }
 
-    // 5. Publish the command
-    return this.publishMqttCommand(mqttClient, serial, 'print', commandPayload);
+    await printer.publish(projectFileCmd);
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    return {
+      status: "success",
+      message: `Uploaded and started 3MF print: ${options.projectName}`,
+      remoteProjectPath,
+      plateFile: projectMetadata.plateFileName,
+      platePath: projectMetadata.plateInternalPath,
+      md5,
+      amsMapping,
+    };
   }
-  
-  // --- Refactored cancelJob using MQTT ---
+
   async cancelJob(host: string, port: string, apiKey: string): Promise<any> {
     const [serial, token] = this.extractBambuCredentials(apiKey);
-    const mqttClient = await this.getMqttClient(host, serial, token);
-    // Command structure from OpenBambuAPI (assuming 'stop_print' is correct)
-    const payload = { sequence_id: Date.now().toString(), command: "stop_print" }; 
-    return this.publishMqttCommand(mqttClient, serial, 'print', payload);
+    const printer = await this.getPrinter(host, serial, token);
+
+    try {
+      await printer.executeCommand(new UpdateStateCommand({ state: "stop" }));
+      return { status: "success", message: "Cancel command sent successfully." };
+    } catch (error) {
+      throw new Error(`Failed to cancel print: ${(error as Error).message}`);
+    }
   }
-  
-  // --- setTemperature (still not directly possible via MQTT command) ---
-  async setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
-     console.warn("Setting temperatures directly is not supported via known Bambu MQTT commands. Use G-code.");
-     // We could potentially implement a tool to send custom G-code?
-     throw new Error("Direct temperature setting via MQTT is not supported.");
+
+  async setTemperature(
+    host: string,
+    port: string,
+    apiKey: string,
+    component: string,
+    temperature: number
+  ) {
+    const [serial, token] = this.extractBambuCredentials(apiKey);
+    const printer = await this.getPrinter(host, serial, token);
+
+    const normalizedComponent = component.toLowerCase();
+    const targetTemperature = Math.round(temperature);
+
+    if (targetTemperature < 0 || targetTemperature > 300) {
+      throw new Error("Temperature must be between 0 and 300°C.");
+    }
+
+    let gcode: string;
+    if (normalizedComponent === "bed") {
+      gcode = `M140 S${targetTemperature}`;
+    } else if (
+      normalizedComponent === "extruder" ||
+      normalizedComponent === "nozzle" ||
+      normalizedComponent === "tool" ||
+      normalizedComponent === "tool0"
+    ) {
+      gcode = `M104 S${targetTemperature}`;
+    } else {
+      throw new Error(
+        `Unsupported temperature component: ${component}. Use one of: bed, nozzle, extruder.`
+      );
+    }
+
+    await printer.executeCommand(new GCodeLineCommand({ gcodes: [gcode] }));
+    return {
+      status: "success",
+      message: `Temperature command sent for ${normalizedComponent}.`,
+      command: gcode,
+    };
   }
-  
-  // --- Other methods (getFiles, getFile, uploadFile, startJob) need review/refactoring ---
-  // For now, keep using bambu-js FTP for file ops, but MQTT for commands
+
   async getFiles(host: string, port: string, apiKey: string) {
     const [serial, token] = this.extractBambuCredentials(apiKey);
-    const printerFTP = this.getBambuPrinterForFTP(host, serial, token);
-    if (!printerFTP.isConnected) await printerFTP.connect();
-    const fileList: string[] = [];
-    await printerFTP.manipulateFiles(async (context: BambuFTP) => {
-        const files = await context.readDir("gcodes");
-        fileList.push(...files);
+    const printer = new BambuPrinter(host, serial, token);
+    const directories = ["cache", "timelapse", "logs"];
+    const filesByDirectory: Record<string, string[]> = {};
+
+    await printer.manipulateFiles(async (context) => {
+      for (const directory of directories) {
+        try {
+          filesByDirectory[directory] = await context.readDir(directory);
+        } catch {
+          filesByDirectory[directory] = [];
+        }
+      }
     });
-    return { files: fileList };
+
+    const files = Object.entries(filesByDirectory).flatMap(([directory, names]) =>
+      names.map((name) => `${directory}/${name}`)
+    );
+
+    return {
+      files,
+      directories: filesByDirectory,
+    };
   }
 
   async getFile(host: string, port: string, apiKey: string, filename: string) {
-    // Still relies on checking existence via FTP
     const [serial, token] = this.extractBambuCredentials(apiKey);
-    const printerFTP = this.getBambuPrinterForFTP(host, serial, token);
-    if (!printerFTP.isConnected) await printerFTP.connect();
-    let fileExists = false;
-    await printerFTP.manipulateFiles(async (context: BambuFTP) => {
-        const files = await context.readDir("gcodes");
-        fileExists = files.includes(filename);
+    const printer = new BambuPrinter(host, serial, token);
+
+    const normalized = filename.replace(/^\/+/, "");
+    const directory = path.posix.dirname(normalized) === "." ? "cache" : path.posix.dirname(normalized);
+    const baseName = path.posix.basename(normalized);
+
+    let exists = false;
+
+    await printer.manipulateFiles(async (context) => {
+      const entries = await context.readDir(directory);
+      exists = entries.includes(baseName);
     });
-    if (!fileExists) throw new Error(`File not found: ${filename}`);
-    return { name: filename, exists: true };
+
+    return {
+      name: `${directory}/${baseName}`,
+      exists,
+    };
   }
 
-  async uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
-     // This method just uploads now, doesn't handle printing
-     const [serial, token] = this.extractBambuCredentials(apiKey);
-     const printerFTP = this.getBambuPrinterForFTP(host, serial, token);
-     const remotePath = `gcodes/${filename}`.replace(/\\/g, '/');
-     if (!printerFTP.isConnected) await printerFTP.connect();
-     console.log(`Uploading ${filePath} to ${remotePath} via FTP...`);
-     try {
-         await printerFTP.manipulateFiles(async (context: BambuFTP) => {
-             await context.sendFile(filePath, remotePath);
-         });
-         console.log(`File ${filename} uploaded successfully.`);
-         if (print) {
-             console.warn("'print=true' ignored in uploadFile for Bambu. Use print_3mf tool instead.");
-         }
-         return { status: "success", message: `File ${filename} uploaded successfully` };
-     } catch (uploadError) {
-         console.error(`FTP Upload Error:`, uploadError);
-         throw new Error(`Failed to upload file via FTP: ${(uploadError as Error).message}`);
-     }
+  async uploadFile(
+    host: string,
+    port: string,
+    apiKey: string,
+    filePath: string,
+    filename: string,
+    print: boolean
+  ) {
+    await fs.access(filePath);
+
+    const [serial, token] = this.extractBambuCredentials(apiKey);
+
+    const normalizedFileName = filename.replace(/^\/+/, "");
+    const remotePath = normalizedFileName.includes("/")
+      ? normalizedFileName
+      : `cache/${normalizedFileName}`;
+
+    // Use direct FTP upload (bypasses bambu-js double-path bug)
+    await this.ftpUpload(host, token, filePath, `/${remotePath}`);
+
+    const response: Record<string, unknown> = {
+      status: "success",
+      uploaded: true,
+      remotePath,
+      printRequested: print,
+    };
+
+    if (print) {
+      if (remotePath.toLowerCase().endsWith(".gcode")) {
+        response.startResult = await this.startJob(host, port, apiKey, remotePath);
+      } else if (remotePath.toLowerCase().endsWith(".3mf")) {
+        response.note =
+          "3MF upload complete. Use print_3mf to start a project print with plate and metadata options.";
+      } else {
+        throw new Error(
+          "Automatic print after upload supports .gcode only. Use print_3mf for .3mf project prints."
+        );
+      }
+    }
+
+    return response;
   }
 
   async startJob(host: string, port: string, apiKey: string, filename: string) {
-    // This should likely be deprecated or only work for G-code files via a different MQTT command?
-    console.warn("startJob is not recommended for Bambu .3mf files. Use print_3mf tool.");
-    throw new Error("startJob is not implemented for Bambu printers using MQTT commands yet.");
+    if (filename.toLowerCase().endsWith(".3mf")) {
+      throw new Error("Use print_3mf for .3mf project files.");
+    }
+
+    const [serial, token] = this.extractBambuCredentials(apiKey);
+    const printer = await this.getPrinter(host, serial, token);
+
+    const normalizedFileName = filename.replace(/^\/+/, "");
+    const remoteFile = normalizedFileName.includes("/")
+      ? normalizedFileName
+      : `cache/${normalizedFileName}`;
+
+    await printer.executeCommand(new GCodeFileCommand({ fileName: remoteFile }));
+
+    return {
+      status: "success",
+      message: `Start command sent for ${remoteFile}.`,
+      file: remoteFile,
+    };
   }
-  
-  // --- Helper to publish MQTT commands ---
-  private async publishMqttCommand(client: mqtt.MqttClient, serial: string, commandType: string, payload: any): Promise<any> {
-      const topic = `device/${serial}/request`;
-      const message = JSON.stringify({ [commandType]: payload });
-      
-      console.log(`Publishing MQTT to ${topic}: ${message}`);
-      
-      return new Promise((resolve, reject) => {
-          client.publish(topic, message, { qos: 1 }, (err) => {
-              if (err) {
-                  console.error(`MQTT Publish Error to ${topic}:`, err);
-                  reject(new Error(`Failed to publish MQTT command: ${err.message}`));
-              } else {
-                  console.log(`MQTT command published successfully to ${topic}`);
-                  // Note: We don't wait for a response here. Status updates come via /report topic.
-                  resolve({ status: "success", message: "Command sent successfully via MQTT." });
-              }
-          });
+
+  /**
+   * Upload a file to the printer via FTP using basic-ftp directly.
+   * Bypasses bambu-js's sendFile which has a double-path bug (ensureDir CDs
+   * into the target directory, then uploadFrom uses the full relative path
+   * again, resulting in e.g. /cache/cache/file.3mf).
+   */
+  private async ftpUpload(
+    host: string,
+    token: string,
+    localPath: string,
+    remotePath: string
+  ): Promise<void> {
+    const client = new FTPClient(15_000);
+    try {
+      await client.access({
+        host,
+        port: 990,
+        user: "bblp",
+        password: token,
+        secure: "implicit",
+        secureOptions: { rejectUnauthorized: false },
       });
+      // Use absolute path to avoid CWD side-effects
+      const absoluteRemote = remotePath.startsWith("/") ? remotePath : `/${remotePath}`;
+      const remoteDir = path.posix.dirname(absoluteRemote);
+      await client.ensureDir(remoteDir);
+      // uploadFrom with just the basename since we're already in the right dir
+      await client.uploadFrom(localPath, path.posix.basename(absoluteRemote));
+    } finally {
+      client.close();
+    }
   }
 
-  // Helper method to extract Bambu-specific credentials from apiKey
   private extractBambuCredentials(apiKey: string): [string, string] {
-    const parts = apiKey.split(':');
-    if (parts.length !== 2) {
-      throw new Error("Invalid Bambu credentials format. Expected 'serial:token'");
+    const separatorIndex = apiKey.indexOf(":");
+
+    if (separatorIndex <= 0 || separatorIndex === apiKey.length - 1) {
+      throw new Error("Invalid Bambu credentials format. Expected 'serial:token'.");
     }
-    return [parts[0], parts[1]];
+
+    const serial = apiKey.slice(0, separatorIndex).trim();
+    const token = apiKey.slice(separatorIndex + 1).trim();
+
+    if (!serial || !token) {
+      throw new Error("Invalid Bambu credentials format. Expected 'serial:token'.");
+    }
+
+    return [serial, token];
   }
-} 
+
+  async disconnectAll(): Promise<void> {
+    await this.printerStore.disconnectAll();
+  }
+}