scenri 0.20.3 → 0.20.4

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.20.4](https://github.com/tonygorb/Scenri/compare/v0.20.3...v0.20.4) (2026-09-28)
+
+
+### Bug Fixes
+
+* **codex:** run on the Codex default when the plan lacks gpt-6-sol ([e7dc36d](https://github.com/tonygorb/Scenri/commit/e7dc36df2698e4ce22de66c8a997252af04c42f0))
+* **codex:** run on the Codex default when the plan lacks gpt-6-sol, keep only drawn pictures ([7851c59](https://github.com/tonygorb/Scenri/commit/7851c5944c5e4cbfd17ef7ac12cd6068f57e84b7))
+* **codex:** store only a picture the image tool drew ([4573de7](https://github.com/tonygorb/Scenri/commit/4573de7944a479b0585af1fe62ec9cd9bce470b2))
+* **studio:** reload a tab whose server came back as another version ([22c5b6d](https://github.com/tonygorb/Scenri/commit/22c5b6d7f730d37e8435923feec1266fb3fe11ca))
+* **studio:** reload a tab whose server came back as another version ([06629f0](https://github.com/tonygorb/Scenri/commit/06629f09dcb5b47551ae18ce2a88ed3985e3579d))
+
 ## [0.20.3](https://github.com/tonygorb/Scenri/compare/v0.20.2...v0.20.3) (2026-09-27)
 
 

package/dist/serve.js

@@ -967,6 +967,9 @@ function codexFailureDetail(stderr, stdout) {
   return tailOf(marked) || tailOf(body) || tailOf(stdout.trim()) || tailOf(stderr.trim());
 }
 var MODEL_NEEDS_NEWER_CODEX = /The '([^']+)' model requires a newer version of Codex/;
+var MODEL_NOT_ON_PLAN = /The '([^']+)' model is not supported when using Codex with a ChatGPT account/;
+var ModelNotOnPlan = class extends Error {
+};
 var BAD_KEY_401 = /incorrect api key provided|invalid_api_key|invalid api key/i;
 function tooOldForModel(version, model) {
   return `Codex CLI ${version ?? "on this computer"} is too old for the model it is set to, ${model}.`;
@@ -1020,18 +1023,33 @@ function createRunner(opts = {}) {
   }
   let knownVersion = null;
   let tooOldFor = null;
+  const offPlan = /* @__PURE__ */ new Set();
+  const withoutOffPlan = (rest) => {
+    const i = rest.indexOf("-m");
+    return i >= 0 && offPlan.has(rest[i + 1]) ? [...rest.slice(0, i), ...rest.slice(i + 2)] : rest;
+  };
   const winArg = (a) => `"${a.replace(/[\r\n]+/g, " ").replace(/"/g, "'").replace(/%/g, " percent ")}"`;
   const spawnCodex = (exe, args, stdinOpen) => {
     const stdio = [stdinOpen ? "pipe" : "ignore", "pipe", "pipe"];
     const env = buildChildEnv(parentEnv, [...ignoreEnvKeys(), ...SIBLING_PROVIDER_KEYS]);
-    if (args[0] === "exec") args = ["exec", ...extensionsOffArgs(parentEnv), ...args.slice(1)];
+    if (args[0] === "exec") args = ["exec", ...extensionsOffArgs(parentEnv), ...withoutOffPlan(args.slice(1))];
     return exe.direct ? spawnImpl(exe.command, args, { stdio, env, ...platform !== "win32" ? { detached: true } : {} }) : spawnImpl([exe.command, ...args.map(winArg)].join(" "), [], { stdio, env, shell: true });
   };
   async function run4(args, signal, io) {
+    try {
+      await runOnce(args, signal, io);
+    } catch (err) {
+      if (!(err instanceof ModelNotOnPlan)) throw err;
+      await runOnce(args, signal, io);
+    }
+  }
+  async function runOnce(args, signal, io) {
     const exe = await resolution();
     const timeoutMs = io?.timeoutMs ?? defaultTimeoutMs;
     const launchedAs = args[0] === "exec" ? fingerprintFor(exe, knownVersion) : null;
     return new Promise((resolve, reject) => {
+      const sent = withoutOffPlan(args.slice(1));
+      const sentModel = sent.includes("-m") ? sent[sent.indexOf("-m") + 1] : null;
       let child;
       try {
         child = spawnCodex(exe, args, io?.stdin != null);
@@ -1145,6 +1163,26 @@ function createRunner(opts = {}) {
           );
           return;
         }
+        const refused = MODEL_NOT_ON_PLAN.exec(stderr);
+        if (refused) {
+          const model = refused[1];
+          if (sentModel === model) {
+            if (!offPlan.has(model))
+              console.warn(`codex: ${model} is not on this ChatGPT plan, running on the Codex default`);
+            offPlan.add(model);
+            finish("model-not-on-plan", () => reject(new ModelNotOnPlan(`${model} is not on this ChatGPT plan`)));
+            return;
+          }
+          finish(
+            `exit-${code ?? "unknown"}`,
+            () => reject(
+              new Error(
+                `Your ChatGPT plan cannot run ${model} in Codex. Choose another model in Codex, then run this again.`
+              )
+            )
+          );
+          return;
+        }
         const conflicting = presentConflictKeys(parentEnv, ignoreEnvKeys());
         if (conflicting.length > 0 && /\b401\b|unauthorized/i.test(stderr) && BAD_KEY_401.test(stderr)) {
           noteConnection("refused", {
@@ -1780,14 +1818,57 @@ function createCodexEngine(opts) {
   const withWorkDir = runner.withWorkDir;
   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, claimed) {
+  async function drawnSince(before, claimed) {
+    const home = generatedImagesDir();
+    let names;
+    try {
+      names = await readdir(home);
+    } catch {
+      return [];
+    }
+    const found = [];
+    const consider = async (path) => {
+      const st = await lstat(path);
+      if (st.isFile() && /\.png$/i.test(path) && !claimed.has(path)) found.push({ path, mtime: st.mtimeMs });
+    };
+    for (const name of names) {
+      if (before.has(name)) continue;
+      const at = join(home, name);
+      try {
+        const st = await lstat(at);
+        if (st.isDirectory()) for (const file of await readdir(at)) await consider(join(at, file));
+        else await consider(at);
+      } catch {
+      }
+    }
+    return found.sort((a, b) => b.mtime - a.mtime).map((f) => f.path);
+  }
+  async function claimCopy(drawn, buf, claimed) {
+    for (const path of drawn) {
+      try {
+        if ((await stat(path)).size !== buf.length || !(await readFile(path)).equals(buf)) continue;
+      } catch {
+        continue;
+      }
+      claimed.add(path);
+      return true;
+    }
+    return false;
+  }
+  async function takeDrawn(path, claimed) {
+    claimed.add(path);
+    const buf = await readLeftFile(path, basename(path));
+    const hash = saveImage(buf);
+    await forgetGenerated(buf);
+    return hash;
+  }
+  async function collectImages(dir, before, claimed = /* @__PURE__ */ new Set()) {
     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);
@@ -1796,9 +1877,12 @@ function createCodexEngine(opts) {
       return a.localeCompare(b);
     });
     if (outFiles.length === 0) {
-      if (before) {
-        const recovered = await recoverFromGenerated(before, claimed);
-        if (recovered) return [recovered];
+      if (platform === "win32") {
+        const [newest] = await drawnSince(before, claimed);
+        if (newest) {
+          console.warn(`codex: workdir empty, recovered ${newest}`);
+          return [await takeDrawn(newest, claimed)];
+        }
       }
       throw new Error("Codex finished but produced no images");
     }
@@ -1806,6 +1890,12 @@ function createCodexEngine(opts) {
     for (const name of outFiles) {
       const buf = await readLeftFile(join(dir, name), name);
       if (buf.length === 0) throw new Error(`codex: ${name} is empty`);
+      const drawn = platform === "win32" ? [] : await drawnSince(before, claimed);
+      if (drawn.length > 0 && !await claimCopy(drawn, buf, claimed)) {
+        console.warn(`codex: ${name} is not a picture the image tool drew, taking the tool's own file`);
+        hashes.push(await takeDrawn(drawn[0], claimed));
+        continue;
+      }
       hashes.push(saveImage(buf));
       await forgetGenerated(buf);
     }
@@ -1844,22 +1934,6 @@ function createCodexEngine(opts) {
       }
     }
   }
-  async function recoverFromGenerated(before, claimed) {
-    const home = generatedImagesDir();
-    let names;
-    try {
-      names = (await readdir(home)).filter((n) => !before.has(n) && !claimed?.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;
-    claimed?.add(pick2);
-    console.warn(`codex: workdir empty, recovered ${pick2} from ${home}`);
-    return saveImage(await readLeftFile(join(home, pick2), pick2));
-  }
   return {
     capabilities() {
       return {
@@ -16312,6 +16386,21 @@ function registerImageRoutes(app, deps) {
 var HEADLINES_KEPT = 5;
 var FIRST_PUBLIC = "0.2.0";
 var RELEASES = [
+  {
+    version: "0.20.4",
+    date: "2026-09-28",
+    title: "Shots made with Codex work on every ChatGPT plan",
+    sections: [
+      {
+        heading: "Create",
+        body: "When your ChatGPT plan does not offer the model Scenri asks Codex for, the shot now runs on the model your Codex is set to, with every reference picture still attached."
+      },
+      {
+        heading: "Fixes",
+        body: "On Mac and Linux a shot keeps only the picture Codex drew, never a stray file. An open tab reloads itself when Scenri restarts on a new version."
+      }
+    ]
+  },
   {
     version: "0.20.3",
     date: "2026-09-27",

package/package.json

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