agentbox-app 0.1.12 → 0.1.16

package/scripts/after-install.mjs

@@ -26,19 +26,41 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const require = createRequire(import.meta.url);
 
-// A checkout has scripts/linux-launcher.mjs next to this file. The published
-// package does not, so an npm install of that package, including npx, leaves
-// the launcher alone. A missing file is the ordinary case, not an error.
-const launcherPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'linux-launcher.mjs');
-if (fs.existsSync(launcherPath)) {
+// A checkout has scripts/linux-launcher.mjs and scripts/link-own-bin.mjs next
+// to this file. The published package carries neither, so an npm install of
+// that package, including npx, leaves both alone. A missing file is the
+// ordinary case here, not an error.
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+async function fromCheckout(file) {
+  const at = path.join(here, file);
+  if (!fs.existsSync(at)) return null;
   try {
-    const { installLinuxLauncher } = await import(pathToFileURL(launcherPath).href);
-    installLinuxLauncher({ env: process.env });
+    return await import(pathToFileURL(at).href);
   } catch {
     // Nothing here is worth stopping an install for.
+    return null;
   }
 }
 
+const launcher = await fromCheckout('linux-launcher.mjs');
+if (launcher) {
+  const { changed, why } = launcher.installLinuxLauncher({ env: process.env });
+  if (changed) console.log('agentbox: this checkout is in the app launcher.');
+  // A launcher that did not happen says so. Before this, a fresh clone whose
+  // Electron binary was not downloaded yet got no launcher and no word about
+  // it, and `which agentbox` answered nothing.
+  else if (why) console.log(`agentbox: no app launcher was written: ${why}.`);
+}
+
+// And the checkout's own command, so `npx agentbox-app` from here starts the
+// browser rather than looking for `agentbox` on PATH.
+const own = await fromCheckout('link-own-bin.mjs');
+if (own) {
+  const { why } = own.linkOwnBin();
+  if (why) console.log(`agentbox: \`npx agentbox-app\` will not work from this checkout: ${why}.`);
+}
+
 function prebuildsDir() {
   // Resolve the package rather than guessing at ../node-pty: npm may have
   // hoisted it, nested it, or put it in a workspace root.
@@ -67,7 +89,7 @@ try {
     fs.chmodSync(helper, 0o755);
     fixed += 1;
   }
-  if (fixed) console.log(`agentbox: made ${fixed} node-pty spawn-helper binary${fixed === 1 ? '' : 'ies'} executable, so the terminal works.`);
+  if (fixed) console.log(`agentbox: made ${fixed} node-pty spawn-helper binar${fixed === 1 ? 'y' : 'ies'} executable, so the terminal works.`);
 } catch {
   // Nothing here is worth stopping an install for.
 }

package/scripts/approval-server.sh

@@ -39,10 +39,29 @@ case "$here" in
     exec env ELECTRON_RUN_AS_NODE=1 "$app/MacOS/$exe" "$res/app.asar/main/approval-prompt-server.mjs"
     ;;
   *)
