wizards 0.6.2 → 0.7.1

package/README.md

@@ -159,8 +159,12 @@ when a newer release is out and can run the same update from there or from its A
 From source: `git pull`, `pnpm install`, `pnpm build`. Your data is brought up to date at the
 next start.
 
-To remove engenty wizards, run `wizards stop`, `wizards autostart off` and `wizards disconnect`, then delete `~/.engenty/wizards` (your data is in its `data` folder) and
-`~/.local/bin/wizards`.
+To remove engenty wizards, run `wizards uninstall` (or `npx wizards uninstall` if the command no
+longer runs). It shows what it will remove first: your AI apps' entries, the login item, every
+running process, `~/.engenty/wizards` and `~/.local/bin/wizards`. Your data in
+`~/.engenty/wizards/data` is kept unless you choose to delete it, and a reinstall picks it up
+again. `--dry-run` only shows the plan, `--yes` runs it without questions and keeps your data,
+and `--yes --delete-data` deletes your data too.
 
 ## Run it on a server
 

package/apps/runtime/dist/agents/architect.js

@@ -7,16 +7,16 @@ import { z } from "zod";
 import { connectorsLine, exampleWizard, mcpServersLine, PRINCIPLES, pluginToolsLine, SCHEMA_DOC, WIDGET_GUIDE, } from "../authoring/guide.js";
 import { wizardOpSchema } from "../authoring/ops.js";
 import { importFromRegistry, listConnectors, searchRegistry } from "../connectors/external.js";
-import { attachTools, costOf, gatewayTools, textModel } from "../models.js";
+import { agentModel, attachTools, costOf, gatewayTools, textModel, totalUsage, } from "../models.js";
 import { pluginToolsOf } from "../plugins/registry.js";
 import { htmlToMarkdown } from "../render/convert.js";
-import { ServiceError } from "../services/errors.js";
 import { deleteFile, listFiles, readFileText, writeFile } from "../services/files.js";
 import { checkDraftWidget } from "../services/widgets.js";
 import { editWizard, ownedWizard, writeDraft } from "../services/wizards.js";
 import { currentTenant } from "../tenants/tenant.js";
 import { serverText } from "../texts.js";
 import { assertPublicUrl, safeFetch } from "../tools/net-guard.js";
+import { attempt as attemptTool, imageOutput } from "../tools/shared.js";
 import { runScript } from "../widgets/script.js";
 import { thoughtLine } from "./thought.js";
 const MAX_STEPS = 45;
@@ -93,18 +93,8 @@ function activity(tool, args, lang = "en") {
             return null;
     }
 }
-/** A tool failure the model can read and fix, instead of a crashed turn. */
-async function attempt(run) {
-    try {
-        return await run();
-    }
-    catch (err) {
-        if (err instanceof ServiceError) {
-            return { error: err.message, ...err.data };
-        }
-        return { error: err.message };
-    }
-}
+/** A tool failure the model can read and fix, instead of a crashed turn: the whole message. */
+const attempt = (run) => attemptTool(run, { limit: Number.POSITIVE_INFINITY });
 function buildTools(input, resolved, wrote) {
     const { userId, wizardId } = input;
     const signal = input.signal;
@@ -314,19 +304,7 @@ function buildTools(input, resolved, wrote) {
                     screenshot: Buffer.from(r.png).toString("base64"),
                 };
             }),
-            toModelOutput: (out) => {
-                if (!out || out.error || !out.screenshot) {
-                    return { type: "json", value: out };
-                }
-                const { screenshot, ...rest } = out;
-                return {
-                    type: "content",
-                    value: [
-                        { type: "text", text: JSON.stringify(rest) },
-                        { type: "image-data", data: screenshot, mediaType: "image/png" },
-                    ],
-                };
-            },
+            toModelOutput: imageOutput("screenshot"),
         }),
     };
     if (resolved.vendor === "anthropic") {
@@ -357,7 +335,7 @@ export async function runArchitect(input) {
             content: systemPrompt(input.mcpServers, input.connectors, await pluginToolsOf(currentTenant())),
             providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
         },
-        model: resolved.model,
+        model: agentModel(resolved),
         tools,
     });
     const context = [
@@ -456,7 +434,7 @@ export async function runArchitect(input) {
             throw payload.error ?? new Error("architect stream error");
         }
     }
