@engenty/wizards-runtime 0.0.0-stage → 0.7.5

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

@@ -0,0 +1,50 @@
+import { defaultFeatures, FEATURE_NAME, parseFeatures, resolveFeatures, } from "@engenty-wizards/shared/features";
+import { declaredFeatures, featuresFile, fileFeatures, writeFeature } from "../features.js";
+import { discoverPlugins } from "../plugins/discovery.js";
+import { pluginDirs } from "../plugins/loader.js";
+import { proModulesDir } from "../plugins/pro-state.js";
+import { cmd, tilde } from "./ui.js";
+/**
+ * `wizards features` — the feature switches of this install, from its `.features` file. Not in
+ * the help: for whoever works on a part before it is on for everyone.
+ *
+ *   features                 what is on, and where that comes from
+ *   features <name> on|off   put a switch into the file
+ *   features <name> default  take it out again
+ */
+export function featuresCommand(args) {
+    const [name, value] = args;
+    const file = featuresFile();
+    if (!name) {
+        // The core's switches and those the plugins here declare, without loading them.
+        const found = discoverPlugins([...pluginDirs(), proModulesDir()]).found;
+        const declared = declaredFeatures(found);
+        const fromEnv = parseFeatures(process.env.FEATURES ?? "");
+        const fromFile = fileFeatures(file);
+        const all = resolveFeatures(defaultFeatures(declared), fromEnv, fromFile);
+        const names = [
+            ...new Set([...Object.keys(declared), ...Object.keys(fromEnv), ...Object.keys(fromFile)]),
+        ];
+        for (const n of names) {
+            const source = n in fromFile ? "file" : n in fromEnv ? "FEATURES" : "default";
+            const d = declared[n];
+            const kind = d ? d.kind : "?";
+            console.log(`${all[n] ? "on " : "off"}  ${n.padEnd(28)} ${kind.padEnd(8)} ${source.padEnd(9)} ${d?.label ?? ""}`);
+        }
+        console.log(`\nFile: ${tilde(file)}\nWhile engenty wizards runs, account and team switches apply on top of these.`);
+        return 0;
+    }
+    if (!FEATURE_NAME.test(name)) {
+        console.error(`“${name}” isn’t a valid switch name (e.g. teamPlans, contacts.leadScoring).`);
+        return 2;
+    }
+    if (value === "on" || value === "off" || value === "default") {
+        writeFeature(name, value === "default" ? null : value === "on", file);
+        console.log(value === "default"
+            ? `${name} follows the default again (${tilde(file)}). engenty wizards picks this up straight away.`
+            : `${name} is ${value} on this computer (${tilde(file)}). engenty wizards picks this up straight away.`);
+        return 0;
+    }
+    console.error(`Usage: ${cmd(`features ${name} on|off|default`)}`);
+    return 2;
+}

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

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Where a local install lives: `~/.engenty/wizards`, inside the folder the engenty framework
+ * keeps its own install in. `ENGENTY_HOME` moves both.
+ */
+export function wizardsHome(env = process.env) {
+    const base = env.ENGENTY_HOME?.trim() || join(homedir(), ".engenty");
+    return join(resolve(base), "wizards");
+}
+export function layout(home = wizardsHome()) {
+    return {
+        home,
+        data: join(home, "data"),
+        logs: join(home, "logs"),
+        envFile: join(home, ".env"),
+        installFile: join(home, "install.json"),
+        runtime: join(home, "runtime"),
+        tools: join(home, "tools"),
+        clients: join(home, "clients"),
+        bin: join(home, "bin"),
+        plugins: join(home, "plugins"),
+    };
+}
+/** The folder this code was installed to: it holds `apps/`, `plugin/` and package.json. */
+export const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../../..");
+let running;
+/**
+ * The version this process runs, read once: an update replaces package.json under a runtime that
+ * still runs the old code, and the studio reloads only when another version answers.
+ */
+export function packageVersion() {
+    if (running === undefined) {
+        try {
+            running =
+                JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")).version ?? "0.0.0";
+        }
+        catch {
+            running = "0.0.0";
+        }
+    }
+    return running ?? "0.0.0";
+}
+/** 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 {
+        // Node names this file by its real path; the home folder may be reached through a link.
+        return packageRoot.startsWith(realpathSync(paths.runtime) + sep);
+    }
+    catch {
+        return false;
+    }
+}
+/** This copy is a checkout of the repository, run with `pnpm wizards`. */
+export function isCheckout() {
+    return existsSync(join(packageRoot, "pnpm-workspace.yaml"));
+}
+/** How this install is started, as the person types it. */
+export const command = () => installedByScript() ? "wizards" : isCheckout() ? "pnpm wizards" : "npx wizards";
+export function readInstallNote(paths = layout()) {
+    try {
+        return JSON.parse(readFileSync(paths.installFile, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeInstallNote(note, paths = layout()) {
+    // A checkout or npx has no install folder until something writes into it.
+    mkdirSync(dirname(paths.installFile), { recursive: true });
+    writeFileSync(paths.installFile, `${JSON.stringify(note, null, 2)}\n`);
+}
+/** `KEY=value` lines of the install's `.env`, the way the runtime reads them. */
+export function readEnvFile(file) {
+    const out = {};
+    if (!existsSync(file)) {
+        return out;
+    }
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        const match = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+        if (match) {
+            out[match[1]] = match[2].replace(/^(['"])(.*)\1$/, "$2");
+        }
+    }
+    return out;
+}

package/apps/runtime/dist/cli/install-env.js

@@ -0,0 +1,33 @@
+import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { layout, readEnvFile } from "./home.js";
+/**
+ * Imported first by the command: before the runtime's modules load, this process sees the
+ * install the way its runtime does. env.ts reads the process once, when it is first imported,
+ * and `.env` from the working directory; the runtime starts in the install's folder (start.ts)
+ * and so reads the install's `.env`, with its data folder beside it. The command goes there
+ * too — else `wizards account` or `wizards status` from another folder would open a `data/`
+ * of its own there, with a secret of its own, and a vault the runtime cannot read.
+ *
+ * What the terminal exports for other projects never reaches the runtime (environment.ts); a
+ * few keys that would make this process another runtime are taken from the install's `.env`
+ * alone. The rest the runtime inherits, so the terminal's word stands.
+ */
+const paths = layout();
+const fileEnv = readEnvFile(paths.envFile);
+/** The install's data folder, as start.ts hands it to the runtime: the terminal's word first. */
+const given = process.env.DATA_DIR?.trim() || fileEnv.DATA_DIR?.trim();
+process.env.DATA_DIR = given ? resolve(paths.home, given) : paths.data;
+for (const key of ["MANAGE_URL", "APP_SECRET", "DATABASE_URL", "DATABASE_AUTH_TOKEN"]) {
+    process.env[key] = fileEnv[key] ?? "";
+}
+// Keys and the account's sign-in live in the Keychain on a Mac, as the runtime keeps them.
+if (process.platform === "darwin" &&
+    process.env.SECRETS === undefined &&
+    fileEnv.SECRETS === undefined) {
+    process.env.SECRETS = "keychain";
+}
+/** Where the command was typed: `wizards validate ./my.wizard` means a path from there. */
+export const startedIn = process.cwd();
+mkdirSync(paths.home, { recursive: true });
+process.chdir(paths.home);

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

@@ -0,0 +1,107 @@
+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";
+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 = [
+    {
+        id: "codex",
+        name: "Codex",
+        bin: "codex",
+        account: "ChatGPT",
+        install: { kind: "npm", pkg: "@openai/codex" },
+        app: "ChatGPT",
+    },
+    {
+        id: "claude",
+        name: "Claude Code",
+        bin: "claude",
+        account: "Claude",
+        install: { kind: "script", url: "https://claude.ai/install.sh" },
+        app: "Claude",
+    },
+    {
+        id: "antigravity",
+        name: "Antigravity",
+        bin: "agy",
+        account: "Google AI",
+        install: { kind: "script", url: "https://antigravity.google/cli/install.sh" },
+        app: "Antigravity",
+    },
+    {
+        id: "cursor",
+        name: "Cursor Agent",
+        bin: "cursor-agent",
+        account: "Cursor",
+        install: { kind: "script", url: "https://cursor.com/install" },
+        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 = APP_ROOTS) {
+    if (process.platform !== "darwin" || !client.app) {
+        return 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 —
+ * its subscription is most likely already paid for — else the first.
+ */
+export function suggestedClient(missing) {
+    return missing.find((state) => vendorApp(state.client)) ?? missing[0] ?? null;
+}
+/** The first file of that name on a PATH that may be run. */
+/** What a command prints for `--version`: its last word that looks like one. */
+async function versionOf(file, path) {
+    try {
+        const { stdout } = await run(file, ["--version"], {
+            timeout: 10_000,
+            env: { ...process.env, PATH: path, TERM: "dumb" },
+        });
+        const line = stdout.trim().split("\n").pop()?.trim() ?? "";
+        return line.match(/\d+\.\d+[\w.+-]*/)?.[0] ?? (line || null);
+    }
+    catch {
+        return null;
+    }
+}
+export async function detectClients(paths) {
+    const path = runtimePath(paths, process.env);
+    return Promise.all(CLIENTS.map(async (client) => {
+        const file = findOnPath(client.bin, path);
+        // A file that does not answer `--version` is not a client we can run.
+        const version = file ? await versionOf(file, path) : null;
+        return { client, path: version ? file : null, version };
+    }));
+}
+export async function findFfmpeg(env = process.env) {
+    const path = env.PATH ?? "";
+    const file = env.FFMPEG_PATH || findOnPath("ffmpeg", path);
+    if (!file) {
+        return { path: null, version: null };
+    }
+    try {
+        const { stdout } = await run(file, ["-version"], { timeout: 10_000 });
+        return { path: file, version: stdout.match(/ffmpeg version (\S+)/)?.[1] ?? null };
+    }
+    catch {
+        return { path: null, version: null };
+    }
+}
+/** Node 24.11 or newer: what the runtime is built for. */
+export function nodeIsCurrent(version = process.versions.node) {
+    const [major, minor] = version.split(".").map(Number);
+    return major > 24 || (major === 24 && minor >= 11);
+}

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

@@ -0,0 +1,222 @@
+import "./install-env.js";
+import { accountCommand } from "./account.js";
+import { apps, connectCommand } from "./connect.js";
+import { featuresCommand } from "./features.js";
+import { command, layout, packageVersion, readInstallNote } from "./home.js";
+import { startedIn } from "./install-env.js";
+import { CLIENTS, nodeIsCurrent } from "./machine.js";
+import { mcp } from "./mcp.js";
+import { menu } from "./menu.js";
+import { logsCommand, reportCommand } from "./report.js";
+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 { 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}`;
+const more = (what) => `  ${" ".repeat(command().length + 12)}${what}`;
+const HELP = `engenty wizards ${packageVersion()}
+engenty wizards runs the studio and your wizards on this computer. Below, “it” means engenty wizards.
+
+Usage
+  ${command()} [command] [options]
+
+Commands
+${line(command(), "show the status and a menu (start, stop, update…); runs the setup the first time")}
+${more("(needs a terminal)")}
+${line(`${command()} start`, "start it in this terminal and open the studio (Ctrl-C stops it)")}
+${line(`${command()} studio`, "open the studio, starting it in the background if needed")}
+${line(`${command()} setup`, "set up your engenty account, an AI client, ffmpeg and start at login")}
+${line(`${command()} account`, "show your engenty account; add sign-in or sign-out to change it")}
+${line(`${command()} open`, "sign this browser in to the running studio (--print: only print the link)")}
+${line(`${command()} status`, "show what’s installed and running")}
+${line(`${command()} doctor`, "show the status and check for problems")}
+${line(`${command()} logs`, `print the last log lines (${command()} logs 500 for more)`)}
+${line(`${command()} report`, "send the status, model settings and last log lines to your account for support")}
+${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()} 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())
+    .map((app) => app.id)
+    .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.")}
+
+Options
+  --yes, -y           don’t ask; skip everything optional
+  --local             set up without an account; nothing leaves this computer
+  --client <name>     install this AI client without asking: ${CLIENTS.map((c) => c.id).join(", ")}
+  --no-open           start without opening the browser
+  --background, -s    start in the background, detached from this terminal (${command()} stop stops it)
+  --version, -v       print the version
+  --help, -h          print this help
+
+Everything lives in ${tilde(layout().home)} (ENGENTY_HOME moves it). Settings go in its .env file.
+`;
+/** After a mistake on the command line: one line, not the whole help. */
+const SEE_HELP = `Run ${cmd("help")} to see every command.`;
+function parse(argv) {
+    const args = {
+        command: "",
+        value: "",
+        apps: [],
+        paths: [],
+        json: false,
+        yes: false,
+        local: false,
+        open: true,
+        service: false,
+        print: false,
+        clients: [],
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--yes" || arg === "-y") {
+            args.yes = true;
+        }
+        else if (arg === "--local") {
+            args.local = true;
+        }
+        else if (arg === "--no-open") {
+            args.open = false;
+        }
+        else if (arg === "--background" || arg === "--service" || arg === "-s") {
+            args.service = true;
+        }
+        else if (arg === "--print") {
+            args.print = true;
+        }
+        else if (arg === "--json") {
+            args.json = true;
+        }
+        else if (arg === "--client") {
+            const id = argv[++i];
+            if (!CLIENTS.some((client) => client.id === id)) {
+                return `--client takes one of these: ${CLIENTS.map((c) => c.id).join(", ")}.`;
+            }
+            args.clients.push(id);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            args.command = "help";
+        }
+        else if (arg === "--version" || arg === "-v") {
+            args.command = "version";
+        }
+        else if (arg.startsWith("-")) {
+            return `Unknown option ${arg}.`;
+        }
+        else if (["autostart", "autoupdate", "logs", "account"].includes(args.command) &&
+            !args.value) {
+            args.value = arg;
+        }
+        else if (["connect", "disconnect", "features"].includes(args.command)) {
+            args.apps.push(arg);
+        }
+        else if (args.command === "validate") {
+            args.paths.push(arg);
+        }
+        else if (args.command) {
+            return `Unexpected argument “${arg}”.`;
+        }
+        else {
+            args.command = arg;
+        }
+    }
+    return args;
+}
+async function main(argv) {
+    const args = parse(argv);
+    if (typeof args === "string") {
+        console.error(`${args} ${SEE_HELP}`);
+        return 2;
+    }
+    const paths = layout();
+    const setupOptions = { yes: args.yes, clients: args.clients, local: args.local };
+    if (!args.command) {
+        // Without a command: the menu, which needs a terminal. Starting is \`start\`.
+        if (args.service || !args.open || args.print) {
+            console.error(`Those options belong to start: ${cmd(`start ${argv.join(" ")}`)}`);
+            return 2;
+        }
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error(`The menu needs a terminal. To start engenty wizards: ${cmd("start")}\n\n${HELP}`);
+            return 2;
+        }
+        return menu(paths, setupOptions, HELP);
+    }
+    switch (args.command) {
+        case "help":
+            console.log(HELP);
+            return 0;
+        case "version":
+            console.log(packageVersion());
+            return 0;
+        case "start": {
+            // The first start on a terminal begins with the setup.
+            const first = !readInstallNote(paths).setupAt;
+            if (first && !args.yes && process.stdin.isTTY && process.stdout.isTTY) {
+                // You asked to start it: once the setup is done, it starts.
+                if (!(await setup(paths, { ...setupOptions, next: "start" }))) {
+                    return 130;
+                }
+            }
+            return start(paths, { open: args.open, background: args.service });
+        }
+        case "setup":
+            return (await setup(paths, setupOptions)) ? 0 : 130;
+        case "studio":
+            return studio(paths);
+        case "open":
+            return open(paths, args.print);
+        case "status":
+            return status(paths, false);
+        case "doctor":
+            return status(paths, true);
+        case "logs":
+            return logsCommand(paths, args.value);
+        case "report":
+            return reportCommand(paths);
+        case "stop":
+            return stop(paths);
+        case "restart":
+            return restart(paths);
+        case "update":
+            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":
+        case "disconnect":
+            return connectCommand(paths, args.apps, args.command === "disconnect");
+        case "mcp":
+            return mcp(paths);
+        case "features":
+            return featuresCommand(args.apps);
+        case "validate":
+            // The paths are the person's, from where they typed the command (install-env.ts).
+            process.chdir(startedIn);
+            return validateCommand(args.paths, args.json);
+        default:
+            console.error(`Unknown command “${args.command}”. ${SEE_HELP}`);
+            return 2;
+    }
+}
+if (!nodeIsCurrent()) {
+    console.error(`engenty wizards needs Node.js 24.11 or newer. This is ${process.version}.`);
+    process.exit(1);
+}
+process.exitCode = await main(process.argv.slice(2));

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

@@ -0,0 +1,136 @@
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { LOCAL_CLIENT_HEADER, LOCAL_MCP_HEADER, mintLocalTicket } from "../auth/local-ticket.js";
+import { readSecret, runningRuntime, settings, startInBackground } from "./start.js";
+import { tilde } from "./ui.js";
+/** The JSON-RPC messages of a response: a JSON body (one or a batch) or a server-sent stream. */
+export function messagesOf(contentType, body) {
+    if (!body.trim()) {
+        return [];
+    }
+    if (contentType.includes("text/event-stream")) {
+        const out = [];
+        for (const event of body.split(/\r?\n\r?\n/)) {
+            const data = event
+                .split(/\r?\n/)
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => line.slice(5).replace(/^ /, ""))
+                .join("\n");
+            if (data.trim()) {
+                out.push(JSON.parse(data));
+            }
+        }
+        return out;
+    }
+    const parsed = JSON.parse(body);
+    return Array.isArray(parsed) ? parsed : [parsed];
+}
+export async function mcp(paths) {
+    const { dataDir } = settings(paths);
+    let running = null;
+    let clientName = "";
+    let protocolVersion = "";
+    const runtime = () => {
+        running ??= (async () => {
+            const found = await runningRuntime(dataDir);
+            if (found) {
+                return found;
+            }
+            process.stderr.write("engenty wizards isn’t running. Starting it…\n");
+            const started = await startInBackground(paths);
+            if (started) {
+                return started;
+            }
+            throw new Error(`engenty wizards didn’t start. Its log is in ${tilde(join(paths.logs, "runtime.log"))}.`);
+        })();
+        running.catch(() => {
+            running = null;
+        });
+        return running;
+    };
+    const post = async (message) => {
+        const at = await runtime();
+        const secret = readSecret(paths);
+        if (!secret) {
+            throw new Error("No secret in the data folder yet. Start engenty wizards once first.");
+        }
+        const response = await fetch(`http://127.0.0.1:${at.port}/api/mcp`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                accept: "application/json, text/event-stream",
+                [LOCAL_MCP_HEADER]: mintLocalTicket(secret, Date.now(), "local-mcp"),
+                ...(clientName ? { [LOCAL_CLIENT_HEADER]: clientName } : {}),
+                ...(protocolVersion ? { "mcp-protocol-version": protocolVersion } : {}),
+            },
+            body: JSON.stringify(message),
+        });
+        const body = await response.text();
+        if (!response.ok && response.status !== 202) {
+            throw new Error(`engenty wizards responded with ${response.status}: ${body.slice(0, 300)}`);
+        }
+        return messagesOf(response.headers.get("content-type") ?? "", body);
+    };
+    const write = (message) => {
+        process.stdout.write(`${JSON.stringify(message)}\n`);
+    };
+    const handle = async (message) => {
+        if (message.method === "initialize") {
+            const info = message.params?.clientInfo;
+            clientName = info?.title || info?.name || "";
+        }
+        let answers;
+        try {
+            answers = await post(message);
+        }
+        catch (error) {
+            // The runtime went away (stopped, restarted on another port): once more, with a fresh look.
+            running = null;
+            try {
+                answers = await post(message);
+            }
+            catch {
+                if (message.id !== undefined && message.method) {
+                    write({
+                        jsonrpc: "2.0",
+                        id: message.id,
+                        error: { code: -32603, message: error.message },
+                    });
+                }
+                process.stderr.write(`${error.message}\n`);
+                return;
+            }
+        }
+        for (const answer of answers) {
+            const version = answer.result?.protocolVersion;
+            if (message.method === "initialize" && typeof version === "string") {
+                protocolVersion = version;
+            }
+            write(answer);
+        }
+    };
+    const pending = new Set();
+    const lines = createInterface({ input: process.stdin, crlfDelay: Number.POSITIVE_INFINITY });
+    for await (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            write({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            continue;
+        }
+        // Requests are answered as they finish: a long get_run never holds up the next call.
+        const job = handle(message).finally(() => pending.delete(job));
+        pending.add(job);
+    }
+    await Promise.all(pending);
+    return 0;
+}