mcp-3d-printer-server 1.2.9 → 1.2.12

package/src/printers/klipper.ts

@@ -1,65 +1,120 @@
-import { PrinterImplementation } from "../types.js";
 import fs from "fs";
 import FormData from "form-data";
+import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+
+function encodePath(filename: string): string {
+  return filename.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+
+export class KlipperImplementation extends GenericPrinterImplementation {
+  protected readonly printerLabel = "Klipper/Moonraker";
+
+  protected authHeaders(apiKey: string): Record<string, unknown> {
+    return apiKey ? { headers: { "X-Api-Key": apiKey } } : {};
+  }
 
-export class KlipperImplementation extends PrinterImplementation {
   async getStatus(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/printer/info`;
-    const response = await this.apiClient.get(url);
+    const response = await this.apiClient.get(url, this.authHeaders(apiKey));
     return response.data;
   }
 
   async getFiles(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/server/files/list`;
-    const response = await this.apiClient.get(url);
+    const response = await this.apiClient.get(url, this.authHeaders(apiKey));
     return response.data;
   }
 
   async getFile(host: string, port: string, apiKey: string, filename: string) {
     const url = `http://${host}:${port}/server/files/metadata?filename=${encodeURIComponent(filename)}`;
-    const response = await this.apiClient.get(url);
+    const response = await this.apiClient.get(url, this.authHeaders(apiKey));
     return response.data;
   }
 
-  async uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
+  /**
+   * Moonraker object query: webhooks.state must be "ready" (not startup,
+   * shutdown or error) and print_stats.state standby/complete/cancelled.
+   * complete/cancelled can leave a part on the bed, so they need a human.
+   */
+  protected async readPrinterState(host: string, port: string, apiKey: string): Promise<GenericPrinterState> {
+    let data: any;
+    try {
+      data = (await this.apiClient.get(
+        `http://${host}:${port}/printer/objects/query?webhooks&print_stats`,
+        this.authHeaders(apiKey)
+      )).data;
+    } catch (error) {
+      throw new Error(`Cannot read Klipper/Moonraker printer state; nothing was sent: ${(error as Error).message}`);
+    }
+    const status = data?.result?.status;
+    const klippy = status?.webhooks?.state;
+    const job = status?.print_stats?.state;
+    if (typeof klippy !== "string" || typeof job !== "string") {
+      throw new Error("Moonraker did not report webhooks.state and print_stats.state; cannot verify the printer is idle.");
+    }
+    const state = `klippy ${klippy}, print ${job}`;
+    if (klippy !== "ready") {
+      return { state, ready: false, reason: status?.webhooks?.state_message ? String(status.webhooks.state_message) : "Klipper is not ready" };
+    }
+    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]),
+    };
+  }
+
+  protected async downloadRemoteFile(host: string, port: string, apiKey: string, filename: string, destination: string): Promise<void> {
+    await this.downloadToFile(
+      `http://${host}:${port}/server/files/gcodes/${encodePath(filename)}`,
+      apiKey ? { "X-Api-Key": apiKey } : {},
+      destination
+    );
+  }
+
+  /** Current Moonraker returns {result:{item}}; older releases returned result "success". */
+  protected uploadSucceeded(data: any): boolean {
+    return data?.result === "success" || !!data?.result?.item || !!data?.item;
+  }
+
+  protected async rawUploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
     const url = `http://${host}:${port}/server/files/upload`;
-    
+
     const formData = new FormData();
     formData.append("file", fs.createReadStream(filePath));
     formData.append("filename", filename);
-    
+
     const response = await this.apiClient.post(url, formData as any, {
       headers: {
-        ...formData.getHeaders()
+        ...formData.getHeaders(),
+        ...(apiKey ? { "X-Api-Key": apiKey } : {})
       }
     });
-    
-    if (print && response.data.result === "success") {
-      await this.startJob(host, port, apiKey, filename);
-    }
-    
+
     return response.data;
   }
 
