@engenty/wizards-runtime 0.7.9 → 0.7.10

package/README.md

@@ -57,7 +57,8 @@ the cloud behind the same links. On macOS or Linux, in a terminal:
 curl -fsSL https://engenty.ai/install.sh | bash
 ```
 
-With Node.js 20 or newer on the machine, `npx wizards` does the same.
+On Windows, in PowerShell: `irm https://engenty.ai/install.ps1 | iex`. With Node.js 20 or newer on
+the machine, `npx wizards` does the same.
 
 It needs nothing but `curl` and `tar` and asks for no password. It brings its own Node.js (a
 Node you already have is left alone), installs engenty wizards into `~/.engenty/wizards` and

package/apps/runtime/dist/app.js

@@ -305,13 +305,13 @@ async function previewFor(path) {
 /**
  * Production: the built app. Its files and the studio's pages sit below `/studio`; the public
  * pages are `/w/<token>` and `/s/<token>`. Of the root only what others fetch there is served:
- * the installer, the embed script for websites, and the service worker of public wizards. The
+ * the installers, the embed script for websites, and the service worker of public wizards. The
  * rest of the root belongs to others (the landing page); a runtime alone sends `/` to the studio.
  * The app's files are served by both halves: a wizard's page loads its scripts from `/studio`
  * too. Which pages a half answers follows its role.
  */
 const webDir = resolve(dirname(fileURLToPath(import.meta.url)), "../../web/dist");
-const STUDIO_FILES = ["/install.sh"];
+const STUDIO_FILES = ["/install.sh", "/install.ps1"];
 const DOORS_FILES = ["/embed.js", "/sw.js"];
 const PAGES = new RegExp(`^/(${[...(serves.studio ? ["studio(/|$)"] : []), ...(serves.doors ? ["w/", "s/"] : [])].join("|")})`);
 if (existsSync(webDir)) {

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

@@ -3,14 +3,15 @@ import { lstatSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
-import { installedByScript } from "./home.js";
+import { installedByScript, installedScript } from "./home.js";
 import { findOnPath } from "./machine.js";
 const run = promisify(execFile);
 /**
  * engenty wizards starting by itself when the person logs in, so that links and AI clients
  * reach it without anybody starting it: `wizards start --no-open`, on a Mac from a
- * LaunchAgent, on Linux from a systemd user service. Only for an install made by install.sh,
- * whose command stays where it is.
+ * LaunchAgent, on Linux from a systemd user service, on Windows from a scheduled task (or, where
+ * Windows refuses one without an administrator, a shortcut in the Startup folder). Only for an
+ * install made by the installer, whose command stays where it is.
  */
 export const LOGIN_LABEL = "com.engenty.wizards.login";
 /** The LaunchAgent. */
@@ -80,6 +81,82 @@ async function systemdHere() {
         return false;
     }
 }
+const TASK = "engenty wizards";
+const TASK_HOW = `a scheduled task, ${TASK}`;
+const STARTUP_HOW = "a shortcut in the Startup folder";
+/** The shortcut Windows starts at login when no task may be made. */
+function startupShortcut(env = process.env) {
+    return join(env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", `${TASK}.lnk`);
+}
+/**
+ * What Windows starts: the install's Node and script through conhost without a window — Node is
+ * a console program, and the task or shortcut would otherwise open a console at every login.
+ */
+export function windowsStart(paths) {
+    const { node, script } = installedScript(paths, "win32");
+    return {
+        file: join(process.env.SystemRoot ?? "C:\\Windows", "System32", "conhost.exe"),
+        args: ["--headless", node, script, "start", "--no-open"],
+    };
+}
+const quoted = (arg) => (/[\s"]/.test(arg) ? `"${arg.replaceAll('"', '\\"')}"` : arg);
+async function windowsState() {
+    try {
+        await run("schtasks", ["/Query", "/TN", TASK], { timeout: 10_000 });
+        return { on: true, how: TASK_HOW };
+    }
+    catch {
+        return present(startupShortcut())
+            ? { on: true, how: STARTUP_HOW }
+            : { on: false, how: TASK_HOW };
+    }
+}
+/** The Windows login item, as the uninstall names it; null without one. */
+export async function windowsLoginItem() {
+    const state = await windowsState();
+    if (!("on" in state) || !state.on) {
+        return null;
+    }
+    return state.how === STARTUP_HOW ? startupShortcut() : `the scheduled task “${TASK}”`;
+}
+/** Takes the scheduled task and the Startup shortcut away. */
+export async function removeWindowsLoginItem() {
+    await run("schtasks", ["/Delete", "/F", "/TN", TASK], { timeout: 10_000 }).catch(() => undefined);
+    rmSync(startupShortcut(), { force: true });
+}
+async function setWindows(paths, on) {
+    await run("schtasks", ["/Delete", "/F", "/TN", TASK], { timeout: 10_000 }).catch(() => undefined);
+    rmSync(startupShortcut(), { force: true });
+    if (!on) {
+        return windowsState();
+    }
+    // Takes effect at the next login, as on a Mac; nothing is started now.
+    const { file, args } = windowsStart(paths);
+    const command = [file, ...args].map(quoted).join(" ");
+    try {
+        await run("schtasks", ["/Create", "/F", "/TN", TASK, "/SC", "ONLOGON", "/RL", "LIMITED", "/TR", command], {
+            timeout: 15_000,
+        });
+    }
+    catch {
+        // A task at logon may need an administrator; the Startup folder needs none.
+        const ps = (text) => `'${text.replaceAll("'", "''")}'`;
+        await run("powershell.exe", [
+            "-NoProfile",
+            "-Command",
+            [
+                "$s = (New-Object -ComObject WScript.Shell).CreateShortcut(" +
+                    ps(startupShortcut()) +
+                    ")",
+                `$s.TargetPath = ${ps(file)}`,
+                `$s.Arguments = ${ps(args.map(quoted).join(" "))}`,
+                `$s.WorkingDirectory = ${ps(paths.home)}`,
+                "$s.Save()",
+            ].join("; "),
+        ], { timeout: 15_000 });
+    }
+    return windowsState();
+}
 /**
  * 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.
@@ -102,10 +179,13 @@ export function present(file) {
  * 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 (!["darwin", "linux", "win32"].includes(process.platform)) {
+        return { unavailable: `not on ${process.platform}` };
+    }
+    if (process.platform === "win32") {
+        return installedByScript(paths)
+            ? windowsState()
+            : { unavailable: "only for installs made with the install script" };
     }
     const file = process.platform === "darwin" ? LOGIN_ITEM : unitFile();
     const there = present(file);
@@ -153,6 +233,9 @@ export async function setAutostart(paths, on) {
     if ("unavailable" in state) {
         return state;
     }
+    if (process.platform === "win32") {
+        return setWindows(paths, on);
+    }
     if (process.platform === "darwin") {
         // Takes effect at the next login; nothing is started or stopped now.
         if (on) {

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

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { mkdirSync, mkdtempSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
+import { withPath } from "./environment.js";
 import { readEnvFile, readInstallNote } from "./home.js";
 import { currentVersion, promote, prune, RUNTIME_PACKAGE, runtimeDir, switchTo, versionIn, } from "./versions.js";
 /**
@@ -92,14 +93,26 @@ async function latestVersion(deps, env) {
 }
 /** 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");
+    // On Windows Node sits in the folder itself, and npm is its npm-cli.js (npm.cmd starts only
+    // through cmd.exe).
+    const windows = process.platform === "win32";
+    const bin = windows ? join(paths.tools, "node") : 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 args = [
+        ..."install --omit=dev --ignore-scripts --legacy-peer-deps --no-audit --no-fund --loglevel=error".split(" "),
+        "--prefix",
+        prefix,
+        spec,
+    ];
+    const [command, all] = windows
+        ? [join(bin, "node.exe"), [join(bin, "node_modules", "npm", "bin", "npm-cli.js"), ...args]]
+        : [join(bin, "npm"), args];
     const code = await new Promise((done) => {
-        const child = spawn(join(bin, "npm"), [...args.split(" "), "--prefix", prefix, spec], {
+        const child = spawn(command, all, {
             stdio: ["ignore", log, log],
-            env: { ...process.env, PATH: `${bin}:${process.env.PATH ?? ""}` },
+            env: withPath(process.env, [bin, process.env.PATH ?? ""].join(delimiter)),
+            windowsHide: true,
         });
         child.on("error", () => done(127));
         child.on("exit", (exit) => done(exit ?? 1));

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

@@ -1,16 +1,31 @@
 import { mkdirSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
-import { runtimePath } from "./environment.js";
+import { runtimePath, withPath } 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}`
+/** A word for PowerShell: in single quotes, which take everything but a single quote as it is. */
+const powershellWord = (word) => /^[\w@%+=:,./\\-]+$/.test(word) ? word : `'${word.replaceAll("'", "''")}'`;
+/** The command the setup runs for a client, as the person would type it (PowerShell on Windows). */
+export function installCommand(client, paths, platform = process.platform) {
+    const windows = platform === "win32";
+    if (client.install.kind === "npm") {
+        const prefix = windows ? powershellWord(paths.clients) : shellWord(paths.clients);
+        return `npm install --global --prefix ${prefix} ${client.install.pkg}`;
+    }
+    return windows
+        ? `irm ${powershellWord(client.install.windows)} | iex`
         : `curl -fsSL ${client.install.url} | bash`;
 }
+/** PowerShell, for a command written for it: without the person's profile, scripts allowed. */
+export const POWERSHELL = [
+    "powershell.exe",
+    "-NoProfile",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+];
 /**
  * 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
@@ -18,7 +33,11 @@ export function installCommand(client, paths) {
  */
 export function installClient(client, paths, onLine) {
     const logFile = join(paths.logs, "install.log");
-    const env = { ...process.env, PATH: runtimePath(paths, process.env) };
+    const env = withPath(process.env, runtimePath(paths, process.env));
+    if (client.install.kind === "script" && process.platform === "win32") {
+        const [shell, ...args] = POWERSHELL;
+        return runLogged(shell, [...args, installCommand(client, paths)], { env, logFile, onLine });
+    }
     if (client.install.kind === "script") {
         return runLogged("bash", ["-c", `set -o pipefail; curl -fsSL ${client.install.url} | bash`], {
             env,

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

@@ -3,7 +3,7 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from
 import { homedir } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { promisify } from "node:util";
-import { installedByScript, packageRoot } from "./home.js";
+import { commandFile, installedByScript, installedScript, packageRoot, } from "./home.js";
 import { findOnPath, macAppPresent } from "./machine.js";
 import { bad, cmd, dim, ok, tilde } from "./ui.js";
 const run = promisify(execFile);
@@ -23,8 +23,13 @@ export const SERVER_NAME = "engenty-wizards";
 export function serverCommand(paths, script = join(packageRoot, "bin", "wizards.mjs")) {
     const moved = dirname(paths.home) !== join(homedir(), ".engenty");
     const env = moved ? { env: { ENGENTY_HOME: dirname(paths.home) } } : {};
+    if (installedByScript(paths) && process.platform === "win32") {
+        // Not wizards.cmd: an app starts a .cmd file only through cmd.exe, if at all.
+        const { node, script: installed } = installedScript(paths);
+        return { command: node, args: [installed, "mcp"], ...env };
+    }
     if (installedByScript(paths)) {
-        return { command: join(paths.bin, "wizards"), args: ["mcp"], ...env };
+        return { command: commandFile(paths), args: ["mcp"], ...env };
     }
     return { command: process.execPath, args: [script, "mcp"], ...env };
 }

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

@@ -1,4 +1,4 @@
-import { basename, delimiter, dirname, join } from "node:path";
+import { basename, delimiter, dirname, join, win32 } from "node:path";
 import { isCI } from "./autoupdate.js";
 /**
  * Variables of the terminal the runtime inherits. Everything else it gets comes from the
@@ -59,7 +59,24 @@ export function inherited(env) {
  * The PATH of the runtime: AI clients the setup installed and the Node that runs this command
  * come first — a client installed with npm is a script that asks for `node`.
  */
-export function runtimePath(paths, env, node = process.execPath) {
+export function runtimePath(paths, env, node = process.execPath, platform = process.platform) {
+    if (platform === "win32") {
+        // npm puts a prefix's commands in the prefix itself on Windows. Claude Code installs into
+        // ~\.local\bin, Cursor Agent into %LOCALAPPDATA%\cursor-agent and Antigravity into
+        // %LOCALAPPDATA%\agy\bin; each adds that to the user's PATH, which a process started before
+        // the install does not see.
+        const p = win32;
+        const home = env.USERPROFILE ?? "";
+        const entries = [
+            paths.clients,
+            p.dirname(node),
+            ...(env.PATH ?? env.Path ?? "").split(";"),
+            home && p.join(home, ".local", "bin"),
+            env.LOCALAPPDATA && p.join(env.LOCALAPPDATA, "cursor-agent"),
+            env.LOCALAPPDATA && p.join(env.LOCALAPPDATA, "agy", "bin"),
+        ];
+        return [...new Set(entries.filter(Boolean))].join(";");
+    }
     const entries = [
         join(paths.clients, "bin"),
         dirname(node),
@@ -68,6 +85,20 @@ export function runtimePath(paths, env, node = process.execPath) {
     ];
     return [...new Set(entries.filter(Boolean))].join(delimiter);
 }
+/**
+ * An environment with this PATH, once: Windows names it Path, and a copy holding both leaves to
+ * chance which one a program gets.
+ */
+export function withPath(env, path) {
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (key.toUpperCase() !== "PATH") {
+            out[key] = value;
+        }
+    }
+    out.PATH = path;
+    return out;
+}
 /**
  * The environment the command line starts the runtime with. `fileEnv` is the install's `.env`:
  * the runtime reads it itself, it is only looked at here so that a default does not override it.

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

@@ -1,6 +1,8 @@
-import { spawn } from "node:child_process";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+// cross-spawn: on Windows a command from npm is a .cmd file, which only cmd.exe starts, with
+// its arguments quoted the way cmd.exe reads them. Elsewhere it is child_process.spawn.
+import spawn from "cross-spawn";
 /**
  * Runs a command; what it prints goes line by line to `onLine` and into the log file.
  * Never rejects for a command that fails: the caller reads `code`.
@@ -43,3 +45,38 @@ export function runLogged(command, args, options = {}) {
         child.on("close", (code) => resolve({ code: code ?? 1, tail: tail.trim() }));
     });
 }
+/**
+ * Runs a file and gives what it printed, like execFile: it rejects when the file is not there,
+ * ends with another code than 0, or takes longer than `timeout`.
+ */
+export function runFile(file, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(file, args, {
+            env: options.env,
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: options.timeout,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", reject);
+        child.on("close", (code, signal) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                reject(Object.assign(new Error(`${file} ended with ${signal ?? code}`), {
+                    code,
+                    stdout,
+                    stderr,
+                }));
+            }
+        });
+    });
+}

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

@@ -43,6 +43,21 @@ export function packageVersion() {
     }
     return running ?? "0.0.0";
 }
+/** The `wizards` command install.sh (on Windows install.ps1) writes: `bin/wizards`, `bin\\wizards.cmd`. */
+export function commandFile(paths, platform = process.platform) {
+    return join(paths.bin, platform === "win32" ? "wizards.cmd" : "wizards");
+}
+/**
+ * The Node and the script of an install made by the installer: what its command runs. They stay
+ * where they are across updates (`tools/node` follows the Node of the version).
+ */
+export function installedScript(paths, platform = process.platform) {
+    const win = platform === "win32";
+    return {
+        node: join(paths.tools, "node", win ? "node.exe" : "bin/node"),
+        script: join(paths.runtime, "current", "node_modules", "@engenty", "wizards-runtime", "bin", "wizards.mjs"),
+    };
+}
 /** How this copy got here: by install.sh into the home folder, or by npm/npx or a checkout. */
 export function installedByScript(paths = layout()) {
     try {

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

@@ -1,13 +1,11 @@
-import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { promisify } from "node:util";
 // The search for a browser is shared with env.ts, so the runtime uses the one the setup found.
 import { findChrome, findOnPath } from "../render/browser-path.js";
-import { runtimePath } from "./environment.js";
+import { runtimePath, withPath } from "./environment.js";
+import { runFile as run } from "./exec.js";
 export { findChrome, findOnPath };
-const run = promisify(execFile);
 /** The AI clients the runtime can think with, in the order its own setup offers them. */
 export const CLIENTS = [
     {
@@ -23,7 +21,11 @@ export const CLIENTS = [
         name: "Claude Code",
         bin: "claude",
         account: "Claude",
-        install: { kind: "script", url: "https://claude.ai/install.sh" },
+        install: {
+            kind: "script",
+            url: "https://claude.ai/install.sh",
+            windows: "https://claude.ai/install.ps1",
+        },
         app: "Claude",
     },
     {
@@ -31,7 +33,11 @@ export const CLIENTS = [
         name: "Antigravity",
         bin: "agy",
         account: "Google AI",
-        install: { kind: "script", url: "https://antigravity.google/cli/install.sh" },
+        install: {
+            kind: "script",
+            url: "https://antigravity.google/cli/install.sh",
+            windows: "https://antigravity.google/cli/install.ps1",
+        },
         app: "Antigravity",
     },
     {
@@ -39,7 +45,11 @@ export const CLIENTS = [
         name: "Cursor Agent",
         bin: "cursor-agent",
         account: "Cursor",
-        install: { kind: "script", url: "https://cursor.com/install" },
+        install: {
+            kind: "script",
+            url: "https://cursor.com/install",
+            windows: "https://cursor.com/install?win32=true",
+        },
         app: "Cursor",
     },
 ];
@@ -68,7 +78,7 @@ async function versionOf(file, path) {
     try {
         const { stdout } = await run(file, ["--version"], {
             timeout: 10_000,
-            env: { ...process.env, PATH: path, TERM: "dumb" },
+            env: { ...withPath(process.env, path), TERM: "dumb" },
         });
         const line = stdout.trim().split("\n").pop()?.trim() ?? "";
         return line.match(/\d+\.\d+[\w.+-]*/)?.[0] ?? (line || null);

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

@@ -1,7 +1,25 @@
 import { execFileSync } from "node:child_process";
 import { sep } from "node:path";
-/** Every process, as `ps` lists it; empty where there is no `ps` (Windows). */
+/** Every process, as `ps` lists it, on Windows as Windows' own process table does. */
 function listProcesses() {
+    if (process.platform === "win32") {
+        try {
+            const json = execFileSync("powershell.exe", [
+                "-NoProfile",
+                "-Command",
+                "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress",
+            ], { encoding: "utf8", windowsHide: true, maxBuffer: 32 * 1024 * 1024 });
+            const rows = JSON.parse(json);
+            return rows.map((row) => ({
+                pid: row.ProcessId,
+                ppid: row.ParentProcessId,
+                command: row.CommandLine ?? "",
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
     try {
         return execFileSync("ps", ["-axww", "-o", "pid=,ppid=,command="], { encoding: "utf8" })
             .split("\n")
@@ -17,14 +35,16 @@ function listProcesses() {
  * 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) {
+export function wizardsProcesses(home, list, self = process.pid, platform = process.platform) {
+    // Windows paths are the same in any case.
+    const fold = (text) => (platform === "win32" ? text.toLowerCase() : text);
     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))
+        .filter((entry) => !skip.has(entry.pid) && fold(entry.command).includes(fold(home + sep)))
         .map(({ pid, command }) => {
         const args = command.split(/\s+/);
         const kind = /apps[\\/]runtime[\\/]dist[\\/]index\.js/.test(command)

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

@@ -8,7 +8,7 @@ import { autostartForStatus, setAutostart } from "./autostart.js";
 import { installClient, installCommand } from "./clients.js";
 import { appStates, connectApps } from "./connect.js";
 import { runLogged } from "./exec.js";
-import { command, installedByScript, isCheckout, packageVersion, readInstallNote, writeInstallNote, } from "./home.js";
+import { command, installedByScript, isCheckout, layout, packageVersion, readInstallNote, writeInstallNote, } from "./home.js";
 import { CLIENTS, detectClients, findChrome, findFfmpeg, findOnPath, suggestedClient, vendorApp, } from "./machine.js";
 import { appAsksForPassword, DECISION_MODEL_GB, decisionModelProblem, freeGb, installOllama, ollamaState, pullModel, servesDecisions, startOllama, } from "./ollama.js";
 import { runningRuntime, settings } from "./start.js";
@@ -320,6 +320,16 @@ function pathLine() {
 }
 /** An install made by install.sh has its command in `~/.local/bin`: is that on the PATH? */
 async function pathStep(interactive) {
+    if (process.platform === "win32") {
+        // install.ps1 put the command's folder on the user's PATH; a terminal opened before it
+        // does not see that.
+        const bin = layout().bin.toLowerCase();
+        const path = (process.env.PATH ?? "").toLowerCase().split(";");
+        if (installedByScript() && !path.includes(bin)) {
+            p.log.info(`Open a new terminal to use the ${cyan("wizards")} command.`);
+        }
+        return;
+    }
     const local = join(homedir(), ".local", "bin");
     if (!installedByScript() || (process.env.PATH ?? "").split(delimiter).includes(local)) {
         return;

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

@@ -8,11 +8,12 @@ import { readRunning } from "../running.js";
 import { RESTART_EXIT } from "../update.js";
 import { applyPendingUpdate, autoUpdatePolicy, notesUrl } from "./autoupdate.js";
 import { runtimeEnv } from "./environment.js";
-import { installedByScript, packageRoot, readEnvFile } from "./home.js";
+import { commandFile, installedByScript, installedScript, packageRoot, readEnvFile, } from "./home.js";
 import { findOnPath } from "./machine.js";
 import { cmd, cyan, dim, live, tilde } from "./ui.js";
 const DEFAULT_PORT = 24368;
-const START_TIMEOUT_MS = 60_000;
+// Windows on Arm runs the runtime's x64 Node emulated, and a first start there takes longer.
+const START_TIMEOUT_MS = process.platform === "win32" ? 180_000 : 60_000;
 /** The settings this install starts with: its `.env`, overridden by the terminal's variables. */
 export function settings(paths, env = process.env) {
     const fileEnv = readEnvFile(paths.envFile);
@@ -83,6 +84,21 @@ export function entryUrl(running, paths, env = process.env) {
 }
 /** Opens an address in the person's browser; false when this machine has none to open it with. */
 export function openBrowser(url) {
+    if (process.platform === "win32") {
+        // The default browser, through the shell's own handler: no cmd.exe, which would read the
+        // link's & as the start of another command.
+        const rundll32 = join(process.env.SystemRoot || "C:\\Windows", "System32", "rundll32.exe");
+        try {
+            spawn(rundll32, ["url.dll,FileProtocolHandler", url], {
+                stdio: "ignore",
+                detached: true,
+            }).unref();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     const opener = process.platform === "darwin"
         ? "open"
         : process.env.DISPLAY || process.env.WAYLAND_DISPLAY
@@ -111,16 +127,26 @@ function show(url, entry, open) {
         console.log(dim("    The link signs in one browser and works only once."));
     }
 }
-/** The command of this install, as it is on disk now: `wizards <args>`. */
+/**
+ * The command of this install, as it is on disk now: `wizards <args>`. On Windows its Node and
+ * script, which is what wizards.cmd runs, without a console window of its own.
+ */
 function spawnCommand(paths, args, options) {
-    const wrapper = join(paths.bin, "wizards");
+    const wrapper = commandFile(paths);
+    if (existsSync(wrapper) && process.platform === "win32") {
+        const { node, script } = installedScript(paths);
+        return spawn(node, [script, ...args], { ...options, windowsHide: true });
+    }
     return existsSync(wrapper)
         ? spawn(wrapper, args, options)
-        : spawn(process.execPath, [join(packageRoot, "bin/wizards.mjs"), ...args], options);
+        : spawn(process.execPath, [join(packageRoot, "bin/wizards.mjs"), ...args], {
+            ...options,
+            windowsHide: true,
+        });
 }
 /**
  * `wizards start --no-open` detached from this terminal, its output in logs/runtime.log; the
- * runtime once it answers, or null when it ended or did not answer within a minute.
+ * runtime once it answers, or null when it ended or did not answer in time.
  */
 export async function startInBackground(paths) {
     const { dataDir } = settings(paths);
@@ -226,7 +252,7 @@ export async function start(paths, options) {
     while (exited === null && !(await healthy(port))) {
         if (Date.now() - began > START_TIMEOUT_MS) {
             child.kill("SIGTERM");
-            console.error("engenty wizards didn’t respond within 60 seconds.");
+            console.error(`engenty wizards didn’t respond within ${START_TIMEOUT_MS / 1000} seconds.`);
             return 1;
         }
         await new Promise((wait) => setTimeout(wait, 150));