mcp-3d-printer-server 1.2.25 → 1.2.27

package/src/printers/creality.ts

@@ -1,5 +1,5 @@
 import type { AxiosInstance } from "axios";
-import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate, type CameraCandidate } from "./generic-base.js";
 import { KlipperImplementation, MACRO_TIMEOUT_MS } from "./klipper.js";
 import type { ConfirmHardware } from "../safety/confirmation.js";
 import type { CounterpartProgress, FilamentSlot, PrinterIdentity } from "../counterpart/contract.js";
@@ -73,6 +73,11 @@ export class CrealityImplementation extends GenericPrinterImplementation {
     return moonraker ? this.moonraker.snapshotCandidates(host, moonraker, "") : [];
   }
 
+  async cameraCandidates(host: string): Promise<CameraCandidate[]> {
+    const moonraker = await this.moonrakerPort(host);
+    return moonraker ? this.moonraker.cameraCandidates(host, moonraker, "") : [];
+  }
+
   async counterpartFilaments(host: string, port: string, apiKey: string): Promise<FilamentSlot[]> {
     const moonraker = await this.moonrakerPort(host);
     return moonraker ? this.moonraker.counterpartFilaments(host, moonraker, "") : super.counterpartFilaments(host, port, apiKey);
@@ -111,7 +116,7 @@ export class CrealityImplementation extends GenericPrinterImplementation {
     }
     const state = raw.trim().toLowerCase();
     if (IDLE_STATES.has(state)) return { state, ready: true };
-    if (FINISHED_STATES.has(state)) return { state, ready: true, finishedJob: JSON.stringify([state]) };
+    if (FINISHED_STATES.has(state)) return { state, ready: true };
     return { state, ready: false, reason: `state is ${state}` };
   }
 
@@ -217,4 +222,4 @@ export class CrealityImplementation extends GenericPrinterImplementation {
     
     return response.data;
   }
-} 
+}

package/src/printers/generic-base.ts

@@ -26,6 +26,12 @@ export interface SnapshotCandidate {
   /** True when the firmware's own settings name this URL; false for a conventional fallback. */
   configured: boolean;
 }
