@engenty/wizards-runtime 0.0.0-stage → 0.7.6

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

@@ -0,0 +1,212 @@
+import { accessSync, constants, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { accountState, describeAccount } from "./account.js";
+import { autostartForStatus, autostartState, setAutostart } from "./autostart.js";
+import { autoUpdatePolicy, updateNotice } from "./autoupdate.js";
+import { installedByScript, isCheckout, packageRoot, packageVersion } from "./home.js";
+import { detectClients, findChrome, findFfmpeg, nodeIsCurrent } from "./machine.js";
+import { findWizardsProcesses, stopProcesses } from "./processes.js";
+import { installedEngines } from "./sandbox.js";
+import { entryUrl, runningRuntime, settings, startInBackground } from "./start.js";
+import { bad, badge, cmd, cyan, dim, no, ok, tilde } from "./ui.js";
+/**
+ * What is installed and what runs. With `checks` (`doctor`) it also says what is wrong and
+ * returns 1 when something is.
+ */
+export async function status(paths, checks) {
+    const { dataDir } = settings(paths);
+    const [running, clients, ffmpeg, atLogin, account] = await Promise.all([
+        runningRuntime(dataDir),
+        detectClients(paths),
+        findFfmpeg(),
+        autostartForStatus(paths),
+        accountState(),
+    ]);
+    const chrome = findChrome();
+    const row = (label, value) => console.log(`  ${label.padEnd(9)} ${value}`);
+    console.log(`\n${badge("engenty wizards")} ${dim(packageVersion())}\n`);
+    row("Install", installedByScript()
+        ? tilde(paths.home)
+        : `${tilde(packageRoot)} ${dim(isCheckout() ? "(a checkout)" : "(npm)")}`);
+    row("Data", tilde(dataDir));
+    row("Node", `${process.version} ${dim(tilde(process.execPath))}`);
+    row("Running", running
+        ? `${ok} ${cyan(running.url)} ${dim(`pid ${running.pid}, since ${new Date(running.startedAt).toLocaleString()}`)}`
+        : `${no} not running`);
+    if (!("unavailable" in atLogin)) {
+        row("At login", atLogin.on ? `${ok} starts ${dim(`(${atLogin.how})`)}` : `${no} doesn’t start`);
+    }
+    if (installedByScript(paths)) {
+        const policy = autoUpdatePolicy(paths, { installed: true });
+        row("Updates", policy.on ? `${ok} automatic` : `${no} ${policy.reason} ${dim(`(${cmd("autoupdate on")})`)}`);
+    }
+    row("Account", `${account.kind === "linked" ? ok : no} ${describeAccount(account)}`);
+    for (const { client, path, version } of clients) {
+        row(client.name.split(" ")[0], path ? `${ok} ${version} ${dim(tilde(path))}` : `${no} not installed`);
+    }
+    row("Browser", chrome ? `${ok} ${dim(tilde(chrome))}` : `${no} not found (needed for PDF and PNG)`);
+    row("ffmpeg", ffmpeg.path ? `${ok} ${ffmpeg.version ?? ""}` : `${no} not found (needed for MP4)`);
+    const engines = installedEngines(paths);
+    row("Sandbox", engines.length
+        ? engines
+            .map(({ label, version, current }) => version === current
+            ? `${ok} ${label} ${version}`
+            : `${no} ${label} ${version} is outdated (${cmd("sandbox add")} installs ${current})`)
+            .join(", ")
+        : `${no} not installed (${cmd("sandbox add")} lets AI steps run code)`);
+    const { updated, pending } = updateNotice(paths, packageVersion());
+    if (updated) {
+        console.log(`\n  ${ok} Updated to ${updated.to}. What changed: ${cyan(updated.notes)}`);
+    }
+    else if (pending) {
+        console.log(`\n  ${ok} Version ${pending.version} is downloaded; it runs from the next start.`);
+    }
+    console.log("");
+    if (!checks) {
+        return 0;
+    }
+    const problems = [];
+    if (!nodeIsCurrent()) {
+        problems.push(`Node ${process.version} is too old. engenty wizards needs 24.11 or newer.`);
+    }
+    for (const part of ["apps/runtime/dist/index.js", "apps/web/dist/index.html", "plugin"]) {
+        if (!existsSync(join(packageRoot, part))) {
+            problems.push(`${part} is missing from this install (${tilde(packageRoot)}).`);
+        }
+    }
+    try {
+        mkdirSync(paths.home, { recursive: true });
+        accessSync(paths.home, constants.W_OK);
+    }
+    catch {
+        problems.push(`${tilde(paths.home)} can’t be written to.`);
+    }
+    if (!clients.some((state) => state.path)) {
+        console.log(`  ${no} No AI client. The studio needs an API key, Ollama or Apple Intelligence (Mac only) instead. ${dim(`To install one: ${cmd("setup")}`)}`);
+    }
+    for (const problem of problems) {
+        console.log(`  ${bad} ${problem}`);
+    }
+    if (!problems.length) {
+        console.log(`  ${ok} No problems found.`);
+    }
+    console.log("");
+    return problems.length ? 1 : 0;
+}
+/** Waits for a process to end; false when it still runs after `ms`. */
+async function ended(pid, ms) {
+    for (let waited = 0; waited < ms; waited += 100) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return true;
+        }
+        await new Promise((wait) => setTimeout(wait, 100));
+    }
+    return false;
+}
+/**
+ * Stops engenty wizards: the runtime that runs on this install's data folder, and every other
+ * runtime or `start` of this install still about (an older `start --no-open` whose note another
+ * one overwrote). `wizards mcp` processes belong to the AI apps and stay.
+ */
+export async function stop(paths) {
+    const { dataDir } = settings(paths);
+    const running = await runningRuntime(dataDir);
+    const found = findWizardsProcesses(paths.home);
+    const pids = [
+        ...new Set([
+            ...(running ? [running.pid] : []),
+            ...found.filter((p) => p.kind === "runtime" || p.kind === "start").map((p) => p.pid),
+        ]),
+    ];
+    if (!pids.length) {
+        console.log("engenty wizards isn’t running.");
+        return 0;
+    }
+    const left = await stopProcesses(pids);
+    const stopped = pids.length - left.length;
+    if (stopped) {
+        console.log(pids.length === 1
+            ? `Stopped (pid ${pids[0]}). Your data is kept.`
+            : `Stopped ${stopped} processes (pid ${pids.filter((pid) => !left.includes(pid)).join(", ")}). Your data is kept.`);
+    }
+    const apps = found.filter((p) => p.kind === "mcp").length;
+    if (apps && !left.length) {
+        console.log(dim(`${apps === 1 ? "An AI app connection still runs" : `${apps} AI app connections still run`}. Using a wizard there starts engenty wizards again.`));
+    }
+    if (left.length) {
+        console.error(`${left.length === 1 ? "A process" : `${left.length} processes`} of engenty wizards didn’t stop (pid ${left.join(", ")}). To stop ${left.length === 1 ? "it" : "them"}: ${cyan(`kill -9 ${left.join(" ")}`)}`);
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Stops the runtime and starts it again, the version on disk now. One the command started (a
+ * terminal, the login item) is started again by that command, where it ran; any other is
+ * stopped and started in the background. When nothing runs, it is started in the background.
+ */
+export async function restart(paths) {
+    const { dataDir } = settings(paths);
+    const running = await runningRuntime(dataDir);
+    if (running?.restarts && process.platform !== "win32") {
+        process.kill(running.pid, "SIGUSR2");
+        for (let waited = 0; waited < 60_000; waited += 300) {
+            await new Promise((wait) => setTimeout(wait, 300));
+            const again = await runningRuntime(dataDir);
+            if (again && again.pid !== running.pid) {
+                console.log(`${ok} Restarted: ${cyan(again.url)} ${dim(`pid ${again.pid}`)}`);
+                return 0;
+            }
+        }
+        console.error("engenty wizards didn’t restart within a minute.");
+        return 1;
+    }
+    if (running) {
+        process.kill(running.pid, "SIGTERM");
+        if (!(await ended(running.pid, 8000))) {
+            console.error(`engenty wizards (pid ${running.pid}) didn’t stop within 8 seconds.`);
+            return 1;
+        }
+    }
+    const started = await startInBackground(paths);
+    if (!started) {
+        console.error(`engenty wizards didn’t start. Its log is in ${tilde(join(paths.logs, "runtime.log"))}.`);
+        return 1;
+    }
+    console.log(`${ok} ${running ? "Restarted" : "Started"}: ${cyan(started.url)} ${dim(`pid ${started.pid}, in the background`)}`);
+    if (!running) {
+        console.log(`  Open the studio: ${cyan(entryUrl(started, paths))}`);
+    }
+    return 0;
+}
+/** `autostart [on|off]`: whether it starts at login, and the switch. */
+export async function autostart(paths, value) {
+    if (value && value !== "on" && value !== "off") {
+        console.error(`Use ${cmd("autostart on")} or ${cmd("autostart off")}.`);
+        return 2;
+    }
+    let state;
+    try {
+        state = await autostartState(paths);
+        if (value && !("unavailable" in state)) {
+            state = await setAutostart(paths, value === "on");
+        }
+    }
+    catch (error) {
+        console.error(`Couldn’t ${value ? `turn start at login ${value}` : "check start at login"}: ${error.message}`);
+        return 1;
+    }
+    if ("unavailable" in state) {
+        console.error(`Start at login isn’t available here: ${state.unavailable}.`);
+        return value ? 1 : 0;
+    }
+    console.log(state.on
+        ? `${ok} engenty wizards starts at login: ${state.how}.`
+        : `${no} engenty wizards doesn’t start at login. ${dim(`To turn it on: ${cmd("autostart on")}`)}`);
+    if (state.on && process.platform === "linux") {
+        console.log(dim(`  To start it even before anyone logs in: ${cyan("loginctl enable-linger")}`));
+    }
+    return value && state.on !== (value === "on") ? 1 : 0;
+}

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

@@ -0,0 +1,59 @@
+import { homedir } from "node:os";
+import { emitKeypressEvents } from "node:readline";
+import { styleText } from "node:util";
+import * as p from "@clack/prompts";
+import { command } from "./home.js";
+const colours = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+/** The name on engenty's orange. */
+export const badge = (text) => colours ? `\x1b[48;2;224;83;27m\x1b[97m\x1b[1m ${text} \x1b[0m` : text;
+export const dim = (text) => styleText("dim", text);
+export const bold = (text) => styleText("bold", text);
+export const cyan = (text) => styleText("cyan", text);
+export const ok = styleText("green", "✓");
+export const no = styleText("yellow", "–");
+export const bad = styleText("red", "✗");
+export const live = styleText("green", "●");
+/** A path as the person would write it. */
+export const tilde = (path) => path.startsWith(homedir()) ? `~${path.slice(homedir().length)}` : path;
+/** A command as the person types it, with this install's prefix: `cmd("stop")` → wizards stop. */
+export const cmd = (args = "") => cyan(args ? `${command()} ${args}` : command());
+/**
+ * A spinner on a terminal; where nobody watches, only what came of it. The message ends in "…"
+ * ("Checking status…"); clack animates its own dots in its place.
+ */
+export function busy(message) {
+    if (!process.stdout.isTTY) {
+        return { stop: (text) => p.log.step(text), fail: (text) => p.log.warn(text) };
+    }
+    exitOnCtrlC();
+    const spinner = p.spinner();
+    spinner.start(message.replace(/…$/, ""));
+    return {
+        stop: (text) => spinner.stop(text),
+        fail: (text) => spinner.error(text),
+    };
+}
+let watching = false;
+/**
+ * Ctrl-C under a spinner: clack ends the process itself, with code 0, as if all went well. The
+ * key is noted before clack sees it (this listener comes first), and the process ends with 130
+ * instead, as a command stopped by Ctrl-C does: `wizards setup && …` goes no further.
+ */
+function exitOnCtrlC() {
+    if (watching || !process.stdin.isTTY) {
+        return;
+    }
+    watching = true;
+    let pressed = false;
+    emitKeypressEvents(process.stdin);
+    process.stdin.on("keypress", (_text, key) => {
+        if (key?.ctrl && key.name === "c") {
+            pressed = true;
+        }
+    });
+    process.on("exit", () => {
+        if (pressed) {
+            process.exitCode = 130;
+        }
+    });
+}

package/apps/runtime/dist/cli/uninstall-main.js

@@ -0,0 +1,20 @@
+import { layout } from "./home.js";
+import { nodeIsCurrent } from "./machine.js";
+import { parseUninstall, uninstall } from "./uninstall.js";
+/**
+ * `wizards uninstall` on its own: bin/wizards.mjs starts it instead of main.ts, whose modules make
+ * the install folder, its data folder and a secret when they load (install-env.ts, env.ts,
+ * db/client.ts). An uninstall must find the computer as it is, and leave nothing behind.
+ */
+if (!nodeIsCurrent()) {
+    console.error(`engenty wizards needs Node.js 24.11 or newer. This is ${process.version}.`);
+    process.exit(1);
+}
+const options = parseUninstall(process.argv.slice(2));
+if (typeof options === "string") {
+    console.error(options);
+    process.exitCode = 2;
+}
+else {
+    process.exitCode = await uninstall(layout(), options);
+}

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

@@ -0,0 +1,231 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, readlinkSync, rmdirSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import * as p from "@clack/prompts";
+import { LOGIN_LABEL, present, removeUnit, UNIT, unloadLoginItem } from "./autostart.js";
+import { apps as allApps } from "./connect.js";
+import { findWizardsProcesses, stopProcesses } from "./processes.js";
+import { settings } from "./start.js";
+import { bad, cyan, dim, no, ok } from "./ui.js";
+export const realSystem = () => ({
+    userHome: homedir(),
+    platform: process.platform,
+    env: process.env,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    apps: allApps,
+    processes: findWizardsProcesses,
+    stop: (pids) => stopProcesses(pids),
+    unloadLoginItem,
+    removeUnit,
+});
+/** Parts of the install folder that are the person's: kept or deleted with the data. */
+const WITH_DATA = [".env", ".env.local", "plugins"];
+function loginItemPath(system) {
+    if (system.platform === "darwin") {
+        return join(system.userHome, "Library", "LaunchAgents", `${LOGIN_LABEL}.plist`);
+    }
+    if (system.platform === "linux") {
+        const config = system.env.XDG_CONFIG_HOME || join(system.userHome, ".config");
+        return join(config, "systemd", "user", UNIT);
+    }
+    return null;
+}
+/** The links install.sh put into ~/.local/bin that point into the install. */
+function ourLinks(home, system) {
+    return ["wizards", "engenty-wizards"]
+        .map((name) => join(system.userHome, ".local", "bin", name))
+        .filter((link) => {
+        try {
+            return (lstatSync(link).isSymbolicLink() &&
+                resolve(dirname(link), readlinkSync(link)).startsWith(home + sep));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Works out what an uninstall takes away, without changing anything. */
+export async function makePlan(paths, system) {
+    const apps = [];
+    for (const app of system.apps(paths)) {
+        if (await app.connected().catch(() => false)) {
+            apps.push(app);
+        }
+    }
+    const item = loginItemPath(system);
+    let loginItem = null;
+    try {
+        loginItem = item && present(item) ? item : null;
+    }
+    catch {
+        // Can't look: count it as there, so the uninstall tries and says so.
+        loginItem = item;
+    }
+    const { dataDir } = settings(paths, system.env);
+    const program = [];
+    const data = existsSync(dataDir) ? [dataDir] : [];
+    for (const name of existsSync(paths.home) ? readdirSync(paths.home) : []) {
+        const path = join(paths.home, name);
+        if (path === dataDir) {
+            continue;
+        }
+        const empty = name === "plugins" && readdirSync(path).length === 0;
+        (WITH_DATA.includes(name) && !empty ? data : program).push(path);
+    }
+    return {
+        home: paths.home,
+        apps,
+        loginItem,
+        processes: system.processes(paths.home),
+        program,
+        links: ourLinks(paths.home, system),
+        data,
+    };
+}
+/** Size of a folder as `du` counts it, e.g. " (805 MB)"; "" where it can't tell. */
+function size(path) {
+    const kb = Number(spawnSync("du", ["-sk", path], { encoding: "utf8" }).stdout?.split(/\s/)[0]);
+    return kb > 0 ? ` (${kb < 1024 ? `${kb} KB` : `${Math.round(kb / 1024)} MB`})` : "";
+}
+const processes = (n) => `${n} running process${n === 1 ? "" : "es"}`;
+/** `wizards uninstall [--dry-run] [--yes] [--delete-data]`. */
+export async function uninstall(paths, options, system = realSystem()) {
+    const t = (path) => path.startsWith(system.userHome + sep) ? `~${path.slice(system.userHome.length)}` : path;
+    if (!options.dryRun && !options.yes && !system.interactive) {
+        console.error("The uninstall asks before it deletes anything, and there is no terminal to ask in.\n" +
+            "Run it with --yes (your data is kept), --yes --delete-data, or --dry-run to only look.");
+        return 2;
+    }
+    const plan = await makePlan(paths, system);
+    const steps = [
+        ...plan.apps.map((app) => `Disconnect ${app.name}`),
+        ...(plan.loginItem ? [`Remove the login item ${t(plan.loginItem)}`] : []),
+        ...(plan.processes.length ? [`Stop ${processes(plan.processes.length)}`] : []),
+        ...(plan.program.length ? [`Delete the program in ${t(plan.home)}${size(plan.home)}`] : []),
+        ...plan.links.map((link) => `Delete the command ${t(link)}`),
+    ];
+    if (!steps.length && !plan.data.length) {
+        console.log(`${ok} engenty wizards isn’t installed here.`);
+        return 0;
+    }
+    if (steps.length) {
+        console.log("\nThis removes engenty wizards:");
+    }
+    for (const step of steps) {
+        console.log(`  ${no} ${step}`);
+    }
+    if (plan.data.length) {
+        console.log(`\nYour data: ${plan.data.map((path) => t(path) + size(path)).join(", ")}`);
+        console.log(dim("  Kept unless you choose to delete it. A reinstall picks it up again."));
+    }
+    console.log("");
+    if (options.dryRun) {
+        console.log(dim("Nothing was changed (--dry-run)."));
+        return 0;
+    }
+    let deleteData = options.yes && options.deleteData;
+    if (!options.yes) {
+        if (plan.data.length) {
+            const answer = await p.confirm({
+                message: "Delete your data too? Your wizards, runs and results are gone for good.",
+                initialValue: false,
+            });
+            if (p.isCancel(answer)) {
+                return 130;
+            }
+            deleteData = answer;
+        }
+        const go = await p.confirm({
+            message: deleteData ? "Uninstall and delete your data now?" : "Uninstall now?",
+        });
+        if (p.isCancel(go) || !go) {
+            p.cancel("Nothing was changed.");
+            return 130;
+        }
+    }
+    const failed = (what, error) => console.log(`${bad} ${what}: ${error.message.split("\n")[0]}`);
+    for (const app of plan.apps) {
+        const result = await app
+            .disconnect()
+            .catch((error) => ({ ok: false, message: error.message }));
+        console.log(result.ok ? `${ok} Disconnected ${app.name}` : `${bad} ${app.name}: ${result.message}`);
+    }
+    if (plan.loginItem) {
+        try {
+            if (system.platform === "darwin") {
+                await system.unloadLoginItem();
+                rmSync(plan.loginItem, { force: true });
+            }
+            else {
+                await system.removeUnit(plan.loginItem);
+            }
+            console.log(`${ok} Removed the login item`);
+        }
+        catch (error) {
+            failed("The login item", error);
+        }
+    }
+    // Twice: an AI app's `wizards mcp` may start the studio again meanwhile.
+    for (let round = 0; round < 2; round++) {
+        const running = system.processes(paths.home);
+        if (running.length && !(await system.stop(running.map((proc) => proc.pid))).length) {
+            console.log(`${ok} Stopped ${processes(running.length)}`);
+        }
+    }
+    for (const path of [...plan.program, ...plan.links, ...(deleteData ? plan.data : [])]) {
+        try {
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch (error) {
+            failed(`Couldn’t delete ${t(path)}`, error);
+        }
+    }
+    for (const dir of [plan.home, join(system.userHome, ".engenty")]) {
+        try {
+            rmdirSync(dir);
+        }
+        catch {
+            // not empty, or not there
+        }
+    }
+    // A second look: what is still there.
+    const after = await makePlan(paths, system);
+    const left = [
+        ...after.apps.map((app) => `${app.name} still lists the wizards: ${cyan(`npx wizards disconnect ${app.id}`)}`),
+        ...(after.loginItem ? [t(after.loginItem)] : []),
+        ...after.processes.map((proc) => `process ${proc.pid}: ${cyan(`kill -9 ${proc.pid}`)}`),
+        ...[...after.program, ...after.links, ...(deleteData ? after.data : [])].map(t),
+    ];
+    if (!deleteData && after.data.length) {
+        console.log(`${ok} Kept your data: ${after.data.map(t).join(", ")}`);
+    }
+    if (left.length) {
+        console.log(`\n${bad} Still there:`);
+        for (const line of left) {
+            console.log(`  ${line}`);
+        }
+        return 1;
+    }
+    console.log(`\n${ok} engenty wizards is uninstalled.\n`);
+    return 0;
+}
+/** The options of `uninstall` from its command line; a message when something is off. */
+export function parseUninstall(argv) {
+    const options = { dryRun: false, yes: false, deleteData: false };
+    for (const arg of argv) {
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+        }
+        else if (arg === "--yes" || arg === "-y") {
+            options.yes = true;
+        }
+        else if (arg === "--delete-data") {
+            options.deleteData = true;
+        }
+        else if (arg !== "uninstall") {
+            return `Unknown option ${arg}. The uninstall takes --dry-run, --yes and --delete-data.`;
+        }
+    }
+    return options;
+}

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

@@ -0,0 +1,86 @@
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { autoUpdatePolicy, noteUpdated } from "./autoupdate.js";
+import { installedByScript, isCheckout, readInstallNote, writeInstallNote, } from "./home.js";
+import { runningRuntime, settings } from "./start.js";
+import { restart } from "./status.js";
+import { cmd, cyan, no, ok } from "./ui.js";
+import { currentVersion } from "./versions.js";
+/** The installer this install was made with; it also updates one. */
+const INSTALLER = "https://engenty.ai/install.sh";
+async function installer(into) {
+    const source = process.env.ENGENTY_WIZARDS_INSTALLER?.trim() || INSTALLER;
+    if (!/^https?:\/\//.test(source)) {
+        return source;
+    }
+    const response = await fetch(source);
+    const text = response.ok ? await response.text() : "";
+    // The address answers with the studio's page while a server has no installer yet.
+    if (!text.startsWith("#!")) {
+        throw new Error(`${source} didn’t return the installer.`);
+    }
+    const file = join(into, "install.sh");
+    writeFileSync(file, text, { mode: 0o700 });
+    return file;
+}
+/**
+ * Brings an install made by install.sh to the newest version by running the installer again
+ * without its questions: Node, the runtime and the command. With `restart`, a runtime that runs
+ * restarts into the new version; otherwise it says how.
+ */
+export async function update(paths, options = {}) {
+    if (!installedByScript(paths)) {
+        console.log(isCheckout()
+            ? `This is a source checkout. To update: ${cyan("git pull && pnpm install && pnpm build")}`
+            : `This copy runs from npm. To update: ${cyan("npx wizards@latest")}`);
+        return 0;
+    }
+    const before = currentVersion(paths);
+    const tmp = mkdtempSync(join(paths.home, "update-"));
+    try {
+        const script = await installer(tmp);
+        const code = await new Promise((done) => {
+            const child = spawn("bash", [script, "--no-setup"], { stdio: "inherit" });
+            child.on("error", () => done(127));
+            child.on("exit", (exit) => done(exit ?? 1));
+        });
+        if (code !== 0) {
+            return code;
+        }
+    }
+    catch (error) {
+        console.error(error.message);
+        return 1;
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+    const after = currentVersion(paths);
+    if (before && after) {
+        noteUpdated(paths, before, after);
+    }
+    if (await runningRuntime(settings(paths).dataDir)) {
+        if (options.restart) {
+            return restart(paths);
+        }
+        console.log(`  Installed. Restart engenty wizards to use the new version: ${cmd("restart")}`);
+    }
+    return 0;
+}
+/** `wizards autoupdate [on|off]`: whether updates come by themselves (autoupdate.ts). */
+export function autoUpdateCommand(paths, value) {
+    if (value && value !== "on" && value !== "off") {
+        console.error(`Use ${cmd("autoupdate on")} or ${cmd("autoupdate off")}.`);
+        return 2;
+    }
+    const installed = installedByScript(paths);
+    if (value && installed) {
+        writeInstallNote({ ...readInstallNote(paths), autoUpdate: value === "on" }, paths);
+    }
+    const policy = autoUpdatePolicy(paths, { installed });
+    console.log(policy.on
+        ? `${ok} Updates come by themselves: downloaded in the background, used from the next start.`
+        : `${no} Updates don’t come by themselves: ${policy.reason}. To update now: ${cmd("update")}`);
+    return value && !installed ? 1 : 0;
+}

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

@@ -0,0 +1,75 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { parseWizard } from "@engenty-wizards/shared/definition";
+import { PACKAGE_FILES, PACKAGE_MANIFEST } from "@engenty-wizards/shared/wizard-package";
+import { json, readManifest, readPackage } from "../services/package-file.js";
+import { bad, dim, ok } from "./ui.js";
+function workspace(folder) {
+    const root = join(folder, PACKAGE_FILES);
+    try {
+        return readdirSync(root, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name !== ".DS_Store")
+            .map((entry) => relative(root, join(entry.parentPath, entry.name)).split("\\").join("/"));
+    }
+    catch {
+        return [];
+    }
+}
+/** The definition and the workspace's paths, read the way the import reads them. */
+function read(path) {
+    const folder = statSync(path).isDirectory()
+        ? path
+        : basename(path) === PACKAGE_MANIFEST
+            ? dirname(path)
+            : null;
+    if (folder) {
+        const manifest = readManifest(json(readFileSync(join(folder, PACKAGE_MANIFEST))));
+        return { definition: manifest.definition, files: workspace(folder) };
+    }
+    const { manifest, files } = readPackage(readFileSync(path));
+    return { definition: manifest.definition, files: files.map((f) => f.path) };
+}
+export function validatePath(path) {
+    let given;
+    try {
+        given = read(path);
+    }
+    catch (err) {
+        const message = err.code === "ENOENT"
+            ? "No such file or folder."
+            : err.message;
+        return { path, ok: false, issues: [{ message }] };
+    }
+    const parsed = parseWizard(given.definition, given.files);
+    return {
+        path,
+        ok: parsed.ok && parsed.issues.length === 0,
+        steps: parsed.ok ? parsed.wizard.steps.length : undefined,
+        files: given.files.length,
+        issues: parsed.issues,
+    };
+}
+export function validateCommand(paths, asJson) {
+    if (!paths.length) {
+        console.error("Give a path: a .wizard file, an unpacked package or a wizard JSON file.");
+        return 2;
+    }
+    const results = paths.map(validatePath);
+    if (asJson) {
+        console.log(JSON.stringify(results, null, 2));
+    }
+    else {
+        for (const r of results) {
+            if (r.ok) {
+                console.log(`${ok} ${r.path} ${dim(`${r.steps} ${r.steps === 1 ? "step" : "steps"}, ${r.files} ${r.files === 1 ? "file" : "files"}`)}`);
+                continue;
+            }
+            const count = `${r.issues.length} ${r.issues.length === 1 ? "issue" : "issues"}`;
+            console.log(`${bad} ${r.path} ${dim(count)}`);
+            for (const issue of r.issues) {
+                console.log(`  ${issue.message}`);
+            }
+        }
+    }
+    return results.every((r) => r.ok) ? 0 : 1;
+}