agentbox-app 0.1.13 → 0.1.16

package/main/codex-threads-worker.mjs

@@ -0,0 +1,12 @@
+// Reads Codex transcripts for the watch, off the app's main process
+// (codex-threads.mjs readCodexThreadsOffThread).
+import { parentPort } from 'node:worker_threads';
+import { readCodexThreads } from './codex-threads.mjs';
+
+parentPort.on('message', ({ id, opts }) => {
+  try {
+    parentPort.postMessage({ id, ok: true, value: readCodexThreads(opts) });
+  } catch (err) {
+    parentPort.postMessage({ id, ok: false, error: String(err?.message ?? err) });
+  }
+});

package/main/codex-threads.mjs

@@ -24,11 +24,13 @@
 // table. It is not read: Electron ships no sqlite, the file is written live
 // under WAL, and the two plain files carry what the row needs.
 import fs from 'node:fs';
+import { Worker } from 'node:worker_threads';
 import os from 'node:os';
 import path from 'node:path';
 import { RECENT_DAYS, isScratchFolder, shortFolder, threadTitle } from './agent-sessions.mjs';
 import { codexDataDirs } from './agent-homes.mjs';
 import { WAS_SLUGS, nameSlug } from '../shared/product-name.mjs';
+import { howTheChatEnded } from '../shared/agent-import.mjs';
 
 export const CODEX_RECENT_DAYS = RECENT_DAYS;
 /** The originator Codex records for a run this app started (CLIENT_INFO.name), now and before. */
