agentic-numerical-control 0.1.8 → 0.2.0

package/dist/server/cncjs.js

@@ -1,21 +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. */
@@ -24,7 +21,10 @@ 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;
@@ -97,7 +97,7 @@ class CNCjsLink {
         for (const fn of this.onRunEndListeners)
             fn(run);
     }
-    /** Connects (starting a bundled CNCjs if needed). Safe to call repeatedly. */
+    /** Starts the engine if needed and connects to it. Safe to call repeatedly. */
     ensure() {
         if (this.connected)
             return Promise.resolve();
@@ -111,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) {
@@ -129,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);
@@ -188,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 ?? [];
@@ -197,19 +236,7 @@ class CNCjsLink {
             this.controller = o?.controllerType ?? null;
             this.baudrate = typeof o?.baudrate === "number" ? o.baudrate : null;
         });
-        socket.on("serialport:close", () => {
-            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";
-        });
+        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;
@@ -295,7 +322,7 @@ 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,
@@ -319,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);
             });
         });
     }
@@ -357,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/server.js

@@ -6,10 +6,12 @@ import path from "node:path";
 import { z } from "zod";
 import { currentJob, deleteJobFile, jobFileInfo, jobSummary, jobsDir, listJobFiles, loadJobFile, loadJobFromCncjs, loadJobText, parsedLineAt, } from "./jobs.js";
 import { PRODUCT, ROOT, VERSION } from "./product.js";
-import { CNCJS_URL, cncjs } from "./cncjs.js";
+import { cncjs } from "./cncjs.js";
 import { forgetRun, lastRun, recordRun } from "./history.js";
 import { analyzeGcode } from "./analysis.js";
 import { listMachines, machineName, recordMachine, recordMachineRun, renameMachine } from "./machines.js";
+import { camEngine, camJobInfo, camMachine, cancelCamJob, inspectModel, listCamJobs, listModels, listTools, removeTool, saveTool, startGenerate, waitForCamJob, } from "./cam.js";
+import { findSettings, importTools } from "./settings-import.js";
 // The viewer follows whatever program CNCjs has loaded, including files
 // loaded from the CNCjs interface itself.
 cncjs.onGcodeLoad((name, gcode) => loadJobFromCncjs(name, gcode));
@@ -115,6 +117,40 @@ function describeMachine(m, live) {
         lastSeen: live ? new Date().toISOString() : m.lastSeen,
     };
 }
+/** The machine CAM plans for: the connected one, else the one seen most recently. */
+function camMachineNow() {
+    const live = cncjs.controllerSettings();
+    const m = cncjs.snapshot();
+    const record = (m.port && listMachines().find((r) => r.port === m.port)) || listMachines()[0];
+    return { ...camMachine(live?.values ?? record?.settings), name: record ? machineName(record) : null };
+}
+/** A finished generation, with the job check's headline for the new file. */
+async function camResult(job) {
+    if (job.state !== "done" || !job.file)
+        return job;
+    try {
+        const mc = machineContext();
+        const info = await jobFileInfo(job.file, mc.context, mc.key);
+        return { ...job, check: info.check, bounds: info.bounds, next: "Show it with anc_show_job (file). Nothing has been loaded into CNCjs." };
+    }
+    catch {
+        return job;
+    }
+}
+const OPERATION = z.object({
+    type: z.enum(["rough", "outline", "contour"]).describe("rough: clear material in flat layers (stepDown) down to the part. outline: cut along the part's edges, layer by layer (side outside to cut it out). contour: 3D finishing pass over the surface (best with a ball end mill)."),
+    tool: z.number().int().describe("Tool id from anc_cam_settings / anc_save_tool. One tool per job."),
+    stepDown: z.number().positive().optional().describe("mm per layer (rough, outline)"),
+    stepOver: z.number().min(0.05).max(1).optional().describe("Fraction of the tool diameter between passes (rough, contour), e.g. 0.4"),
+    feed: z.number().positive().describe("Cutting feed, mm/min"),
+    plunge: z.number().positive().optional().describe("Plunge feed, mm/min (rough, outline)"),
+    spindle: z.number().positive().describe("Spindle speed, rpm"),
+    leave: z.number().min(0).optional().describe("rough: mm to leave on walls for a finishing pass; contour: mm to leave on the surface"),
+    area: z.enum(["all", "inside"]).optional().describe("rough: clear all stock around the part (default), or only inside its outline"),
+    side: z.enum(["outside", "inside"]).optional().describe("outline: outside edge (default) or inside edges"),
+    axis: z.enum(["X", "Y"]).optional().describe("contour: direction of passes (default X)"),
+    direction: z.enum(["climb", "conventional"]).optional().describe("Milling direction (default climb)"),
+});
 function fail(message) {
     return { content: [{ type: "text", text: message }], isError: true };
 }