-  async startJob(host: string, port: string, apiKey: string, filename: string) {
+  protected async rawStartJob(host: string, port: string, apiKey: string, filename: string) {
     const url = `http://${host}:${port}/printer/print/start`;
-    
-    const response = await this.apiClient.post(url, { filename } as any);
-    
+
+    const response = await this.apiClient.post(url, { filename } as any, this.authHeaders(apiKey));
+
     return response.data;
   }
 
-  async cancelJob(host: string, port: string, apiKey: string) {
+  protected async rawCancelJob(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/printer/print/cancel`;
-    
-    const response = await this.apiClient.post(url, null as any);
-    
+
+    const response = await this.apiClient.post(url, null as any, this.authHeaders(apiKey));
+
     return response.data;
   }
 
-  async setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
+  protected async rawSetTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
     const url = `http://${host}:${port}/printer/gcode/script`;
-    
+
     let gcode;
     if (component === "bed") {
       gcode = `SET_HEATER_TEMPERATURE HEATER=heater_bed TARGET=${temperature}`;
@@ -68,11 +123,11 @@ export class KlipperImplementation extends PrinterImplementation {
     } else {
       throw new Error(`Unsupported component: ${component}`);
     }
-    
+
     const response = await this.apiClient.post(url, {
       script: gcode
-    } as any);
-    
+    } as any, this.authHeaders(apiKey));
+
     return response.data;
   }
-} 
+}

package/src/printers/octoprint.ts

@@ -1,8 +1,19 @@
-import { PrinterImplementation } from "../types.js";
 import fs from "fs";
 import FormData from "form-data";