+export interface CameraCandidate extends SnapshotCandidate {
+  transport: "http-mjpeg" | "http-snapshot";
+  /** Snapshot belonging to this same camera, never an unrelated later candidate. */
+  snapshotUrl?: string;
+  unsupportedStream?: boolean;
+}
 
 /** Normalized adapter state used by the print and heating preflight. */
 export interface GenericPrinterState {
@@ -35,8 +41,6 @@ export interface GenericPrinterState {
   ready: boolean;
   /** Why the printer is not ready. */
   reason?: string;
-  /** Set when the printer explicitly reports a finished or cancelled job that may still be on the bed. */
-  finishedJob?: string;
 }
 
 export interface HeaterComponent {
@@ -51,8 +55,8 @@ export const REMOTE_DOWNLOAD_TIMEOUT_MS = 120_000;
 /**
  * Shared print and heating gate for non-Bambu adapters. Public mutations
  * validate every input before connecting, inspect the exact bytes that are
- * uploaded, check fresh adapter state, ask a human (MCP elicitation), recheck
- * state and only then dispatch. Heater-off and cancel are never gated.
+ * uploaded, check fresh adapter state, recheck it and only then dispatch.
+ * Heater-off and cancel are never gated.
  */
 /** seenRunning: a report showed this job printing or paused, so a later ended report is about it, not about the previous job. */
 type CheckedJob = { name: string; sha256: string; peaks: GenericPrintInspection["peaks"]; materials: string[]; seenRunning: boolean };
@@ -105,6 +109,11 @@ export abstract class GenericPrinterImplementation extends PrinterImplementation
     return [];
   }
 
+  /** Existing snapshot discovery is the fallback for cameras without an MJPEG URL. */
+  async cameraCandidates(host: string, port: string, apiKey: string): Promise<CameraCandidate[]> {
+    return (await this.snapshotCandidates(host, port, apiKey)).map(candidate => ({...candidate, transport: "http-snapshot"}));
+  }
+
   /** The single extruder slot; adapters with a spool manager override this. */
   async counterpartFilaments(_host: string, _port: string, _apiKey: string): Promise<FilamentSlot[]> {
     return [{ id: "ext", source: "unknown" }];
@@ -135,9 +144,9 @@ export abstract class GenericPrinterImplementation extends PrinterImplementation
    * Resume reheats and moves the printer, so it is gated like a print start:
    * only the job this server instance inspected and started, only while the
    * printer freshly reports that job paused, with its bytes re-read and
-   * compared where the firmware can download them, and after human
-   * confirmation (unless the server opted out). A stop or heater-off request
-   * in the meantime cancels it.
+   * compared where the firmware can download them. Only when the bytes cannot
+   * be re-read does a person confirm (MCP elicitation). A stop or heater-off
+   * request in the meantime cancels it.
    */
   async resumeJob(host: string, port: string, apiKey: string): Promise<{ status: string; action: "resume"; message: string; jobName: string; bytesVerified: boolean }> {
     if (!(await this.supportsPauseResume(host, port, apiKey)) || !this.rawResumeJob) {
@@ -165,21 +174,23 @@ export abstract class GenericPrinterImplementation extends PrinterImplementation
         bytesVerified = true;
       }
       assertActive();
-      await requireHumanConfirmation(
-        this.confirm,
-        `Resume ${checked.name} on ${this.printerLabel} (${host}:${port})? It reheats to its targets (peak nozzle ${checked.peaks.nozzle}°C, ` +
-        `bed ${checked.peaks.bed}°C, chamber ${checked.peaks.chamber}°C) and moves. Materials: ${checked.materials.length ? checked.materials.join(", ") : "none declared"}. ` +
-        `File SHA-256: ${checked.sha256}${bytesVerified ? " (re-read from the printer)" : " (this firmware cannot re-read the file; matched by name)"}. ` +
-        "Confirm the nozzle path is clear and the filament is still loaded.",
-        "generic"
-      );
-      assertActive();
-      // Someone may have resumed or stopped it at the printer while the prompt was open.
+      if (!bytesVerified) {
+        // This firmware cannot hand the file back, so only a person can tell it is still the inspected job.
+        await requireHumanConfirmation(
+          this.confirm,
+          `Resume ${checked.name} on ${this.printerLabel} (${host}:${port})? This firmware cannot re-read the file, so it is matched by name only. ` +
+          `It reheats to its targets (peak nozzle ${checked.peaks.nozzle}°C, bed ${checked.peaks.bed}°C, chamber ${checked.peaks.chamber}°C) and moves. ` +
+          `Materials: ${checked.materials.length ? checked.materials.join(", ") : "none declared"}. Inspected file SHA-256: ${checked.sha256}. ` +
+          "Confirm the paused job is that file, the nozzle path is clear and the filament is still loaded."
+        );
+        assertActive();
+      }
+      // Someone may have resumed or stopped it at the printer meanwhile (for example while a prompt was open).
       await this.assertPausedJob(host, port, apiKey, checked.name);
-      // A progress read during the prompt may have retired this record (the job ended, and a new one
-      // could now be paused under the same name); only the record that was confirmed may be resumed.
+      // A progress read meanwhile may have retired this record (the job ended, and a new one
+      // could now be paused under the same name); only the record that was checked may be resumed.
       if (this.checkedJobs.get(key) !== checked) {
-        throw new Error(`Print safety: ${checked.name} ended on ${this.printerLabel} while the confirmation was open; nothing was sent.`);
+        throw new Error(`Print safety: ${checked.name} ended on ${this.printerLabel} during the resume checks; nothing was sent.`);
       }
       assertActive();
       await this.rawResumeJob!(host, port, apiKey);
@@ -276,12 +287,6 @@ export abstract class GenericPrinterImplementation extends PrinterImplementation
     validateGenericTemperature(target.heater, value, material ? [material] : undefined);
     return withPrinterOperation(host, key, async (assertActive) => {
       this.assertReady(await this.readPrinterState(host, port, apiKey), "heat");
-      await requireHumanConfirmation(
-        this.confirm,
-        `Heat ${target.heater} on ${this.printerLabel} (${host}:${port}) to ${value}°C?` +
-        (material && target.heater === "nozzle" ? ` Declared material: ${material}. Confirm the loaded filament matches.` : ""),
-        "generic"
-      );
       assertActive();
       this.assertReady(await this.readPrinterState(host, port, apiKey), "heat");
       assertActive();
@@ -393,10 +398,9 @@ export abstract class GenericPrinterImplementation extends PrinterImplementation
     assertExpectedPeaks(options.expectedPeaks, { nozzle: inspection.peaks.nozzle, bed: inspection.peaks.bed });
     const initial = await this.readPrinterState(host, port, apiKey);
     this.assertReady(initial, "print");
-    await requireHumanConfirmation(this.confirm, this.printPrompt(host, port, remoteName, inspection, initial), "generic");
     assertActive();
-    const confirmed = await this.readPrinterState(host, port, apiKey);
-    this.assertReady(confirmed, "print");
+    const rechecked = await this.readPrinterState(host, port, apiKey);
+    this.assertReady(rechecked, "print");
     assertActive();
 
     const summary = {
@@ -436,15 +440,4 @@ export abstract class GenericPrinterImplementation extends PrinterImplementation
     this.checkedJobs.set(this.operationKey(host, port), checkedJob(remoteName, inspection));
     return { ...summary, upload, response };
   }
-
-  private printPrompt(host: string, port: string, remoteName: string, inspection: GenericPrintInspection, state: GenericPrinterState): string {
-    const materials = inspection.materials.length ? inspection.materials.join(", ") : "none declared (no positive nozzle target)";
-    return (
-      `Start a checked print of ${remoteName} on ${this.printerLabel} (${host}:${port})? ` +
-      `Materials: ${materials} (${inspection.materialSource}). Peak targets: nozzle ${inspection.peaks.nozzle}°C, bed ${inspection.peaks.bed}°C, chamber ${inspection.peaks.chamber}°C ` +
-      `(server ceilings ${inspection.ceilings.nozzle}/${inspection.ceilings.bed}/${inspection.ceilings.chamber}°C). File SHA-256: ${inspection.sha256}. ` +
-      "Confirm the loaded filament matches." +
-""
-    );
-  }
 }

package/src/printers/klipper.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import FormData from "form-data";
 import { isAxiosError } from "axios";
-import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate, type CameraCandidate } from "./generic-base.js";
 import type { CounterpartProgress, FilamentSlot, PrinterIdentity } from "../counterpart/contract.js";
 import { finiteNumber, nonEmptyText } from "../counterpart/contract.js";
 import { mapMoonraker } from "../counterpart/progress.js";
@@ -66,11 +66,19 @@ export class KlipperImplementation extends GenericPrinterImplementation {
    * path relative to the host. https://moonraker.readthedocs.io/en/latest/external_api/webcams/
    */
   async snapshotCandidates(host: string, port: string, apiKey: string): Promise<SnapshotCandidate[]> {
+    return (await this.cameraCandidates(host, port, apiKey)).filter(candidate => candidate.transport === "http-snapshot");
+  }
+
+  async cameraCandidates(host: string, port: string, apiKey: string): Promise<CameraCandidate[]> {
     const data = (await this.apiClient.get(`http://${host}:${port}/server/webcams/list`, this.authHeaders(apiKey))).data;
     const webcams = Array.isArray(data?.result?.webcams) ? data.result.webcams : [];
     return webcams
-      .filter((webcam: any) => webcam?.enabled !== false && nonEmptyText(webcam?.snapshot_url))
-      .map((webcam: any) => ({ url: String(webcam.snapshot_url).trim(), source: "moonraker-webcam", configured: true }));
+      .filter((webcam: any) => webcam?.enabled !== false)
+      .flatMap((webcam: any) => [
+        ...(nonEmptyText(webcam?.stream_url)
+          ? [{url: String(webcam.stream_url).trim(), snapshotUrl: nonEmptyText(webcam?.snapshot_url), unsupportedStream: /webrtc|hls/i.test(String(webcam?.service ?? "")), transport: "http-mjpeg" as const}] : []),
+        ...(nonEmptyText(webcam?.snapshot_url) ? [{url: String(webcam.snapshot_url).trim(), transport: "http-snapshot" as const}] : []),
+      ].map(candidate => ({...candidate, source: "moonraker-webcam", configured: true})));
   }
 
   /**
@@ -175,11 +183,7 @@ export class KlipperImplementation extends GenericPrinterImplementation {
     if (!["standby", "complete", "cancelled"].includes(job)) {
       return { state, ready: false, reason: `print_stats.state is ${job}` };
     }
-    return {
-      state,
-      ready: true,
-      finishedJob: job === "standby" ? undefined : JSON.stringify([job, status?.print_stats?.filename ?? null]),
-    };
+    return { state, ready: true };
   }
 
   protected async downloadRemoteFile(host: string, port: string, apiKey: string, filename: string, destination: string): Promise<void> {

package/src/printers/octoprint.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import FormData from "form-data";
 import { isAxiosError } from "axios";
-import { GenericPrinterImplementation, type GenericPrinterState, type HeaterComponent, type SnapshotCandidate } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type HeaterComponent, type SnapshotCandidate, type CameraCandidate } from "./generic-base.js";
 import type { CounterpartProgress, PrinterIdentity } from "../counterpart/contract.js";
 import { nonEmptyText } from "../counterpart/contract.js";
 import { mapOctoPrint } from "../counterpart/progress.js";
@@ -55,20 +55,27 @@ export class OctoPrintImplementation extends GenericPrinterImplementation {
    * src/octoprint/plugins/classicwebcam/__init__.py; checked on 1.8.7 and 1.11.2.
    */
   async snapshotCandidates(host: string, port: string, apiKey: string): Promise<SnapshotCandidate[]> {
+    return (await this.cameraCandidates(host, port, apiKey)).filter(candidate => candidate.transport === "http-snapshot");
+  }
+
+  async cameraCandidates(host: string, port: string, apiKey: string): Promise<CameraCandidate[]> {
     const settings = (await this.apiClient.get(`http://${host}:${port}/api/settings`, { headers: { "X-Api-Key": apiKey } })).data;
-    const candidates: SnapshotCandidate[] = [];
+    const candidates: CameraCandidate[] = [];
     if (settings?.webcam?.webcamEnabled !== false) {
+      // The settings API maps webcam.stream to streamUrl. Classic Webcam on
+      // 1.9+ exposes its own stream field; only configured URLs are used.
       const configured = [
-        settings?.plugins?.classicwebcam?.snapshot,
-        settings?.webcam?.snapshotUrl,
-        ...(Array.isArray(settings?.webcam?.webcams) ? settings.webcam.webcams.map((webcam: any) => webcam?.compat?.snapshot) : []),
+        settings?.plugins?.classicwebcam,
+        {stream: settings?.webcam?.streamUrl, snapshot: settings?.webcam?.snapshotUrl},
+        ...(Array.isArray(settings?.webcam?.webcams) ? settings.webcam.webcams.map((webcam: any) => webcam?.compat) : []),
       ];
-      for (const url of configured) {
-        const text = nonEmptyText(url);
-        if (text) candidates.push({ url: text, source: "octoprint-settings", configured: true });
+      for (const camera of configured) {
+        const stream = nonEmptyText(camera?.stream), snapshot = nonEmptyText(camera?.snapshot);
+        if (stream) candidates.push({url: stream, snapshotUrl: snapshot, source: "octoprint-settings", configured: true, transport: "http-mjpeg"});
+        if (snapshot) candidates.push({url: snapshot, source: "octoprint-settings", configured: true, transport: "http-snapshot"});
       }
     }
-    candidates.push({ url: `http://${host}/webcam/?action=snapshot`, source: "octoprint-fallback", configured: false });
+    candidates.push({ url: `http://${host}/webcam/?action=snapshot`, source: "octoprint-fallback", configured: false, transport: "http-snapshot" });
     return candidates;
   }
 

package/src/printers/printer-factory.ts

@@ -3,7 +3,7 @@ import { OctoPrintImplementation } from "./octoprint.js";
 import { KlipperImplementation } from "./klipper.js";
 import { DuetImplementation } from "./duet.js";
 import { RepetierImplementation } from "./repetier.js";
-import { BambuImplementation } from "./bambu.js";
+import { BambuImplementation, defaultResumeStateDir } from "./bambu.js";
 import { PrusaImplementation } from "./prusa.js";
 import { CrealityImplementation } from "./creality.js";
 import type { ConfirmHardware } from "../safety/confirmation.js";
@@ -21,13 +21,13 @@ export class PrinterFactory {
   private implementations: Map<string, PrinterImplementation> = new Map();
   private apiClient = axios.create({ timeout: 10000 });
 
-  /** confirm is the human (MCP elicitation) confirmation used before prints and positive heating. */
+  /** confirm is the human (MCP elicitation) confirmation for physical checks software cannot make, such as resuming a job that cannot be re-read. */
   constructor(confirm?: ConfirmHardware) {
     this.implementations.set("octoprint", new OctoPrintImplementation(this.apiClient, confirm));
     this.implementations.set("klipper", new KlipperImplementation(this.apiClient, confirm));
     this.implementations.set("duet", new DuetImplementation(this.apiClient, confirm));
     this.implementations.set("repetier", new RepetierImplementation(this.apiClient, confirm));
-    this.implementations.set("bambu", new BambuImplementation(this.apiClient, confirm));
+    this.implementations.set("bambu", new BambuImplementation(this.apiClient, confirm, { resumeStateDir: defaultResumeStateDir() }));
     this.implementations.set("prusa", new PrusaImplementation(this.apiClient, confirm));
     this.implementations.set("creality", new CrealityImplementation(this.apiClient, confirm));
   }

package/src/printers/prusa.ts

@@ -232,7 +232,6 @@ export class PrusaImplementation extends GenericPrinterImplementation {
         state,
         ready,
         reason: ready ? undefined : `printer.state is ${state}`,
-        finishedJob: ready && (state === "FINISHED" || state === "STOPPED") ? JSON.stringify([state, data?.job?.id ?? null]) : undefined,
       };
     }
     const flags = data?.state?.flags;

package/src/safety/confirmation.ts

@@ -1,26 +1,15 @@
-/** Human confirmation for physical printer mutations (print start, positive heating). */
-export type ConfirmHardware = (message: string) => Promise<boolean>;
-export type ConfirmationScope = "bambu" | "generic";
-
 /**
- * Ordinary print/heat prompts are on by default. Only an explicit "0" opts out.
- * PRINT_REQUIRE_CONFIRMATION applies to every printer type; the older
- * BAMBU_REQUIRE_CONFIRMATION applies to Bambu printers only. If any variable
- * relevant to the scope is set to another value, confirmation stays required.
+ * Human confirmation through MCP elicitation. Ordinary print starts, positive
+ * heating and resumes of a re-read job do not ask: the client's own action is
+ * the approval. Only a check that software cannot make asks a person, such as
+ * resuming a job whose file the printer cannot hand back for re-reading.
  */
-export function confirmationOptOut(scope: ConfirmationScope): boolean {
-  const names = scope === "bambu"
-    ? ["BAMBU_REQUIRE_CONFIRMATION", "PRINT_REQUIRE_CONFIRMATION"]
-    : ["PRINT_REQUIRE_CONFIRMATION"];
-  const values = names
-    .map((name) => process.env[name]?.trim())
-    .filter((value): value is string => value !== undefined && value !== "");
-  return values.length > 0 && values.every((value) => value === "0");
-}
+export type ConfirmHardware = (message: string) => Promise<boolean>;
 
 /**
- * How long a human has to answer a confirmation prompt. The MCP SDK's default
- * request timeout (60 s) is too short for someone walking to the printer.
+ * How long a person has to answer a prompt from the server (a resume of a job
+ * that could not be re-read, or the Bambu printer-model prompt). The MCP SDK's
+ * default request timeout (60 s) is too short for someone walking to the printer.
  */
 export function confirmationTimeoutMs(): number {
   const raw = process.env.PRINT_CONFIRMATION_TIMEOUT_MS?.trim();
@@ -35,27 +24,15 @@ export function confirmationTimedOut(timeoutMs: number): string {
 }
 
 export const CONFIRMATION_UNAVAILABLE =
-  "Human hardware confirmation requires an MCP client with elicitation support. For deliberately headless operation, " +
-  "PRINT_REQUIRE_CONFIRMATION=0 (or BAMBU_REQUIRE_CONFIRMATION=0 for Bambu printers) disables ordinary print/heat prompts. No command was sent.";
+  "This step needs a person to confirm a check at the printer, which requires an MCP client with elicitation support. No command was sent.";
 
-/**
- * physicalCheck marks confirmations that software cannot replace (for example
- * clearing hardware errors). Those are required even when prompts are opted out.
- */
-export async function requireHumanConfirmation(
-  confirm: ConfirmHardware | undefined,
-  message: string,
-  scope: ConfirmationScope,
-  physicalCheck = false
-): Promise<void> {
-  if (!physicalCheck && confirmationOptOut(scope)) return;
+/** Ask a person to accept a physical check that software cannot replace. */
+export async function requireHumanConfirmation(confirm: ConfirmHardware | undefined, message: string): Promise<void> {
   if (!confirm) throw new Error(CONFIRMATION_UNAVAILABLE);
   if (!(await confirm(message))) {
-    throw new Error("Hardware safety confirmation was declined or cancelled in the MCP client. No command was sent. " + (physicalCheck
-      ? "This confirmation covers a physical check at the printer and always needs a person to accept it."
-      : "Some clients decline prompts automatically, for example in a non-interactive permission mode. A deliberately headless " +
-        `setup that approves jobs another way can set ${scope === "bambu"
-          ? "PRINT_REQUIRE_CONFIRMATION=0 (or BAMBU_REQUIRE_CONFIRMATION=0)"
-          : "PRINT_REQUIRE_CONFIRMATION=0"} to skip ordinary print and heating prompts.`));
+    throw new Error(
+      "Hardware safety confirmation was declined or cancelled in the MCP client. No command was sent. " +
+      "This confirmation covers a physical check at the printer and always needs a person to accept it."
+    );
   }
 }