-    const usage = (await stream.totalUsage) ?? (await stream.usage);
+    const usage = await totalUsage(stream);
     return {
         reply: reply.trim(),
         changed,

package/apps/runtime/dist/agents/studio-assistant.js

@@ -7,8 +7,7 @@ import { z } from "zod";
 import { knowsTools } from "../assistant/knows.js";
 import { PRIMER } from "../assistant/primer.js";
 import { currentFeatures } from "../features.js";
-import { attachTools, contextWindowOf, costOf, gatewayTools, textModel, usageOf, } from "../models.js";
-import { ServiceError } from "../services/errors.js";
+import { agentModel, attachTools, contextWindowOf, costOf, gatewayTools, textModel, totalUsage, usageOf, } from "../models.js";
 import { knowledgeCounts } from "../services/knowledge.js";
 import { addProjectFileFromUrl, projectFileContent, projectFiles, updateProjectFile, } from "../services/project-files.js";
 import { documentText } from "../services/project-index.js";
@@ -17,6 +16,7 @@ import { categoryRows } from "../services/space-categories.js";
 import { currentTenant } from "../tenants/tenant.js";
 import { serverText } from "../texts.js";
 import { assistantPageOf, assistantToolsOf } from "../tools/plugin.js";
+import { attempt as attemptTool, imageOutput } from "../tools/shared.js";
 import { readWebsite } from "./website.js";
 /** How a message written meanwhile reaches the model. */
 export function signalText(taken) {
@@ -97,14 +97,8 @@ function activity(tool, args, lang) {
             : tool;
     return LABELS[key] ? serverText(lang, LABELS[key]) : null;
 }
-async function attempt(run) {
-    try {
-        return await run();
-    }
-    catch (err) {
-        return { error: err instanceof ServiceError ? err.message : err.message };
-    }
-}
+/** A tool failure the model can read and fix, instead of a crashed turn: the whole message. */
+const attempt = (run) => attemptTool(run, { limit: Number.POSITIVE_INFINITY });
 async function projectState(userId, projectId) {
     const p = await ownedProject(userId, projectId);
     const files = await projectFiles(projectId);
@@ -587,18 +581,7 @@ function spaceTools(input, project, wrote, on) {
                 }
                 return { name: row.name, image: data.toString("base64"), mime: row.mime };
             }),
-            toModelOutput: (out) => {
-                if (!out?.image) {
-                    return { type: "json", value: out };
-                }
-                return {
-                    type: "content",
-                    value: [
-                        { type: "text", text: out.name },
-                        { type: "image-data", data: out.image, mediaType: out.mime },
-                    ],
-                };
-            },
+            toModelOutput: imageOutput("image", (rest) => String(rest.name)),
         }),
     };
     if (!on.brandSections) {
@@ -765,7 +748,7 @@ export async function runStudioAssistant(input) {
             content: SYSTEM,
             providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
         },
-        model: resolved.model,
+        model: agentModel(resolved),
         tools,
     });
     const page = input.page;
@@ -895,6 +878,6 @@ export async function runStudioAssistant(input) {
             throw payload.error ?? new Error("assistant stream error");
         }
     }
-    const usage = (await stream.totalUsage) ?? (await stream.usage);
+    const usage = await totalUsage(stream);
     return { ...cut(), costUsd: costOf(resolved, usage) };
 }

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

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
@@ -12,7 +12,7 @@ const run = promisify(execFile);
  * LaunchAgent, on Linux from a systemd user service. Only for an install made by install.sh,
  * whose command stays where it is.
  */
