workoffdesk 1.0.1 → 1.0.2

package/dist/server/agents/codex/events.js

@@ -0,0 +1,107 @@
+// What Codex writes down of a conversation, as events, decided here and nowhere else: its app server's items
+// and turns (the protocol is marked experimental, every field may be missing) and the lines of its rollout
+// files. Each source has its own translator: the app server's items are camelCase, the rollout's PascalCase.
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : undefined);
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const arr = (v) => (Array.isArray(v) ? v : []);
+const other = () => ({ k: 'codex:other' });
+// The command of a command execution or of an approval to run one: as Codex parsed it rather than the shell
+// line that wraps it (`/bin/zsh -c '…'`).
+export const commandOf = (o) => str(obj(arr(o.commandActions)[0])?.command) || str(o.command);
+const textParts = (content) => arr(content)
+    .map((c) => (obj(c)?.type === 'text' ? str(obj(c)?.text) : ''))
+    .filter(Boolean)
+    .join('\n');
+function itemKind(i, id) {
+    switch (i.type) {
+        case 'userMessage':
+            return { k: 'codex:userMessage', id, text: textParts(i.content), clientId: str(i.clientId) };
+        case 'agentMessage':
+            return { k: 'codex:agentMessage', id, text: str(i.text) };
+        case 'plan':
+            return { k: 'codex:plan', id, text: str(i.text) };
+        case 'commandExecution': {
+            const exitCode = num(i.exitCode);
+            return { k: 'codex:commandExecution', id, command: commandOf(i), output: str(i.aggregatedOutput), status: str(i.status), ...(exitCode !== undefined && { exitCode }) };
+        }
+        case 'fileChange':
+            return {
+                k: 'codex:fileChange',
+                id,
+                status: str(i.status),
+                changes: arr(i.changes).map((c) => ({ path: str(obj(c)?.path), kind: str(obj(obj(c)?.kind)?.type), diff: str(obj(c)?.diff) })),
+            };
+        case 'mcpToolCall':
+        case 'dynamicToolCall': {
+            const error = str(obj(i.error)?.message);
+            const given = arr(obj(i.result)?.content ?? i.contentItems).map((c) => str(obj(c)?.text)).filter(Boolean).join('\n');
+            return {
+                k: 'codex:toolCall',
+                id,
+                name: [str(i.server) || str(i.namespace), str(i.tool)].filter(Boolean).join('.'),
+                args: obj(i.arguments) ?? {},
+                text: error || given,
+                failed: !!error || str(i.status) === 'failed' || i.success === false,
+            };
+        }
+        case 'webSearch':
+            return { k: 'codex:webSearch', id, query: str(i.query) };
+        case 'imageView':
+            return { k: 'codex:imageView', id, path: str(i.path) };
+        case 'contextCompaction':
+            return { k: 'codex:compaction', id };
+        default:
+            return other();
+    }
+}
+// An item of a thread, as the app server gives it; at: when it started or completed, as the caller knows.
+export function itemEventOf(item, at) {
+    const i = obj(item);
+    const id = str(i?.id);
+    if (!i || !id)
+        return other();
+    const event = itemKind(i, id);
+    return at && event.k !== 'codex:other' ? { ...event, at } : event;
+}
+// A turn as the app server gives it: an event once it has ended.
+export function turnEventOf(turn) {
+    const t = obj(turn);
+    const id = str(t?.id);
+    if (!t || !id)
+        return other();
+    const ended = (how) => ({ k: 'codex:turnEnded', id, how, error: str(obj(t.error)?.message) });
+    switch (t.status) {
+        case 'completed':
+        case 'interrupted':
+        case 'failed':
+            return ended(t.status);
+        default:
+            return other();
+    }
+}
+// A line of a rollout file, once parsed.
+export function rolloutEventOf(line) {
+    const e = obj(line);
+    const p = obj(e?.payload);
+    if (!e || e.type !== 'event_msg' || !p)
+        return other();
+    const at = typeof e.timestamp === 'string' ? { at: e.timestamp } : {};
+    switch (p.type) {
+        case 'task_started':
+            return { k: 'codex:rolloutTurnStarted', ...at };
+        case 'task_complete':
+            return { k: 'codex:rolloutTurnEnded', how: 'completed', ...at };
+        case 'turn_aborted':
+            return { k: 'codex:rolloutTurnEnded', how: 'aborted', ...at };
+        case 'item_completed': {
+            const item = obj(p.item);
+            return item?.type === 'UserMessage' ? { k: 'codex:rolloutPrompt', text: textParts(item.content), ...at } : other();
+        }
+        // How Codex before September wrote it.
+        case 'user_message':
+            return { k: 'codex:rolloutPrompt', text: str(p.message), ...at };
+        default:
+            return other();
+    }
+}

