agentbox-app 0.1.12 → 0.1.16

package/main/opencode.mjs

@@ -0,0 +1,287 @@
+// READING AN OPENCODE RUN, IN OPENCODE'S OWN WORDS.
+//
+// The same five readers Claude Code and Codex each provide -- capture, live
+// text, summary, trace, activity -- over OpenCode's `/event` stream. Nothing
+// here translates an OpenCode event into a pretend Claude JSON line or a
+// pretend Codex notification, for the reason docs/harnesses.md gives: the
+// vocabularies are not the same shape and a fake one loses what the real one
+// carries. OpenCode's `edit` approval, for instance, arrives with a whole
+// unified diff in it, which neither of the other two does.
+//
+// EVERY SHAPE BELOW WAS READ OFF A RUNNING OPENCODE 1.18.35 ON 2026-10-07,
+// not off the docs, which do not enumerate the event payloads at all. The
+// ones that matter:
+//
+//   session.updated          properties.info.{cost,tokens,title,model,directory}
+//   message.part.updated     properties.part.type: text | reasoning | tool |
+//                            step-start | step-finish
+//   message.part.delta       properties.{partID,field,delta}   ("field":"text")
+//   permission.asked         properties.{id,sessionID,permission,patterns,
+//                            metadata:{command} | metadata:{filepath,diff}}
+//   session.idle             properties.sessionID
+//   session.error            properties.{sessionID,error}
+//
+// A tool part carries `state.status` of pending | running | completed | error,
+// with `state.input`, `state.output` and `state.error` beside it.
+
+/** How much streamed prose is kept before it is dropped, as the others do. */
+const SAYING_CAP = 20_000;
+
+/** Tool names worth naming on the row, in the words a person would use. */
+const TOOL_WORDS = {
+  bash: 'Bash', edit: 'Edit', write: 'Write', read: 'Read', glob: 'Glob',
+  grep: 'Grep', list: 'List', webfetch: 'Fetch', websearch: 'Search',
+  task: 'Task', todowrite: 'Todo', patch: 'Edit', skill: 'Skill',
+};
+
+const toolWord = name => {
+  const id = String(name ?? '').trim();
+  if (!id) return null;
+  return TOOL_WORDS[id.toLowerCase()] ?? id;
+};
+
+const partOf = properties => (properties && typeof properties === 'object' ? properties.part ?? null : null);
+
+/**
+ * WHAT THE RUN WAS, kept on the session as it goes.
+ *
+ * `sessionId` is the one OpenCode resumes by, and it is on nearly every event
+ * as `properties.sessionID`. It is taken from the first event that carries one
+ * rather than from the session-creation response, so a resumed run and a fresh
+ * one record it the same way.
+ *
+ * The result is the LAST assistant text of the turn. OpenCode has no single
+ * "here is the answer" event the way Codex's `turn/completed` does: prose
+ * arrives as `text` parts that are updated in place, and the final one is the
+ * answer. So each completed text part overwrites the last, and whatever is
+ * standing when the session goes idle is the result.
+ */
+export function captureOpenCodeEvent(session, type, properties) {
+  try {
+    if (!session || typeof type !== 'string') return;
+    const p = properties ?? {};
+    if (!session.sessionId && typeof p.sessionID === 'string' && p.sessionID) session.sessionId = p.sessionID;
+
+    if (type === 'session.updated') {
+      const info = p.info ?? {};
+      if (Number.isFinite(info.cost)) session.opencodeCost = info.cost;
+      if (info.tokens && typeof info.tokens === 'object') session.opencodeTokens = info.tokens;
+      return;
+    }
+
+    if (type === 'session.error') {
+      session.result = openCodeErrorText(p.error) ?? 'OpenCode stopped with an error it did not name.';
+      session.resultIsError = true;
+      return;
+    }
+
+    if (type === 'message.part.updated') {
+      const part = partOf(p);
+      if (!part) return;
+      // A WRITE THIS RUN MADE, so the card can say what changed. The `edit` and
+      // `write` tools report the file they touched in `state.input.filePath`,
+      // which is the only place a path appears for a change OpenCode has
+      // already applied.
+      if (part.type === 'tool' && part.state?.status === 'completed') {
+        const path = part.state?.input?.filePath ?? part.state?.input?.path;
+        if (typeof path === 'string' && path && (part.tool === 'edit' || part.tool === 'write' || part.tool === 'patch')) {
+          session.opencodeChange ??= [];
+          if (!session.opencodeChange.includes(path)) session.opencodeChange.push(path);
+        }
+      }
+      if (part.type === 'step-finish') {
+        if (Number.isFinite(part.cost)) session.opencodeStepCost = part.cost;
+        if (part.tokens && typeof part.tokens === 'object') session.opencodeTokens = part.tokens;
+      }
+      // Only the assistant's prose is an answer. `reasoning` is the model
+      // thinking out loud and is never the result, which is why it is matched
+      // by name here rather than falling through to the text branch.
+      if (part.type === 'text') {
+        const text = String(part.text ?? '').trim();
+        if (text) { session.result = text; session.resultIsError = false; }
+      }
+      return;
+    }
+  } catch {
+    // A reader that throws kills a run that was going fine. Same rule as the
+    // other two harnesses: read what parses and ignore what does not.
+  }
+}
+
+/** The error on `session.error`, which is an object and not a string. */
+export function openCodeErrorText(error) {
+  if (!error) return null;
+  if (typeof error === 'string') return error.trim() || null;
+  const name = typeof error.name === 'string' ? error.name : '';
+  const message = typeof error.data?.message === 'string' ? error.data.message
+    : typeof error.message === 'string' ? error.message : '';
+  const joined = [name, message].filter(Boolean).join(': ');
+  return joined || null;
+}
+
+/**
+ * THE PROSE AS IT IS TYPED, for the line on the row that moves.
+ *
+ * Deltas arrive as `message.part.delta` with a `field` saying which field of
+ * which part is growing. Only `text` is shown: `reasoning` deltas are the
+ * model's private thinking, and streaming those onto her row would put words
+ * on screen that are not what the run decided.
+ */
+export function openCodeStreamingText(session, type, properties) {
+  try {
+    if (!session) return false;
+    const p = properties ?? {};
+
+    if (type === 'message.part.updated') {
+      const part = partOf(p);
+      // A tool starting means the talking stopped. What is already typed stays
+      // until the trace carries the same words, exactly as Codex's reader does.
+      if (part?.type === 'text' && !String(part.text ?? '')) { session.saying = ''; session.sayingAt = Date.now(); return true; }
+      return false;
+    }
+
+    if (type !== 'message.part.delta') return false;
+    if (p.field !== 'text') return false;
+    const piece = String(p.delta ?? '');
+    if (!piece) return false;
+    // A delta for a reasoning part has the same `field: "text"`, so the part it
+    // belongs to is what tells them apart. Without a remembered prose part id
+    // nothing is streamed, which is the quiet answer rather than the wrong one.
+    if (session.opencodeProsePart && p.partID && p.partID !== session.opencodeProsePart) return false;
+    if (!session.sayingAt) session.sayingAt = Date.now();
+    const next = (session.saying ?? '') + piece;
+    session.saying = next.length > SAYING_CAP ? '' : next;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Which part the prose is going into, so reasoning deltas can be told apart. */
+export function rememberOpenCodeProsePart(session, type, properties) {
+  if (!session || type !== 'message.part.updated') return;
+  const part = partOf(properties);
+  if (part?.type === 'text' && typeof part.id === 'string') session.opencodeProsePart = part.id;
+  if (part?.type === 'step-start') session.opencodeProsePart = null;
+}
+
+/** One short line for the row: what it just did. */
+export function summarizeOpenCodeEvent(type, properties) {
+  try {
+    const p = properties ?? {};
+    if (type !== 'message.part.updated') return null;
+    const part = partOf(p);
+    if (!part) return null;
+    if (part.type === 'text') {
+      const text = String(part.text ?? '').trim();
+      return text ? text.slice(0, 300) : null;
+    }
+    if (part.type === 'tool' && part.state?.status === 'completed') {
+      const word = toolWord(part.tool);
+      return word ? `tool: ${word}` : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** One line for the run trace, the record she can open afterwards. */
+export function traceOpenCodeEvent(type, properties) {
+  try {
+    const p = properties ?? {};
+    const at = new Date().toISOString().slice(11, 19);
+
+    if (type === 'session.error') {
+      const text = openCodeErrorText(p.error);
+      return text ? `${at}  [error] ${text.slice(0, 300)}` : null;
+    }
+
+    if (type !== 'message.part.updated') return null;
+    const part = partOf(p);
+    if (!part) return null;
+
+    if (part.type === 'text') {
+      const text = String(part.text ?? '').trim();
+      return text ? `${at}  ${text}` : null;
+    }
+
+    if (part.type === 'tool' && (part.state?.status === 'completed' || part.state?.status === 'error')) {
+      const word = toolWord(part.tool);
+      if (!word) return null;
+      const input = part.state?.input ?? {};
+      const detail = String(input.command ?? input.filePath ?? input.path ?? input.pattern ?? '').trim();
+      const failed = part.state?.status === 'error' ? ' (refused)' : '';
+      return `${at}  [${word}]${failed}${detail ? ` ${detail.slice(0, 200)}` : ''}`;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** What it is doing right now, for the row's activity line. */
+export function openCodeActivity(type, properties) {
+  try {
+    if (type !== 'message.part.updated') return null;
+    const part = partOf(properties);
+    if (part?.type !== 'tool') return null;
+    if (part.state?.status !== 'pending' && part.state?.status !== 'running') return null;
+    const word = toolWord(part.tool);
+    return word ? { tool: word } : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * THE APPROVAL, IN THE WORDS A CARD NEEDS.
+ *
+ * `bash` asks carry `metadata.command`. `edit` asks carry `metadata.filepath`
+ * AND `metadata.diff`, a whole unified diff of the change it wants to make --
+ * measured, not assumed. That is strictly more than a Codex patch approval
+ * arrives with, and it means an OpenCode card can show the change itself
+ * rather than a filename.
+ */
+export function openCodeApprovalCard(properties) {
+  const p = properties ?? {};
+  const kind = typeof p.permission === 'string' ? p.permission : '';
+  const metadata = p.metadata ?? {};
+  const command = typeof metadata.command === 'string' ? metadata.command.trim() : '';
+  const filepath = typeof metadata.filepath === 'string' ? metadata.filepath.trim() : '';
+  const diff = typeof metadata.diff === 'string' ? metadata.diff : '';
+  const patterns = Array.isArray(p.patterns) ? p.patterns.filter(x => typeof x === 'string') : [];
+
+  if (command) return { kind: kind || 'bash', title: 'Run a command', detail: command, command, patterns };
+  if (filepath) return { kind: kind || 'edit', title: 'Change a file', detail: filepath, filepath, diff, patterns };
+  return { kind: kind || 'tool', title: 'Use a tool', detail: patterns.join(', ') || kind || 'a tool', patterns };
+}
+
+/**
+ * THE PERMISSION POLICY A WORKER RUNS UNDER, as OpenCode's own config.
+ *
+ * This is the whole reason Agentbox can draw a card for OpenCode at all.
+ * Measured 2026-10-07: with no permission config the server runs shell
+ * commands and writes files with no card; with this config it raises
+ * `permission.asked` and waits. The server reports back what it loaded at
+ * `GET /config`, which is how the adapter can tell the policy really took.
+ *
+ * `read`, `glob`, `grep` and `list` are deliberately left alone: a card for
+ * every file read is the 2026-08-05 card flood again, and reading inside the
+ * task's own folder is what the folder is for.
+ */
+export function openCodePermissionConfig() {
+  return {
+    $schema: 'https://opencode.ai/config.json',
+    permission: {
+      bash: 'ask',
+      edit: 'ask',
+      webfetch: 'ask',
+      websearch: 'ask',
+      external_directory: 'ask',
+      task: 'allow',
+      todowrite: 'allow',
+    },
+  };
+}

package/main/phone-alerts.mjs

@@ -0,0 +1,117 @@
+// ALERTS ON HER PHONE'S LOCK SCREEN, SENT BY THIS MAC.
+//
+// The arrivals are the desktop banner's (main/notify.mjs, from App.tsx's
+// inbox), and so are the rules (shared/notify-rules.mjs): nothing while she
+// has used this Mac in the last five minutes, once per stretch away, once
+// more for a permission card. They go out from the phone pass, after it has
+// published, so the thread an alert opens is already on the phone. The
+// server-side sender in docs/mobile/PLAN.md, which alerts with every Mac
+// shut, is a later phase.
+//
+// The words are the phone banner's (phoneBanner): the thread's title in bold,
+// asked for on 2026-10-13 and again on 2026-10-23, and nothing else of it.
+import { atTheComputer, shouldSpeak, phoneBanner } from '../shared/notify-rules.mjs';
+
+export const EXPO_PUSH = 'https://exp.host/--/api/v2/push/send';
+// Arrivals this close together are one alert.
+export const FOLD_MS = 3000;
+const DEADLINE_MS = 10_000;
+const ALERTED_KEPT_MS = 30 * 24 * 3600_000;
+
+// renderer/src/phone-rows.ts phoneSlug, which the phone opens a thread by.
+const phoneSlugOf = (device, project) => `${project}@${device}`;
+const stampOf = (item) => `${item.status ?? ''}:${item.wrote?.status?.ts ?? item.updatedAt ?? ''}`;
+
+/** One request for every phone; Expo answers a ticket for each, in order. */
+export async function sendToExpo(messages, { fetchImpl = fetch, url = EXPO_PUSH, deadlineMs = DEADLINE_MS } = {}) {
+  const res = await fetchImpl(url, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'application/json' }, body: JSON.stringify(messages), signal: AbortSignal.timeout(deadlineMs) });
+  const said = await res.json().catch(() => null);
+  if (!res.ok || !Array.isArray(said?.data)) throw new Error(`Expo answered ${res.status}${said?.errors?.[0]?.message ? `: ${said.errors[0].message}` : ''}`);
+  return said.data;
+}
+
+export function createPhoneAlerts({ backend, owner, device, state, save, now, log, idleMs, send = sendToExpo, still = () => {} }) {
+  state.alerted ??= {};
+  // In memory, as the desktop's banner keeps them: an arrival is news once.
+  const queued = new Map();
+  let firstAt = 0;
+  let needsYou = [];
+  let spoke = false;
+  let spokeAsk = false;
+  const said = new Set();
+  const once = (kind, line) => { if (!said.has(kind)) log(line); said.add(kind); };
+  const away = () => { try { return !atTheComputer({ idleMs: idleMs() }); } catch { return true; } };
+
+  function seen() {
+    queued.clear();
+    spoke = false;
+    spokeAsk = false;
+  }
+
+  /** What the desktop's notifier was told arrived, and the inbox it arrived in. */
+  function arrived(list, inbox = []) {
+    if (!Array.isArray(list) || !list.length) return;
+    if (!away()) return seen();
+    if (Array.isArray(inbox)) needsYou = inbox.filter((r) => r && typeof r.id === 'string' && typeof r.product === 'string');
+    for (const a of list) {
+      if (!a || typeof a.id !== 'string' || typeof a.product !== 'string') continue;
+      const ask = a.kind === 'approval';
+      const item = ask ? a.item : a.id;
+      if (typeof item !== 'string') continue;
+      if (!queued.size) firstAt = now();
+      queued.set(ask ? `ask:${a.id}` : `${a.product}:${a.id}`, { ask, product: a.product, item, title: a.title, thread: a.thread });
+    }
+  }
+
+  // `carried(slug, id)` is the thread's row when the phone has it, else null.
+  async function pass(carried) {
+    if (!away()) return seen();
+    if (!queued.size || now() - firstAt < FOLD_MS) return;
+    const fresh = [];
+    for (const [key, q] of queued) {
+      const row = carried(q.product, q.item);
+      if (!row) continue;
+      const stamp = q.ask ? 'asked' : stampOf(row);
+      if (state.alerted[key]?.stamp !== stamp) fresh.push({ key, stamp, ...q, named: row.title });
+    }
+    queued.clear();
+    if (!fresh.length || !shouldSpeak({ spoke, spokeAsk, waiting: fresh.map((f) => ({ kind: f.ask ? 'approval' : 'item' })) })) return;
+    still();
+    let phones;
+    try { phones = await backend.pushDevices(owner); } catch (err) { once('read', `phone: could not read the phones to alert: ${err?.message ?? err}`); return; }
+    if (!phones.length) return;
+    const threads = [...new Set(fresh.map((f) => `${f.product}\0${f.item}`))];
+    const [product, item] = threads[0].split('\0');
+    const badge = new Set(needsYou.filter((r) => carried(r.product, r.id)).map((r) => `${r.product}\0${r.id}`)).size;
+    const data = threads.length === 1 ? { product: phoneSlugOf(device, product), id: item } : {};
+    const say = phoneBanner(fresh.map((f) => (f.ask
+      ? { kind: 'approval', title: f.title, thread: f.thread || f.named }
+      : { kind: 'item', title: f.title || f.named })));
+    const messages = phones.map((p) => ({ to: p.token, title: say.title, body: say.body, sound: 'default', badge, priority: 'high', channelId: 'default', data }));
+    still();
+    let tickets;
+    try { tickets = await send(messages); } catch (err) { once('send', `phone: could not send an alert: ${err?.message ?? err}`); return; }
+    let reached = 0;
+    for (const [i, t] of (tickets ?? []).entries()) {
+      if (t?.status === 'ok') { reached += 1; continue; }
+      const why = t?.details?.error ?? t?.message ?? 'no answer';
+      if (why === 'DeviceNotRegistered') {
+        try { await backend.dropPushDevice(messages[i].to, owner); } catch (err) { once('drop', `phone: could not forget a phone that stopped taking alerts: ${err?.message ?? err}`); }
+      } else once(`ticket:${why}`, `phone: Expo did not take an alert: ${why}`);
+    }
+    if (!reached) return;
+    said.clear();
+    spoke = true;
+    if (fresh.some((f) => f.ask)) spokeAsk = true;
+    for (const f of fresh) state.alerted[f.key] = { stamp: f.stamp, at: now() };
+    for (const [k, v] of Object.entries(state.alerted)) if (!(now() - (v?.at ?? 0) < ALERTED_KEPT_MS)) delete state.alerted[k];
+    save();
+  }
+
+  return {
+    arrived,
+    pass,
+    /** She answered from her phone, so she has seen what it holds. */
+    phoneUsed: () => { spoke = false; spokeAsk = false; },
+  };
+}