feat: add delete_printer_file MCP tool

- New deleteFile() in BambuImplementation: FTPS DELETE via basic-ftp
  using the same TLS-session-ticket dance as ftpUpload.
- Confirm-gated (confirm:true required) so a default invocation can't
  destroy data; returns status:"skipped" otherwise without contacting
  the printer.
- Path safety: rejects ".." segments, restricts deletes to cache/,
  timelapse/, and logs/ to prevent walking the filesystem.
- Bare filenames default to cache/<name>; relative paths to other
  allowed dirs are honored as-is.
- README features bullet + delete_printer_file tool section updated.
- 5 new unit tests cover the gating, path safety, and happy path.

npm test: 28/28.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: rowbotik

PROGRESS.md

@@ -1,5 +1,49 @@
 # Progress
 
+## Latest commit (2026-04-27)
+
+`12ae6b9 fix(h2): require explicit AMS mapping; reject SuperTack on CLI slicing`
+landed on `codex/collar-charm-h2-cleanup` (not pushed). Stacked on top:
+new `delete_printer_file` MCP tool with confirm-gate + path-allowlist
+guard rails. `npm test` now passes **28/28** (added 5 unit tests for the
+delete behavior). Not committed yet — see "Working state" below.
+
+### Working state
+
+Tracked local changes since `12ae6b9`:
+
+- `README.md` — features bullet, new `delete_printer_file` section
+- `PROGRESS.md` — this section
+- `src/index.ts` — tool registration + dispatch case
+- `src/printers/bambu.ts` — `deleteFile()` (public) and `ftpDelete()` (private)
+- `tests/behavior.test.mjs` — 5 new tests:
+  - `confirm:true` required, otherwise `status: "skipped"` with no FTP
+  - path traversal rejected
+  - paths outside `cache/`/`timelapse/`/`logs/` rejected
+  - happy path: bare names normalize to `cache/`, ftpDelete called with absolute path
+  - `timelapse/` and `logs/` paths accepted as-is
+- rebuilt `dist/` (`dist/index.js`, `dist/printers/bambu.js`)
+
+Suggested commit message:
+
+```
+feat: add delete_printer_file MCP tool
+
+- New deleteFile() in BambuImplementation: FTPS DELETE via basic-ftp
+  using the same TLS-session-ticket dance as ftpUpload.
+- Confirm-gated (confirm:true required) so a default invocation can't
+  destroy data; returns status:"skipped" otherwise without contacting
+  the printer.
+- Path safety: rejects ".." segments, restricts deletes to cache/,
+  timelapse/, and logs/ to prevent walking the filesystem.
+- Bare filenames default to cache/<name>; relative paths to other
+  allowed dirs are honored as-is.
+- README features bullet + delete_printer_file tool section updated.
+- 5 new unit tests cover the gating, path safety, and happy path.
+
+Total npm test: 28/28.
+```
+
 ## Current handoff (2026-04-27)
 
 Branch: `codex/collar-charm-h2-cleanup`.

README.md

@@ -68,7 +68,7 @@ Local handoff note: see [REMOTE-DEPLOYMENT.md](./REMOTE-DEPLOYMENT.md) for the c
 
 - Get detailed printer status: temperatures (nozzle, bed, chamber), print progress, current layer, time remaining, and live AMS slot data
 - Query live AMS inventory with resolved Bambu/Orca filament profile paths via `get_printer_filaments`
