wizards 0.6.2 → 0.7.1

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

@@ -1,9 +1,11 @@
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
 import * as p from "@clack/prompts";
 import { updateStatus } from "../update.js";
 import { accountMenu, accountState, describeAccount } from "./account.js";
-import { autostartState, setAutostart } from "./autostart.js";
+import { autostartForStatus, setAutostart } from "./autostart.js";
 import { connectCommand } from "./connect.js";
-import { command, packageVersion, readInstallNote } from "./home.js";
+import { command, packageRoot, packageVersion, readInstallNote } from "./home.js";
 import { setup } from "./setup.js";
 import { open, runningRuntime, settings, start } from "./start.js";
 import { restart, status, stop } from "./status.js";
@@ -13,7 +15,7 @@ async function look(paths) {
     const { dataDir } = settings(paths);
     const [running, atLogin, release, account] = await Promise.all([
         runningRuntime(dataDir),
-        autostartState(paths),
+        autostartForStatus(paths),
         updateStatus().catch(() => null),
         accountState(),
     ]);
@@ -45,7 +47,7 @@ function choices({ running, atLogin, release, account }) {
         ]
         : [
             { value: "start", label: "Start in the background", hint: "and open the studio" },
-            { value: "foreground", label: "Start here", hint: "in this terminal (Ctrl-C stops it)" },
+            { value: "foreground", label: "Start in this terminal", hint: "Ctrl-C stops it" },
         ];
     options.push({
         value: "update",
@@ -62,14 +64,18 @@ function choices({ running, atLogin, release, account }) {
     options.push({
         value: "connect",
         label: "Connect AI apps",
-        hint: "use your wizards in Claude, Cursor, Codex…",
+        hint: "add your wizards as an MCP server in Claude, Cursor, Codex…",
     }, {
         value: "account",
         label: "Account",
         hint: account.kind === "linked"
             ? `signed in as ${describeAccount(account)}`
             : describeAccount(account),
-    }, { value: "status", label: "Status", hint: "what’s installed, and any problems" }, { value: "setup", label: "Setup", hint: "account, AI client, ffmpeg, start at login" }, { value: "help", label: "Help", hint: "every command" }, { value: "quit", label: "Quit", hint: running ? "engenty wizards keeps running" : undefined });
+    }, { value: "status", label: "Status", hint: "what’s installed, and any problems" }, { value: "setup", label: "Setup", hint: "account, AI client, ffmpeg, start at login" }, {
+        value: "uninstall",
+        label: "Uninstall",
+        hint: "remove it from this computer; asks about your data first",
+    }, { value: "help", label: "Help", hint: "every command" }, { value: "quit", label: "Quit", hint: running ? "engenty wizards keeps running" : undefined });
     return options;
 }
 /** Whether it starts at login. Esc goes back to the menu. */
@@ -81,7 +87,11 @@ async function serviceSettings(paths, atLogin) {
         message: "Start at login?",
         initialValue: atLogin.on,
         options: [
-            { value: true, label: "Yes", hint: "runs in the background whenever you log in" },
+            {
+                value: true,
+                label: "Yes",
+                hint: "runs in the background whenever you log in to this computer",
+            },
             { value: false, label: "No", hint: "only when you start it" },
         ],
     });
