agentic-numerical-control 0.1.5 → 0.1.8

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");
+}