@netnodeag/kraftwerk 0.45.0 → 0.46.0

package/README.md

@@ -82,9 +82,15 @@ download per call:
 npx @netnodeag/kraftwerk --version
 ```
 
-Upgrading is the same command with `@latest`. A running inspector serves the
-version it started with, so restart each UI afterwards. It offers a relaunch
-by itself once a newer version is on disk.
+Upgrading is the same command with `@latest`, or "check for updates" in the
+inspector's info popover: a newer version gets an "update now" that runs the
+install through the server (`POST /api/update`, output in the popover,
+`GET /api/update` for its state) with the npm that belongs to the Node the
+inspector runs on. It is refused inside a container (rebuild the image) and
+when the global folder is not writable by the inspector's user (a system
+Node that needs sudo) — then the command is shown to run by hand. A running
+inspector serves the version it started with and offers a relaunch once a
+newer version is on disk, right after "update now" or after a manual install.
 
 ```bash
 npm install -g @netnodeag/kraftwerk@latest

package/dist/inspector/server.js

@@ -5,6 +5,7 @@ import { attachmentPath, saveAttachment } from "./chat/store.js";
 import { setOutputDir, setProjectRoot, getOutputDir, getProjectRoot } from "./context.js";
 import { resolveProject } from "../config.js";
 import { listRuns, getRun, readRunFile, deleteRun } from "./runs.js";
+import { canSelfUpdate, startUpdate, updateStatus } from "./update.js";
 import { listWorkflows, getWorkflow } from "./workflows.js";
 import { dockerStatus, triggerRun, stopRun } from "./runner.js";
 import { clearNotifications, listNotifications, markNotificationsRead } from "./notifications.js";
@@ -569,6 +570,32 @@ async function handleApi(req, res, url) {
             return json(res, { name, current, latest: "", error: "npm registry unreachable" }, 502);
         }
     }
+    // GET /api/update — state and log of the self-update, plus whether one can run here.
+    // POST /api/update {version?} — run `npm i -g <name>@<version>`; 409 when refused or already running.
+    if (seg.length === 2 && seg[1] === "update") {
+        const name = await getPkgName();
+        if (method === "GET") {
+            const can = canSelfUpdate(name);
+            return json(res, { ...updateStatus(), name, available: can.ok, reason: can.ok ? undefined : can.reason, restartable: supervised() });
+        }
+        if (method === "POST") {
+            let version = "latest";
+            try {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                if (typeof body.version === "string" && body.version)
+                    version = body.version;
+            }
+            catch {
+                return json(res, { error: "invalid body" }, 400);
+            }
+            try {
+                return json(res, { ...startUpdate(name, version), name }, 202);
+            }
+            catch (err) {
+                return json(res, { error: err.message }, 409);
+            }
+        }
+    }
     // POST /api/restart — exit with the respawn code; the `kraftwerk ui` supervisor relaunches
     if (seg.length === 2 && seg[1] === "restart" && method === "POST") {
         if (!supervised()) {

package/dist/inspector/update.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Self-update from the inspector: one `npm i -g <name>@<version>` at a time,
+ * run with the npm that belongs to the Node this server runs on, its output
+ * kept for the UI. The install lands on disk; the existing relaunch
+ * (/api/restart, supervised by `kraftwerk ui`) then switches to it.
+ *
+ * Refused where it cannot work: inside a container (the package is baked
+ * into the image — rebuild instead), or when the global folder is not
+ * writable by this process (a system Node that needs sudo).
+ * KRAFTWERK_NPM points at the npm to use (tests point it at a stub).
+ */
+export interface UpdateStatus {
+    state: "idle" | "running" | "done" | "failed";
+    /** The version asked for ("latest" or a number). */
+    version?: string;
+    log: string[];
+    startedAt?: string;
+    finishedAt?: string;
+    exitCode?: number | null;
+}
+/** The npm next to the running node (nvm layouts), else npm on the PATH. */
+export declare function npmCommand(): string;
+/** Where a global install would go, and whether this process may write there. */
+export declare function canSelfUpdate(name: string): {
+    ok: true;
+    root: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function updateStatus(): UpdateStatus;
+/** Start the install; throws when one is running or the environment refuses it. */
+export declare function startUpdate(name: string, version?: string): UpdateStatus;

package/dist/inspector/update.js

@@ -0,0 +1,73 @@
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync } from "node:fs";
+import path from "node:path";
+const MAX_LOG = 200;
+const IN_CONTAINER = existsSync("/.dockerenv") || existsSync("/run/.containerenv");
+let status = { state: "idle", log: [] };
+/** The npm next to the running node (nvm layouts), else npm on the PATH. */
+export function npmCommand() {
+    if (process.env.KRAFTWERK_NPM)
+        return process.env.KRAFTWERK_NPM;
+    const sibling = path.join(path.dirname(process.execPath), "npm");
+    return existsSync(sibling) ? sibling : "npm";
+}
+/** Where a global install would go, and whether this process may write there. */
+export function canSelfUpdate(name) {
+    if (IN_CONTAINER)
+        return { ok: false, reason: "running in a container — rebuild the image instead" };
+    const r = spawnSync(npmCommand(), ["root", "-g"], { encoding: "utf8", timeout: 15_000 });
+    const root = (r.stdout ?? "").trim();
+    if (r.status !== 0 || !root)
+        return { ok: false, reason: "could not find the global npm folder" };
+    // The package folder if it exists, else the global root it would be created in.
+    const target = existsSync(path.join(root, name)) ? path.join(root, name) : root;
+    try {
+        accessSync(target, constants.W_OK);
+    }
+    catch {
+        return { ok: false, reason: `${target} is not writable by this process — run the install with the rights it needs` };
+    }
+    return { ok: true, root };
+}
+export function updateStatus() {
+    return { ...status, log: [...status.log] };
+}
+/** Start the install; throws when one is running or the environment refuses it. */
+export function startUpdate(name, version = "latest") {
+    if (status.state === "running")
+        throw new Error("an update is already running");
+    if (!/^[A-Za-z0-9][A-Za-z0-9.\-]*$/.test(version))
+        throw new Error("invalid version");
+    const can = canSelfUpdate(name);
+    if (!can.ok)
+        throw new Error(can.reason);
+    const spec = `${name}@${version}`;
+    status = { state: "running", version, log: [`$ npm i -g ${spec}`], startedAt: new Date().toISOString() };
+    const push = (chunk) => {
+        for (const line of String(chunk).split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            status.log.push(line);
+            if (status.log.length > MAX_LOG)
+                status.log.splice(0, status.log.length - MAX_LOG);
+        }
+    };
+    let child;
+    try {
+        child = spawn(npmCommand(), ["i", "-g", spec], {
+            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        status = { ...status, state: "failed", finishedAt: new Date().toISOString(), exitCode: null, log: [...status.log, err.message] };
+        return updateStatus();
+    }
+    child.stdout?.on("data", push);
+    child.stderr?.on("data", push);
+    child.on("error", (err) => push(err.message));
+    child.on("close", (code) => {
+        status = { ...status, state: code === 0 ? "done" : "failed", finishedAt: new Date().toISOString(), exitCode: code };
+    });
+    return updateStatus();
+}