agentbox-app 0.1.13 → 0.1.16

package/main/task-terminals.mjs

@@ -4,6 +4,7 @@ import {randomUUID} from 'node:crypto';
 import {execFileSync} from 'node:child_process';
 import {createRequire} from 'node:module';
 import {commandRunning} from '../shared/terminal-state.mjs';
+import {loginShell} from './shell-path.mjs';
 const require=createRequire(import.meta.url);
 const LIMIT=262144;
 export function terminalEnv(source=process.env){
@@ -37,17 +38,6 @@ export function terminalPlace({store,supervisor,product,id,agent}){
   return {cwd,notice};
 }
 export function terminalFolder(args){return terminalPlace(args).cwd;}
-// The shell a person actually has. `$SHELL` when that file exists, then
-// zsh, bash, and sh. A machine with no zsh used to spawn `/bin/zsh` and
-// the terminal never came up.
-export function loginShell(env=process.env,exists=fs.existsSync){
-  const preferred=env.SHELL;
-  if(preferred&&exists(preferred))return preferred;
-  for(const candidate of ['/bin/zsh','/bin/bash','/bin/sh']){
-    if(exists(candidate))return candidate;
-  }
-  return preferred||'/bin/sh';
-}
 // Enumerate only descendants of our own shell, including background process
 // groups. Kill children before shell; closing a pane never calls this.
 export function disposeTerminalProcess(pty){
@@ -79,20 +69,62 @@ export function disposeTerminalProcess(pty){
  * (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.
  *
- * Idle AND unwatched for ten minutes is a shell that costs something and is
- * worth nothing, and it goes. Everything else stays until she or the app quits.
+ * Idle AND unwatched for an hour is a shell that costs something and is
+ * worth nothing, and it goes. Everything else stays until its task is closed:
+ * task terminals run in ./terminal-host.mjs, which outlives the app.
+ *
+ * IT WAS TEN MINUTES, AND THAT WAS TOO SHORT (w-6841800f17): "I come back after
+ * maybe 15 minutes and it's gone ... I don't see the error message." A deploy
+ * that fails leaves an idle shell with the error on it, and ten minutes away
+ * from the task took the error with the shell. So the wait is an hour, and when
+ * a shell does go, the end of what it showed comes back with the next one.
+ *
+ * AND A SHELL THAT PRINTED SOMETHING SHE HAS NOT SEEN IS NOT WORTH NOTHING
+ * (w-f147e487a1). She started the AWS tools install, left the thread while it
+ * ran, and came back to a new shell: the install finished while she was away,
+ * and since the idle clock ran from her last look, the shell went on the next
+ * sweep with its output unread. "I was running it." So the hour starts only
+ * once she has read everything it printed, and at the cap a shell she has read
+ * goes before one she has not; when all twenty hold unread output, the least
+ * recently watched still makes room.
  */
-const IDLE_MS=600000;
+const IDLE_MS=3600000;
+// How much of a closed shell's screen comes back. The end is where the error
+// is; 64K characters is several hundred lines of it.
+const KEPT_SCREEN=65536;
+// Closed shells whose screen is still held for her. Twice the cap is every
+// terminal open now plus as many again that the app has tidied away.
+const KEPT_SHELLS=40;
+/*
+ * THE END OF A SCREEN, CUT AT A LINE. Cutting mid-line would start the replay
+   halfway through a word or an escape sequence. */
+function keptScreen(buffer){
+  if(buffer.length<=KEPT_SCREEN)return buffer;
+  const tail=buffer.slice(-KEPT_SCREEN);
+  const line=tail.indexOf('\n');
+  return line<0?tail:tail.slice(line+1);
+}
 // 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;
+/*
+ * A TERMINAL LIVES AS LONG AS ITS TASK IS OPEN. Closing the task ends it; so,
+ * while memory is critical, does going unwatched. Each says why on the next
+ * terminal, in these words.
+ */
+export const ENDED={
+  closed:'This task was closed, so its terminal was ended.',
+  memory:'This terminal was ended because this computer was running out of memory.',
+};
+// While memory is critical, a terminal looked at this recently is still in use.
+const WATCHED_MS=600000;
 export class TaskTerminals {
-  constructor({spawn,resolve,disposeProcess=disposeTerminalProcess,env=terminalEnv(),shell=loginShell(),idleMs=IDLE_MS,sweepMs=SWEEP_MS,now=()=>Date.now()}={}){
+  constructor({spawn,resolve,disposeProcess=disposeTerminalProcess,env=terminalEnv(),shell=loginShell(),idleMs=IDLE_MS,sweepMs=SWEEP_MS,now=()=>Date.now(),readPressure=null,watchedMs=WATCHED_MS}={}){
     this.spawn=spawn??((...args)=>require('node-pty').spawn(...args));this.resolve=resolve;this.disposeProcess=disposeProcess;this.env=env;this.shell=shell;this.sessions=new Map();
-    this.idleMs=idleMs;this.now=now;
+    this.idleMs=idleMs;this.now=now;this.readPressure=readPressure;this.watchedMs=watchedMs;
     // Keys whose shell this class ended on its own, and WHY. The next open on
     // one says so rather than handing her a blank screen where her scrollback
     // was, and the two reasons are different sentences because they are
@@ -102,7 +134,7 @@ export class TaskTerminals {
     // `unref` so a sweep that is merely pending never holds the app open, and
     // never in a test: a suite that leaves an interval behind hangs the runner.
     if(sweepMs>0&&typeof setInterval==='function'){
-      this.timer=setInterval(()=>{try{this.sweepIdle();}catch{}},sweepMs);
+      this.timer=setInterval(()=>{try{this.sweepIdle();}catch{}this.relieveMemory().catch(()=>{});},sweepMs);
       this.timer?.unref?.();
     }
   }
@@ -115,29 +147,69 @@ export class TaskTerminals {
     if(session.exited)return false;
     try{return commandRunning(session.pty.process||'Shell',false);}catch{return false;}
   }
+  // Output past the last byte a read handed to the panel.
+  unread(session){return session.offset+session.buffer.length>(session.seenTo??0);}
   /*
-   * THE ONE THE CAP TAKES: least recently watched first, and never a busy one.
-     Null means every slot is genuinely working, which is the only case left
-     where she is told no. */
+   * THE ONE THE CAP TAKES: one she has read everything in before one she has
+     not, then least recently watched, and never a busy one. Null means every
+     slot is genuinely working, which is the only case left where she is told
+     no. */
   oldestIdle(){
-    let pick=null,at=Infinity;
+    let pick=null,pickUnread=true,at=Infinity;
     for(const [key,s] of this.sessions){
       if(this.busy(s))continue;
-      const seen=s.lastReadAt??0;
-      if(seen<at){at=seen;pick=key;}
+      const unread=this.unread(s),seen=s.lastReadAt??0;
+      if(pick===null||(pickUnread&&!unread)||(unread===pickUnread&&seen<at)){pick=key;pickUnread=unread;at=seen;}
     }
     return pick;
   }
+  /*
+   * THE APP ENDS A SHELL, AND KEEPS WHAT IT SAID. Only these two paths keep the
+     screen: when she presses End shell herself, `close` is called directly and
+     nothing comes back, because she chose to throw it away. */
+  retire(key,why){
+    const s=this.sessions.get(key);
+    const screen=s?keptScreen(s.buffer):'';
+    this.close(key);
+    this.reaped.delete(key);
+    this.reaped.set(key,{why,screen});
+    while(this.reaped.size>KEPT_SHELLS)this.reaped.delete(this.reaped.keys().next().value);
+  }
   sweepIdle(){
     const cutoff=this.now()-this.idleMs;
     for(const [key,s] of [...this.sessions]){
-      if(this.busy(s))continue;
+      if(this.busy(s)||this.unread(s))continue;
       if((s.lastReadAt??0)>cutoff)continue;
-      this.close(key);
-      this.reaped.set(key,'The previous shell here was closed after ten minutes idle.');
+      this.retire(key,'The previous shell here was closed after an hour idle.');
+    }
+  }
+  end(key,why){if(this.sessions.has(key))this.retire(key,why);}
+  list(){
+    return [...this.sessions].map(([key,s])=>({key,busy:this.busy(s),exited:s.exited,unread:this.unread(s),lastReadAt:s.lastReadAt??0,cwd:s.cwd,pid:s.pty.pid}));
+  }
+  /*
+   * TOO MUCH FOR THIS COMPUTER. Only while memory is critical, checked once a
+     minute: every shell at its prompt that nobody has looked at for ten
+     minutes, and one terminal running something, the one looked at least
+     recently. Never one looked at inside those ten minutes. */
+  async relieveMemory(){
+    if(!this.readPressure||!this.sessions.size)return [];
+    let pressure='normal';
+    try{pressure=await this.readPressure();}catch{}
+    if(pressure!=='critical')return [];
+    const cutoff=this.now()-this.watchedMs,idle=[];let busy=null,at=Infinity;
+    for(const [key,s] of this.sessions){
+      if(s.exited||(s.lastReadAt??0)>cutoff)continue;
+      if(!this.busy(s)){idle.push(key);continue;}
+      if((s.lastReadAt??0)<at){busy=key;at=s.lastReadAt??0;}
     }
+    const ended=busy?[...idle,busy]:idle;
+    for(const key of ended)this.retire(key,ENDED.memory);
+    return ended;
   }
-  open(key){
+  // `given` is where to open it when the caller has already worked that out:
+  // the terminal host (./terminal-host.mjs) cannot read the store.
+  open(key,given){
     if(this.sessions.has(key))return this.read(key,0);
     if(this.sessions.size>=MAX_TERMINALS){
       /*
@@ -149,22 +221,25 @@ export class TaskTerminals {
          and says so in those words. */
       const victim=this.oldestIdle();
       if(victim===null)throw Error('20 terminals are open and every one of them is running something. Stop one of those commands before opening another terminal.');
-      this.close(victim);
-      this.reaped.set(victim,'This shell was closed to make room for a newer terminal.');
+      this.retire(victim,'This shell was closed to make room for a newer terminal.');
     }
-    const place=this.resolve(key);
+    const place=given??this.resolve(key);
     const cwd=typeof place==='string'?place:place.cwd;
     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'});
+    const pty=this.spawn(command?.file??place?.shell??this.shell,command?.args??['-l'],{cwd,env:{...(place?.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(),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
        scrollback, which is the same event read as a bug. Dim, one line, above a
-       real prompt. */
-    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`;}
+       real prompt, under whatever the old shell last showed. */
+    const gone=this.reaped.get(key);
+    if(gone!==undefined){
+      this.reaped.delete(key);
+      const old=gone.screen?`${gone.screen}\x1b[0m${gone.screen.endsWith('\n')?'':'\r\n'}`:'';
+      session.buffer=`${old}\x1b[2m[${gone.why}${old?' Its output is above.':''} 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;this.wake(session);});
     pty.onExit(({exitCode})=>{session.exited=true;session.exitCode=exitCode;resolveExit();this.wake(session);});
@@ -188,6 +263,7 @@ export class TaskTerminals {
       const timer=setTimeout(done,Math.min(wait,READ_WAIT_MS));
       s.waiters.add(done);
     });
+    s.seenTo=end;
     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;
   }

package/main/team/index.mjs

@@ -17,28 +17,58 @@ import { listSharedProjects, joinSharedProject, markShared, makeDirect } from '.
 import { firstSentence } from '../../shared/thread-cards.mjs';
 import { cardsFor } from '../../shared/thread-cards.mjs';
 import fs from 'node:fs';
+import { saveAttachments, attachmentMarkdown } from '../save-attachments.mjs';
 import { hasLapsed, statusEnds } from '../../shared/team-status.mjs';
+import QRCode from 'qrcode';
+import { createPhoneInbox } from '../phone-inbox.mjs';
+import { SNAPSHOT_LIMITS, phoneProjectsOf, phoneEligible } from '../../shared/phone-snapshot.mjs';
+import { createRooms } from './rooms.mjs';
 
 // `signingIn` is { url } while a Google sign-in waits on the browser, so the
 // page can offer that link again rather than a button that does nothing.
-const EMPTY = { configured: false, started: false, signedIn: false, signingIn: null, me: null, team: null, invites: [], sent: [], people: [], cards: [], lastSyncAt: null, error: null };
+const EMPTY = { configured: false, canSignIn: false, started: false, settling: false, signedIn: false, signingIn: null, me: null, team: null, invites: [], sent: [], people: [], cards: [], lastSyncAt: null, error: null };
+
+// With Alpha features › Multiplayer off the window gets the sign-in the phone
+// needs and no team, so it draws the single-person app.
+export function teamForWindow(state, multiplayer) {
+  if (multiplayer || !state) return state;
+  const { rooms, ...rest } = state;
+  return { ...rest, configured: false, team: null, invites: [], sent: [], people: [], cards: [] };
+}
 
 export function createTeamService({
   session, store, disk, accountRoot, stateFile, onChange = () => {}, log = () => {}, intervalMs = 5000, startRetryMs = 1500,
   // The clock, so a test can move past the moment a status runs out.
   now = Date.now,
+  // HER PHONE WITH THE MAC SHUT (docs/cloud/PHONE-PLAN.md, step 1): which
+  // projects she put on it (slugs), how a command from it is done, and where
+  // this Mac remembers what it sent. Needs no team, only a sign-in.
+  phone = null,
+  // ROOMS (alpha, docs/team/ROOMS-PLAN.md): { enabled, device, presenceFacts, prefsFile }.
+  rooms: roomsSetup = null,
 }) {
-  let state = { ...EMPTY, configured: !!session?.configured };
+  // The phone site's address, only an https one, and its code for Settings.
+  const site = typeof phone?.site === 'string' && /^https:\/\/[^\s/]+(\/[^\s]*)?$/.test(phone.site) ? phone.site : null;
+  let siteQr = null;
+  // `settling` holds the window's boot screen until the team is known, so it
+  // never draws the single-person app first and then redraws with the team.
+  // `canSignIn` survives teamForWindow, so a build with Multiplayer off still asks.
+  let state = { ...EMPTY, configured: !!session?.configured, canSignIn: !!session?.configured, settling: !!session?.configured, phoneSite: site, phoneSiteQr: null };
   let backend = null;
   let sync = null;
   let timer = null;
   let unsubscribe = null;
   let pending = null;
+  let phoneInbox = null;
   // The sync cursors and which team this Mac is in, in one file.
   let local = null;
   const kept = () => (local ??= fileSyncState(stateFile, fs));
 
   const set = (patch) => { state = { ...state, ...patch }; onChange(); };
+  const rooms = roomsSetup ? createRooms({
+    backend: () => backend, me: () => state.me, team: () => state, now, log, onChange, ...roomsSetup,
+  }) : null;
+  if (site) QRCode.toString(site, { type: 'svg', margin: 1, errorCorrectionLevel: 'M' }).then((qr) => { siteQr = qr; set({ phoneSiteQr: qr }); }).catch(() => {});
 
   function products() {
     try { return store.listProducts(); } catch { return []; }
@@ -139,12 +169,71 @@ export function createTeamService({
         set({ error: String(err?.message ?? err) });
         return null;
       } finally {
+        // On its own, so a team sync that failed does not hold up her phone,
+        // nor her phone the team.
+        await phoneOnce();
+        await rooms?.tick().catch((err) => log(`rooms: ${err.message}`));
         pending = null;
       }
     });
     return pending;
   }
 
+  async function phoneOnce() {
+    // Not before the app's handlers exist: a command taken then would be
+    // marked refused for no reason of hers.
+    if (!phoneInbox || phone.ready?.() === false) return;
+    try {
+      await phoneInbox.syncOnce();
+      if (state.phoneError) set({ phoneError: null });
+    } catch (err) {
+      set({ phoneError: String(err?.message ?? err) });
+    }
+  }
+
+  function makePhoneInbox() {
+    if (!phone) return null;
+    const productOf = (slug) => products().find((p) => p.slug === slug) ?? null;
+    // WHO IT SENDS AS, fixed now, and whether that is still who is signed in
+    // (Codex's second review, finding 1).
+    const owner = state.me?.id;
+    const signedInAs = backend;
+    if (!owner) return null;
+    let inbox = null;
+    inbox = createPhoneInbox({
+      backend,
+      owner,
+      alive: () => phoneInbox === inbox && backend === signedInAs && state.me?.id === owner,
+      device: phone.device?.() ?? null,
+      projects: () => {
+        const on = new Set(phoneProjectsOf(phone.projects(), owner, phoneEligible(products())));
+        return products().filter((p) => on.has(p.slug)).map((p) => ({ slug: p.slug, name: p.name || p.slug, dir: p.dir || null, repoPath: p.repoPath || null }));
+      },
+      listItems: (slug) => { const p = productOf(slug); try { return p ? disk.readWorkItems(p.dir) : []; } catch { return []; } },
+      historyOf: (slug, id, { all = false } = {}) => { try { return store.readHistory(slug, id, { max: all ? Number.MAX_SAFE_INTEGER : SNAPSHOT_LIMITS.lines * 4 }); } catch { return []; } },
+      apply: phone.apply,
+      liveOf: (slug, id) => phone.live?.(slug, id) ?? null,
+      approvalsOf: () => phone.approvals?.() ?? [],
+      readSettings: phone.readSettings ?? null,
+      version: phone.version ?? '',
+      idleMs: phone.idleMs ?? null,
+      // The lid shut: projects whose threads carry on in the cloud, and runs it started (shared/cloud-kit.mjs).
+      carrying: phone.carrying ?? null,
+      kitsFor: phone.kitsFor ?? null,
+      adopt: phone.adopt ?? null,
+      cloudReplies: phone.cloudReplies ?? null,
+      runHome: phone.runHome ?? null,
+      newThreadKits: phone.newThreadKits ?? null,
+      adoptNew: phone.adoptNew ?? null,
+      // One file per person: what this Mac sent up for one account is not
+      // what the next one to sign in here has.
+      stateFile: phone.stateFile.replace(/(\.json)?$/, `.${owner}.json`),
+      now,
+      log,
+    });
+    return inbox;
+  }
+
   function stopLoop() {
     if (timer) clearInterval(timer);
     timer = null;
@@ -165,9 +254,12 @@ export function createTeamService({
     // no team cloud. So the single-person app opened on no projects at all.
     // Everybody gets one at boot now (main/main.mjs), signed in or not.
     await refreshTeam();
+    if (state.settling) set({ settling: false });
+    phoneInbox = makePhoneInbox();
     sync = createTeamSync({
       backend,
       disk,
+      log,
       state: kept(),
       // ARCHIVED ONES COUNT AS HERE. Asked of the visible list, a shared
       // project you archived read as missing and was joined again beside it.
@@ -184,7 +276,10 @@ export function createTeamService({
   }
 
   return {
-    state: () => state,
+    state: () => (rooms ? { ...state, rooms: rooms.state() } : state),
+    rooms,
+    /** What the desktop's banner was told arrived, for her phone's alerts (main/phone-alerts.mjs). */
+    phoneArrivals: (list, needsYou) => phoneInbox?.arrivals(list, needsYou),
 
     // THREE TRIES AT START, because one dropped request left the app signed
     // out until it was restarted (measured 2026-10-01 on a loaded Mac: the
@@ -199,10 +294,10 @@ export function createTeamService({
         try {
           const b = await session.restore();
           if (b) await signedIn(b);
-          set({ started: true });
+          set({ started: true, settling: false });
           return state;
         } catch (err) {
-          set({ error: String(err?.message ?? err) });
+          set({ error: String(err?.message ?? err), settling: false });
           if (attempt < 2) await new Promise((r) => setTimeout(r, startRetryMs * (attempt + 1)));
         }
       }
@@ -251,13 +346,16 @@ export function createTeamService({
 
     async signOut() {
       stopLoop();
+      // While still signed in, so this Mac can say it has gone.
+      await rooms?.stop().catch(() => {});
       await session.signOut?.();
       disk.setLineAuthor(null);
       delete process.env.AGENTBOX_PERSON_ID;
       backend = null;
       sync = null;
+      phoneInbox = null;
       // Signed out is a known answer, so the window shows the sign-in page at once.
-      state = { ...EMPTY, configured: !!session?.configured, started: true };
+      state = { ...EMPTY, configured: !!session?.configured, started: true, phoneSite: site, phoneSiteQr: siteQr };
       onChange();
       return state;
     },
@@ -372,7 +470,7 @@ export function createTeamService({
      * later is not a chance to lift it. Nothing picked means nothing sent, so
      * the row keeps composeItem's 0, which the inbox reads as Medium.
      */
-    async message(toIn, body, priority) {
+    async message(toIn, body, priority, files = []) {
       if (!backend || !state.team || !state.me) throw new Error('start or join a team first');
       const me = state.me.id;
       // One person or a few: the same conversation for the same people.
@@ -381,8 +479,9 @@ export function createTeamService({
       if (others.length > 11) throw new Error('a message goes to at most eleven people');
       if (others.some((p) => !state.people.some((q) => q.id === p))) throw new Error('that person is not on your team');
       const to = others.length === 1 ? others[0] : others;
-      const text = String(body ?? '').trim();
-      if (!text) throw new Error('a message needs some words');
+      const words = String(body ?? '').trim();
+      const carried = (Array.isArray(files) ? files : []).filter((f) => f && (f.dataBase64 || f.srcPath));
+      if (!words && !carried.length) throw new Error('a message needs some words');
       // THE RECORD IS REUSED ONLY IF IT IS EXACTLY THE TWO OF YOU AND ONE OF
       // YOU MADE IT. Found by review 2026-10-01: a teammate could make a
       // "direct" record holding you and somebody else, and the next message
@@ -404,6 +503,10 @@ export function createTeamService({
         }
         product = products().find((p) => p.dir === made.dir) ?? { slug: made.slug, dir: made.dir };
       }
+      // ITS FILES, saved into the conversation now that there is one, and
+      // linked under the words the way the reply box links them. The sync
+      // sends each one on before the line that names it (./sync.mjs).
+      const text = [words, attachmentMarkdown(saveAttachments(product.dir, carried))].filter(Boolean).join('\n\n');
       // ONE CONVERSATION PER PERSON (decided 2026-10-01 from user research:
       // people expect to click a name and see what was said before, and a
       // subject line on every message between two coworkers makes talking
@@ -411,7 +514,8 @@ export function createTeamService({
       // conversation the two of you already have, reopened if it was put away,
       // and only the first message ever starts one. Work stays in threads; this
       // is talk.
-      const title = firstSentence(text, 90) || text.slice(0, 90);
+      // Named by its words; a message that is only files is named by them.
+      const title = firstSentence(words, 90) || words.slice(0, 90) || (carried.length === 1 ? String(carried[0].name ?? 'A file') : `${carried.length} files`);
       const convo = conversationIn(product.slug);
       if (convo) {
         store.answerItem(product.slug, convo.id, { answer: text });