mcp-3d-printer-server 1.0.2 → 1.0.3

package/README.md

@@ -9,6 +9,10 @@
 [![Downloads](https://img.shields.io/npm/dm/mcp-3d-printer-server.svg)](https://www.npmjs.com/package/mcp-3d-printer-server)
 [![GitHub stars](https://img.shields.io/github/stars/dmontgomery40/mcp-3d-printer-server.svg?style=social&label=Star)](https://github.com/yourusername/mcp-3d-printer-server)
 
+<a href="https://glama.ai/mcp/servers/7f6v2enbgk">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/7f6v2enbgk/badge" alt="3D Printer Server MCP server" />
+</a>
+
 <details>
 <summary><strong>✨ What's New / Significant Updates (as of last session)</strong></summary>
 
@@ -795,4 +799,4 @@ Due to the nature of the Bambu Lab printer API, there are some limitations:
 
 ## License
 
-GPL-2.0
+GPL-2.0

package/dist/printers/bambu.d.ts

@@ -1,4 +1,4 @@
-import { PrinterImplementation, BambuPrinterStore } from "../types.js";
+import { PrinterImplementation } from "../types.js";
 interface BambuPrintOptionsInternal {
     projectName: string;
     filePath: string;
@@ -9,34 +9,31 @@ interface BambuPrintOptionsInternal {
     vibrationCalibration?: boolean;
     layerInspect?: boolean;
     timelapse?: boolean;
-    amsMapping?: number[];
+    amsMapping?: {
+        [originalFilamentIndex: string]: number;
+    };
     md5?: string;
 }
 export declare class BambuImplementation extends PrinterImplementation {
-    private bambuPrinterStore;
-    private mqttClients;
-    private mqttConnectionPromises;
-    constructor(apiClient: any, bambuPrinterStore: BambuPrinterStore);
-    private getBambuPrinterForFTP;
-    private getMqttClient;
-    disconnectAllMqtt(): Promise<void>;
+    private printerStore;
+    constructor(apiClient: any);
+    private getPrinter;
     getStatus(host: string, port: string, apiKey: string): Promise<any>;
     print3mf(host: string, serial: string, token: string, options: BambuPrintOptionsInternal): Promise<any>;
     cancelJob(host: string, port: string, apiKey: string): Promise<any>;
     setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number): Promise<void>;
     getFiles(host: string, port: string, apiKey: string): Promise<{
-        files: string[];
+        files: never[];
+        note: string;
     }>;
     getFile(host: string, port: string, apiKey: string, filename: string): Promise<{
         name: string;
         exists: boolean;
+        note: string;
     }>;
-    uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean): Promise<{
-        status: string;
-        message: string;
-    }>;
+    uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean): Promise<void>;
     startJob(host: string, port: string, apiKey: string, filename: string): Promise<void>;
-    private publishMqttCommand;
     private extractBambuCredentials;
+    disconnectAll(): Promise<void>;
 }
 export {};

package/dist/printers/bambu.js

@@ -1,279 +1,226 @@
 import { PrinterImplementation } from "../types.js";
-import * as mqtt from 'mqtt'; // Import MQTT library
-import * as path from 'path';
-export class BambuImplementation extends PrinterImplementation {
-    constructor(apiClient, bambuPrinterStore) {
-        super(apiClient);
-        this.mqttClients = {}; // Store connected MQTT clients
-        this.mqttConnectionPromises = {}; // Track connection attempts
-        this.bambuPrinterStore = bambuPrinterStore;
-    }
-    // Get BambuPrinter instance for FTP
-    getBambuPrinterForFTP(host, serial, token) {
-        // This still uses bambu-js just for the FTP part
-        return this.bambuPrinterStore.get(host, serial, token);
+import { BambuClient, UpdateStateCommand,
+// State, // Removed as using string literal
+// TempUpdatePartType // Removed as likely unusable type
+ } from "bambu-node"; // Use bambu-node library
+// Store for bambu-node printer instances
+class BambuClientStore {
+    constructor() {
+        this.printers = new Map();
+        this.initialConnectionPromises = new Map();
     }
-    // Get or establish MQTT connection
-    async getMqttClient(host, serial, token) {
-        const clientKey = `${host}-${serial}`;
-        if (this.mqttClients[clientKey] && this.mqttClients[clientKey].connected) {
-            return this.mqttClients[clientKey];
+    async getPrinter(host, serial, token) {
+        const key = `${host}-${serial}`;
+        // 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 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];
+        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.`);
+            }
         }
-        console.log(`Attempting to establish new MQTT connection to ${host} for ${serial}...`);
-        const connectPromise = new Promise((resolve, reject) => {
-            // Use port 8883 and TLS
-            const mqttOptions = {
-                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);
-                }
-            });
+        // Create new instance and attempt connection
+        console.log(`Creating new BambuClient instance for ${key}`);
+        const printer = new BambuClient({
+            host: host,
+            serialNumber: serial,
+            accessToken: token,
         });
-        this.mqttConnectionPromises[clientKey] = connectPromise; // Store the promise
-        return connectPromise;
+        // 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) => {
+            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}`);
+        });
+        // Store promise and initiate connection
+        console.log(`Attempting initial connection for BambuClient ${key}...`);
+        const connectPromise = printer.connect().then(() => { });
+        this.initialConnectionPromises.set(key, connectPromise);
+        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
+        }
     }
-    // Disconnect MQTT clients on shutdown
-    async disconnectAllMqtt() {
-        console.log("Disconnecting all MQTT clients...");
-        for (const key in this.mqttClients) {
-            const client = this.mqttClients[key];
-            if (client) {
-                await new Promise((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();
-                        }
-                    });
-                });
-            }
+    async disconnectAll() {
+        console.log("Disconnecting all BambuClient instances...");
+        const disconnectPromises = [];
+        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)));
         }
