agentbox-app 0.1.12 → 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,10 +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. */
@@ -163,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');
@@ -178,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;
@@ -212,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;
     }
@@ -230,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 };
 }
 
 /**
@@ -252,12 +277,40 @@ export const isLive = (mtime, now = Date.now()) => Number(mtime) > 0 && now - Nu
 /**
  * THE USER'S CONVERSATIONS, newest first, in the shape the import card and the
  *  import row both read. One entry per thread a person typed into, in a real folder,
- *  touched in the last `days` days. */
-export function readCodexThreads({ home = os.homedir(), codexDir = codexHome(home), days = CODEX_RECENT_DAYS, now = Date.now() } = {}) {
-  const index = readCodexIndex(codexDir);
+ *  touched in the last `days` days.
+ *
+ *  EVERY CODEX FOLDER ON THE MACHINE, not only `~/.codex` (w-e46f2e9cea): a
+ *  second login under `~/.codex-<name>` or a `CODEX_HOME` holds conversations
+ *  the import never offered. `codexDirs` is the list main/agent-homes.mjs makes;
+ *  `codexDir` still names exactly one folder for a caller that means one. The
+ *  same conversation in two folders is one row.
+ *
+ *  WHICH COPY, AND WHICH NAME, decided apart (Codex's review of this change,
+ *  2026-10-11). The copy kept is the transcript file written last, judged by
+ *  the file alone: judging by `when`, which folds in the index's own date, let
+ *  a stale copy whose folder's index was touched later beat the copy still
+ *  being written. And the name Codex gave a conversation is read from every
+ *  folder's index, newest entry winning, so the copy kept still carries a name
+ *  that only another folder's index knew. */
+export function readCodexThreads({ home = os.homedir(), codexDir = null, codexDirs = null, days = CODEX_RECENT_DAYS, now = Date.now() } = {}) {
+  const dirs = codexDirs ?? (codexDir ? [codexDir] : codexDataDirs({ home }));
   const cutoff = now - Math.max(0, Number(days) || 0) * 86400 * 1000;
-  const out = [];
-  const skipped = { notHers: 0, scratch: 0, old: 0, empty: 0, unreadable: 0 };
+  const index = new Map();
+  for (const dir of dirs) {
+    for (const [id, entry] of readCodexIndex(dir)) {
+      const had = index.get(id);
+      if (!had || (entry.name && (!had.name || entry.updatedAt > had.updatedAt))) index.set(id, entry);
+    }
+  }
+  const byId = new Map();
+  const skipped = { notHers: 0, scratch: 0, old: 0, empty: 0, unreadable: 0, copy: 0 };
+  for (const dir of dirs) readOneCodexHome(dir, { home, days, now, cutoff, index, byId, skipped });
+  const out = [...byId.values()].map(({ fileTime, ...t }) => t);
+  out.sort((a, b) => b.when - a.when);
+  return { threads: out, skipped };
+}
+
+function readOneCodexHome(codexDir, { home, days, now, cutoff, index, byId, skipped }) {
   for (const file of listRolloutFiles(codexDir, { days, since: cutoff })) {
     const r = readRollout(file);
     if (!r) { skipped.unreadable += 1; continue; }
@@ -268,7 +321,13 @@ export function readCodexThreads({ home = os.homedir(), codexDir = codexHome(hom
     if (when < cutoff) { skipped.old += 1; continue; }
     const title = named?.name || threadTitle([r.prompt]);
     if (!title) { skipped.empty += 1; continue; }
-    out.push({
+    const had = byId.get(r.id);
+    if (had) {
+      skipped.copy += 1;
+      if (had.fileTime >= r.mtime) continue;
+    }
+    byId.set(r.id, {
+      fileTime: r.mtime,
       id: r.id,
       source: 'codex',
       folder: r.cwd,
@@ -284,8 +343,50 @@ export function readCodexThreads({ home = os.homedir(), codexDir = codexHome(hom
       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,
     });
   }
-  out.sort((a, b) => b.when - a.when);
-  return { threads: out, skipped };
+}
+
+// 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

@@ -10,21 +10,99 @@
 // The founder, before launch: "after onboarding for both anthropic and openai
 // harnesses, it should only import on command, not continuously". Importing is
 // now the walk's last card and ⌘K import, for Claude Code and Codex alike.
+//
+// IT IS ALSO WHERE A CODEX AGENT IS NOTICED (w-1116fbb68a, 2026-10-08). It is
+// the one thing in the app that already knows a person's Codex conversations,
+// and it reads them on a timer rather than on the snapshot, which is what makes
+// it the right place: see `noticeCodexAgents` below.
 import { readCodexThreads } from './codex-threads.mjs';
 
 export const CODEX_POLL_MS = 60_000;
 
-export function scanCodex({ store, readThreads = readCodexThreads, now = Date.now() } = {}) {
-  let threads = [];
-  try { ({ threads } = readThreads({ now })); } catch { return { refreshed: 0, retold: 0, threads: 0 }; }
+/**
+ * HOW LONG AFTER ITS LAST WRITE A CODEX THREAD IS STILL AN AGENT THAT WAS SEEN.
+ *
+ *  A Claude Code session is a process, so `agent_seen` catches one that has sat
+ *  open since earlier in the sitting (main/ipc.mjs, liveAgents). A Codex thread
+ *  leaves no process behind: `isLive` is two minutes of file mtime, so counting
+ *  only live threads would notice a Codex user ONLY when this watch's minute
+ *  happened to land while they were typing. An hour is one sitting, which is
+ *  the span the Claude read already covers without being asked to.
+ *
+ *  AND IT IS NOT A DAY. The reader hands over ten days of conversations, and
+ *  counting those would say every install with Codex on it had an agent up on
+ *  every day the app was opened, which is the opposite of the under-count this
+ *  was added to fix.
+ */
+export const CODEX_SEEN_MS = 60 * 60_000;
+
+/**
+ * "AN AGENT WAS SEEN", FOR CODEX TOO (w-1116fbb68a, 2026-10-08).
+ *
+ *  `agent_seen` listed Claude Code processes and nothing else, and about a
+ *  third of the people on this app are on Codex, so whether they had an agent
+ *  at all was read off proxies: a run this app started, or a reply. The threads
+ *  are already in hand once a minute for the mirror refresh, so this costs
+ *  nothing beyond the comparison.
+ *
+ *  NOTHING ABOUT A THREAD IS SENT. Not its folder, not its title, not its id,
+ *  which is only ever compared inside this process. `engine` is the whole of
+ *  the payload and it is one of two fixed words.
+ *
+ *  ONCE PER THREAD PER RUN OF THE APP, for the reason the Claude side keeps a
+ *  set: this reads the same conversations every minute, so without it one
+ *  conversation would send an event a minute all day.
+ */
+export function noticeCodexAgents(threads, { count = null, seen = null, now = Date.now() } = {}) {
+  if (typeof count !== 'function') return 0;
+  let sent = 0;
+  for (const t of threads ?? []) {
+    const id = String(t?.id ?? '');
+    if (!id) continue;
+    const at = Number(t.lastActive ?? 0);
+    if (!t.live && !(at > 0 && now - at < CODEX_SEEN_MS)) continue;
+    if (seen) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+    }
+    // A count is never worth the watch: the mirror refresh below is what
+    // somebody actually sees, and it runs whatever the switch does.
+    try { count('agent_seen', { engine: 'codex' }); } catch { /* nothing */ }
+    sent += 1;
+  }
+  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 } = {}) {
+  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 });
   return { refreshed, retold, threads: threads.length };
 }
 
-export function startCodexWatch({ store, readThreads = readCodexThreads, pollMs = CODEX_POLL_MS, firstDelayMs = 8_000 } = {}) {
+export function startCodexWatch({ store, readThreads = readCodexThreads, pollMs = CODEX_POLL_MS, firstDelayMs = 8_000, count = null } = {}) {
+  // Conversations this run has already counted. In memory on purpose, exactly
+  // 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 }); } 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);