agent-dealer 0.1.13 → 0.3.0

package/bundle/server/dist/runners/models.js

@@ -1,6 +1,9 @@
 import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { CURSOR_DEFAULT_MODEL, CURSOR_SUBSCRIPTION_MODEL_IDS } from "@agent-dealer/shared";
-import { cursorInvokeArgs, resolveCursorBin } from "../cli-env.js";
+import { cursorInvokeArgs, resolveCursorBin, resolveCodexBin } from "../cli-env.js";
 const CURSOR_PINNED = [
     { id: CURSOR_DEFAULT_MODEL, label: "Auto (subscription pool)" },
     { id: "composer-2.5", label: "Composer 2.5 (subscription pool)" },
@@ -15,6 +18,11 @@ const CLAUDE_FALLBACK = [
     { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
     { id: "claude-haiku-4-5", label: "Claude Haiku 4.5" },
 ];
+const CODEX_FALLBACK = [
+    { id: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
+    { id: "gpt-5.6-terra", label: "GPT-5.6 Terra" },
+    { id: "gpt-5.6-luna", label: "GPT-5.6 Luna" },
+];
 /** Live CLI/API lists change rarely — default 14d; bust with server restart or GET ?refresh=1. */
 const LIVE_CACHE_MS = Number(process.env.RUNTIME_MODELS_CACHE_MS ?? 14 * 24 * 60 * 60 * 1000);
 /** Failed/empty fetch — retry sooner; successful lists use LIVE_CACHE_MS. */
@@ -90,10 +98,54 @@ function listCursorModels() {
     }
     return { models: CURSOR_FALLBACK, source: "fallback" };
 }
+function listCodexModelsFromCache() {
+    const home = process.env.HOME ?? os.homedir();
+    const cachePath = path.join(home, ".codex", "models_cache.json");
+    if (!fs.existsSync(cachePath))
+        return [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+        return parseCodexModelsCache(raw);
+    }
+    catch {
+        return [];
+    }
+}
+/** Picker-visible Codex models only (`visibility === "list"`). Exported for unit tests. */
+export function parseCodexModelsCache(raw) {
+    if (!raw || typeof raw !== "object")
+        return [];
+    const modelsIn = raw.models;
+    if (!Array.isArray(modelsIn))
+        return [];
+    const models = [];
+    for (const entry of modelsIn) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const m = entry;
+        if (m.visibility !== "list")
+            continue;
+        const id = m.id ?? m.slug;
+        if (!id)
+            continue;
+        models.push({ id, label: m.display_name ?? m.label ?? id });
+    }
+    return models;
+}
+function listCodexModels() {
+    void resolveCodexBin();
+    const live = listCodexModelsFromCache();
+    if (live.length > 0)
+        return { models: live, source: "live" };
+    return { models: CODEX_FALLBACK, source: "fallback" };
+}
 async function fetchRuntimeModelsFresh(runtime) {
     if (runtime === "cursor_local") {
         return listCursorModels();
     }
+    if (runtime === "codex_local") {
+        return listCodexModels();
+    }
     const fromApi = await tryAnthropicModelsApi();
     if (fromApi.length > 0) {
         const aliasIds = new Set(CLAUDE_FALLBACK.map((m) => m.id));

package/bundle/server/dist/runners/persist.js

@@ -4,6 +4,7 @@ import { detectExecutionBlocker, outboundDraftKind } from "@agent-dealer/shared"
 import { addArtifact, appendEvent, getLatestArtifact, getLineageParentRun, resolveBudgetForPhase } from "../repository/runs.js";
 import { getTemporalOutputDir } from "../paths.js";
 import { buildStreamTrace, extractOutboundDraft, extractPlanMarkdown, extractPlanTriage, extractResultIsError, extractResultText, extractSessionId, extractUsage, parseNdjson, } from "./stream-json.js";
+import { normalizeCodexEvents, parseCodexJsonl } from "./codex-jsonl.js";
 import { humanFeedbackText } from "./run-context.js";
 export function seedDeliverableFromParent(run) {
     const parent = getLineageParentRun(run);
@@ -42,7 +43,9 @@ function expectedDocPath(run) {
 export function persistRunOutput(input) {
     const { run, phase, runtime, exitCode, logPath } = input;
     const raw = input.rawTranscript ?? (fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "");
-    const events = parseNdjson(raw);
+    const events = runtime === "codex_local"
+        ? normalizeCodexEvents(parseCodexJsonl(raw))
+        : parseNdjson(raw);
     const sessionId = extractSessionId(events);
     let resultText = extractResultText(events);
     const outboundExtract = phase === "execute" ? extractOutboundDraft(resultText ?? "") : null;

package/bundle/server/dist/runners/qa.js

@@ -1,6 +1,8 @@
 import { runClaude, runCursor } from "./claude.js";
+import { runCodex } from "./codex.js";
 import { buildQaPrompt } from "./prompts.js";
 import { extractResultIsError, extractResultText, extractUsage, parseNdjson } from "./stream-json.js";
+import { normalizeCodexEvents, parseCodexJsonl } from "./codex-jsonl.js";
 /** One read-only Q&A turn against a finished run. Resumes the execute session when we still have it. */
 export async function runQa(run, question, resumeSessionId) {
     let result;
@@ -19,13 +21,27 @@ export async function runQa(run, question, resumeSessionId) {
             });
         }
     }
+    else if (runtime === "codex_local") {
+        const prompt = buildQaPrompt(run, question, { grounded: Boolean(resumeSessionId) });
+        result = await runCodex(run, "qa", executeModel ?? undefined, {
+            promptOverride: prompt,
+            ...(resumeSessionId ? { resumeSessionId } : {}),
+        });
+        if (result.exitCode !== 0 && resumeSessionId) {
+            result = await runCodex(run, "qa", executeModel ?? undefined, {
+                promptOverride: buildQaPrompt(run, question, { grounded: false }),
+            });
+        }
+    }
     else {
         result = await runClaude(run, "qa", executeModel, {
             promptOverride: buildQaPrompt(run, question, { grounded: Boolean(resumeSessionId) }),
             ...(resumeSessionId ? { resumeSessionId } : {}),
         });
     }
-    const events = parseNdjson(result.transcript);
+    const events = runtime === "codex_local"
+        ? normalizeCodexEvents(parseCodexJsonl(result.transcript))
+        : parseNdjson(result.transcript);
     const usage = extractUsage(events, "qa", runtime);
     const answer = extractResultText(events)?.trim() ?? "";
     const failed = result.exitCode !== 0 || extractResultIsError(events) || !answer;

package/bundle/server/dist/runners/spawn-cli.js

@@ -0,0 +1,90 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { getTemporalLogsDir } from "../paths.js";
+import { acquireSpawnSlot, killRunProcess, registerChild, releaseSpawnSlot, unregisterChild, } from "./process-registry.js";
+export { getActiveLogPath, killRunProcess } from "./process-registry.js";
+export function timeoutMsForMode(mode) {
+    const envKey = mode === "plan"
+        ? "PLAN_TIMEOUT_MS"
+        : mode === "execute"
+            ? "EXECUTE_TIMEOUT_MS"
+            : mode === "reflect"
+                ? "REFLECT_TIMEOUT_MS"
+                : "QA_TIMEOUT_MS";
+    const defaults = {
+        plan: 15 * 60_000,
+        execute: 60 * 60_000,
+        reflect: 10 * 60_000,
+        qa: 5 * 60_000,
+    };
+    const raw = process.env[envKey];
+    if (raw !== undefined && raw !== "")
+        return Number(raw);
+    return defaults[mode];
+}
+export async function spawnCli(runId, cmd, args, cwd, opts) {
+    await acquireSpawnSlot();
+    try {
+        return await new Promise((resolve, reject) => {
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            let timedOut = false;
+            let settled = false;
+            const logStream = fs.createWriteStream(opts.logPath, { flags: "w" });
+            const child = spawn(cmd, args, {
+                cwd,
+                env: { ...process.env },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            registerChild(runId, child, opts.logPath);
+            const finish = (exitCode) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                unregisterChild(runId);
+                logStream.end();
+                const stderr = stderrChunks.join("");
+                if (stderr.trim()) {
+                    logStream.write(`\n--- stderr ---\n${stderr}`);
+                }
+                resolve({
+                    exitCode,
+                    transcript: stdoutChunks.join(""),
+                    timedOut,
+                });
+            };
+            const timer = setTimeout(() => {
+                timedOut = true;
+                killRunProcess(runId);
+                setTimeout(() => finish(124), 500);
+            }, opts.timeoutMs);
+            child.stdout?.on("data", (buf) => {
+                const chunk = buf.toString();
+                stdoutChunks.push(chunk);
+                logStream.write(buf);
+            });
+            child.stderr?.on("data", (buf) => {
+                stderrChunks.push(buf.toString());
+            });
+            child.on("error", (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                unregisterChild(runId);
+                logStream.end();
+                reject(err);
+            });
+            child.on("close", (code) => finish(code ?? 1));
+        });
+    }
+    finally {
+        releaseSpawnSlot();
+    }
+}
+export function logPathFor(run, mode) {
+    const logDir = getTemporalLogsDir();
+    return path.join(logDir, `${run.id}-${mode}-${Date.now()}.ndjson`);
+}

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "0.1.13",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -21,7 +21,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agent-dealer/shared": "*",
+    "@agent-dealer/shared": "0.3.0",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",