codex-exec-json 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# codex-exec-json
+
+This is a tiny wrapper around `codex exec`. It runs a one-shot, non-interactive Codex task, forces a JSON-shaped final answer, writes that JSON to a file, prints the file path, and exits. It is meant for agents and automations that want a predictable machine-readable output and no long-lived session.
+
+## Install / npx
+
+```bash
+npx -y codex-exec-json "summarize this repo"
+```
+
+## Usage
+
+```bash
+codex-exec-json [options] <prompt...>
+```
+
+Options are `--schema <json>` for an inline JSON schema string, `--schema-file <path>` to load a schema from disk, `--out <path>` to control the output file path (default is `/tmp/.codex-exec.<uuid>.json`), `--model <name>` to select a model, `--reasoning <level>` to set reasoning effort, `--codex-bin <path>` to point at a different Codex binary, `--yolo` to bypass approvals and sandboxing, `--keep-trace` to keep Codex session files, `--models` to print available models, `--models-json` to print models as JSON, and `--help` to show usage.
+
+Pass through args to Codex after `--`:
+
+```bash
+codex-exec-json -- --add-dir /tmp "update the README"
+```
+
+## For LLMs and agents
+
+The point is to return a JSON file and exit. Treat stdout as the file path and read the JSON from disk.
+
+```bash
+npx -y codex-exec-json --schema '{"type":"object","properties":{"summary":{"type":"string"},"next":{"type":"array","items":{"type":"string"}}},"required":["summary","next"]}' "Summarize and list next steps"
+```
+
+Example flow:
+
+```bash
+OUT=$(npx -y codex-exec-json "Describe the repo in JSON")
+cat "$OUT"
+```
+
+## Models and reasoning levels
+
+To list available models and their supported reasoning levels with descriptions, run:
+
+```bash
+npx -y codex-exec-json --models
+```
+
+For JSON output:
+
+```bash
+npx -y codex-exec-json --models-json
+```
+
+This uses your Codex auth and local cache. If the API is unavailable, it falls back to the built-in preset list.
+
+## Default schema
+
+If no schema is provided, this default is used, so you always get a predictable JSON object:
+
+```json
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "ok": { "type": "boolean" },
+    "result": { "type": "string" },
+    "error": { "type": "string" }
+  },
+  "required": ["ok", "result"]
+}
+```
+
+## Skill
+
+If you use the Codex skills format, a ready-to-pull skill is included at `skills/codex-exec-json/SKILL.md`.

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,639 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile, writeFile, readdir, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+const DEFAULT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        ok: { type: "boolean" },
+        result: { type: "string" },
+        error: { type: "string" }
+    },
+    required: ["ok", "result"]
+};
+const FALLBACK_MODELS = [
+    {
+        slug: "gpt-5.2-codex",
+        display_name: "gpt-5.2-codex",
+        description: "Latest frontier agentic coding model.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "low", description: "Fast responses with lighter reasoning" },
+            { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
+            { effort: "high", description: "Greater reasoning depth for complex problems" },
+            { effort: "xhigh", description: "Extra high reasoning depth for complex problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5.1-codex-max",
+        display_name: "gpt-5.1-codex-max",
+        description: "Codex-optimized flagship for deep and fast reasoning.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "low", description: "Fast responses with lighter reasoning" },
+            { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
+            { effort: "high", description: "Greater reasoning depth for complex problems" },
+            { effort: "xhigh", description: "Extra high reasoning depth for complex problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5.1-codex-mini",
+        display_name: "gpt-5.1-codex-mini",
+        description: "Optimized for codex. Cheaper, faster, but less capable.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "medium", description: "Dynamically adjusts reasoning based on the task" },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5.2",
+        display_name: "gpt-5.2",
+        description: "Latest frontier model with improvements across knowledge, reasoning and coding",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            {
+                effort: "low",
+                description: "Balances speed with some reasoning; useful for straightforward queries and short explanations"
+            },
+            {
+                effort: "medium",
+                description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks"
+            },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" },
+            { effort: "xhigh", description: "Extra high reasoning depth for complex problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "bengalfox",
+        display_name: "bengalfox",
+        description: "bengalfox",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "low", description: "Fast responses with lighter reasoning" },
+            { effort: "medium", description: "Balances speed and reasoning depth for everyday tasks" },
+            { effort: "high", description: "Greater reasoning depth for complex problems" },
+            { effort: "xhigh", description: "Extra high reasoning depth for complex problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "boomslang",
+        display_name: "boomslang",
+        description: "boomslang",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            {
+                effort: "low",
+                description: "Balances speed with some reasoning; useful for straightforward queries and short explanations"
+            },
+            {
+                effort: "medium",
+                description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks"
+            },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" },
+            { effort: "xhigh", description: "Extra high reasoning depth for complex problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5-codex",
+        display_name: "gpt-5-codex",
+        description: "Optimized for codex.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "low", description: "Fastest responses with limited reasoning" },
+            { effort: "medium", description: "Dynamically adjusts reasoning based on the task" },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5-codex-mini",
+        display_name: "gpt-5-codex-mini",
+        description: "Optimized for codex. Cheaper, faster, but less capable.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "medium", description: "Dynamically adjusts reasoning based on the task" },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5.1-codex",
+        display_name: "gpt-5.1-codex",
+        description: "Optimized for codex.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "low", description: "Fastest responses with limited reasoning" },
+            { effort: "medium", description: "Dynamically adjusts reasoning based on the task" },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5",
+        display_name: "gpt-5",
+        description: "Broad world knowledge with strong general reasoning.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "minimal", description: "Fastest responses with little reasoning" },
+            {
+                effort: "low",
+                description: "Balances speed with some reasoning; useful for straightforward queries and short explanations"
+            },
+            {
+                effort: "medium",
+                description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks"
+            },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" }
+        ],
+        supported_in_api: true
+    },
+    {
+        slug: "gpt-5.1",
+        display_name: "gpt-5.1",
+        description: "Broad world knowledge with strong general reasoning.",
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            {
+                effort: "low",
+                description: "Balances speed with some reasoning; useful for straightforward queries and short explanations"
+            },
+            {
+                effort: "medium",
+                description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks"
+            },
+            { effort: "high", description: "Maximizes reasoning depth for complex or ambiguous problems" }
+        ],
+        supported_in_api: true
+    }
+];
+const USAGE = `codex-exec-json [options] <prompt...>
+
+Options:
+  --schema <json>         Inline JSON schema string
+  --schema-file <path>    Path to JSON schema file
+  --out <path>            Output file path (default: /tmp/.codex-exec.<uuid>.json)
+  --model <name>          Codex model to use
+  --reasoning <level>     Reasoning effort (none|minimal|low|medium|high|xhigh)
+  --codex-bin <path>      Path to codex binary (default: codex)
+  --yolo                  Pass --dangerously-bypass-approvals-and-sandbox
+  --keep-trace            Do not delete new session files
+  --models                Print available models and reasoning levels
+  --models-json           Print available models as JSON
+  --help                  Show help
+
+Pass through args to codex after "--":
+  codex-exec-json -- --add-dir /tmp "do the thing"`;
+function parseArgs(argv) {
+    const options = {
+        yolo: false,
+        keepTrace: false,
+        codexBin: "codex",
+        showModels: false,
+        showModelsJson: false,
+        passThroughArgs: []
+    };
+    const promptParts = [];
+    const passThroughIndex = argv.indexOf("--");
+    const mainArgs = passThroughIndex === -1 ? argv : argv.slice(0, passThroughIndex);
+    const passThroughArgs = passThroughIndex === -1 ? [] : argv.slice(passThroughIndex + 1);
+    options.passThroughArgs = passThroughArgs;
+    for (let i = 0; i < mainArgs.length; i += 1) {
+        const arg = mainArgs[i];
+        if (arg === "--help" || arg === "-h") {
+            console.log(USAGE);
+            process.exit(0);
+        }
+        if (arg === "--schema") {
+            const value = mainArgs[i + 1];
+            if (!value)
+                throw new Error("--schema requires a value");
+            options.schemaJson = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--schema-file") {
+            const value = mainArgs[i + 1];
+            if (!value)
+                throw new Error("--schema-file requires a value");
+            options.schemaFile = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--out") {
+            const value = mainArgs[i + 1];
+            if (!value)
+                throw new Error("--out requires a value");
+            options.outPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--model") {
+            const value = mainArgs[i + 1];
+            if (!value)
+                throw new Error("--model requires a value");
+            options.model = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--reasoning") {
+            const value = mainArgs[i + 1];
+            if (!value)
+                throw new Error("--reasoning requires a value");
+            options.reasoning = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--codex-bin") {
+            const value = mainArgs[i + 1];
+            if (!value)
+                throw new Error("--codex-bin requires a value");
+            options.codexBin = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--yolo") {
+            options.yolo = true;
+            continue;
+        }
+        if (arg === "--keep-trace") {
+            options.keepTrace = true;
+            continue;
+        }
+        if (arg === "--models") {
+            options.showModels = true;
+            continue;
+        }
+        if (arg === "--models-json") {
+            options.showModelsJson = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        promptParts.push(arg);
+    }
+    return { options, promptParts };
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return "";
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function resolveSchema(options) {
+    if (options.schemaJson && options.schemaFile) {
+        throw new Error("Use only one of --schema or --schema-file");
+    }
+    if (options.schemaFile) {
+        const fileContents = await readFile(options.schemaFile, "utf8");
+        const schemaObj = JSON.parse(fileContents);
+        return { schemaObj, schemaString: JSON.stringify(schemaObj) };
+    }
+    if (options.schemaJson) {
+        const schemaObj = JSON.parse(options.schemaJson);
+        return { schemaObj, schemaString: JSON.stringify(schemaObj) };
+    }
+    const schemaObj = DEFAULT_SCHEMA;
+    return { schemaObj, schemaString: JSON.stringify(schemaObj) };
+}
+function getCodexHome() {
+    return process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+}
+async function listSessionFiles(codexHome) {
+    const sessionsDir = path.join(codexHome, "sessions");
+    if (!existsSync(sessionsDir))
+        return [];
+    const results = [];
+    const stack = [sessionsDir];
+    while (stack.length) {
+        const dir = stack.pop();
+        if (!dir)
+            break;
+        let entries = [];
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else if (entry.isFile()) {
+                results.push(fullPath);
+            }
+        }
+    }
+    return results;
+}
+async function deleteNewSessionFiles(before, after, codexHome) {
+    const beforeSet = new Set(before);
+    const newFiles = after.filter((p) => !beforeSet.has(p));
+    for (const file of newFiles) {
+        try {
+            await rm(file, { force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+    const sessionsDir = path.join(codexHome, "sessions");
+    for (const file of newFiles) {
+        let dir = path.dirname(file);
+        while (dir.startsWith(sessionsDir) && dir !== sessionsDir) {
+            try {
+                const items = await readdir(dir);
+                if (items.length === 0) {
+                    await rm(dir, { force: true, recursive: true });
+                    dir = path.dirname(dir);
+                    continue;
+                }
+            }
+            catch {
+                // ignore
+            }
+            break;
+        }
+    }
+}
+async function getCodexVersion(codexBin) {
+    const child = spawn(codexBin, ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+        stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+        stderr += d.toString();
+    });
+    const exitCode = await new Promise((resolve) => child.on("close", resolve));
+    if (exitCode !== 0) {
+        if (stderr.trim()) {
+            throw new Error(stderr.trim());
+        }
+        throw new Error("Failed to get codex version");
+    }
+    const match = stdout.trim().match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : "0.0.0";
+}
+async function readConfigValue(key) {
+    const configPath = path.join(getCodexHome(), "config.toml");
+    if (!existsSync(configPath))
+        return null;
+    const text = await readFile(configPath, "utf8");
+    const re = new RegExp(`^\\s*${key}\\s*=\\s*\"([^\"]+)\"`, "m");
+    const match = text.match(re);
+    return match ? match[1] : null;
+}
+async function loadAuth() {
+    const authPath = path.join(getCodexHome(), "auth.json");
+    if (!existsSync(authPath))
+        return {};
+    const raw = await readFile(authPath, "utf8");
+    const data = JSON.parse(raw);
+    const tokens = data.tokens;
+    const accessToken = typeof tokens?.access_token === "string" ? tokens.access_token : undefined;
+    const accountId = typeof tokens?.account_id === "string" ? tokens.account_id : undefined;
+    const apiKey = typeof data.OPENAI_API_KEY === "string" ? data.OPENAI_API_KEY : undefined;
+    return { accessToken, accountId, apiKey };
+}
+async function loadModelsCache(codexHome) {
+    const cachePath = path.join(codexHome, "models_cache.json");
+    if (!existsSync(cachePath))
+        return null;
+    try {
+        const raw = await readFile(cachePath, "utf8");
+        const data = JSON.parse(raw);
+        if (Array.isArray(data.models) && data.models.length > 0)
+            return data.models;
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+async function primeModelsCache(codexBin, codexHome) {
+    const uuid = crypto.randomUUID();
+    const outputPath = path.join(os.tmpdir(), `.codex-exec-models.${uuid}.json`);
+    const schemaPath = path.join(os.tmpdir(), `.codex-exec-models-schema.${uuid}.json`);
+    const schema = {
+        type: "object",
+        additionalProperties: false,
+        properties: { ok: { type: "boolean" } },
+        required: ["ok"]
+    };
+    await writeFile(schemaPath, JSON.stringify(schema), "utf8");
+    const before = await listSessionFiles(codexHome);
+    const args = [
+        "exec",
+        "--skip-git-repo-check",
+        "--output-last-message",
+        outputPath,
+        "--output-schema",
+        schemaPath,
+        "--color",
+        "never",
+        "Return {\"ok\": true}"
+    ];
+    const child = spawn(codexBin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.on("data", () => { });
+    child.stderr.on("data", () => { });
+    await new Promise((resolve) => child.on("close", resolve));
+    const after = await listSessionFiles(codexHome);
+    await deleteNewSessionFiles(before, after, codexHome);
+    try {
+        await rm(outputPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+    try {
+        await rm(schemaPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+async function fetchModels(codexBin) {
+    const codexHome = getCodexHome();
+    const cached = await loadModelsCache(codexHome);
+    if (cached && cached.length > 0)
+        return { models: cached, source: "cache" };
+    const version = await getCodexVersion(codexBin);
+    const { accessToken, accountId, apiKey } = await loadAuth();
+    const chatgptBase = (await readConfigValue("chatgpt_base_url")) || "https://chatgpt.com/backend-api/";
+    const chatgptBaseClean = chatgptBase.replace(/\/+$/, "");
+    const codexBase = chatgptBaseClean.endsWith("/codex") ? chatgptBaseClean : `${chatgptBaseClean}/codex`;
+    if (accessToken) {
+        const url = new URL(`${codexBase}/models`);
+        url.searchParams.set("client_version", version);
+        const headers = {
+            Authorization: `Bearer ${accessToken}`
+        };
+        if (accountId)
+            headers["ChatGPT-Account-ID"] = accountId;
+        const res = await fetch(url, { headers });
+        if (res.ok) {
+            const body = (await res.json());
+            if (Array.isArray(body.models))
+                return { models: body.models, source: "api" };
+        }
+    }
+    if (apiKey) {
+        const url = new URL("https://api.openai.com/v1/models");
+        const headers = { Authorization: `Bearer ${apiKey}` };
+        const res = await fetch(url, { headers });
+        if (res.ok) {
+            const body = (await res.json());
+            if (Array.isArray(body.data)) {
+                return {
+                    models: body.data.map((item) => ({
+                        slug: item.id,
+                        display_name: item.id,
+                        description: "OpenAI model",
+                        supported_reasoning_levels: []
+                    })),
+                    source: "api"
+                };
+            }
+        }
+    }
+    await primeModelsCache(codexBin, codexHome);
+    const cachedAfter = await loadModelsCache(codexHome);
+    if (cachedAfter && cachedAfter.length > 0)
+        return { models: cachedAfter, source: "cache" };
+    return { models: FALLBACK_MODELS, source: "fallback" };
+}
+function formatModelsText(models) {
+    const lines = [];
+    for (const model of models) {
+        lines.push(`${model.slug} (${model.display_name})`);
+        if (model.description) {
+            lines.push(model.description);
+        }
+        const defaultReasoning = model.default_reasoning_level ?? "default";
+        const supported = model.supported_reasoning_levels || [];
+        if (supported.length > 0) {
+            lines.push(`Reasoning default: ${defaultReasoning}`);
+            for (const preset of supported) {
+                lines.push(`- ${preset.effort}: ${preset.description}`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+async function runCodex(options, prompt, schemaString, outputPath) {
+    const schemaPath = path.join(os.tmpdir(), `.codex-exec-schema.${crypto.randomUUID()}.json`);
+    await writeFile(schemaPath, schemaString, "utf8");
+    const preprompt = [
+        "You are running in exec mode.",
+        "Return only valid JSON that matches the provided schema.",
+        "Do not include extra text."
+    ].join(" ");
+    const finalPrompt = `${preprompt}\n\nTask: ${prompt}`;
+    const args = [
+        "exec",
+        "--skip-git-repo-check",
+        "--output-last-message",
+        outputPath,
+        "--output-schema",
+        schemaPath,
+        "--color",
+        "never"
+    ];
+    if (options.model) {
+        args.push("--model", options.model);
+    }
+    if (options.reasoning) {
+        args.push("--config", `model_reasoning_effort=\"${options.reasoning}\"`);
+    }
+    if (options.yolo) {
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    }
+    args.push(...options.passThroughArgs, finalPrompt);
+    const codexHome = getCodexHome();
+    const beforeSessions = options.keepTrace ? [] : await listSessionFiles(codexHome);
+    const child = spawn(options.codexBin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+        stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+        stderr += data.toString();
+    });
+    const exitCode = await new Promise((resolve) => {
+        child.on("close", resolve);
+    });
+    if (!options.keepTrace) {
+        const afterSessions = await listSessionFiles(codexHome);
+        await deleteNewSessionFiles(beforeSessions, afterSessions, codexHome);
+    }
+    try {
+        await rm(schemaPath, { force: true });
+    }
+    catch {
+        // ignore
+    }
+    if (exitCode !== 0) {
+        if (stderr.trim()) {
+            console.error(stderr.trim());
+        }
+        else if (stdout.trim()) {
+            console.error(stdout.trim());
+        }
+        throw new Error(`codex exited with code ${exitCode}`);
+    }
+}
+async function run() {
+    const { options, promptParts } = parseArgs(process.argv.slice(2));
+    if (options.showModels || options.showModelsJson) {
+        const { models, source } = await fetchModels(options.codexBin);
+        if (options.showModelsJson) {
+            console.log(JSON.stringify({ source, models }, null, 2));
+        }
+        else {
+            const header = source === "fallback"
+                ? "Models (fallback list)"
+                : source === "cache"
+                    ? "Models (cached)"
+                    : "Models";
+            console.log(`${header}\\n\\n${formatModelsText(models)}`.trim());
+        }
+        return;
+    }
+    const stdinPrompt = await readStdin();
+    const prompt = promptParts.join(" ").trim() || stdinPrompt.trim();
+    if (!prompt) {
+        console.error("Missing prompt. Provide a prompt as arguments or via stdin.\n");
+        console.error(USAGE);
+        process.exit(1);
+    }
+    const uuid = crypto.randomUUID();
+    const outputPath = options.outPath ?? path.join(os.tmpdir(), `.codex-exec.${uuid}.json`);
+    const { schemaString } = await resolveSchema(options);
+    await runCodex(options, prompt, schemaString, outputPath);
+    console.log(outputPath);
+}
+run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "codex-exec-json",
+  "version": "0.1.0",
+  "description": "Run Codex exec in non-persistent mode and write structured JSON output to a temp file",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "codex-exec-json": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "codex",
+    "cli",
+    "json",
+    "exec"
+  ],
+  "author": "pp",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "typescript": "^5.6.3"
+  }
+}