agentbox-app 0.1.11 → 0.1.13

package/main/agent-sessions.mjs

@@ -12,7 +12,9 @@
 //
 // WHERE A THREAD LIVES. Two places, because she named two:
 //
-//   ~/.claude/projects/<folder>/<id>.jsonl     every terminal session
+//   ~/.claude/projects/<folder>/<id>.jsonl     every terminal session (and the
+//                                              same under every other Claude
+//                                              data folder: main/agent-homes.mjs)
 //   ~/Library/Application Support/Claude/
 //     claude-code-sessions/**/local_<id>.json  the desktop app
 //
@@ -49,6 +51,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { claudeDataDirs } from './agent-homes.mjs';
 
 /**
  * "Recent = last few days", in days.
@@ -149,9 +152,22 @@ export function isScratchProjectDir(name, home = os.homedir()) {
  *
  *  An entrypoint we have never seen is treated as not hers. The cost of being
  *  wrong that way is one missing row on a card; the other way is the hundreds
- *  she is complaining about. */
+ *  she is complaining about.
+ *
+ *  `claude-vscode` IS A PERSON TOO (w-e46f2e9cea, 2026-10-11). It is what the
+ *  Claude Code extension writes in VS Code, Cursor and Windsurf, and leaving it
+ *  out threw away every session of everybody who runs Claude Code in an editor.
+ *  Read out of the 2.1.293 binary, which maps it to `claude_code_vscode`. The
+ *  `remote*` family stays out: those run in the cloud, not on this disk. */
+const BY_HAND = new Set(['cli', 'claude-desktop', 'claude-vscode']);
 export function startedByHand(entrypoint) {
-  return entrypoint === 'cli' || entrypoint === 'claude-desktop';
+  return BY_HAND.has(entrypoint);
+}
+
+/** Which of the three places a person starts Claude Code a session came from. */
+export function sourceOf(entrypoint) {
+  if (entrypoint === 'claude-desktop') return 'desktop';
+  return entrypoint === 'claude-vscode' ? 'editor' : 'terminal';
 }
 
 /**
@@ -251,9 +267,11 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_B
     const n = fs.readSync(fd, buf, 0, bytes, 0);
     const text = buf.slice(0, n).toString('utf8');
     // The last line of a fixed read is usually cut in half. Dropping it costs
-    // nothing, because what is wanted is at the top.
+    // nothing, because what is wanted is at the top. UNLESS THE WHOLE FILE FIT:
+    // then the last line is complete, and a file whose one row has no newline
+    // after it lost that row (found by Codex's review, 2026-10-11).
     const lines = text.split('\n');
-    const cut = lines.pop();
+    const cut = n < bytes ? null : lines.pop();
     let cwd = null;
     let entrypoint = null;
     const said = [];
@@ -278,7 +296,7 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_B
     // only when nothing she said was found and the session is not already
     // known to be the app's own, so the thousands of worker transcripts are
     // never read past their head.
-    if (!said.length && n === bytes && cut && /"type":"user"/.test(cut.slice(0, 2048))
+    if (!said.length && n === bytes && cut && /"type"\s*:\s*"user"/.test(cut.slice(0, 2048))
       && (!entrypoint || startedByHand(entrypoint))) {
       const rest = restOfLine(fd, n, most - n);
       if (rest) take(Buffer.concat([buf.subarray(buf.lastIndexOf(0x0a, n - 1) + 1, n), rest]).toString('utf8'));
@@ -331,25 +349,35 @@ function messageText(row) {
  *  `skipped` comes back with it because the counts are the argument for the
  *  filters, and a session that changes one of them should be able to see what
  *  it changed rather than take this comment's word for it. */