-    # Running from source: node is nvm-only on this machine, and MCP servers
-    # boot from a bare login shell, so resolve it the same way the store
-    # launcher does.
-    export PATH="$HOME/.nvm/versions/node/$(ls "$HOME/.nvm/versions/node" 2>/dev/null | tail -1)/bin:$PATH"
-    exec node "$(cd "$here/.." && pwd)/main/approval-prompt-server.mjs"
+    # RUNNING FROM SOURCE, AND THIS LINE USED TO ASSUME NVM. It prepended
+    # $HOME/.nvm/versions/node/<newest>/bin and exec'd node. On a Mac that
+    # installed node by Homebrew, Volta, asdf or not at all, that folder is
+    # absent, PATH is untouched, and an MCP server booting from a bare login
+    # shell has no node on it: the exec failed and every agent died the same
+    # four-second death described at the top of this file. Reported from
+    # source on 2026-10-07 (issue 21).
+    #
+    # So the app hands its own binary down in ZERO_APPROVALS_RUNTIME, and
+    # ELECTRON_RUN_AS_NODE=1 makes that binary a node, exactly as the packaged
+    # branch above does. Nothing on the machine is needed.
+    server="$(cd "$here/.." && pwd)/main/approval-prompt-server.mjs"
+    if [ -f "$ZERO_APPROVALS_RUNTIME" ] && [ -x "$ZERO_APPROVALS_RUNTIME" ]; then
+      exec env ELECTRON_RUN_AS_NODE=1 "$ZERO_APPROVALS_RUNTIME" "$server"
+    fi
+    # Nobody handed one down, so this is somebody running the script by hand.
+    # A node already on PATH wins; nvm's newest is the last resort, for the
+    # bare login shell that has never sourced nvm.
+    if ! command -v node >/dev/null 2>&1; then
+      nvm="$HOME/.nvm/versions/node"
+      newest="$(ls "$nvm" 2>/dev/null | tail -1)"
+      [ -n "$newest" ] && export PATH="$nvm/$newest/bin:$PATH"
+    fi
+    exec node "$server"
     ;;
 esac

package/scripts/before-publish.mjs

@@ -69,17 +69,19 @@ function wouldShip(changed) {
     // If npm cannot tell us, the honest answer is the cautious one.
     return changed;
   }
-  // THE FILES THE PUBLISH ITSELF REWRITES, which would otherwise make every
-  // attempt poison the next one. `prepack` runs `npm run build`, and the build
-  // reads the installed Claude Code and writes what it found into
-  // shared/*.generated.*. So a failed publish leaves those modified, and the
-  // next publish refuses because of dirt the last publish made. Measured
-  // 2026-09-28: one failed attempt left claude-models.generated.mjs changed by
-  // a version number, and that alone blocked the retry.
+  // THE FILES A PUBLISH USED TO REWRITE, which made every attempt poison the
+  // next one. `prepack` runs `npm run build`, and the build read the installed
+  // Claude Code and wrote what it found over shared/*.generated.*. So a failed
+  // publish left those modified and the next publish refused because of dirt the
+  // last publish had made. Measured 2026-09-28: one failed attempt left
+  // claude-models.generated.mjs changed by a version number, and that alone
+  // blocked the retry.
   //
-  // They are safe to ignore here BECAUSE the build rewrites them anyway. What
-  // ships is whatever the build produces on the machine publishing, every time,
-  // committed or not, so a difference in the working tree changes nothing.
+  // THE BUILD NO LONGER WRITES THEM (w-6bbb709b1f): it writes
+  // shared/*.local.json, which is gitignored, and `npm run read:claude` is what
+  // updates the committed tables. This filter stays as the belt for a folder an
+  // OLDER build already dirtied, and because what ships is whatever the build
+  // produces on the machine publishing, so a difference here changes nothing.
   return changed.filter((f) => packed.has(f) && !/\.generated\./.test(f));
 }
 

package/scripts/cloud-shim.pl