+import { isAxiosError } from "axios";
+import { GenericPrinterImplementation, type GenericPrinterState, type HeaterComponent } from "./generic-base.js";
+
+const BLOCKING_FLAGS = ["printing", "paused", "pausing", "cancelling", "resuming", "finishing", "error", "closedOrError"];
+
+function encodePath(filename: string): string {
+  return filename.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+
+export class OctoPrintImplementation extends GenericPrinterImplementation {
+  protected readonly printerLabel = "OctoPrint";
+  // POST /api/files/local with print=true uploads and starts the same bytes.
+  protected readonly uploadStartsPrint = true;
 
-export class OctoPrintImplementation extends PrinterImplementation {
   async getStatus(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/api/printer`;
     const response = await this.apiClient.get(url, {
@@ -33,30 +44,63 @@ export class OctoPrintImplementation extends PrinterImplementation {
     return response.data;
   }
 
-  async uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
+  /**
+   * GET /api/printer state.flags (OctoPrint REST API). A 409 means the printer
+   * is not operational. Informational flags such as sdReady never block.
+   */
+  protected async readPrinterState(host: string, port: string, apiKey: string): Promise<GenericPrinterState> {
+    let data: any;
+    try {
+      data = (await this.apiClient.get(`http://${host}:${port}/api/printer`, { headers: { "X-Api-Key": apiKey } })).data;
+    } catch (error) {
+      if (isAxiosError(error) && error.response?.status === 409) {
+        return { state: "Offline", ready: false, reason: "OctoPrint reports the printer is not operational" };
+      }
+      throw new Error(`Cannot read OctoPrint printer state; nothing was sent: ${(error as Error).message}`);
+    }
+    const flags = data?.state?.flags;
+    if (!flags || typeof flags !== "object") {
+      throw new Error("OctoPrint returned no printer state flags; cannot verify the printer is idle.");
+    }
+    const blocking = BLOCKING_FLAGS.filter((flag) => flags[flag] === true);
+    if (flags.operational !== true) blocking.unshift("not operational");
+    if (flags.ready === false && !blocking.length) blocking.push("not ready");
+    return { state: String(data?.state?.text ?? "unknown"), ready: blocking.length === 0, reason: blocking.join(", ") || undefined };
+  }
+
+  /** OctoPrint reports effectivePrint=false when print=true had no effect. */
+  protected uploadStartedPrint(data: any): boolean {
+    return data?.effectivePrint !== false;
+  }
+
+  protected async downloadRemoteFile(host: string, port: string, apiKey: string, filename: string, destination: string): Promise<void> {
+    await this.downloadToFile(`http://${host}:${port}/downloads/files/local/${encodePath(filename)}`, { "X-Api-Key": apiKey }, destination);
+  }
+
+  protected async rawUploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
     const url = `http://${host}:${port}/api/files/local`;
-    
+
     const formData = new FormData();
     formData.append("file", fs.createReadStream(filePath));
     formData.append("filename", filename);
-    
+
     if (print) {
       formData.append("print", "true");
     }
-    
+
     const response = await this.apiClient.post(url, formData as any, {
       headers: {
         "X-Api-Key": apiKey,
         ...formData.getHeaders()
       }
     });
-    
+
     return response.data;
   }
 
-  async startJob(host: string, port: string, apiKey: string, filename: string) {
+  protected async rawStartJob(host: string, port: string, apiKey: string, filename: string) {
     const url = `http://${host}:${port}/api/files/local/${filename}`;
-    
+
     const response = await this.apiClient.post(url, {
       command: "select",
       print: true
@@ -66,13 +110,13 @@ export class OctoPrintImplementation extends PrinterImplementation {
         "Content-Type": "application/json"
       }
     });
-    
+
     return response.data;
   }
 
-  async cancelJob(host: string, port: string, apiKey: string) {
+  protected async rawCancelJob(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/api/job`;
-    
+
     const response = await this.apiClient.post(url, {
       command: "cancel"
     } as any, {
@@ -81,33 +125,42 @@ export class OctoPrintImplementation extends PrinterImplementation {
         "Content-Type": "application/json"
       }
     });
-    
+
     return response.data;
   }
 
-  async setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
+  /** OctoPrint tool targets are keyed tool{n} (POST /api/printer/tool, command "target"). */
+  protected heaterComponent(component: string): HeaterComponent | undefined {
+    const normalized = component.trim().toLowerCase();
+    if (normalized === "bed") return { heater: "bed", raw: "bed" };
+    if (["extruder", "nozzle", "tool"].includes(normalized)) return { heater: "nozzle", raw: "tool0" };
+    const indexed = normalized.match(/^(?:extruder|tool)(\d+)$/);
+    if (indexed) return { heater: "nozzle", raw: `tool${Number(indexed[1])}` };
+    return undefined;
+  }
+
+  protected async rawSetTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
     let url = `http://${host}:${port}/api/printer/tool`;
-    
+
     const data: Record<string, any> = {};
     if (component === "bed") {
       data.command = "target";
       data.target = temperature;
       url = `http://${host}:${port}/api/printer/bed`;
-    } else if (component.startsWith("extruder")) {
+    } else if (/^tool\d+$/.test(component)) {
       data.command = "target";
-      data.targets = {};
-      data.targets[component] = temperature;
+      data.targets = { [component]: temperature };
     } else {
       throw new Error(`Unsupported component: ${component}`);
     }
-    
+
     const response = await this.apiClient.post(url, data as any, {
       headers: {
         "X-Api-Key": apiKey,
         "Content-Type": "application/json"
       }
     });
-    
+
     return response.data;
   }
-} 
+}

package/src/printers/printer-factory.ts

@@ -6,28 +6,38 @@ import { RepetierImplementation } from "./repetier.js";
 import { BambuImplementation } from "./bambu.js";
 import { PrusaImplementation } from "./prusa.js";
 import { CrealityImplementation } from "./creality.js";
+import type { ConfirmHardware } from "../safety/confirmation.js";
+import type { PrintSafetyOptions } from "../safety/expected-peaks.js";
 import axios from "axios";
 
+/** Every adapter accepts trailing safety options on its print and heating mutations. */
+export type GuardedPrinterImplementation = PrinterImplementation & {
+  uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean, options?: PrintSafetyOptions): Promise<any>;
+  startJob(host: string, port: string, apiKey: string, filename: string, options?: PrintSafetyOptions): Promise<any>;
+  setTemperature(host: string, port: string, apiKey: string, component: string, temperature: unknown, options?: PrintSafetyOptions): Promise<any>;
+};
+
 export class PrinterFactory {
   private implementations: Map<string, PrinterImplementation> = new Map();
   private apiClient = axios.create({ timeout: 10000 });
 
-  constructor() {
-    this.implementations.set("octoprint", new OctoPrintImplementation(this.apiClient));
-    this.implementations.set("klipper", new KlipperImplementation(this.apiClient));
-    this.implementations.set("duet", new DuetImplementation(this.apiClient));
-    this.implementations.set("repetier", new RepetierImplementation(this.apiClient));
-    this.implementations.set("bambu", new BambuImplementation(this.apiClient));
-    this.implementations.set("prusa", new PrusaImplementation(this.apiClient));
-    this.implementations.set("creality", new CrealityImplementation(this.apiClient));
+  /** confirm is the human (MCP elicitation) confirmation used before prints and positive heating. */
+  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("prusa", new PrusaImplementation(this.apiClient, confirm));
+    this.implementations.set("creality", new CrealityImplementation(this.apiClient, confirm));
   }
 
-  getImplementation(type: string): PrinterImplementation {
+  getImplementation(type: string): GuardedPrinterImplementation {
     const implementation = this.implementations.get(type.toLowerCase());
     if (!implementation) {
       throw new Error(`Unsupported printer type: ${type}`);
     }
-    return implementation;
+    return implementation as GuardedPrinterImplementation;
   }
 
   async disconnectAll(): Promise<void> {
@@ -37,4 +47,4 @@ export class PrinterFactory {
       await bambuImpl.disconnectAll();
     }
   }
-} 
+}

package/src/printers/prusa.ts