@@ -295,6 +331,194 @@ export function createServer() {
             return fail(e.message);
         }
     });
+    // ---- CAM: 3D models to G-code with the built-in Kiri:Moto. Generating only
+    // writes a job file; nothing here loads it into CNCjs or moves the machine.
+    registerAppTool(server, "anc_list_models", {
+        title: "List 3D models",
+        description: "List the 3D models (STL files) in the Agentic Numerical Control jobs folder that can be turned into G-code. " +
+            "The person adds models by putting STL files in that folder. Each comes with its size in the file's own units, " +
+            "the units the person gave when a job was last made from it, and the jobs made from it. Reads only.",
+        inputSchema: z.object({
+            preview: z.boolean().optional().describe("Include a coarse top view of each model, for the website's Models page"),
+        }),
+        annotations: { readOnlyHint: true },
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async ({ preview }) => {
+        try {
+            return json({ computer: os.hostname(), folder: jobsDir(), models: listModels({ preview }) });
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_inspect_model", {
+        title: "Inspect 3D model",
+        description: "Size and triangle count of an STL model, read by the CAM engine. STL has no units, so the size is given both as millimetres and as inches: " +
+            "confirm with the person which is right before generating. Reads only.",
+        inputSchema: z.object({ file: z.string().describe("STL file name from anc_list_models") }),
+        annotations: { readOnlyHint: true },
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async ({ file }) => {
+        try {
+            return json(await inspectModel(file));
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_cam_settings", {
+        title: "CAM settings",
+        description: "What G-code generation will use: the machine (work area, spindle maximum, feed limits, from the controller when it has reported them), " +
+            "the person's tool library, the operations available, how stock and zero are set, and the CAM engine version. Reads only.",
+        inputSchema: z.object({}),
+        annotations: { readOnlyHint: true },
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async () => {
+        return json({
+            engine: camEngine(),
+            machine: camMachineNow(),
+            output: "Grbl / grblHAL G-code in mm: G21 G90, spindle on with M3, off with M5, no M6 tool changes.",
+            tools: listTools(),
+            operations: {
+                rough: "Clears material in flat layers. Needs tool, stepDown, stepOver, feed, plunge, spindle; optional leave, area.",
+                outline: "Cuts along the part's edges layer by layer; side outside cuts the part out. Needs tool, stepDown, feed, plunge, spindle; optional side.",
+                contour: "3D finishing over the surface, usually after rough. Needs tool, stepOver, feed, spindle; optional axis, leave.",
+            },
+            placement: "The part sits with its top at the top of the stock. Z zero is the top of the stock; X/Y zero is the stock's front-left corner (origin front-left, default) or its centre (origin center). " +
+                "Stock defaults to the part plus 10 mm in X and Y, and the part's height.",
+            limits: "One tool per job. STL models only for now.",
+            recentGenerations: listCamJobs(),
+        });
+    });
+    registerAppTool(server, "anc_save_tool", {
+        title: "Save cutting tool",
+        description: "Add a cutting tool to the person's tool library, or change one (pass its id). Sizes in mm: convert inch tools (1/8 in = 3.175 mm). " +
+            "Ask the person for the tool's real measurements rather than guessing.",
+        inputSchema: z.object({
+            id: z.number().int().optional().describe("Existing tool to change; leave out to add a new one"),
+            name: z.string().max(60).describe("The person's name for it, e.g. '3 mm 2-flute flat'"),
+            type: z.enum(["flat", "ball", "vbit", "drill"]),
+            diameter: z.number().positive().describe("Cutting diameter, mm"),
+            fluteLength: z.number().positive().describe("Length of the cutting edge, mm"),
+            shankDiameter: z.number().positive().optional().describe("Shank diameter, mm (defaults to the cutting diameter)"),
+            angle: z.number().positive().optional().describe("V-bit included angle, degrees"),
+            number: z.number().int().positive().optional().describe("Tool number (T word), if the machine has a tool changer"),
+        }),
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async (input) => {
+        try {
+            return json({ saved: saveTool(input), tools: listTools() });
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_delete_tool", {
+        title: "Delete cutting tool",
+        description: "Remove a tool from the person's tool library.",
+        inputSchema: z.object({ id: z.number().int() }),
+        annotations: { destructiveHint: true },
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async ({ id }) => {
+        try {
+            removeTool(id);
+            return json({ deleted: id, tools: listTools() });
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_find_settings", {
+        title: "Find settings from other CNC software",
+        description: "Look on this computer for settings from other CNC software that could be imported: Kiri:Moto tool exports (.km, .b64), Fusion tool library exports (.json) and CNCjs's ~/.cncrc. " +
+            "Searches only ~/.cncrc and, one level deep, Downloads, Documents, Desktop, the jobs folder and Fusion's local libraries. Reads only; changes nothing. " +
+            "Show the person what was found and ask which tools to import before calling anc_import_tools.",
+        inputSchema: z.object({}),
+        annotations: { readOnlyHint: true },
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async () => json(findSettings()));
+    registerAppTool(server, "anc_import_tools", {
+        title: "Import cutting tools",
+        description: "Add tools from a source found by anc_find_settings to the person's tool library, after they have agreed. Only adds: tools already in the library are left as they are, and nothing is replaced or deleted.",
+        inputSchema: z.object({
+            source: z.string().describe("Source id from anc_find_settings"),
+            pick: z.array(z.number().int().min(0)).optional().describe("Which of the source's tools to add (0-based positions in its tools list); leave out for all"),
+        }),
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async ({ source, pick }) => {
+        try {
+            return json(importTools(source, pick));
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_generate_gcode", {
+        title: "Generate G-code from a 3D model",
+        description: "Make a G-code job from an STL model with the built-in Kiri:Moto CAM engine, and save it in the jobs folder as a new file. " +
+            "Before calling: confirm the model's units with the person (anc_inspect_model), the stock size, where they will set zero, and the tool and its feeds and speeds. " +
+            "Waits up to about 40 seconds; a longer job keeps going and anc_cam_status reports it. " +
+            "Never loads the job into CNCjs or moves the machine: show it with anc_show_job for the person to review.",
+        inputSchema: z.object({
+            model: z.string().describe("STL file name from anc_list_models"),
+            units: z.enum(["mm", "in"]).describe("Units the model was drawn in, as the person confirmed"),
+            stock: z
+                .object({ x: z.number().positive(), y: z.number().positive(), z: z.number().positive() })
+                .optional()
+                .describe("Stock size in mm; at least the part's size"),
+            origin: z.enum(["front-left", "center"]).optional().describe("Where X/Y zero is on the stock (Z zero is always the top of the stock)"),
+            operations: z.array(OPERATION).min(1).max(8).describe("Operations in order, all with the same tool"),
+            name: z.string().max(80).optional().describe("Job file name (defaults to the model's name)"),
+        }),
+        _meta: {
+            ui: { visibility: ["model", "app"] },
+            "openai/toolInvocation/invoking": "Generating toolpaths…",
+            "openai/toolInvocation/invoked": "Toolpaths generated",
+        },
+    }, async (req) => {
+        try {
+            const started = await startGenerate(req, camMachineNow());
+            return json(await camResult(await waitForCamJob(started.id, 40000)));
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_cam_status", {
+        title: "G-code generation status",
+        description: "Progress of a G-code generation started with anc_generate_gcode: running (with progress 0-1), done (with the new job file), failed (with the reason) or cancelled. " +
+            "Waits up to about 20 seconds for a running one to finish. Without id, lists recent generations. Pass file instead to see how a generated job was made.",
+        inputSchema: z.object({
+            id: z.string().optional(),
+            file: z.string().optional().describe("A generated job file: returns its model, units, stock, tool, operations and engine version"),
+        }),
+        annotations: { readOnlyHint: true },
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async ({ id, file }) => {
+        try {
+            if (file)
+                return json({ file, generatedWith: camJobInfo(file) });
+            if (!id)
+                return json({ generations: listCamJobs() });
+            return json(await camResult(await waitForCamJob(id, 20000)));
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
+    registerAppTool(server, "anc_cam_cancel", {
+        title: "Cancel G-code generation",
+        description: "Stop a G-code generation that is still running. Nothing is saved.",
+        inputSchema: z.object({ id: z.string() }),
+        _meta: { ui: { visibility: ["model", "app"] } },
+    }, async ({ id }) => {
+        try {
+            return json(cancelCamJob(id));
+        }
+        catch (e) {
+            return fail(e.message);
+        }
+    });
     // ---- App-only tools: the viewer and the Jobs page call these directly, without a model turn.
     registerAppTool(server, "anc_delete_job", {
         title: "Delete job file",
@@ -346,7 +570,6 @@ export function createServer() {
                 }
                 : null,
             machineName: machine.port ? machineName(listMachines().find((r) => r.port === machine.port) ?? { name: null, port: machine.port, firmware: null, controller: machine.controller }) : null,
-            cncjsUrl: CNCJS_URL,
             version: VERSION,
             serverTime: new Date().toISOString(),
         });