wizards 0.1.9

package/apps/runtime/dist/harness/claude.js

@@ -0,0 +1,138 @@
+import { resolveEnv, run } from "./env.js";
+import { failureOf, HarnessModel, lastJson, runClient, } from "./model.js";
+/**
+ * Claude Code: `claude -p` answers on the person's sign-in — the client's keychain, or the key
+ * or token their login shell sets. Tools go over MCP; structured output is validated by the
+ * client (`--json-schema`); web search is its own tool.
+ */
+export const CLAUDE_BIN = process.env.CLAUDE_BIN?.trim() || "claude";
+const CLASSES = {
+    classifier: "haiku",
+    standard: "sonnet",
+    high: "opus",
+    highest: "opus",
+};
+const spec = {
+    id: "claude",
+    passThrough: /^(ANTHROPIC_|CLAUDE_CODE_OAUTH_TOKEN$|CLAUDE_CODE_USE_|CLAUDE_CONFIG_DIR$|AWS_(PROFILE|REGION|DEFAULT_REGION|ACCESS_KEY_ID|SECRET_ACCESS_KEY|SESSION_TOKEN)$|GOOGLE_APPLICATION_CREDENTIALS$|CLOUD_ML_REGION$)/,
+    keyVars: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
+    async auth(env) {
+        try {
+            const { stdout } = await run(CLAUDE_BIN, ["auth", "status", "--json"], {
+                timeout: 15_000,
+                env,
+            });
+            const status = JSON.parse(stdout.trim());
+            if (!status.loggedIn) {
+                return "none";
+            }
+            return status.authMethod === "api_key" ? "api_key" : "subscription";
+        }
+        catch {
+            return "none";
+        }
+    },
+};
+export async function claudeEnv() {
+    return (await resolveEnv(spec)).env;
+}
+/** The client's result as the model call wants it: text (or the structured output as JSON) and usage. */
+export function claudeAnswer(event) {
+    const u = event.usage ?? {};
+    const cacheRead = u.cache_read_input_tokens ?? 0;
+    const cacheWrite = u.cache_creation_input_tokens ?? 0;
+    return {
+        text: event.structured_output !== undefined
+            ? JSON.stringify(event.structured_output)
+            : typeof event.result === "string"
+                ? event.result
+                : JSON.stringify(event.result ?? ""),
+        usage: {
+            input: (u.input_tokens ?? 0) + cacheRead + cacheWrite,
+            cacheRead,
+            cacheWrite,
+            output: u.output_tokens ?? 0,
+        },
+        meta: { costUsd: event.total_cost_usd ?? 0, turns: event.num_turns ?? 1 },
+        sessionId: event.session_id,
+        stopReason: event.stop_reason,
+    };
+}
+class ClaudeCodeModel extends HarnessModel {
+    provider = "claude-code";
+    nativeSchema = true;
+    async invoke(call) {
+        const builtin = [];
+        if (call.files.length) {
+            builtin.push("Read");
+        }
+        if (call.webSearch) {
+            builtin.push("WebSearch");
+        }
+        const args = [
+            "-p",
+            "--output-format",
+            "json",
+            "--model",
+            this.modelId,
+            "--tools",
+            builtin.join(","),
+            "--strict-mcp-config",
+            "--setting-sources",
+            "",
+            "--disable-slash-commands",
+            "--no-session-persistence",
+        ];
+        if (call.system) {
+            args.push("--system-prompt", call.system);
+        }
+        if (call.effort) {
+            args.push("--effort", call.effort);
+        }
+        if (call.schema) {
+            args.push("--json-schema", JSON.stringify(call.schema));
+        }
+        if (call.bridgeUrl) {
+            args.push("--mcp-config", JSON.stringify({ mcpServers: { step: { type: "http", url: call.bridgeUrl } } }));
+        }
+        const allowed = [...builtin, ...(call.bridgeUrl ? ["mcp__step"] : [])];
+        if (allowed.length) {
+            args.push("--allowedTools", allowed.join(","));
+        }
+        if (call.files.length) {
+            args.push("--add-dir", call.dir);
+        }
+        const { stdout, stderr, code } = await runClient(CLAUDE_BIN, args, {
+            cwd: call.dir,
+            env: await claudeEnv(),
+            signal: call.signal,
+            stdin: call.prompt,
+        });
+        const event = lastJson(stdout);
+        if (!event) {
+            throw failureOf(this.harness, stderr.trim() || `exit ${code}`);
+        }
+        if (event.is_error) {
+            throw failureOf(this.harness, String(event.result ?? "error"));
+        }
+        return claudeAnswer(event);
+    }
+}
+export const claude = {
+    ...spec,
+    name: "Claude Code",
+    bin: CLAUDE_BIN,
+    classes: CLASSES,
+    async version(env) {
+        try {
+            const { stdout } = await run(CLAUDE_BIN, ["--version"], { timeout: 5000, env });
+            return stdout.trim().split(/\s+/)[0] || stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    },
+    login: { args: ["auth", "login"], interactive: false },
+    model: (alias, effort) => new ClaudeCodeModel(claude, alias || "sonnet", effort),
+    exhausted: "Das Anthropic-Konto, mit dem Claude Code angemeldet ist, hat kein Guthaben. Melde Claude Code mit deinem Abo an: in den Einstellungen unter „Modelle & Konto“.",
+};

package/apps/runtime/dist/harness/codex.js

@@ -0,0 +1,228 @@
+import { existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveEnv, run } from "./env.js";
+import { failureOf, HarnessImageModel, HarnessModel, runClient, } from "./model.js";
+/**
+ * Codex: `codex exec` answers on the ChatGPT sign-in kept in CODEX_HOME. The person's own
+ * config is left out so none of their MCP servers start for a call; tools go over MCP through
+ * a config override; structured output is validated by the client (`--output-schema`).
+ */
+export const CODEX_BIN = process.env.CODEX_BIN?.trim() || "codex";
+/**
+ * Models a ChatGPT sign-in runs (checked 2026-10-04): Luna for small calls, Sol as the
+ * workhorse, Astra for the hardest work. A binding `codex/<model>` names another;
+ * `codex/default` = the model the client picks itself.
+ */
+const CLASSES = {
+    classifier: "gpt-6-luna",
+    standard: "gpt-6.1-sol",
+    high: "gpt-6.1-sol",
+    highest: "gpt-6-astra",
+};
+const spec = {
+    id: "codex",
+    passThrough: /^CODEX_HOME$/,
+    keyVars: [],
+    async auth(env) {
+        try {
+            const { stdout, stderr } = await run(CODEX_BIN, ["login", "status"], {
+                timeout: 15_000,
+                env,
+            });
+            const text = `${stdout}\n${stderr}`;
+            if (/not logged in/i.test(text)) {
+                return "none";
+            }
+            if (/api key/i.test(text)) {
+                return "api_key";
+            }
+            return /logged in/i.test(text) ? "subscription" : "none";
+        }
+        catch {
+            return "none";
+        }
+    },
+};
+/** The events of one run as the model call wants them: the last agent message and the usage. */
+export function codexAnswer(stdout) {
+    let text = null;
+    let usage;
+    let failure = null;
+    let sessionId;
+    for (const line of stdout.split("\n")) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (event.type === "thread.started") {
+            sessionId = event.thread_id;
+        }
+        else if (event.type === "item.completed" && event.item?.type === "agent_message") {
+            text = event.item.text ?? "";
+        }
+        else if (event.type === "turn.completed") {
+            const u = event.usage ?? {};
+            usage = {
+                input: u.input_tokens ?? 0,
+                cacheRead: u.cached_input_tokens ?? 0,
+                cacheWrite: u.cache_write_input_tokens ?? 0,
+                output: u.output_tokens ?? 0,
+            };
+        }
+        else if (event.type === "turn.failed" || event.type === "error") {
+            failure =
+                typeof event.error === "string"
+                    ? event.error
+                    : (event.error?.message ?? event.message ?? "error");
+        }
+    }
+    return {
+        answer: text === null ? null : { text, usage, sessionId },
+        failure,
+    };
+}
+class CodexModel extends HarnessModel {
+    provider = "codex";
+    nativeSchema = true;
+    async invoke(call) {
+        const args = [
+            "exec",
+            "-",
+            "--json",
+            "--ephemeral",
+            "--skip-git-repo-check",
+            "--ignore-user-config",
+            "-s",
+            "read-only",
+            "-C",
+            call.dir,
+            "-c",
+            'approval_policy="never"',
+            "-c",
+            `web_search="${call.webSearch ? "live" : "disabled"}"`,
+        ];
+        if (this.modelId !== "default") {
+            args.push("-m", this.modelId);
+        }
+        if (call.effort) {
+            args.push("-c", `model_reasoning_effort="${call.effort}"`);
+        }
+        if (call.system) {
+            // A JSON string is a TOML basic string: the instructions travel as one config value.
+            args.push("-c", `developer_instructions=${JSON.stringify(call.system)}`);
+        }
+        if (call.bridgeUrl) {
+            args.push("-c", `mcp_servers.step.url="${call.bridgeUrl}"`, "-c", "mcp_servers.step.startup_timeout_sec=30", "-c", "mcp_servers.step.tool_timeout_sec=600", 
+            // The tools are this runtime's own: they run without the client asking anyone.
+            "-c", 'mcp_servers.step.default_tools_approval_mode="approve"');
+        }
+        if (call.schema) {
+            const file = join(call.dir, "schema.json");
+            writeFileSync(file, JSON.stringify(call.schema));
+            args.push("--output-schema", file);
+        }
+        const { stdout, stderr, code } = await runClient(CODEX_BIN, args, {
+            cwd: call.dir,
+            env: (await resolveEnv(spec)).env,
+            signal: call.signal,
+            stdin: call.prompt,
+        });
+        const { answer, failure } = codexAnswer(stdout);
+        if (failure || !answer) {
+            throw failureOf(this.harness, failure ?? stderr.trim() ?? `exit ${code}`);
+        }
+        return answer;
+    }
+}
+/**
+ * Images: `codex exec` with the built-in image tool, the reference photos attached with `-i`.
+ * Codex keeps what it made under CODEX_HOME/generated_images/<thread>; the file is read from
+ * there and that folder removed. `codex/image` runs the tool on the standard model.
+ */
+class CodexImageModel extends HarnessImageModel {
+    provider = "codex";
+    async invoke(call) {
+        const prompt = [
+            call.prompt,
+            call.files.length
+                ? "Work from the attached image(s): edit them as described, keeping what is not to change."
+                : "",
+            call.aspectRatio ? `Aspect ratio: ${call.aspectRatio}.` : "",
+            "Make exactly one image with your image generation tool. Write no files yourself and run no commands. Reply only with: done",
+        ]
+            .filter(Boolean)
+            .join("\n\n");
+        const args = [
+            "exec",
+            "-",
+            "--json",
+            "--ephemeral",
+            "--skip-git-repo-check",
+            "--ignore-user-config",
+            "-s",
+            "read-only",
+            "-C",
+            call.dir,
+            "-c",
+            'approval_policy="never"',
+            "-c",
+            'web_search="disabled"',
+            "-m",
+            this.modelId === "image" ? CLASSES.standard : this.modelId,
+        ];
+        for (const file of call.files) {
+            args.push("-i", file);
+        }
+        const { env } = await resolveEnv(spec);
+        const { stdout, stderr, code } = await runClient(CODEX_BIN, args, {
+            cwd: call.dir,
+            env,
+            signal: call.signal,
+            stdin: prompt,
+        });
+        const { answer, failure } = codexAnswer(stdout);
+        if (failure || !answer?.sessionId) {
+            throw failureOf(this.harness, failure ?? stderr.trim() ?? `exit ${code}`);
+        }
+        const folder = join(env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "generated_images", answer.sessionId);
+        try {
+            const made = existsSync(folder)
+                ? readdirSync(folder)
+                    .filter((f) => /\.(png|jpe?g|webp)$/i.test(f))
+                    .map((f) => join(folder, f))
+                    .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)
+                : [];
+            if (!made[0]) {
+                throw new Error(`Codex made no image: ${answer.text.slice(0, 300)}`);
+            }
+            return new Uint8Array(readFileSync(made[0]));
+        }
+        finally {
+            rmSync(folder, { recursive: true, force: true });
+        }
+    }
+}
+export const codex = {
+    ...spec,
+    name: "Codex",
+    bin: CODEX_BIN,
+    classes: CLASSES,
+    async version(env) {
+        try {
+            const { stdout } = await run(CODEX_BIN, ["--version"], { timeout: 5000, env });
+            const words = stdout.trim().split(/\s+/);
+            return words[words.length - 1] || null;
+        }
+        catch {
+            return null;
+        }
+    },
+    login: { args: ["login"], interactive: false },
+    model: (alias, effort) => new CodexModel(codex, alias || "default", effort),
+    image: { alias: "image", model: (alias) => new CodexImageModel(codex, alias || "image") },
+    exhausted: "Das Kontingent des ChatGPT-Kontos, mit dem Codex angemeldet ist, ist aufgebraucht. Später noch einmal versuchen oder einen anderen Client wählen.",
+};