@@ -164,7 +166,25 @@ const partsOf = (payload) => (Array.isArray(payload?.content) ? payload.content
  *  `message` with a `role` and a `content` array of `input_text`, `input_image`
  *  and `output_text` parts. Current Codex threads are paginated, and a build
  *  that read only legacy showed "Codex has not answered yet." on every row. */
+// Each transcript as last read, kept while its size and time are unchanged:
+// her Codex folder can hold thousands of them, and reading every one again
+// each minute held the app for seconds.
+const ROLLOUTS_KEPT = 5000;
+const rollouts = new Map();
+
 export function readRollout(file) {
+  let st = null;
+  try { st = fs.statSync(file); } catch { return null; }
+  const kept = rollouts.get(file);
+  if (kept && kept.size === st.size && kept.mtimeMs === st.mtimeMs) return kept.value;
+  const value = readRolloutAfresh(file);
+  rollouts.delete(file);
+  rollouts.set(file, { size: st.size, mtimeMs: st.mtimeMs, value });
+  if (rollouts.size > ROLLOUTS_KEPT) rollouts.delete(rollouts.keys().next().value);
+  return value;
+}
+
+function readRolloutAfresh(file) {
   let text = '';
   try {
     const fd = fs.openSync(file, 'r');
@@ -179,6 +199,8 @@ export function readRollout(file) {
   let meta = null;
   let prompt = '';
   let last = '';
+  // Whether the person wrote after Codex's last answer, so it is not waiting.
+  let herTurnLast = false;
   let turns = 0;
   let images = 0;
   let lastActive = 0;
@@ -213,11 +235,12 @@ export function readRollout(file) {
       if (p.type === 'user_message') {
         const said = cleanPrompt(p.message);
         if (!prompt && said && !isInjected(said)) prompt = said;
+        if (said && !isInjected(said)) herTurnLast = true;
         turns += 1;
         sawEventTurns = true;
       } else if (p.type === 'agent_message') {
         const said = cleanAnswer(p.message);
-        if (said) last = said;
+        if (said) { last = said; herTurnLast = false; }
       }
       continue;
     }
@@ -231,16 +254,17 @@ export function readRollout(file) {
         .filter(Boolean);
       if (!hers.length) continue; // a turn made of nothing but Codex's own preamble
       if (!prompt) prompt = hers.join('\n\n').trim();
+      herTurnLast = true;
       if (!sawEventTurns) turns += 1;
     } else if (p.role === 'assistant') {
       const said = cleanAnswer(partsOf(p).filter((c) => c.type === 'output_text').map((c) => c.text ?? '').join('\n'));
-      if (said) last = said;
+      if (said) { last = said; herTurnLast = false; }
     }
   }
   if (!meta || !meta.id) return null;
   let mtime = 0;
   try { mtime = fs.statSync(file).mtimeMs; } catch { mtime = 0; }
-  return { ...meta, prompt, last, turns, images, lastActive, path: file, mtime };
+  return { ...meta, prompt, last, herTurnLast, turns, images, lastActive, path: file, mtime };
 }
 
 /**
@@ -319,6 +343,50 @@ function readOneCodexHome(codexDir, { home, days, now, cutoff, index, byId, skip
       prompt: r.prompt,
       last: r.last,
       live: isLive(r.mtime, now),
+      ...(r.herTurnLast ? { waiting: false, ask: '' } : howTheChatEnded(r.last)),
+      lastSaid: r.last,
+      firstSaid: r.prompt,
     });
   }
 }
+
+// THE SAME READ IN A THREAD OF ITS OWN, for the watch that runs every minute:
+// a first read of a large Codex folder takes seconds, and on the main process
+// that is seconds of the app not answering. One worker, kept for the life of
+// the app, so its transcripts stay remembered between reads. Where a worker
+// cannot start, the read runs here as before.
+const OFF_THREAD_DEADLINE_MS = 5 * 60_000;
+let worker = null;
+let asked = 0;
+const waiting = new Map();
+export function readCodexThreadsOffThread(opts = {}) {
+  try {
+    if (!worker) {
+      worker = new Worker(new URL('./codex-threads-worker.mjs', import.meta.url));
+      worker.unref();
+      worker.on('message', ({ id, ok, value, error }) => {
+        const w = waiting.get(id);
+        if (!w) return;
+        waiting.delete(id);
+        clearTimeout(w.timer);
+        if (ok) w.resolve(value); else w.reject(new Error(error));
+      });
+      const fail = (err) => {
+        for (const w of waiting.values()) { clearTimeout(w.timer); w.reject(err); }
+        waiting.clear();
+        worker = null;
+      };
+      worker.on('error', fail);
+      worker.on('exit', () => fail(new Error('the Codex reader stopped')));
+    }
+  } catch {
+    return Promise.resolve().then(() => readCodexThreads(opts));
+  }
+  const id = (asked += 1);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { waiting.delete(id); reject(new Error('the Codex reader did not answer in time')); }, OFF_THREAD_DEADLINE_MS);
+    timer.unref?.();
+    waiting.set(id, { resolve, reject, timer });
+    worker.postMessage({ id, opts });
+  });
+}

package/main/codex-usage-file.mjs

@@ -16,9 +16,11 @@
 // such records across its most recent sessions, the newest written within
 // the minute.
 //
-// THE PUSH STILL WINS. A live notification is this second's truth and a log is
-// the last thing anybody wrote down, so main/codex-usage.mjs reads this only when
-// it has nothing of its own. Nothing about the existing path changes.
+// A LIVE PUSH STILL WINS, AND A QUIET ONE NO LONGER DOES (w-7b7182ef61). A
+// notification that arrived a moment ago is this second's truth and nothing on
+// disk can be newer, so main/codex-usage.mjs does not open a file while one is
+// fresh. Past that the two are compared and the newer is read, because an hours
+// old push was being drawn over a newer line in this log.
 //
 // IT IS THE SAME ACCOUNT OR IT IS NOT READ. One CODEX_HOME is one login, and the
 // log lives inside the home, so a reading taken from `~/.codex/sessions` is a

package/main/codex-usage.mjs

@@ -62,8 +62,38 @@
 // level down.
 
 import { codexLimits, mergeRateLimits } from '../shared/codex-usage.mjs';
+import { limitsStillRunning } from '../shared/usage.mjs';
 import { loggedCodexLimits } from './codex-usage-file.mjs';
 
+const LOG_EVERY_MS = 30_000;
+
+/**
+ * HOW LONG A PUSH IS THIS SECOND'S TRUTH (w-7b7182ef61).
+ *
+ * "The push still wins" holds while pushes are arriving, which is every few
+ * seconds during a turn; nothing on disk can be newer than one of those, so the
+ * busy case never opens a file. A push from four hours ago is just the oldest
+ * thing anybody knows, so past this it is compared against the log instead.
+ */
+const PUSH_FRESH_MS = 60_000;
+
+/**
+ * Every Codex login's own reading, for the Settings page: each out of the
+ * session logs under its own home, and the one in use from `current`, which
+ * the push keeps newer while it works. A login that has never run here gets
+ * no limits rather than zeroes, and a window that has reset since is dropped,
+ * because a login not in use can go days without a new reading.
+ */
+export function codexAccountReadings({ profiles, homeOf, current = null, currentHome = null, now = Date.now(), readLog = loggedCodexLimits }) {
+  return profiles.map((profile) => {
+    const home = homeOf(profile);
+    const live = !!current?.limits?.length && home === currentHome;
+    const reading = live ? current : readLog(home, { now });
+    const limits = limitsStillRunning(live ? current.limits : codexLimits(reading?.snapshot), now);
+    return limits.length ? { profile, limits, at: reading.at } : { profile };
+  });
+}
+
 export class CodexUsage {
   /**
    * @param {object} how @param { => string|null} how.home Which CODEX_HOME the
@@ -94,23 +124,42 @@ export class CodexUsage {
   read() {
     if (this._takenUnder !== null && this._takenUnder !== this._home()) this._forget();
     const limits = codexLimits(this._snapshot);
-    if (limits.length) return { limits, at: this._at };
-    // NOTHING HAS PUSHED, SO ASK WHAT CODEX ALREADY WROTE DOWN. This is the
-    // whole of: the push only ever arrives for work the app itself ran, and a
-    // person who runs Codex in its own app would see the panel stay empty
+    const pushed = limits.length ? { limits, at: this._at } : null;
+    if (pushed && this._now() - pushed.at < PUSH_FRESH_MS) return pushed;
+    // NOTHING HAS PUSHED LATELY, SO ASK WHAT CODEX ALREADY WROTE DOWN. This is
+    // the whole of: the push only ever arrives for work the app itself ran, and
+    // a person who runs Codex in its own app would see the panel stay empty
     // while their weekly limit was full. main/codex-usage-file.mjs is a read of a file
     // under this same CODEX_HOME. It starts no process and sends nothing
     // anywhere, so neither rule above is bent.
-    return this._logged();
+    const logged = this._logged();
+    if (!pushed) return logged;
+    return logged && logged.at > pushed.at ? logged : pushed;
+  }
+
+  /**
+   * `read()` with the log cache dropped, for a person who pressed Refresh:
+   *  inside `LOG_EVERY_MS` a press would otherwise change nothing. It asks
+   *  nobody anything, so both rules at the top of this file still hold. */
+  refreshNow() {
+    this._loggedRead = null;
+    return this.read();
   }
 
   /**
    * The last figure in Codex's own session log under this home, shaped exactly
    *  like a pushed one. Null on a Mac where Codex has never run. */
   _logged() {
-    const reading = this._readLog(this._home(), { now: this._now() });
+    // Asked on every request the window makes; the log is walked at most
+    // every half minute.
+    const home = this._home();
+    const now = this._now();
+    if (this._loggedRead && this._loggedRead.home === home && now - this._loggedRead.at < LOG_EVERY_MS) return this._loggedRead.value;
+    const reading = this._readLog(home, { now });
     const limits = codexLimits(reading?.snapshot);
-    return limits.length ? { limits, at: reading.at } : null;
+    const value = limits.length ? { limits, at: reading.at } : null;
+    this._loggedRead = { home, at: now, value };
+    return value;
   }
 
   /**

package/main/codex-watch.mjs

@@ -73,9 +73,17 @@ export function noticeCodexAgents(threads, { count = null, seen = null, now = Da
   return sent;
 }
 
+// Answers at once for a reader that answers at once, and as a promise for one
+// that reads off the main process (readCodexThreadsOffThread).
 export function scanCodex({ store, readThreads = readCodexThreads, now = Date.now(), count = null, seen = null } = {}) {
-  let threads = [];
-  try { ({ threads } = readThreads({ now })); } catch { return { refreshed: 0, retold: 0, threads: 0 }; }
+  const none = { refreshed: 0, retold: 0, threads: 0 };
+  let read;
+  try { read = readThreads({ now }); } catch { return none; }
+  if (typeof read?.then === 'function') return read.then(({ threads }) => applyCodexThreads(threads, { store, now, count, seen }), () => none);
+  return applyCodexThreads(read?.threads ?? [], { store, now, count, seen });
+}
+
+function applyCodexThreads(threads, { store, now, count, seen }) {
   noticeCodexAgents(threads, { count, seen, now });
   const refreshed = store.refreshCodexMirrors(threads, { now });
   const retold = store.refreshCodexAsks(threads, { now });
@@ -87,8 +95,14 @@ export function startCodexWatch({ store, readThreads = readCodexThreads, pollMs
   // as the Claude side's set is: a fresh launch seeing the same conversation
   // again is a fresh fact about the app being used.
   const seen = new Set();
+  // One scan at a time: a read slower than the minute must not stack up.
+  let scanning = null;
   const run = () => {
-    try { scanCodex({ store, readThreads, count, seen }); } catch (e) { console.warn('codex watch:', e?.message ?? e); }
+    if (scanning) return scanning;
+    scanning = Promise.resolve().then(() => scanCodex({ store, readThreads, count, seen }))
+      .catch((e) => console.warn('codex watch:', e?.message ?? e))
+      .finally(() => { scanning = null; });
+    return scanning;
   };
   const first = setTimeout(run, firstDelayMs);
   const timer = setInterval(run, pollMs);