@engenty/wizards-runtime 0.0.0-stage → 0.7.6

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

@@ -0,0 +1,335 @@
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import * as p from "@clack/prompts";
+import { accountStep } from "./account.js";
+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 { CLIENTS, detectClients, findChrome, findFfmpeg, findOnPath, suggestedClient, vendorApp, } from "./machine.js";
+import { runningRuntime, settings } from "./start.js";
+import { badge, busy, cmd, cyan, dim, tilde } from "./ui.js";
+/** The studio as an app of its own: Chrome (or Edge) installs it from the page. */
+const CHROME_APP = "Tip: in Chrome or Edge you can install the studio as an app, with its own window and icon. Use the offer at the top of the studio, or the install icon in the address bar.";
+function cancelled(value) {
+    if (p.isCancel(value)) {
+        p.cancel(`Setup stopped. To run it again: ${cmd("setup")}`);
+        return true;
+    }
+    return false;
+}
+async function install(client, paths) {
+    const task = p.taskLog({ title: `Installing ${client.name}`, limit: 6 });
+    task.message(dim(installCommand(client, paths)));
+    const { code, tail } = await installClient(client, paths, (line) => task.message(line));
+    const installed = (await detectClients(paths)).find((state) => state.client.id === client.id);
+    if (code === 0 && installed?.path) {
+        task.success(`${client.name} ${installed.version ?? ""} installed`.trim());
+        return true;
+    }
+    task.error(`${client.name} didn’t install${code === 0 ? ": its command isn’t on the PATH" : ""}. ${tail.split("\n").pop() ?? ""}`);
+    return false;
+}
+async function clientsStep(paths, options, interactive) {
+    const spinner = busy("Looking for AI clients on this computer…");
+    const found = await detectClients(paths);
+    const installed = found.filter((state) => state.path);
+    const missing = found.filter((state) => !state.path);
+    spinner.stop(installed.length
+        ? `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 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));
+    // 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: "Which AI client should be installed? (space to choose, enter to continue)",
+            options: offered.map(({ client }) => {
+                const app = vendorApp(client);
+                return {
+                    value: client.id,
+                    label: client.name,
+                    hint: [
+                        `${client.account} subscription`,
+                        app ? `the ${app} app is on this Mac` : "",
+                        client.id === suggested?.client.id ? "recommended" : "",
+                    ]
+                        .filter(Boolean)
+                        .join(", "),
+                };
+            }),
+            initialValues: suggested ? [suggested.client.id] : [],
+            required: false,
+        });
+        if (cancelled(answer)) {
+            return "cancelled";
+        }
+        wanted = missing.filter((s) => answer.includes(s.client.id));
+    }
+    let any = installed.length > 0;
+    for (const { client } of wanted) {
+        any = (await install(client, paths)) || any;
+    }
+    if (any) {
+        p.log.info("Sign in to the AI client on the first page of the studio.");
+    }
+    else {
+        p.log.warn(`No AI client yet. The first page of the studio can install one, or you can use an API key (Vercel AI Gateway, OpenAI, Anthropic) or a local model (Ollama).\n${dim(`To install ${CLIENTS.map((c) => c.name).join(", ")} here later: ${cmd("setup")}`)}`);
+    }
+    return any;
+}
+async function toolsStep(interactive) {
+    const chrome = findChrome();
+    if (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");
+    }
+    const ffmpeg = await findFfmpeg();
+    if (ffmpeg.path) {
+        p.log.success(`ffmpeg ${ffmpeg.version ?? ""} for videos`.replace("  ", " "));
+        return;
+    }
+    const brew = findOnPath("brew", process.env.PATH ?? "");
+    if (!interactive || !brew) {
+        p.log.warn(`No ffmpeg found. MP4 videos of animated widgets need it.${brew ? `\n${dim(`To install it: ${cyan("brew install ffmpeg")}`)}` : ""}`);
+        return;
+    }
+    const answer = await p.confirm({
+        message: "No ffmpeg (for MP4 videos of animated widgets). Install it with Homebrew?",
+        initialValue: false,
+    });
+    if (cancelled(answer)) {
+        return "cancelled";
+    }
+    if (answer) {
+        const task = p.taskLog({ title: "Installing ffmpeg", limit: 6 });
+        const { code, tail } = await runLogged(brew, ["install", "ffmpeg"], {
+            onLine: (line) => task.message(line),
+        });
+        if (code === 0) {
+            task.success("ffmpeg installed");
+        }
+        else {
+            task.error(`ffmpeg didn’t install. ${tail.split("\n").pop() ?? ""}`);
+        }
+    }
+}
+/**
+ * Starting at login: on a Mac a LaunchAgent starts the runtime, on Linux a systemd user
+ * service does. Asked, never assumed; `autostart off` undoes it.
+ */
+async function autostartStep(paths, interactive) {
+    const state = await autostartForStatus(paths);
+    if ("unavailable" in state) {
+        return;
+    }
+    if (state.on) {
+        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 to this computer: ${cmd("autostart on")}`));
+        return;
+    }
+    const answer = await p.confirm({
+        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)) {
+        return "cancelled";
+    }
+    if (!answer) {
+        p.log.info(dim(`To do it later: ${cmd("autostart on")}`));
+        return;
+    }
+    try {
+        const after = await setAutostart(paths, true);
+        if ("on" in after && after.on) {
+            p.log.success(`Starts when you log in to this computer: ${dim(after.how)}`);
+        }
+        else {
+            p.log.warn("Couldn’t set it to start when you log in.");
+        }
+    }
+    catch (error) {
+        p.log.warn(`Couldn’t set it to start when you log in. ${error.message}`);
+    }
+}
+/**
+ * The wizards in the person's AI apps (Claude Desktop, Cursor, Codex …): offered for each app on
+ * this machine that does not have them yet. Asked, never assumed; `disconnect` undoes it.
+ */
+async function appsStep(paths, interactive) {
+    const states = await appStates(paths);
+    const connected = states.filter((s) => s.connected);
+    const offered = states.filter((s) => s.installed && !s.connected);
+    if (connected.length) {
+        p.log.success(`Already in your AI apps: ${connected.map((s) => s.name).join(", ")}`);
+    }
+    if (!offered.length) {
+        return;
+    }
+    if (!interactive) {
+        p.log.info(dim(`To use your wizards in ${offered.map((s) => s.name).join(", ")}: ${cmd("connect")}`));
+        return;
+    }
+    const answer = await p.multiselect({
+        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,
+    });
+    if (cancelled(answer)) {
+        return "cancelled";
+    }
+    if (!answer.length) {
+        p.log.info(dim(`To do it later: ${cmd("connect")}`));
+        return;
+    }
+    for (const { app, outcome } of await connectApps(paths, answer)) {
+        if (outcome.ok) {
+            p.log.success(`${app.name}: ${dim(outcome.message)}`);
+        }
+        else {
+            p.log.warn(`${app.name}: ${outcome.message}${outcome.snippet ? `\n${outcome.snippet}` : ""}`);
+        }
+    }
+    p.log.info(dim("Restart those apps to see the wizards in them."));
+}
+/** The line that puts `~/.local/bin` on the PATH, and the shell file it belongs in. */
+function pathLine() {
+    const shell = process.env.SHELL ?? "";
+    if (shell.endsWith("fish")) {
+        return {
+            file: join(homedir(), ".config/fish/config.fish"),
+            line: "fish_add_path ~/.local/bin",
+        };
+    }
+    const file = shell.endsWith("zsh")
+        ? ".zshrc"
+        : process.platform === "darwin"
+            ? ".bash_profile"
+            : ".bashrc";
+    return { file: join(homedir(), file), line: 'export PATH="$HOME/.local/bin:$PATH"' };
+}
+/** An install made by install.sh has its command in `~/.local/bin`: is that on the PATH? */
+async function pathStep(interactive) {
+    const local = join(homedir(), ".local", "bin");
+    if (!installedByScript() || (process.env.PATH ?? "").split(delimiter).includes(local)) {
+        return;
+    }
+    const { file, line } = pathLine();
+    if (existsSync(file) && readFileSync(file, "utf8").includes(".local/bin")) {
+        p.log.info(`Open a new terminal to use the ${cyan("wizards")} command.`);
+        return;
+    }
+    const hint = `Until then, use ${cyan(tilde(join(local, "wizards")))}`;
+    if (!interactive) {
+        p.log.warn(`~/.local/bin isn’t on your PATH. Add this to ${tilde(file)}:\n${line}\n${dim(hint)}`);
+        return;
+    }
+    const answer = await p.confirm({
+        message: `The wizards command is in ~/.local/bin, which isn’t on your PATH. Add it in ${tilde(file)}?`,
+        initialValue: true,
+    });
+    if (cancelled(answer)) {
+        return "cancelled";
+    }
+    if (answer) {
+        appendFileSync(file, `\n# engenty wizards\n${line}\n`);
+        p.log.success(`Added to ${tilde(file)}. Open a new terminal to use it.\n${dim(hint)}`);
+    }
+    else {
+        p.log.info(hint);
+    }
+}
+/** What runs now, and the commands to start, stop and check it from now on. */
+async function howToUse(paths) {
+    const [running, atLogin] = await Promise.all([
+        runningRuntime(settings(paths).dataDir),
+        autostartForStatus(paths),
+    ]);
+    const wizards = command();
+    const row = (what, cmd, note = "") => `${what.padEnd(9)}${cyan(cmd.padEnd(wizards.length + 12))}${note ? dim(note) : ""}`;
+    p.log.message([
+        running
+            ? `engenty wizards is running: ${cyan(running.url)}`
+            : "engenty wizards isn’t running yet.",
+        "unavailable" in atLogin || !atLogin.on
+            ? ""
+            : dim("It starts automatically when you log in to this computer."),
+    ]
+        .filter(Boolean)
+        .join("\n"));
+    p.outro([
+        "From now on, in a terminal:",
+        "",
+        row("Start", `${wizards} start`, "runs in this terminal; Ctrl-C stops it"),
+        row("", `${wizards} start -s`, "runs in the background; the terminal stays free"),
+        row("Studio", `${wizards} studio`, "opens the studio, starting it first if needed"),
+        row("Stop", `${wizards} stop`, "your data is kept"),
+        row("Check", `${wizards} status`, "shows what’s running and where"),
+        row("Restart", `${wizards} restart`),
+        row("Menu", wizards, "everything in one menu"),
+        "",
+        dim("It’s installed, so there’s no need to run the installer again. To update: ") +
+            cmd("update"),
+    ].join("\n"));
+}
+/**
+ * The guided setup: the account this computer joins, then what this machine has, what is
+ * missing, and what to install — an AI client to think with, ffmpeg, starting at login. It
+ * starts nothing; it ends with what runs and how to start, stop and check it. Returns false
+ * when it was stopped.
+ */
+export async function setup(paths, options) {
+    const interactive = !options.yes && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const version = packageVersion();
+    p.intro(`${badge("engenty wizards")} ${dim(version)}`);
+    p.log.message([
+        `Install  ${tilde(paths.home)}${installedByScript() ? "" : dim(`  (data; the code runs from ${isCheckout() ? "this checkout" : "npm"})`)}`,
+        `Node     ${process.version}  ${dim(tilde(process.execPath))}`,
+    ].join("\n"));
+    if ((await accountStep(paths, options, interactive)) === "cancelled") {
+        return false;
+    }
+    if ((await clientsStep(paths, options, interactive)) === "cancelled") {
+        return false;
+    }
+    if ((await toolsStep(interactive)) === "cancelled") {
+        return false;
+    }
+    if ((await autostartStep(paths, interactive)) === "cancelled") {
+        return false;
+    }
+    if ((await appsStep(paths, interactive)) === "cancelled") {
+        return false;
+    }
+    if ((await pathStep(interactive)) === "cancelled") {
+        return false;
+    }
+    writeInstallNote({
+        ...readInstallNote(paths),
+        setupAt: new Date().toISOString(),
+        version,
+        unattended: !process.stdout.isTTY,
+    }, paths);
+    p.log.info(CHROME_APP);
+    if (options.next) {
+        p.outro(options.next === "start"
+            ? "Setup is done. Starting engenty wizards…"
+            : `Setup is done. ${dim(`${cmd("help")} lists every command.`)}`);
+        return true;
+    }
+    await howToUse(paths);
+    return true;
+}

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

