scenri 0.4.3 → 0.4.4

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.4.4](https://github.com/tonygorb/Scenri/compare/v0.4.3...v0.4.4) (2026-08-23)
+
+
+### Bug Fixes
+
+* cache the codex probe behind one shared runner and kill the whole tree on windows ([7c21235](https://github.com/tonygorb/Scenri/commit/7c212351231e4badcd49b8636f765dcb2ae0d73e))
+* classify codex auth and verification failures where the user can act on them ([83c6512](https://github.com/tonygorb/Scenri/commit/83c651224095664cf439bf9ee0ea483d307bbd0d))
+* harden the codex probe with timeouts, exe resolution and a version floor ([7c57808](https://github.com/tonygorb/Scenri/commit/7c578083b9dc665ea983cded464c0506db44ad3b))
+* honest codex states and platform-aware setup copy in studio ([672195e](https://github.com/tonygorb/Scenri/commit/672195e373ea07940a8d661ed397ecd7d7e540e3))
+* kill the whole install and login tree when a setup step times out on windows ([fa755a2](https://github.com/tonygorb/Scenri/commit/fa755a207b0cb81d53714d948867fce049a99171))
+* leave the codex program token unquoted so npm cmd shims keep their own path ([72cd69d](https://github.com/tonygorb/Scenri/commit/72cd69dc3bbba1d8312d13c3be0379ecbde25d94))
+* let taskkill own the windows kill so the process tree really dies ([340821a](https://github.com/tonygorb/Scenri/commit/340821a35d6db397ae5728047bbc5abf91a93e35))
+* make Codex on Windows honest about readiness and unable to hang ([d698d5f](https://github.com/tonygorb/Scenri/commit/d698d5f526d9365e64e170819a61803ff0162f3e))
+* recover codex images the windows sandbox could not move into the workdir ([4ce1d51](https://github.com/tonygorb/Scenri/commit/4ce1d51352d13f3afb83f190a9cb78bbc7427a0a))
+* send codex prompts over stdin and watchdog silent or runaway generations ([35a7c1b](https://github.com/tonygorb/Scenri/commit/35a7c1bad5c9eea65df338f719ecd2f66065289f))
+* set the codex version floor at the newest release verified working ([531a255](https://github.com/tonygorb/Scenri/commit/531a255b2a2e93a97b8620efa88a727cba06e43b))
+
 ## [0.4.3](https://github.com/tonygorb/Scenri/compare/v0.4.2...v0.4.3) (2026-08-23)
 
 

package/dist/serve.js

@@ -8,7 +8,7 @@ import Database from 'better-sqlite3';
 import { randomBytes, createHash, randomUUID, timingSafeEqual } from 'crypto';
 import fs, { realpathSync, existsSync, readFileSync, mkdirSync, chmodSync, writeFileSync, readdirSync, statSync, rmSync, renameSync } from 'fs';
 import { fileURLToPath } from 'url';
-import { readFile, copyFile, readdir, mkdtemp, rm, writeFile } from 'fs/promises';
+import { readFile, copyFile, mkdtemp, rm, readdir, stat, writeFile } from 'fs/promises';
 import { spawn } from 'child_process';
 import sharp6 from 'sharp';
 import Fastify from 'fastify';
@@ -1850,59 +1850,175 @@ function createFalEngine(opts) {
     }
   };
 }
+
+// ../engines/codex/src/locate.ts
+var MIN_CODEX_VERSION = "0.145.0";
+var WHERE_TIMEOUT_MS = 5e3;
+function parseCodexVersion(text) {
+  const m = /codex-cli\s+(\d+\.\d+\.\d+)/.exec(text);
+  return m ? m[1] : null;
+}
+function versionAtLeast(version, floor) {
+  const a = version.split(".").map(Number);
+  const b = floor.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
+  }
+  return true;
+}
+function resolveCodex(platform, spawnImpl, timeoutMs = WHERE_TIMEOUT_MS) {
+  if (platform !== "win32") return Promise.resolve({ command: "codex", direct: true });
+  const fallback = { command: "codex", direct: false };
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    let child;
+    const timer = setTimeout(() => {
+      done(fallback);
+      child?.kill();
+    }, timeoutMs);
+    try {
+      child = spawnImpl("where.exe", ["codex"], { stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+      done(fallback);
+      return;
+    }
+    let stdout = "";
+    child.stdout?.on("data", (d) => {
+      stdout += String(d);
+    });
+    child.on("error", () => done(fallback));
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        done(fallback);
+        return;
+      }
+      const hits = stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      const exe = hits.find((h) => h.toLowerCase().endsWith(".exe"));
+      done(exe ? { command: exe, direct: true } : fallback);
+    });
+  });
+}
+
+// ../engines/codex/src/run.ts
 var NOT_INSTALLED_REASON = "Codex CLI is not installed on this computer";
 var NOT_AUTHENTICATED_REASON = "Codex CLI is installed but not signed in";
+var UNVERIFIED_REASON = "Could not verify Codex on this computer";
 var DEFAULT_TIMEOUT_MS2 = 3e5;
-function execArgs(dir, promptText, effort = "low") {
+var PROBE_TIMEOUT_MS = 1e4;
+var NO_ACTIVITY_TIMEOUT_MS = 12e4;
+var PROBE_TTL_MS = 3e4;
+function execArgs(dir, effort = "low") {
   return [
     "exec",
     "--skip-git-repo-check",
     "--sandbox",
     "workspace-write",
+    "--color",
+    "never",
     "-c",
     `model_reasoning_effort="${effort}"`,
     "-C",
     dir,
-    promptText
+    "-"
   ];
 }
+function killTree(child, platform, spawnImpl) {
+  if (platform === "win32" && child.pid) {
+    try {
+      const tk = spawnImpl("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      const fallback = () => {
+        try {
+          child.kill();
+        } catch {
+        }
+      };
+      tk.on("error", fallback);
+      tk.on("exit", (code) => {
+        if (code !== 0) fallback();
+      });
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill();
+  } catch {
+  }
+}
 function createRunner(opts = {}) {
   const spawnImpl = opts.spawnImpl ?? spawn;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const probeTimeoutMs = opts.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
+  const probeTtlMs = opts.probeTtlMs ?? PROBE_TTL_MS;
+  const noActivityMs = opts.noActivityMs ?? NO_ACTIVITY_TIMEOUT_MS;
   const platform = opts.platform ?? process.platform;
+  const killCodex = (child) => killTree(child, platform, spawnImpl);
+  let resolved = null;
+  async function resolution() {
+    resolved ??= await resolveCodex(platform, spawnImpl);
+    return resolved;
+  }
   const winArg = (a) => `"${a.replace(/[\r\n]+/g, " ").replace(/"/g, "'").replace(/%/g, " percent ")}"`;
-  const spawnCodex = (args) => platform === "win32" ? spawnImpl(["codex", ...args].map(winArg).join(" "), [], {
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: true
-  }) : spawnImpl("codex", args, { stdio: ["ignore", "pipe", "pipe"] });
-  function run2(args, signal) {
+  const spawnCodex = (exe, args, stdinOpen) => {
+    const stdio = [stdinOpen ? "pipe" : "ignore", "pipe", "pipe"];
+    return exe.direct ? spawnImpl(exe.command, args, { stdio }) : spawnImpl([exe.command, ...args.map(winArg)].join(" "), [], { stdio, shell: true });
+  };
+  async function run2(args, signal, io) {
+    const exe = await resolution();
     return new Promise((resolve, reject) => {
       let child;
       try {
-        child = spawnCodex(args);
+        child = spawnCodex(exe, args, io?.stdin != null);
       } catch (err) {
         reject(new Error(`Failed to spawn codex: ${err.message}`));
         return;
       }
       let settled = false;
       let stderr = "";
-      child.stdout?.on("data", () => {
-      });
+      let activityTimer = setTimeout(onSilence, noActivityMs);
+      function sawActivity() {
+        if (settled) return;
+        clearTimeout(activityTimer);
+        activityTimer = setTimeout(onSilence, noActivityMs);
+      }
+      function onSilence() {
+        finish(
+          () => reject(
+            new Error(`Codex CLI produced no output for ${Math.round(noActivityMs / 1e3)}s, treating it as stuck`)
+          )
+        );
+        killCodex(child);
+      }
+      child.stdout?.on("data", sawActivity);
       child.stderr?.on("data", (d) => {
         stderr += String(d);
+        sawActivity();
       });
+      if (io?.stdin != null) {
+        child.stdin?.on("error", () => {
+        });
+        child.stdin?.write(io.stdin);
+        child.stdin?.end();
+      }
       const timer = setTimeout(() => {
-        child.kill();
         finish(() => reject(new Error(`Codex CLI timed out after ${timeoutMs}ms`)));
+        killCodex(child);
       }, timeoutMs);
       const onAbort = () => {
-        child.kill();
         finish(() => reject(new Error("Codex CLI run aborted")));
+        killCodex(child);
       };
       function finish(fn) {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        clearTimeout(activityTimer);
         signal?.removeEventListener("abort", onAbort);
         fn();
       }
@@ -1937,47 +2053,99 @@ function createRunner(opts = {}) {
       });
     }
   }
-  function exitedZero(args) {
+  function probeSpawn(exe, args) {
+    const CAP = 8192;
     return new Promise((resolve) => {
       let settled = false;
-      const done = (ok) => {
-        if (!settled) {
-          settled = true;
-          resolve(ok);
-        }
+      let stdout = "";
+      const done = (outcome) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ outcome, stdout });
       };
       let child;
+      const timer = setTimeout(() => {
+        done("timeout");
+        if (child) killCodex(child);
+      }, probeTimeoutMs);
       try {
-        child = spawnCodex(args);
+        child = spawnCodex(exe, args, false);
       } catch {
-        done(false);
+        done("spawn-error");
         return;
       }
-      child.stdout?.on("data", () => {
+      child.stdout?.on("data", (d) => {
+        if (stdout.length < CAP) stdout += String(d).slice(0, CAP - stdout.length);
       });
       child.stderr?.on("data", () => {
       });
-      child.on("error", () => done(false));
-      child.on("exit", (code) => done(code === 0));
+      child.on("error", () => done("spawn-error"));
+      child.on("exit", (code) => done(code === 0 ? "ok" : "nonzero"));
     });
   }
+  let lastDiag = "";
+  function verdict(avail, exe, version) {
+    const line = `codex probe: exe=${exe.command} version=${version ?? "unknown"} outcome=${avail.ok ? "ready" : avail.code}`;
+    if (line !== lastDiag) {
+      lastDiag = line;
+      if (!avail.ok) console.warn(line);
+      else if (process.env.SCENRI_DEBUG === "1") console.log(line);
+    }
+    return avail;
+  }
+  let cached = null;
   async function probe() {
     if (process.env.SCENRI_NO_CODEX === "1") {
       return { ok: false, reason: NOT_INSTALLED_REASON, code: "not-installed" };
     }
-    if (!await exitedZero(["--version"])) {
-      return { ok: false, reason: NOT_INSTALLED_REASON, code: "not-installed" };
+    if (cached && probeTtlMs > 0 && Date.now() - cached.at < probeTtlMs) {
+      return cached.value;
+    }
+    const value = await probeUncached();
+    cached = { at: Date.now(), value };
+    return value;
+  }
+  async function probeUncached() {
+    resolved = await resolveCodex(platform, spawnImpl);
+    const exe = resolved;
+    const ver = await probeSpawn(exe, ["--version"]);
+    if (ver.outcome === "timeout") {
+      return verdict({ ok: false, reason: UNVERIFIED_REASON, code: "unverified" }, exe, null);
     }
-    if (!await exitedZero(["login", "status"])) {
-      return { ok: false, reason: NOT_AUTHENTICATED_REASON, code: "not-authenticated" };
+    if (ver.outcome !== "ok") {
+      return verdict({ ok: false, reason: NOT_INSTALLED_REASON, code: "not-installed" }, exe, null);
     }
-    return { ok: true };
+    const version = parseCodexVersion(ver.stdout);
+    if (version && !versionAtLeast(version, MIN_CODEX_VERSION)) {
+      return verdict(
+        {
+          ok: false,
+          reason: `Codex CLI ${version} is too old. Scenri needs ${MIN_CODEX_VERSION} or newer.`,
+          code: "update-needed"
+        },
+        exe,
+        version
+      );
+    }
+    const login = await probeSpawn(exe, ["login", "status"]);
+    if (login.outcome === "ok") {
+      return verdict({ ok: true }, exe, version);
+    }
+    if (login.outcome === "nonzero") {
+      return verdict({ ok: false, reason: NOT_AUTHENTICATED_REASON, code: "not-authenticated" }, exe, version);
+    }
+    return verdict({ ok: false, reason: UNVERIFIED_REASON, code: "unverified" }, exe, version);
+  }
+  function invalidateProbe() {
+    cached = null;
+    resolved = null;
   }
-  return { run: run2, withWorkDir, probe };
+  return { run: run2, withWorkDir, probe, invalidateProbe };
 }
 var OUT_FILE = "analysis.json";
 function createCodexAnalyzer(opts = {}) {
-  const runner = createRunner(opts);
+  const runner = opts.runner ?? createRunner(opts);
   return {
     isAvailable: () => runner.probe(),
     async analyze(req, signal) {
@@ -1990,11 +2158,11 @@ function createCodexAnalyzer(opts = {}) {
         }
         let problems = [];
         for (let attempt = 0; attempt < 2; attempt++) {
-          const args = execArgs(dir, buildPrompt(req, refs.length, problems), "high");
+          const args = execArgs(dir, "high");
           for (const ref of refs) {
             args.splice(args.length - 1, 0, `--image=${ref}`);
           }
-          await runner.run(args, signal);
+          await runner.run(args, signal, { stdin: buildPrompt(req, refs.length, problems) });
           let raw;
           try {
             raw = await readFile(join(dir, OUT_FILE), "utf8");
@@ -2122,12 +2290,19 @@ var INSTALL_COMMAND_SUDO = "sudo npm install -g @openai/codex";
 var DEFAULT_INSTALL_TIMEOUT_MS = 18e4;
 function stateFrom(avail) {
   if (avail.ok) return "ready";
-  return avail.code === "not-authenticated" ? "not-authenticated" : "not-installed";
+  switch (avail.code) {
+    case "not-authenticated":
+    case "update-needed":
+    case "unverified":
+      return avail.code;
+    default:
+      return "not-installed";
+  }
 }
 function createCodexSetup(opts = {}) {
   const spawnImpl = opts.spawnImpl ?? spawn;
   const platform = opts.platform ?? process.platform;
-  const runner = createRunner(opts);
+  const runner = opts.runner ?? createRunner(opts);
   const installTimeoutMs = opts.installTimeoutMs ?? DEFAULT_INSTALL_TIMEOUT_MS;
   function run2(cmd, args, timeoutMs) {
     return new Promise((resolve) => {
@@ -2141,8 +2316,8 @@ function createCodexSetup(opts = {}) {
       };
       let child;
       const timer = setTimeout(() => {
-        child?.kill();
         done({ code: null, stderr, spawnError: `${cmd} timed out after ${timeoutMs}ms` });
+        if (child) killTree(child, platform, spawnImpl);
       }, timeoutMs);
       try {
         child = spawnImpl(cmd, args, { stdio: ["ignore", "pipe", "pipe"], shell: platform === "win32" });
@@ -2161,12 +2336,15 @@ function createCodexSetup(opts = {}) {
   }
   return {
     async status() {
+      runner.invalidateProbe();
       const avail = await runner.probe();
-      return { state: stateFrom(avail), reason: avail.reason };
+      const setupPlatform = platform === "win32" ? "windows" : platform === "darwin" ? "mac" : "linux";
+      return { state: stateFrom(avail), reason: avail.reason, platform: setupPlatform };
     },
     async install() {
       const res = await run2("npm", ["install", "-g", "@openai/codex"], installTimeoutMs);
       if (res.code === 0) {
+        runner.invalidateProbe();
         const avail = await runner.probe();
         if (avail.code === "not-installed") {
           return {
@@ -2191,6 +2369,7 @@ function createCodexSetup(opts = {}) {
     },
     async login() {
       const res = await run2("codex", ["login"], installTimeoutMs);
+      runner.invalidateProbe();
       if (res.code === 0) return { ok: true };
       const detail = (res.spawnError ?? res.stderr).trim().slice(0, 400) || void 0;
       return { ok: false, fallbackCommand: "codex login --device-auth", detail };
@@ -2201,10 +2380,20 @@ function createCodexSetup(opts = {}) {
 // ../engines/codex/src/index.ts
 function createCodexEngine(opts) {
   const { saveImage } = opts;
-  const runner = createRunner(opts);
+  const platform = opts.platform ?? process.platform;
+  const runner = opts.runner ?? createRunner(opts);
   const runCodex = runner.run;
   const withWorkDir = runner.withWorkDir;
-  async function collectImages(dir) {
+  const generatedImagesDir = () => join(process.env.CODEX_HOME || join(homedir(), ".codex"), "generated_images");
+  async function snapshotGenerated() {
+    if (platform !== "win32") return null;
+    try {
+      return new Set(await readdir(generatedImagesDir()));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  async function collectImages(dir, before = null) {
     const entries = await readdir(dir);
     const outFiles = entries.filter((name) => /^out-.*\.png$/.test(name)).sort((a, b) => {
       const na = Number(/^out-(\d+)\.png$/.exec(a)?.[1] ?? NaN);
@@ -2213,6 +2402,10 @@ function createCodexEngine(opts) {
       return a.localeCompare(b);
     });
     if (outFiles.length === 0) {
+      if (before) {
+        const recovered = await recoverFromGenerated(before);
+        if (recovered) return [recovered];
+      }
       throw new Error("Codex finished but produced no images");
     }
     const hashes = [];
@@ -2221,6 +2414,21 @@ function createCodexEngine(opts) {
     }
     return hashes;
   }
+  async function recoverFromGenerated(before) {
+    const home = generatedImagesDir();
+    let names;
+    try {
+      names = (await readdir(home)).filter((n) => !before.has(n));
+    } catch {
+      return null;
+    }
+    if (!names.length) return null;
+    const stamped = await Promise.all(names.map(async (n) => ({ n, mtime: (await stat(join(home, n))).mtimeMs })));
+    stamped.sort((a, b) => b.mtime - a.mtime);
+    const pick2 = stamped[0].n;
+    console.warn(`codex: workdir empty, recovered ${pick2} from ${home}`);
+    return saveImage(await readFile(join(home, pick2)));
+  }
   return {
     capabilities() {
       return {
@@ -2250,41 +2458,61 @@ function createCodexEngine(opts) {
       const count = Math.max(1, req.count);
       const refs = req.referenceImages ?? [];
       const roles = req.referenceRoles ?? refs.map(() => "reference");
+      const inner = new AbortController();
+      const onOuterAbort = () => inner.abort();
+      if (signal?.aborted) inner.abort();
+      else signal?.addEventListener("abort", onOuterAbort, { once: true });
       const jobs = Array.from(
         { length: count },
         (_, i) => async () => withWorkDir(async (dir) => {
-          const args = execArgs(dir, buildPrompt2(req, i, roles));
+          const args = execArgs(dir);
           for (const [idx, ref] of refs.entries()) {
             const dest = join(dir, `ref-${idx}.png`);
             await copyFile(ref, dest);
             args.splice(args.length - 1, 0, `--image=${dest}`);
           }
-          await runCodex(args, signal);
-          return collectImages(dir);
+          const before = await snapshotGenerated();
+          await runCodex(args, inner.signal, { stdin: buildPrompt2(req, i, roles) });
+          return collectImages(dir, before);
         })
       );
       const results = new Array(count);
       const failures = [];
+      let fatal = null;
       let next = 0;
-      const workers = Array.from({ length: Math.min(3, count) }, async () => {
-        while (next < count) {
-          const i = next++;
-          try {
-            results[i] = await jobs[i]();
-          } catch (err) {
-            if (signal?.aborted) throw err;
-            results[i] = [];
-            failures.push(err);
+      try {
+        const workers = Array.from({ length: Math.min(3, count) }, async () => {
+          while (next < count && !inner.signal.aborted) {
+            const i = next++;
+            try {
+              results[i] = await jobs[i]();
+            } catch (err) {
+              if (signal?.aborted) throw err;
+              results[i] = [];
+              failures.push(err);
+              if (fatal == null && isFatalSetupError(err)) {
+                fatal = err;
+                inner.abort();
+                runner.invalidateProbe();
+              }
+            }
           }
-        }
-      });
-      await Promise.all(workers);
-      const images = results.flat();
-      if (!images.length && failures.length) throw failures[0];
+        });
+        await Promise.all(workers);
+      } finally {
+        signal?.removeEventListener("abort", onOuterAbort);
+      }
+      const images = results.filter(Boolean).flat();
+      if (!images.length && failures.length) throw fatal ?? failures[0];
       if (failures.length) {
         console.warn(
           `codex: ${failures.length} of ${count} variants failed, keeping ${images.length}: ${String(failures[0]?.message ?? failures[0])}`
         );
+        return {
+          images,
+          costUsd: 0,
+          raw: { requested: count, partialFailures: failures.map((f) => String(f?.message ?? f)) }
+        };
       }
       return { images, costUsd: 0 };
     },
@@ -2301,16 +2529,27 @@ function createCodexEngine(opts) {
           refLines.push(`${name} shows ${EDIT_REFERENCE_ROLE_DIRECTIVE[role]}`);
         }
         const promptText = `Edit input.png using your image generation/editing tool: ${req.instruction}.` + (refLines.length ? ` ${refLines.join(". ")}.` : "") + ` Do not browse the web or explore files. Save the result in the current directory as out-1.png (you may run the commands needed to save and resize it). Nothing else.`;
-        const args = execArgs(dir, promptText);
+        const args = execArgs(dir);
         for (const name of ["input.png", ...refLines.map((_, i) => `${editRoles[i] ?? "reference"}-${i + 1}.png`)]) {
           args.splice(args.length - 1, 0, `--image=${join(dir, name)}`);
         }
-        await runCodex(args, signal);
-        const images = await collectImages(dir);
+        const before = await snapshotGenerated();
+        try {
+          await runCodex(args, signal, { stdin: promptText });
+        } catch (err) {
+          if (isFatalSetupError(err)) runner.invalidateProbe();
+          throw err;
+        }
+        const images = await collectImages(dir, before);
         return { images, costUsd: 0 };
       });
     }
   };
+  function isFatalSetupError(err) {
+    return /failed to spawn|ENOENT|not logged in|login required|401|unauthorized/i.test(
+      String(err?.message ?? err)
+    );
+  }
   function buildPrompt2(req, index, roles) {
     const roleDirective = REFERENCE_ROLE_DIRECTIVE;
     const refDirectives = roles.map(
@@ -2326,17 +2565,19 @@ function keyGetter(core, settingKey, envVar) {
 }
 function createEngineRegistry(core, extra = []) {
   const saveImage = (buf) => core.images.save(buf);
+  const codexRunner = createRunner();
   const adapters = [
     createOpenRouterEngine({ getKey: keyGetter(core, "openrouter_api_key", "OPENROUTER_API_KEY"), saveImage }),
     createReplicateEngine({ getKey: keyGetter(core, "replicate_api_token", "REPLICATE_API_TOKEN"), saveImage }),
     createFalEngine({ getKey: keyGetter(core, "fal_key", "FAL_KEY"), saveImage }),
-    createCodexEngine({ saveImage }),
+    createCodexEngine({ saveImage, runner: codexRunner }),
     ...extra
   ];
   const byId = new Map(adapters.map((a) => [a.capabilities().id, a]));
   return {
     all: () => adapters,
-    get: (id) => byId.get(id) ?? null
+    get: (id) => byId.get(id) ?? null,
+    codexRunner
   };
 }
 function createDemoEngine(saveImage) {
@@ -6153,7 +6394,7 @@ function registerPresenterRoutes(app, deps) {
 // src/routes/assetBuilds.ts
 function registerAssetBuildRoutes(app, deps) {
   const { core, engines, scenes, presenters } = deps;
-  const analyzer = deps.analyzer ?? createCodexAnalyzer();
+  const analyzer = deps.analyzer ?? createCodexAnalyzer({ runner: engines.codexRunner });
   const buildEngine = async () => {
     const ordered = [...engines.all()].sort((a, b) => {
       const rank = (e) => e.capabilities().id === "codex-cli" ? 0 : 1;
@@ -6548,7 +6789,7 @@ function registerProjectRoutes(app, deps) {
 
 // src/routes/codexSetup.ts
 function registerCodexSetupRoutes(app, deps) {
-  const codexSetup = deps.codexSetup ?? createCodexSetup();
+  const codexSetup = deps.codexSetup ?? createCodexSetup({ runner: deps.codexRunner });
   let codexSetupBusy = null;
   app.get("/api/engines/codex/status", async () => codexSetup.status());
   app.post("/api/engines/codex/install", async (_req, reply) => {
@@ -6781,6 +7022,21 @@ function registerImageRoutes(app, deps) {
 
 // src/release/notes.data.ts
 var RELEASES = [
+  {
+    version: "0.4.4",
+    date: "2026-08-23",
+    title: "Codex setup tells the truth, and a stuck generation fails instead of running forever.",
+    sections: [
+      {
+        heading: "Codex",
+        body: 'Setup now verifies more than a binary on the path: it checks the version, the sign-in, and says "could not verify" when it cannot tell, with a Check again button instead of a false Connected. Windows instructions say PowerShell, and Codex installed through npm works again.'
+      },
+      {
+        heading: "Fixes",
+        body: "A generation that goes silent now fails within minutes with a plain reason instead of running on with no news, and Cancel stops the Codex process for real, on Windows too. A signed-out or outdated Codex fails fast with the step that fixes it."
+      }
+    ]
+  },
   {
     version: "0.4.3",
     date: "2026-08-23",
@@ -7493,7 +7749,7 @@ function buildServer(opts) {
     return { ...rest, referenceCount: referenceImages.length };
   });
   registerProjectRoutes(app, { core });
-  registerCodexSetupRoutes(app, { codexSetup: opts.codexSetup });
+  registerCodexSetupRoutes(app, { codexSetup: opts.codexSetup, codexRunner: engines.codexRunner });
   app.get("/api/engines", async () => {
     const list2 = [];
     for (const e of engines.all()) {
@@ -7572,11 +7828,17 @@ function buildServer(opts) {
         );
     }
   }
+  const NODE_TIMEOUT_MS = 6e5;
   async function runNode(nodeId, engine, estimate, work, expect, post) {
     const engineId = engine.capabilities().id;
     reserved.set(engineId, (reserved.get(engineId) ?? 0) + estimate);
     const ctrl = new AbortController();
     runningGenerations.set(nodeId, ctrl);
+    let watchdogFired = false;
+    const watchdog = setTimeout(() => {
+      watchdogFired = true;
+      ctrl.abort();
+    }, opts.nodeTimeoutMs ?? NODE_TIMEOUT_MS);
     try {
       const result = await work(ctrl.signal);
       result.images = await normalizePngs(result.images);
@@ -7585,9 +7847,11 @@ function buildServer(opts) {
       core.store.completeNode(nodeId, result);
       core.ledger.recordCost(engineId, nodeId, result.costUsd);
     } catch (err) {
-      if (ctrl.signal.aborted) core.store.cancelNode(nodeId);
+      if (watchdogFired) core.store.failNode(nodeId, "generation timed out after 10 minutes");
+      else if (ctrl.signal.aborted) core.store.cancelNode(nodeId);
       else core.store.failNode(nodeId, String(err?.message ?? err));
     } finally {
+      clearTimeout(watchdog);
       runningGenerations.delete(nodeId);
       const left = (reserved.get(engineId) ?? 0) - estimate;
       if (left > 1e-9) reserved.set(engineId, left);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenri",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "author": "Tony Gorb <hello@scenri.co>",
   "license": "AGPL-3.0-only",
   "type": "module",