@@ -0,0 +1,57 @@
+#!/usr/bin/perl
+# A CLOUD RUN, AS THE SUPERVISOR SEES IT: one small process standing in for a
+# run whose relay lives in the shared host (main/cloud/host.mjs). It carries
+# its input, output, signals and exit code there and back. Perl, because every
+# Mac has it and a stand-in in it costs a few megabytes.
+#
+#   cloud-shim.pl <host socket> <the relay's own arguments ...>
+use strict;
+use warnings;
+use IO::Socket::UNIX;
+use IO::Select;
+use MIME::Base64 qw(encode_base64 decode_base64);
+use JSON::PP;
+use Cwd qw(getcwd);
+use POSIX qw(:sys_wait_h);
+
+my $sockpath = shift @ARGV;
+# A host just started may take a moment to listen.
+my $sock;
+for (1 .. 50) { $sock = IO::Socket::UNIX->new(Type => SOCK_STREAM(), Peer => $sockpath); last if $sock; select(undef, undef, undef, 0.1); }
+if (!$sock) { print STDERR "agentbox cloud: the cloud host is not running ($!)\n"; exit 75; }
+binmode($sock); binmode(STDIN); binmode(STDOUT); binmode(STDERR);
+$sock->autoflush(1);
+
+sub put { my ($line) = @_; local $SIG{PIPE} = 'IGNORE'; print {$sock} "$line\n"; }
+
+put(JSON::PP->new->canonical->encode({ argv => [@ARGV], env => {%ENV}, cwd => getcwd(), pid => $$ }));
+for my $sig (qw(TERM INT HUP)) { $SIG{$sig} = sub { put("k SIG$sig"); }; }
+
+my $sel = IO::Select->new($sock, \*STDIN);
+my ($buf, $code, $parent, $orphaned) = ('', undef, getppid(), 0);
+while (1) {
+  my @ready = $sel->can_read(1);
+  # The app gone without a word: the run is left going, as on a quit.
+  if (!$orphaned && getppid() != $parent) { $orphaned = 1; put('k SIGHUP'); }
+  for my $fh (@ready) {
+    if ($fh == $sock) {
+      my $n = sysread($sock, my $chunk, 65536);
+      if (!defined $n) { next if $!{EINTR}; $n = 0; }
+      if (!$n) { exit(defined $code ? $code : 75); }
+      $buf .= $chunk;
+      while ((my $i = index($buf, "\n")) >= 0) {
+        my $line = substr($buf, 0, $i);
+        $buf = substr($buf, $i + 1);
+        my ($tag, $rest) = (substr($line, 0, 1), substr($line, 2));
+        if ($tag eq 'o') { my $d = decode_base64($rest); my $off = 0; while ($off < length $d) { my $w = syswrite(STDOUT, $d, length($d) - $off, $off); last unless defined $w; $off += $w; } }
+        elsif ($tag eq 'e') { my $d = decode_base64($rest); syswrite(STDERR, $d); }
+        elsif ($tag eq 'x') { $code = int($rest); }
+      }
+    } else {
+      my $n = sysread(STDIN, my $chunk, 65536);
+      if (!defined $n) { next if $!{EINTR}; $n = 0; }
+      if (!$n) { put('I'); $sel->remove(\*STDIN); }
+      else { put('i ' . encode_base64($chunk, '')); }
+    }
+  }
+}

package/shared/account-names.d.mts

@@ -0,0 +1,6 @@
+export declare function accountName(account?: {
+  email?: string | null;
+  engine?: string;
+  index?: number;
+  total?: number;
+}): string;

package/shared/account-names.mjs

@@ -0,0 +1,15 @@
+// WHAT ONE LOGIN IS CALLED, in the one rule both sides read: the Settings
+// page, which has named accounts by their email since it had rows, and the
+// sentence a thread gets when a login runs out, which had no name for one at
+// all until w-e1a42f6b21.
+
+/**
+ * @param {{ email?: string | null, engine?: string, index?: number, total?: number }} account
+ *  `index` is its place among that engine's accounts, `total` how many there
+ *  are: one account is not counted, because the number would mean nothing.
+ */
+export function accountName({ email = null, engine = 'claude', index = 0, total = 1 } = {}) {
+  if (email) return email;
+  const word = engine === 'codex' ? 'Codex' : 'Claude';
+  return `${word} account${total > 1 ? ` ${index + 1}` : ''}`;
+}

package/shared/agent-hours.mjs