@@ -1,5 +1,5 @@
 import { isAxiosError, type AxiosRequestConfig, type AxiosResponse } from "axios";
-import { PrinterImplementation } from "../types.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type HeaterComponent } from "./generic-base.js";
 import fs from "fs";
 import FormData from "form-data";
 
@@ -8,7 +8,11 @@ type RequestCandidate = {
   data?: unknown;
 };
 
-export class PrusaImplementation extends PrinterImplementation {
+const PRUSALINK_READY_STATES = new Set(["IDLE", "READY", "FINISHED", "STOPPED"]);
+const OCTOPRINT_BLOCKING_FLAGS = ["printing", "paused", "pausing", "cancelling", "resuming", "finishing", "error", "closedOrError"];
+
+export class PrusaImplementation extends GenericPrinterImplementation {
+  protected readonly printerLabel = "Prusa";
   private buildAuthHeaders(apiKey: string): Record<string, string> {
     return {
       Accept: "application/json",
@@ -147,7 +151,40 @@ export class PrusaImplementation extends PrinterImplementation {
     return response.data;
   }
 
-  async uploadFile(
+  /**
+   * PrusaLink /api/v1/status printer.state, falling back to the legacy
+   * OctoPrint-compatible /api/printer flags. FINISHED and STOPPED are idle but
+   * may leave a part on the bed, so they require a human confirmation.
+   */
+  protected async readPrinterState(host: string, port: string, apiKey: string): Promise<GenericPrinterState> {
+    let response: AxiosResponse;
+    try {
+      response = await this.getWithFallback(host, port, apiKey, ["/api/v1/status", "/api/printer"]);
+    } catch (error) {
+      throw new Error(`Cannot read Prusa printer state; nothing was sent: ${(error as Error).message}`);
+    }
+    const data: any = response.data;
+    const v1State = data?.printer?.state;
+    if (typeof v1State === "string" && v1State) {
+      const state = v1State.toUpperCase();
+      const ready = PRUSALINK_READY_STATES.has(state);
+      return {
+        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;
+    if (flags && typeof flags === "object") {
+      const blocking = OCTOPRINT_BLOCKING_FLAGS.filter((flag) => flags[flag] === true);
+      if (flags.operational !== true) blocking.unshift("not operational");
+      return { state: String(data?.state?.text ?? "unknown"), ready: blocking.length === 0, reason: blocking.join(", ") || undefined };
+    }
+    throw new Error("Prusa did not report printer.state or state flags; cannot verify the printer is idle.");
+  }
+
+  protected async rawUploadFile(
     host: string,
     port: string,
     apiKey: string,
@@ -174,14 +211,11 @@ export class PrusaImplementation extends PrinterImplementation {
       }
     );
 
-    if (print) {
-      await this.startJob(host, port, apiKey, filename);
-    }
-
+    // Printing is started by the shared gate only after a fresh state recheck.
     return response.data;
   }
 
-  async startJob(host: string, port: string, apiKey: string, filename: string) {
+  protected async rawStartJob(host: string, port: string, apiKey: string, filename: string) {
     const response = await this.postWithFallback(host, port, apiKey, [
       {
         route: "/api/v1/job",
@@ -216,7 +250,7 @@ export class PrusaImplementation extends PrinterImplementation {
     return response.data;
   }
 
-  async cancelJob(host: string, port: string, apiKey: string) {
+  protected async rawCancelJob(host: string, port: string, apiKey: string) {
     const response = await this.postWithFallback(host, port, apiKey, [
       {
         route: "/api/v1/job",
@@ -235,7 +269,16 @@ export class PrusaImplementation extends PrinterImplementation {
     return response.data;
   }
 
-  async setTemperature(
+  protected heaterComponent(component: string): HeaterComponent | undefined {
+    const normalized = component.trim().toLowerCase();
+    if (normalized === "bed") return { heater: "bed", raw: "bed" };
+    if (normalized.startsWith("extruder") || normalized === "nozzle" || normalized === "tool0" || normalized === "tool") {
+      return { heater: "nozzle", raw: "nozzle" };
+    }
+    return undefined;
+  }
+
+  protected async rawSetTemperature(
     host: string,
     port: string,
     apiKey: string,

package/src/printers/repetier.ts

@@ -1,58 +1,96 @@
-import { PrinterImplementation } from "../types.js";
 import fs from "fs";
 import FormData from "form-data";
+import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+
+/**
+ * Note: Repetier-Server documents printer commands at /printer/api/<slug>;
+ * this adapter's slug-less routes are unverified. Remote starts are refused
+ * because Repetier documents no complete file download for inspection.
+ */
+export class RepetierImplementation extends GenericPrinterImplementation {
+  protected readonly printerLabel = "Repetier";
+  // The upload form's print=1 flag uploads and starts the same bytes.
+  protected readonly uploadStartsPrint = true;
 
-export class RepetierImplementation extends PrinterImplementation {
   async getStatus(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/printer/api/?a=getPrinterInfo&apikey=${apiKey}`;
     const response = await this.apiClient.get(url);
     return response.data;
   }
-  
+
   async getFiles(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/printer/api/?a=ls&apikey=${apiKey}`;
     const response = await this.apiClient.get(url);
     return response.data;
   }
-  
+
   async getFile(host: string, port: string, apiKey: string, filename: string) {
     const url = `http://${host}:${port}/printer/api/?a=getFileInfo&apikey=${apiKey}&filename=${encodeURIComponent(filename)}`;
     const response = await this.apiClient.get(url);
     return response.data;
   }
-  
-  async uploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
+
+  /**
+   * listPrinter returns one entry per printer (online 0/1, active, job "none").
+   * Without a configured slug, more than one printer is ambiguous.
+   */
+  protected async readPrinterState(host: string, port: string, apiKey: string): Promise<GenericPrinterState> {
+    let data: any;
+    try {
+      data = (await this.apiClient.get(`http://${host}:${port}/printer/api/?a=listPrinter&apikey=${encodeURIComponent(apiKey)}`)).data;
+    } catch (error) {
+      throw new Error(`Cannot read Repetier printer state; nothing was sent: ${(error as Error).message}`);
+    }
+    const printers = Array.isArray(data) ? data : Array.isArray(data?.data) ? data.data : undefined;
+    if (!printers) throw new Error("Repetier did not return a printer list; cannot verify the printer is idle.");
+    if (printers.length !== 1) {
+      throw new Error(`Repetier reports ${printers.length} printers; this adapter cannot tell which one would receive the job.`);
+    }
+    const [printer] = printers;
+    const online = printer?.online === 1 || printer?.online === true;
+    const job = typeof printer?.job === "string" ? printer.job : undefined;
+    if (job === undefined) throw new Error("Repetier did not report the printer's job state; cannot verify it is idle.");
+    const reasons = [
+      ...(online ? [] : ["offline"]),
+      ...(printer?.active === false ? ["inactive"] : []),
+      ...(job !== "none" && job !== "" ? [`job ${job} is active`] : []),
+      ...(printer?.paused === true ? ["paused"] : []),
+    ];
+    return { state: `${online ? "online" : "offline"}, job ${job || "none"}`, ready: reasons.length === 0, reason: reasons.join(", ") || undefined };
+  }
+
+  protected async rawUploadFile(host: string, port: string, apiKey: string, filePath: string, filename: string, print: boolean) {
     const url = `http://${host}:${port}/printer/api/`;
-    
+
     const formData = new FormData();
     formData.append("a", "upload");
     formData.append("apikey", apiKey);
     formData.append("filename", filename);
     formData.append("print", print ? "1" : "0");
     formData.append("file", fs.createReadStream(filePath));
-    
+
     const response = await this.apiClient.post(url, formData as any, {
       headers: {
         ...formData.getHeaders()
       }
     });
-    
+
     return response.data;
   }
-  
-  async startJob(host: string, port: string, apiKey: string, filename: string) {
+
+  protected async rawStartJob(host: string, port: string, apiKey: string, filename: string) {
     const url = `http://${host}:${port}/printer/api/?a=startJob&apikey=${apiKey}&filename=${encodeURIComponent(filename)}`;
     const response = await this.apiClient.get(url);
     return response.data;
   }
-  
-  async cancelJob(host: string, port: string, apiKey: string) {
+
+  protected async rawCancelJob(host: string, port: string, apiKey: string) {
     const url = `http://${host}:${port}/printer/api/?a=stopJob&apikey=${apiKey}`;
     const response = await this.apiClient.get(url);
     return response.data;
   }
-  
-  async setTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
+
+  protected async rawSetTemperature(host: string, port: string, apiKey: string, component: string, temperature: number) {
     let url;
     if (component === "bed") {
       url = `http://${host}:${port}/printer/api/?a=setBedTemp&apikey=${apiKey}&temp=${temperature}`;
@@ -61,8 +99,8 @@ export class RepetierImplementation extends PrinterImplementation {
     } else {
       throw new Error(`Unsupported component: ${component}`);
     }
-    
+
     const response = await this.apiClient.get(url);
     return response.data;
   }
-} 
+}