package/dist/server/agents/codex/items.js

@@ -1,23 +1,19 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { unhandled } from '../events.js';
+import { commandOf, itemEventOf, turnEventOf } from './events.js';
 const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : undefined);
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
 const arr = (v) => (Array.isArray(v) ? v : []);
 const SUMMARY_MAX = 200;
 const RESULT_MAX = 2000;
+const INPUT_MAX = 4000;
 const DIFF_LINES_MAX = 300;
 const DIFF_LINE_MAX = 400;
 const DETAIL_MAX = 4000;
 const clip = (s, max) => (s.length > max ? `${s.slice(0, max)}…` : s);
 const line1 = (s) => clip(s.split('\n')[0], SUMMARY_MAX);
-// What the user typed, as the chat shows it; a picture sent along is named by its path in the text already.
-const userText = (content) => arr(content)
-    .map((c) => (obj(c)?.type === 'text' ? str(obj(c)?.text) : ''))
-    .filter(Boolean)
-    .join('\n');
-// The command as Codex parsed it rather than the shell line that wraps it (`/bin/zsh -c '…'`).
-const commandOf = (i) => str(obj(arr(i.commandActions)[0])?.command) || str(i.command);
 function unifiedDiff(file, kind, text) {
     const lines = text.replace(/\n$/, '').split('\n');
     const hunks = [];
@@ -61,80 +57,64 @@ function unifiedDiff(file, kind, text) {
 const failedOrStopped = (status) => ({ error: status === 'failed', ...(status === 'declined' && { stopped: true }) });
 // What one completed item adds to the chat; nothing for what the chat does not show (reasoning).
 export function entriesOf(item, at) {
-    const i = obj(item);
-    const id = str(i?.id);
-    if (!i || !id)
-        return [];
-    const stamp = at ? { at } : {};
-    switch (i.type) {
-        case 'userMessage': {
-            const text = userText(i.content);
-            const clientId = str(i.clientId);
-            return text ? [{ id, item: { k: 'user', text, ...stamp }, ...(clientId && { clientId }) }] : [];
-        }
-        case 'agentMessage':
-            return str(i.text) ? [{ id, item: { k: 'text', text: str(i.text), ...stamp } }] : [];
-        case 'plan':
-            return str(i.text) ? [{ id, item: { k: 'text', text: str(i.text), ...stamp } }] : [];
-        case 'commandExecution': {
-            const status = str(i.status);
-            const exit = num(i.exitCode);
+    return entriesOfEvent(itemEventOf(item, at));
+}
+// A turn that did not end by itself, as the line the chat puts after it.
+export function turnNote(turn) {
+    return entriesOfEvent(turnEventOf(turn))[0] ?? null;
+}
+export function entriesOfEvent(e) {
+    const stamp = e.at ? { at: e.at } : {};
+    switch (e.k) {
+        case 'codex:userMessage':
+            return e.text ? [{ id: e.id, item: { k: 'user', text: e.text, ...stamp }, ...(e.clientId && { clientId: e.clientId }) }] : [];
+        case 'codex:agentMessage':
+        case 'codex:plan':
+            return e.text ? [{ id: e.id, item: { k: 'text', text: e.text, ...stamp } }] : [];
+        case 'codex:commandExecution': {
+            const { id, command } = e;
+            const summary = line1(command);
             return [
-                { id, item: { k: 'tool', id, name: 'Bash', summary: line1(commandOf(i)), ...stamp } },
-                { id: `${id}#r`, item: { k: 'result', id, text: clip(str(i.aggregatedOutput), RESULT_MAX), ...failedOrStopped(status), ...(exit !== undefined && exit !== 0 && { error: true }) } },
+                { id, item: { k: 'tool', id, name: 'Bash', summary, ...(summary !== command && { input: clip(command, INPUT_MAX) }), ...stamp } },
+                { id: `${id}#r`, item: { k: 'result', id, text: clip(e.output, RESULT_MAX), ...failedOrStopped(e.status), ...(e.exitCode !== undefined && e.exitCode !== 0 && { error: true }) } },
             ];
         }
-        case 'fileChange': {
-            const status = str(i.status);
-            return arr(i.changes).flatMap((c, n) => {
-                const change = obj(c);
-                const path = str(change?.path);
-                if (!path)
+        case 'codex:fileChange':
+            return e.changes.flatMap((c, n) => {
+                if (!c.path)
                     return [];
-                const kind = str(obj(change?.kind)?.type);
-                const cid = `${id}:${n}`;
+                const cid = `${e.id}:${n}`;
                 return [
-                    { id: cid, item: { k: 'tool', id: cid, name: kind === 'add' ? 'Write' : 'Edit', summary: line1(path), ...stamp } },
-                    { id: `${cid}#r`, item: { k: 'result', id: cid, text: '', ...failedOrStopped(status), diff: unifiedDiff(path, kind, str(change?.diff)) } },
+                    { id: cid, item: { k: 'tool', id: cid, name: c.kind === 'add' ? 'Write' : 'Edit', summary: line1(c.path), ...stamp } },
+                    { id: `${cid}#r`, item: { k: 'result', id: cid, text: '', ...failedOrStopped(e.status), diff: unifiedDiff(c.path, c.kind, c.diff) } },
                 ];
             });
-        }
-        case 'mcpToolCall':
-        case 'dynamicToolCall': {
-            const name = [str(i.server) || str(i.namespace), str(i.tool)].filter(Boolean).join('.');
-            const args = obj(i.arguments) ?? {};
-            const summary = line1(Object.values(args).map(str).find(Boolean) ?? '');
-            const error = str(obj(i.error)?.message);
-            const text = error || arr(obj(i.result)?.content ?? i.contentItems).map((c) => str(obj(c)?.text)).filter(Boolean).join('\n');
+        case 'codex:toolCall': {
+            const { id } = e;
+            const summary = line1(Object.values(e.args).map(str).find(Boolean) ?? '');
             return [
-                { id, item: { k: 'tool', id, name: name || 'tool', summary, ...stamp } },
-                { id: `${id}#r`, item: { k: 'result', id, text: clip(text, RESULT_MAX), error: !!error || str(i.status) === 'failed' || i.success === false } },
+                { id, item: { k: 'tool', id, name: e.name || 'tool', summary, ...stamp } },
+                { id: `${id}#r`, item: { k: 'result', id, text: clip(e.text, RESULT_MAX), error: e.failed } },
             ];
         }
-        case 'webSearch':
-            return [{ id, item: { k: 'tool', id, name: 'WebSearch', summary: line1(str(i.query)), ...stamp } }];
-        case 'imageView':
-            return [{ id, item: { k: 'tool', id, name: 'Read', summary: line1(str(i.path)), ...stamp } }];
-        case 'contextCompaction':
-            return [{ id, item: { k: 'note', event: { e: 'compacted' } } }];
-        default:
+        case 'codex:webSearch':
+            return [{ id: e.id, item: { k: 'tool', id: e.id, name: 'WebSearch', summary: line1(e.query), ...stamp } }];
+        case 'codex:imageView':
+            return [{ id: e.id, item: { k: 'tool', id: e.id, name: 'Read', summary: line1(e.path), ...stamp } }];
+        case 'codex:compaction':
+            return [{ id: e.id, item: { k: 'note', event: { e: 'compacted' } } }];
+        case 'codex:turnEnded':
+            if (e.how === 'interrupted')
+                return [{ id: `${e.id}#end`, item: { k: 'note', event: { e: 'interrupted' } } }];
+            if (e.how === 'failed')
+                return [{ id: `${e.id}#end`, item: { k: 'note', event: { e: 'failed' }, ...(e.error && { detail: e.error }) } }];
             return [];
+        case 'codex:other':
+            return [];
+        default:
+            return unhandled(e);
     }
 }
-// A turn that did not end by itself, as the line the chat puts after it.
-export function turnNote(turn) {
-    const t = obj(turn);
-    const id = str(t?.id);
-    if (!t || !id)
-        return null;
-    if (t.status === 'interrupted')
-        return { id: `${id}#end`, item: { k: 'note', event: { e: 'interrupted' } } };
-    if (t.status === 'failed') {
-        const detail = str(obj(t.error)?.message);
-        return { id: `${id}#end`, item: { k: 'note', event: { e: 'failed' }, ...(detail && { detail }) } };
-    }
-    return null;
-}
 export const COMMAND_APPROVAL = 'item/commandExecution/requestApproval';
 export const FILE_APPROVAL = 'item/fileChange/requestApproval';
 export const isApproval = (method) => method === COMMAND_APPROVAL || method === FILE_APPROVAL;
@@ -152,9 +132,9 @@ const offered = (params, decision) => {
     const all = arr(params.availableDecisions);
     return !all.length || all.includes(decision);
 };
-// An approval Codex asks for, as the phone's permission card. fileItem: the file change it is for, as it
-// started, which names the files the request itself does not.
-export function askOf(askId, method, params, fileItem) {
+// An approval Codex asks for, as the phone's permission card. files: the file change it is for, as it started,
+// which names the files the request itself does not.
+export function askOf(askId, method, params, files) {
     const reason = str(params.reason);
     if (method === COMMAND_APPROVAL) {
         const command = commandOf(params);
@@ -169,9 +149,9 @@ export function askOf(askId, method, params, fileItem) {
             always: amendment ? { rules: [amendment.acceptWithExecpolicyAmendment.execpolicy_amendment.join(' ')], dirs: [], mode: null } : null,
         };
     }
-    const changes = arr(fileItem?.changes).map(obj);
-    const paths = changes.map((c) => str(c?.path)).filter(Boolean);
-    const diffs = changes.map((c) => str(c?.diff)).filter(Boolean).join('\n');
+    const changes = files ?? [];
+    const paths = changes.map((c) => c.path).filter(Boolean);
+    const diffs = changes.map((c) => c.diff).filter(Boolean).join('\n');
     return {
         id: askId,
         kind: 'permission',

package/dist/server/agents/codex/notifications.js

@@ -1,5 +1,6 @@
 import { realpathSync } from 'node:fs';
-import { askOf, entriesOf, isApproval, turnNote, usageOf } from './items.js';
+import { itemEventOf } from './events.js';
+import { askOf, entriesOfEvent, isApproval, turnNote, usageOf } from './items.js';
 const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : undefined);
 const str = (v) => (typeof v === 'string' ? v : '');
 // How often the reply being written is put in the journal while deltas come.
@@ -59,24 +60,24 @@ export class CodexNotifications {
                 return;
             }
             case 'item/started': {
-                const item = obj(params.item);
-                if (item?.type === 'fileChange')
-                    t.files.set(str(item.id), item);
-                if (item?.type === 'contextCompaction')
+                const e = itemEventOf(params.item);
+                if (e.k === 'codex:fileChange')
+                    t.files.set(e.id, e.changes);
+                if (e.k === 'codex:compaction')
                     this.compacting(t, true);
                 return;
             }
             case 'item/completed': {
-                const item = obj(params.item);
                 const at = typeof params.completedAtMs === 'number' ? new Date(params.completedAtMs).toISOString() : undefined;
-                this.put(t, entriesOf(item, at));
-                if (item?.type === 'agentMessage') {
-                    t.said = str(item.text) || t.said;
-                    this.liveDone(t, str(item.id));
+                const e = itemEventOf(params.item, at);
+                this.put(t, entriesOfEvent(e));
+                if (e.k === 'codex:agentMessage') {
+                    t.said = e.text || t.said;
+                    this.liveDone(t, e.id);
                 }
-                if (item?.type === 'fileChange')
-                    t.files.delete(str(item.id));
-                if (item?.type === 'contextCompaction')
+                if (e.k === 'codex:fileChange')
+                    t.files.delete(e.id);
+                if (e.k === 'codex:compaction')
                     this.compacting(t, false);
                 return;
             }

package/dist/server/agents/codex/threads.js

@@ -2,10 +2,13 @@ import { execFile } from 'node:child_process';
 import { realpathSync } from 'node:fs';
 import { open } from 'node:fs/promises';
 import { basename, join } from 'node:path';
+import { turnSays } from '../turnSays.js';
+import { rolloutEventOf } from './events.js';
 const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : undefined);
 const str = (v) => (typeof v === 'string' ? v : '');
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 const LIMIT = 50;
+const ALL_PAGE = 100;
 // How long the list is kept: it takes the app server seconds to make.
 const KEEP_MS = 5 * 60_000;
 // How much of the end of a rollout is read for how its last turn went and what the person said last.
@@ -43,15 +46,49 @@ function anyThread(t) {
         updatedAt: num(t.updatedAt) * 1000,
     };
 }
+// What `make` makes, kept for KEEP_MS: everyone who asks while it is made waits for the one making; once old it
+// is made again in the background while the kept one answers, and kept on when that fails.
+function kept(make) {
+    let had = null;
+    let making = null;
+    return () => {
+        if (!(had && Date.now() - had.at < KEEP_MS) && !making) {
+            making = make()
+                .then((value) => {
+                had = { at: Date.now(), value };
+                return value;
+            })
+                .finally(() => {
+                making = null;
+            });
+        }
+        if (had) {
+            making?.catch(() => { });
+            return Promise.resolve(had.value);
+        }
+        return making;
+    };
+}
 export class CodexThreads {
     o;
-    kept = null;
-    listing = null;
     asking = null;
     locks;
+    threads;
+    everyThread;
     constructor(o) {
         this.o = o;
         this.locks = join(o.codexHome, 'thread-writer-locks');
+        this.threads = kept(async () => (await o.agent.listThreads({ limit: LIMIT, sourceKinds: ['cli', 'vscode'] })).flatMap((d) => threadOf(d) ?? []));
+        this.everyThread = kept(async () => {
+            const threads = [];
+            let cursor = null;
+            do {
+                const page = await o.agent.listThreadPage({ limit: ALL_PAGE, sourceKinds: ['cli', 'vscode'], ...(cursor && { cursor }) });
+                threads.push(...page.data.flatMap((d) => threadOf(d) ?? []));
+                cursor = page.next;
+            } while (cursor);
+            return threads;
+        });
     }
     // The latest threads and every thread open somewhere now, newest first. Asked again while one runs, the one
     // running answers.
@@ -61,6 +98,12 @@ export class CodexThreads {
         });
         return this.asking;
     }
+    // Every thread people opened, however old, newest first, as list() has them.
+    async all() {
+        const [threads, holders] = await Promise.all([this.everyThread(), this.holders()]);
+        const shown = await Promise.all(threads.map((t) => this.live(t, holders.get(t.id) ?? null)));
+        return shown.sort((a, b) => b.lastActivity - a.lastActivity);
+    }
     // One thread as list() has it, also when it is older than the list goes or not one list() shows; null when
     // there is none.
     async where(id) {
@@ -82,27 +125,6 @@ export class CodexThreads {
         const shown = await Promise.all(all.map((t) => this.live(t, holders.get(t.id) ?? null)));
         return shown.sort((a, b) => b.lastActivity - a.lastActivity);
     }
-    // The kept list, made again in the background once old; the first ask waits for it.
-    threads() {
-        const fresh = this.kept && Date.now() - this.kept.at < KEEP_MS;
-        if (!fresh && !this.listing) {
-            this.listing = this.o.agent
-                .listThreads({ limit: LIMIT, sourceKinds: ['cli', 'vscode'] })
-                .then((data) => {
-                const threads = data.flatMap((d) => threadOf(d) ?? []);
-                this.kept = { at: Date.now(), threads };
-                return threads;
-            })
-                .finally(() => {
-                this.listing = null;
-            });
-        }
-        if (this.kept) {
-            this.listing?.catch(() => { });
-            return Promise.resolve(this.kept.threads);
-        }
-        return this.listing;
-    }
     // The thread's state as its rollout says now.
     async live(t, holder) {
         const end = t.path ? await rolloutEnd(t.path).catch(() => null) : null;
@@ -174,31 +196,23 @@ export async function rolloutEnd(path) {
         for (const line of lines) {
             if (!line.includes('"event_msg"'))
                 continue;
-            let e;
-            let p;
+            let v;
             try {
-                e = obj(JSON.parse(line));
-                p = obj(e?.payload);
+                v = JSON.parse(line);
             }
             catch {
                 continue;
             }
-            const type = str(p?.type);
-            if (type === 'task_started') {
+            const e = rolloutEventOf(v);
+            const turn = turnSays(e);
+            if (turn === 'starts') {
                 busy = true;
-                turnAt = Date.parse(str(e?.timestamp)) || 0;
+                turnAt = Date.parse(e.at ?? '') || 0;
             }
-            else if (type === 'task_complete' || type === 'turn_aborted')
+            else if (turn === 'over')
                 busy = false;
-            else if (type === 'item_completed' && obj(p?.item)?.type === 'UserMessage') {
-                const text = (Array.isArray(obj(p?.item)?.content) ? obj(p?.item).content : [])
-                    .map((c) => (obj(c)?.type === 'text' ? str(obj(c)?.text) : ''))
-                    .join(' ');
-                lastPrompt = promptOf(text) ?? lastPrompt;
-            }
-            // How Codex before September wrote it.
-            else if (type === 'user_message')
-                lastPrompt = promptOf(str(p?.message)) ?? lastPrompt;
+            if (e.k === 'codex:rolloutPrompt')
+                lastPrompt = promptOf(e.text) ?? lastPrompt;
         }
         return { busy, turnAt, lastPrompt, mtime: mtimeMs };
     }

package/dist/server/agents/events.js

@@ -0,0 +1,4 @@
+// For a switch over every kind: a kind no case handles leaves this called with it, which does not compile.
+export function unhandled(e) {
+    throw new Error(`agent event not handled: ${JSON.stringify(e)}`);
+}

package/dist/server/agents/turnSays.js

@@ -0,0 +1,58 @@
+import { unhandled } from './events.js';
+// What an event, of either agent, says of the turn: that one begins with it, that it goes on, that it ended there, or nothing.
+export function turnSays(e) {
+    switch (e.k) {
+        case 'claude:prompt':
+        case 'claude:shell':
+        case 'claude:shellOutput':
+        case 'claude:teammates':
+        case 'claude:taskNotification':
+        case 'claude:fromOther':
+            return 'starts';
+        case 'claude:command':
+            return e.local ? null : 'starts';
+        case 'claude:results':
+        case 'claude:reply':
+            return 'going';
+        case 'claude:queue':
+            return e.op === 'dequeue' ? 'going' : null;
+        case 'claude:interrupted':
+        case 'claude:apiError':
+        case 'claude:turnOver':
+            return 'over';
+        // A compaction asked for runs between turns; one Claude Code starts on its own can fall in the middle of one.
+        case 'claude:compactBoundary':
+            return e.manual ? 'over' : null;
+        case 'claude:commandOutput':
+        case 'claude:compacted':
+        case 'claude:noted':
+        case 'claude:peer':
+        case 'claude:midTurnPrompt':
+        case 'claude:midTurnTaskEnd':
+        case 'claude:title':
+        case 'claude:lastPrompt':
+        case 'claude:sidechain':
+        case 'claude:other':
+            return null;
+        // Codex marks its turns itself; what is said inside one says nothing more of it.
+        case 'codex:rolloutTurnStarted':
+            return 'starts';
+        case 'codex:rolloutTurnEnded':
+        case 'codex:turnEnded':
+            return 'over';
+        case 'codex:rolloutPrompt':
+        case 'codex:userMessage':
+        case 'codex:agentMessage':
+        case 'codex:plan':
+        case 'codex:commandExecution':
+        case 'codex:fileChange':
+        case 'codex:toolCall':
+        case 'codex:webSearch':
+        case 'codex:imageView':
+        case 'codex:compaction':
+        case 'codex:other':
+            return null;
+        default:
+            return unhandled(e);
+    }
+}

package/dist/server/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { account } from './commands/account.js';
+import { activity } from './commands/activity.js';
 import { attach } from './commands/attach.js';
 import { doctor } from './commands/doctor.js';
 import { install } from './commands/install.js';
@@ -31,6 +32,7 @@ const commands = {
     serve,
     doctor,
     status,
+    activity,
     attach,
     account,
     claude: (args) => openHere('claude', args),

package/dist/server/commands/activity.js

@@ -0,0 +1,28 @@
+import { watchActivity } from '../sessions/control.js';
+import { m } from '../system/messages.js';
+import { homeDir, socketPath } from '../system/paths.js';
+import { fail } from './common.js';
+const real = () => ({
+    sock: socketPath(homeDir(), 'control.sock'),
+    print: (line) => console.log(line),
+    fail,
+    orphaned: () => process.ppid === 1,
+});
+// What the menu bar app runs: how many sessions are working, a line of JSON now and at each change, until the
+// server or the app goes.
+export async function activity(args, io = real()) {
+    if (!args.includes('--json'))
+        return io.fail(m.cli.activityUsage);
+    const watch = watchActivity(io.sock, (working) => io.print(JSON.stringify({ working })));
+    const check = setInterval(() => io.orphaned() && watch.stop(), io.checkMs ?? 5000);
+    try {
+        await watch.done;
+    }
+    catch (e) {
+        const code = e.code;
+        return io.fail(code === 'ENOENT' || code === 'ECONNREFUSED' ? m.cli.notRunning : e.message);
+    }
+    finally {
+        clearInterval(check);
+    }
+}

package/dist/server/http/app.js

@@ -3,7 +3,8 @@ import fastifyWebsocket from '@fastify/websocket';
 import Fastify, { LogController } from 'fastify';
 import { Guard, clientIp, sessionCookie } from './auth/guard.js';
 import { LoginSessions } from './auth/sessions.js';
-import { findTranscript, lastReply } from '../agents/claude/transcript/transcriptFile.js';
+import { findTranscript, lastSaid } from '../agents/claude/transcript/transcriptFile.js';
+import { sites } from '../system/config.js';
 import { DomainError, errorReply } from '../system/errors.js';
 import { EventHub } from '../sessions/events.js';
 import { register as appUpdate } from './routes/appUpdate.js';
@@ -16,6 +17,7 @@ import { register as journal } from './routes/journal.js';
 import { register as mac } from './routes/mac.js';
 import { register as media } from './routes/media.js';
 import { register as push } from './routes/push.js';
+import { register as pushRelay } from './routes/pushRelay.js';
 import { register as sessions } from './routes/sessions.js';
 import { register as web } from './routes/web.js';
 import { VERSION } from '../system/version.js';
@@ -48,13 +50,13 @@ export async function buildApp(deps) {
         return reply.code(status).send(body);
     });
     const logins = new LoginSessions(store, now);
-    const guard = new Guard(logins, origin);
+    const guard = new Guard(logins, sites({ origin, rpId: deps.rpId, extraOrigins: deps.extraOrigins ?? [] }));
     const secure = origin.startsWith('https://');
     const hub = new EventHub(machine, async (s) => {
         if (s.kind === 'codex')
-            return machine.lastReply(s.id);
+            return { reply: machine.lastReply(s.id), at: null };
         const path = s.claudeSessionId && deps.claudeProjectsRoot ? await findTranscript(deps.claudeProjectsRoot, s.claudeSessionId) : null;
-        return path ? lastReply(path) : null;
+        return path ? lastSaid(path) : { reply: null, at: null };
     });
     const audit = (req, method, ok) => {
         const line = { t: new Date(now()).toISOString(), ip: clientIp(req), ua: req.headers['user-agent'] ?? '', method, ok };
@@ -137,6 +139,8 @@ export async function buildApp(deps) {
     const ctx = { deps, guard, logins, hub, secure, now, audit, createLogin, startLogin, admit, dropRevokedSockets, machineOr404 };
     for (const register of [health, auth, sessions, chat, journal, media, claude, codex, push, appUpdate, mac])
         await register(app, ctx);
+    if (deps.relay?.relayTopic)
+        await pushRelay(deps.relay)(app, ctx);
     if (deps.extend)
         await deps.extend(app, ctx);
     await web(app, ctx);

package/dist/server/http/auth/guard.js

@@ -26,13 +26,17 @@ export function clientIp(req) {
 }
 export class Guard {
     logins;
-    origin;
-    constructor(logins, origin) {
+    sites;
+    constructor(logins, sites) {
         this.logins = logins;
-        this.origin = origin;
+        this.sites = sites;
     }
     originOk(req) {
-        return req.headers.origin === this.origin;
+        return this.sites.some((s) => s.origin === req.headers.origin);
+    }
+    // The address the page is on, or the origin for a request that names none of them.
+    siteOf(req) {
+        return this.sites.find((s) => s.origin === req.headers.origin) ?? this.sites[0];
     }
     // The login a request claims, and whether it came in the cookie. A browser sends the cookie by itself to
     // whatever page makes the request; the Authorization header only the app's own code puts there. Where