rpg-engine 0.0.0-stage → 0.1.1

package/dist/pictures/claude.js

@@ -0,0 +1,129 @@
+// Claude draws the pictures as SVG where Codex cannot (D-342, D-390): Claude Code with the player's Claude login, never an API key, in an empty folder of its
+// own without tools, settings, memory or a session kept; its SVG cleaned before the engine takes it. Three minutes at most; a refusal never tried again.
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { svgBrief } from "./briefs.js";
+import { helperChanges, helperEnvironment, helperState } from "./helpers.js";
+import { stopTree } from "./stop.js";
+import { cleanSvg, svgIn } from "./svg.js";
+// How long a picture may take before the engine gives it up: the probe's took 18 to 74 seconds.
+const longest = 3 * 60 * 1000;
+// Claude Code without the chat's own settings, tools, memory or session: only the brief, and the SVG as its answer.
+const drawing = (claude) => `${claude} -p --model sonnet --effort low --output-format json --tools "" --setting-sources "" --strict-mcp-config --no-session-persistence `
+    + `--disable-slash-commands --max-budget-usd 0.5 --system-prompt "You draw pictures as SVG code from a brief. You reply with the SVG alone."`;
+// Claude Code as a writer of text (D-406): Sonnet at low effort, with nothing but the brief.
+const writing = (claude) => `${claude} -p --model sonnet --effort low --output-format json --tools "" --setting-sources "" --strict-mcp-config --no-session-persistence `
+    + `--disable-slash-commands --max-budget-usd 0.5 --system-prompt "You write what a brief asks, and only that."`;
+/** Claude Code on this computer as a writer of text (D-406): ready where the player's Claude login lets it draw too. */
+export function claudeWriter(maker = claudePictures()) {
+    return { ready: () => maker.ready().ready, write };
+}
+/** Why Claude draws no pictures, for the master and the player (D-390). */
+export const claudeSays = {
+    loggedOut: { why: "Claude Code is not logged in on this computer" },
+    apiKey: { why: "Claude Code uses an API key, which pays by the call: pictures are drawn only with the Claude login" },
+};
+// How Claude Code is started, as the last look found it: by name on the PATH, or by its full path in the engine's folder (D-425).
+let claude = "claude";
+/** Claude Code on this computer, as the player's Claude login lets it draw pictures. */
+export function claudePictures() {
+    let known;
+    return {
+        ready: (again) => {
+            const late = again === true && Date.now() - (known?.at ?? 0) > 60_000;
+            if (known === undefined || (!known.said.ready && (late || known.changes !== helperChanges()))) {
+                known = { said: claudeReady(), at: Date.now(), changes: helperChanges() };
+            }
+            return known.said;
+        },
+        make,
+    };
+}
+/** Whether Claude Code is there and logged in with the player's Claude plan: asked in a moment, without spending anything. */
+function claudeReady() {
+    const { state, line } = helperState("claude");
+    claude = line ?? "claude";
+    if (state === "missing" || state === "logged out") {
+        return { ready: false, ...claudeSays.loggedOut };
+    }
+    return state === "ready" ? { ready: true, maker: "Claude" } : { ready: false, ...claudeSays.apiKey };
+}
+/** One SVG picture: Claude Code in an empty folder of its own, the brief on its input, its answer read, cleaned and written there. */
+function make(subject) {
+    const folder = mkdtempSync(join(tmpdir(), "rpg-picture-"));
+    const clean = () => rmSync(folder, { recursive: true, force: true });
+    return new Promise((done) => {
+        const child = spawn(drawing(claude), { shell: true, windowsHide: true, cwd: folder, env: helperEnvironment("claude"), stdio: ["pipe", "pipe", "pipe"] });
+        let output = "";
+        let errors = "";
+        let settled = false;
+        // Out of time, the drawing goes whole and the answer is given at once; what comes after counts for nothing.
+        const timer = setTimeout(() => {
+            settled = true;
+            stopTree(child);
+            clean();
+            done({ refused: "no picture came in three minutes" });
+        }, longest);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => (output += chunk));
+        child.stderr.on("data", (chunk) => (errors += chunk));
+        child.stdin.on("error", () => undefined);
+        child.on("error", () => undefined);
+        child.on("close", () => {
+            clearTimeout(timer);
+            if (settled) {
+                return;
+            }
+            const answer = parsed(output);
+            const svg = answer?.is_error === true || typeof answer?.result !== "string" ? undefined : cleanSvg(svgIn(answer.result) ?? "");
+            if (svg === undefined) {
+                clean();
+                done({ refused: refusal(answer, errors) });
+                return;
+            }
+            const file = join(folder, "picture.svg");
+            writeFileSync(file, svg);
+            done({ file, done: clean });
+        });
+        child.stdin.end(svgBrief(subject));
+    });
+}
+/** Claude's answer to a brief, in an empty folder of its own; none when it failed or gave none in time. */
+function write(brief) {
+    const folder = mkdtempSync(join(tmpdir(), "rpg-writing-"));
+    return new Promise((done) => {
+        const child = spawn(writing(claude), { shell: true, windowsHide: true, cwd: folder, env: helperEnvironment("claude"), stdio: ["pipe", "pipe", "ignore"] });
+        let output = "";
+        const timer = setTimeout(() => stopTree(child), longest);
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => (output += chunk));
+        child.stdin.on("error", () => undefined);
+        child.on("error", () => undefined);
+        child.on("close", () => {
+            clearTimeout(timer);
+            rmSync(folder, { recursive: true, force: true });
+            const answer = parsed(output);
+            done(answer?.is_error === true || typeof answer?.result !== "string" ? undefined : answer.result);
+        });
+        child.stdin.end(brief);
+    });
+}
+/** Why no picture came: Claude's own error, a drawing that could not be used, or what Claude Code said as it stopped. */
+function refusal(answer, errors) {
+    if (answer === undefined) {
+        const said = errors.trim().split("\n").at(-1)?.trim() ?? "";
+        return said === "" ? "Claude Code stopped without an answer" : `Claude Code said: ${said}`;
+    }
+    return answer.is_error === true ? `Claude failed: ${String(answer.result)}` : "Claude drew no picture that could be used";
+}
+function parsed(output) {
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/pictures/codex.d.ts

@@ -0,0 +1,20 @@
+import type { PictureMaker, TextWriter } from "../core/context.ts";
+/** Why Codex makes no pictures, for the master, and how the player has them, which the dashboard writes in its language (D-308). */
+export declare const codexSays: {
+    missing: {
+        why: string;
+        fix: string;
+    };
+    loggedOut: {
+        why: string;
+        fix: string;
+    };
+    apiKey: {
+        why: string;
+        fix: string;
+    };
+};
+/** Codex on this computer, as the player's ChatGPT login lets it make pictures. */
+export declare function codexPictures(): PictureMaker;
+/** Codex on this computer as a writer of text (D-406): ready where its ChatGPT login makes pictures too. */
+export declare function codexWriter(maker?: PictureMaker): TextWriter;

package/dist/pictures/codex.js

@@ -0,0 +1,154 @@
+// Codex makes the pictures (D-308): only when the player is logged in with ChatGPT, never with an API key, which pays by the picture. It runs in an empty folder of
+// its own, so that it never reads the campaign; the picture it makes stays in its own folder, from which the engine takes it. Three minutes at most; a refusal is
+// never tried again, as it costs all the same.
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { paintedBrief } from "./briefs.js";
+import { helperChanges, helperEnvironment, helperState } from "./helpers.js";
+import { stopTree } from "./stop.js";
+// How long a picture may take before the engine gives it up (D-308): the probe's took 31 to 45 seconds.
+const longest = 3 * 60 * 1000;
+/** Why Codex makes no pictures, for the master, and how the player has them, which the dashboard writes in its language (D-308). */
+export const codexSays = {
+    missing: {
+        why: "Codex is not installed on this computer",
+        fix: "Pictures need Codex, which is not on this computer yet. To have them:\n"
+            + "1. Open a terminal: on Windows, Start, then type Terminal.\n"
+            + "2. Paste `npm install -g @openai/codex` and press Enter.\n"
+            + "3. Paste `codex login` and sign in with your ChatGPT account in the browser that opens.\n"
+            + "Codex makes them with your ChatGPT plan, never paying by the picture.",
+    },
+    loggedOut: {
+        why: "Codex is not logged in on this computer: the player logs in with codex login",
+        fix: "Codex is on this computer but not logged in. To have pictures:\n"
+            + "1. Open a terminal: on Windows, Start, then type Terminal.\n"
+            + "2. Paste `codex login` and sign in with your ChatGPT account in the browser that opens.\n"
+            + "Codex makes them with your ChatGPT plan, never paying by the picture.",
+    },
+    apiKey: {
+        why: "Codex uses an API key, which pays by the picture: pictures are made only with the ChatGPT login",
+        fix: "Codex on this computer pays for each picture with an API key, which the engine never uses. To make them with your ChatGPT plan instead:\n"
+            + "1. Open a terminal: on Windows, Start, then type Terminal.\n"
+            + "2. Paste `codex login` and sign in with your ChatGPT account in the browser that opens.",
+    },
+};
+// How Codex is started, as the last look found it: by name on the PATH, or by its full path in the engine's folder (D-425).
+let codex = "codex";
+/** Codex on this computer, as the player's ChatGPT login lets it make pictures. */
+export function codexPictures() {
+    let known;
+    return {
+        // Asked once; a no again after a minute, only where the player may be waiting for it, as Settings and image: never on every call of the master; and
+        // again at once after a program came ready here, as after the player signs in (D-424).
+        ready: (again) => {
+            const late = again === true && Date.now() - (known?.at ?? 0) > 60_000;
+            if (known === undefined || (!known.said.ready && (late || known.changes !== helperChanges()))) {
+                known = { said: codexReady(), at: Date.now(), changes: helperChanges() };
+            }
+            return known.said;
+        },
+        make,
+    };
+}
+/** Codex on this computer as a writer of text (D-406): ready where its ChatGPT login makes pictures too. */
+export function codexWriter(maker = codexPictures()) {
+    return { ready: () => maker.ready().ready, write };
+}
+/** Whether Codex is there and logged in with ChatGPT: asked in about a second, without spending anything. */
+function codexReady() {
+    const { state, line } = helperState("codex");
+    codex = line ?? "codex";
+    if (state === "missing") {
+        return { ready: false, ...codexSays.missing };
+    }
+    if (state === "logged out") {
+        return { ready: false, ...codexSays.loggedOut };
+    }
+    return state === "ready" ? { ready: true, maker: "Codex" } : { ready: false, ...codexSays.apiKey };
+}
+/** One picture: Codex in an empty folder of its own, the painted brief on its input, its events read for its thread; the picture from its own folder. */
+function make(subject) {
+    const folder = mkdtempSync(join(tmpdir(), "rpg-picture-"));
+    const last = join(folder, "last.txt");
+    const line = `${codex} exec --ephemeral --skip-git-repo-check -s read-only -C "${folder}" --json -o "${last}" --ignore-user-config --ignore-rules -c model_reasoning_effort="low" -`;
+    return new Promise((done) => {
+        const child = spawn(line, { shell: true, windowsHide: true, cwd: folder, env: helperEnvironment("codex"), stdio: ["pipe", "pipe", "pipe"] });
+        let output = "";
+        let errors = "";
+        const timer = setTimeout(() => stopTree(child), longest);
+        child.stdout.on("data", (chunk) => (output += chunk.toString()));
+        child.stderr.on("data", (chunk) => (errors += chunk.toString()));
+        child.stdin.on("error", () => undefined);
+        child.on("error", () => undefined);
+        child.on("close", () => {
+            clearTimeout(timer);
+            const events = output.split("\n").flatMap((line) => {
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            });
+            const thread = events.find((event) => event.type === "thread.started")?.thread_id;
+            const pictures = typeof thread === "string" ? join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "generated_images", thread) : undefined;
+            const file = pictures === undefined || !existsSync(pictures) ? undefined : readdirSync(pictures).find((name) => name.toLowerCase().endsWith(".png"));
+            const clean = () => {
+                rmSync(folder, { recursive: true, force: true });
+                if (pictures !== undefined) {
+                    rmSync(pictures, { recursive: true, force: true });
+                }
+            };
+            if (pictures !== undefined && file !== undefined) {
+                done({ file: join(pictures, file), done: clean });
+                return;
+            }
+            const failed = events.find((event) => event.type === "turn.failed");
+            const said = existsSync(last) ? lastLine(last) : "";
+            clean();
+            done({ refused: refusal(errors, failed, said) });
+        });
+        child.stdin.end(paintedBrief(subject));
+    });
+}
+/** Codex's answer to a brief, in an empty folder of its own, as its last message; none when it gave none in time. */
+function write(brief) {
+    const folder = mkdtempSync(join(tmpdir(), "rpg-writing-"));
+    const last = join(folder, "last.txt");
+    const line = `${codex} exec --ephemeral --skip-git-repo-check -s read-only -C "${folder}" -o "${last}" --ignore-user-config --ignore-rules -c model_reasoning_effort="low" -`;
+    return new Promise((done) => {
+        const child = spawn(line, { shell: true, windowsHide: true, cwd: folder, env: helperEnvironment("codex"), stdio: ["pipe", "ignore", "ignore"] });
+        const timer = setTimeout(() => stopTree(child), longest);
+        child.stdin.on("error", () => undefined);
+        child.on("error", () => undefined);
+        child.on("close", () => {
+            clearTimeout(timer);
+            const said = existsSync(last) ? readFileSync(last, "utf8").trim() : "";
+            rmSync(folder, { recursive: true, force: true });
+            done(said === "" ? undefined : said);
+        });
+        child.stdin.end(brief);
+    });
+}
+/** Why no picture came: the generator's safety check, a failed turn, what Codex said, or the time that ran out. */
+function refusal(errors, failed, said) {
+    if (/moderation_blocked/.test(errors)) {
+        return "the generator's safety check refused it: describe the place, never a victim or wounds";
+    }
+    if (failed !== undefined) {
+        const error = failed.error;
+        return `Codex failed: ${String(error?.message ?? "no reason given")}`;
+    }
+    return said === "" ? "no picture came in three minutes" : `Codex said: ${said}`;
+}
+/** The last line Codex wrote as its answer; nothing when it wrote none. */
+function lastLine(file) {
+    try {
+        return readFileSync(file, "utf8").trim().split("\n").at(-1)?.trim() ?? "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/pictures/helpers.d.ts

@@ -0,0 +1,26 @@
+import type { HelperLogin, HelperName, Helpers, HelperState } from "../core/context.ts";
+/** Codex and Claude Code on this computer, the engine's own folder in `folder`. */
+export declare function computerHelpers(folder?: string): Helpers;
+/** Where the engine keeps the programs it installs: the player's local data, as they weigh hundreds of megabytes (D-425). */
+export declare function toolsFolder(): string;
+/** The line that starts a program in the shell: its name where the PATH has it, else its full path in the engine's folder; undefined where neither answers. */
+export declare function helperLine(name: HelperName, folder?: string): string | undefined;
+/** How a program stands, from its own status, without spending anything; with the line that starts it. */
+export declare function helperState(name: HelperName, folder?: string): {
+    state: HelperState;
+    line?: string;
+};
+/** How many times a program came ready on this computer since the engine started: a maker that said no asks again after one. */
+export declare function helperChanges(): number;
+/**
+ * The environment of a program: the chat's variables and any API key taken away, where its login and its shell are kept (D-342, D-425); and on Windows the shell
+ * told not to look for programs in the folder it starts in, which could be a campaign's.
+ */
+export declare function helperEnvironment(name: HelperName): NodeJS.ProcessEnv;
+/**
+ * The player's sign-in, started once and kept alive until it ends or ten minutes pass. It answers once the program printed its link, for a browser that did
+ * not open, or ended, or after a few seconds; how it ends later is told by the next call.
+ */
+export declare function startLogin(name: HelperName, line: string, wait?: number): Promise<HelperLogin>;
+/** The line that starts a program installed in the engine's folder, from its package's own bin: node and a script, or the program itself; undefined where it is not there. */
+export declare function installedLine(name: HelperName, folder: string): string | undefined;

package/dist/pictures/helpers.js

@@ -0,0 +1,219 @@
+// Codex and Claude Code with the player's own login (D-424, D-425): found on the PATH or in the engine's folder, installed there with npm, never globally, and
+// signed in by the player in the browser; started through the shell from a folder of no campaign, without the chat's variables or an API key.
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { stopTree } from "./stop.js";
+// The npm package of each program.
+const packages = { codex: "@openai/codex", claude: "@anthropic-ai/claude-code" };
+// How long the player has to sign in, in the browser that opened (neither program stops waiting by itself).
+const loginWait = 10 * 60 * 1000;
+// How long install waits for the sign-in's link, or its end, before it answers: the probe's printed its link at once.
+const linkWait = 5000;
+// How long an installation may take: the probe's took 13 to 21 seconds.
+const installWait = 5 * 60 * 1000;
+// The sign-ins under way, or failed and not yet told, by program; the installations under way; how each program stood when last asked; and how many times one
+// came ready here, after which the makers of pictures ask again.
+const logins = new Map();
+const installs = new Map();
+const states = new Map();
+let changes = 0;
+// A sign-in still waiting goes with the server: its own timer would never come.
+process.once("exit", () => logins.forEach((run) => run.child !== undefined && run.login.state === "waiting" && stopTree(run.child)));
+/** Codex and Claude Code on this computer, the engine's own folder in `folder`. */
+export function computerHelpers(folder = toolsFolder()) {
+    return {
+        // A program come ready, however the player signed in, has the makers of pictures ask again.
+        state: (name) => {
+            const state = helperState(name, folder).state;
+            if (state === "ready" && states.get(name) !== "ready") {
+                changes++;
+            }
+            states.set(name, state);
+            return state;
+        },
+        install: (name) => {
+            // One installation of a program at a time: a call the host gave up on and asked again waits for the first.
+            const running = installs.get(name) ?? installHelper(name, folder).finally(() => installs.delete(name));
+            installs.set(name, running);
+            return running;
+        },
+        login: (name) => {
+            const run = logins.get(name);
+            if (run?.login.state === "waiting") {
+                return Promise.resolve(run.login);
+            }
+            // A sign-in that failed after install answered is told once; the next call starts another.
+            if (run?.login.state === "failed") {
+                logins.delete(name);
+                return Promise.resolve(run.login);
+            }
+            const line = helperLine(name, folder);
+            return line === undefined ? Promise.resolve({ state: "failed", why: `${name} does not answer on this computer` }) : startLogin(name, line);
+        },
+    };
+}
+/** Where the engine keeps the programs it installs: the player's local data, as they weigh hundreds of megabytes (D-425). */
+export function toolsFolder() {
+    const home = homedir();
+    if (process.platform === "win32") {
+        return join(process.env.LOCALAPPDATA || join(home, "AppData", "Local"), "rpg-engine", "tools");
+    }
+    return process.platform === "darwin"
+        ? join(home, "Library", "Application Support", "rpg-engine", "tools")
+        : join(process.env.XDG_DATA_HOME || join(home, ".local", "share"), "rpg-engine", "tools");
+}
+/** The line that starts a program in the shell: its name where the PATH has it, else its full path in the engine's folder; undefined where neither answers. */
+export function helperLine(name, folder = toolsFolder()) {
+    if (answers(name, name)) {
+        return name;
+    }
+    const own = installedLine(name, folder);
+    return own !== undefined && answers(name, own) ? own : undefined;
+}
+/** How a program stands, from its own status, without spending anything; with the line that starts it. */
+export function helperState(name, folder = toolsFolder()) {
+    const line = helperLine(name, folder);
+    if (line === undefined) {
+        return { state: "missing" };
+    }
+    const status = spawnSync(`${line} ${name === "codex" ? "login status" : "auth status"}`, {
+        shell: true,
+        encoding: "utf8",
+        timeout: 15_000,
+        windowsHide: true,
+        cwd: tmpdir(),
+        env: helperEnvironment(name),
+    });
+    const said = `${status.stdout ?? ""}${status.stderr ?? ""}`;
+    if (name === "codex") {
+        const state = status.error !== undefined || status.status !== 0 || /not logged in/i.test(said) ? "logged out" : /chatgpt/i.test(said) ? "ready" : "api key";
+        return { state, line };
+    }
+    const json = (() => {
+        try {
+            return JSON.parse(status.stdout ?? "");
+        }
+        catch {
+            return {};
+        }
+    })();
+    return { state: json.loggedIn !== true ? "logged out" : json.authMethod === "claude.ai" ? "ready" : "api key", line };
+}
+/** How many times a program came ready on this computer since the engine started: a maker that said no asks again after one. */
+export function helperChanges() {
+    return changes;
+}
+/**
+ * The environment of a program: the chat's variables and any API key taken away, where its login and its shell are kept (D-342, D-425); and on Windows the shell
+ * told not to look for programs in the folder it starts in, which could be a campaign's.
+ */
+export function helperEnvironment(name) {
+    const kept = new Set(["CLAUDE_CONFIG_DIR", "CLAUDE_CODE_GIT_BASH_PATH", "CODEX_HOME"]);
+    const dropped = name === "codex" ? /^(OPENAI_API_KEY|CODEX_API_KEY)$/i : /^(CLAUDE|ANTHROPIC)/i;
+    const own = Object.fromEntries(Object.entries(process.env).filter(([variable]) => kept.has(variable.toUpperCase()) || !dropped.test(variable)));
+    return { ...own, NoDefaultCurrentDirectoryInExePath: "1" };
+}
+/**
+ * The player's sign-in, started once and kept alive until it ends or ten minutes pass. It answers once the program printed its link, for a browser that did
+ * not open, or ended, or after a few seconds; how it ends later is told by the next call.
+ */
+export function startLogin(name, line, wait = linkWait) {
+    const child = spawn(`${line} ${name === "codex" ? "login" : "auth login"}`, { shell: true, windowsHide: true, cwd: tmpdir(), env: helperEnvironment(name), stdio: ["pipe", "pipe", "pipe"] });
+    const run = { login: { state: "waiting" }, child };
+    let said = "";
+    let answer;
+    logins.set(name, run);
+    const tell = () => {
+        answer?.(run.login);
+        answer = undefined;
+    };
+    const end = (login) => {
+        clearTimeout(timer);
+        if (logins.get(name) !== run) {
+            return;
+        }
+        run.login = login;
+        // Signed in: nothing to tell later, as the program now says it is ready; a failure waits for the next call.
+        if (login.state === "done") {
+            changes++;
+            logins.delete(name);
+        }
+        tell();
+    };
+    const hear = (chunk) => {
+        said += chunk;
+        const link = /https:\/\/\S+/.exec(said)?.[0];
+        if (link !== undefined && run.login.state === "waiting" && run.login.link === undefined) {
+            run.login = { state: "waiting", link };
+            tell();
+        }
+    };
+    const timer = setTimeout(() => {
+        stopTree(child);
+        end({ state: "failed", why: "the sign-in waited ten minutes, and the player did not finish it" });
+    }, loginWait);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", hear);
+    child.stderr.on("data", hear);
+    child.stdin.on("error", () => undefined);
+    child.on("error", () => undefined);
+    child.on("close", (code) => {
+        const last = said.trim().split("\n").filter((one) => one.trim() !== "").at(-1)?.trim();
+        end(code === 0 ? { state: "done" } : { state: "failed", why: last === undefined ? "the sign-in stopped" : `it said: ${last}` });
+    });
+    return new Promise((done) => {
+        answer = done;
+        setTimeout(tell, wait).unref();
+    });
+}
+/** The line that starts a program installed in the engine's folder, from its package's own bin: node and a script, or the program itself; undefined where it is not there. */
+export function installedLine(name, folder) {
+    const packageFolder = join(folder, "node_modules", ...packages[name].split("/"));
+    try {
+        const bin = JSON.parse(readFileSync(join(packageFolder, "package.json"), "utf8")).bin;
+        const relative = typeof bin === "string" ? bin : bin?.[name];
+        const file = relative === undefined ? undefined : join(packageFolder, relative);
+        if (file === undefined || !existsSync(file)) {
+            return undefined;
+        }
+        return /\.[cm]?js$/i.test(file) ? `"${process.execPath}" "${file}"` : `"${file}"`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Installs a program in the engine's folder with npm, never globally (D-425): undefined once it answers there, else why not. */
+function installHelper(name, folder) {
+    return new Promise((done) => {
+        const child = spawn(`npm install --prefix "${folder}" ${packages[name]} --no-audit --no-fund --loglevel=error`, {
+            shell: true,
+            windowsHide: true,
+            cwd: tmpdir(),
+            env: { ...process.env, NoDefaultCurrentDirectoryInExePath: "1" },
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        let errors = "";
+        const timer = setTimeout(() => stopTree(child), installWait);
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => (errors += chunk));
+        child.on("error", () => undefined);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const line = installedLine(name, folder);
+            if (code === 0 && line !== undefined && answers(name, line)) {
+                done(undefined);
+                return;
+            }
+            const said = errors.trim().split("\n").filter((one) => one.trim() !== "").at(-1)?.trim();
+            done(said === undefined ? `npm stopped without installing ${packages[name]}` : `npm said: ${said}`);
+        });
+    });
+}
+/** Whether a program answers through a line, its version given in a moment. */
+function answers(name, line) {
+    const version = spawnSync(`${line} --version`, { shell: true, encoding: "utf8", timeout: 15_000, windowsHide: true, cwd: tmpdir(), env: helperEnvironment(name) });
+    return version.error === undefined && version.status === 0;
+}

package/dist/pictures/index.d.ts

@@ -0,0 +1,6 @@
+export { creatureBrief, paintedBrief, placeBrief, portraitBrief, questBrief, svgBrief } from "./briefs.ts";
+export { hostPictures, hostWriter } from "./chosen.ts";
+export { claudePictures, claudeSays, claudeWriter } from "./claude.ts";
+export { codexPictures, codexSays, codexWriter } from "./codex.ts";
+export { computerHelpers, helperChanges, helperEnvironment, helperLine, helperState, toolsFolder } from "./helpers.ts";
+export { cleanSvg, svgIn } from "./svg.ts";

package/dist/pictures/index.js

@@ -0,0 +1,8 @@
+// Pictures made from words (D-308, D-390): what makes them on the player's computer, chosen by the chat in use, injected through Context so that tests never
+// spend: Codex's painted ones, else Claude's SVG ones; and the two programs themselves, found, installed and signed in with the player's yes (D-424).
+export { creatureBrief, paintedBrief, placeBrief, portraitBrief, questBrief, svgBrief } from "./briefs.js";
+export { hostPictures, hostWriter } from "./chosen.js";
+export { claudePictures, claudeSays, claudeWriter } from "./claude.js";
+export { codexPictures, codexSays, codexWriter } from "./codex.js";
+export { computerHelpers, helperChanges, helperEnvironment, helperLine, helperState, toolsFolder } from "./helpers.js";
+export { cleanSvg, svgIn } from "./svg.js";

package/dist/pictures/stop.d.ts

@@ -0,0 +1,3 @@
+import { type ChildProcess } from "node:child_process";
+/** Stops a process and, on Windows, every process it started. */
+export declare function stopTree(child: ChildProcess): void;

package/dist/pictures/stop.js

@@ -0,0 +1,10 @@
+// A maker of pictures run through the shell, stopped whole when its time runs out: on Windows the shell's child lives on after the shell, so its tree goes.
+import { spawnSync } from "node:child_process";
+/** Stops a process and, on Windows, every process it started. */
+export function stopTree(child) {
+    if (process.platform === "win32" && child.pid !== undefined) {
+        spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true });
+        return;
+    }
+    child.kill();
+}

package/dist/pictures/svg.d.ts

@@ -0,0 +1,4 @@
+/** The SVG rebuilt from what is allowed, its root always in the SVG namespace; undefined when it has no single allowed root, does not close, or is too large. */
+export declare function cleanSvg(svg: string): string | undefined;
+/** The SVG in a model's answer, from <svg to </svg>, whatever came around it; undefined when there is none. */
+export declare function svgIn(answer: string): string | undefined;