package/apps/runtime/dist/harness/cursor.js

@@ -0,0 +1,93 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveEnv, run } from "./env.js";
+import { failureOf, HarnessModel, lastJson, runClient, } from "./model.js";
+/**
+ * Cursor Agent: `cursor-agent -p` answers on the Cursor sign-in. The call's folder is its
+ * workspace: the instructions as AGENTS.md, the tools as an MCP server in .cursor/mcp.json.
+ * The answer is asked for as JSON where a schema is wanted.
+ */
+export const CURSOR_BIN = process.env.CURSOR_AGENT_BIN?.trim() || "cursor-agent";
+/** "auto" = the model the client picks itself; a binding `cursor/<model>` names one. */
+const CLASSES = {
+    classifier: "auto",
+    standard: "auto",
+    high: "auto",
+    highest: "auto",
+};
+/** The escape sequences a terminal app draws with. */
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+const spec = {
+    id: "cursor",
+    passThrough: /^CURSOR_API_KEY$/,
+    keyVars: ["CURSOR_API_KEY"],
+    async auth(env) {
+        try {
+            const { stdout, stderr } = await run(CURSOR_BIN, ["status"], { timeout: 15_000, env });
+            // The client draws on the terminal even here: the control sequences are taken out.
+            const text = `${stdout}\n${stderr}`.replace(ANSI, "");
+            if (/not logged in/i.test(text) || !/logged in/i.test(text)) {
+                return "none";
+            }
+            return env.CURSOR_API_KEY ? "api_key" : "subscription";
+        }
+        catch {
+            return "none";
+        }
+    },
+};
+class CursorModel extends HarnessModel {
+    provider = "cursor-agent";
+    async invoke(call) {
+        if (call.system) {
+            writeFileSync(join(call.dir, "AGENTS.md"), call.system);
+        }
+        if (call.bridgeUrl) {
+            mkdirSync(join(call.dir, ".cursor"), { recursive: true });
+            writeFileSync(join(call.dir, ".cursor", "mcp.json"), JSON.stringify({ mcpServers: { step: { url: call.bridgeUrl } } }));
+        }
+        const args = ["-p", "--output-format", "json", "--workspace", call.dir, "--approve-mcps"];
+        if (this.modelId !== "auto") {
+            args.push("--model", this.modelId);
+        }
+        if (!call.bridgeUrl) {
+            // Nothing to work through: the client answers, it does not edit.
+            args.push("--mode", "ask");
+        }
+        const { stdout, stderr, code } = await runClient(CURSOR_BIN, args, {
+            cwd: call.dir,
+            env: (await resolveEnv(spec)).env,
+            signal: call.signal,
+            stdin: call.prompt,
+        });
+        const event = lastJson(stdout);
+        if (!event) {
+            throw failureOf(this.harness, stderr.trim() || `exit ${code}`);
+        }
+        if (event.is_error) {
+            throw failureOf(this.harness, String(event.result ?? "error"));
+        }
+        return {
+            text: typeof event.result === "string" ? event.result : JSON.stringify(event.result ?? ""),
+            sessionId: event.session_id,
+            meta: { durationMs: event.duration_ms ?? 0 },
+        };
+    }
+}
+export const cursor = {
+    ...spec,
+    name: "Cursor Agent",
+    bin: CURSOR_BIN,
+    classes: CLASSES,
+    async version(env) {
+        try {
+            const { stdout } = await run(CURSOR_BIN, ["--version"], { timeout: 10_000, env });
+            return stdout.trim().split("\n").pop()?.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    },
+    login: { args: ["login"], interactive: false },
+    model: (alias, effort) => new CursorModel(cursor, alias || "auto", effort),
+};

package/apps/runtime/dist/harness/env.js

@@ -0,0 +1,124 @@
+import { execFile, spawn } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { layout } from "../cli/home.js";
+export const run = promisify(execFile);
+let shellEnv = null;
+/** The person's login shell, asked once: a desktop app and a bare dev server start without its variables. */
+export function loginShellEnv() {
+    shellEnv ??= new Promise((done) => {
+        const shell = process.env.SHELL || "/bin/zsh";
+        // In a session of its own, away from the terminal `wizards` runs in: an interactive
+        // shell takes over that terminal for its job control and keeps it when it ends, and Ctrl-C
+        // then reaches nobody. (execFile cannot do this: it drops `detached`.)
+        const child = spawn(shell, ["-l", "-i", "-c", "env"], {
+            detached: true,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 10_000,
+            env: {
+                HOME: process.env.HOME,
+                USER: process.env.USER,
+                PATH: process.env.PATH,
+                TERM: "dumb",
+            },
+        });
+        let stdout = "";
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.on("error", () => done({}));
+        child.on("close", (code) => {
+            const out = {};
+            for (const line of code === 0 ? stdout.split("\n") : []) {
+                const at = line.indexOf("=");
+                if (at > 0) {
+                    out[line.slice(0, at)] = line.slice(at + 1);
+                }
+            }
+            done(out);
+        });
+    });
+    return shellEnv;
+}
+/**
+ * The environment a client gets: its sign-in as the login shell sets it (else as this process
+ * has it), PATH as the shell has it so the client is found from a GUI app too, and nothing else —
+ * no key of ours, no session of a parent client.
+ */
+export function pickEnv(shell, own, passThrough, 
+/** Folders before the shell's PATH: the clients the setup installed. */
+first = []) {
+    const picked = {};
+    const source = Object.keys(shell).length ? shell : own;
+    for (const [key, value] of Object.entries(source)) {
+        if (passThrough.test(key) && value) {
+            picked[key] = value;
+        }
+    }
+    const path = [...first, ...(shell.PATH ?? "").split(":"), ...(own.PATH ?? "").split(":")].filter(Boolean);
+    return {
+        ...picked,
+        PATH: [...new Set(path)].join(":"),
+        HOME: own.HOME,
+        USER: own.USER,
+        LANG: "en_US.UTF-8",
+        TERM: "dumb",
+    };
+}
+export function stripKeys(env, keyVars) {
+    const bare = { ...env };
+    for (const key of keyVars) {
+        delete bare[key];
+    }
+    return bare;
+}
+/** Where the setup installs clients from npm, whoever started this runtime. */
+const installed = () => [join(layout().clients, "bin")];
+const resolved = new Map();
+/**
+ * The environment a client runs in, decided once: the subscription sign-in comes first — it is
+ * what the person installed the client for — so a key the shell sets is held back while the
+ * client is signed in without it, and used only where it is the one way in.
+ */
+export function resolveEnv(spec) {
+    let pending = resolved.get(spec.id);
+    if (!pending) {
+        pending = (async () => {
+            const withKey = pickEnv(await loginShellEnv(), process.env, spec.passThrough, installed());
+            const bare = stripKeys(withKey, spec.keyVars);
+            const own = await spec.auth(bare);
+            if (own !== "none") {
+                return { env: bare, auth: own };
+            }
+            if (spec.keyVars.some((key) => withKey[key])) {
+                const keyed = await spec.auth(withKey);
+                if (keyed !== "none") {
+                    return { env: withKey, auth: "api_key" };
+                }
+            }
+            return { env: bare, auth: "none" };
+        })();
+        resolved.set(spec.id, pending);
+    }
+    return pending;
+}
+/** The environment of a sign-in: the client on its own, without a key of the shell, in a real terminal. */
+export async function loginEnv(spec) {
+    const bare = stripKeys(pickEnv(await loginShellEnv(), process.env, spec.passThrough, installed()), spec.keyVars);
+    return { ...bare, TERM: "xterm-256color", COLORTERM: "truecolor" };
+}
+/** The client's sign-in right now, on its own: asked again and again while the person signs in. */
+export async function freshAuth(spec) {
+    return spec.auth(await loginEnv(spec));
+}
+/** Forgets what was decided: the person may just have signed in or changed their shell. */
+export function forgetEnv(id) {
+    shellEnv = null;
+    if (id) {
+        resolved.delete(id);
+    }
+    else {
+        resolved.clear();
+    }
+}