@@ -0,0 +1,136 @@
+// AGENT HOURS: the level, the week, the streak (w-3d0fa23ffb).
+//
+// Pure. A run is `{key, at, start, item, product, engine, seconds, failed,
+// began}`: `at` is when it ended, and a run is counted on the local day it
+// ended. Every run whose agent actually began counts its wall time, failed or
+// not, and overlapping runs each count.
+
+export const MASTERY_HOURS = 10_000;
+const MAX_RUN_SECONDS = 24 * 3600;
+const DAY_MS = 86_400_000;
+
+// Up to 99, hours grow as level^2.5: level 2 in minutes, 99 at MASTERY_HOURS.
+// Not RuneScape's curve, which spends half its hours on the last seven levels
+// and so reads 82 after one heavy month. Past 99 there is no ceiling and each
+// level costs 5% more than the last, starting from the curve's pace at 99 so
+// no level ever costs less than the one before.
+const RISE = 2.5;
+const PAST = Math.log(1.05);
+const PACE_AT_99 = (MASTERY_HOURS * RISE) / 98;
+// A level starts at its exact hours, not one float step later.
+const EPS = 1e-10;
+
+export function hoursForLevel(level) {
+  const L = Number(level);
+  if (!(L > 1)) return 0;
+  if (L <= 99) return MASTERY_HOURS * ((L - 1) / 98) ** RISE;
+  return MASTERY_HOURS + (PACE_AT_99 * Math.expm1((L - 99) * PAST)) / PAST;
+}
+
+export function levelFor(hours) {
+  const h = Number(hours);
+  if (!Number.isFinite(h) || h <= 0) return 1;
+  if (h < MASTERY_HOURS) return 1 + Math.floor(98 * (h / MASTERY_HOURS) ** (1 / RISE) + EPS);
+  return 99 + Math.floor(Math.log1p(((h - MASTERY_HOURS) * PAST) / PACE_AT_99) / PAST + EPS);
+}
+
+const pad = (n) => String(n).padStart(2, '0');
+export const localDate = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+const localMonth = (ms) => localDate(ms).slice(0, 7);
+
+function mondayOf(ms) {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - ((d.getDay() + 6) % 7));
+  return d.getTime();
+}
+
+function startOfDay(ms) {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+const counts = (r) => r && r.began !== false && Number.isFinite(r.at) && Number(r.seconds) > 0;
+
+// One line per key. The line written when the run ended beats one read back
+// from its log, which may have been read while the run was still going.
+export function dedupeRuns(runs) {
+  const seen = new Map();
+  for (const r of runs ?? []) {
+    if (!r || typeof r !== 'object' || typeof r.key !== 'string' || !r.key) continue;
+    if (!Number.isFinite(r.at) || !(Number(r.seconds) > 0)) continue;
+    const had = seen.get(r.key);
+    if (!had || (had.backfilled && !r.backfilled)) seen.set(r.key, r);
+  }
+  return [...seen.values()];
+}
+
+// Days in a row with a run, counted back from today, or from yesterday when
+// today has none yet. `dates` are local YYYY-MM-DD strings, from any number of
+// Macs.
+export function streakOf(dates, now = Date.now()) {
+  const have = new Set(dates);
+  let cursor = startOfDay(now);
+  if (!have.has(localDate(cursor))) cursor -= DAY_MS / 2;
+  let n = 0;
+  while (have.has(localDate(cursor))) {
+    n += 1;
+    // Half a day back and then to the start of that day survives a DST change.
+    cursor = startOfDay(startOfDay(cursor) - DAY_MS / 2);
+  }
+  return n;
+}
+
+export function summarizeRuns(runs, { now = Date.now() } = {}) {
+  const weekStartMs = mondayOf(now);
+  const dayStartMs = startOfDay(now);
+  let total = 0;
+  let week = 0;
+  let today = 0;
+  const active = new Set();
+  const months = new Map();
+  const first = new Date(now);
+  first.setDate(1);
+  for (let i = 11; i >= 0; i -= 1) {
+    const d = new Date(first.getFullYear(), first.getMonth() - i, 1);
+    months.set(`${d.getFullYear()}-${pad(d.getMonth() + 1)}`, 0);
+  }
+  for (const r of dedupeRuns(runs)) {
+    if (!counts(r) || r.at > now) continue;
+    const h = Math.min(Number(r.seconds), MAX_RUN_SECONDS) / 3600;
+    total += h;
+    if (r.at >= weekStartMs) week += h;
+    if (r.at >= dayStartMs) today += h;
+    active.add(localDate(r.at));
+    const m = localMonth(r.at);
+    if (months.has(m)) months.set(m, months.get(m) + h);
+  }
+  const activeDays = [...active].sort().slice(-60);
+  return {
+    total,
+    week,
+    weekStart: localDate(weekStartMs),
+    today,
+    day: localDate(dayStartMs),
+    streak: streakOf(activeDays, now),
+    activeDays,
+    byMonth: [...months].map(([month, hours]) => ({ month, hours })),
+    level: levelFor(total),
+  };
+}
+
+// One run read back from its trace log, `sessions/<item>/<startedAtMs>.log`:
+// the start is the file's name, the end the `# exited (code) <ISO>` footer,
+// else the file's last write.
+export function runFromTrace({ name, text = '', mtimeMs, item, product }) {
+  const m = /^(\d{12,14})\.log$/.exec(String(name ?? ''));
+  if (!m) return null;
+  const start = Number(m[1]);
+  const footer = /# exited \((-?\d+|null)\) (\S+)(?: · [^\n]*)?\s*$/m.exec(String(text));
+  const end = footer ? Date.parse(footer[2]) : Number(mtimeMs);
+  if (!Number.isFinite(end) || end <= start) return null;
+  const seconds = Math.round((end - start) / 1000);
+  if (seconds > MAX_RUN_SECONDS) return null;
+  return { key: `${item}:${start}`, at: end, start, item, product, engine: null, seconds, failed: footer ? footer[1] !== '0' : null };
+}

package/shared/agent-import.mjs

@@ -18,7 +18,7 @@
 /**
  * The label every one of these rows carries, so a second walk through the
  *  first run can tell which agents already have a row and file nothing twice. */
-import { NAME, Name } from '../shared/product-name.mjs';
+import { NAME } from '../shared/product-name.mjs';
 export const IMPORT_LABEL = 'agent-import';
 
 /**
@@ -107,11 +107,11 @@ export function agentsNeedingRows(chosen, existingItems = []) {
 }
 
 /* --------------------------- AND THE THREADS ----------------------------- */
-// Of the three things a picked thread could do, this is the plainest one. It
-// does NOT resume the conversation, and that is the half these words have to
-// carry, because a row named after an earlier conversation is a row anybody
-// would assume was carrying it on. So the body says, in plain words, that this
-// starts fresh.
+// A picked thread becomes a row that carries the conversation on. It first
+// did not: the body said the reply started fresh, and somebody importing a
+// hundred half-finished sessions was asked to restate every one of them
+// (GitHub #44). The row is still only a row here; the resume happens on the
+// first reply, in `Supervisor#importedThreadFor`.
 //
 // Everything else is the agent import's shape, for the same reasons: one row per
 // thing the user ticked, a label so a second press files nothing twice, and a
@@ -125,6 +125,53 @@ export const THREAD_LABEL = 'thread-import';
  *  which is stable across renames and is what the transcript is filed under. */
 export const threadLabel = (id) => `thread:${String(id ?? '').trim()}`;
 
+/**
+ * WHETHER A CHAT ENDED WAITING ON YOU, read off the agent's last reply.
+ *
+ *  Waiting means the reply's last line is a question, or a question followed by
+ *  the choices it offers. `ask` is that question, cut from the front when it is
+ *  long, because the question is at the end of the line. */
+const ASK_CHARS = 140;
+const SHORT_ASK = 40;
+const CHOICE = /^(\d+[.)]|[-*+]|[a-z][.)])\s+/i;
+const NOT_WAITING = Object.freeze({ waiting: false, ask: '' });
+
+function plainLine(line) {
+  return String(line)
+    .replace(/^(>\s*)+/, '')
+    .replace(/^#{1,6}\s+/, '')
+    .replace(/[*`]+/g, '')
+    // An underscore between two letters is part of a name (account_id).
+    .replace(/(?<![A-Za-z0-9])_+|_+(?![A-Za-z0-9])/g, '')
+    .replace(/^[("'“‘\s]+/, '')
+    .replace(/[)"'”’\s]+$/, '')
+    .trim();
+}
+
+function shortAsk(line) {
+  if (line.length <= ASK_CHARS) return line;
+  const sentences = line.split(/(?<=[.!?])\s+/);
+  let last = sentences.pop();
+  // "Shall I do that?" says nothing without the sentence it follows.
+  while (last.length < SHORT_ASK && sentences.length && sentences.at(-1).length + 1 + last.length <= ASK_CHARS) {
+    last = `${sentences.pop()} ${last}`;
+  }
+  if (last.length <= ASK_CHARS) return last;
+  const tail = line.slice(-(ASK_CHARS - 1));
+  const sp = tail.indexOf(' ');
+  return `…${sp > 0 && sp < 40 ? tail.slice(sp + 1) : tail}`;
+}
+
+export function howTheChatEnded(said) {
+  const lines = String(said ?? '').replace(/\r/g, '').split('\n').map((l) => l.trim()).filter(Boolean);
+  let i = lines.length - 1;
+  while (i >= 0 && CHOICE.test(lines[i])) i -= 1;
+  if (i < 0) return { ...NOT_WAITING };
+  const line = plainLine(lines[i].replace(CHOICE, ''));
+  if (!line.endsWith('?')) return { ...NOT_WAITING };
+  return { waiting: true, ask: shortAsk(line) };
+}
+
 /**
  * WHEN SHE HAD IT, in the words a person uses about this week.
  *
@@ -148,41 +195,22 @@ export function whenWords(when, now = Date.now()) {
 /** Where she was when she started it, in the two places she named. */
 export function startedIn(source) {
   if (source === 'codex') return 'in Codex';
+  // VS Code, Cursor or Windsurf: the extension says which family, not which one.
+  if (source === 'editor') return 'in your code editor';
   return source === 'desktop' ? 'in the Claude Code desktop app' : 'in a terminal';
 }
 
 /**
- * ONE IMPORTED THREAD'S WORDS.
- *
- *  The title is the thread's own, which is the first thing the user typed into
- *  it, so the row in the inbox is called what they would call it. Ours is not
- *  added in front of it: a list of rows all opening with the same three words is
- *  a list that has to be read past to find which is which.
- *
- *  The last paragraph is the honest one. Agentbox read the top of the transcript
- *  to find this name and nothing else, and the reply starts a fresh session. A
- *  row that let her believe otherwise would be the same empty promise the agent
- *  import had before 08-23, in a new place. */
-export function threadImportRow(thread, { projectName = null, now = Date.now() } = {}) {
+ * ONE IMPORTED THREAD'S WORDS, the chat as it was: the title Claude Code gave
+ *  it, your first message as the body and the agent's last reply as the
+ *  result, so the thread opens on the question it ended with. The reply
+ *  carries the conversation on (`Supervisor#importedThreadFor`). */
+export function threadImportRow(thread) {
   const title = String(thread?.title || '').trim();
-  const where = String(thread?.short || thread?.folder || '').trim();
-  const when = whenWords(thread?.when, now);
-  const started = [
-    'You started this',
-    startedIn(thread?.source),
-    when,
-    where ? `in ${where}` : '',
-  ].filter(Boolean).join(' ');
-  const inProject = projectName ? ` here in ${projectName}` : '';
-  const body = [
-    '**Say what you want done next in this thread.**',
-    `${started}.`,
-    `Reply with the job and ${NAME} runs it${inProject}, answering you here.`,
-    `${Name} has not read the conversation, only the line above that names it, and replying starts a fresh session rather than carrying the old one on. So say what you need in the reply.`,
-  ].join('\n\n');
   return {
     title,
-    body,
+    body: String(thread?.firstSaid || '').trim() || title,
+    result: String(thread?.lastSaid || '').trim(),
     kind: 'question',
     priority: 3,
     labels: [THREAD_LABEL, threadLabel(thread?.id)],

package/shared/agents.d.mts

@@ -110,6 +110,7 @@ export interface AgentTurnLike {
 // ONE THING THE AGENT RAN, between two messages. Shape B.
 export interface AgentWorkLike {
   kind: 'work';
+  standalone?: true;
   at: number;
   verb: string;
   subject: string;