@engenty/wizards-runtime 0.0.0-stage → 0.7.6

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

@@ -0,0 +1,202 @@
+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 { autostartForStatus, setAutostart } from "./autostart.js";
+import { connectCommand } from "./connect.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";
+import { badge, busy, cmd, cyan, dim, no, ok } from "./ui.js";
+import { update } from "./update.js";
+async function look(paths) {
+    const { dataDir } = settings(paths);
+    const [running, atLogin, release, account] = await Promise.all([
+        runningRuntime(dataDir),
+        autostartForStatus(paths),
+        updateStatus().catch(() => null),
+        accountState(),
+    ]);
+    return { running, atLogin, release, account };
+}
+function report({ running, atLogin, release, account }) {
+    const lines = [
+        running
+            ? `${ok} running  ${cyan(running.url)} ${dim(`pid ${running.pid}, since ${new Date(running.startedAt).toLocaleString()}`)}`
+            : `${no} not running`,
+    ];
+    if (!("unavailable" in atLogin)) {
+        lines.push(atLogin.on ? `${ok} starts at login` : `${no} doesn’t start at login`);
+    }
+    lines.push(account.kind === "linked"
+        ? `${ok} signed in as ${describeAccount(account)}`
+        : `${no} ${describeAccount(account)}`);
+    if (release?.newer) {
+        lines.push(`${cyan("↑")} ${release.latest} is out ${dim(`(you have ${release.current})`)}`);
+    }
+    return lines.join("\n");
+}
+function choices({ running, atLogin, release, account }) {
+    const options = running
+        ? [
+            { value: "open", label: "Open the studio", hint: "in your browser" },
+            { value: "restart", label: "Restart" },
+            { value: "stop", label: "Stop", hint: "your data is kept" },
+        ]
+        : [
+            { value: "start", label: "Start in the background", hint: "and open the studio" },
+            { value: "foreground", label: "Start in this terminal", hint: "Ctrl-C stops it" },
+        ];
+    options.push({
+        value: "update",
+        label: "Update",
+        hint: release?.newer ? `${release.latest} is out` : release?.latest ? "up to date" : undefined,
+    });
+    if (!("unavailable" in atLogin)) {
+        options.push({
+            value: "service",
+            label: "Start at login",
+            hint: atLogin.on ? "on" : "off",
+        });
+    }
+    options.push({
+        value: "connect",
+        label: "Connect AI apps",
+        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: "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. */
+async function serviceSettings(paths, atLogin) {
+    if ("unavailable" in atLogin) {
+        return;
+    }
+    const on = await p.select({
+        message: "Start at login?",
+        initialValue: atLogin.on,
+        options: [
+            {
+                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" },
+        ],
+    });
+    if (p.isCancel(on) || on === atLogin.on) {
+        return;
+    }
+    try {
+        await setAutostart(paths, on);
+    }
+    catch (error) {
+        p.log.warn(`Couldn’t change start at login: ${error.message}`);
+    }
+}
+/** The commands used most, for when the menu ends. */
+function commands() {
+    const name = command();
+    return [
+        [`${name} start`, "start engenty wizards and open the studio"],
+        [`${name} studio`, "open the studio, starting engenty wizards if needed"],
+        [`${name} stop`, "stop engenty wizards (your data is kept)"],
+        [`${name} status`, "show what’s installed and running"],
+        [`${name} update`, "install the latest version"],
+        [`${name} --version`, "print the version you have"],
+        [`${name} help`, "list every command"],
+    ]
+        .map(([line, what]) => `${cyan(line.padEnd(name.length + 12))}${dim(what)}`)
+        .join("\n");
+}
+/**
+ * `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 in this terminal" ends it with the runtime in the
+ * foreground.
+ */
+export async function menu(paths, setupOptions, help) {
+    if (!readInstallNote(paths).setupAt) {
+        if (!(await setup(paths, { ...setupOptions, next: "menu" }))) {
+            return 130;
+        }
+    }
+    p.intro(`${badge("engenty wizards")} ${dim(packageVersion())}`);
+    for (;;) {
+        const spinner = busy("Checking status…");
+        const state = await look(paths);
+        spinner.stop(report(state));
+        const action = await p.select({
+            message: "What would you like to do?",
+            options: choices(state),
+        });
+        if (p.isCancel(action) || action === "quit") {
+            p.outro(dim(`${cmd()} opens this menu again. ${cmd("help")} lists every command.`));
+            return 0;
+        }
+        switch (action) {
+            case "start":
+                await start(paths, { open: true, background: true });
+                break;
+            case "foreground":
+                p.outro("Starting engenty wizards here…");
+                return start(paths, { open: true });
+            case "open":
+                await open(paths, false);
+                break;
+            case "restart":
+                await restart(paths);
+                break;
+            case "stop":
+                await stop(paths);
+                break;
+            case "update": {
+                // What runs restarts into the new version.
+                if ((await update(paths, { restart: true })) !== 0) {
+                    break;
+                }
+                // This menu is still the old version, so it ends here.
+                p.note(commands(), "Updated");
+                p.outro(dim(`${cmd()} opens this menu again, in the new version.`));
+                return 0;
+            }
+            case "service":
+                await serviceSettings(paths, state.atLogin);
+                break;
+            case "connect":
+                await connectCommand(paths, [], false);
+                break;
+            case "account":
+                await accountMenu(paths);
+                break;
+            case "status":
+                await status(paths, true);
+                break;
+            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/report.js

@@ -0,0 +1,66 @@
+import { join } from "node:path";
+import { LOCAL_MCP_HEADER, mintLocalTicket } from "../auth/local-ticket.js";
+import { readSecret, runningRuntime, settings } from "./start.js";
+import { bad, cmd, dim, ok, tilde } from "./ui.js";
+/**
+ * `wizards logs` shows the last lines the running runtime printed; `wizards report` sends its
+ * status, model settings and those lines to the linked account, where an operator reads them
+ * (docs/plans/remote-debug.md). Both talk to the running process, signed with the data folder's
+ * secret as `wizards mcp` does; neither sends anything by itself.
+ */
+async function ask(paths, method, path) {
+    const { dataDir } = settings(paths);
+    const running = await runningRuntime(dataDir);
+    if (!running) {
+        return `engenty wizards isn’t running. To start it: ${cmd("start")}`;
+    }
+    const secret = readSecret(paths);
+    if (!secret) {
+        return `Couldn’t read the data folder’s secret (${tilde(join(dataDir, "secret"))}).`;
+    }
+    const res = await fetch(`http://127.0.0.1:${running.port}/api/local/debug${path}`, {
+        method,
+        headers: { [LOCAL_MCP_HEADER]: mintLocalTicket(secret, Date.now(), "local-debug") },
+        signal: AbortSignal.timeout(30_000),
+    });
+    return {
+        status: res.status,
+        body: (await res.json().catch(() => ({}))),
+    };
+}
+/** The last lines of the running runtime; `value` may name how many (default 100). */
+export async function logsCommand(paths, value) {
+    const limit = Math.min(Math.max(1, Number(value) || 100), 2000);
+    const answer = await ask(paths, "GET", `/logs?limit=${limit}`);
+    if (typeof answer === "string") {
+        console.error(answer);
+        return 1;
+    }
+    const lines = answer.body.lines ?? [];
+    for (const line of lines) {
+        const at = new Date(line.at).toISOString().slice(11, 19);
+        const level = line.level === "info" ? "     " : line.level.padEnd(5);
+        console.log(`${dim(at)} ${level} ${line.text}`);
+    }
+    if (!lines.length) {
+        console.log(dim("No log lines yet."));
+    }
+    return 0;
+}
+export async function reportCommand(paths) {
+    const answer = await ask(paths, "POST", "/report");
+    if (typeof answer === "string") {
+        console.error(answer);
+        return 1;
+    }
+    if (answer.status === 409) {
+        console.error(`${bad} This computer isn’t connected to an account. Sign in under Settings → Account in the studio, or with ${cmd("account sign-in")}. Then try again.`);
+        return 1;
+    }
+    if (answer.status !== 200) {
+        console.error(`${bad} ${answer.body.error ?? `engenty wizards responded with an error (${answer.status}).`}`);
+        return 1;
+    }
+    console.log(`${ok} Sent report ${answer.body.id} to ${answer.body.to}. Quote this ID when you ask for help.`);
+    return 0;
+}

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

@@ -0,0 +1,77 @@
+import { delimiter, dirname, join } from "node:path";
+import { ENGINE_PACKAGES, engineList, installEngine, installedVersion, removeEngine, } from "../sandbox/install.js";
+import { runtimePath } from "./environment.js";
+import { runLogged } from "./exec.js";
+import { findOnPath } from "./machine.js";
+import { busy, cmd, no, ok, tilde } from "./ui.js";
+/** What `sandbox add` installs when no engine is named. */
+const DEFAULT_ENGINE = "agentos";
+/** Where an engine goes: `SANDBOX_ENGINES_DIR/<name>`, else `engines/<name>` in the install's folder. */
+export const engineDirOf = (paths, name) => join(process.env.SANDBOX_ENGINES_DIR?.trim() || join(paths.home, "engines"), name);
+/** The engines installed here, with their versions and the versions this release installs. */
+export function installedEngines(paths) {
+    return Object.entries(ENGINE_PACKAGES).flatMap(([name, engine]) => {
+        const version = installedVersion(engineDirOf(paths, name));
+        return version ? [{ name, label: engine.label, version, current: engine.version }] : [];
+    });
+}
+/**
+ * `wizards sandbox [add|remove] [engine]`: the sandbox where AI steps run code, without Docker.
+ * The engines are not part of engenty wizards; `add` downloads one beside the install.
+ */
+export async function sandboxCommand(paths, value, engine = "") {
+    const name = engine.toLowerCase() || DEFAULT_ENGINE;
+    if ((value === "add" || value === "remove") && !ENGINE_PACKAGES[name]) {
+        console.error(`${no} There is no engine “${name}”. ${engineList()}`);
+        return 2;
+    }
+    if (value === "add") {
+        return add(paths, name);
+    }
+    if (value === "remove") {
+        removeEngine(engineDirOf(paths, name));
+        console.log(`${ok} The sandbox ${ENGINE_PACKAGES[name].label} is removed. It goes away with the next ${cmd("restart")}.`);
+        return 0;
+    }
+    if (value) {
+        console.error(`Use ${cmd("sandbox add")} or ${cmd("sandbox remove")}.`);
+        return 2;
+    }
+    const installed = installedEngines(paths);
+    if (!installed.length) {
+        console.log(`${no} No sandbox is installed. AI steps can’t run code unless Docker has the engenty-sandbox image. To add one: ${cmd("sandbox add")}`);
+        return 0;
+    }
+    for (const { name, label, version } of installed) {
+        console.log(`${ok} The sandbox ${label} ${version} is in ${tilde(engineDirOf(paths, name))}.`);
+    }
+    console.log(`AI steps run code in ${installed.length === 1 ? "it" : "the first one"}, unless Docker has the engenty-sandbox image or SANDBOX names an engine.`);
+    return 0;
+}
+async function add(paths, name) {
+    const engine = ENGINE_PACKAGES[name];
+    const unsupported = engine.unsupported?.();
+    if (unsupported) {
+        console.error(`${no} ${unsupported}`);
+        return 1;
+    }
+    const npm = findOnPath("npm", [dirname(process.execPath), process.env.PATH ?? ""].join(delimiter));
+    if (!npm) {
+        console.error(`${no} npm wasn’t found next to this Node.js.`);
+        return 1;
+    }
+    const env = { ...process.env, PATH: runtimePath(paths, process.env) };
+    const logFile = join(paths.logs, "install.log");
+    const dir = engineDirOf(paths, name);
+    const spinner = busy(`Installing the sandbox (${engine.label} ${engine.version}, ${engine.size})…`);
+    try {
+        await installEngine(name, dir, (args) => runLogged(npm, args, { env, logFile }));
+    }
+    catch (err) {
+        spinner.fail(`The sandbox couldn’t be installed: ${err.message}`);
+        return 1;
+    }
+    spinner.stop(`${ok} The sandbox is installed in ${tilde(dir)}.`);
+    console.log(`AI steps run code in it from the next start: ${cmd("restart")}`);
+    return 0;
+}