-const LOGIN_LABEL = "com.engenty.wizards.login";
+export const LOGIN_LABEL = "com.engenty.wizards.login";
 /** The LaunchAgent. */
 export const LOGIN_ITEM = join(homedir(), "Library", "LaunchAgents", `${LOGIN_LABEL}.plist`);
 const xml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -45,7 +45,7 @@ ${program.map((arg) => `    <string>${xml(arg)}</string>\n`).join("")}  </array>
 </plist>
 `;
 }
-const UNIT = "engenty-wizards.service";
+export const UNIT = "engenty-wizards.service";
 export function unitFile(env = process.env) {
     return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "systemd", "user", UNIT);
 }
@@ -80,27 +80,71 @@ async function systemdHere() {
         return false;
     }
 }
+/**
+ * Whether a file is there. Unlike existsSync, a folder it may not look into (a sandbox, its
+ * permissions) is an error, not "no file": `autostart off` must not say it's off then.
+ */
+export function present(file) {
+    try {
+        lstatSync(file);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw new Error(`Couldn’t check ${file}: ${error.message}`);
+    }
+}
+/**
+ * Whether it starts at login, read from the login item itself: a LaunchAgent or unit file that
+ * is there counts, whichever copy of the command wrote it. Only an install made by install.sh can
+ * write one.
+ */
 export async function autostartState(paths) {
     if (process.platform !== "darwin" && process.platform !== "linux") {
         return {
             unavailable: process.platform === "win32" ? "not on Windows" : `not on ${process.platform}`,
         };
     }
-    if (!installedByScript(paths)) {
+    const file = process.platform === "darwin" ? LOGIN_ITEM : unitFile();
+    const there = present(file);
+    if (!there && !installedByScript(paths)) {
         return { unavailable: "only for installs made with the install script" };
     }
     if (process.platform === "darwin") {
-        return { on: existsSync(LOGIN_ITEM), how: MAC_HOW };
+        return { on: there, how: MAC_HOW };
     }
     if (!(await systemdHere())) {
-        return { unavailable: "this system has no systemd user session" };
+        return there
+            ? { on: true, how: LINUX_HOW }
+            : { unavailable: "this system has no systemd user session" };
     }
     try {
         await run("systemctl", ["--user", "is-enabled", "--quiet", UNIT], { timeout: 10_000 });
         return { on: true, how: LINUX_HOW };
     }
     catch {
-        return { on: false, how: LINUX_HOW };
+        // A unit file that is there but not enabled still counts: `off` takes it away.
+        return { on: there, how: LINUX_HOW };
+    }
+}
+/** The LaunchAgent unloaded from this login session, if launchd has it; errors are ignored. */
+export async function unloadLoginItem() {
+    const uid = process.getuid?.();
+    if (process.platform !== "darwin" || uid === undefined) {
+        return;
+    }
+    await run("launchctl", ["bootout", `gui/${uid}/${LOGIN_LABEL}`], { timeout: 15_000 }).catch(() => undefined);
+}
+/** The systemd user service disabled, stopped and its file gone. */
+export async function removeUnit(file = unitFile()) {
+    if (findOnPath("systemctl", process.env.PATH ?? "")) {
+        await run("systemctl", ["--user", "disable", "--now", UNIT]).catch(() => undefined);
+    }
+    rmSync(file, { force: true });
+    if (findOnPath("systemctl", process.env.PATH ?? "")) {
+        await run("systemctl", ["--user", "daemon-reload"]).catch(() => undefined);
     }
 }
 /** Switches it on or off; what it is afterwards, or an error the person can read. */
@@ -110,7 +154,7 @@ export async function setAutostart(paths, on) {
         return state;
     }
     if (process.platform === "darwin") {
-        // Takes effect at the next login; nothing is started now.
+        // Takes effect at the next login; nothing is started or stopped now.
         if (on) {
             mkdirSync(dirname(LOGIN_ITEM), { recursive: true });
             writeFileSync(LOGIN_ITEM, loginItemText(join(paths.home, "bin", "wizards"), join(paths.home, "logs", "autostart.log")));
@@ -118,7 +162,7 @@ export async function setAutostart(paths, on) {
         else {
             rmSync(LOGIN_ITEM, { force: true });
         }
-        return { on: existsSync(LOGIN_ITEM), how: MAC_HOW };
+        return { on: present(LOGIN_ITEM), how: MAC_HOW };
     }
     const file = unitFile();
     if (on) {
@@ -128,9 +172,11 @@ export async function setAutostart(paths, on) {
         await run("systemctl", ["--user", "enable", "--now", UNIT]);
     }
     else {
-        await run("systemctl", ["--user", "disable", "--now", UNIT]).catch(() => undefined);
-        rmSync(file, { force: true });
-        await run("systemctl", ["--user", "daemon-reload"]).catch(() => undefined);
+        await removeUnit(file);
     }
     return autostartState(paths);
 }
+/** The state for a status line: a login item that can't be checked reads as unavailable. */
+export function autostartForStatus(paths) {
+    return autostartState(paths).catch((error) => ({ unavailable: error.message }));
+}

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, 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 `wizards` 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/wizards/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, `wizards@${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/connect.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { installedByScript, packageRoot } from "./home.js";
-import { findOnPath } from "./machine.js";
+import { findOnPath, macAppPresent } from "./machine.js";
 import { bad, cmd, dim, ok, tilde } from "./ui.js";
 const run = promisify(execFile);
 /**
@@ -225,7 +225,8 @@ function jsonApp(def) {
         name: def.name,
         widgets: def.widgets,
         where: def.file,
-        installed: () => existsSync(def.marker),
+        installed: () => existsSync(def.marker) &&
+            (process.platform !== "darwin" || !def.macApp || macAppPresent(def.macApp)),
         connected: async () => jsonHasServer(read(def.file) ?? "", def.at),
         async connect(server) {
             const busy = running();
@@ -423,6 +424,7 @@ export function apps(paths) {
             widgets: true,
             file: join(appSupport("Claude"), "claude_desktop_config.json"),
             marker: appSupport("Claude"),
+            macApp: "Claude",
             at: ["mcpServers"],
             entry: stdioEntry,
             ownsFileWhileRunning: () => processRunning(CLAUDE_DESKTOP_PROCESS),
@@ -444,6 +446,7 @@ export function apps(paths) {
             widgets: true,
             file: join(vscodeUser, "mcp.json"),
             marker: vscodeUser,
+            macApp: "Visual Studio Code",
             at: ["servers"],
             entry: (server) => ({ type: "stdio", ...stdioEntry(server) }),
         }),
@@ -453,6 +456,7 @@ export function apps(paths) {
             widgets: false,
             file: join(home, ".codeium", "windsurf", "mcp_config.json"),
             marker: join(home, ".codeium", "windsurf"),
+            macApp: "Windsurf",
             at: ["mcpServers"],
             entry: stdioEntry,
         }),

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

@@ -1,4 +1,5 @@
 import { basename, delimiter, dirname, join } from "node:path";
+import { isCI } from "./autoupdate.js";
 /**
  * Variables of the terminal the runtime inherits. Everything else it gets comes from the
  * install's `.env` or is set by the command line. A key or a database address that the shell
@@ -40,6 +41,8 @@ const INHERITED = new Set([
     "ACCOUNT_URL",
     "ACCOUNT_GATEWAY_URL",
     "CLOUD_URL",
+    // Off for this start (autoupdate.ts).
+    "WIZARDS_DISABLE_AUTOUPDATE",
 ]);
 export function inherited(env) {
     const out = {};
@@ -82,6 +85,8 @@ export function runtimeEnv(paths, start, env = process.env, fileEnv = {}, platfo
         LOCAL_ACCESS_KEY: start.accessKey,
         // The install the runtime belongs to: the studio connects AI apps to its command.
         ...(basename(paths.home) === "wizards" ? { ENGENTY_HOME: dirname(paths.home) } : {}),
+        // The runtime sees no CI variables; it is told so, and checks for no updates (autoupdate.ts).
+        ...(isCI(env) ? { ENGENTY_WIZARDS_CI: "1" } : {}),
         // Keys entered in the settings live in the Keychain, as with the desktop app.
         ...(platform === "darwin" && !secretsGiven ? { SECRETS: "keychain" } : {}),
     };

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

@@ -42,13 +42,17 @@ export const CLIENTS = [
         app: "Cursor",
     },
 ];
+const APP_ROOTS = ["/Applications", join(homedir(), "Applications")];
+/** Whether `<name>.app` is in one of the Mac's Applications folders. */
+export function macAppPresent(name, roots = APP_ROOTS) {
+    return roots.some((root) => existsSync(join(root, `${name}.app`)));
+}
 /** The client's desktop app, when it is on this Mac: its name, e.g. "Claude". */
-export function vendorApp(client, roots = ["/Applications", join(homedir(), "Applications")]) {
+export function vendorApp(client, roots = APP_ROOTS) {
     if (process.platform !== "darwin" || !client.app) {
         return null;
     }
-    const app = client.app;
-    return roots.some((root) => existsSync(join(root, `${app}.app`))) ? app : null;
+    return macAppPresent(client.app, roots) ? client.app : null;
 }
 /**
  * The client the setup suggests among those not installed: the one whose app is on this Mac —

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

@@ -12,7 +12,7 @@ import { setup } from "./setup.js";
 import { open, start, studio } from "./start.js";
 import { autostart, restart, status, stop } from "./status.js";
 import { cmd, cyan, tilde } from "./ui.js";
-import { update } from "./update.js";
+import { autoUpdateCommand, update } from "./update.js";
 import { validateCommand } from "./validate.js";
 /** One line of the help: the name padded, then coloured, so the columns stay straight. */
 const line = (name, what) => `  ${cyan(name.padEnd(command().length + 12))}${what}`;
@@ -38,7 +38,9 @@ ${line(`${command()} report`, "send the status, model settings and last log line
 ${line(`${command()} stop`, "stop it (your data is kept)")}
 ${line(`${command()} restart`, "restart it, e.g. to switch to a newly installed version")}
 ${line(`${command()} update`, "install the latest version")}
-${line(`${command()} autostart`, "start it when you log in: add on or off")}
+${line(`${command()} autoupdate`, "updates by themselves: add on or off (WIZARDS_DISABLE_AUTOUPDATE=1 is off too)")}
+${more("(downloaded in the background, used from the next start; never during a run)")}
+${line(`${command()} autostart`, "start it when you log in to this computer: add on or off")}
 ${more("(macOS: a LaunchAgent; Linux: a systemd user service)")}
 ${line(`${command()} connect`, "add your wizards to your AI apps: every app found, or the ones you name:")}
 ${more(apps(layout())
@@ -46,6 +48,8 @@ ${more(apps(layout())
     .join(", "))}
 ${line(`${command()} disconnect`, "remove your wizards from those apps (same names)")}
 ${line(`${command()} mcp`, "run the MCP server over stdio (AI apps start this)")}
+${line(`${command()} uninstall`, "take it off this computer: shows the plan, asks about your data (kept by default)")}
+${more("--dry-run only shows it; --yes asks nothing and keeps your data; --yes --delete-data")}
 ${line(`${command()} validate`, "check wizards without the studio: .wizard files, unpacked packages, wizard JSON")}
 ${more("--json prints the issues as JSON. A space’s connectors and plugins are checked on import.")}
 
@@ -112,7 +116,8 @@ function parse(argv) {
         else if (arg.startsWith("-")) {
             return `Unknown option ${arg}.`;
         }
-        else if (["autostart", "logs", "account"].includes(args.command) && !args.value) {
+        else if (["autostart", "autoupdate", "logs", "account"].includes(args.command) &&
+            !args.value) {
             args.value = arg;
         }
         else if (["connect", "disconnect", "features"].includes(args.command)) {
@@ -190,6 +195,8 @@ async function main(argv) {
             return update(paths);
         case "autostart":
             return autostart(paths, args.value);
+        case "autoupdate":
+            return autoUpdateCommand(paths, args.value);
         case "account":
             return accountCommand(paths, args.value, { yes: args.yes });
         case "connect":