-- List, upload, and manage files on the printer's SD card via FTPS
+- List, upload, and delete files on the printer's SD card via FTPS
 - Upload and print pre-sliced `.gcode.3mf` files with full plate selection and calibration flag control (recommended path — see [docs/SLICING.md](./docs/SLICING.md))
 - Optional auto-slice path via BambuStudio CLI. Set `BAMBU_CLI_FLATTEN=true` to enable a workaround that flattens BBL profile inheritance before invoking the CLI — works around upstream bugs in BambuStudio CLI mode ([#9636](https://github.com/bambulab/BambuStudio/issues/9636), [#9968](https://github.com/bambulab/BambuStudio/issues/9968)). Verified on H2S/H2D/X1C/P1S. Default off; Path A (GUI-slice) remains the recommended workflow for non-BBL profiles or first-time prints. See [docs/SLICING.md](./docs/SLICING.md).
 - Parse AMS mapping from the 3MF's embedded slicer metadata (`Metadata/plate_<n>.json` + gcode filament header) and send it correctly formatted per the OpenBambuAPI spec
@@ -678,6 +678,27 @@ List files stored on the printer's SD card. Scans the `cache/`, `timelapse/`, an
 }
 ```
 
+#### delete_printer_file
+
+Delete a single file from the printer's SD card via FTPS. **Destructive.** Requires `confirm: true` — without it the call returns `status: "skipped"` and does not contact the printer. Path traversal segments (`..`) are rejected. Only files under `cache/`, `timelapse/`, and `logs/` can be deleted.
+
+```json
+{
+  "filename": "old_print.gcode.3mf",
+  "confirm": true,
+  "host": "192.168.1.100",
+  "bambu_serial": "01P00A123456789",
+  "bambu_token": "your_access_token"
+}
+```
+
+A bare filename defaults to `cache/<filename>`. To target other directories pass a relative path:
+
+```json
+{ "filename": "timelapse/2026-04-26_12-00.mp4", "confirm": true }
+{ "filename": "logs/printer.log", "confirm": true }
+```
+
 #### upload_gcode
 
 Write G-code content from a string directly to the printer's `cache/` directory. The content is written to a temporary file and uploaded via FTPS.

dist/index.js

@@ -1039,6 +1039,27 @@ class BambuPrinterMCPServer {
                             }
                         }
                     },
+                    {
+                        name: "delete_printer_file",
+                        description: "Delete a file from the Bambu Lab printer's SD card via FTPS. Destructive: requires confirm:true. Restricted to cache/, timelapse/, and logs/ directories. Path traversal segments (..) are rejected.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                filename: {
+                                    type: "string",
+                                    description: "File to delete. Bare names default to cache/<name>; pass a relative path like timelapse/foo.mp4 to target other allowed directories."
+                                },
+                                confirm: {
+                                    type: "boolean",
+                                    description: "Must be true to actually delete. When false or omitted the call returns without sending an FTP request."
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["filename"]
+                        }
+                    },
                     {
                         name: "upload_gcode",
                         description: "Upload a G-code file to the Bambu Lab printer",
@@ -1458,6 +1479,12 @@ class BambuPrinterMCPServer {
                     case "list_printer_files":
                         result = await this.bambu.getFiles(host, bambuSerial, bambuToken);
                         break;
+                    case "delete_printer_file":
+                        if (!args?.filename) {
+                            throw new Error("Missing required parameter: filename");
+                        }
+                        result = await this.bambu.deleteFile(host, bambuSerial, bambuToken, String(args.filename), Boolean(args.confirm));
+                        break;
                     case "upload_gcode": {
                         if (!args?.filename || !args?.gcode) {
                             throw new Error("Missing required parameters: filename and gcode");

dist/printers/bambu.d.ts

@@ -71,6 +71,29 @@ export declare class BambuImplementation {
         message: string;
         file: string;
     }>;
+    /**
+     * Delete a single file from the printer's SD card via FTPS.
+     *
+     * Destructive. Caller MUST set confirm=true; otherwise we return without
+     * touching the printer. Path is normalized the same way uploadFile()
+     * normalizes -- if the caller passes a bare filename, we look in cache/.
+     * Path traversal (`..`) is rejected.
+     *
+     * Only the printer-managed directories (cache/, timelapse/, logs/) are
+     * accepted as parents to avoid letting an agent wander further into the
+     * filesystem than expected.
+     */
+    deleteFile(host: string, _serial: string, token: string, filename: string, confirm: boolean): Promise<{
+        status: string;
+        deleted: boolean;
+        remotePath: string;
+        message?: string;
+    }>;
+    /**
+     * Delete a single remote file via FTPS, using basic-ftp directly so we
+     * get the same TLS-session-ticket handshake as ftpUpload().
+     */
+    private ftpDelete;
     /**
      * 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

dist/printers/bambu.js

@@ -910,6 +910,72 @@ export class BambuImplementation {
             file: remoteFile,
         };
     }
+    /**
+     * Delete a single file from the printer's SD card via FTPS.
+     *
+     * Destructive. Caller MUST set confirm=true; otherwise we return without
+     * touching the printer. Path is normalized the same way uploadFile()
+     * normalizes -- if the caller passes a bare filename, we look in cache/.
+     * Path traversal (`..`) is rejected.
+     *
+     * Only the printer-managed directories (cache/, timelapse/, logs/) are
+     * accepted as parents to avoid letting an agent wander further into the
+     * filesystem than expected.
+     */
+    async deleteFile(host, _serial, token, filename, confirm) {
+        if (!confirm) {
+            return {
+                status: "skipped",
+                deleted: false,
+                remotePath: filename,
+                message: "delete_printer_file requires confirm:true. No FTP request was made.",
+            };
+        }
+        const normalizedFileName = filename.replace(/^\/+/, "");
+        if (normalizedFileName.length === 0) {
+            throw new Error("delete_printer_file: filename is required.");
+        }
+        if (normalizedFileName.split("/").some((seg) => seg === "..")) {
+            throw new Error(`delete_printer_file: path traversal segments are not allowed (got "${filename}").`);
+        }
+        const remotePath = normalizedFileName.includes("/")
+            ? normalizedFileName
+            : `cache/${normalizedFileName}`;
+        const topDir = remotePath.split("/")[0];
+        const ALLOWED_DIRS = new Set(["cache", "timelapse", "logs"]);
+        if (!ALLOWED_DIRS.has(topDir)) {
+            throw new Error(`delete_printer_file: refusing to delete outside cache/, timelapse/, logs/. Got "${remotePath}".`);
+        }
+        await this.ftpDelete(host, token, `/${remotePath}`);
+        return {
+            status: "success",
+            deleted: true,
+            remotePath,
+        };
+    }
+    /**
+     * Delete a single remote file via FTPS, using basic-ftp directly so we
+     * get the same TLS-session-ticket handshake as ftpUpload().
+     */
+    async ftpDelete(host, token, remotePath) {
+        const client = new FTPClient(15000);
+        try {
+            await client.access({
+                host,
+                port: 990,
+                user: "bblp",
+                password: token,
+                secure: "implicit",
+                secureOptions: ftpsSecureOptions(),
+            });
+            await this.waitForTlsSession(client);
+            const absoluteRemote = remotePath.startsWith("/") ? remotePath : `/${remotePath}`;
+            await client.remove(absoluteRemote);
+        }
+        finally {
+            client.close();
+        }
+    }
     /**
      * 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

src/index.ts

@@ -1324,6 +1324,27 @@ class BambuPrinterMCPServer {
               }
             }
           },
+          {
+            name: "delete_printer_file",
+            description: "Delete a file from the Bambu Lab printer's SD card via FTPS. Destructive: requires confirm:true. Restricted to cache/, timelapse/, and logs/ directories. Path traversal segments (..) are rejected.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                filename: {
+                  type: "string",
+                  description: "File to delete. Bare names default to cache/<name>; pass a relative path like timelapse/foo.mp4 to target other allowed directories."
+                },
+                confirm: {
+                  type: "boolean",
+                  description: "Must be true to actually delete. When false or omitted the call returns without sending an FTP request."
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["filename"]
+            }
+          },
           {
             name: "upload_gcode",
             description: "Upload a G-code file to the Bambu Lab printer",
@@ -1782,6 +1803,19 @@ class BambuPrinterMCPServer {
             result = await this.bambu.getFiles(host, bambuSerial, bambuToken);
             break;
 
+          case "delete_printer_file":
+            if (!args?.filename) {
+              throw new Error("Missing required parameter: filename");
+            }
+            result = await this.bambu.deleteFile(
+              host,
+              bambuSerial,
+              bambuToken,
+              String(args.filename),
+              Boolean(args.confirm)
+            );
+            break;
+
           case "upload_gcode": {
             if (!args?.filename || !args?.gcode) {
               throw new Error("Missing required parameters: filename and gcode");

src/printers/bambu.ts

@@ -1140,6 +1140,90 @@ export class BambuImplementation {
     };
   }
 
+  /**
+   * Delete a single file from the printer's SD card via FTPS.
+   *
+   * Destructive. Caller MUST set confirm=true; otherwise we return without
+   * touching the printer. Path is normalized the same way uploadFile()
+   * normalizes -- if the caller passes a bare filename, we look in cache/.
+   * Path traversal (`..`) is rejected.
+   *
+   * Only the printer-managed directories (cache/, timelapse/, logs/) are
+   * accepted as parents to avoid letting an agent wander further into the
+   * filesystem than expected.
+   */
+  async deleteFile(
+    host: string,
+    _serial: string,
+    token: string,
+    filename: string,
+    confirm: boolean
+  ): Promise<{ status: string; deleted: boolean; remotePath: string; message?: string }> {
+    if (!confirm) {
+      return {
+        status: "skipped",
+        deleted: false,
+        remotePath: filename,
+        message:
+          "delete_printer_file requires confirm:true. No FTP request was made.",
+      };
+    }
+
+    const normalizedFileName = filename.replace(/^\/+/, "");
+    if (normalizedFileName.length === 0) {
+      throw new Error("delete_printer_file: filename is required.");
+    }
+    if (
+      normalizedFileName.split("/").some((seg) => seg === "..")
+    ) {
+      throw new Error(
+        `delete_printer_file: path traversal segments are not allowed (got "${filename}").`
+      );
+    }
+
+    const remotePath = normalizedFileName.includes("/")
+      ? normalizedFileName
+      : `cache/${normalizedFileName}`;
+    const topDir = remotePath.split("/")[0];
+    const ALLOWED_DIRS = new Set(["cache", "timelapse", "logs"]);
+    if (!ALLOWED_DIRS.has(topDir)) {
+      throw new Error(
+        `delete_printer_file: refusing to delete outside cache/, timelapse/, logs/. Got "${remotePath}".`
+      );
+    }
+
+    await this.ftpDelete(host, token, `/${remotePath}`);
+
+    return {
+      status: "success",
+      deleted: true,
+      remotePath,
+    };
+  }
+
+  /**
+   * Delete a single remote file via FTPS, using basic-ftp directly so we
+   * get the same TLS-session-ticket handshake as ftpUpload().
+   */
+  private async ftpDelete(host: string, token: string, remotePath: string): Promise<void> {
+    const client = new FTPClient(15_000);
+    try {
+      await client.access({
+        host,
+        port: 990,
+        user: "bblp",
+        password: token,
+        secure: "implicit",
+        secureOptions: ftpsSecureOptions(),
+      });
+      await this.waitForTlsSession(client);
+      const absoluteRemote = remotePath.startsWith("/") ? remotePath : `/${remotePath}`;
+      await client.remove(absoluteRemote);
+    } finally {
+      client.close();
+    }
+  }
+
   /**
    * 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