mcp-3d-printer-server 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcp-3d-printer-server",
-    "version": "1.0.2",
+    "version": "1.0.3",
     "description": "MCP server for connecting Claude with 3D printer management systems",
     "main": "dist/index.js",
     "repository": "https://github.com/DMontgomery40/mcp-3D-printer-server",
@@ -9,7 +9,8 @@
         "start": "node dist/index.js",
         "dev": "nodemon src/index.ts --exec \"npm run build && npm start\"",
         "build": "tsc",
-        "test": "npm run build && node dist/test/stl-manipulator-test.js"
+        "test": "npm run build && node dist/test/stl-manipulator-test.js",
+        "inspect": "npm run build && npx @modelcontextprotocol/inspector dist/index.js"
     },
     "bin": {
         "mcp-3d-printer-server": "./dist/index.js"
@@ -38,6 +39,7 @@
         "@modelcontextprotocol/sdk": "^1.6.0",
         "axios": "^1.6.2",
         "bambu-js": "^2.2.2",
+        "bambu-node": "^3.22.21",
         "dotenv": "^16.3.1",
         "form-data": "^4.0.0",
         "jszip": "^3.10.1",

package/src/printers/bambu.ts

@@ -1,44 +1,18 @@
-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 { PrinterImplementation } from "../types.js";
+import { 
+    BambuClient, 
+    UpdateStateCommand, 
+    UpdateTempCommand, 
+    // State, // Removed as using string literal
+    // TempUpdatePartType // Removed as likely unusable type
+} from "bambu-node"; // Use bambu-node library
 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;
-}
-
-// 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
-}
-
-// Define interface for print options including overrides passed from index.ts
+// Define interface for print options matching bambu-node expectations
+// Note: Check ProjectFileCommand in bambu-node for exact structure
 interface BambuPrintOptionsInternal {
     projectName: string;
     filePath: string; // Path to the local .3mf file
-    // Base options from OpenBambuAPI spec
     useAMS?: boolean;
     plateIndex?: number;
     bedLeveling?: boolean;
@@ -46,306 +20,247 @@ interface BambuPrintOptionsInternal {
     vibrationCalibration?: boolean;
     layerInspect?: boolean;
     timelapse?: boolean;
-    // Overrides / parsed data
-    amsMapping?: number[]; // Explicit mapping (from user override or parsed 3MF)
+    amsMapping?: { [originalFilamentIndex: string]: number }; // Map original filament index (string) to AMS slot number
     md5?: string; // Optional MD5 hash of the file
 }
 
-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
+// Store for bambu-node printer instances
+class BambuClientStore {
+    private printers: Map<string, BambuClient> = new Map();
+    private initialConnectionPromises: Map<string, Promise<void>> = new Map();
 
-  constructor(apiClient: any, bambuPrinterStore: BambuPrinterStore) {
-    super(apiClient);
-    this.bambuPrinterStore = bambuPrinterStore;
-  }
+    async getPrinter(host: string, serial: string, token: string): Promise<BambuClient> {
+        const key = `${host}-${serial}`;
 
-  // 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);
-  }
+        // If already connected/connecting, return existing instance or wait for connection
+        if (this.printers.has(key)) {
+            console.log(`Returning existing BambuClient instance for ${key}`);
+            return this.printers.get(key)!;
+        } 
+        if (this.initialConnectionPromises.has(key)) {
+            console.log(`Waiting for existing initial connection attempt for ${key}...`);
+            // Don't await here; if promise exists, listeners will handle map update
+            // await this.initialConnectionPromises.get(key); 
+            // Throw error immediately if we know a connection is pending but not resolved yet
+            // Or rely on the promise rejection propagating if it fails
+            await this.initialConnectionPromises.get(key); // Await necessary to ensure connection completes or fails
+             if (this.printers.has(key)) {
+                 return this.printers.get(key)!;
+            } else {
+                throw new Error(`Existing initial connection attempt for ${key} failed or timed out.`);
+            }
+        }
 
-  // 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];
-      }
+        // Create new instance and attempt connection
+        console.log(`Creating new BambuClient instance for ${key}`);
+        const printer = new BambuClient({
+            host: host,
+            serialNumber: serial,
+            accessToken: token,
+        });
 
-      // 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];
-      }
+        // Setup event listeners for state management
+        printer.on('client:connect', () => { 
+            console.log(`BambuClient connected for ${key}`);
+            this.printers.set(key, printer);
+            this.initialConnectionPromises.delete(key); 
+        });
+        printer.on('client:error', (err: Error) => { 
+            console.error(`BambuClient connection error for ${key}:`, err);
+            this.printers.delete(key); 
+            this.initialConnectionPromises.delete(key); 
+        });
+        printer.on('client:disconnect', () => { 
+            console.log(`BambuClient connection closed for ${key}`);
+            this.printers.delete(key); 
+            this.initialConnectionPromises.delete(key); 
+        });
+        printer.on('printer:dataUpdate', (data) => {
+             // Optional: log or update internal state based on data
+             // console.log(`BambuClient data update for ${key}`);
+         });
 
