@dna113p/machines 0.2.0 → 0.3.1

package/dist/src/cli.js

@@ -1,13 +1,21 @@
 #!/usr/bin/env node
+import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, resolve } from "node:path";
 import { emitKeypressEvents } from "node:readline";
-import { stripVTControlCharacters } from "node:util";
+import { inspect, stripVTControlCharacters } from "node:util";
 import yoctoSpinner from "yocto-spinner";
 import { bold, cyan, dim, green, magenta, red, yellow } from "yoctocolors";
+import { assertJsonValue, isJsonValue } from "./json.js";
 import { discoverMachines, machinesUserHome } from "./discovery.js";
 import { listAgentPresets, listMachines, prepareMachineRun, } from "./launcher.js";
+import { inboxHuman, respondToRun } from "./run-inbox.js";
+import { createRunStatusPublisher, isProcessAlive, readRunStatuses, runSessionId, runStatusDirectory, runStatusObserver, } from "./run-status.js";
+import { readRunWatches, runWatch, runWatchMatches, runWatchPath, sameRunWatch, writeRunWatches, } from "./run-watch.js";
 const [command, selector, ...argumentsAfterSelector] = process.argv.slice(2);
+const runsOptions = selector === undefined ? [] : [selector, ...argumentsAfterSelector];
+const watchUsage = "machine watch [<run-id-or-label-start> | --dir <path>]";
+const unwatchUsage = "machine unwatch <run-id-or-label-start> | --dir <path> | --all";
 try {
     if (command === "list" && selector === undefined) {
         const machines = await listMachines({ cwd: process.cwd() });
@@ -35,13 +43,30 @@ try {
     else if (command === "run" && selector !== undefined) {
         await runMachine(await resolveMachine(selector), argumentsAfterSelector);
     }
+    else if (command === "runs"
+        && runsOptions.every((option, index) => (option === "--json" || option === "--all") && runsOptions.indexOf(option) === index)) {
+        listRuns(runsOptions.includes("--json"), runsOptions.includes("--all"));
+    }
+    else if (command === "respond" && selector !== undefined) {
+        await respond([selector, ...argumentsAfterSelector]);
+    }
+    else if (command === "watch") {
+        watch(selector === undefined ? [] : [selector, ...argumentsAfterSelector]);
+    }
+    else if (command === "unwatch" && selector !== undefined) {
+        unwatch([selector, ...argumentsAfterSelector]);
+    }
     else {
         throw new Error([
             "Usage:",
             "  machine list",
             "  machine agents",
             "  machine show <name-or-file>",
-            "  machine run <name-or-file> [--agent role=preset]... [--] [input]",
+            "  machine run <name-or-file> [--agent role=preset]... [--input-file <file|->] [--] [input]",
+            "  machine runs [--json] [--all]",
+            "  machine respond [--question] <run-id> <request-id> [--] <response>",
+            `  ${watchUsage}`,
+            `  ${unwatchUsage}`,
         ].join("\n"));
     }
 }
@@ -61,7 +86,7 @@ async function resolveMachine(selector) {
     return found.path;
 }
 async function runMachine(machinePath, args) {
-    const invocation = parseRunArguments(args);
+    const invocation = await parseRunArguments(args);
     printMachineHeader(machinePath);
     const prepared = await prepareMachineRun({
         cwd: process.cwd(),
@@ -70,16 +95,51 @@ async function runMachine(machinePath, args) {
         agents: Object.fromEntries(invocation.agentOverrides),
     });
     const status = createRunStatus(machinePath);
+    const runId = randomUUID();
+    const published = createRunStatusPublisher({ id: runId, machine: prepared.name, path: prepared.path, cwd: process.cwd() });
+    const statusDirectory = runStatusDirectory();
+    // Machines started by this run's Operations and Agents are its sub-runs.
+    process.env.MACHINES_RUN_PARENT = runId;
+    const observed = runStatusObserver((change) => published.update(change));
     try {
         const result = await prepared.start({
-            onAgentUpdate: status.onAgentUpdate,
-            onHumanInput: status.onHumanInput,
-            onState: status.onState,
+            onAgentUpdate(update) {
+                observed.onAgentUpdate(update);
+                status.onAgentUpdate(update);
+            },
+            // A published run can also be answered through its inbox by `machine respond`.
+            ...(statusDirectory === undefined ? {} : {
+                human: inboxHuman({
+                    directory: statusDirectory,
+                    runId,
+                    publish: (request) => published.update({ status: "waiting", human: request }),
+                    acknowledge: (delivery) => published.update({ delivery }),
+                    onTerminalRefused: (reason) => console.error(reason),
+                    onTerminalClosed(requestId) {
+                        // Finish the unanswered prompt line before saying where the answer can come from.
+                        process.stdout.write("\n");
+                        console.error(`No terminal input. Answer with: machine respond ${runId} ${requestId} <response>`);
+                    },
+                }),
+            }),
+            onHumanInput(active) {
+                published.update(active ? { status: "waiting" } : { status: "running", human: undefined });
+                status.onHumanInput(active);
+            },
+            onState(state) {
+                observed.onState(state);
+                status.onState(state);
+            },
         });
+        published.finish({ state: result.value });
         status.succeed();
         console.log(`--> ${String(result.value)}`);
+        if (result.output !== undefined) {
+            console.log(isJsonValue(result.output) ? JSON.stringify(result.output, null, 2) : inspect(result.output));
+        }
     }
     catch (cause) {
+        published.finish({ error: cause instanceof Error ? cause.message : String(cause) });
         status.fail();
         throw cause;
     }
@@ -87,7 +147,130 @@ async function runMachine(machinePath, args) {
         status.close();
     }
 }
-function parseRunArguments(args) {
+function listRuns(json, all) {
+    const directory = requireStatusDirectory();
+    const published = publishedRuns(directory);
+    // Without --all, only the runs that can still change or be answered.
+    const runs = all ? published : published.filter(isActiveRun);
+    if (json) {
+        console.log(JSON.stringify(runs, null, 2));
+        return;
+    }
+    if (runs.length === 0)
+        console.log(all ? "No Machine runs are published." : "No Machine runs are running or waiting.");
+    const session = runSessionId();
+    const watches = session === undefined ? [] : readRunWatches(directory, session);
+    runs.forEach((record, index) => {
+        printRunListing(record, index > 0, watches.some((watched) => runWatchMatches(watched, record)));
+    });
+}
+/** Every record in the directory, including runs that finished or lost their process and are still recorded. */
+function publishedRuns(directory) {
+    return readRunStatuses(directory).sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
+}
+/** A run that stopped reporting without finishing has lost its process, as on the status line. */
+function runStatus(record) {
+    return record.status !== "completed" && record.status !== "failed" && !isProcessAlive(record.pid) ? "lost" : record.status;
+}
+function isActiveRun(record) {
+    const status = runStatus(record);
+    return status === "running" || status === "waiting";
+}
+function watch(args) {
+    const { directory, session } = requireWatchList();
+    const watches = readRunWatches(directory, session);
+    const runs = publishedRuns(directory);
+    if (args.length === 0) {
+        if (watches.length === 0)
+            console.log("This session watches no other runs.");
+        for (const watched of watches) {
+            console.log(describeWatch(watched));
+            printWatchedRuns(watched, runs);
+        }
+        return;
+    }
+    const added = parseWatch(args, watchUsage);
+    if (!watches.some((watched) => sameRunWatch(watched, added)))
+        writeRunWatches(directory, session, [...watches, added]);
+    console.log(`Watching ${describeWatch(added)}`);
+    printWatchedRuns(added, runs);
+}
+function unwatch(args) {
+    const { directory, session } = requireWatchList();
+    if (args[0] === "--all") {
+        if (args.length !== 1)
+            throw new Error(`Usage: ${unwatchUsage}`);
+        writeRunWatches(directory, session, []);
+        console.log("This session watches no other runs.");
+        return;
+    }
+    const removed = parseWatch(args, unwatchUsage);
+    const watches = readRunWatches(directory, session);
+    const kept = watches.filter((watched) => !sameRunWatch(watched, removed));
+    if (kept.length === watches.length) {
+        console.log(`This session was not watching ${describeWatch(removed)}`);
+        return;
+    }
+    writeRunWatches(directory, session, kept);
+    console.log(`No longer watching ${describeWatch(removed)}`);
+}
+function parseWatch(args, usage) {
+    if (args[0] === "--dir") {
+        if (args.length !== 2)
+            throw new Error(`Usage: ${usage}`);
+        return runWatch({ dir: args[1] });
+    }
+    if (args[0] !== "--" && args[0]?.startsWith("--") === true)
+        throw new Error(`Usage: ${usage}`);
+    return runWatch({ text: (args[0] === "--" ? args.slice(1) : args).join(" ") });
+}
+function describeWatch(watched) {
+    return "dir" in watched ? `--dir ${watched.dir}` : watched.text;
+}
+function printWatchedRuns(watched, runs) {
+    const matched = runs.filter((record) => runWatchMatches(watched, record));
+    if (matched.length === 0)
+        console.log("  no published run matches yet");
+    for (const record of matched)
+        console.log(`  ${runColumns(record).join("\t")}`);
+}
+/** The session whose watch list this process changes, and where the list is kept. */
+function requireWatchList() {
+    const directory = requireStatusDirectory();
+    const session = runSessionId();
+    if (session === undefined) {
+        throw new Error("No session to watch for: set MACHINES_RUN_OWNER to the id of the session whose status line shows the runs.");
+    }
+    // Refuses a session id that cannot name a file.
+    runWatchPath(directory, session);
+    return { directory, session };
+}
+async function respond(args) {
+    const question = args[0] === "--question";
+    const [runId, requestId, ...words] = question ? args.slice(1) : args;
+    if (words[0] === "--")
+        words.shift();
+    if (runId === undefined || requestId === undefined || words.length === 0) {
+        throw new Error("Usage: machine respond [--question] <run-id> <request-id> [--] <response>");
+    }
+    const text = words.join(" ");
+    await respondToRun({
+        directory: requireStatusDirectory(),
+        runId,
+        requestId,
+        response: question ? { type: "question", text } : text,
+    });
+    console.log(`Machine run ${runId} took the ${question ? "question" : "response"}.`);
+}
+function requireStatusDirectory() {
+    const directory = runStatusDirectory();
+    if (directory === undefined) {
+        throw new Error("Run status publication is off: set MACHINES_RUN_STATUS_DIR to the directory the runs publish to.");
+    }
+    return directory;
+}
+async function parseRunArguments(args) {
+    let inputFile;
     const agentOverrides = new Map();
     let index = 0;
     while (index < args.length) {
@@ -96,6 +279,13 @@ function parseRunArguments(args) {
             index += 1;
             break;
         }
+        if (argument === "--input-file") {
+            if (inputFile !== undefined || args[index + 1] === undefined)
+                throw new Error("Expected one --input-file <file|->");
+            inputFile = args[index + 1];
+            index += 2;
+            continue;
+        }
         if (argument !== "--agent")
             break;
         const assignment = args[index + 1];
@@ -117,10 +307,24 @@ function parseRunArguments(args) {
         agentOverrides.set(role, preset);
         index += 2;
     }
-    return {
-        agentOverrides,
-        input: args.slice(index).join(" "),
-    };
+    let input = args.slice(index).join(" ");
+    if (inputFile !== undefined) {
+        if (args.length > index)
+            throw new Error("Use positional input or --input-file, not both");
+        let text;
+        if (inputFile === "-") {
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(Buffer.from(chunk));
+            text = Buffer.concat(chunks).toString("utf8");
+        }
+        else
+            text = await readFile(inputFile, "utf8");
+        const parsed = JSON.parse(text);
+        assertJsonValue(parsed, "Machine input");
+        input = parsed;
+    }
+    return { agentOverrides, input };
 }
 function printMachineListing(found, separate) {
     if (!process.stdout.isTTY) {
@@ -153,6 +357,7 @@ function printAgentListing(preset, separate) {
             preset.model ?? "",
             preset.thinking ?? "",
             preset.source,
+            preset.fallback?.join(", ") ?? "",
         ].join("\t"));
         return;
     }
@@ -162,8 +367,53 @@ function printAgentListing(preset, separate) {
     console.log(`  ${preset.description}`);
     if (identity.length > 0)
         console.log(`  ${magenta(identity.join(" · "))}`);
+    if (preset.fallback !== undefined)
+        console.log(`  fallback: ${preset.fallback.join(", ") || "none"}`);
     console.log(`  ${dim(preset.source)}`);
 }
+/** Recorded text must not be able to move the cursor or restyle the terminal. */
+function plain(text) {
+    return text.replace(/[\u0000-\u001f\u007f-\u009f]+/gu, " ").trim();
+}
+/** A run as tab-separated columns: its label follows the four that were always there. */
+function runColumns(record) {
+    const label = record.label === undefined ? "" : plain(record.label);
+    return [record.id, record.machine, runStatus(record), record.state ?? "starting"].map(plain).concat(label === "" ? [] : [label]);
+}
+function printRunListing(record, separate, watched) {
+    const state = record.state ?? "starting";
+    const recorded = runStatus(record);
+    const human = recorded === "waiting" ? record.human : undefined;
+    // A run that finished or lost its process is no longer waiting for anything.
+    const limit = recorded === "running" || recorded === "waiting" ? record.limit : undefined;
+    const details = human === undefined ? (limit === undefined ? [] : [plain(limit.text)]) : [
+        ...human.prompt.split("\n").map(plain).filter((line) => line !== ""),
+        ...(human.requestId === undefined ? [] : [`request: ${plain(human.requestId)}`]),
+        ...(record.answeredBy === "host" ? ["answered through its host"] : []),
+        ...(human.choices === undefined ? [] : [`choices: ${human.choices.map(plain).join(", ")}`]),
+        ...(human.suggestions === undefined ? [] : [`suggestions: ${human.suggestions.map(plain).join(", ")}`]),
+        ...(human.discussion === true ? ["discussion: questions allowed"] : []),
+    ];
+    if (!process.stdout.isTTY) {
+        const columns = runColumns(record);
+        // The mark has its own column, after the label's, whether or not the run has a label.
+        console.log((watched ? [...columns, ...(columns.length === 4 ? [""] : []), "watched"] : columns).join("\t"));
+        for (const line of details)
+            console.log(`  ${line}`);
+        return;
+    }
+    if (separate)
+        console.log();
+    const status = recorded === "waiting"
+        ? yellow(recorded)
+        : recorded === "running" ? cyan(recorded) : recorded === "completed" ? green(recorded) : red(recorded);
+    console.log(`${bold(plain(record.id))}  ${bold(cyan(plain(record.machine)))} › ${status} · ${plain(state)}${watched ? ` · ${dim("watched")}` : ""}`);
+    if (record.label !== undefined && plain(record.label) !== "")
+        console.log(`  ${plain(record.label)}`);
+    for (const line of details) {
+        console.log(`  ${line.startsWith("request: ") || line === "answered through its host" ? dim(line) : line}`);
+    }
+}
 function printMachineHeader(machinePath) {
     if (!process.stdout.isTTY) {
         console.log(`Machine: ${machinePath}`);
@@ -179,7 +429,10 @@ function createRunStatus(machinePath) {
             onState(state) {
                 console.error(`● ${name} · ${formatState(state)}`);
             },
-            onAgentUpdate() { },
+            onAgentUpdate(update) {
+                if (update.type === "limit")
+                    console.error(update.text.replace(/\s+/gu, " "));
+            },
             onHumanInput() { },
             succeed() { },
             fail() { },
@@ -192,6 +445,8 @@ function createRunStatus(machinePath) {
     let activityExpanded = false;
     let agentOutput = "";
     let agentIdentity = {};
+    let agentLimit = "";
+    let agentWaiting = false;
     let refresh;
     const tools = new Map();
     const hotkeysAvailable = Boolean(process.stdin.isTTY && process.stdin.setRawMode);
@@ -211,12 +466,14 @@ function createRunStatus(machinePath) {
                 ? undefined
                 : `thinking ${agentIdentity.thinking}`,
         ].filter(Boolean).join(" · ");
-        const identityLine = identity === ""
+        const width = Math.max(20, (process.stderr.columns ?? 100) - 4);
+        const identityLine = identity === "" ? "" : `\n  ${dim(truncate(identity, width))}`;
+        const limitLine = agentLimit === ""
             ? ""
-            : `\n  ${dim(truncate(identity, Math.max(20, (process.stderr.columns ?? 100) - 4)))}`;
+            : `\n  ${yellow(truncate(stripVTControlCharacters(agentLimit).replace(/\s+/gu, " "), width))}`;
         return activityExpanded
-            ? `${status}${identityLine}\n${activityText()}`
-            : `${status}${identityLine}`;
+            ? `${status}${identityLine}${limitLine}\n${activityText()}`
+            : `${status}${identityLine}${limitLine}`;
     }
     function completedText() {
         return `${green(displayState(currentState))} · ${dim(formatElapsed(Date.now() - enteredAt))}`;
@@ -317,6 +574,13 @@ function createRunStatus(machinePath) {
             else if (update.type === "output") {
                 agentOutput = (agentOutput + update.text).slice(-32_768);
             }
+            else if (update.type === "limit") {
+                // A wait stays on screen while its presets are tried again, until one of them resumes.
+                if (update.status !== "swapped")
+                    agentWaiting = update.status === "waiting";
+                if (update.status !== "swapped" || !agentWaiting)
+                    agentLimit = update.text;
+            }
             else {
                 const previous = tools.get(update.id);
                 tools.set(update.id, {
@@ -344,6 +608,8 @@ function createRunStatus(machinePath) {
             enteredAt = Date.now();
             agentOutput = "";
             agentIdentity = {};
+            agentLimit = "";
+            agentWaiting = false;
             tools.clear();
             if (humanInputActive)
                 return;

package/dist/src/codex.d.ts

@@ -0,0 +1,16 @@
+import type { AgentRunner } from "./index.ts";
+export interface CodexAgentOptions {
+    readonly env?: Readonly<Record<string, string>>;
+    readonly harness?: string;
+    readonly model?: string;
+    /** A reasoning effort supported by the selected Codex model. */
+    readonly effort?: string;
+    /** Defaults to read-only; writes and unrestricted access require an explicit choice. */
+    readonly sandbox?: "read-only" | "workspace-write" | "danger-full-access";
+    readonly skipGitRepoCheck?: boolean;
+    /** Defaults to true, so each invocation does not persist a Codex session. */
+    readonly ephemeral?: boolean;
+    readonly output?: "capture" | "stream";
+}
+/** Runs one fresh, non-interactive Codex turn using the installed CLI and its authentication. */
+export declare function codexAgent(command?: string, args?: readonly string[], options?: CodexAgentOptions): AgentRunner;

package/dist/src/codex.js

@@ -0,0 +1,176 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import * as v from "valibot";
+import { AgentLimitError } from "./agent-limit.js";
+import { agentPrompt, readAgentEvent } from "./agent-protocol.js";
+/** Runs one fresh, non-interactive Codex turn using the installed CLI and its authentication. */
+export function codexAgent(command = "codex", args = [], options = {}) {
+    return async (request, report) => {
+        if (request.cwd === undefined)
+            throw new Error("Codex Agent requires a working directory");
+        if (request.outcomes.length === 0)
+            throw new Error("Codex Agent requires at least one allowed outcome");
+        const harness = options.harness ?? command;
+        const env = { ...process.env, ...options.env };
+        const model = options.model ?? env.CODEX_MODEL ?? env.MACHINES_AGENT_MODEL;
+        const effort = options.effort ?? env.CODEX_EFFORT ?? env.MACHINES_AGENT_EFFORT;
+        const outputMode = options.output ?? "stream";
+        report?.({
+            type: "identity",
+            harness,
+            ...(model === undefined ? {} : { model }),
+            ...(effort === undefined ? {} : { thinking: effort }),
+        });
+        const temporary = await mkdtemp(join(tmpdir(), "machines-codex-result-"));
+        const finalPath = join(temporary, "response.txt");
+        let stderr = "";
+        try {
+            const child = spawn(command, [
+                ...args,
+                "exec", "--json", "--color", "never",
+                "--sandbox", options.sandbox ?? "read-only",
+                "--config", 'approval_policy="never"',
+                ...(options.skipGitRepoCheck === true ? ["--skip-git-repo-check"] : []),
+                ...(options.ephemeral === false ? [] : ["--ephemeral"]),
+                ...(model === undefined ? [] : ["--model", model]),
+                ...(effort === undefined ? [] : ["--config", `model_reasoning_effort=${JSON.stringify(effort)}`]),
+                "--output-last-message", finalPath, "-",
+            ], { cwd: request.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+            const exited = new Promise((resolve, reject) => {
+                child.once("error", reject);
+                child.stdin.once("error", reject);
+                child.once("close", (code, signal) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(signal === null
+                            ? `Process exited with code ${code}`
+                            : `Process terminated by ${signal}`));
+                });
+            });
+            // Attach handlers before reading stdout: errors can arrive while it drains.
+            void exited.catch(() => { });
+            child.stderr.setEncoding("utf8");
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk;
+                if (outputMode === "stream")
+                    process.stderr.write(chunk);
+            });
+            const lines = createInterface({ input: child.stdout });
+            let completed = false;
+            let failure;
+            let lastError;
+            let lastMessage;
+            const emitMessage = (text) => {
+                if (text === "")
+                    return;
+                report?.({ type: "output", text: `${text}${text.endsWith("\n") ? "" : "\n"}` });
+                if (outputMode === "stream")
+                    process.stdout.write(`${text}${text.endsWith("\n") ? "" : "\n"}`);
+            };
+            try {
+                child.stdin.end(agentPrompt(request));
+                for await (const line of lines) {
+                    const record = decodeRecord(line);
+                    if (record === undefined)
+                        continue;
+                    if (record.type === "turn.completed")
+                        completed = true;
+                    else if (record.type === "turn.failed")
+                        failure = record.error.message;
+                    else if (record.type === "error")
+                        lastError = record.message;
+                    else {
+                        const item = record.item;
+                        if (item.type === "agent_message") {
+                            if (record.type === "item.completed") {
+                                lastMessage = item.text;
+                                emitMessage(item.text);
+                            }
+                        }
+                        else {
+                            const title = item.type === "command_execution" ? item.command
+                                : item.type === "mcp_tool_call" ? `${item.server}/${item.tool}`
+                                    : item.type === "web_search" ? item.query : "File changes";
+                            const status = item.status === "failed" || item.status === "declined" ? "failed"
+                                : record.type === "item.completed" ? "completed" : "in_progress";
+                            report?.({ type: "tool", id: item.id, title, status });
+                        }
+                    }
+                }
+                // Codex states a usage limit only in the text of a failed turn.
+                const detail = failure ?? lastError;
+                const turnFailure = (message, cause) => detail !== undefined && usageLimitText.test(detail)
+                    ? new AgentLimitError(message, { harness, kind: "usage" }, cause)
+                    : new Error(message, cause);
+                try {
+                    await exited;
+                }
+                catch (cause) {
+                    if (detail === undefined)
+                        throw cause;
+                    const message = cause instanceof Error ? cause.message : String(cause);
+                    throw turnFailure(`${message}: ${detail}`, { cause });
+                }
+                if (failure !== undefined)
+                    throw turnFailure(failure);
+                if (!completed)
+                    throw turnFailure(lastError ?? "Codex exited without completing its turn");
+                // A progress message may contain a preliminary event. Only the CLI's
+                // final-response file determines the outcome, never accumulated activity.
+                const response = await readFile(finalPath, "utf8");
+                if (response.trimEnd() !== lastMessage?.trimEnd())
+                    emitMessage(response);
+                return readAgentEvent(response, { adapter: "Codex", includeMessage: outputMode === "capture" });
+            }
+            finally {
+                lines.close();
+                child.kill();
+            }
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            const detail = stderr.trim();
+            const text = `Codex Agent "${command}" failed in "${request.cwd}": ${message}${detail === "" ? "" : `\n${detail}`}`;
+            throw cause instanceof AgentLimitError
+                ? new AgentLimitError(text, cause.limit, { cause })
+                : new Error(text, { cause });
+        }
+        finally {
+            await rm(temporary, { recursive: true, force: true });
+        }
+    };
+}
+// Codex 0.162.1 writes the first of these with a typographic apostrophe (U+2019).
+const usageLimitText = /^(?:You['’]ve hit your usage limit|Your workspace is out of credits|You hit your spend cap)/u;
+const statusSchema = v.optional(v.picklist(["in_progress", "completed", "failed", "declined"]));
+const itemSchema = v.variant("type", [
+    v.object({ type: v.literal("agent_message"), id: v.string(), text: v.string() }),
+    v.object({ type: v.literal("command_execution"), id: v.string(), command: v.string(), status: statusSchema }),
+    v.object({ type: v.literal("file_change"), id: v.string(), status: statusSchema }),
+    v.object({ type: v.literal("mcp_tool_call"), id: v.string(), server: v.string(), tool: v.string(), status: statusSchema }),
+    v.object({ type: v.literal("web_search"), id: v.string(), query: v.string(), status: statusSchema }),
+]);
+const recordSchema = v.variant("type", [
+    v.object({ type: v.literal("item.started"), item: itemSchema }),
+    v.object({ type: v.literal("item.updated"), item: itemSchema }),
+    v.object({ type: v.literal("item.completed"), item: itemSchema }),
+    v.object({ type: v.literal("turn.completed") }),
+    v.object({ type: v.literal("turn.failed"), error: v.object({ message: v.string() }) }),
+    v.object({ type: v.literal("error"), message: v.string() }),
+]);
+// Ignore unsupported events and malformed records without exposing raw protocol data.
+function decodeRecord(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const result = v.safeParse(recordSchema, value);
+    return result.success ? result.output : undefined;
+}