@vextrix3d/machine-agent 0.0.0-stage → 2.1.0

package/dist/clients/MoonrakerClient.js

@@ -0,0 +1,289 @@
+import { KlippyState } from '../types/index.js';
+import { findMoonrakerChamberObject, MOONRAKER_SUBSCRIBED_OBJECTS, mergeMoonrakerStatus, } from '../utils.js';
+const METHOD_NOT_FOUND = -32601;
+class MoonrakerRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(`Moonraker error ${code}: ${message}`);
+        this.code = code;
+    }
+}
+const RECONNECT_DELAYS_MS = [2_000, 5_000, 15_000, 30_000, 60_000];
+export class MoonrakerClient {
+    options;
+    socket = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    status = {};
+    isSubscribed = false;
+    subscribing = null;
+    isStopped = false;
+    hasListedWebcams = false;
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    baseUrl;
+    constructor(options) {
+        this.options = options;
+        this.baseUrl = `${options.ip}:${options.port}`;
+        void this.connect();
+    }
+    async stop() {
+        this.isStopped = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.stopHeartbeat();
+        this.socket?.close();
+    }
+    async getFileEstimatedTime(filename) {
+        const metadata = await this.request('server.files.metadata', {
+            filename,
+        });
+        return typeof metadata.estimated_time === 'number' && metadata.estimated_time > 0
+            ? metadata.estimated_time
+            : null;
+    }
+    async connect() {
+        let url;
+        try {
+            url = await this.resolveSocketUrl();
+        }
+        catch (error) {
+            this.handleError(error);
+            this.scheduleReconnect();
+            return;
+        }
+        const socket = new WebSocket(url);
+        this.socket = socket;
+        socket.addEventListener('open', () => {
+            this.reconnectAttempt = 0;
+            void this.initialise();
+        });
+        socket.addEventListener('message', event => {
+            this.handleMessage(event.data);
+        });
+        socket.addEventListener('error', () => {
+            this.handleError(new Error(`WebSocket error on ws://${this.baseUrl}/websocket`));
+        });
+        socket.addEventListener('close', () => {
+            this.handleClose(socket);
+        });
+    }
+    async resolveSocketUrl() {
+        const url = `ws://${this.baseUrl}/websocket`;
+        if (!this.options.apiKey) {
+            return url;
+        }
+        const response = await fetch(`http://${this.baseUrl}/access/oneshot_token`, {
+            headers: {
+                'X-Api-Key': this.options.apiKey,
+            },
+            signal: AbortSignal.timeout(this.options.requestTimeoutMs ?? 15_000),
+        });
+        if (!response.ok) {
+            throw new Error(`Moonraker refused the API key: ${response.status} ${response.statusText}`);
+        }
+        const { result } = (await response.json());
+        return `${url}?token=${encodeURIComponent(result)}`;
+    }
+    async initialise() {
+        try {
+            await this.request('server.connection.identify', {
+                client_name: 'vextrix3d-machine-agent',
+                version: '1.0.0',
+                type: 'other',
+                url: 'https://vextrix3d.co.uk',
+            });
+            this.startHeartbeat();
+            void this.listWebcams();
+            await this.subscribeOnceKlippyAnswers();
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    async listWebcams() {
+        let webcams;
+        try {
+            const result = await this.request('server.webcams.list');
+            webcams = Array.isArray(result.webcams) ? result.webcams : [];
+        }
+        catch (error) {
+            if (!(error instanceof MoonrakerRequestError && error.code === METHOD_NOT_FOUND)) {
+                this.handleError(error);
+                return;
+            }
+            webcams = null;
+        }
+        this.passWebcams(webcams);
+    }
+    passWebcams(webcams) {
+        this.hasListedWebcams = true;
+        this.options.onWebcams?.(webcams);
+    }
+    async subscribeOnceKlippyAnswers() {
+        const { klippy_state: klippyState } = await this.request('server.info');
+        const isAnswering = klippyState === KlippyState.READY ||
+            klippyState === KlippyState.SHUTDOWN ||
+            klippyState === KlippyState.ERROR;
+        if (isAnswering) {
+            await this.subscribe();
+        }
+    }
+    subscribe() {
+        this.subscribing ??= this.requestSubscription().finally(() => {
+            this.subscribing = null;
+        });
+        return this.subscribing;
+    }
+    async requestSubscription() {
+        const { objects } = await this.request('printer.objects.list');
+        const chamberObject = findMoonrakerChamberObject(objects);
+        const { status } = await this.request('printer.objects.subscribe', {
+            objects: {
+                ...MOONRAKER_SUBSCRIBED_OBJECTS,
+                ...(chamberObject
+                    ? {
+                        [chamberObject]: ['temperature'],
+                    }
+                    : {}),
+            },
+        });
+        this.status = status;
+        this.isSubscribed = true;
+        this.options.onConnect?.();
+        this.options.onStatus?.(this.status);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.hasListedWebcams) {
+                void this.listWebcams();
+            }
+            if (this.isSubscribed) {
+                this.options.onStatus?.(this.status);
+                return;
+            }
+            void this.subscribeOnceKlippyAnswers().catch(error => this.handleError(error));
+        }, this.options.heartbeatMs ?? 30_000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    request(method, params) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
+            return Promise.reject(new Error(`Moonraker is not connected for ${method}`));
+        }
+        const id = ++this.requestId;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Moonraker did not answer ${method}`));
+            }, this.options.requestTimeoutMs ?? 15_000);
+            this.pendingRequests.set(id, {
+                resolve: result => resolve(result),
+                reject,
+                timeout,
+            });
+            socket.send(JSON.stringify({
+                jsonrpc: '2.0',
+                method,
+                ...(params
+                    ? {
+                        params,
+                    }
+                    : {}),
+                id,
+            }));
+        });
+    }
+    handleMessage(data) {
+        let message;
+        try {
+            message = JSON.parse(String(data));
+        }
+        catch (error) {
+            this.handleError(new Error('Failed to parse a Moonraker message', {
+                cause: error,
+            }));
+            return;
+        }
+        if (message.id !== undefined) {
+            this.settleRequest(message);
+            return;
+        }
+        switch (message.method) {
+            case 'notify_status_update': {
+                const update = message.params?.[0];
+                if (!this.isSubscribed || !update) {
+                    return;
+                }
+                this.status = mergeMoonrakerStatus(this.status, update);
+                this.options.onStatus?.(this.status);
+                break;
+            }
+            case 'notify_webcams_changed': {
+                const { webcams } = (message.params?.[0] ?? {});
+                if (Array.isArray(webcams)) {
+                    this.passWebcams(webcams);
+                }
+                break;
+            }
+            case 'notify_klippy_ready':
+                void this.subscribe().catch(error => this.handleError(error));
+                break;
+            case 'notify_klippy_disconnected':
+                this.isSubscribed = false;
+                break;
+        }
+    }
+    settleRequest(message) {
+        const pending = this.pendingRequests.get(message.id);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message.id);
+        if (message.error) {
+            pending.reject(new MoonrakerRequestError(message.error.code, message.error.message));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    handleClose(socket) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.socket = null;
+        this.isSubscribed = false;
+        this.hasListedWebcams = false;
+        this.stopHeartbeat();
+        this.pendingRequests.forEach(({ reject, timeout }) => {
+            clearTimeout(timeout);
+            reject(new Error('The connection to Moonraker closed'));
+        });
+        this.pendingRequests.clear();
+        this.options.onClose?.();
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.isStopped) {
+            return;
+        }
+        const delay = RECONNECT_DELAYS_MS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.options.onReconnect?.();
+            void this.connect();
+        }, delay);
+    }
+    handleError(error) {
+        this.options.onError?.(error);
+    }
+}

package/dist/clients/Vextrix3dApiClient.js

@@ -0,0 +1,121 @@
+import { ApiRequestError } from './ApiRequestError.js';
+var PrintTechnology;
+(function (PrintTechnology) {
+    PrintTechnology["FDM"] = "fdm";
+    PrintTechnology["SLA"] = "sla";
+})(PrintTechnology || (PrintTechnology = {}));
+var PrinterStatus;
+(function (PrinterStatus) {
+    PrinterStatus["ONLINE"] = "online";
+    PrinterStatus["OFFLINE"] = "offline";
+})(PrinterStatus || (PrinterStatus = {}));
+export var PrinterConnectionType;
+(function (PrinterConnectionType) {
+    PrinterConnectionType["BAMBU_MQTT"] = "bambu-mqtt";
+    PrinterConnectionType["MOONRAKER"] = "moonraker";
+})(PrinterConnectionType || (PrinterConnectionType = {}));
+export var MachineAgentStateType;
+(function (MachineAgentStateType) {
+    MachineAgentStateType["IDLE"] = "idle";
+    MachineAgentStateType["RUNNING"] = "running";
+    MachineAgentStateType["PAUSED"] = "paused";
+    MachineAgentStateType["FAILED"] = "failed";
+    MachineAgentStateType["CANCELLED"] = "cancelled";
+    MachineAgentStateType["FINISHED"] = "finished";
+    MachineAgentStateType["PREPARING"] = "preparing";
+})(MachineAgentStateType || (MachineAgentStateType = {}));
+export var PrintAttemptFailureReason;
+(function (PrintAttemptFailureReason) {
+    PrintAttemptFailureReason["PRINTER_ERROR"] = "printer-error";
+    PrintAttemptFailureReason["MATERIAL_ERROR"] = "material-error";
+    PrintAttemptFailureReason["MODEL_ERROR"] = "model-error";
+    PrintAttemptFailureReason["SUPPORT_REMOVAL_DAMAGE"] = "support-removal-damage";
+    PrintAttemptFailureReason["QUALITY_CHECK_FAILED"] = "quality-check-failed";
+    PrintAttemptFailureReason["UNKNOWN"] = "unknown";
+})(PrintAttemptFailureReason || (PrintAttemptFailureReason = {}));
+export class Vextrix3dApiClient {
+    functionsUrl;
+    apiKey;
+    agentVersion;
+    timeoutMs;
+    constructor({ functionsUrl, apiKey, agentVersion, timeoutMs = 15_000, }) {
+        this.functionsUrl = functionsUrl.replace(/\/+$/, '');
+        this.apiKey = apiKey;
+        this.agentVersion = agentVersion;
+        this.timeoutMs = timeoutMs;
+    }
+    getPrinterInfo() {
+        return this.request('/getMachineAgentInfo');
+    }
+    async getCamera() {
+        try {
+            return await this.request('/getMachineAgentCamera', {
+                method: 'POST',
+            });
+        }
+        catch (error) {
+            if (error instanceof ApiRequestError && error.status === 404) {
+                return {
+                    tunnelToken: null,
+                    relayKey: null,
+                };
+            }
+            throw error;
+        }
+    }
+    reportPrinterState(state) {
+        return this.request('/reportMachineAgentState', {
+            method: 'POST',
+            body: { ...state, agentVersion: this.agentVersion },
+        });
+    }
+    getCurrentPrintAttempt() {
+        return this.request('/getMachineAgentPrintAttempt');
+    }
+    cancelCurrentPrintAttempt() {
+        return this.request('/cancelMachineAgentPrintAttempt', {
+            method: 'POST',
+        });
+    }
+    failCurrentPrintAttempt(reason) {
+        return this.request('/failMachineAgentPrintAttempt', {
+            method: 'POST',
+            body: {
+                reason,
+            },
+        });
+    }
+    async request(path, { method = 'GET', body } = {}) {
+        const response = await fetch(`${this.functionsUrl}${path}`, {
+            method,
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+                ...(body === undefined
+                    ? {}
+                    : {
+                        'Content-Type': 'application/json',
+                    }),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        const responseText = await response.text();
+        if (!response.ok) {
+            throw new ApiRequestError(`API request failed: ${method} ${path} - ${response.status} ${response.statusText}${responseText ? ` - ${responseText}` : ''}`, response.status);
+        }
+        let result;
+        if (responseText) {
+            try {
+                result = JSON.parse(responseText);
+            }
+            catch {
+                throw new Error(`The API returned invalid JSON for ${method} ${path}`);
+            }
+        }
+        if (!result || result.status !== 'ok' || result.data === undefined) {
+            throw new Error(`The API returned an invalid response for ${method} ${path}`);
+        }
+        return result.data;
+    }
+}

package/dist/moonraker-camera-reporter.js

@@ -0,0 +1,21 @@
+export const createMoonrakerCameraReporter = ({ stateReporter, cameraRelay, readWebcams, hasCameraStream, }) => {
+    let webcamReport;
+    let lastState = null;
+    const reportState = (state) => {
+        lastState = state;
+        stateReporter.report({
+            ...state,
+            hasCameraStream: hasCameraStream(webcamReport),
+        });
+    };
+    return {
+        reportState,
+        noteWebcams: webcams => {
+            webcamReport = readWebcams(webcams);
+            cameraRelay?.update(webcamReport);
+            if (lastState) {
+                reportState(lastState);
+            }
+        },
+    };
+};

package/dist/print-attempt-synchronizer.js

@@ -0,0 +1,76 @@
+import { PrintAttemptFailureReason, MachineAgentStateType, } from './clients/Vextrix3dApiClient.js';
+export const createPrintAttemptSynchronizer = ({ printerLabel, apiClient, printerGone, }) => {
+    let currentAttempt = null;
+    let previousState = null;
+    let requestPromise = null;
+    let loadPromise = null;
+    const refreshCurrentAttempt = () => {
+        if (printerGone.isGone()) {
+            return Promise.resolve();
+        }
+        loadPromise ??= apiClient
+            .getCurrentPrintAttempt()
+            .then(attempt => {
+            currentAttempt = attempt;
+            if (attempt) {
+                console.log(`Current print attempt loaded: ${attempt.id}`);
+            }
+            else {
+                console.log(`No active print attempt for "${printerLabel}"`);
+            }
+        })
+            .catch(error => {
+            if (!printerGone.notice(error)) {
+                console.error(`Failed to load the current print attempt for "${printerLabel}":`, error);
+            }
+        })
+            .finally(() => {
+            loadPromise = null;
+        });
+        return loadPromise;
+    };
+    const runOnce = (action) => {
+        if (requestPromise || printerGone.isGone()) {
+            return;
+        }
+        requestPromise = action()
+            .then(() => {
+            currentAttempt = null;
+        })
+            .catch(error => {
+            if (!printerGone.notice(error)) {
+                console.error(`Failed to update print attempt for "${printerLabel}":`, error);
+            }
+        })
+            .finally(() => {
+            requestPromise = null;
+        });
+    };
+    const handleState = (state) => {
+        const stateChanged = state !== previousState;
+        previousState = state;
+        if (!stateChanged) {
+            return;
+        }
+        if (!currentAttempt &&
+            (state === MachineAgentStateType.PREPARING || state === MachineAgentStateType.RUNNING)) {
+            void refreshCurrentAttempt();
+            return;
+        }
+        if (!currentAttempt) {
+            return;
+        }
+        switch (state) {
+            case MachineAgentStateType.CANCELLED:
+                runOnce(() => apiClient.cancelCurrentPrintAttempt());
+                break;
+            case MachineAgentStateType.FAILED:
+                runOnce(() => apiClient.failCurrentPrintAttempt(PrintAttemptFailureReason.PRINTER_ERROR));
+                break;
+        }
+    };
+    return {
+        initialise: refreshCurrentAttempt,
+        handleState,
+    };
+};

package/dist/printer-gone.js

@@ -0,0 +1,26 @@
+import { ApiRequestError } from './clients/ApiRequestError.js';
+export const isPrinterGoneError = (error) => error instanceof ApiRequestError && (error.status === 401 || error.status === 410);
+const defaultKeepAlive = () => {
+    setInterval(() => { }, 2 ** 30);
+};
+export const createPrinterGone = ({ stop, keepAlive = defaultKeepAlive, }) => {
+    let isGone = false;
+    return {
+        isGone: () => isGone,
+        notice: error => {
+            if (!isPrinterGoneError(error)) {
+                return false;
+            }
+            if (isGone) {
+                return true;
+            }
+            isGone = true;
+            console.error(`vextrix3d no longer knows ${error.status === 410 ? 'this printer' : "this printer's key"} (${error.status}) - stopped; restart the agent once it has a new key`);
+            keepAlive();
+            void (async () => stop())().catch(stopError => {
+                console.error('Failed to stop cleanly:', stopError);
+            });
+            return true;
+        },
+    };
+};

package/dist/printer-state-reporter.js

@@ -0,0 +1,93 @@
+import { backoffDelayMs } from './utils.js';
+const STATE_REPORT_INTERVAL_MS = 120_000;
+const PROGRESS_REPORT_STEP_PCT = 5;
+export const createPrinterStateReporter = ({ printerLabel, reportPrinterState, printerGone, }) => {
+    let lastReportedState = null;
+    let lastReportedAt = 0;
+    let pendingState = null;
+    let reportingPromise = null;
+    let failures = 0;
+    let retryTimeoutId;
+    let isStopped = false;
+    const shouldReport = (state) => {
+        if (!lastReportedState) {
+            return true;
+        }
+        if (state.state !== lastReportedState.state ||
+            state.hasCameraStream !== lastReportedState.hasCameraStream) {
+            return true;
+        }
+        const previousProgress = lastReportedState.progressPct;
+        const currentProgress = state.progressPct;
+        if (previousProgress !== null &&
+            currentProgress !== null &&
+            Math.abs(currentProgress - previousProgress) >= PROGRESS_REPORT_STEP_PCT) {
+            return true;
+        }
+        return Date.now() - lastReportedAt >= STATE_REPORT_INTERVAL_MS;
+    };
+    const canSend = () => !isStopped && !printerGone.isGone();
+    const send = () => {
+        if (reportingPromise || !pendingState || !canSend()) {
+            return;
+        }
+        const state = pendingState;
+        pendingState = null;
+        reportingPromise = reportPrinterState(state)
+            .then(() => {
+            lastReportedState = state;
+            lastReportedAt = Date.now();
+            failures = 0;
+            if (pendingState && !shouldReport(pendingState)) {
+                pendingState = null;
+            }
+        }, error => {
+            if (printerGone.notice(error)) {
+                pendingState = null;
+                return;
+            }
+            pendingState ??= state;
+            failures++;
+            const delayMs = backoffDelayMs(failures, 30_000, 600_000);
+            console.error(`Failed to report state for "${printerLabel}"; trying again in ${delayMs / 1000}s:`, error);
+            if (canSend()) {
+                retryTimeoutId = setTimeout(() => {
+                    retryTimeoutId = undefined;
+                    send();
+                }, delayMs);
+            }
+        })
+            .finally(() => {
+            reportingPromise = null;
+            if (retryTimeoutId === undefined) {
+                send();
+            }
+        });
+    };
+    return {
+        report: state => {
+            if (!canSend() || (!pendingState && !shouldReport(state))) {
+                return;
+            }
+            pendingState = state;
+            if (retryTimeoutId === undefined) {
+                send();
+            }
+        },
+        flush: async () => {
+            if (!reportingPromise && retryTimeoutId !== undefined) {
+                clearTimeout(retryTimeoutId);
+                retryTimeoutId = undefined;
+                send();
+            }
+            while (reportingPromise) {
+                await reportingPromise;
+            }
+        },
+        stop: () => {
+            isStopped = true;
+            clearTimeout(retryTimeoutId);
+            retryTimeoutId = undefined;
+        },
+    };
+};

package/dist/types/bambu.types.js

@@ -0,0 +1,10 @@
+export var BambuGcodeState;
+(function (BambuGcodeState) {
+    BambuGcodeState["IDLE"] = "IDLE";
+    BambuGcodeState["RUNNING"] = "RUNNING";
+    BambuGcodeState["PAUSE"] = "PAUSE";
+    BambuGcodeState["FAILED"] = "FAILED";
+    BambuGcodeState["CANCEL"] = "CANCEL";
+    BambuGcodeState["FINISH"] = "FINISH";
+    BambuGcodeState["PREPARE"] = "PREPARE";
+})(BambuGcodeState || (BambuGcodeState = {}));

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from './bambu.types.js';
+export * from './moonraker.types.js';

package/dist/types/moonraker.types.js

@@ -0,0 +1,16 @@
+export var MoonrakerPrintState;
+(function (MoonrakerPrintState) {
+    MoonrakerPrintState["STANDBY"] = "standby";
+    MoonrakerPrintState["PRINTING"] = "printing";
+    MoonrakerPrintState["PAUSED"] = "paused";
+    MoonrakerPrintState["COMPLETE"] = "complete";
+    MoonrakerPrintState["CANCELLED"] = "cancelled";
+    MoonrakerPrintState["ERROR"] = "error";
+})(MoonrakerPrintState || (MoonrakerPrintState = {}));
+export var KlippyState;
+(function (KlippyState) {
+    KlippyState["READY"] = "ready";
+    KlippyState["STARTUP"] = "startup";
+    KlippyState["SHUTDOWN"] = "shutdown";
+    KlippyState["ERROR"] = "error";
+})(KlippyState || (KlippyState = {}));