@engenty/wizards-runtime 0.0.0-stage → 0.7.5

package/apps/runtime/dist/cli/autoupdate.js

@@ -0,0 +1,221 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { readEnvFile, readInstallNote } from "./home.js";
+import { currentVersion, promote, prune, RUNTIME_PACKAGE, runtimeDir, switchTo, versionIn, } from "./versions.js";
+/**
+ * Updates that come by themselves, for an install made by install.sh (never `npx wizards` or a
+ * checkout). The runtime asks the npm registry for the newest runtime when it starts and once
+ * a day; npm installs a newer one, checking its integrity, beside the one that runs
+ * (versions.ts). Nothing switches then: runs cost credits and are never cut off. The next
+ * `wizards start` (a restart, the next login) makes it `current` before any runtime runs.
+ *
+ * Off with `wizards autoupdate off` or WIZARDS_DISABLE_AUTOUPDATE=1 (terminal or the install's
+ * .env); off by default in CI and for an install set up without a terminal.
+ */
+const LATEST_URL = `https://registry.npmjs.org/${RUNTIME_PACKAGE}/latest`;
+const HOUR = 60 * 60_000;
+/** How long the status and the studio keep saying what came with an update. */
+const NOTICE_MS = 14 * 24 * HOUR;
+export const notesUrl = (version) => `https://github.com/engenty/wizards/releases/tag/v${version}`;
+const stateFile = (paths) => join(paths.home, "update.json");
+export function readUpdateState(paths) {
+    try {
+        return JSON.parse(readFileSync(stateFile(paths), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeUpdateState(paths, state) {
+    mkdirSync(paths.home, { recursive: true });
+    const tmp = `${stateFile(paths)}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+    renameSync(tmp, stateFile(paths));
+}
+/** Whether `a` is a newer version than `b`; a `v` and a pre-release suffix are ignored. */
+export function isNewer(a, b) {
+    const parts = (v) => v.replace(/^v/, "").split("-")[0].split(".").map(Number);
+    const [x, y] = [parts(a), parts(b)];
+    for (let i = 0; i < Math.max(x.length, y.length); i++) {
+        if ((x[i] || 0) !== (y[i] || 0)) {
+            return (x[i] || 0) > (y[i] || 0);
+        }
+    }
+    return false;
+}
+// --- whether it is on ----------------------------------------------------------------------
+const truthy = (value) => value !== undefined && !["", "0", "false", "no", "off"].includes(value.trim().toLowerCase());
+/** A build machine. The runtime gets ENGENTY_WIZARDS_CI from the command, which sees CI. */
+export const isCI = (env) => truthy(env.CI) || truthy(env.ENGENTY_WIZARDS_CI);
+/**
+ * Whether this install updates itself. The variable switches it off whatever else says;
+ * `wizards autoupdate on|off` decides next; without either it is on, except in CI and for an
+ * install set up without a terminal.
+ */
+export function autoUpdatePolicy(paths, options) {
+    const env = options.env ?? process.env;
+    if (!options.installed) {
+        return { on: false, reason: "only an install made by install.sh updates itself" };
+    }
+    if (truthy(env.WIZARDS_DISABLE_AUTOUPDATE ?? readEnvFile(paths.envFile).WIZARDS_DISABLE_AUTOUPDATE)) {
+        return { on: false, reason: "WIZARDS_DISABLE_AUTOUPDATE is set" };
+    }
+    const { autoUpdate, unattended } = options.note ?? readInstallNote(paths);
+    if (autoUpdate !== undefined) {
+        return { on: autoUpdate, reason: autoUpdate ? "turned on" : "turned off" };
+    }
+    if (isCI(env)) {
+        return { on: false, reason: "off in CI" };
+    }
+    if (unattended) {
+        return { on: false, reason: "off: set up without a terminal" };
+    }
+    return { on: true, reason: "on" };
+}
+export const systemDeps = {
+    fetch: (...args) => fetch(...args),
+    npmInstall,
+    now: () => new Date(),
+};
+/** The version npm's `latest` tag names; null when it names none. */
+async function latestVersion(deps, env) {
+    const response = await deps.fetch(env.ENGENTY_WIZARDS_REGISTRY_URL?.trim() || LATEST_URL, {
+        headers: { accept: "application/json" },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`The npm registry answered ${response.status} for the newest version.`);
+    }
+    const { version } = (await response.json());
+    return typeof version === "string" && /^\d+\.\d+\.\d+$/.test(version) ? version : null;
+}
+/** npm of the install's own Node, as install.sh runs it; its output goes to logs/update.log. */
+async function npmInstall(paths, prefix, spec) {
+    const bin = join(paths.tools, "node", "bin");
+    mkdirSync(paths.logs, { recursive: true });
+    const log = openSync(join(paths.logs, "update.log"), "a");
+    const args = "install --omit=dev --ignore-scripts --legacy-peer-deps --no-audit --no-fund --loglevel=error";
+    const code = await new Promise((done) => {
+        const child = spawn(join(bin, "npm"), [...args.split(" "), "--prefix", prefix, spec], {
+            stdio: ["ignore", log, log],
+            env: { ...process.env, PATH: `${bin}:${process.env.PATH ?? ""}` },
+        });
+        child.on("error", () => done(127));
+        child.on("exit", (exit) => done(exit ?? 1));
+    });
+    if (code !== 0) {
+        throw new Error(`npm install of the new version failed (exit ${code}); see logs/update.log.`);
+    }
+}
+/**
+ * Asks npm for the newest version and, when it is newer than the current one, installs it into
+ * its version folder (npm checks the package against the registry's integrity hash). It switches nothing. `force` asks even
+ * within the hour since the last time.
+ */
+export async function checkForUpdate(paths, options, deps = systemDeps) {
+    if (!options.policy.on) {
+        return { kind: "off", reason: options.policy.reason };
+    }
+    const state = readUpdateState(paths);
+    const now = deps.now();
+    const current = currentVersion(paths);
+    if (!current) {
+        return { kind: "skipped", reason: "no runtime installed" };
+    }
+    if (!options.force && now.getTime() - Date.parse(state.checkedAt ?? "0") < HOUR) {
+        return { kind: "skipped", reason: "asked within the hour" };
+    }
+    state.checkedAt = now.toISOString();
+    delete state.error;
+    const tmp = mkdtempSync(join(paths.home, "update-"));
+    try {
+        const version = await latestVersion(deps, options.env ?? process.env);
+        if (!version || !isNewer(version, current)) {
+            return { kind: "current", version: current };
+        }
+        if (state.pending?.version !== version || !versionIn(runtimeDir(paths, version))) {
+            await deps.npmInstall(paths, tmp, `${RUNTIME_PACKAGE}@${version}`);
+            promote(paths, tmp, version);
+            state.pending = { version, notes: notesUrl(version) };
+            prune(paths, keepOf(state));
+        }
+        return { kind: "downloaded", version };
+    }
+    catch (error) {
+        state.error = error.message;
+        return { kind: "failed", reason: state.error };
+    }
+    finally {
+        writeUpdateState(paths, state);
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}
+/** The versions kept besides the current one: the one waiting and the one before. */
+const keepOf = (state) => [state.pending?.version, state.updated?.from].filter((v) => Boolean(v));
+// --- switching -------------------------------------------------------------------------------
+/**
+ * Makes a downloaded version `current`. Only called where no runtime runs (`wizards start`
+ * before it starts one), so no run is cut off; a version that is no longer newer is dropped.
+ */
+export function applyPendingUpdate(paths, now = new Date()) {
+    const state = readUpdateState(paths);
+    const { pending } = state;
+    const from = currentVersion(paths);
+    if (!pending || !from) {
+        return null;
+    }
+    delete state.pending;
+    try {
+        if (!isNewer(pending.version, from)) {
+            return null;
+        }
+        switchTo(paths, pending.version);
+        state.updated = { from, to: pending.version, at: now.toISOString(), notes: pending.notes };
+        prune(paths, [from]);
+        return { from, to: pending.version };
+    }
+    catch (error) {
+        state.error = error.message;
+        return null;
+    }
+    finally {
+        writeUpdateState(paths, state);
+    }
+}
+/** Notes a switch somebody made by hand (`wizards update`), so the notice says it too. */
+export function noteUpdated(paths, from, to, now = new Date()) {
+    if (from !== to) {
+        const state = readUpdateState(paths);
+        delete state.pending;
+        state.updated = { from, to, at: now.toISOString(), notes: notesUrl(to) };
+        writeUpdateState(paths, state);
+    }
+}
+/** What the status and the studio say: a fresh update, or one waiting for the next start. */
+export function updateNotice(paths, running, now = new Date()) {
+    const { updated, pending } = readUpdateState(paths);
+    return {
+        updated: updated?.to === running && now.getTime() - Date.parse(updated.at) < NOTICE_MS
+            ? updated
+            : null,
+        pending: pending && isNewer(pending.version, running) ? pending : null,
+    };
+}
+/** The runtime's part: a check soon after it starts, then once a day. */
+export function scheduleUpdateChecks(paths, policy, deps = systemDeps) {
+    if (!policy().on) {
+        return;
+    }
+    const check = async (force) => {
+        const result = await checkForUpdate(paths, { policy: policy(), force }, deps);
+        if (result.kind === "downloaded") {
+            console.log(`[update] ${result.version} is ready; it runs from the next start.`);
+        }
+        else if (result.kind === "failed") {
+            console.error(`[update] ${result.reason}`);
+        }
+    };
+    setTimeout(() => void check(false), 30_000).unref();
+    setInterval(() => void check(true), 24 * HOUR).unref();
+}

package/apps/runtime/dist/cli/clients.js

@@ -0,0 +1,44 @@
+import { mkdirSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { runtimePath } from "./environment.js";
+import { runLogged } from "./exec.js";
+import { findOnPath } from "./machine.js";
+/** A word for the shell: quoted when it holds anything but plain characters. */
+const shellWord = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
+/** The command the setup runs for a client, as the person would type it. */
+export function installCommand(client, paths) {
+    return client.install.kind === "npm"
+        ? `npm install --global --prefix ${shellWord(paths.clients)} ${client.install.pkg}`
+        : `curl -fsSL ${client.install.url} | bash`;
+}
+/**
+ * Installs an AI client. One that comes from npm goes into the install's own prefix
+ * (`clients/`), with the npm of the Node that runs this command: nothing of the person's own
+ * Node, if they have one, is touched. The others bring their own installer.
+ */
+export function installClient(client, paths, onLine) {
+    const logFile = join(paths.logs, "install.log");
+    const env = { ...process.env, PATH: runtimePath(paths, process.env) };
+    if (client.install.kind === "script") {
+        return runLogged("bash", ["-c", `set -o pipefail; curl -fsSL ${client.install.url} | bash`], {
+            env,
+            logFile,
+            onLine,
+        });
+    }
+    const npm = findOnPath("npm", [dirname(process.execPath), process.env.PATH ?? ""].join(delimiter));
+    if (!npm) {
+        return Promise.resolve({ code: 127, tail: "npm wasn’t found next to this Node.js." });
+    }
+    mkdirSync(paths.clients, { recursive: true });
+    return runLogged(npm, [
+        "install",
+        "--global",
+        "--prefix",
+        paths.clients,
+        "--no-audit",
+        "--no-fund",
+        "--loglevel=error",
+        client.install.pkg,
+    ], { env, logFile, onLine });
+}