mcp-3d-printer-server 1.0.2 → 1.2.1

package/dist/printers/bambu.js

@@ -1,284 +1,371 @@
 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 { 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";
+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 (this.printers.has(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)) {
+            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.`);
         }
-        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) => {
+        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() {
+        const disconnectPromises = [];
+        for (const printer of this.printers.values()) {
+            disconnectPromises.push((async () => {
                 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');
+                    await printer.disconnect();
                 }
-                catch (e) {
-                    console.error('Failed to parse MQTT message:', e);
+                catch (error) {
+                    console.error("Failed to disconnect Bambu client", error);
                 }
-            });
-        });
-        this.mqttConnectionPromises[clientKey] = connectPromise; // Store the promise
-        return connectPromise;
+            })());
+        }
+        await Promise.allSettled(disconnectPromises);
+        this.printers.clear();
+        this.initialConnectionPromises.clear();
     }
-    // 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();
-                        }
-                    });
-                });
+}
+export class BambuImplementation extends PrinterImplementation {
+    constructor(apiClient) {
+        super(apiClient);
+        this.printerStore = new BambuClientStore();
+    }
+    async getPrinter(host, serial, token) {
+        return this.printerStore.getPrinter(host, serial, token);
+    }
+    async resolveProjectFileMetadata(localThreeMfPath, plateIndex) {
+        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.");
+        }
+        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}`);
             }
+            selectedEntry = matchedEntry;
         }
-        this.mqttClients = {};
-        this.mqttConnectionPromises = {};
+        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,
+        };
     }
-    // --- getStatus (Limited Implementation) ---
     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);
+            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: 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 || 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.message };
+            console.error(`Failed to get Bambu status for ${serial}:`, error);
+            return { status: "error", connected: false, error: error.message };
         }
     }
-    // --- Refactored print3mf using direct MQTT ---
     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
+        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) => {
-                await context.sendFile(options.filePath, remotePath);
-            });
-            console.log(`File ${remoteFilename} uploaded successfully.`);
+        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;
+        if (options.amsMapping && options.amsMapping.length > 0) {
+            amsMapping = Array.from({ length: 5 }, (_, i) => i < options.amsMapping.length ? options.amsMapping[i] : -1);
         }
-        catch (uploadError) {
-            console.error(`FTP Upload Error:`, uploadError);
-            throw new Error(`Failed to upload 3MF file via FTP: ${uploadError.message}`);
+        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 = {
-            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
+        const projectFileCmd = {
+            print: {
+                command: "project_file",
+                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,
+                use_ams: options.useAMS !== false,
+                ams_mapping: amsMapping,
+                profile_id: "0",
+                project_id: "0",
+                sequence_id: "0",
+                subtask_id: "0",
+                task_id: "0",
+            },
+        };
+        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,
         };
-        // 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);
     }
-    // --- Refactored cancelJob using MQTT ---
     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);
+        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.message}`);
+        }
     }
-    // --- setTemperature (still not directly possible via MQTT command) ---
     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);
+        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;
+        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, 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);
+        const printer = new BambuPrinter(host, serial, token);
+        const directories = ["cache", "timelapse", "logs"];
+        const filesByDirectory = {};
+        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, 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);
+        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, port, apiKey, filePath, filename, print) {
-        // This method just uploads now, doesn't handle printing
+        await fs.access(filePath);
         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.");
+        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 = {
+            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 { 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.message}`);
         }
+        return response;
     }
     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.");
+        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 ---
-    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." });
-                }
+    /**
+     * 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).
+     */
+    async ftpUpload(host, token, localPath, remotePath) {
+        const client = new FTPClient(15000);
+        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
     extractBambuCredentials(apiKey) {
-        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() {
+        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;