-        this.mqttClients = {};
-        this.mqttConnectionPromises = {};
+        await Promise.allSettled(disconnectPromises);
+        this.printers.clear();
+        this.initialConnectionPromises.clear();
+    }
+}
+export class BambuImplementation extends PrinterImplementation {
+    constructor(apiClient /* Not used */) {
+        super(apiClient);
+        this.printerStore = new BambuClientStore();
+    }
+    // Helper to get connected printer instance
+    async getPrinter(host, serial, token) {
+        return this.printerStore.getPrinter(host, serial, token);
     }
-    // --- getStatus (Limited Implementation) ---
+    // --- getStatus ---
     async getStatus(host, port, apiKey) {
         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
+            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: client.connected ? "connected" : "connecting",
-                serial: serial,
-                note: "Full status details require MQTT state tracking implementation."
+                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.message };
+            console.error(`Failed to get BambuClient status for ${serial}:`, error);
+            return { status: "error", connected: false, error: error.message };
         }
     }
-    // --- Refactored print3mf using direct MQTT ---
+    // --- print3mf ---
     async print3mf(host, serial, token, options) {
-        // 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.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) => {
-                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.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 = {
-            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, port, apiKey) {
         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.message}`);
+        }
     }
-    // --- setTemperature (still not directly possible via MQTT command) ---
+    // --- setTemperature --- (Commenting out due to type issues)
     async setTemperature(host, port, apiKey, component, temperature) {
-        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, port, apiKey) {
-        const [serial, token] = this.extractBambuCredentials(apiKey);
-        const printerFTP = this.getBambuPrinterForFTP(host, serial, token);
-        if (!printerFTP.isConnected)
-            await printerFTP.connect();
-        const fileList = [];
-        await printerFTP.manipulateFiles(async (context) => {
-            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, port, apiKey, filename) {
-        // 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) => {
-            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, port, apiKey, filePath, filename, print) {
-        // 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) => {
-                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` };
+        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." };
         }
-        catch (uploadError) {
-            console.error(`FTP Upload Error:`, uploadError);
-            throw new Error(`Failed to upload file via FTP: ${uploadError.message}`);
+        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, port, apiKey, filename) {
-        // 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 ---
-    async publishMqttCommand(client, serial, commandType, payload) {
-        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 ---
     extractBambuCredentials(apiKey) {
         const parts = apiKey.split(':');
         if (parts.length !== 2) {
@@ -281,4 +228,8 @@ export class BambuImplementation extends PrinterImplementation {
         }
         return [parts[0], parts[1]];
     }
+    // Method required by PrinterFactory, disconnects managed printers
+    async disconnectAll() {
+        await this.printerStore.disconnectAll();
+    }
 }

package/dist/printers/printer-factory.d.ts

@@ -1,7 +1,6 @@
 import { PrinterImplementation } from "../types.js";
 export declare class PrinterFactory {
     private implementations;
-    private bambuPrinterStore;
     private apiClient;
     constructor();
     getImplementation(type: string): PrinterImplementation;

package/dist/printers/printer-factory.js

@@ -1,4 +1,3 @@
-import { BambuPrinterStore } from "../types.js";
 import { OctoPrintImplementation } from "./octoprint.js";
 import { KlipperImplementation } from "./klipper.js";
 import { DuetImplementation } from "./duet.js";
@@ -10,13 +9,12 @@ import axios from "axios";
 export class PrinterFactory {
     constructor() {
         this.implementations = new Map();
-        this.bambuPrinterStore = new BambuPrinterStore();
         this.apiClient = axios.create({ timeout: 10000 });
         this.implementations.set("octoprint", new OctoPrintImplementation(this.apiClient));
         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));
     }
@@ -28,6 +26,10 @@ export class PrinterFactory {
         return implementation;
     }
     async disconnectAll() {
-        await this.bambuPrinterStore.disconnectAll();
+        // Disconnect all printers if needed
+        const bambuImpl = this.implementations.get("bambu");
+        if (bambuImpl) {
+            await bambuImpl.disconnectAll();
+        }
     }
 }

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import { AxiosInstance } from "axios";
-import { BambuPrinter } from "bambu-js";
 export type BambuFTP = {
     readDir: (path: string) => Promise<string[]>;
     sendFile: (sourcePath: string, destinationPath: string, progressCallback?: (progress: number) => void) => Promise<void>;
@@ -16,11 +15,6 @@ export declare abstract class PrinterImplementation {
     abstract cancelJob(host: string, port: string, apiKey: string): Promise<any>;
     abstract setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number): Promise<any>;
 }
-export declare class BambuPrinterStore {
-    private printers;
-    get(host: string, serial: string, token: string): InstanceType<typeof BambuPrinter>;
-    disconnectAll(): Promise<void>;
-}
 export interface SectionBounds {
     minX: number;
     minY: number;

package/dist/types.js

@@ -1,26 +1,6 @@
-import { BambuPrinter } from "bambu-js";
 // Base class for printer implementations
 export class PrinterImplementation {
     constructor(apiClient) {
         this.apiClient = apiClient;
     }
 }
-// Store for Bambu printers
-export class BambuPrinterStore {
-    constructor() {
-        this.printers = new Map();
-    }
-    get(host, serial, token) {
-        const key = `${host}-${serial}`;
-        if (!this.printers.has(key)) {
-            const printer = new BambuPrinter(host, serial, token);
-            this.printers.set(key, printer);
-        }
-        return this.printers.get(key);
-    }
-    async disconnectAll() {
-        for (const printer of this.printers.values()) {
-            await printer.disconnect();
-        }
-    }
-}