@vextrix3d/machine-agent 0.0.0-stage → 2.0.0

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 = {}));

package/dist/utils.js

@@ -0,0 +1,233 @@
+import { createHash } from 'node:crypto';
+import { accessSync, constants, createReadStream } from 'node:fs';
+import { createServer } from 'node:net';
+import { MachineAgentStateType } from './clients/Vextrix3dApiClient.js';
+import { BambuGcodeState, KlippyState, MoonrakerPrintState, } from './types/index.js';
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+export const backoffDelayMs = (failures, baseMs, maxMs) => Math.min(maxMs, baseMs * 2 ** (failures - 1));
+export const isExecutable = (path) => {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const requireEnvVar = (name) => {
+    const value = process.env[name]?.trim();
+    assert(value, `The ${name} environment variable is not configured`);
+    return value;
+};
+export const once = (fn) => {
+    let promise = null;
+    return () => {
+        promise ??= fn();
+        return promise;
+    };
+};
+export const isPortFree = (port) => new Promise(resolve => {
+    const server = createServer();
+    server.once('error', () => resolve(false));
+    server.listen({
+        host: '127.0.0.1',
+        port,
+    }, () => server.close(() => resolve(true)));
+});
+export const sha256File = async (path) => {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(path)) {
+        hash.update(chunk);
+    }
+    return hash.digest('hex');
+};
+export const describeError = (error) => {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    return error.cause instanceof Error ? `${error.message} (${error.cause.message})` : error.message;
+};
+export const readArmVersion = () => {
+    const armVersion = process.config.variables.arm_version;
+    return armVersion === undefined ? undefined : String(armVersion);
+};
+export const stopChildProcess = (child, killAfterMs = 3_000) => new Promise(resolve => {
+    const killTimeoutId = setTimeout(() => {
+        child.kill('SIGKILL');
+        resolve();
+    }, killAfterMs);
+    child.once('exit', () => {
+        clearTimeout(killTimeoutId);
+        resolve();
+    });
+    child.kill('SIGTERM');
+});
+export const formatSubtaskName = (value) => {
+    const subtaskName = value?.trim();
+    if (!subtaskName) {
+        return null;
+    }
+    const isCut = subtaskName.endsWith('...');
+    const names = (isCut ? subtaskName.slice(0, -3) : subtaskName).split(' + ');
+    const cutName = isCut ? names.pop()?.replace(/ \+?$/, '') : undefined;
+    const lastName = names.at(-1);
+    const counts = new Map();
+    names.forEach(name => {
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    });
+    const atLeastName = cutName && lastName?.startsWith(cutName) ? lastName : null;
+    if (atLeastName) {
+        counts.set(atLeastName, (counts.get(atLeastName) ?? 0) + 1);
+    }
+    const formattedNames = [...counts].map(([name, count]) => {
+        if (count === 1) {
+            return name;
+        }
+        return name === atLeastName ? `${name} ×${count}+` : `${name} ×${count}`;
+    });
+    if (cutName !== undefined && !atLeastName) {
+        formattedNames.push(`${cutName}...`);
+    }
+    return formattedNames.join(' + ');
+};
+const isReportObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const mergeReportObjects = (status, report) => {
+    const merged = { ...status };
+    Object.entries(report).forEach(([key, value]) => {
+        const statusValue = merged[key];
+        merged[key] =
+            isReportObject(statusValue) && isReportObject(value)
+                ? mergeReportObjects(statusValue, value)
+                : value;
+    });
+    return merged;
+};
+export const mergeBambuStatus = (status, report) => status
+    ? mergeReportObjects(status, report)
+    : report;
+export const readBambuTemperature = (value) => typeof value === 'number' ? value & 0xffff : null;
+const BAMBU_GCODE_STATE_MAP = {
+    [BambuGcodeState.IDLE]: MachineAgentStateType.IDLE,
+    [BambuGcodeState.RUNNING]: MachineAgentStateType.RUNNING,
+    [BambuGcodeState.PAUSE]: MachineAgentStateType.PAUSED,
+    [BambuGcodeState.FAILED]: MachineAgentStateType.FAILED,
+    [BambuGcodeState.CANCEL]: MachineAgentStateType.CANCELLED,
+    [BambuGcodeState.FINISH]: MachineAgentStateType.FINISHED,
+    [BambuGcodeState.PREPARE]: MachineAgentStateType.PREPARING,
+};
+const mapBambuGcodeState = (state) => {
+    if (typeof state === 'string' &&
+        Object.values(BambuGcodeState).includes(state)) {
+        return BAMBU_GCODE_STATE_MAP[state];
+    }
+    if (state) {
+        console.warn('Unknown Bambu gcode state', {
+            state,
+        });
+    }
+    return MachineAgentStateType.IDLE;
+};
+const BAMBU_PRINT_CANCELLED_ERROR = 0x0300400c;
+export const createBambuStateResolver = () => {
+    let failedAs = null;
+    return (status) => {
+        const state = mapBambuGcodeState(status.gcode_state);
+        if (state !== MachineAgentStateType.FAILED) {
+            failedAs = null;
+            return state;
+        }
+        if (status.print_error === BAMBU_PRINT_CANCELLED_ERROR) {
+            failedAs = MachineAgentStateType.CANCELLED;
+        }
+        failedAs ??= MachineAgentStateType.FAILED;
+        return failedAs;
+    };
+};
+export const MOONRAKER_SUBSCRIBED_OBJECTS = {
+    webhooks: ['state'],
+    print_stats: ['state', 'filename', 'print_duration'],
+    display_status: ['progress'],
+    extruder: ['temperature'],
+    heater_bed: ['temperature'],
+};
+const MOONRAKER_CHAMBER_OBJECT = /^(temperature_sensor|heater_generic|temperature_fan) .*chamber/i;
+export const findMoonrakerChamberObject = (objects) => objects.find(object => MOONRAKER_CHAMBER_OBJECT.test(object)) ?? null;
+export const mergeMoonrakerStatus = (status, update) => mergeReportObjects(status, update);
+const readNumber = (object, field) => {
+    const value = object?.[field];
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+};
+const MOONRAKER_PRINT_STATE_MAP = {
+    [MoonrakerPrintState.STANDBY]: MachineAgentStateType.IDLE,
+    [MoonrakerPrintState.PRINTING]: MachineAgentStateType.RUNNING,
+    [MoonrakerPrintState.PAUSED]: MachineAgentStateType.PAUSED,
+    [MoonrakerPrintState.COMPLETE]: MachineAgentStateType.FINISHED,
+    [MoonrakerPrintState.CANCELLED]: MachineAgentStateType.CANCELLED,
+    [MoonrakerPrintState.ERROR]: MachineAgentStateType.FAILED,
+};
+export const resolveMoonrakerState = (status) => {
+    const klippyState = status.webhooks?.state;
+    if (klippyState === KlippyState.SHUTDOWN || klippyState === KlippyState.ERROR) {
+        return MachineAgentStateType.FAILED;
+    }
+    const printState = status.print_stats?.state;
+    if (typeof printState === 'string' &&
+        Object.values(MoonrakerPrintState).includes(printState)) {
+        return MOONRAKER_PRINT_STATE_MAP[printState];
+    }
+    if (printState) {
+        console.warn('Unknown Moonraker print state', {
+            state: printState,
+        });
+    }
+    return MachineAgentStateType.IDLE;
+};
+export const formatMoonrakerJobName = (filename) => {
+    if (typeof filename !== 'string') {
+        return null;
+    }
+    return (filename
+        .split('/')
+        .at(-1)
+        ?.replace(/\.gcode$/i, '')
+        .trim() || null);
+};
+export const estimateMoonrakerRemainingMinutes = ({ printDurationS, progress, estimatedTimeS, }) => {
+    if (!printDurationS || printDurationS < 1) {
+        return null;
+    }
+    let remainingS = null;
+    if (estimatedTimeS) {
+        remainingS = estimatedTimeS - printDurationS;
+    }
+    else if (progress) {
+        remainingS = printDurationS / progress - printDurationS;
+    }
+    return remainingS === null ? null : Math.max(0, Math.round(remainingS / 60));
+};
+export const buildMoonrakerAgentState = (status, estimatedTimeS) => {
+    const state = resolveMoonrakerState(status);
+    const isUnderWay = state === MachineAgentStateType.RUNNING || state === MachineAgentStateType.PAUSED;
+    const progress = readNumber(status.display_status, 'progress');
+    const chamberObject = findMoonrakerChamberObject(Object.keys(status));
+    return {
+        state,
+        subtaskName: formatMoonrakerJobName(status.print_stats?.filename),
+        progressPct: progress === null ? null : Math.round(progress * 100),
+        remainingMinutes: isUnderWay
+            ? estimateMoonrakerRemainingMinutes({
+                printDurationS: readNumber(status.print_stats, 'print_duration'),
+                progress,
+                estimatedTimeS,
+            })
+            : null,
+        nozzleTemperature: readNumber(status.extruder, 'temperature'),
+        bedTemperature: readNumber(status.heater_bed, 'temperature'),
+        chamberTemperature: chamberObject ? readNumber(status[chamberObject], 'temperature') : null,
+        wifiSignalDbm: null,
+    };
+};

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "@vextrix3d/machine-agent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "Connects a Bambu or Klipper printer to Vextrix3D: reports its state and print progress, and relays its camera",
+  "keywords": [
+    "vextrix3d",
+    "3d-printing",
+    "printer",
+    "bambu-lab",
+    "klipper",
+    "moonraker",
+    "mqtt",
+    "go2rtc"
+  ],
+  "author": "Mike Aliinyk <m.aliynik@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Vextrix3D/machine-agent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Vextrix3D/machine-agent/issues"
+  },
+  "homepage": "https://github.com/Vextrix3D/machine-agent",
+  "type": "module",
+  "bin": {
+    "machine-agent": "dist/bootstrap.js"
+  },
+  "files": [
+    "dist",
+    "certs",
+    "!dist/**/__tests__"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint src && prettier --check src",
+    "test": "vitest",
+    "prepublishOnly": "CI=1 npm test && npm run build",
+    "start": "npm run build && pm2 start dist/bootstrap.js --name \"$(basename \"$(pwd -P)\")\"",
+    "start:prod": "npm run build && NODE_ENV=production pm2 start dist/bootstrap.js --name \"$(basename \"$(pwd -P)\")\"",
+    "restart": "npm run build && pm2 restart \"$(basename \"$(pwd -P)\")\"",
+    "restart:prod": "npm run build && NODE_ENV=production pm2 restart \"$(basename \"$(pwd -P)\")\" --update-env",
+    "stop": "pm2 stop \"$(basename \"$(pwd -P)\")\"",
+    "delete": "pm2 delete \"$(basename \"$(pwd -P)\")\"",
+    "logs": "pm2 logs \"$(basename \"$(pwd -P)\")\" --time"
+  },
+  "dependencies": {
+    "mqtt": "5.16.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "24.19.2",
+    "eslint": "10.14.0",
+    "pm2": "7.1.2",
+    "prettier": "3.10.1",
+    "ts-loader": "9.6.2",
+    "ts-node": "10.9.2",
+    "tsc-alias": "1.9.10",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.2",
+    "vite": "8.3.8",
+    "vitest": "5.1.0"
+  }
+}