agentic-numerical-control 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Edward Coventry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,44 @@
-# Temporary Holding Version
+# Agentic Numerical Control
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+See and run CNC jobs from Claude: a 3D toolpath viewer inside the chat, live machine status and job control, for CNCjs/GRBL machines. Claude on the web, desktop and phone.
+
+The product name, npm package name and cloud address live in [product.json](product.json); renaming is a change there.
+
+## How it fits together
+
+```
+Claude ──MCP+OAuth──▶ cloud/ (Cloudflare Worker) ◀──outbound WebSocket── PC app (npm package) ──▶ CNCjs ──USB──▶ GRBL
+```
+
+- **cloud/**: the address Claude connects to. Sign-in through Neon Auth, OAuth for Claude, PC pairing by code, and a per-user relay (Durable Object). Also serves the product page and the one-line installers. Deployed by hand: `cd cloud && npm run deploy`.
+- **PC app** (repo root, published to npm): runs beside the machine, bundles CNCjs, serves the MCP tools and the viewer, and keeps an outbound connection to the cloud. Nothing listens on the network.
+- **sim/**: grblHAL simulator exposed to CNCjs as a GRBL-SIM serial port, for testing without a machine (development only, not shipped).
+
+## For users
+
+```powershell
+irm https://agenticnumericalcontrol.netlify.app/install.ps1 | iex      # Windows
+```
+```bash
+curl -fsSL https://agenticnumericalcontrol.netlify.app/install.sh | sh # macOS / Linux
+```
+
+The installer puts a private Node.js and the app in the user's app-data folder (no admin), links the PC to the account with a code, and starts it at every login. G-code goes in `Documents/Agentic Numerical Control`. The app updates itself from npm when it starts.
+
+CLI: `anc setup | start | status | unlink | stdio | serve`.
+
+## Development
+
+```powershell
+npm install
+npm run build          # viewer + compiled app in dist/
+npm run dev            # build and run the app against the cloud in product.json
+npm run dev:serve      # local MCP endpoint only, http://127.0.0.1:3311/mcp/<token>
+npm run sim:build      # build the simulator (WSL on Windows)
+npm run sim:e2e        # connect GRBL-SIM, load the demo job, start, pause, stop
+npm pack               # what would be published (dist, product.json, demo job, sim hook)
+```
+
+State (local token, bundled CNCjs config, device link, log) is in `%LOCALAPPDATA%\AgenticNumericalControl`, `~/Library/Application Support/AgenticNumericalControl` or `~/.local/share/agentic-numerical-control`.
+
+Design notes and decisions: [docs/design-notes.md](docs/design-notes.md).

package/dist/server/autostart.js

@@ -0,0 +1,85 @@
+// Start the app when the user logs in, without admin rights: the per-user Run
+// key on Windows, a launchd agent on macOS, a systemd user service on Linux.
+// Each runs `<cli> start --log`.
+import { execFileSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { STATE_DIR } from "./paths.js";
+import { PRODUCT } from "./product.js";
+const LABEL = `com.${PRODUCT.name}.agent`;
+const RUN_KEY = String.raw `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`;
+const LAUNCHER = path.join(STATE_DIR, "start.cmd");
+function quiet(file, args) {
+    try {
+        execFileSync(file, args, { stdio: "ignore" });
+    }
+    catch {
+        // nothing to remove / not loaded
+    }
+}
+function command(cliPath) {
+    return [process.execPath, cliPath, "start", "--log"];
+}
+export function enableAutostart(cliPath) {
+    const cmd = command(cliPath);
+    if (process.platform === "win32") {
+        // A short launcher keeps the Run entry well under its length limit;
+        // conhost --headless runs it without a visible window. Logon-triggered
+        // scheduled tasks would need admin rights, the Run key does not.
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(LAUNCHER, `@${cmd.map((c) => `"${c}"`).join(" ")}\r\n`);
+        execFileSync("reg", ["add", RUN_KEY, "/v", PRODUCT.displayName, "/t", "REG_SZ", "/d", `conhost.exe --headless "${LAUNCHER}"`, "/f"], {
+            stdio: "ignore",
+        });
+        spawn("conhost.exe", ["--headless", LAUNCHER], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+        return "Windows sign-in startup entry (no admin needed)";
+    }
+    if (process.platform === "darwin") {
+        const plist = path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+        fs.mkdirSync(path.dirname(plist), { recursive: true });
+        fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key><array>${cmd.map((c) => `<string>${c}</string>`).join("")}</array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+</dict></plist>
+`);
+        quiet("launchctl", ["unload", plist]);
+        execFileSync("launchctl", ["load", "-w", plist], { stdio: "ignore" });
+        return `launchd agent ${plist}`;
+    }
+    const unit = path.join(os.homedir(), ".config", "systemd", "user", `${PRODUCT.name}.service`);
+    fs.mkdirSync(path.dirname(unit), { recursive: true });
+    fs.writeFileSync(unit, `[Unit]
+Description=${PRODUCT.displayName} agent
+
+[Service]
+ExecStart=${cmd.map((c) => `"${c}"`).join(" ")}
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`);
+    execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    execFileSync("systemctl", ["--user", "enable", "--now", `${PRODUCT.name}.service`], { stdio: "ignore" });
+    return `systemd user service ${PRODUCT.name}.service`;
+}
+export function disableAutostart() {
+    if (process.platform === "win32") {
+        quiet("reg", ["delete", RUN_KEY, "/v", PRODUCT.displayName, "/f"]);
+        fs.rmSync(LAUNCHER, { force: true });
+    }
+    else if (process.platform === "darwin") {
+        const plist = path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+        quiet("launchctl", ["unload", plist]);
+        fs.rmSync(plist, { force: true });
+    }
+    else {
+        quiet("systemctl", ["--user", "disable", "--now", `${PRODUCT.name}.service`]);
+        fs.rmSync(path.join(os.homedir(), ".config", "systemd", "user", `${PRODUCT.name}.service`), { force: true });
+    }
+}

package/dist/server/cli.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// Command-line entry point.
+//
+//   <name> setup        link this PC to your account, start now and at every login
+//   <name> start        run in the foreground (what the login task runs)
+//   <name> status       show the link, jobs folder and version
+//   <name> unlink       forget this PC's link and stop starting at login
+//   <name> stdio        local MCP over stdio (Claude Desktop / Claude Code config)
+//   <name> serve        local MCP over HTTP at /mcp/<token> (development)
+import { createMcpExpressApp } from "@modelcontextprotocol/express";
+import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { disableAutostart, enableAutostart } from "./autostart.js";
+import { cncjs } from "./cncjs.js";
+import { STATE_DIR } from "./paths.js";
+import { JOBS_DIR, PRODUCT, VERSION } from "./product.js";
+import { DEVICE_FILE, pair, readLink, runRelay } from "./relay.js";
+import { createServer } from "./server.js";
+import { updateIfAvailable } from "./update.js";
+const TOKEN_FILE = path.join(STATE_DIR, "token");
+const LOG_FILE = path.join(STATE_DIR, "agent.log");
+const PID_FILE = path.join(STATE_DIR, "agent.pid");
+/** Stops a background copy started at login or by an earlier setup, if running. */
+function stopRunning() {
+    try {
+        const pid = Number(fs.readFileSync(PID_FILE, "utf-8"));
+        if (pid && pid !== process.pid)
+            process.kill(pid);
+    }
+    catch {
+        // not running
+    }
+    fs.rmSync(PID_FILE, { force: true });
+}
+const CLI_PATH = fileURLToPath(import.meta.url);
+/**
+ * The local HTTP endpoint is served only at /mcp/<token>, so other programs
+ * on this computer cannot drive the machine through it. The relay knows the
+ * token; nothing outside this computer ever sees the endpoint.
+ */
+function accessToken() {
+    if (process.env.ANC_TOKEN)
+        return process.env.ANC_TOKEN;
+    if (fs.existsSync(TOKEN_FILE))
+        return fs.readFileSync(TOKEN_FILE, "utf-8").trim();
+    const token = randomBytes(24).toString("base64url");
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.writeFileSync(TOKEN_FILE, token + "\n", { mode: 0o600 });
+    return token;
+}
+function tokenMatches(candidate, token) {
+    const a = Buffer.from(candidate);
+    const b = Buffer.from(token);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/** Starts the loopback MCP endpoint and resolves with its URL. */
+function startHttp() {
+    const port = parseInt(process.env.PORT ?? "3311", 10);
+    const token = accessToken();
+    const app = createMcpExpressApp({ host: "127.0.0.1" });
+    app.all("/mcp/:token", async (req, res) => {
+        if (!tokenMatches(String(req.params.token), token)) {
+            res.status(404).end();
+            return;
+        }
+        const server = createServer();
+        const transport = new NodeStreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        res.on("close", () => {
+            transport.close().catch(() => { });
+            server.close().catch(() => { });
+        });
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error("MCP error:", error);
+            if (!res.headersSent) {
+                res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null });
+            }
+        }
+    });
+    return new Promise((resolve) => {
+        app.listen(port, "127.0.0.1", (err) => {
+            if (err) {
+                const inUse = err.code === "EADDRINUSE";
+                console.error(inUse
+                    ? `${PRODUCT.displayName} is already running on this computer (port ${port} is taken).`
+                    : `${PRODUCT.displayName} could not listen on port ${port}: ${err.message}`);
+                process.exit(1);
+            }
+            resolve(`http://127.0.0.1:${port}/mcp/${token}`);
+        });
+    });
+}
+function logToFile() {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const stream = fs.createWriteStream(LOG_FILE, { flags: "a" });
+    const write = (chunk) => stream.write(`${new Date().toISOString()} ${String(chunk)}`);
+    process.stdout.write = ((chunk) => write(chunk));
+    process.stderr.write = ((chunk) => write(chunk));
+}
+function linkCncjs() {
+    cncjs.ensure().catch((e) => console.error(`[cncjs] ${e.message}`));
+}
+const [command = "start", ...rest] = process.argv.slice(2);
+switch (command) {
+    case "setup": {
+        console.log(`\n  ${PRODUCT.displayName} ${VERSION}`);
+        const link = readLink();
+        if (link?.cloudUrl === PRODUCT.cloudUrl)
+            console.log("  This PC is already linked.");
+        else
+            await pair(PRODUCT.cloudUrl);
+        stopRunning();
+        const how = enableAutostart(CLI_PATH);
+        console.log(`  Running now, and at every login (${how}).`);
+        console.log(`  Put G-code files in: ${JOBS_DIR}`);
+        console.log(`  Next: add the connector in Claude: ${PRODUCT.cloudUrl}\n`);
+        break;
+    }
+    case "start": {
+        if (rest.includes("--log"))
+            logToFile();
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(PID_FILE, String(process.pid));
+        if (await updateIfAvailable())
+            process.exit(0);
+        linkCncjs();
+        const cloudUrl = rest.find((a) => a.startsWith("http")) ?? PRODUCT.cloudUrl;
+        await runRelay(cloudUrl, await startHttp());
+        break;
+    }
+    case "status": {
+        const link = readLink();
+        console.log(`${PRODUCT.displayName} ${VERSION}`);
+        console.log(`  Linked:      ${link ? `yes, as "${link.name}" to ${link.cloudUrl}` : "no (run setup)"}`);
+        console.log(`  Jobs folder: ${JOBS_DIR}`);
+        console.log(`  Data:        ${STATE_DIR}`);
+        console.log(`  Log:         ${LOG_FILE}`);
+        break;
+    }
+    case "unlink": {
+        disableAutostart();
+        stopRunning();
+        fs.rmSync(DEVICE_FILE, { force: true });
+        console.log(`Unlinked this PC and stopped ${PRODUCT.displayName} starting at login.`);
+        break;
+    }
+    case "stdio": {
+        linkCncjs();
+        await createServer().connect(new StdioServerTransport());
+        break;
+    }
+    case "serve": {
+        linkCncjs();
+        const url = await startHttp();
+        console.log(`MCP endpoint: ${url.replace(/\/mcp\/.+$/, "/mcp/<token>")} (token in ${TOKEN_FILE})`);
+        break;
+    }
+    case "--version":
+    case "version":
+        console.log(VERSION);
+        break;
+    default:
+        console.log(`Usage: ${PRODUCT.name} [setup | start | status | unlink | stdio | serve | version]`);
+        process.exit(command === "help" || command === "--help" ? 0 : 1);
+}

