mcp-3d-printer-server 0.2.3 → 1.0.1

package/README.md

@@ -7,7 +7,84 @@
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://makeapullrequest.com)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D%2018.0.0-green.svg)](https://nodejs.org/en/download/)
 [![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/yourusername/mcp-3d-printer-server.svg?style=social&label=Star)](https://github.com/yourusername/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)
+
+<details>
+<summary><strong>✨ What's New / Significant Updates (as of last session)</strong></summary>
+
+- **Bambu `.3mf` Printing:** Added the `print_3mf` tool specifically for Bambu Lab printers. This uploads the `.3mf` file and sends the print command directly via MQTT based on OpenBambuAPI specs.
+- **Direct MQTT Communication (Bambu):** Refactored Bambu command handling (`print_3mf`, `cancelJob`) to use direct MQTT (TLS port 8883) instead of relying solely on `bambu-js` for commands.
+- **`.3mf` File Parsing:** Implemented a parser (`src/3mf_parser.ts`) to read metadata and Bambu-specific slicer settings (from `project_settings.config`) within `.3mf` files.
+- **Bambu Preset Resources:** Added support for reading Bambu Studio preset files (`machine`, `filament`, `process`) as MCP resources (e.g., `preset://bambu/process/MyPreset`) if `BAMBU_STUDIO_CONFIG_PATH` is set.
+- **OrcaSlicer Integration:** Added support for using OrcaSlicer via its command-line interface for the `slice_stl` tool.
+- **New STL Manipulation Tools:** Added `merge_vertices`, `center_model`, and `lay_flat` tools for basic model preparation using `three.js`.
+- **Configuration Update:** Added `BAMBU_STUDIO_CONFIG_PATH` environment variable for preset loading.
+- **FTP Usage Note:** Acknowledged in documentation that file operations for Bambu currently use potentially unsecured FTP via `bambu-js`.
+
+</details>
+
+<details>
+<summary><strong>🗺️ Roadmap / TODO</strong></summary>
+
+- **Achieve Feature Parity:** Bring functionality (status detail, file operations, direct printing where possible, preset handling) for OctoPrint, Klipper, Duet, Repetier, Prusa Connect, and Creality Cloud up to the level of robustness planned for the Bambu implementation.
+- **Implement Full Bambu MQTT Status:** Refactor `getStatus` for Bambu to subscribe to MQTT reports and maintain real-time state.
+- **Implement Robust AMS Mapping:** Replace placeholder logic; correctly parse and use AMS mapping from `.3mf` slicer config or user overrides for the MQTT print command.
+- **Implement `.3mf` Print Overrides:** Add logic to the `print_3mf` tool to handle user-provided overrides (e.g., calibration flags) and potentially common slicer settings if feasible via MQTT/G-code.
+- **Calculate MD5 Hash:** Add logic to calculate and include the MD5 hash of the `.3mf` file in the MQTT print command (optional but recommended by protocol).
+- **Refactor Bambu File Ops:** Investigate replacing `bambu-js` FTP operations (`getFiles`, `uploadFile`) with direct MQTT methods if possible/stable, or contribute FTPS support to `bambu-js`.
+- **Add Preset Discovery Logic:** Improve preset resource listing (currently lists based on potential filenames, could parse index files if they exist).
+- **Expand `.3mf` Support:** Add `.3mf` printing support for other printer types where applicable.
+- **Error Handling & Reporting:** Enhance MQTT error handling and reporting of print progress/completion.
+- **Testing:** Conduct thorough runtime testing of all new Bambu features.
+
+</details>
+
+<details>
+<summary>Click to expand Table of Contents</summary>
+
+## Table of Contents
+
+- [Description](#description)
+- [Features](#features)
+- [Installation](#installation)
+  - [Prerequisites](#prerequisites)
+  - [Install from npm](#install-from-npm)
+  - [Install from source](#install-from-source)
+  - [Running with Docker](#running-with-docker)
+    - [Using Slicers with Docker](#using-slicers-with-docker)
+- [Configuration](#configuration)
+- [Usage with Claude Desktop](#usage-with-claude-desktop)
+- [Supported Printer Management Systems](#supported-printer-management-systems)
+  - [OctoPrint](#octoprint)
+  - [Klipper (via Moonraker)](#klipper-via-moonraker)
+  - [Duet](#duet)
+  - [Repetier](#repetier)
+  - [Bambu Labs](#bambu-labs)
+    - [Finding Your Bambu Printer's Serial Number and Access Token](#finding-your-bambu-printers-serial-number-and-access-token)
+    - [Bambu Communication Notes (MQTT & FTP)](#bambu-communication-notes-mqtt--ftp)
+  - [Prusa Connect](#prusa-connect)
+    - [Setting up Prusa Connect](#setting-up-prusa-connect)
+  - [Creality Cloud](#creality-cloud)
+    - [Setting up Creality Cloud](#setting-up-creality-cloud)
+- [Available Tools](#available-tools)
+  - [STL Manipulation Tools](#stl-manipulation-tools)
+  - [Printer Control Tools](#printer-control-tools)
+  - [Bambu-Specific Tools](#bambu-specific-tools)
+- [Available Resources](#available-resources)
+  - [Printer Resources](#printer-resources)
+  - [Bambu Preset Resources](#bambu-preset-resources)
+- [Example Commands for LLM](#example-commands-for-claude)
+- [Bambu Lab Printer Limitations](#bambu-lab-printer-limitations)
+- [Limitations and Considerations](#limitations-and-considerations)
+  - [Memory Usage](#memory-usage)
+  - [STL Manipulation Limitations](#stl-manipulation-limitations)
+  - [Visualization Limitations](#visualization-limitations)
+  - [Performance Considerations](#performance-considerations)
+  - [Testing Recommendations](#testing-recommendations)
+- [Badges](#badges)
+- [License](#license)
+
+</details>
 
 ## Description
 
@@ -21,7 +98,7 @@ This is a server that allows MCP users to connect with the API endpoints of thes
 - Prusa Connect
 - Creality/Ender
 
-This server is a Model Context Protocol (MCP) server for connecting Claude with 3D printer management systems. It allows Claude to interact with 3D printers through the APIs of various printer management systems such as OctoPrint, Klipper (via Moonraker), Duet, Repetier, and Bambu Labs printers.
+This server is a Model Context Protocol (MCP) server for connecting Claude with 3D printer management systems. It allows MCP to interact with 3D printers through the APIs of various printer management systems such as OctoPrint, Klipper (via Moonraker), Duet, Repetier, and Bambu Labs printers.
 
 **Note on Resource Usage**: This MCP server includes advanced 3D model manipulation features that can be memory-intensive when working with large STL files. Please see the "Limitations and Considerations" section for important information about memory usage and performance.
 
@@ -45,6 +122,8 @@ This server is a Model Context Protocol (MCP) server for connecting Claude with
 - Slice STL files to generate G-code
 - Confirm temperature settings in G-code files
 - Complete end-to-end workflow from STL modification to printing
+- Print `.3mf` files directly on Bambu Lab printers (via MQTT command)
+- Read Bambu Studio preset files (printer, filament, process) as resources
 
 ## Installation
 
@@ -62,12 +141,52 @@ npm install -g mcp-3d-printer-server
 ### Install from source
 
 ```bash
-git clone https://github.com/yourusername/mcp-3d-printer-server.git
+git clone https://github.com/dmontgomery40/mcp-3d-printer-server.git
 cd mcp-3d-printer-server
 npm install
 npm link  # Makes the command available globally
 ```
 
+### Running with Docker
+
+You can also run the server using Docker and Docker Compose for a containerized environment.
+
+1.  Ensure you have Docker and Docker Compose installed.
+2.  Copy `.env.example` to `.env` and configure your settings.
+3.  Build and run the container:
+    ```bash
+    docker-compose up --build -d
+    ```
+
+#### Using Slicers with Docker
+
+Please note that the default Docker setup **cannot directly use a slicer installed on your host machine**. Mounting the slicer executable directly from the host into the container is unreliable due to operating system and library differences between your host and the container.
+
+The recommended approach is to **install your preferred slicer *inside* the Docker image**. This makes the container self-sufficient.
+
+To do this, you will need to modify the `Dockerfile`. Here's a conceptual example of how you might add PrusaSlicer or OrcaSlicer (specific commands may vary depending on the slicer, its dependencies, and current Alpine packages):
+
+```dockerfile
+# ... other Dockerfile commands ...
+
+# Example: Install PrusaSlicer or OrcaSlicer (adjust command as needed)
+# Check Alpine package repositories first (e.g., apk add prusaslicer or apk add orcaslicer)
+# If not available, download and install manually (e.g., AppImage):
+# RUN apk add --no-cache fuse # FUSE might be needed for AppImages
+# RUN wget https://example.com/path/to/OrcaSlicer_Linux_Vxxxx.AppImage -O /usr/local/bin/orcaslicer && \
+#     chmod +x /usr/local/bin/orcaslicer
+
+# Set the SLICER_PATH env var accordingly in docker-compose.yml or when running
+# Example for installed executable:
+ENV SLICER_PATH=/usr/local/bin/orcaslicer 
+
+# ... rest of Dockerfile ...
+```
+
+After modifying the `Dockerfile`, rebuild your image (`docker-compose build`). You'll also need to ensure the `SLICER_PATH` environment variable in your `.env` file or `docker-compose.yml` points to the correct path *inside the container* (e.g., `/usr/local/bin/orcaslicer`). Set `SLICER_TYPE` to `orcaslicer` as well.
+
+Apologies for not including a specific slicer out-of-the-box, but given the wide variety of slicers (PrusaSlicer, OrcaSlicer, Cura, etc.) and configurations available, pre-installing one would unnecessarily bloat the image for many users. If a particular slicer becomes a very common request, I can certainly look into adding official support for it in a future version.
+
 ## Configuration
 
 Create a `.env` file in the directory where you'll run the server or set environment variables:
@@ -78,20 +197,26 @@ API_KEY=your_api_key_here
 
 # Default printer connection settings
 PRINTER_HOST=localhost
-PRINTER_PORT=80
-PRINTER_TYPE=octoprint  # Options: octoprint, klipper, duet, repetier, bambu
+PRINTER_PORT=80 # Port for non-Bambu HTTP APIs
+PRINTER_TYPE=octoprint  # Options: octoprint, klipper, duet, repetier, bambu, prusa, creality
 
 # Optional: Directory for temporary files
 TEMP_DIR=/path/to/temp/dir
 
 # Bambu Labs specific configuration
-BAMBU_SERIAL=your_printer_serial
-BAMBU_TOKEN=your_access_token
+BAMBU_SERIAL=your_printer_serial # REQUIRED for Bambu
+BAMBU_TOKEN=your_access_token    # REQUIRED for Bambu
 
-# Slicer configuration
-SLICER_TYPE=prusaslicer  # Options: prusaslicer, cura, slic3r
+# Slicer configuration (for slice_stl tool)
+SLICER_TYPE=prusaslicer  # Options: prusaslicer, cura, slic3r, orcaslicer
 SLICER_PATH=/path/to/slicer/executable
 SLICER_PROFILE=/path/to/slicer/profile
+
+# Optional: Path to Bambu Studio user config dir (for loading presets)
+# Example macOS: /Users/your_user/Library/Application Support/BambuStudio/user/YOUR_USER_ID
+# Example Windows: C:\Users\your_user\AppData\Roaming\BambuStudio\user\YOUR_USER_ID
+# Example Linux: /home/your_user/.config/BambuStudio/user/YOUR_USER_ID
+BAMBU_STUDIO_CONFIG_PATH=
 ```
 
 ## Usage with Claude Desktop
@@ -168,7 +293,7 @@ Repetier-Server is a host software for 3D printers.
 
 Bambu Lab printers use MQTT for status and control and FTP for file operations.
 
-- Authentication: Serial number and access token required
+- Authentication: Serial number and access token required (set `BAMBU_SERIAL` and `BAMBU_TOKEN`)
 - Requirements: Printer must be on the same network or have cloud connection enabled
 - Compatible with: X1C, P1S, P1P, A1, and other Bambu Lab printers
 
@@ -188,6 +313,11 @@ To connect to your Bambu Lab printer, you need two things:
 
 **Note**: If your printer is not on the same local network or you can't find the access token, you may need to update your printer's firmware to the latest version to enable LAN Mode.
 
+#### Bambu Communication Notes (MQTT & FTP)
+
+- **MQTT:** This server uses the local MQTT protocol (port 8883, TLS) based on community findings (e.g., [OpenBambuAPI](https://github.com/Doridian/OpenBambuAPI)) to send commands like starting prints and cancelling jobs.
+- **FTP:** File listing and uploading currently rely on the FTP server running on the printer (via the `bambu-js` library helper). **Note:** This FTP connection might be **unsecured (plain FTP)** based on current library limitations. Use with awareness of your network security.
+
 ### Prusa Connect
 
 Prusa Connect is Prusa's own cloud-based solution for managing their printers.
@@ -220,6 +350,9 @@ Creality Cloud is Creality's management system for their printers.
 
 ## Available Tools
 
+<details>
+<summary>Click to expand STL Manipulation Tools</summary>
+
 ### STL Manipulation Tools
 
 > **Memory Usage Warning**: The following STL manipulation tools load entire 3D models into memory. For large or complex STL files (>10MB), these operations can consume significant memory. When using these tools within the MCP environment, be mindful of memory constraints.
@@ -293,6 +426,37 @@ Move an STL model along specific axes (in millimeters).
 }
 ```
 
+#### merge_vertices
+
+Merge vertices that are closer than a specified tolerance. Helps close small gaps and can slightly simplify the mesh.
+
+```json
+{
+  "stl_path": "/path/to/model.stl",
+  "tolerance": 0.01 // Optional, default = 0.01mm
+}
+```
+
+#### center_model
+
+Translate the model so the center of its bounding box is at the world origin (0,0,0).
+
+```json
+{
+  "stl_path": "/path/to/model.stl"
+}
+```
+
+#### lay_flat
+
+Attempt to identify the largest flat surface of the model (that isn't already facing directly up or down) and rotate the model so this face is oriented downwards on the XY plane (Z=0). Useful for orienting models for printing.
+
+```json
+{
+  "stl_path": "/path/to/model.stl"
+}
+```
+
 #### modify_stl_section
 
 Apply a specific transformation to a selected section of an STL file. This allows for detailed modifications of specific parts of a model.
@@ -380,6 +544,13 @@ Process an STL file (extend base), slice it, confirm temperatures, and start pri
 }
 ```
 
+**Note:** Automatic orientation for optimal printing (minimizing supports, etc.) is a complex task typically handled by slicer GUIs (like OrcaSlicer or PrusaSlicer) and is not implemented in this server.
+
+</details>
+
+<details>
+<summary>Click to expand Printer Control Tools</summary>
+
 ### Printer Control Tools
 
 #### get_printer_status
@@ -394,18 +565,9 @@ Get the current status of the 3D printer.
 }
 ```
 
-For Bambu printers:
-
-```json
-{
-  "host": "192.168.1.100",
-  "type": "bambu",
-  "bambu_serial": "YOUR_PRINTER_SERIAL",
-  "bambu_token": "YOUR_ACCESS_TOKEN"
-}
-```
+For Bambu printers, this currently only confirms MQTT connection.
 
-### list_printer_files
+#### list_printer_files
 
 List files available on the printer.
 
@@ -417,7 +579,9 @@ List files available on the printer.
 }
 ```
 
-### upload_gcode
+For Bambu printers, lists files in the `gcodes` directory via FTP.
+
+#### upload_gcode
 
 Upload a G-code file to the printer.
 
@@ -432,7 +596,9 @@ Upload a G-code file to the printer.
 }
 ```
 
-### start_print
+For Bambu printers, uploads to the `gcodes` directory via FTP. Cannot start print automatically.
+
+#### start_print
 
 Start printing a file that is already on the printer.
 
@@ -445,7 +611,9 @@ Start printing a file that is already on the printer.
 }
 ```
 
-### cancel_print
+**Not recommended for Bambu printers.** Use `print_3mf` for Bambu `.3mf` files.
+
+#### cancel_print
 
 Cancel the current print job.
 
@@ -457,7 +625,9 @@ Cancel the current print job.
 }
 ```
 
-### set_printer_temperature
+For Bambu printers, sends the `stop_print` command via MQTT.
+
+#### set_printer_temperature
 
 Set the temperature of a printer component.
 
@@ -471,11 +641,68 @@ Set the temperature of a printer component.
 }
 ```
 
+**Not supported for Bambu printers** via direct MQTT commands.
+
+</details>
+
+<details open>
+<summary>Click to expand Bambu-Specific Tools</summary>
+
+### Bambu-Specific Tools
+
+#### print_3mf
+
+Uploads a `.3mf` file to a Bambu printer via FTP and initiates the print job via an MQTT command. Allows overriding some print parameters like AMS mapping.
+
+```json
+{
+  "three_mf_path": "/path/to/your_model.3mf",
+  "host": "your_bambu_ip", // Optional if default is set
+  "bambu_serial": "YOUR_SERIAL", // Optional if default is set
+  "bambu_token": "YOUR_TOKEN", // Optional if default is set
+  // Optional Overrides:
+  "use_ams": true, // Default: true
+  "ams_mapping": [0, 1, 2, 3], // Array of AMS slot indices to use
+  "bed_leveling": true, // Default: true
+  "flow_calibration": false, // Default: false
+  "vibration_calibration": false, // Default: false
+  "timelapse": false // Default: false
+}
+```
+
+**Note:** Overriding slicer settings like layer height or temperature via this tool is not supported by the printer's MQTT command. Apply those changes before generating the `.3mf` file.
+
+</details>
+
 ## Available Resources
 
-- `printer://{host}/status` - Current status of the 3D printer
-- `printer://{host}/files` - List of files available on the 3D printer
-- `printer://{host}/file/{filename}` - Content of a specific file on the 3D printer
+<details>
+<summary>Click to expand Printer Resources</summary>
+
+### Printer Resources
+
+- `printer://{host}/status` - Current status of the 3D printer (limited for Bambu currently)
+- `printer://{host}/files` - List of files available on the 3D printer (FTP for Bambu)
+- `printer://{host}/file/{filename}` - Content of a specific G-code file (checks existence only for Bambu)
+
+</details>
+
+<details open>
+<summary>Click to expand Bambu Preset Resources</summary>
+
+### Bambu Preset Resources
+
+If the `BAMBU_STUDIO_CONFIG_PATH` environment variable is set to your Bambu Studio user settings directory, you can read your saved presets.
+
+- `preset://bambu/machine/{preset_name}` - Reads a machine preset file (e.g., `Bambu Lab P1S 0.4 nozzle.json`)
+- `preset://bambu/filament/{preset_name}` - Reads a filament preset file (e.g., `Generic PLA.json`)
+- `preset://bambu/process/{preset_name}` - Reads a process preset file (e.g., `0.20mm Standard @BBL P1S.json`)
+
+**Example Usage:**
+"Read the content of my Bambu process preset named '0.16mm Optimal @BBL P1S'"
+(Claude would call ReadResource with `preset://bambu/process/0.16mm%20Optimal%20%40BBL%20P1S`)
+
+</details>
 
 ## Example Commands for Claude
 
@@ -505,6 +732,11 @@ Here are some example commands you can give to Claude after connecting the MCP s
 - "Slice the modified STL file using PrusaSlicer."
 - "Confirm that the temperatures in the G-code are 200°C for the extruder and 60°C for the bed."
 - "Process this STL file, make the base 2 inches longer, slice it, and start printing, but confirm the temperatures first."
+- "Print `~/Downloads/my_model.3mf` on the Bambu printer."
+- "Upload `~/Desktop/calibration_cube.3mf` to the Bambu printer using AMS slots 0 and 2, and turn off bed leveling."
+- "Cancel the print job on my Bambu P1S."
+- "What are the settings in my Bambu filament preset 'Generic PETG'?"
+- "Show me my Bambu process presets."
 
 ## Bambu Lab Printer Limitations
 
@@ -516,6 +748,12 @@ Due to the nature of the Bambu Lab printer API, there are some limitations:
 
 3. **File management**: Files must be uploaded to the "gcodes" directory on the printer.
 
+4. **FTP Security:** File operations currently use the printer's FTP server, which may be unsecured (plain FTP).
+
+5. **Parameter Overrides:** Only parameters supported by the MQTT `project_file` command can be overridden via the `print_3mf` tool (e.g., AMS usage, calibration flags). Slicer settings like layer height or temperature cannot be changed at print time via this command.
+
+6. **Status Updates:** Full real-time status monitoring via MQTT needs further implementation.
+
 ## Limitations and Considerations
 
 ### Memory Usage
@@ -553,7 +791,7 @@ Due to the nature of the Bambu Lab printer API, there are some limitations:
 | [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://makeapullrequest.com) | We welcome contributions via Pull Requests |
 | [![Node.js Version](https://img.shields.io/badge/node-%3E%3D%2018.0.0-green.svg)](https://nodejs.org/en/download/) | Requires Node.js 18.0.0 or higher |
 | [![Downloads](https://img.shields.io/npm/dm/mcp-3d-printer-server.svg)](https://www.npmjs.com/package/mcp-3d-printer-server) | Number of downloads per month from npm |
-| [![GitHub stars](https://img.shields.io/github/stars/yourusername/mcp-3d-printer-server.svg?style=social&label=Star)](https://github.com/yourusername/mcp-3d-printer-server) | Number of GitHub stars this project has received |
+| [![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) | Number of GitHub stars this project has received |
 
 ## License
 

package/dist/3mf_parser.d.ts

@@ -0,0 +1,3 @@
+import { ThreeMFData } from './types.js';
+export { ThreeMFData };
+export declare function parse3MF(filePath: string): Promise<ThreeMFData>;

package/dist/3mf_parser.js

@@ -0,0 +1,216 @@
+import JSZip from 'jszip';
+import { parseStringPromise } from 'xml2js';
+import * as fs from 'fs/promises';
+// Parses Bambu Studio's JSON config data
+function parseBambuJSONConfig(jsonData) {
+    const config = {};
+    const amsMapping = {};
+    // Map known keys, converting types as needed
+    if (jsonData.layer_height !== undefined)
+        config.layer_height = parseFloat(jsonData.layer_height);
+    if (jsonData.initial_layer_print_height !== undefined)
+        config.first_layer_height = parseFloat(jsonData.initial_layer_print_height);
+    if (jsonData.sparse_infill_density !== undefined)
+        config.sparse_infill_density = parseFloat(jsonData.sparse_infill_density);
+    if (jsonData.sparse_infill_pattern !== undefined)
+        config.sparse_infill_pattern = String(jsonData.sparse_infill_pattern);
+    if (jsonData.enable_support !== undefined)
+        config.support_enabled = String(jsonData.enable_support) === '1' || String(jsonData.enable_support).toLowerCase() === 'true';
+    if (jsonData.support_type !== undefined)
+        config.support_type = String(jsonData.support_type);
+    if (jsonData.support_angle !== undefined)
+        config.support_threshold_angle = parseFloat(jsonData.support_angle);
+    if (jsonData.raft_layers !== undefined)
+        config.raft_layers = parseInt(String(jsonData.raft_layers), 10);
+    if (jsonData.brim_width !== undefined)
+        config.brim_width = parseFloat(jsonData.brim_width);
+    if (jsonData.wall_loops !== undefined)
+        config.wall_loops = parseInt(String(jsonData.wall_loops), 10);
+    if (jsonData.top_shell_layers !== undefined)
+        config.top_shell_layers = parseInt(String(jsonData.top_shell_layers), 10);
+    if (jsonData.bottom_shell_layers !== undefined)
+        config.bottom_shell_layers = parseInt(String(jsonData.bottom_shell_layers), 10);
+    // Temperatures (handle potential arrays)
+    if (Array.isArray(jsonData.nozzle_temperature) && jsonData.nozzle_temperature.length > 0) {
+        config.nozzle_temperature = jsonData.nozzle_temperature.map((t) => parseFloat(String(t)));
+    }
+    else if (jsonData.nozzle_temperature !== undefined) {
+        config.nozzle_temperature = [parseFloat(String(jsonData.nozzle_temperature))];
+    }
+    // Bed Temp (prefer initial layer temp)
+    let bedTempKey = jsonData.hot_plate_temp_initial_layer !== undefined ? 'hot_plate_temp_initial_layer' : 'hot_plate_temp';
+    if (jsonData[bedTempKey] !== undefined) {
+        if (Array.isArray(jsonData[bedTempKey]) && jsonData[bedTempKey].length > 0) {
+            config.bed_temperature = parseFloat(String(jsonData[bedTempKey][0]));
+        }
+        else {
+            config.bed_temperature = parseFloat(String(jsonData[bedTempKey]));
+        }
+    }
+    // Filaments and Flow (handle potential arrays)
+    if (Array.isArray(jsonData.filament_type) && jsonData.filament_type.length > 0) {
+        config.filament_type = jsonData.filament_type.map(String);
+    }
+    if (Array.isArray(jsonData.filament_flow_ratio) && jsonData.filament_flow_ratio.length > 0) {
+        config.flow_ratio = jsonData.filament_flow_ratio.map((f) => parseFloat(String(f)));
+    }
+    // AMS Mapping (derive from filament_settings_id order)
+    if (Array.isArray(jsonData.filament_settings_id) && jsonData.filament_settings_id.length > 0) {
+        jsonData.filament_settings_id.forEach((filamentId, index) => {
+            // Map filament ID (e.g., "Generic PLA @BBL P1P") to its index (assumed AMS slot)
+            if (filamentId) { // Ensure filamentId is not empty
+                amsMapping[filamentId] = index;
+            }
+        });
+        if (Object.keys(amsMapping).length > 0) {
+            config.ams_mapping = amsMapping;
+        }
+    }
+    // Store remaining keys found in the config
+    for (const key in jsonData) {
+        if (!config.hasOwnProperty(key)) {
+            // Simple assignment for remaining keys, preserving original type if possible
+            config[key] = jsonData[key];
+        }
+    }
+    return config;
+}
+async function parseBambuConfig(zip) {
+    // Look for common Bambu config file names
+    const potentialFiles = ['Metadata/project_settings.config', 'Metadata/model_settings.config', 'Metadata/slice_info.config'];
+    let configFile = null;
+    let configContent = '';
+    for (const name of potentialFiles) {
+        const file = zip.file(name);
+        if (file) {
+            configFile = file;
+            configContent = await file.async('string');
+            console.log(`Found Bambu config file: ${configFile.name}`);
+            break; // Use the first one found (project usually has the most)
+        }
+    }
+    if (configFile && configContent) {
+        try {
+            // Attempt to parse as JSON
+            const jsonData = JSON.parse(configContent);
+            const parsedConfig = parseBambuJSONConfig(jsonData);
+            console.log('Bambu config parsed successfully as JSON.');
+            return parsedConfig;
+        }
+        catch (jsonError) {
+            console.warn(`Failed to parse ${configFile.name} as JSON: ${jsonError.message}. Attempting INI parse as fallback...`);
+            // Fallback: Try parsing as INI if JSON fails (though unlikely based on sample)
+            try {
+                const parsedConfig = parseFallbackINIConfig(configContent); // Keep a simple INI parser as fallback
+                console.log('Bambu config parsed successfully as INI (fallback).');
+                return parsedConfig;
+            }
+            catch (iniError) {
+                console.error(`Error parsing Bambu config ${configFile.name} as INI (fallback):`, iniError);
+                return {};
+            }
+        }
+    }
+    else {
+        console.log('No Bambu-specific config file found in Metadata directory.');
+        return {};
+    }
+}
+// Fallback INI parser (Simplified version of the previous one)
+function parseFallbackINIConfig(configContent) {
+    const config = {};
+    const lines = configContent.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#') || trimmedLine.startsWith(';'))
+            continue;
+        const equalsIndex = trimmedLine.indexOf('=');
+        if (equalsIndex === -1)
+            continue;
+        const key = trimmedLine.substring(0, equalsIndex).trim();
+        const value = trimmedLine.substring(equalsIndex + 1).trim();
+        // Simple assignment - no type conversion here for fallback
+        config[key] = value;
+    }
+    return config;
+}
+async function parse3DModelConfig(zip) {
+    const modelFile = zip.file('3D/3dmodel.model');
+    if (!modelFile) {
+        throw new Error('3D/3dmodel.model not found in 3MF archive');
+    }
+    const modelContent = await modelFile.async('string');
+    try {
+        const parsedXml = await parseStringPromise(modelContent, {
+            explicitArray: false,
+            mergeAttrs: true,
+            charkey: 'value'
+        });
+        const modelData = parsedXml.model;
+        if (!modelData) {
+            throw new Error('Invalid 3dmodel.model format: <model> tag not found.');
+        }
+        const metadata = { unit: modelData.unit || 'millimeter' };
+        if (modelData.metadata) {
+            const metas = Array.isArray(modelData.metadata) ? modelData.metadata : [modelData.metadata];
+            metas.forEach((meta) => {
+                if (meta.name && meta.value !== undefined) {
+                    metadata[meta.name] = String(meta.value);
+                }
+            });
+        }
+        const objects = [];
+        if (modelData.resources?.object) {
+            const resources = Array.isArray(modelData.resources.object) ? modelData.resources.object : [modelData.resources.object];
+            resources.forEach((objResource) => {
+                objects.push({
+                    id: objResource.id,
+                    name: objResource.name,
+                    type: objResource.type || 'model'
+                    // Actual mesh data (vertices, triangles) is nested deeper if needed
+                });
+            });
+        }
+        const buildItems = [];
+        if (modelData.build?.item) {
+            const items = Array.isArray(modelData.build.item) ? modelData.build.item : [modelData.build.item];
+            items.forEach((item) => {
+                buildItems.push({
+                    objectId: item.objectid,
+                    transform: item.transform
+                });
+            });
+        }
+        console.log('3dmodel.model parsed successfully.');
+        return { metadata, objects, build: { items: buildItems } };
+    }
+    catch (error) {
+        console.error('Error parsing 3dmodel.model XML:', error);
+        throw new Error(`Failed to parse 3dmodel.model: ${error.message}`);
+    }
+}
+export async function parse3MF(filePath) {
+    console.log(`Parsing 3MF file: ${filePath}`);
+    try {
+        const data = await fs.readFile(filePath);
+        const zip = await JSZip.loadAsync(data);
+        // List files for debugging
+        // const fileList = Object.keys(zip.files);
+        // console.log('Files in 3MF:', fileList);
+        const { metadata, objects, build } = await parse3DModelConfig(zip);
+        const bambuConfig = await parseBambuConfig(zip);
+        // Combine data into the final structure
+        const combinedData = {
+            metadata,
+            objects,
+            build,
+            slicerConfig: bambuConfig
+        };
+        console.log('3MF parsing completed.');
+        return combinedData;
+    }
+    catch (error) {
+        console.error(`Error parsing 3MF file ${filePath}:`, error);
+        throw new Error(`Failed to parse 3MF file: ${error.message}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};