agentic-numerical-control 0.1.6 → 0.2.0

package/dist/server/cncjs.js

@@ -1,20 +1,18 @@
-// Link to CNCjs over its socket.io API, with a cached view of controller
-// state. Agentic Numerical Control uses an existing CNCjs at CNCJS_URL when one answers there;
-// otherwise it starts the CNCjs bundled in node_modules on that address,
-// with its own config file in .anc/.
-import { spawn } from "node:child_process";
+// Link to ANC's own headless CNCjs (engines/cncjs, built into
+// dist/engines/cncjs) over its socket.io API, with a cached view of controller
+// state. ANC always starts and owns this engine as a child process on a free
+// loopback port; it never looks for, adopts or controls any other CNCjs.
+import { fork } from "node:child_process";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import { createRequire } from "node:module";
 import jwt from "jsonwebtoken";
 import io from "socket.io-client";
-const require = createRequire(import.meta.url);
-export const CNCJS_URL = process.env.CNCJS_URL ?? "http://127.0.0.1:8000";
 import { STATE_DIR } from "./paths.js";
 import { ROOT } from "./product.js";
+import { programHash } from "./program.js";
+/** ANC's CNCjs config (CNCjs's .cncrc format). Not the user's ~/.cncrc. */
 const MANAGED_CONFIG = path.join(STATE_DIR, "cncrc");
-const USER_CONFIG = process.env.CNCJS_CONFIG ?? path.join(os.homedir(), ".cncrc");
+const ENGINE_DIR = path.join(ROOT, "dist", "engines", "cncjs");
 /** Telemetry older than this is shown as stale rather than live. */
 const STALE_MS = 3000;
 /** Wait this long after a failed connect before trying again. */
