agentbox-app 0.1.12 → 0.1.13

package/main/task-terminals.mjs

@@ -9,6 +9,11 @@ const LIMIT=262144;
 export function terminalEnv(source=process.env){
   const env={...source,TERM:'xterm-256color',COLORTERM:'truecolor'};
   for(const key of Object.keys(env)) if(/^(ANTHROPIC_|OPENAI_API_KEY$|CLAUDE_CODE_|CLAUDECODE$|CLAUDE_PID$|CLAUDE_EFFORT$|ELECTRON_|NODE_OPTIONS$)/.test(key)) delete env[key];
+  // NPM'S STAND-IN EDITOR IS NOBODY'S CHOICE. `npm start` gives everything it
+  // runs EDITOR=vi when neither EDITOR nor VISUAL is set, and zsh reads "vi"
+  // there as a request for vi keys: Option+Left deleted and Option+Delete
+  // moved. A login shell sets the person's own EDITOR from their startup files.
+  if(env.EDITOR==='vi'&&!env.VISUAL) delete env.EDITOR;
   return env;
 }
 /*
@@ -68,8 +73,9 @@ export function disposeTerminalProcess(pty){
  * it is the same call the toolbar makes to decide whether to draw Stop command,
  * deliberately, so a shell she can see is busy can never be one this reaps.
  *
- * WHICH SHELLS NOBODY IS WATCHING: the panel asks for output every 150ms while
- * it is on screen and stops the instant it is hidden or she leaves the task
+ * WHICH SHELLS NOBODY IS WATCHING: the panel asks for output at least once a
+ * second while it is on screen (each ask waits up to READ_WAIT_MS for some)
+ * and stops the instant it is hidden or she leaves the task
  * (TaskTerminal.tsx). So `lastReadAt` is not a guess about attention, it is the
  * last time the app was actually asked what this shell had to say.
  *
@@ -77,6 +83,10 @@ export function disposeTerminalProcess(pty){
  * worth nothing, and it goes. Everything else stays until she or the app quits.
  */
 const IDLE_MS=600000;