-      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
-            };
+        // Store promise and initiate connection
+        console.log(`Attempting initial connection for BambuClient ${key}...`);
+        const connectPromise = printer.connect().then(() => {});
+        this.initialConnectionPromises.set(key, connectPromise);
 
-            const client = mqtt.connect(mqttOptions);
+        try {
+            await connectPromise;
+            console.log(`Initial connection successful for ${key}.`);
+            // Redundant set, already handled by 'client:connect' listener
+            // this.printers.set(key, printer); 
+            return printer;
+        } catch (err) {
+            console.error(`Initial connection failed for ${key}:`, err);
+            this.initialConnectionPromises.delete(key); // Clean up promise map on failure
+            throw err; // Rethrow the error
+        }
+    }
 
-            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);
-            });
+    async disconnectAll(): Promise<void> {
+        console.log("Disconnecting all BambuClient instances...");
+        const disconnectPromises: Promise<void>[] = [];
+        for (const [key, printer] of this.printers.entries()) {
+            disconnectPromises.push(
+                printer.disconnect()
+                    .then(() => console.log(`Disconnected ${key}`))
+                    .catch(err => console.error(`Error disconnecting ${key}:`, err))
+            );
+        }
+        await Promise.allSettled(disconnectPromises);
+        this.printers.clear();
+        this.initialConnectionPromises.clear();
+    }
+}
 
-            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);
-            });
+export class BambuImplementation extends PrinterImplementation {
+  private printerStore: BambuClientStore; // Use correct store name
 
-            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;
+  constructor(apiClient: any /* Not used */) {
+    super(apiClient);
+    this.printerStore = new BambuClientStore();
   }
 
-  // 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 = {};
-   }
+  // Helper to get connected printer instance
+  private async getPrinter(host: string, serial: string, token: string): Promise<BambuClient> {
+      return this.printerStore.getPrinter(host, serial, token);
+  }
 
-  // --- getStatus (Limited Implementation) ---
+  // --- getStatus ---
   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);
+        
+        // Wait a moment for status data to populate if needed
+        if (!printer.data || Object.keys(printer.data).length === 0) {
+          await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        
+        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 || "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",
+          raw: data // Include raw data for debugging
+        };
     } 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 BambuClient status for ${serial}:`, error);
+         return { status: "error", connected: false, error: (error as Error).message }; 
     }
   }
   
-  // --- Refactored print3mf using direct MQTT ---
+  // --- print3mf ---
   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
-    }
-
-    // 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}`);
-    }
-    
-    // 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(),
-        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,
-        timelapse: options.timelapse ?? false,
-        ams_mapping: options.amsMapping,
-        md5: options.md5
-    };
-    
-    // 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);
+    console.error("print3mf error: bambu-node library does not directly support the required FTPS file upload for .3mf files.");
+    throw new Error("Printing .3mf files is not supported with the current bambu-node library integration due to missing FTPS capability.");
   }
   
-  // --- Refactored cancelJob using MQTT ---
+  // --- cancelJob ---
   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);
+    
+    console.log(`Attempting to cancel print via bambu-node...`);
+    try {
+        // Use UpdateStateCommand with string literal state
+        const command = new UpdateStateCommand({ state: 'stop' }); 
+        await printer.executeCommand(command);
+        console.log(`Cancel print command successful via bambu-node.`);
+        return { status: "success", message: "Cancel command sent successfully." };
+    } catch (cancelError) {
+        console.error(`Error sending cancel command via bambu-node:`, cancelError);
+        throw new Error(`Failed to cancel print: ${(cancelError as Error).message}`);
+    }
   }
   
-  // --- setTemperature (still not directly possible via MQTT command) ---
+  // --- setTemperature --- (Commenting out due to type issues)
   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.");
+    // const [serial, token] = this.extractBambuCredentials(apiKey);
+    // const printer = await this.getPrinter(host, serial, token);
+    // console.log(`Attempting to set temperature for ${component} to ${temperature}°C via bambu-node...`);
+    // try {
+    //     let command;
+    //     const partArg = component.toLowerCase();
+    //     if (partArg === 'extruder' || partArg === 'nozzle') {
+    //         // Use string literal for part. Cast temp due to strict lib types.
+    //         console.warn("Casting temperature to 'any' for UpdateTempCommand.");
+    //         command = new UpdateTempCommand({ part: 'nozzle', temperature: temperature as any });
+    //     } else if (partArg === 'bed') {
+    //         // Use string literal for part. Cast temp due to strict lib types.
+    //          console.warn("Casting temperature to 'any' for UpdateTempCommand.");
+    //         command = new UpdateTempCommand({ part: 'bed', temperature: temperature as any });
+    //     } else {
+    //          throw new Error(`Unsupported temperature component: ${component}. Use 'extruder' or 'bed'.`);
+    //     }
+    //     await printer.executeCommand(command);
+    //     console.log(`Set temperature command successful for ${component}.`);
+    //     return { status: "success", message: `Temperature set command for ${component} sent.` };
+    // } catch (tempError) {
+    //     console.error(`Error sending set temperature command via bambu-node:`, tempError);
+    //     throw new Error(`Failed to set temperature: ${(tempError as Error).message}`);
+    // }
+    console.warn("setTemperature is currently disabled due to type inconsistencies in the bambu-node library.");
+    throw new Error("setTemperature is disabled.");
   }
   
