agentbox-app 0.1.6

package/scripts/after-install.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// THE ONE THING AN NPM INSTALL GETS WRONG, AND IT IS A PERMISSION BIT.
+//
+// node-pty is how this app opens a terminal. On a Mac it does not spawn the
+// shell itself: it runs a tiny bundled executable called `spawn-helper` that
+// sets the terminal up and then becomes the shell. The prebuilt binaries ship
+// inside the npm tarball, and a tarball does not reliably carry the executable
+// bit through `npm install`.
+//
+// So the file arrives as `-rw-r--r--`, node-pty loads perfectly, and the first
+// terminal anybody opens fails with `posix_spawnp failed`. Nothing else in the
+// app is affected, which is what makes it hard to find: the inbox works, the
+// agents run, and one button is broken.
+//
+// Measured on 2026-09-25 by installing the packed tarball into an empty folder:
+// both prebuilds came out 644, against 755 in the working checkout.
+//
+// THIS MUST NEVER FAIL AN INSTALL. A missing node-pty, a read-only folder or a
+// platform with no prebuilds are all ordinary, and none of them is a reason to
+// make `npm install` exit non-zero. It says what it did and leaves quietly.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+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.
+  const entry = require.resolve('node-pty');
+  let at = path.dirname(entry);
+  for (let up = 0; up < 6; up += 1) {
+    const here = path.join(at, 'prebuilds');
+    if (fs.existsSync(here)) return here;
+    const next = path.dirname(at);
+    if (next === at) break;
+    at = next;
+  }
+  return null;
+}
+
+try {
+  const dir = prebuildsDir();
+  if (!dir) process.exit(0);
+  let fixed = 0;
+  for (const platform of fs.readdirSync(dir)) {
+    const helper = path.join(dir, platform, 'spawn-helper');
+    if (!fs.existsSync(helper)) continue;
+    // Only touch it when it is actually wrong, so a correct install prints
+    // nothing and a re-install is not noise.
+    if (fs.statSync(helper).mode & 0o111) continue;
+    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.`);
+} catch {
+  // Nothing here is worth stopping an install for.
+}

package/scripts/approval-server.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Launcher for the approvals MCP server.
+#
+# TWO WORLDS, AND THE PACKAGED ONE WAS BROKEN UNTIL 2026-08-21. Inside a bundle
+# this file is the copy electron-builder's `asarUnpack` leaves in
+# `app.asar.unpacked/scripts`, because macOS cannot exec a path inside the
+# archive. The old line then walked one directory up and asked for
+# `app.asar.unpacked/main/approval-prompt-server.mjs`, which has never existed:
+# only `scripts/` and `worker-permissions.json` are unpacked, never `main/`.
+# node threw MODULE_NOT_FOUND, the MCP server never came up, and the Claude CLI
+# refuses to start a session at all when the tool named by
+# --permission-prompt-tool is missing. Every agent in every packaged Agentbox died
+# in about four seconds. Measured on the walk she was testing, 08-21.
+#
+# Agentbox's own binary IS Electron, and Electron reads straight out of app.asar,
+# so the packaged branch runs the server with that instead of node. It needs no
+# node on the machine, which also fixes the second half of the old line: the
+# nvm path below only exists on a Mac that installed node that way.
+#
+# AND IT NO LONGER SPELLS THE APP'S NAME. This line said `MacOS/Astral`, and
+# electron-builder names the bundle's executable after `productName`, so the
+# path stopped resolving the moment the app was renamed. A shell script cannot
+# import shared/product-name.mjs, so it asks the bundle it is standing inside:
+# CFBundleExecutable is exactly that name, whatever it is today. The fallback is
+# the one file in MacOS/, because a bundle has exactly one and a Mac without
+# PlistBuddy should still start her agents.
+here="$(cd "$(dirname "$0")" && pwd)"
+case "$here" in
+  *app.asar.unpacked/scripts)
+    res="$(cd "$here/../.." && pwd)"
+    app="$(cd "$res/.." && pwd)"
+    exe="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$app/Info.plist" 2>/dev/null)"
+    [ -x "$app/MacOS/$exe" ] || exe="$(ls "$app/MacOS" 2>/dev/null | head -1)"
+    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"
+    ;;
+esac

package/scripts/before-publish.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// WHAT `npm publish` IS ABOUT TO SEND, CHECKED AGAINST WHAT IS ON MAIN.
+//
+// A published version can never be replaced, only superseded, so the wrong one
+// going out costs a version number and a correction rather than an undo.
+//
+// THE MISTAKE THIS EXISTS TO CATCH IS NOT HYPOTHETICAL. There is more than one
+// checkout of this repo on the machine it is developed on: the one work happens
+// in, and ~/Astral, which is where the running app lives and sits on whatever
+// branch it was last built from. Both have a package.json saying agentbox-app.
+// Signing in to npm is global, so `npm login` in one folder makes `npm publish`
+// work in the other, and on 2026-09-25 that is exactly where the terminal was:
+// ~/Astral, eight commits behind main, carrying a description that had been
+// replaced. Nothing about that command would have looked wrong.
+//
+// So this refuses unless three things are true, and says which one is not.
+//  1. Nothing uncommitted that would actually be packed. Scratch files that
+//     the `files` list does not reach are somebody else's business.
+//  2. HEAD is on origin/main, so what ships is what was reviewed.
+//  3. origin/main has been fetched recently enough to mean anything.
+//
+// Bypass, deliberately awkward, for a case nobody has met yet:
+// AGENTBOX_PUBLISH_ANYWAY=1 npm publish
+
+import { execFileSync } from 'node:child_process';
+
+const git = (...args) => execFileSync('git', args, { encoding: 'utf8' }).trim();
+
+function stop(what, fix) {
+  console.error(`\n  Not publishing.\n\n  ${what}\n  ${fix}\n`);
+  process.exit(1);
+}
+
+if (process.env.AGENTBOX_PUBLISH_ANYWAY === '1') {
+  console.log('agentbox: publishing without the checks, because AGENTBOX_PUBLISH_ANYWAY is set.');
+  process.exit(0);
+}
+
+let head, dirty;
+try {
+  head = git('rev-parse', 'HEAD');
+  dirty = git('status', '--porcelain');
+} catch {
+  stop('This folder is not a git checkout.', 'Publish from the repo.');
+}
+
+// WHICH UNCOMMITTED FILES ACTUALLY MATTER, rather than how many there are.
+//
+// The first version of this refused on any dirty tree at all, and that made it
+// useless in the checkout it most needs to work in: a repo several agents share
+// always has somebody's scratch file in it, and none of that scratch is in the
+// package. Refusing over it trains you to reach for the override, and an
+// override you always use is not a guard.
+//
+// So it asks npm what it would actually pack and refuses only where the two
+// lists meet. Exact, because it is npm's own resolution of `files` rather than
+// this script's guess at it. Ignored paths never appear: `git status` leaves
+// them out, which is why renderer/dist, packed on every publish and committed
+// on none, is correctly not a complaint.
+function wouldShip(changed) {
+  if (!changed.length) return [];
+  let packed;
+  try {
+    const raw = execFileSync('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 * 1024 * 1024,
+    });
+    packed = new Set(JSON.parse(raw.slice(raw.indexOf('['))) [0].files.map((f) => f.path));
+  } catch {
+    // 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.
+  //
+  // 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.
+  return changed.filter((f) => packed.has(f) && !/\.generated\./.test(f));
+}
+
+if (dirty) {
+  // --untracked-files=all, or a whole new directory arrives as one line and a
+  // file inside it is never compared against anything.
+  const changed = git('status', '--porcelain', '--untracked-files=all')
+    .split('\n')
+    .map((line) => line.slice(3).trim())
+    .filter(Boolean);
+  const bad = wouldShip(changed);
+  if (bad.length) {
+    stop(
+      `${bad.length} uncommitted file${bad.length === 1 ? '' : 's'} would go into the package:\n    ${bad.slice(0, 8).join('\n    ')}`,
+      'Commit them, or move them out, or the package holds something no commit does.',
+    );
+  }
+}
+
+try {
+  execFileSync('git', ['fetch', 'origin', '--quiet'], { stdio: 'ignore' });
+} catch {
+  // Offline is not a reason to refuse. The ancestor check below still runs
+  // against whatever origin/main was last known to be.
+}
+
+let onMain = false;
+try {
+  execFileSync('git', ['merge-base', '--is-ancestor', head, 'origin/main'], { stdio: 'ignore' });
+  onMain = true;
+} catch {}
+
+if (!onMain) {
+  const branch = (() => { try { return git('rev-parse', '--abbrev-ref', 'HEAD'); } catch { return '?'; } })();
+  stop(
+    `This checkout is on ${branch} at ${head.slice(0, 8)}, which is not on origin/main.`,
+    'Publish from a checkout whose commit has been merged and pushed.',
+  );
+}
+
+const behind = (() => {
+  try { return Number(git('rev-list', '--count', `${head}..origin/main`)); } catch { return 0; }
+})();
+if (behind > 0) {
+  stop(
+    `This checkout is ${behind} commit${behind === 1 ? '' : 's'} behind origin/main.`,
+    'Pull, then publish, or you will send an older build than the one on main.',
+  );
+}
+
+console.log(`agentbox: publishing ${head.slice(0, 8)}, which is the tip of origin/main.`);

package/shared/agent-import.d.mts

@@ -0,0 +1,13 @@
+// Types for shared/agent-import.mjs, which is plain ESM so that main (Node) and
+// the renderer (Vite) can share one copy of the words.
+//
+// Only the two the card itself calls are declared. The rest of that file writes
+// work items, which is main's half and never the renderer's, and declaring them
+// here would put a store write one import away from a component.
+
+/** "today", "yesterday", "on Monday", or nothing when the moment cannot be
+ *  placed inside the week the card covers. */
+export function whenWords(when: number | null | undefined, now?: number): string;
+
+/** "in a terminal" or "in the Claude Code desktop app". */
+export function startedIn(source: string | null | undefined): string;

package/shared/agent-import.mjs

@@ -0,0 +1,252 @@
+// WHAT AN IMPORTED AGENT LOOKS LIKE IN THE INBOX.
+//
+// So the import stops being a note to itself and becomes rows. One per agent
+// the person ticked, in the project the walk just made, each one that agent
+// asking to be put to work.
+//
+// WHY A ROW HAS TO ASK SOMETHING. An imported agent needs no carrying across:
+// Claude Code loads its own agent folders at the start of every session, which
+// was measured on 2026-08-23 and is why the old import had nothing to do. What
+// was actually missing is that Agentbox could not put one to work. A row that
+// only announced an agent would be the same empty promise in a louder place,
+// so the row asks for the agent's first job and the reply is what runs it.
+//
+// Pure on purpose: the files are read in main/agent-files.mjs and the rows are
+// written in main/store.mjs. Everything here is words, so the words are tested
+// rather than eyeballed on a card nobody can screenshot twice.
+
+/**
+ * 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';
+export const IMPORT_LABEL = 'agent-import';
+
+/**
+ * And the one that says WHICH agent, for the same reason. Names only, the way
+ *  `projectAgents` stores them: the file is the author's and never moves, so a
+ *  name that has gone stale costs nothing. */
+export const agentLabel = (name) => `agent:${String(name ?? '').trim()}`;
+
+/**
+ * `/Users/x/.claude/agents/a.md` as `~/.claude/agents/a.md`. A path with a
+ *  stranger's home folder in it is a path they read twice to find their own
+ *  name in it. */
+export function shortenHome(p, home) {
+  const full = String(p ?? '');
+  const h = String(home ?? '').replace(/\/+$/, '');
+  return h && full.startsWith(h + '/') ? `~${full.slice(h.length)}` : full;
+}
+
+/**
+ * ONE ROW'S WORDS.
+ *
+ *  The first line is the ask and nothing else, because the inbox row shows the
+ *  opening of the body and the reading pane leads with it. The agent's own
+ *  description follows when it has one; a file with nothing but a heading in it
+ *  gets no second paragraph rather than a blank one.
+ *
+ *  The last paragraph is the honest half. Agentbox does not copy an agent file,
+ *  does not move one, and did not make it work: it says where the file is and
+ *  which of Claude Code's two scopes it is in, in the same two words the finish
+ *  card uses.
+ */
+export function agentImportRow(agent, { projectName = null, home = '' } = {}) {
+  const title = String(agent?.title || agent?.name || '').trim();
+  const name = String(agent?.name || '').trim();
+  const line = String(agent?.line || '').trim();
+  const where = shortenHome(agent?.path, home);
+  const inProject = projectName ? ` here in ${projectName}` : '';
+  const scopeLine = agent?.scope === 'project'
+    ? 'It works in this project only.'
+    : 'It works in every project on this Mac.';
+  const body = [
+    `**Tell ${title} what to do first, in one sentence.**`,
+    ...(line ? [line] : []),
+    `Reply with the job and ${NAME} runs it${inProject}, putting your ${name} agent on the work and answering you here.`,
+    `${scopeLine} The file stays exactly where you wrote it, at ${where}, and ${NAME} never moves or copies one.`,
+  ].join('\n\n');
+  return {
+    title: `${title} is ready. Give it its first job.`,
+    body,
+    kind: 'question',
+    priority: 3,
+    labels: [IMPORT_LABEL, agentLabel(name)],
+  };
+}
+
+/**
+ * WHICH OF THE TICKED AGENTS STILL NEED A ROW.
+ *
+ *  Walking the first run again is a thing the app offers from ⌘K, and it opens
+ *  on what was taken last time with everything still ticked. Without this, the
+ *  second walk files a second copy of every row, which is the one failure an
+ *  inbox cannot absorb.
+ *
+ *  Matched on the agent's own name rather than on the row's title, so renaming
+ *  an agent's front matter files a new row and rewording ours does not.
+ *
+ *  ONE ROW PER NAME, EVEN WHEN TWO FILES CLAIM IT. Claude Code lets a project
+ *  folder shadow a home folder agent of the same name, and the project's copy
+ *  is the one that runs, so that is the one the row describes.
+ */
+export function agentsNeedingRows(chosen, existingItems = []) {
+  const already = new Set();
+  for (const item of existingItems) {
+    for (const label of item?.labels ?? []) {
+      if (typeof label === 'string' && label.startsWith('agent:')) already.add(label.slice(6));
+    }
+  }
+  const byName = new Map();
+  for (const a of chosen ?? []) {
+    const name = String(a?.name ?? '').trim();
+    if (!name || already.has(name)) continue;
+    const seen = byName.get(name);
+    if (!seen || (a.scope === 'project' && seen.scope !== 'project')) byName.set(name, a);
+  }
+  return [...byName.values()];
+}
+
+/* ------------------------- AND THE THREADS SHE MEANT ----------------------- */
+// She was offered three things a picked thread could do and she picked the
+// plainest one. It does NOT resume the conversation, and that is the half these
+// words have to carry, because a row named after a conversation she had on
+// Friday is a row anybody would assume was carrying it on. So the body says, in
+// her vocabulary, that this starts fresh.
+//
+// Everything else is the agent import's shape, for the same reasons: one row per
+// thing she ticked, a label so a second press files nothing twice, and a
+// question so the supervisor waits for her rather than starting on its own.
+
+/** The label every imported thread carries. */
+export const THREAD_LABEL = 'thread-import';
+
+/**
+ * And the one that says WHICH thread. The id is Claude Code's own session id,
+ *  which is stable across renames and is what the transcript is filed under. */
+export const threadLabel = (id) => `thread:${String(id ?? '').trim()}`;
+
+/**
+ * WHEN SHE HAD IT, in the words a person uses about this week.
+ *
+ *  The window is seven days (`RECENT_DAYS`, main/agent-sessions.mjs), so a day
+ *  name covers all of it and a date never has to appear. Anything the arithmetic
+ *  cannot place says nothing rather than guessing. */
+export function whenWords(when, now = Date.now()) {
+  const then = new Date(Number(when) || 0);
+  if (!Number.isFinite(then.getTime()) || !when) return '';
+  const midnight = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+  const days = Math.round((midnight(new Date(now)) - midnight(then)) / 86400000);
+  if (days <= 0) return 'today';
+  if (days === 1) return 'yesterday';
+  if (days < 7) return `on ${then.toLocaleDateString('en-US', { weekday: 'long' })}`;
+  return '';
+}
+
+/** Where she was when she started it, in the two places she named. */
+export function startedIn(source) {
+  if (source === 'codex') return 'in Codex';
+  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 she typed into it, so
+ *  the row in her inbox is called what she 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
+ *  she has to 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() } = {}) {
+  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,
+    kind: 'question',
+    priority: 3,
+    labels: [THREAD_LABEL, threadLabel(thread?.id)],
+  };
+}
+
+/**
+ * WHICH OF THE TICKED THREADS STILL NEED A ROW. The card opens on a Mac whose
+ *  threads it has offered before, so pressing twice is ordinary and a second row
+ *  for the same conversation is the one failure an inbox cannot absorb. */
+export function threadsNeedingRows(chosen, existingItems = []) {
+  const already = new Set();
+  for (const item of existingItems) {
+    for (const label of item?.labels ?? []) {
+      if (typeof label === 'string' && label.startsWith('thread:')) already.add(label.slice(7));
+    }
+  }
+  const byId = new Map();
+  for (const t of chosen ?? []) {
+    const id = String(t?.id ?? '').trim();
+    if (!id || already.has(id) || byId.has(id)) continue;
+    if (!String(t?.title ?? '').trim()) continue;
+    byId.set(id, t);
+  }
+  return [...byId.values()];
+}
+
+/**
+ * WHICH AGENT A ROW IS ABOUT, or null for every other row in the inbox.
+ *
+ *  The worker's brief reads this. Without it the row's body is the only thing
+ *  saying whose job this is, and a body is prose: it tells a session that an
+ *  agent exists, not that it is the one meant to do the work. The whole of the
+ *  fix is that the reply reaches the agent, so the instruction is explicit
+ *  (`importedAgentBrief`) rather than inferred from a sentence on a card. */
+export function importedAgentName(item) {
+  for (const label of item?.labels ?? []) {
+    if (typeof label === 'string' && label.startsWith('agent:')) {
+      const name = label.slice(6).trim();
+      if (name) return name;
+    }
+  }
+  return null;
+}
+
+/**
+ * AND WHAT THE BRIEF SAYS ABOUT IT.
+ *
+ *  The last sentence is the honest one and it is not decoration. Claude Code
+ *  loads its own agent folders every session, so the subagent is normally right
+ *  there — but it is loaded from the person's own disk, under whichever profile
+ *  the worker is billing to, and Agentbox cannot promise that from here. A
+ *  session that quietly does the work itself would leave them believing their
+ *  agent ran when it did not, which is the same empty promise this row exists
+ *  to end. */
+export function importedAgentBrief(name) {
+  const n = String(name ?? '').trim();
+  if (!n) return '';
+  return [
+    '# This row belongs to one of their own Claude Code agents',
+    '',
+    `They imported \`${n}\` on their first run, and this row is that agent asking for its first job.`,
+    'Their answer above is the job.',
+    '',
+    `Do it by dispatching the \`${n}\` subagent and giving it that job, rather than doing the work yourself,`,
+    'then report on this row what it did. If that subagent is not available to you in this session, do not',
+    'quietly do the work as yourself: say so plainly in your result, because they are expecting their own',
+    'agent to have run.',
+  ].join('\n');
+}