+// The longest a read waits for output before answering with none, so the panel
+// still hears about a command that finished quietly and the sweep still sees
+// it watching.
+const READ_WAIT_MS=1000;
 const SWEEP_MS=60000;
 const MAX_TERMINALS=20;
 export class TaskTerminals {
@@ -147,7 +157,7 @@ export class TaskTerminals {
     const command=place?.command;
     const pty=this.spawn(command?.file??this.shell,command?.args??['-l'],{cwd,env:{...this.env,...command?.env},cols:80,rows:24,name:'xterm-256color'});
     let resolveExit;const exitPromise=new Promise(resolve=>{resolveExit=resolve;});
-    const session={token:randomUUID(),pty,cwd,buffer:'',offset:0,exitCode:null,exited:false,exitPromise,lastReadAt:this.now()};this.sessions.set(key,session);
+    const session={token:randomUUID(),pty,cwd,buffer:'',offset:0,exitCode:null,exited:false,exitPromise,lastReadAt:this.now(),waiters:new Set()};this.sessions.set(key,session);
     /*
      * AND IT SAYS WHAT HAPPENED TO THE LAST ONE. Without this line, reopening a
        terminal the app tidied away looks exactly like the app losing her
@@ -156,17 +166,37 @@ export class TaskTerminals {
     const why=this.reaped.get(key);
     if(why!==undefined){this.reaped.delete(key);session.buffer=`\x1b[2m[${why} This is a new one.]\x1b[0m\r\n`;}
     if(place?.notice)session.buffer+=`\x1b[2m[${place.notice}]\x1b[0m\r\n`;
-    pty.onData(data=>{session.buffer+=data;const trim=Math.max(0,session.buffer.length-LIMIT);session.buffer=session.buffer.slice(trim);session.offset+=trim;});
-    pty.onExit(({exitCode})=>{session.exited=true;session.exitCode=exitCode;resolveExit();});
+    pty.onData(data=>{session.buffer+=data;const trim=Math.max(0,session.buffer.length-LIMIT);session.buffer=session.buffer.slice(trim);session.offset+=trim;this.wake(session);});
+    pty.onExit(({exitCode})=>{session.exited=true;session.exitCode=exitCode;resolveExit();this.wake(session);});
     return this.read(key,0);
   }
   get(key){const s=this.sessions.get(key);if(!s)throw Error('Terminal session ended. Open a new terminal to continue.');return s;}
   // EVERY READ IS THE PANEL SAYING IT IS STILL THERE. This one line is the whole
   // attention signal the sweep runs on; see the note on the class.
-  read(key,offset=0){const s=this.get(key);if(!Number.isSafeInteger(offset)||offset<0)throw Error('Invalid terminal cursor.');s.lastReadAt=this.now();const end=s.offset+s.buffer.length;return {token:s.token,cwd:s.cwd,data:s.buffer.slice(Math.max(0,offset-s.offset)),offset:end,truncated:offset<s.offset,exited:s.exited,exitCode:s.exitCode,process:s.exited?'Exited':s.pty.process||'Shell'};}
+  read(key,offset=0,wait=0){
+    const s=this.get(key);if(!Number.isSafeInteger(offset)||offset<0)throw Error('Invalid terminal cursor.');s.lastReadAt=this.now();
+    const end=s.offset+s.buffer.length;
+    /*
+     * A READ MAY WAIT FOR THE SHELL'S NEXT OUTPUT, and comes back the moment
+       there is some. The panel used to ask every 150ms, so the echo of a key
+       sat in this buffer until the next ask: deleted characters stayed on her
+       screen after she deleted them (w-16e47d0836). `live` tells the panel this
+       main can wait, so it asks again at once instead of in 150ms; a main
+       older than its renderer (⌘R ahead of a restart) answers without it. */
+    if(wait>0&&!s.exited&&offset>=end)return new Promise((resolve,reject)=>{
+      const done=()=>{clearTimeout(timer);s.waiters.delete(done);try{if(this.sessions.get(key)!==s)throw Error('Terminal session ended. Open a new terminal to continue.');resolve({...this.read(key,offset),live:true});}catch(e){reject(e);}};
+      const timer=setTimeout(done,Math.min(wait,READ_WAIT_MS));
+      s.waiters.add(done);
+    });
+    const state={token:s.token,cwd:s.cwd,data:s.buffer.slice(Math.max(0,offset-s.offset)),offset:end,truncated:offset<s.offset,exited:s.exited,exitCode:s.exitCode,process:s.exited?'Exited':s.pty.process||'Shell'};
+    return wait>0?{...state,live:true}:state;
+  }
+  // Answers every waiting read. Deferred a turn so the pieces of one echo the
+  // pty hands over back to back go out as one answer.
+  wake(s){if(!s.waiters.size||s.waking)return;s.waking=true;setImmediate(()=>{s.waking=false;for(const done of [...s.waiters])done();});}
   write(key,data){const s=this.get(key);if(s.exited)throw Error('This shell has exited. Start a new session.');if(typeof data!=='string'||data.length>65536)throw Error('Terminal input is too large. Paste at most 64 KB at a time.');s.pty.write(data);}
   resize(key,cols,rows){if(!Number.isInteger(cols)||!Number.isInteger(rows)||cols<2||cols>500||rows<2||rows>300)throw Error('Invalid terminal size.');const s=this.get(key);if(!s.exited)s.pty.resize(cols,rows);}
-  close(key){const s=this.sessions.get(key);if(s){if(!s.exited)this.disposeProcess(s.pty);this.sessions.delete(key);}}
+  close(key){const s=this.sessions.get(key);if(s){if(!s.exited)this.disposeProcess(s.pty);this.sessions.delete(key);for(const done of [...s.waiters])done();}}
   async shutdown(){
     const exits=[...this.sessions.values()].map(s=>s.exitPromise);
     this.dispose();

package/main/updater.mjs

@@ -48,6 +48,7 @@
 
 import { createRequire } from 'node:module';
 import { Name } from '../shared/product-name.mjs';
+import { MOVE_SAY } from '../shared/where-it-runs-from.mjs';
 
 const require = createRequire(import.meta.url);
 
@@ -68,6 +69,14 @@ export function describe(state) {
   const { phase, currentVersion, newVersion, percent, error, checkedAt, readyAt, source, changes, behind } = state;
   const installing = phase === 'installing';
   return {
+    // WHETHER THIS COPY CAN UPDATE ITSELF FROM WHERE IT IS, and the one press
+    // that fixes it when it cannot (main/where-it-runs-from.mjs). It rides the
+    // updater's own state because the three surfaces that would have to ask
+    // separately — the Settings row, the sidebar card and ⌘K — all already
+    // read this one object, and a second channel for it is a second answer.
+    canMove: !!state.canMove,
+    place: state.canMove ? (state.place ?? null) : null,
+    moveError: state.moveError ?? null,
     phase,
     currentVersion,
     newVersion: newVersion ?? null,
@@ -96,7 +105,17 @@ export function describe(state) {
   };
 }
 
-export function createUpdater({ app, log = console, onChanged = () => {} }) {
+/**
+ * `autoUpdater` is a SEAM FOR THE TESTS and nothing else. The real one is
+ * required below; passing one in is how the failure paths get tested without a
+ * packaged build, a signed release and a network, which is the only reason the
+ * download bug (see the swallow in `check`) went seven reports unnoticed.
+ */
+export function createUpdater({ app, log = console, onChanged = () => {}, autoUpdater: given = null, place = null }) {
+  // READ ONCE, at construction (main/where-it-runs-from.mjs says why the
+  // bundle cannot move under a running process). A build with no place passed
+  // in — the tests, and `main/serve.mjs` — simply never offers the move.
+  const where = place?.state?.() ?? { place: null, canUpdate: true, offerMove: false };
   let state = {
     phase: 'idle',
     currentVersion: app.getVersion(),
@@ -105,6 +124,9 @@ export function createUpdater({ app, log = console, onChanged = () => {} }) {
     error: null,
     checkedAt: null,
     readyAt: null,
+    canMove: !!where.offerMove,
+    place: where.place ?? null,
+    moveError: null,
   };
   let timer = null;
   let stopped = false;
@@ -117,12 +139,14 @@ export function createUpdater({ app, log = console, onChanged = () => {} }) {
   // Loaded lazily and inside a try, so a build that somehow shipped without the
   // dependency degrades to "no updates" instead of failing to boot at all. The
   // app not starting is a strictly worse outcome than the app not updating.
-  let autoUpdater = null;
-  try {
-    ({ autoUpdater } = require('electron-updater'));
-  } catch (e) {
-    set({ phase: 'unsupported', error: 'This build has no updater in it.' });
-    log.warn?.('[updater] electron-updater is not available:', e?.message ?? e);
+  let autoUpdater = given;
+  if (!autoUpdater) {
+    try {
+      ({ autoUpdater } = require('electron-updater'));
+    } catch (e) {
+      set({ phase: 'unsupported', error: 'This build has no updater in it.' });
+      log.warn?.('[updater] electron-updater is not available:', e?.message ?? e);
+    }
   }
 
   if (autoUpdater) {
@@ -184,7 +208,23 @@ export function createUpdater({ app, log = console, onChanged = () => {} }) {
     if (state.phase === 'ready') return describe(state);
     if (state.phase === 'checking' || (state.phase === 'downloading' && !manual)) return describe(state);
     try {
-      await autoUpdater.checkForUpdates();
+      const found = await autoUpdater.checkForUpdates();
+      // THE DOWNLOAD IS A SECOND PROMISE AND NOBODY WAS HOLDING IT. With
+      // `autoDownload` on, electron-updater starts the download inside the
+      // check and hands it back here as `downloadPromise`; its own
+      // `downloadUpdate` dispatches the `error` event and then RE-THROWS. The
+      // await above resolves on the RESULT, not on the download, so a failed
+      // download had nowhere to land but `unhandledRejection` — and
+      // `main/crash-report.mjs` files one of those as a crash.
+      //
+      // That is 7 of the 14 crash reports of launch week (PostHog, 2026-10-08)
+      // and not one of them was a crash: five are Squirrel's read-only volume
+      // error from an app run out of the disk image, two are a dropped
+      // connection, and in every one of them the app carried on running. The
+      // failure is ALREADY on screen by the time we get here, because the
+      // `error` handler above set it, so there is nothing left to do with this
+      // rejection but stop it being mistaken for a crash.
+      found?.downloadPromise?.catch?.(() => {});
     } catch (e) {
       set({ phase: 'error', error: shortError(e), checkedAt: Date.now() });
     }
@@ -201,6 +241,18 @@ export function createUpdater({ app, log = console, onChanged = () => {} }) {
     return true;
   }
 
+  // THE OTHER BUTTON, for a copy that cannot update itself from where it is.
+  // Electron moves the bundle and relaunches, so a `true` here is the last
+  // thing this process does. A failure goes into the state like every other
+  // failure, so the row and the sidebar card both say it and both offer
+  // another press.
+  function move() {
+    if (!state.canMove) return { moved: false, error: null };
+    const got = place?.move?.() ?? { moved: false, error: null };
+    if (!got.moved) set({ moveError: got.error ?? null });
+    return got;
+  }
+
   function start() {
     if (stopped || timer) return;
     const tick = () => { void check(); };
@@ -215,7 +267,7 @@ export function createUpdater({ app, log = console, onChanged = () => {} }) {
     timer = null;
   }
 
-  return { start, stop, check, install, state: () => describe(state) };
+  return { start, stop, check, install, move, state: () => describe(state) };
 }
 
 // electron-updater's errors arrive as Error objects whose `message` is
@@ -234,6 +286,16 @@ export function shortError(e) {
   // releases/download/v0.1.0/latest-mac.yml): HttpErr…" to her. The sentence
   // for exactly that failure was already on the line below it.
   const named = `${e?.code ?? ''} ${raw}`;
+  // SQUIRREL'S OWN PARAGRAPH, WHICH IS 240 CHARACTERS AND HAS A URL IN IT.
+  // "Cannot update while running on a read-only volume. The application is on
+  // a read-only volume. Please move the application and try again. If you'll
+  // need to move the application out of the Downloads directory. See
+  // https://github.com/Squirrel/Squirrel.Mac …" — the whole of what 23 of the
+  // 26 main-rejection reports carried (PostHog, 2026-10-12), and the Settings
+  // row showed the first 160 characters of it. The app knows where it is
+  // running from (shared/where-it-runs-from.mjs), so this is one sentence and
+  // the row beside it is the press that fixes it.
+  if (/read-only volume/i.test(raw)) return MOVE_SAY.cannotUpdateHere;
   if (/ERR_UPDATER_ZIP_FILE_NOT_FOUND/.test(named)) return 'That release has no app in it to install.';
   if (/ERR_UPDATER_CHANNEL_FILE_NOT_FOUND/.test(named)) return 'That release is missing its update file.';
   if (/ERR_UPDATER_NO_PUBLISHED_VERSIONS|LATEST_VERSION_NOT_FOUND/.test(named)) return 'No published version to update to yet.';