@@ -23,26 +21,83 @@ const MOVING_STATES = new Set(["Run", "Jog", "Home"]);
 class CNCjsLink {
     socket = null;
     child = null;
-    managed = false;
+    url = null;
+    version = null;
+    /** The engine's last "Error opening serial port" log line, per port. */
+    openErrors = new Map();
     connected = false;
     error = null;
     starting = null;
     lastFailure = 0;
     port = null;
     controller = null;
+    baudrate = null;
     status = null;
     parserState = null;
     workflow = "idle";
     sender = null;
     alarm = null;
+    settings = null;
+    /** Firmware name from the controller's startup line ("Grbl", "GrblHAL"). */
+    firmware = null;
+    /** Grbl's $# parameters: saved zeros (G54-G59, G28, G30, G92), tool length offset. */
+    parameters = null;
+    onMachineListeners = [];
     gcodeName = null;
+    gcodeHash = null;
     telemetryAt = 0;
     ports = [];
     onLoadListeners = [];
+    onRunEndListeners = [];
+    // The sender as it stood during the run: CNCjs rewinds it to zero when the
+    // workflow stops, so the outcome is read from this, not the live sender.
+    runSender = null;
     onGcodeLoad(fn) {
         this.onLoadListeners.push(fn);
     }
-    /** Connects (starting a bundled CNCjs if needed). Safe to call repeatedly. */
+    onRunEnd(fn) {
+        this.onRunEndListeners.push(fn);
+    }
+    /** Called when the controller reports its settings, parameters or an alarm. */
+    onMachine(fn) {
+        this.onMachineListeners.push(fn);
+    }
+    reportMachine() {
+        if (!this.port)
+            return;
+        const report = {
+            port: this.port,
+            controller: this.controller,
+            firmware: this.firmware,
+            version: this.settings?.version ?? null,
+            baudrate: this.baudrate,
+            settings: this.settings?.values ?? null,
+            parameters: this.parameters,
+            alarm: this.alarm,
+        };
+        for (const fn of this.onMachineListeners)
+            fn(report);
+    }
+    /** Called when the workflow leaves running/paused: finished, stopped, or halted by an alarm. */
+    endRun() {
+        const s = this.runSender;
+        this.runSender = null;
+        if (!s || !s.name)
+            return;
+        const finished = s.finishTime > 0 || (s.total > 0 && s.received >= s.total);
+        const alarmed = this.status?.activeState === "Alarm" || this.alarm !== null;
+        const run = {
+            name: s.name,
+            outcome: finished ? "complete" : alarmed ? "alarm" : "stopped",
+            received: s.received,
+            total: s.total,
+            elapsedMs: s.startTime ? (s.finishTime || Date.now()) - s.startTime : s.elapsedTime,
+            alarm: alarmed ? this.alarm : null,
+        };
+        for (const fn of this.onRunEndListeners)
+            fn(run);
+    }
+    /** Starts the engine if needed and connects to it. Safe to call repeatedly. */
     ensure() {
         if (this.connected)
             return Promise.resolve();
@@ -56,16 +111,9 @@ class CNCjsLink {
     }
     async start() {
         try {
-            // An already-running CNCjs is either the user's (~/.cncrc) or one Agentic Numerical Control
-            // started earlier and outlived (.anc/cncrc).
-            let configFile = this.managed || (!fs.existsSync(USER_CONFIG) && fs.existsSync(MANAGED_CONFIG))
-                ? MANAGED_CONFIG
-                : USER_CONFIG;
-            if (!(await reachable(CNCJS_URL))) {
-                await this.launchBundled();
-                configFile = MANAGED_CONFIG;
-            }
-            await this.connect(accessToken(configFile));
+            if (!this.child)
+                await this.launch();
+            await this.connect(accessToken());
             this.error = null;
         }
         catch (e) {
@@ -74,47 +122,80 @@ class CNCjsLink {
             throw e;
         }
     }
-    async launchBundled() {
-        const url = new URL(CNCJS_URL);
-        if (!["127.0.0.1", "localhost"].includes(url.hostname)) {
-            throw new Error(`No CNCjs answered at ${CNCJS_URL}, and Agentic Numerical Control only starts its own CNCjs on this computer.`);
+    launch() {
+        const manifestPath = path.join(ENGINE_DIR, "manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+            return Promise.reject(new Error(`The built-in CNCjs is missing (${ENGINE_DIR}). Run npm run build.`));
         }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
         fs.mkdirSync(STATE_DIR, { recursive: true });
-        const bin = require.resolve("cncjs/bin/cncjs");
-        const port = url.port || "8000";
-        console.error(`[anc] Starting bundled CNCjs on 127.0.0.1:${port} (config ${MANAGED_CONFIG})`);
         // The preload adds the GRBL-SIM port (sim/) alongside real serial ports.
         const simHook = path.join(ROOT, "sim", "virtual-port.cjs");
-        this.child = spawn(process.execPath, ["--require", simHook, bin, "-H", "127.0.0.1", "-p", port, "-c", MANAGED_CONFIG], {
-            stdio: ["ignore", "ignore", "pipe"],
+        const child = fork(path.join(ENGINE_DIR, manifest.entry), [], {
+            execArgv: ["--require", simHook],
+            env: { ...process.env, ANC_CNCJS_CONFIG: MANAGED_CONFIG, ANC_CNCJS_PORT: process.env.ANC_CNCJS_PORT ?? "0" },
+            stdio: ["ignore", "pipe", "pipe", "ipc"],
             windowsHide: true,
         });
-        this.child.stderr?.on("data", (d) => process.stderr.write(`[cncjs] ${d}`));
-        this.child.on("exit", (code) => {
-            console.error(`[anc] Bundled CNCjs exited (${code})`);
-            this.child = null;
+        this.child = child;
+        // CNCjs logs to stdout; pass on its warnings and errors, and keep the
+        // reason a serial port failed to open (its error object doesn't survive
+        // socket.io).
+        const onLog = (d) => {
+            for (const line of d.toString().split(/\r?\n/)) {
+                const plain = line.replace(/\x1b\[[0-9;]*m/g, "");
+                const m = /Error opening serial port "([^"]+)":\s*(.*)/.exec(plain);
+                if (m)
+                    this.openErrors.set(m[1], m[2].replace(/^\[?(Error:\s*)+/, "").replace(/\]$/, "").trim());
+                if (/ - (error|warn) /.test(plain) || (plain && !/ - \w+ /.test(plain)))
+                    process.stderr.write(`[cncjs] ${plain}\n`);
+            }
+        };
+        child.stdout?.on("data", onLog);
+        child.stderr?.on("data", onLog);
+        child.on("exit", (code) => {
+            console.error(`[anc] CNCjs engine exited (${code})`);
+            if (this.child === child) {
+                this.child = null;
+                this.url = null;
+                this.connected = false;
+                this.socket?.close();
+                this.socket = null;
+                this.resetPort();
+            }
         });
-        this.managed = true;
-        process.once("exit", () => this.child?.kill());
-        for (const sig of ["SIGINT", "SIGTERM"]) {
-            process.once(sig, () => {
-                this.child?.kill();
-                process.exit(0);
+        process.once("exit", () => child.kill());
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                child.kill();
+                reject(new Error("The built-in CNCjs did not start within 30 seconds."));
+            }, 30000);
+            child.on("message", (m) => {
+                if (m?.type === "ready") {
+                    clearTimeout(timer);
+                    this.url = `http://127.0.0.1:${m.port}`;
+                    this.version = m.version ?? manifest.upstream?.version ?? null;
+                    console.error(`[anc] CNCjs ${this.version} engine on ${this.url}`);
+                    resolve();
+                }
+                else if (m?.type === "error") {
+                    clearTimeout(timer);
+                    reject(new Error(`The built-in CNCjs could not start: ${m.message}`));
+                }
             });
-        }
-        for (let i = 0; i < 60; i++) {
-            if (await reachable(CNCJS_URL))
-                return;
-            await sleep(500);
-        }
-        throw new Error("The bundled CNCjs did not start within 30 seconds.");
+            child.on("exit", (code) => {
+                clearTimeout(timer);
+                reject(new Error(`The built-in CNCjs stopped while starting (exit ${code}).`));
+            });
+        });
     }
     connect(token) {
+        const url = this.url;
         return new Promise((resolve, reject) => {
-            const socket = io(CNCJS_URL, { query: `token=${token}`, reconnection: true });
+            const socket = io(url, { query: `token=${token}`, reconnection: true });
             const timer = setTimeout(() => {
                 socket.close();
-                reject(new Error(`Timed out connecting to CNCjs at ${CNCJS_URL}`));
+                reject(new Error(`Timed out connecting to the built-in CNCjs at ${url}`));
             }, 10000);
             socket.on("connect", () => {
                 clearTimeout(timer);
@@ -133,6 +214,19 @@ class CNCjsLink {
             this.listen(socket);
         });
     }
+    resetPort() {
+        if (this.workflow !== "idle")
+            this.endRun();
+        this.port = null;
+        this.controller = null;
+        this.baudrate = null;
+        this.status = null;
+        this.settings = null;
+        this.firmware = null;
+        this.parameters = null;
+        this.sender = null;
+        this.workflow = "idle";
+    }
     listen(socket) {
         socket.on("serialport:list", (ports) => {
             this.ports = ports ?? [];
@@ -140,13 +234,23 @@ class CNCjsLink {
         socket.on("serialport:open", (o) => {
             this.port = o?.port ?? null;
             this.controller = o?.controllerType ?? null;
+            this.baudrate = typeof o?.baudrate === "number" ? o.baudrate : null;
         });
-        socket.on("serialport:close", () => {
-            this.port = null;
-            this.controller = null;
-            this.status = null;
-            this.sender = null;
-            this.workflow = "idle";
+        socket.on("serialport:close", () => this.resetPort());
+        // Grbl's $$ settings (travel, rapid rates, homing), which CNCjs asks for on connect.
+        socket.on("controller:settings", (_type, s) => {
+            const values = s?.settings && typeof s.settings === "object" ? s.settings : null;
+            if (values) {
+                const first = !this.settings;
+                this.settings = { version: typeof s.version === "string" ? s.version : null, values };
+                const params = s?.parameters && typeof s.parameters === "object" ? s.parameters : null;
+                if (params && Object.keys(params).length)
+                    this.parameters = params;
+                this.reportMachine();
+                // Ask once for the saved zeros ($#); Grbl answers at once and nothing moves.
+                if (first && this.workflow === "idle")
+                    this.socket?.emit("command", this.port, "gcode", "$#");
+            }
         });
         socket.on("controller:state", (type, state) => {
             this.controller = type;
@@ -161,27 +265,43 @@ class CNCjsLink {
         });
         socket.on("serialport:read", (data) => {
             const m = /ALARM:(\d+)(.*)/.exec(data ?? "");
-            if (m)
+            if (m) {
                 this.alarm = `ALARM:${m[1]}${m[2]}`.trim();
+                this.reportMachine();
+            }
+            const startup = /^(Grbl\w*)\s+v?\d/i.exec(data ?? "");
+            if (startup)
+                this.firmware = startup[1];
         });
         socket.on("workflow:state", (s) => {
+            const wasRunning = this.workflow !== "idle";
             this.workflow = s;
+            if (wasRunning && s === "idle")
+                this.endRun();
         });
         socket.on("sender:status", (s) => {
             this.sender = s;
+            if (this.workflow !== "idle" && (s.sent > 0 || s.finishTime > 0))
+                this.runSender = { ...s };
         });
         socket.on("gcode:load", (name, gcode) => {
             this.gcodeName = name;
             // CNCjs appends its own "%wait" dwell line; drop it from the preview.
             const program = gcode.replace(/\n%wait ; Wait for the planner to empty\s*$/, "");
+            this.gcodeHash = programHash(program);
             for (const fn of this.onLoadListeners)
                 fn(name, program);
         });
         socket.on("gcode:unload", () => {
             this.gcodeName = null;
+            this.gcodeHash = null;
             this.sender = null;
         });
     }
+    /** The controller's own settings ($$ for Grbl), or null before it has reported them. */
+    controllerSettings() {
+        return this.port ? this.settings : null;
+    }
     snapshot() {
         const age = Date.now() - this.telemetryAt;
         // CNCjs emits controller:state only when the state changes, so a quiet
@@ -202,9 +322,10 @@ class CNCjsLink {
         return {
             link,
             state,
-            cncjs: { url: CNCJS_URL, managed: this.managed, connected: this.connected, error: this.error },
+            cncjs: { version: this.version, connected: this.connected, error: this.error },
             port: this.port,
             controller: this.controller,
+            baudrate: this.baudrate,
             activeState: this.status?.activeState ?? null,
             workflow: this.workflow,
             mpos: toVec(this.status?.mpos),
@@ -213,6 +334,7 @@ class CNCjsLink {
             alarm: this.alarm,
             sender: this.sender,
             loadedFile: this.gcodeName,
+            loadedHash: this.gcodeHash,
             telemetryAt: this.telemetryAt ? new Date(this.telemetryAt).toISOString() : null,
         };
     }
@@ -224,12 +346,13 @@ class CNCjsLink {
     }
     async openPort(port, baudrate, controllerType) {
         await this.ensure();
+        this.openErrors.delete(port);
         await new Promise((resolve, reject) => {
             this.socket.emit("open", port, { controllerType, baudrate }, (err) => {
-                if (err)
-                    reject(new Error(`CNCjs could not open ${port}: ${JSON.stringify(err)}`));
-                else
-                    resolve();
+                if (!err)
+                    return resolve();
+                // The error object doesn't survive socket.io; the engine logs its message.
+                setTimeout(() => reject(new Error(openErrorMessage(port, this.openErrors.get(port) ?? err?.message ?? null))), 200);
             });
         });
     }
@@ -262,28 +385,24 @@ class CNCjsLink {
         return this.port;
     }
 }
-function accessToken(configFile) {
-    if (process.env.CNCJS_TOKEN)
-        return process.env.CNCJS_TOKEN;
+function accessToken() {
     let secret;
     try {
-        secret = JSON.parse(fs.readFileSync(configFile, "utf-8")).secret;
+        secret = JSON.parse(fs.readFileSync(MANAGED_CONFIG, "utf-8")).secret;
     }
     catch {
-        throw new Error(`Could not read the CNCjs secret from ${configFile}. Set CNCJS_CONFIG or CNCJS_TOKEN.`);
+        throw new Error(`Could not read the CNCjs secret from ${MANAGED_CONFIG}.`);
     }
     if (!secret)
-        throw new Error(`${configFile} has no "secret".`);
+        throw new Error(`${MANAGED_CONFIG} has no "secret".`);
     return jwt.sign({ id: "", name: "anc" }, secret, { expiresIn: "30d" });
 }
-async function reachable(url) {
-    try {
-        const res = await fetch(url, { signal: AbortSignal.timeout(1500) });
-        return res.status < 500;
-    }
-    catch {
-        return false;
+/** Says plainly when another program holds the port, rather than sharing it. */
+export function openErrorMessage(port, detail) {
+    if (detail && /access denied|resource busy|cannot lock|ebusy|in use/i.test(detail)) {
+        return `${port} is in use by another program (another CNCjs, a G-code sender, or a serial monitor). Close that program and try again. (${detail})`;
     }
+    return `Could not open ${port}${detail ? `: ${detail}` : "."}`;
 }
 function toVec(v) {
     if (!v)

package/dist/server/history.js

@@ -0,0 +1,48 @@
+// How each job file last ran on this computer, so the Jobs page can show
+// Complete or Stopped for files CNCjs no longer has loaded. CNCjs itself only
+// knows the program loaded right now. Kept beside the app's other state.
+import fs from "node:fs";
+import path from "node:path";
+import { STATE_DIR } from "./paths.js";
+const FILE = path.join(STATE_DIR, "job-history.json");
+let runs = null;
+function load() {
+    if (runs)
+        return runs;
+    try {
+        runs = JSON.parse(fs.readFileSync(FILE, "utf-8"));
+    }
+    catch {
+        runs = {};
+    }
+    return runs;
+}
+function save() {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(FILE, JSON.stringify(runs, null, 2));
+    }
+    catch {
+        // History is a convenience; a write failure must never affect a run.
+    }
+}
+export function lastRun(name) {
+    return load()[name] ?? null;
+}
+export function recordRun(run) {
+    load()[run.name] = {
+        outcome: run.outcome,
+        endedAt: new Date().toISOString(),
+        elapsedMs: run.elapsedMs,
+        received: run.received,
+        total: run.total,
+        alarm: run.alarm,
+    };
+    save();
+}
+export function forgetRun(name) {
+    if (!(name in load()))
+        return;
+    delete runs[name];
+    save();
+}

package/dist/server/jobs.js

@@ -4,6 +4,8 @@ import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { JOBS_DIR, ROOT } from "./product.js";
+import { programHash } from "./program.js";
+import { analyzeGcode } from "./analysis.js";
 import { buildToolpath, packToolpath } from "./toolpath.js";
 const GCODE_EXT = /\.(nc|gcode|gc|ngc|tap|cnc|txt)$/i;
 let current = null;
@@ -29,6 +31,49 @@ export async function listJobFiles() {
         .map((e) => e.name)
         .sort();
 }
+// Files over this are listed without parsing; opening them still works.
+const INFO_MAX_BYTES = 4 * 1024 * 1024;
+const infoCache = new Map();
+export async function jobFileInfo(file, machine, machineKey = "") {
+    const resolved = jobPath(file);
+    const stat = await fs.stat(resolved);
+    const key = `${stat.size}:${stat.mtimeMs}:${machineKey}`;
+    const cached = infoCache.get(file);
+    if (cached?.key === key)
+        return cached.info;
+    const info = {
+        file,
+        bytes: stat.size,
+        modified: stat.mtime.toISOString(),
+        lineCount: null,
+        units: null,
+        bounds: null,
+        check: null,
+    };
+    if (stat.size <= INFO_MAX_BYTES) {
+        try {
+            const gcode = await fs.readFile(resolved, "utf-8");
+            const tp = buildToolpath(gcode);
+            info.lineCount = tp.lines.length;
+            info.units = tp.units;
+            info.bounds = tp.bounds;
+            const a = analyzeGcode(gcode, machine);
+            const problems = a.checks.filter((c) => c.severity === "problem").length;
+            info.check = {
+                estimatedSeconds: a.time.totalSeconds,
+                tools: a.tools,
+                problems,
+                toCheck: a.checks.length - problems,
+                fit: a.fit.status,
+            };
+        }
+        catch {
+            // Listed without details; anc_show_job reports why it can't be opened.
+        }
+    }
+    infoCache.set(file, { key, info });
+    return info;
+}
 function load(name, source, gcode) {
     const toolpath = buildToolpath(gcode);
     current = {
@@ -36,21 +81,32 @@ function load(name, source, gcode) {
         source,
         revision: ++revision,
         gcode,
+        hash: programHash(gcode),
         toolpath,
         packed: packToolpath(toolpath),
         loadedAt: new Date().toISOString(),
     };
     return current;
 }
-/** Reads a file from the jobs directory only; paths outside it are refused. */
-export async function loadJobFile(file) {
-    await ensureJobsDir();
+/** Resolves a name to a G-code file directly in the jobs directory; anything else is refused. */
+function jobPath(file) {
     const resolved = path.resolve(JOBS_DIR, file);
     if (path.dirname(resolved) !== JOBS_DIR || !GCODE_EXT.test(resolved)) {
         throw new Error(`"${file}" is not a G-code file in the Agentic Numerical Control jobs folder (${JOBS_DIR}).`);
     }
+    return resolved;
+}
+export async function loadJobFile(file) {
+    await ensureJobsDir();
+    const resolved = jobPath(file);
     return load(path.basename(resolved), "file", await fs.readFile(resolved, "utf-8"));
 }
+/** Deletes a file from the jobs directory. The job already shown stays shown until another is opened. */
+export async function deleteJobFile(file) {
+    const resolved = jobPath(file);
+    await fs.unlink(resolved);
+    return path.basename(resolved);
+}
 export function loadJobText(name, gcode) {
     return load(name, "inline", gcode);
 }
@@ -79,6 +135,7 @@ export function jobSummary(job) {
         name: job.name,
         source: job.source,
         revision: job.revision,
+        hash: job.hash,
         loadedAt: job.loadedAt,
         lineCount: tp.lines.length,
         segmentCount: tp.motions.length,

package/dist/server/machines.js

@@ -0,0 +1,96 @@
+// The machines this computer has talked to, for the Machines page: what each
+// controller reported about itself the last time it connected (firmware,
+// travel, speeds, homing, saved zeros), how much it has run, and the name the
+// person gave it. Grbl doesn't report a make or model, so the name is theirs.
+// Kept beside the app's other state, one entry per port.
+import fs from "node:fs";
+import path from "node:path";
+import { STATE_DIR } from "./paths.js";
+const FILE = path.join(STATE_DIR, "machines.json");
+let machines = null;
+function load() {
+    if (machines)
+        return machines;
+    try {
+        machines = JSON.parse(fs.readFileSync(FILE, "utf-8"));
+    }
+    catch {
+        machines = {};
+    }
+    return machines;
+}
+function save() {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(FILE, JSON.stringify(machines, null, 2));
+    }
+    catch {
+        // A convenience; a write failure must never affect the machine.
+    }
+}
+function entry(port) {
+    const all = load();
+    const now = new Date().toISOString();
+    return (all[port] ??= {
+        port,
+        name: null,
+        controller: null,
+        firmware: null,
+        version: null,
+        baudrate: null,
+        settings: null,
+        parameters: null,
+        firstSeen: now,
+        lastSeen: now,
+        jobsRun: 0,
+        cuttingMs: 0,
+        lastAlarm: null,
+    });
+}
+/** Records what the controller reported; keeps earlier values it didn't repeat. */
+export function recordMachine(report) {
+    const m = entry(report.port);
+    m.lastSeen = new Date().toISOString();
+    m.controller = report.controller ?? m.controller;
+    m.firmware = report.firmware ?? m.firmware;
+    m.version = report.version ?? m.version;
+    m.baudrate = report.baudrate ?? m.baudrate;
+    if (report.settings && Object.keys(report.settings).length)
+        m.settings = report.settings;
+    if (report.parameters && Object.keys(report.parameters).length)
+        m.parameters = report.parameters;
+    if (report.alarm && report.alarm !== m.lastAlarm?.alarm)
+        m.lastAlarm = { alarm: report.alarm, at: m.lastSeen };
+    save();
+}
+/** Counts a finished or stopped run against the machine it ran on. */
+export function recordMachineRun(port, run) {
+    if (!port)
+        return;
+    const m = entry(port);
+    m.jobsRun++;
+    m.cuttingMs += Math.max(0, run.elapsedMs);
+    if (run.alarm)
+        m.lastAlarm = { alarm: run.alarm, at: new Date().toISOString() };
+    save();
+}
+export function listMachines() {
+    return Object.values(load()).sort((a, b) => b.lastSeen.localeCompare(a.lastSeen));
+}
+export function renameMachine(port, name) {
+    const all = load();
+    const m = all[port];
+    if (!m)
+        throw new Error(`No machine has connected on ${port}.`);
+    m.name = name.trim().slice(0, 60) || null;
+    save();
+    return m;
+}
+/** The name to show: the person's, else what the port says it is. */
+export function machineName(m) {
+    if (m.name)
+        return m.name;
+    if (m.port === "GRBL-SIM")
+        return "grblHAL simulator";
+    return `${m.firmware ?? m.controller ?? "Machine"} on ${m.port}`;
+}

package/dist/server/program.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+/**
+ * Identifies a G-code program by its content, so a start can be tied to the
+ * exact program the person was looking at rather than to a file name. Line
+ * endings, trailing spaces and blank lines don't change what the machine does,
+ * so they don't change the hash either.
+ */
+export function programHash(gcode) {
+    const lines = gcode
+        .split(/\r?\n/)
+        .map((l) => l.trimEnd())
+        .filter((l) => l !== "");
+    return createHash("sha256").update(lines.join("\n")).digest("hex");
+}