@@ -0,0 +1,276 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { createServer } from "node:net";
+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 { installedByScript, 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;
+/** 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);
+    const value = (key) => env[key]?.trim() || fileEnv[key]?.trim() || "";
+    return {
+        fileEnv,
+        dataDir: value("DATA_DIR") ? resolve(paths.home, value("DATA_DIR")) : paths.data,
+        port: Number(value("API_PORT")) || null,
+        appUrl: value("APP_URL").replace(/\/$/, ""),
+    };
+}
+/**
+ * The secret the runtime this command starts signs with, read the way it reads it (env.ts): its
+ * APP_SECRET, else the one it keeps in the data folder; null before it made one. The runtime
+ * never sees the terminal's APP_SECRET (cli/environment.ts), only its folder's `.env.local` and
+ * `.env`, so the terminal's is left out here too: a ticket signed with it would be refused.
+ */
+export function readSecret(paths, env = process.env) {
+    const { fileEnv, dataDir } = settings(paths, env);
+    const given = readEnvFile(join(paths.home, ".env.local")).APP_SECRET?.trim() || fileEnv.APP_SECRET?.trim();
+    if (given) {
+        return given;
+    }
+    try {
+        return readFileSync(join(dataDir, "secret"), "utf8").trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function healthy(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/api/health`, {
+            signal: AbortSignal.timeout(1500),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function portIsFree(port) {
+    return new Promise((done) => {
+        const probe = createServer();
+        probe.once("error", () => done(false));
+        probe.listen(port, "127.0.0.1", () => probe.close(() => done(true)));
+    });
+}
+/** The usual port, or the next free one after it. */
+async function freePort() {
+    for (let port = DEFAULT_PORT; port < DEFAULT_PORT + 20; port++) {
+        if (await portIsFree(port)) {
+            return port;
+        }
+    }
+    throw new Error(`No free port between ${DEFAULT_PORT} and ${DEFAULT_PORT + 19}.`);
+}
+/** The runtime that already runs on this install's data folder and answers. */
+export async function runningRuntime(dataDir) {
+    const running = readRunning(dataDir);
+    return running && (await healthy(running.port)) ? running : null;
+}
+/** A link that lets this browser into a running runtime: a ticket signed with the runtime's secret. */
+export function entryUrl(running, paths, env = process.env) {
+    const secret = readSecret(paths, env);
+    // No secret to be read here: the browser gets in if it was let in before.
+    return secret ? `${running.url}/api/local/enter?t=${mintLocalTicket(secret)}` : `${running.url}/`;
+}
+/** Opens an address in the person's browser; false when this machine has none to open it with. */
+export function openBrowser(url) {
+    const opener = process.platform === "darwin"
+        ? "open"
+        : process.env.DISPLAY || process.env.WAYLAND_DISPLAY
+            ? "xdg-open"
+            : null;
+    if (!opener || !findOnPath(opener, process.env.PATH ?? "")) {
+        return false;
+    }
+    try {
+        spawn(opener, [url], { stdio: "ignore", detached: true }).unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function show(url, entry, open) {
+    const opened = open && openBrowser(entry);
+    console.log("");
+    console.log(`  ${live} engenty wizards is running: ${cyan(url)}`);
+    if (opened) {
+        console.log(dim("    The studio opens in your browser."));
+    }
+    else {
+        console.log(`    Open the studio: ${cyan(entry)}`);
+        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>`. */
+function spawnCommand(paths, args, options) {
+    const wrapper = join(paths.bin, "wizards");
+    return existsSync(wrapper)
+        ? spawn(wrapper, args, options)
+        : spawn(process.execPath, [join(packageRoot, "bin/wizards.mjs"), ...args], options);
+}
+/**
+ * `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.
+ */
+export async function startInBackground(paths) {
+    const { dataDir } = settings(paths);
+    mkdirSync(paths.logs, { recursive: true });
+    const log = openSync(join(paths.logs, "runtime.log"), "a");
+    const child = spawnCommand(paths, ["start", "--no-open"], {
+        cwd: paths.home,
+        detached: true,
+        stdio: ["ignore", log, log],
+    });
+    let exited = false;
+    child.on("error", () => {
+        exited = true;
+    });
+    child.on("exit", () => {
+        exited = true;
+    });
+    child.unref();
+    const began = Date.now();
+    while (!exited && Date.now() - began < START_TIMEOUT_MS) {
+        await new Promise((wait) => setTimeout(wait, 300));
+        const started = await runningRuntime(dataDir);
+        if (started) {
+            return started;
+        }
+    }
+    return null;
+}
+/**
+ * Starts the runtime of this install and opens the studio: in the foreground, or with
+ * `background` detached from this terminal. If one already runs on the same data folder
+ * (another terminal, the desktop app), that one is opened instead.
+ */
+export async function start(paths, options) {
+    const { fileEnv, dataDir, port: wanted, appUrl } = settings(paths);
+    mkdirSync(dataDir, { recursive: true });
+    mkdirSync(paths.logs, { recursive: true });
+    const running = await runningRuntime(dataDir);
+    if (running) {
+        show(running.url, entryUrl(running, paths), options.open);
+        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) {
+            console.error(`engenty wizards didn’t start. Its log is in ${tilde(join(paths.logs, "runtime.log"))}.`);
+            return 1;
+        }
+        show(started.url, entryUrl(started, paths), options.open);
+        console.log(dim(`    It’s running in the background. To stop it: ${cmd("stop")}`));
+        console.log(dim(`    Its log is in ${tilde(join(paths.logs, "runtime.log"))}.`));
+        return 0;
+    }
+    const port = wanted ?? (await freePort());
+    if (!wanted && port !== DEFAULT_PORT) {
+        console.log(dim(`  Port ${DEFAULT_PORT} is taken, so it uses ${port}.`));
+    }
+    const accessKey = randomBytes(24).toString("hex");
+    const url = appUrl || `http://localhost:${port}`;
+    const child = spawn(process.execPath, [join(packageRoot, "apps/runtime/dist/index.js")], {
+        cwd: paths.home,
+        env: {
+            ...runtimeEnv(paths, { port, url, dataDir, accessKey }, process.env, fileEnv),
+            // This command starts it again when it exits with RESTART_EXIT.
+            ENGENTY_WIZARDS_RESTARTS: "1",
+        },
+        stdio: ["ignore", "inherit", "inherit"],
+    });
+    let current = child;
+    let exited = null;
+    const ended = new Promise((done) => {
+        child.on("error", (error) => {
+            console.error(`engenty wizards didn’t start: ${error.message}`);
+            exited = 1;
+            done(1);
+        });
+        child.on("exit", (code, signal) => {
+            exited = code ?? (signal ? 0 : 1);
+            done(exited);
+        });
+    });
+    // Ctrl-C reaches the runtime as well (same terminal); it closes its browser and its databases.
+    process.on("SIGINT", () => undefined);
+    process.on("SIGTERM", () => current.kill("SIGTERM"));
+    const began = Date.now();
+    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.");
+            return 1;
+        }
+        await new Promise((wait) => setTimeout(wait, 150));
+    }
+    if (exited !== null) {
+        return exited || 1;
+    }
+    show(url, `${url}/api/local/enter?k=${accessKey}`, options.open);
+    console.log(dim("    To stop it, press Ctrl-C."));
+    console.log("");
+    const code = await ended;
+    if (code !== RESTART_EXIT) {
+        return code;
+    }
+    // Updated or `wizards restart`: the command as it is on disk now starts it again, in this
+    // terminal or under the login item, which keeps waiting on this process.
+    console.log(dim("  Restarting…"));
+    current = spawnCommand(paths, ["start", "--no-open"], { stdio: "inherit" });
+    return new Promise((done) => {
+        current.on("error", () => done(1));
+        current.on("exit", (exit) => done(exit ?? 0));
+    });
+}
+/** `wizards studio`: opens the studio in the browser; when nothing runs, it starts as a service first. */
+export async function studio(paths) {
+    const { dataDir } = settings(paths);
+    const running = await runningRuntime(dataDir);
+    if (running) {
+        show(running.url, entryUrl(running, paths), true);
+        return 0;
+    }
+    return start(paths, { open: true, background: true });
+}
+/** `wizards open`: lets the browser into the runtime that runs. */
+export async function open(paths, print) {
+    const { dataDir } = settings(paths);
+    const running = await runningRuntime(dataDir);
+    if (!running) {
+        console.error(`engenty wizards isn’t running. To start it: ${cmd("start")}`);
+        return 1;
+    }
+    const entry = entryUrl(running, paths);
+    if (print || !openBrowser(entry)) {
+        console.log(entry);
+    }
+    return 0;
+}