@@ -112,7 +122,7 @@ function commands() {
 }
 /**
  * `wizards` on a terminal: what runs, and a menu of what the commands do. The first time, the
- * setup runs first. Returns the exit code; "Start here" ends it with the runtime in the
+ * setup runs first. Returns the exit code; "Start in this terminal" ends it with the runtime in the
  * foreground.
  */
 export async function menu(paths, setupOptions, help) {
@@ -175,6 +185,15 @@ export async function menu(paths, setupOptions, help) {
             case "setup":
                 await setup(paths, setupOptions);
                 break;
+            case "uninstall": {
+                // Its own process, as `wizards uninstall` is: this one's modules write to the install.
+                const { status: code } = spawnSync(process.execPath, [join(packageRoot, "bin", "wizards.mjs"), "uninstall"], { stdio: "inherit" });
+                // 130: the person said no, so the menu goes on.
+                if (code !== 130) {
+                    return code ?? 1;
+                }
+                break;
+            }
             case "help":
                 console.log(help);
                 break;

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

@@ -0,0 +1,72 @@
+import { execFileSync } from "node:child_process";
+import { sep } from "node:path";
+/** Every process, as `ps` lists it; empty where there is no `ps` (Windows). */
+function listProcesses() {
+    try {
+        return execFileSync("ps", ["-axww", "-o", "pid=,ppid=,command="], { encoding: "utf8" })
+            .split("\n")
+            .map((line) => line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/))
+            .filter((match) => match !== null)
+            .map((match) => ({ pid: Number(match[1]), ppid: Number(match[2]), command: match[3] }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The processes in `list` that run from `home`, apart from `self` and the processes that started
+ * it (npx, a shell).
+ */
+export function wizardsProcesses(home, list, self = process.pid) {
+    const parents = new Map(list.map((entry) => [entry.pid, entry.ppid]));
+    const skip = new Set();
+    for (let at = self; at && !skip.has(at); at = parents.get(at)) {
+        skip.add(at);
+    }
+    return list
+        .filter((entry) => !skip.has(entry.pid) && entry.command.includes(home + sep))
+        .map(({ pid, command }) => {
+        const args = command.split(/\s+/);
+        const kind = /apps[\\/]runtime[\\/]dist[\\/]index\.js/.test(command)
+            ? "runtime"
+            : args.includes("mcp")
+                ? "mcp"
+                : args.includes("start")
+                    ? "start"
+                    : "other";
+        return { pid, kind };
+    });
+}
+export const findWizardsProcesses = (home) => wizardsProcesses(home, listProcesses());
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+};
+/** SIGTERM, then SIGKILL after 8 seconds; the processes still there after that. */
+export async function stopProcesses(pids) {
+    const signal = (name) => {
+        for (const pid of pids.filter(alive)) {
+            try {
+                process.kill(pid, name);
+            }
+            catch {
+                // gone meanwhile, or not ours: the check below tells
+            }
+        }
+    };
+    const wait = async (ms) => {
+        for (let waited = 0; waited < ms && pids.some(alive); waited += 100) {
+            await new Promise((done) => setTimeout(done, 100));
+        }
+    };
+    signal("SIGTERM");
+    await wait(8000);
+    signal("SIGKILL");
+    await wait(2000);
+    return pids.filter(alive);
+}

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

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import * as p from "@clack/prompts";
 import { accountStep } from "./account.js";
-import { autostartState, setAutostart } from "./autostart.js";
+import { autostartForStatus, setAutostart } from "./autostart.js";
 import { installClient, installCommand } from "./clients.js";
 import { appStates, connectApps } from "./connect.js";
 import { runLogged } from "./exec.js";
@@ -41,17 +41,16 @@ async function clientsStep(paths, options, interactive) {
         ? `Found AI clients: ${installed.map((s) => `${s.client.name} ${s.version}`).join(", ")}.`
         : "No AI client on this computer yet.");
     if (!installed.length) {
-        p.log.message(dim("engenty wizards uses an AI client to think, on a subscription you already have."));
+        p.log.message(dim("engenty wizards runs its AI through an AI client, like Claude Code or Codex, on a subscription you already have."));
     }
     let wanted = missing.filter((s) => options.clients.includes(s.client.id));
-    if (interactive && missing.length && !wanted.length) {
+    // With a client already here, setup asks nothing more; another one is a `--client` away.
+    if (interactive && !installed.length && missing.length && !wanted.length) {
         const suggested = suggestedClient(missing);
         // A client whose app is on this Mac comes first: its subscription is most likely paid for.
         const offered = [...missing].sort((a, b) => Number(!vendorApp(a.client)) - Number(!vendorApp(b.client)));
         const answer = await p.multiselect({
-            message: installed.length
-                ? "Install another AI client? (space to choose, enter to continue)"
-                : "Which AI client should be installed?",
+            message: "Which AI client should be installed? (space to choose, enter to continue)",
             options: offered.map(({ client }) => {
                 const app = vendorApp(client);
                 return {
@@ -60,13 +59,13 @@ async function clientsStep(paths, options, interactive) {
                     hint: [
                         `${client.account} subscription`,
                         app ? `the ${app} app is on this Mac` : "",
-                        !installed.length && client.id === suggested?.client.id ? "recommended" : "",
+                        client.id === suggested?.client.id ? "recommended" : "",
                     ]
                         .filter(Boolean)
                         .join(", "),
                 };
             }),
-            initialValues: installed.length || !suggested ? [] : [suggested.client.id],
+            initialValues: suggested ? [suggested.client.id] : [],
             required: false,
         });
         if (cancelled(answer)) {
@@ -89,7 +88,7 @@ async function clientsStep(paths, options, interactive) {
 async function toolsStep(interactive) {
     const chrome = findChrome();
     if (chrome) {
-        p.log.success(`Browser for PDF and PNG: ${dim(tilde(chrome))}`);
+        p.log.success(`Browser for PDF and PNG exports: ${dim(tilde(chrome))}`);
     }
     else {
         p.log.warn("No Chrome, Edge or Chromium found. PDF and PNG exports and browser steps need one.\nhttps://www.google.com/chrome");
@@ -129,20 +128,20 @@ async function toolsStep(interactive) {
  * service does. Asked, never assumed; `autostart off` undoes it.
  */
 async function autostartStep(paths, interactive) {
-    const state = await autostartState(paths);
+    const state = await autostartForStatus(paths);
     if ("unavailable" in state) {
         return;
     }
     if (state.on) {
-        p.log.success(`Starts at login: ${dim(state.how)}`);
+        p.log.success(`Starts when you log in to this computer: ${dim(state.how)}`);
         return;
     }
     if (!interactive) {
-        p.log.info(dim(`To start it when you log in: ${cmd("autostart on")}`));
+        p.log.info(dim(`To start it when you log in to this computer: ${cmd("autostart on")}`));
         return;
     }
     const answer = await p.confirm({
-        message: "Start engenty wizards when you log in? It keeps running in the background, so links and your AI apps can always reach it.",
+        message: "Start engenty wizards when you log in to this computer? It runs as a background process, without a terminal window, so links and your AI apps can always reach it.",
         initialValue: true,
     });
     if (cancelled(answer)) {
@@ -155,14 +154,14 @@ async function autostartStep(paths, interactive) {
     try {
         const after = await setAutostart(paths, true);
         if ("on" in after && after.on) {
-            p.log.success(`Starts at login: ${dim(after.how)}`);
+            p.log.success(`Starts when you log in to this computer: ${dim(after.how)}`);
         }
         else {
-            p.log.warn("Couldn’t turn on start at login.");
+            p.log.warn("Couldn’t set it to start when you log in.");
         }
     }
     catch (error) {
-        p.log.warn(`Couldn’t turn on start at login. ${error.message}`);
+        p.log.warn(`Couldn’t set it to start when you log in. ${error.message}`);
     }
 }
 /**
@@ -174,7 +173,7 @@ async function appsStep(paths, interactive) {
     const connected = states.filter((s) => s.connected);
     const offered = states.filter((s) => s.installed && !s.connected);
     if (connected.length) {
-        p.log.success(`In your AI apps: ${connected.map((s) => s.name).join(", ")}`);
+        p.log.success(`Already in your AI apps: ${connected.map((s) => s.name).join(", ")}`);
     }
     if (!offered.length) {
         return;
@@ -184,12 +183,8 @@ async function appsStep(paths, interactive) {
         return;
     }
     const answer = await p.multiselect({
-        message: "Use your wizards in these AI apps? (space to choose, enter to continue)",
-        options: offered.map((s) => ({
-            value: s.id,
-            label: s.name,
-            hint: s.widgets ? "shows runs as a widget" : "shows runs as text",
-        })),
+        message: "Add your wizards to these AI apps, as an MCP server in each app’s settings? (space to choose, enter to continue)",
+        options: offered.map((s) => ({ value: s.id, label: s.name })),
         initialValues: offered.map((s) => s.id),
         required: false,
     });
@@ -261,7 +256,7 @@ async function pathStep(interactive) {
 async function howToUse(paths) {
     const [running, atLogin] = await Promise.all([
         runningRuntime(settings(paths).dataDir),
-        autostartState(paths),
+        autostartForStatus(paths),
     ]);
     const wizards = command();
     const row = (what, cmd, note = "") => `${what.padEnd(9)}${cyan(cmd.padEnd(wizards.length + 12))}${note ? dim(note) : ""}`;
@@ -271,7 +266,7 @@ async function howToUse(paths) {
             : "engenty wizards isn’t running yet.",
         "unavailable" in atLogin || !atLogin.on
             ? ""
-            : dim("It starts automatically when you log in."),
+            : dim("It starts automatically when you log in to this computer."),
     ]
         .filter(Boolean)
         .join("\n"));
@@ -322,7 +317,12 @@ export async function setup(paths, options) {
     if ((await pathStep(interactive)) === "cancelled") {
         return false;
     }
-    writeInstallNote({ ...readInstallNote(paths), setupAt: new Date().toISOString(), version }, paths);
+    writeInstallNote({
+        ...readInstallNote(paths),
+        setupAt: new Date().toISOString(),
+        version,
+        unattended: !process.stdout.isTTY,
+    }, paths);
     p.log.info(CHROME_APP);
     await howToUse(paths);
     return true;

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

@@ -6,8 +6,9 @@ import { join, resolve } from "node:path";
 import { mintLocalTicket } from "../auth/local-ticket.js";
 import { readRunning } from "../running.js";
 import { RESTART_EXIT } from "../update.js";
+import { applyPendingUpdate, autoUpdatePolicy, notesUrl } from "./autoupdate.js";
 import { runtimeEnv } from "./environment.js";
-import { packageRoot, readEnvFile } from "./home.js";
+import { installedByScript, packageRoot, readEnvFile } from "./home.js";
 import { findOnPath } from "./machine.js";
 import { cmd, cyan, dim, live, tilde } from "./ui.js";
 const DEFAULT_PORT = 24368;
@@ -163,6 +164,22 @@ export async function start(paths, options) {
         console.log(dim(`    It was already running. To stop it: ${cmd("stop")}`));
         return 0;
     }
+    // Nothing runs, so no run is cut off: a version downloaded meanwhile becomes current and
+    // takes this process's place (the login item keeps waiting on the same pid). In the
+    // background, the `start` spawned below does it.
+    if (!options.background && installedByScript(paths) && process.execve) {
+        const switched = autoUpdatePolicy(paths, { installed: true }).on && applyPendingUpdate(paths);
+        if (switched) {
+            console.log(`  ${live} Updated to ${switched.to}. What changed: ${notesUrl(switched.to)}`);
+            const wrapper = join(paths.bin, "wizards");
+            try {
+                process.execve(wrapper, [wrapper, "start", ...(options.open ? [] : ["--no-open"])]);
+            }
+            catch {
+                // This version starts once more; the next start is the new one.
+            }
+        }
+    }
     if (options.background) {
         const started = await startInBackground(paths);
         if (!started) {

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

@@ -1,9 +1,11 @@
 import { accessSync, constants, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { accountState, describeAccount } from "./account.js";
-import { autostartState, setAutostart } from "./autostart.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 { entryUrl, runningRuntime, settings, startInBackground } from "./start.js";
 import { bad, badge, cmd, cyan, dim, no, ok, tilde } from "./ui.js";
 /**
@@ -16,7 +18,7 @@ export async function status(paths, checks) {
         runningRuntime(dataDir),
         detectClients(paths),
         findFfmpeg(),
-        autostartState(paths),
+        autostartForStatus(paths),
         accountState(),
     ]);
     const chrome = findChrome();
@@ -33,12 +35,23 @@ export async function status(paths, checks) {
     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 { 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;
@@ -84,21 +97,41 @@ async function ended(pid, ms) {
     }
     return false;
 }
-/** Stops the runtime that runs on this install's data folder. */
+/**
+ * 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);
-    if (!running) {
+    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;
     }
-    process.kill(running.pid, "SIGTERM");
-    if (await ended(running.pid, 8000)) {
-        console.log(`Stopped (pid ${running.pid}). Your data is kept.`);
-        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.`);
     }
-    console.error(`engenty wizards (pid ${running.pid}) didn’t stop within 8 seconds.`);
-    return 1;
+    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
@@ -145,15 +178,16 @@ export async function autostart(paths, value) {
         console.error(`Use ${cmd("autostart on")} or ${cmd("autostart off")}.`);
         return 2;
     }
-    let state = await autostartState(paths);
-    if (value && !("unavailable" in state)) {
-        try {
+    let state;
+    try {
+        state = await autostartState(paths);
+        if (value && !("unavailable" in state)) {
             state = await setAutostart(paths, value === "on");
         }
-        catch (error) {
-            console.error(`Couldn’t turn start at login ${value}: ${error.message}`);
-            return 1;
-        }
+    }
+    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}.`);

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);
+}