-function readTerminalThreads({ home, cutoff, max, skipIds = new Set() }) {
-  const root = path.join(home, '.claude', 'projects');
-  const skipped = { old: 0, scratch: 0, started: 0, subagent: 0, empty: 0, unread: 0, desktopDupe: 0 };
+function readTerminalThreads({ home, dirs, cutoff, max, skipIds = new Set() }) {
+  const skipped = { old: 0, scratch: 0, started: 0, subagent: 0, empty: 0, unread: 0, desktopDupe: 0, copy: 0 };
   const out = [];
-  const all = [];
-  walkTranscripts(root, all);
   // Stat everything, keep the recent, newest first, and only then start opening
   // files. This is the order that makes `max` safe: whatever it cuts off is
   // older than everything it kept.
+  //
+  // EVERY DATA FOLDER, NOT ONLY ~/.claude (main/agent-homes.mjs). They are
+  // pooled before the sort, so the cap and the time budget are spent on the
+  // newest sessions on the machine, whichever folder they are in.
   const recent = [];
-  for (const file of all) {
-    let when = 0;
-    try { when = fs.statSync(file).mtimeMs; } catch { continue; }
-    if (when < cutoff) { skipped.old += 1; continue; }
-    if (isSubagentPath(file.slice(root.length))) { skipped.subagent += 1; continue; }
-    if (isScratchProjectDir(path.relative(root, file).split(path.sep)[0], home)) { skipped.scratch += 1; continue; }
-    recent.push({ file, when });
+  for (const dir of dirs) {
+    const root = path.join(dir, 'projects');
+    const all = [];
+    walkTranscripts(root, all);
+    for (const file of all) {
+      let when = 0;
+      try { when = fs.statSync(file).mtimeMs; } catch { continue; }
+      if (when < cutoff) { skipped.old += 1; continue; }
+      if (isSubagentPath(file.slice(root.length))) { skipped.subagent += 1; continue; }
+      if (isScratchProjectDir(path.relative(root, file).split(path.sep)[0], home)) { skipped.scratch += 1; continue; }
+      recent.push({ file, when });
+    }
   }
   recent.sort((a, b) => b.when - a.when);
+  // ONE SESSION IS ONE ROW, even when two folders hold it: a backup folder with
+  // a copy of a conversation is ordinary. Newest first, so the copy kept is the
+  // one still being written to.
+  const seenIds = new Set();
   // THE CAP COUNTS WHAT IS KEPT, NOT WHAT IS OPENED (w-ec62ab6b38, 2026-09-28).
   // On a busy machine the last seven days held 9,073 transcripts, the newest
   // 1,200 were opened, and every one of those was started by agentbox itself,
@@ -373,14 +401,18 @@ function readTerminalThreads({ home, cutoff, max, skipIds = new Set() }) {
     // one desktop thread in her store. Its own record wins, because the app
     // wrote a real title into it and this side would have to guess one.
     if (skipIds.has(id)) { skipped.desktopDupe += 1; continue; }
+    if (seenIds.has(id)) { skipped.copy += 1; continue; }
     const { cwd, entrypoint, said } = readTranscriptHead(file);
+    // A copy is only the copy once it could be read. A damaged newer one, cut
+    // off mid-write, would otherwise hide the good older one in another folder.
+    if (cwd || entrypoint) seenIds.add(id);
     if (!startedByHand(entrypoint)) { skipped.started += 1; continue; }
     if (isScratchFolder(cwd, home)) { skipped.scratch += 1; continue; }
     const title = threadTitle(said);
     if (!title) { skipped.empty += 1; continue; }
     out.push({
       id,
-      source: entrypoint === 'claude-desktop' ? 'desktop' : 'terminal',
+      source: sourceOf(entrypoint),
       folder: cwd,
       folderName: path.basename(cwd),
       short: shortFolder(cwd, home),
@@ -484,6 +516,11 @@ function walkDesktop(dir, into, max, depth = 3) {
  *  the card groups by it, the same way it already groups agent files. */
 export function readSessionThreads({
   home = os.homedir(),
+  // Every Claude Code data folder to read (main/agent-homes.mjs). The app hands
+  // in the list it made with its own environment and settings; left out, it is
+  // the folders under `home`, and nothing from whatever CLAUDE_CONFIG_DIR the
+  // caller's process happens to carry.
+  dirs = claudeDataDirs({ home }),
   days = RECENT_DAYS,
   now = Date.now(),
   max = MAX_READS,
@@ -492,7 +529,7 @@ export function readSessionThreads({
   // The desktop side goes first so its ids are known before the transcripts are
   // walked, which is what stops one thread appearing twice.
   const desk = readDesktopThreads({ home, cutoff, max });
-  const term = readTerminalThreads({ home, cutoff, max, skipIds: desk.owned });
+  const term = readTerminalThreads({ home, dirs, cutoff, max, skipIds: desk.owned });
   const threads = [...term.threads, ...desk.threads].sort((a, b) => b.when - a.when);
   return {
     threads,

package/main/agent-updates.mjs

@@ -2,10 +2,11 @@
 // started only by the app's Update now action, never by a poll or terminal open.
 import fs from 'node:fs';
 import os from 'node:os';
-import path from 'node:path';
 import {execFile} from 'node:child_process';
 import {promisify} from 'node:util';
 import {TaskTerminals,terminalEnv} from './task-terminals.mjs';
+import { harnessFor } from './harnesses.mjs';
+import { harnessDefinition } from '../shared/harness-definitions.mjs';
 const exec=promisify(execFile);
 const valid=v=>typeof v==='string'&&/^\d+\.\d+\.\d+$/.test(v);
 export function newerVersion(installed,latest){
@@ -14,27 +15,15 @@ export function newerVersion(installed,latest){
  for(let i=0;i<3;i++){if(b[i]!==a[i])return b[i]>a[i];}return false;
 }
 export function updatePlan({engine,bin,real,home=os.homedir(),channel='latest'}){
- if(!['claude','codex'].includes(engine)||!path.isAbsolute(bin||'')||!real)return null;
- const name=engine==='claude'?'Claude Code':'Codex';
- const brew=real.match(/^(\/opt\/homebrew|\/usr\/local)\/Caskroom\/(claude-code(?:@latest)?|codex)\//);
- if(brew&&((engine==='claude'&&brew[2].startsWith('claude-code'))||(engine==='codex'&&brew[2]==='codex')))
-  return {name,file:`${brew[1]}/bin/brew`,args:['upgrade','--cask',brew[2]],feed:`https://formulae.brew.sh/api/cask/${brew[2]}.json`,format:'brew'};
- const pkg=engine==='claude'?'@anthropic-ai/claude-code':'@openai/codex';
- const tail=`/lib/node_modules/${pkg}/`;
- const at=real.indexOf(tail);
- if(at>0){const prefix=real.slice(0,at);return {name,file:path.join(prefix,'bin/npm'),args:['install','--global','--prefix',prefix,`${pkg}@${channel}`],env:{PATH:`${prefix}/bin:${process.env.PATH||''}`},feed:`https://registry.npmjs.org/${pkg}/${channel}`,format:'npm'};}
- if(engine==='claude'&&real.startsWith(path.join(home,'.local/share/claude/versions')+'/'))return {name,file:bin,args:['update'],feed:`https://downloads.claude.ai/claude-code-releases/${channel}`,format:'text'};
- const standalone=real.match(/^(.*)\/packages\/standalone\/(?:releases|current)\//);
- if(engine==='codex'&&standalone)return {name,file:'/bin/bash',args:['-o','pipefail','-c','/usr/bin/curl -fsSL --connect-timeout 10 --max-time 60 https://chatgpt.com/codex/install.sh | /bin/sh'],env:{CODEX_HOME:standalone[1],CODEX_INSTALL_DIR:path.dirname(bin)},feed:'https://releases.openai.com/codex/channels/latest',format:'codex'};
- return null;
+ if(!harnessDefinition(engine))return null;
+ return harnessFor(engine).updatePlan({bin,real,home,channel});
 }
-const json=file=>{try{return JSON.parse(fs.readFileSync(file,'utf8'))}catch{return {}}};
 export async function installedAgent(engine,config){
- const bin=engine==='codex'?config.codexBin:config.claudeBin;
+ const harness=harnessFor(engine), bin=harness.binary(config);
  if(!bin)throw Error('This agent is not installed.');
  const home=config.home||os.homedir();
- const settings=engine==='claude'?json(path.join(process.env.CLAUDE_CONFIG_DIR||path.join(home,'.claude'),'settings.json')):{};
- const env=terminalEnv();
+ const settings=harness.updateSettings({home});
+ const env=harness.launchEnv(bin,terminalEnv());
  // Version inspection must not itself auto-update anything.
  const {stdout}=await exec(bin,['--version'],{timeout:8000,maxBuffer:16384,env:{...env,DISABLE_AUTOUPDATER:'1'}});
  const version=stdout.match(/\b\d+\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
@@ -57,7 +46,7 @@ export class AgentUpdates{
  }
  status(engine){return this.entries.get(engine)||{engine,state:'unknown'};}
  check(engine,force=false){
-  if(!['claude','codex'].includes(engine))return Promise.reject(Error('Unknown agent.'));
+  if(!harnessDefinition(engine))return Promise.reject(Error('Unknown agent.'));
   if(this.starts.has(engine)||this.status(engine).state==='running')return Promise.resolve(this.status(engine));
   if(this.checks.has(engine))return this.checks.get(engine);
   const saved=this.status(engine);if(!force&&saved.checkedAt&&this.now()-saved.checkedAt<3600000)return Promise.resolve(saved);
@@ -103,7 +92,7 @@ export class AgentUpdates{
   if(!this.plans.has(engine))throw Error('Click Update now first.');
   switch(p.action){
    case 'open':return this.terminals.read(engine,0);
-   case 'read':return this.terminals.read(engine,p.offset);
+   case 'read':return this.terminals.read(engine,p.offset,p.wait);
    case 'write':return this.terminals.write(engine,p.data);
    case 'resize':return this.terminals.resize(engine,p.cols,p.rows);
    case 'close':return this.terminals.close(engine);

package/main/analytics.mjs

@@ -178,6 +178,36 @@ export function createAnalytics({ config, version, dir, client, env = process.en
         report_version: Number(payload.v ?? 1),
         error: payload.error ?? null,
         happened_at: String(payload.ts ?? ''),
+        // THE VERSION IT CRASHED ON, WHICH IS NOT ALWAYS THE ONE SENDING IT.
+        // A report written by a dying process is drained on the NEXT launch,
+        // and that launch may be a newer app: `base.app_version` then files
+        // 0.1.11's crash against 0.1.12. It did, for three of the six window
+        // errors the launch report attributes to 0.1.12 (PostHog, 2026-10-08),
+        // and a version asked to answer for the bugs of the one before it is
+        // how a release that fixed something reads as a release that broke it.
+        // The report has carried the right answer all along.
+        app_version: String(payload.app?.version ?? base.app_version),
+        // WHY THE WINDOW DIED, which is the only thing a `renderer-gone`
+        // report is for and the one thing it was not carrying.
+        // `installCrashReports` collects Electron's `details.reason` and
+        // `details.exitCode` and says in its own comment why they are safe:
+        // the reason is Electron's closed vocabulary (`crashed`, `oom`,
+        // `killed`, `launch-failed` and the rest) and carries nothing of
+        // anyone's. They were written to disk and then dropped here, because
+        // this list names its properties by hand. So the launch report's one
+        // dead window says `render process gone` and nothing else, and `oom`
+        // after three and a half hours (a leak) could not be told apart from a
+        // hard fault (not a leak). Measured 2026-10-08.
+        //
+        // Absent rather than empty when there is nothing to say: a null reason
+        // on the thirteen crashes that never had one reads as an answer in a
+        // chart. A reason longer than Electron's longest word is a bug
+        // upstream rather than a reason, and is left out too.
+        ...(typeof payload.reason === 'string' && payload.reason && payload.reason.length <= 40
+          ? { crash_reason: payload.reason } : {}),
+        ...(Number.isFinite(payload.exitCode) ? { exit_code: Number(payload.exitCode) } : {}),
+        ...(typeof payload.processType === 'string' && payload.processType && payload.processType.length <= 40
+          ? { process_type: payload.processType } : {}),
       });
     },
 

package/main/approvals.mjs

@@ -387,12 +387,20 @@ const REQUEST_SUFFIX = '.request.json';
  * FORWARD to now. A worker can therefore make its own request look younger than
  * it is, which costs it the front of the stack, and can never make it look
  * older. Nanoseconds because APFS keeps them and two files written back to back
- * differ by about 170 microseconds; equal stamps keep `readdir` order, which is
- * as good as anything when two things really did happen at once.
+ * differ by about 170 microseconds.
+ *
+ * A coarse clock stamps both files the same. tmpfs does this: two writes in
+ * one poll share a ctime, and `readdir` then comes back in name order, which
+ * is the forgery the paragraph above is about. The inode breaks that tie.
+ * The kernel assigns it, a later create in a fresh directory gets a higher
+ * one, and a worker cannot move it backwards. Equal inode and equal ctime
+ * keep the order we already had.
  */
 function bornAt(dir, name) {
-  try { return fs.lstatSync(path.join(dir, name), { bigint: true }).ctimeNs; }
-  catch { return 2n ** 63n; } // gone or unreadable: never in front of something real
+  try {
+    const st = fs.lstatSync(path.join(dir, name), { bigint: true });
+    return { ctime: st.ctimeNs, ino: st.ino };
+  } catch { return { ctime: 2n ** 63n, ino: 2n ** 63n }; } // gone or unreadable: never in front of something real
 }
 
 export function listPending(storeRoot, { now = Date.now } = {}) {
@@ -409,7 +417,8 @@ export function listPending(storeRoot, { now = Date.now } = {}) {
   for (const { f } of names
     .filter((f) => !seenAt.has(prefix + f.slice(0, -REQUEST_SUFFIX.length)))
     .map((f) => ({ f, born: bornAt(dir, f) }))
-    .sort((a, b) => (a.born < b.born ? -1 : a.born > b.born ? 1 : 0))) {
+    .sort((a, b) => (a.born.ctime < b.born.ctime ? -1 : a.born.ctime > b.born.ctime ? 1
+      : a.born.ino < b.born.ino ? -1 : a.born.ino > b.born.ino ? 1 : 0))) {
     seenAt.set(prefix + f.slice(0, -REQUEST_SUFFIX.length), { at, seq: sightings += 1 });
   }
   const present = new Set();