package/dist/server/cncjs.js

@@ -0,0 +1,294 @@
+// 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";
+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";
+const MANAGED_CONFIG = path.join(STATE_DIR, "cncrc");
+const USER_CONFIG = process.env.CNCJS_CONFIG ?? path.join(os.homedir(), ".cncrc");
+/** 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. */
+const RETRY_MS = 15000;
+const MOVING_STATES = new Set(["Run", "Jog", "Home"]);
+class CNCjsLink {
+    socket = null;
+    child = null;
+    managed = false;
+    connected = false;
+    error = null;
+    starting = null;
+    lastFailure = 0;
+    port = null;
+    controller = null;
+    status = null;
+    parserState = null;
+    workflow = "idle";
+    sender = null;
+    alarm = null;
+    gcodeName = null;
+    telemetryAt = 0;
+    ports = [];
+    onLoadListeners = [];
+    onGcodeLoad(fn) {
+        this.onLoadListeners.push(fn);
+    }
+    /** Connects (starting a bundled CNCjs if needed). Safe to call repeatedly. */
+    ensure() {
+        if (this.connected)
+            return Promise.resolve();
+        if (!this.starting && Date.now() - this.lastFailure < RETRY_MS) {
+            return Promise.reject(new Error(this.error ?? "CNCjs not connected"));
+        }
+        this.starting ??= this.start().finally(() => {
+            this.starting = null;
+        });
+        return this.starting;
+    }
+    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));
+            this.error = null;
+        }
+        catch (e) {
+            this.error = e.message;
+            this.lastFailure = Date.now();
+            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.`);
+        }
+        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"],
+            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.managed = true;
+        process.once("exit", () => this.child?.kill());
+        for (const sig of ["SIGINT", "SIGTERM"]) {
+            process.once(sig, () => {
+                this.child?.kill();
+                process.exit(0);
+            });
+        }
+        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.");
+    }
+    connect(token) {
+        return new Promise((resolve, reject) => {
+            const socket = io(CNCJS_URL, { query: `token=${token}`, reconnection: true });
+            const timer = setTimeout(() => {
+                socket.close();
+                reject(new Error(`Timed out connecting to CNCjs at ${CNCJS_URL}`));
+            }, 10000);
+            socket.on("connect", () => {
+                clearTimeout(timer);
+                this.connected = true;
+                this.socket = socket;
+                resolve();
+            });
+            socket.on("error", (err) => {
+                clearTimeout(timer);
+                this.error = `CNCjs refused the connection: ${typeof err === "string" ? err : JSON.stringify(err)}`;
+                reject(new Error(this.error));
+            });
+            socket.on("disconnect", () => {
+                this.connected = false;
+            });
+            this.listen(socket);
+        });
+    }
+    listen(socket) {
+        socket.on("serialport:list", (ports) => {
+            this.ports = ports ?? [];
+        });
+        socket.on("serialport:open", (o) => {
+            this.port = o?.port ?? null;
+            this.controller = o?.controllerType ?? null;
+        });
+        socket.on("serialport:close", () => {
+            this.port = null;
+            this.controller = null;
+            this.status = null;
+            this.sender = null;
+            this.workflow = "idle";
+        });
+        socket.on("controller:state", (type, state) => {
+            this.controller = type;
+            this.status = state?.status ?? this.status;
+            this.parserState = state?.parserstate ?? this.parserState;
+            // CNCjs also emits its default (empty) state on open; only a parsed
+            // status report from the controller counts as telemetry.
+            if (state?.status?.activeState)
+                this.telemetryAt = Date.now();
+            if (this.status?.activeState !== "Alarm")
+                this.alarm = null;
+        });
+        socket.on("serialport:read", (data) => {
+            const m = /ALARM:(\d+)(.*)/.exec(data ?? "");
+            if (m)
+                this.alarm = `ALARM:${m[1]}${m[2]}`.trim();
+        });
+        socket.on("workflow:state", (s) => {
+            this.workflow = s;
+        });
+        socket.on("sender:status", (s) => {
+            this.sender = 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*$/, "");
+            for (const fn of this.onLoadListeners)
+                fn(name, program);
+        });
+        socket.on("gcode:unload", () => {
+            this.gcodeName = null;
+            this.sender = null;
+        });
+    }
+    snapshot() {
+        const age = Date.now() - this.telemetryAt;
+        // CNCjs emits controller:state only when the state changes, so a quiet
+        // stationary machine sends nothing. Silence means stale only while the
+        // machine is reported as moving; a lost serial port arrives as a close.
+        const moving = MOVING_STATES.has(this.status?.activeState);
+        const live = this.connected && this.port !== null && this.telemetryAt > 0 && (!moving || age < STALE_MS);
+        const link = !this.connected || !this.port ? "none" : live ? "live" : "stale";
+        const state = !this.connected
+            ? this.error ?? "CNCjs not connected"
+            : !this.port
+                ? "CNCjs connected, no machine port open"
+                : link === "stale"
+                    ? this.telemetryAt
+                        ? `No status for ${Math.round(age / 1000)} s`
+                        : "Waiting for first status report"
+                    : this.status?.activeState ?? "Unknown";
+        return {
+            link,
+            state,
+            cncjs: { url: CNCJS_URL, managed: this.managed, connected: this.connected, error: this.error },
+            port: this.port,
+            controller: this.controller,
+            activeState: this.status?.activeState ?? null,
+            workflow: this.workflow,
+            mpos: toVec(this.status?.mpos),
+            wpos: toVec(this.status?.wpos),
+            wcs: this.parserState?.modal?.wcs ?? null,
+            alarm: this.alarm,
+            sender: this.sender,
+            loadedFile: this.gcodeName,
+            telemetryAt: this.telemetryAt ? new Date(this.telemetryAt).toISOString() : null,
+        };
+    }
+    async listPorts() {
+        await this.ensure();
+        this.socket.emit("list");
+        await sleep(800);
+        return this.ports;
+    }
+    async openPort(port, baudrate, controllerType) {
+        await this.ensure();
+        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();
+            });
+        });
+    }
+    async closePort() {
+        await this.ensure();
+        const port = this.requirePort();
+        this.socket.emit("close", port);
+    }
+    /** Loads a program into CNCjs's sender. Does not start it. */
+    async load(name, gcode) {
+        await this.ensure();
+        const port = this.requirePort();
+        await new Promise((resolve, reject) => {
+            this.socket.emit("command", port, "gcode:load", name, gcode, {}, (err) => {
+                if (err)
+                    reject(new Error(`CNCjs rejected the program: ${err.message ?? JSON.stringify(err)}`));
+                else
+                    resolve();
+            });
+        });
+    }
+    async command(cmd, ...args) {
+        await this.ensure();
+        const port = this.requirePort();
+        this.socket.emit("command", port, cmd, ...args);
+    }
+    requirePort() {
+        if (!this.port)
+            throw new Error("No machine port is open in CNCjs.");
+        return this.port;
+    }
+}
+function accessToken(configFile) {
+    if (process.env.CNCJS_TOKEN)
+        return process.env.CNCJS_TOKEN;
+    let secret;
+    try {
+        secret = JSON.parse(fs.readFileSync(configFile, "utf-8")).secret;
+    }
+    catch {
+        throw new Error(`Could not read the CNCjs secret from ${configFile}. Set CNCJS_CONFIG or CNCJS_TOKEN.`);
+    }
+    if (!secret)
+        throw new Error(`${configFile} 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;
+    }
+}
+function toVec(v) {
+    if (!v)
+        return null;
+    return { x: Number(v.x), y: Number(v.y), z: Number(v.z) };
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export const cncjs = new CNCjsLink();