-  // --- Other methods (getFiles, getFile, uploadFile, startJob) need review/refactoring ---
-  // For now, keep using bambu-js FTP for file ops, but MQTT for commands
+  // --- getFiles --- (Library doesn't seem to expose direct file listing)
   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);
-    });
-    return { files: fileList };
+    console.warn("File listing is not directly supported by bambu-node. Returning empty list.");
+    return { files: [], note: "Not supported by bambu-node library" };
   }
 
+  // --- getFile --- (Library doesn't seem to expose direct file metadata/download)
   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);
-    });
-    if (!fileExists) throw new Error(`File not found: ${filename}`);
-    return { name: filename, exists: true };
+      console.warn("Getting individual file metadata/content is not directly supported by bambu-node.");
+      return { name: filename, exists: false, note: "Not supported by bambu-node library" };
   }
 
+  // --- uploadFile (Handled by print method if supported) ---
   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}`);
+     console.warn("Use the 'print_3mf' tool. Direct upload without print is not the primary use case.");
+     if (print) {
+         // Cannot directly call print3mf as it's not supported by this library
+         throw new Error("Cannot initiate print via uploadFile as print_3mf is not supported by bambu-node.");
+         // const [serial, token] = this.extractBambuCredentials(apiKey);
+         // await this.print3mf(host, serial, token, { 
+         //     filePath: filePath, 
+         //     projectName: path.basename(filePath, path.extname(filePath))
+         // });
+         // return { status: "success", message: "Upload and print initiated via print_3mf." };
+     } else {
+         throw new Error("Uploading without printing is not supported. Use print_3mf (if supported).");
      }
   }
 
+  // --- startJob (Use print method via print_3mf if supported) ---
   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.");
+    console.warn("startJob is deprecated for Bambu. Use the 'print_3mf' tool (if supported).");
+    throw new Error("startJob is deprecated for Bambu printers. Use print_3mf (if supported).");
   }
   
-  // --- 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." });
-              }
-          });
-      });
-  }
-
-  // Helper method to extract Bambu-specific credentials from apiKey
+  // --- Helper to extract Bambu credentials ---
   private extractBambuCredentials(apiKey: string): [string, string] {
     const parts = apiKey.split(':');
     if (parts.length !== 2) {
@@ -353,4 +268,9 @@ export class BambuImplementation extends PrinterImplementation {
     }
     return [parts[0], parts[1]];
   }
+
+  // Method required by PrinterFactory, disconnects managed printers
+  async disconnectAll(): Promise<void> {
+      await this.printerStore.disconnectAll();
+  }
 } 

package/src/printers/printer-factory.ts

@@ -1,4 +1,4 @@
-import { PrinterImplementation, BambuPrinterStore } from "../types.js";
+import { PrinterImplementation } from "../types.js";
 import { OctoPrintImplementation } from "./octoprint.js";
 import { KlipperImplementation } from "./klipper.js";
 import { DuetImplementation } from "./duet.js";
@@ -10,7 +10,6 @@ import axios from "axios";
 
 export class PrinterFactory {
   private implementations: Map<string, PrinterImplementation> = new Map();
-  private bambuPrinterStore = new BambuPrinterStore();
   private apiClient = axios.create({ timeout: 10000 });
 
   constructor() {
@@ -18,7 +17,7 @@ export class PrinterFactory {
     this.implementations.set("klipper", new KlipperImplementation(this.apiClient));
     this.implementations.set("duet", new DuetImplementation(this.apiClient));
     this.implementations.set("repetier", new RepetierImplementation(this.apiClient));
-    this.implementations.set("bambu", new BambuImplementation(this.apiClient, this.bambuPrinterStore));
+    this.implementations.set("bambu", new BambuImplementation(this.apiClient));
     this.implementations.set("prusa", new PrusaImplementation(this.apiClient));
     this.implementations.set("creality", new CrealityImplementation(this.apiClient));
   }
@@ -32,6 +31,10 @@ export class PrinterFactory {
   }
 
   async disconnectAll(): Promise<void> {
-    await this.bambuPrinterStore.disconnectAll();
+    // Disconnect all printers if needed
+    const bambuImpl = this.implementations.get("bambu") as BambuImplementation;
+    if (bambuImpl) {
+      await bambuImpl.disconnectAll();
+    }
   }
 }