workoffdesk 1.0.1 → 1.0.2

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

@@ -32,11 +32,12 @@ function deviceName(ua) {
     return 'Device';
 }
 export function registerPasskeyRoutes(app, ctx, deps) {
-    const { store, origin, rpId } = deps;
+    const { store } = deps;
     const now = deps.now ?? Date.now;
     const challenges = new ChallengeStore(now);
     const expect = (purpose) => (c) => challenges.consume(c, purpose);
-    app.post('/api/auth/passkey/register/options', async () => {
+    app.post('/api/auth/passkey/register/options', async (req) => {
+        const { rpId } = ctx.guard.siteOf(req);
         const user = store.get().user;
         const options = await generateRegistrationOptions({
             rpName: 'WorkOffDesk',
@@ -57,6 +58,7 @@ export function registerPasskeyRoutes(app, ctx, deps) {
         const response = req.body?.response;
         if (!response)
             return reply.code(400).send({ error: 'registration failed' });
+        const { origin, rpId } = ctx.guard.siteOf(req);
         let result;
         try {
             result = await verifyRegistrationResponse({
@@ -92,7 +94,7 @@ export function registerPasskeyRoutes(app, ctx, deps) {
     app.post('/api/auth/passkey/login/options', PUBLIC, async (req, reply) => {
         if (!ctx.guard.originOk(req))
             return reply.code(403).send({ error: 'bad origin' });
-        const options = await generateAuthenticationOptions({ rpID: rpId, userVerification: 'required' });
+        const options = await generateAuthenticationOptions({ rpID: ctx.guard.siteOf(req).rpId, userVerification: 'required' });
         challenges.add(options.challenge, 'login');
         return options;
     });
@@ -107,6 +109,7 @@ export function registerPasskeyRoutes(app, ctx, deps) {
         };
         if (!passkey || !response)
             return fail();
+        const { origin, rpId } = ctx.guard.siteOf(req);
         let result;
         try {
             result = await verifyAuthenticationResponse({

package/dist/server/http/routes/appUpdate.js

@@ -64,7 +64,7 @@ export const register = (app, ctx) => {
             req.log.warn({ updateId: currentId }, 'app update failed to launch on a phone');
         }
         // Requests that went well are not logged; this is how one sees whether the phones took an update.
-        const checked = (offered) => req.log.info({ runtime, platform: header('expo-platform'), running: header('expo-current-update-id'), offered }, 'app update check');
+        const checked = (offered) => req.log.info({ runtime, platform: header('expo-platform'), running: header('expo-current-update-id'), embedded: header('expo-embedded-update-id'), failed, offered }, 'app update check');
         if (!served || header('expo-platform') !== 'ios' || runtime !== served.build.runtimeVersion) {
             checked(null);
             return reply.code(204).headers(PROTOCOL).send();

package/dist/server/http/routes/chat.js

@@ -108,6 +108,16 @@ export const register = (app, ctx) => {
             return reply.code(404).send({ error: 'no such session' });
         return { screen: await m.press(req.params.id, keys) };
     });
+    // Sends what Claude runs in the foreground to the background, so what waits in its queue goes in; sent false
+    // when the screen no longer offers it.
+    app.post('/api/m/:machine/sessions/:id/background', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        return { sent: await m.toBackground(req.params.id) };
+    });
     // Closes the dialog on screen, and only it: what the ✕ under a dialog does.
     app.post('/api/m/:machine/sessions/:id/close', async (req, reply) => {
         const m = machineOr404(req, reply);

package/dist/server/http/routes/claude.js

@@ -1,18 +1,37 @@
-import { findTranscript, readChat, readChatBefore } from '../../agents/claude/transcript/transcriptFile.js';
-import { heldInBackground, listProjectDirs, listRecentClaudeSessions } from '../../agents/claude/transcript/transcripts.js';
+import { findSubagent, findTranscript, readChat, readChatBefore } from '../../agents/claude/transcript/transcriptFile.js';
+import { heldInBackground, listAllClaudeSessions, listProjectDirs, listRecentClaudeSessions, oneClaudeSession } from '../../agents/claude/transcript/transcripts.js';
 import { isDir } from '../../system/dirs.js';
+import { InvalidRequest, NotFound } from '../../system/errors.js';
 // The Claude conversations people had on this Mac lately, and where each is open now.
-export async function recentClaude(deps) {
+// How old a look at the Mac's terminals the list may show: a page open on a conversation asks every few seconds.
+const MAC_SEEN_MS = 10_000;
+export function recentClaude(deps) {
+    return claudeRows(deps, (root) => listRecentClaudeSessions(root));
+}
+// Every Claude conversation Claude Code still keeps on this Mac, however old.
+export function allClaude(deps) {
+    return claudeRows(deps, listAllClaudeSessions);
+}
+// One Claude conversation on this Mac, as the lists have it; null when Claude Code keeps none by that id.
+export async function oneClaude(deps, sid) {
+    const [row] = await claudeRows(deps, async (root) => {
+        const r = await oneClaudeSession(root, sid);
+        return r ? [r] : [];
+    });
+    return row ?? null;
+}
+async function claudeRows(deps, list) {
     const { machine } = deps;
     if (!deps.claudeProjectsRoot)
         return [];
     const [recent, sessions, held, onMac] = await Promise.all([
-        listRecentClaudeSessions(deps.claudeProjectsRoot),
+        list(deps.claudeProjectsRoot),
         machine.listSessions(),
         deps.claudeJobsRoot ? heldInBackground(deps.claudeJobsRoot) : () => false,
-        machine.openOnMac(),
+        machine.openOnMac(MAC_SEEN_MS),
     ]);
-    const open = new Map(sessions.filter((s) => s.claudeSessionId).map((s) => [s.claudeSessionId, s.id]));
+    // An ended session is gone on with by Continue, which, with the conversation open on the Mac, leads to taking it over.
+    const open = new Map(sessions.filter((s) => s.claudeSessionId && s.status !== 'ended').map((s) => [s.claudeSessionId, s.id]));
     return recent.map((r) => {
         const there = onMac.get(r.sessionId);
         return {
@@ -27,11 +46,39 @@ export async function recentClaude(deps) {
         };
     });
 }
+// The conversation of the Claude on this Mac that sent a message, by its process, and the session here that
+// goes on with it. The name it sent under is checked: a process gone since can be another Claude now.
+export async function peerOf(deps, pid, name) {
+    const c = await deps.machine.macClaudeOf(pid);
+    if (!c || (c.name !== null && c.name !== name))
+        throw new NotFound('the Claude that sent this is no longer running on the Mac', 'peer-gone');
+    const held = (await deps.machine.listSessions()).find((s) => s.claudeSessionId === c.sessionId && s.status !== 'ended');
+    return { sid: c.sessionId, openIn: held?.id ?? null };
+}
+// A page of a transcript's chat, as a session's chat is paged: on from `from`, or back from `before`, both places
+// in the transcript named `sid`; from its latest turns when the caller's copy is of another one.
+async function chatPage(path, sid, q, reply, sidechain = false) {
+    const from = Number(q.from ?? 0);
+    const before = q.before === undefined ? null : Number(q.before);
+    if (!Number.isSafeInteger(from) || from < 0)
+        return reply.code(400).send({ error: 'bad from' });
+    if (before !== null && (!Number.isSafeInteger(before) || before < 0))
+        return reply.code(400).send({ error: 'bad before' });
+    if (q.sid !== sid)
+        return { sid, ...(await readChat(path, 0, { sidechain })) };
+    return { sid, ...(await (before === null ? readChat(path, from, { sidechain }) : readChatBefore(path, before, { sidechain }))) };
+}
 // Claude sessions on this Mac to pick up again, and the folders worth starting one in.
 export const register = (app, ctx) => {
     const { deps } = ctx;
     const { machine } = deps;
     app.get('/api/claude/recent', () => recentClaude(deps));
+    app.get('/api/claude/peers/:pid', (req) => {
+        const pid = Number(req.params.pid);
+        if (!Number.isSafeInteger(pid) || pid <= 0)
+            throw new InvalidRequest('bad process id');
+        return peerOf(deps, pid, req.query.name ?? '');
+    });
     // Stops waiting to take a conversation over from the Mac.
     app.delete('/api/claude/sessions/:sid/take-over', async (req, reply) => machine.cancelTakeOver(req.params.sid) ? reply.code(204).send() : reply.code(404).send({ error: 'not waiting' }));
     // A Claude session's conversation, by its session id, to read before picking it up here; the same shape
@@ -41,15 +88,22 @@ export const register = (app, ctx) => {
         const path = deps.claudeProjectsRoot ? await findTranscript(deps.claudeProjectsRoot, sid) : null;
         if (!path)
             return reply.code(404).send({ error: 'no such conversation' });
-        const from = Number(req.query.from ?? 0);
-        const before = req.query.before === undefined ? null : Number(req.query.before);
-        if (!Number.isSafeInteger(from) || from < 0)
-            return reply.code(400).send({ error: 'bad from' });
-        if (before !== null && (!Number.isSafeInteger(before) || before < 0))
-            return reply.code(400).send({ error: 'bad before' });
-        if (req.query.sid !== sid)
-            return { sid, ...(await readChat(path, 0)) };
-        return { sid, ...(await (before === null ? readChat(path, from) : readChatBefore(path, before))) };
+        return chatPage(path, sid, req.query, reply);
+    });
+    // A sub-agent the conversation started, by the call that started it: what it was started to do, and its own
+    // conversation, read the same way.
+    const subagent = (sid, tool) => (deps.claudeProjectsRoot ? findSubagent(deps.claudeProjectsRoot, sid, tool) : null);
+    app.get('/api/claude/sessions/:sid/agents/:tool', async (req, reply) => {
+        const found = await subagent(req.params.sid, req.params.tool);
+        if (!found)
+            return reply.code(404).send({ error: 'no such sub-agent' });
+        return { description: found.description };
+    });
+    app.get('/api/claude/sessions/:sid/agents/:tool/chat', async (req, reply) => {
+        const found = await subagent(req.params.sid, req.params.tool);
+        if (!found)
+            return reply.code(404).send({ error: 'no such sub-agent' });
+        return chatPage(found.path, req.params.tool, req.query, reply, true);
     });
     // The Claude accounts on this Mac, the one new sessions run on, and a pick of another.
     app.get('/api/claude/accounts', () => machine.claudeAccountsView());
@@ -65,5 +119,5 @@ export const register = (app, ctx) => {
         req.log.info({ moving: view.moving }, 'open sessions moving to the claude account in use');
         return view;
     });
-    app.get('/api/claude/projects', async () => listProjectDirs(await recentClaude(deps), deps.pinnedDirs ?? []));
+    app.get('/api/claude/projects', async () => listProjectDirs((await recentClaude(deps)).filter((r) => !r.folderGone), deps.pinnedDirs ?? []));
 };

package/dist/server/http/routes/codex.js

@@ -1,13 +1,19 @@
 import { isDir } from '../../system/dirs.js';
-import { recentClaude } from './claude.js';
+import { allClaude, oneClaude, recentClaude } from './claude.js';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 // How many items a read of a Codex conversation gives at most: the latest, or those before a place.
 const PAGE = 400;
+// The conversations on the Mac a page gives, unless asked for another number, and at most.
+const PAGE_CONVERSATIONS = 50;
+const MAX_CONVERSATIONS = 200;
 // The Codex conversations people had on this Mac, in the shape of the Claude ones: background is "open in
 // another Codex app", which cannot be gone on with here.
-async function recentCodex(deps) {
+function recentCodex(deps) {
+    return codexRows(deps, () => deps.machine.codexOnMac());
+}
+async function codexRows(deps, list) {
     const { machine } = deps;
-    const [threads, sessions] = await Promise.all([machine.codexOnMac().catch(() => []), machine.listSessions()]);
+    const [threads, sessions] = await Promise.all([list().catch(() => []), machine.listSessions()]);
     const open = new Map(sessions.filter((s) => s.codexThreadId).map((s) => [s.codexThreadId, s.id]));
     return threads.map((t) => ({
         sessionId: t.id,
@@ -32,6 +38,35 @@ export const register = (app, ctx) => {
         const [claude, codex] = await Promise.all([recentClaude(deps), recentCodex(deps)]);
         return [...claude, ...codex].sort((a, b) => b.lastActivity - a.lastActivity);
     });
+    // Every conversation people had on this Mac that its agent still keeps, newest first, a page at a time: at most
+    // limit of those last active before `before`, and whether there are more. q: in the title, folder or what was
+    // said last. One a session here holds, running or past, is in the list of sessions instead.
+    app.get('/api/conversations', async (req, reply) => {
+        const limit = req.query.limit === undefined ? PAGE_CONVERSATIONS : Number(req.query.limit);
+        const before = req.query.before === undefined ? Infinity : Number(req.query.before);
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_CONVERSATIONS)
+            return reply.code(400).send({ error: 'bad limit' });
+        if (Number.isNaN(before))
+            return reply.code(400).send({ error: 'bad before' });
+        const q = (req.query.q ?? '').trim().toLowerCase();
+        const [claude, codex, sessions] = await Promise.all([allClaude(deps), codexRows(deps, () => machine.allCodexOnMac()), machine.listSessions()]);
+        const held = new Set(sessions.flatMap((s) => [s.claudeSessionId, s.codexThreadId].filter((c) => c !== undefined)));
+        const found = (r) => [r.title, r.cwd, r.lastPrompt].some((t) => t?.toLowerCase().includes(q));
+        const rows = [...claude, ...codex]
+            .filter((r) => !r.automated && !held.has(r.sessionId) && r.lastActivity < before && found(r))
+            .sort((a, b) => b.lastActivity - a.lastActivity);
+        return { conversations: rows.slice(0, limit), more: rows.length > limit };
+    });
+    // One conversation, however old, as the lists have it: what its page shows and offers.
+    app.get('/api/conversations/:agent/:sid', async (req, reply) => {
+        const { agent, sid } = req.params;
+        const row = agent === 'claude'
+            ? await oneClaude(deps, sid)
+            : agent === 'codex' && UUID.test(sid)
+                ? ((await codexRows(deps, async () => [await machine.oneCodexOnMac(sid)].filter((t) => t !== null)))[0] ?? null)
+                : null;
+        return row ?? reply.code(404).send({ error: 'no such conversation' });
+    });
     // A thread's conversation, to read before picking it up here; the same shape and paging as a Claude one's,
     // with an item's place in the thread for a byte's in the transcript.
     app.get('/api/codex/threads/:id/chat', async (req, reply) => {

package/dist/server/http/routes/journal.js

@@ -12,6 +12,8 @@ export const register = (app, ctx) => {
         const v = count(req.query.v);
         if (!Number.isSafeInteger(v))
             return reply.code(400).send({ error: 'bad version' });
+        if (machine.isPast(req.params.id))
+            return machine.journal.sync(req.params.id, req.query.epoch, v);
         if (!(await m.exists(req.params.id)))
             return reply.code(404).send({ error: 'no such session' });
         // An answer is never behind the transcript, nor the screen (a copy that asks has no line reading it).
@@ -28,7 +30,7 @@ export const register = (app, ctx) => {
         const conv = req.query.conv ?? '';
         if (!Number.isSafeInteger(before) || !CONV.test(conv))
             return reply.code(400).send({ error: 'conv and before required' });
-        if (!(await m.exists(req.params.id)))
+        if (!machine.isPast(req.params.id) && !(await m.exists(req.params.id)))
             return reply.code(404).send({ error: 'no such session' });
         return machine.journal.older(req.params.id, conv, before);
     });

package/dist/server/http/routes/push.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from 'node:util';
 // The phones that get a notification when Claude needs an answer.
 export const register = (app, ctx) => {
     const { deps, now } = ctx;
@@ -22,8 +23,9 @@ export const register = (app, ctx) => {
         });
         return reply.code(204).send();
     });
-    // The iPhone app: ready says whether this server holds a key to reach it.
-    app.get('/api/push/apns', async () => ({ ready: !!pusher?.toPhones }));
+    // The iPhone app: ready says whether this server can reach it, with its own key or through the relay the
+    // app names (relay=1).
+    app.get('/api/push/apns', async (req) => ({ ready: req.query.relay === '1' || !!pusher?.toPhones }));
     app.post('/api/push/apns', async (req, reply) => {
         const d = parseDevice(req.body);
         if (!d)
@@ -31,7 +33,7 @@ export const register = (app, ctx) => {
         // A phone tells its token on every start and whenever iOS hands it out: what is known already is not
         // written again.
         const was = store.get().apnsDevices.find((x) => x.token === d.token);
-        if (was && was.topic === d.topic && was.words.waiting === d.words.waiting && was.words.idle === d.words.idle)
+        if (was && isDeepStrictEqual({ topic: was.topic, words: was.words, relay: was.relay }, { topic: d.topic, words: d.words, relay: d.relay }))
             return reply.code(204).send();
         store.update((s) => {
             const was = s.apnsDevices.find((x) => x.token === d.token);
@@ -47,7 +49,7 @@ export const register = (app, ctx) => {
         return reply.code(204).send();
     });
 };
-const words = (v) => typeof v === 'string' && v.length > 0 && v.length <= 200;
+const words = (v, max = 200) => typeof v === 'string' && v.length > 0 && v.length <= max;
 function parseDevice(body) {
     const b = body;
     if (!b || typeof b.token !== 'string' || !/^[0-9a-f]{64,200}$/i.test(b.token))
@@ -56,7 +58,36 @@ function parseDevice(body) {
         return null;
     if (!words(b.words?.waiting) || !words(b.words?.idle))
         return null;
-    return { token: b.token, topic: b.topic, words: { waiting: b.words.waiting, idle: b.words.idle } };
+    const hidden = b.words?.hidden;
+    if (hidden !== undefined && !words(hidden, 120))
+        return null;
+    const relay = b.relay === undefined ? undefined : parseRelay(b.relay);
+    if (relay === null || (relay && hidden === undefined))
+        return null;
+    return {
+        token: b.token,
+        topic: b.topic,
+        words: { waiting: b.words.waiting, idle: b.words.idle, ...(hidden === undefined ? {} : { hidden: hidden }) },
+        ...(relay ? { relay } : {}),
+    };
+}
+// An https origin, and a 32-byte key in base64.
+function parseRelay(v) {
+    const r = v;
+    if (!r || typeof r.url !== 'string' || typeof r.key !== 'string')
+        return null;
+    let url;
+    try {
+        url = new URL(r.url);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:' || url.origin !== r.url.replace(/\/$/, ''))
+        return null;
+    if (!/^[A-Za-z0-9+/]{43}=$/.test(r.key) || Buffer.from(r.key, 'base64').length !== 32)
+        return null;
+    return { url: url.origin, key: r.key };
 }
 function parseSubscription(body) {
     const b = body;

package/dist/server/http/routes/pushRelay.js

@@ -0,0 +1,62 @@
+import { PUBLIC } from './context.js';
+// On the server of whoever publishes the App Store app: other people's Macs hand it notifications for that
+// app, sealed for the phone (notify/seal.ts), to pass on to Apple with this server's key. It needs no sign-in,
+// as those Macs have none here; it cannot read what it passes on, and it delivers to no other app.
+const MINUTE = 60_000;
+const PER_DEVICE = 30;
+const IN_ALL = 600;
+// Apple takes 4 KB of payload; this leaves room for the rest of it.
+const SEALED_MAX = 3000;
+export const register = (relay) => (app, { now }) => {
+    const limit = minuteLimits(now);
+    app.post('/api/push/relay', { ...PUBLIC, bodyLimit: 8 * 1024 }, async (req, reply) => {
+        const r = parse(req.body);
+        if (!r)
+            return reply.code(400).send({ error: 'invalid notification' });
+        if (r.topic !== relay.relayTopic)
+            return reply.code(403).send({ error: 'not an app this server relays for' });
+        const wait = limit(r.token);
+        if (wait)
+            return reply.code(429).header('retry-after', String(wait)).send({ error: 'too many' });
+        const payload = { aps: { alert: { body: r.hidden }, sound: 'default', 'mutable-content': 1, 'thread-id': r.thread }, sealed: r.sealed };
+        const { gone, sent } = await relay.send({ token: r.token, topic: r.topic }, payload, r.thread);
+        if (gone)
+            return reply.code(410).send({ error: 'device gone' });
+        return sent ? reply.code(200).send({}) : reply.code(502).send({ error: 'not taken' });
+    });
+};
+function parse(body) {
+    const b = body;
+    if (!b || typeof b.token !== 'string' || !/^[0-9a-f]{64}$/i.test(b.token))
+        return null;
+    if (typeof b.topic !== 'string')
+        return null;
+    if (typeof b.sealed !== 'string' || b.sealed.length > SEALED_MAX || !/^[A-Za-z0-9+/]+={0,2}$/.test(b.sealed))
+        return null;
+    if (typeof b.thread !== 'string' || !/^[0-9a-f]{16}$/.test(b.thread))
+        return null;
+    if (typeof b.hidden !== 'string' || !b.hidden || b.hidden.length > 120)
+        return null;
+    return { token: b.token, topic: b.topic, sealed: b.sealed, thread: b.thread, hidden: b.hidden };
+}
+// How many a minute one device, and all of them, may be sent; the seconds to wait when over, else 0.
+function minuteLimits(now) {
+    let minute = -1;
+    let all = 0;
+    const each = new Map();
+    return (token) => {
+        const t = now();
+        const m = Math.floor(t / MINUTE);
+        if (m !== minute) {
+            minute = m;
+            all = 0;
+            each.clear();
+        }
+        const mine = each.get(token) ?? 0;
+        if (mine >= PER_DEVICE || all >= IN_ALL)
+            return Math.ceil(((m + 1) * MINUTE - t) / 1000);
+        each.set(token, mine + 1);
+        all++;
+        return 0;
+    };
+}

package/dist/server/http/routes/sessions.js

@@ -39,6 +39,22 @@ export const register = (app, ctx) => {
         }
         return m.continueSession(req.params.id);
     });
+    // Moves the session to the Claude account in use, answering once it runs there; once it is free, at once.
+    app.post('/api/m/:machine/sessions/:id/move', async (req, reply) => {
+        const when = req.body?.when;
+        if (when !== undefined && when !== 'now' && when !== 'free')
+            return reply.code(400).send({ error: 'when must be now or free' });
+        const m = machineOr404(req, reply);
+        return m ? m.moveThis(req.params.id, when) : reply;
+    });
+    // Quits the Claudes in terminals on the Mac that hold the session's conversation too, leaving it to the session.
+    app.post('/api/m/:machine/sessions/:id/quit-on-mac', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        await m.quitOnMac(req.params.id, req.body?.force === true);
+        return reply.code(204).send();
+    });
     app.get('/api/m/:machine/agents', async (req, reply) => {
         const m = machineOr404(req, reply);
         return m ? m.agents : reply;
@@ -55,7 +71,22 @@ export const register = (app, ctx) => {
         await m.killSession(req.params.id);
         return reply.code(204).send();
     });
-    // A name of the session's own, for every device; an empty one goes back to the directory's name.
+    // Pinned to the top of the list for every device, or unpinned; asking twice is asking once.
+    for (const method of ['PUT', 'DELETE']) {
+        app.route({
+            method,
+            url: '/api/m/:machine/sessions/:id/pin',
+            handler: async (req, reply) => {
+                const m = machineOr404(req, reply);
+                if (!m)
+                    return reply;
+                if (!(await m.pinSession(req.params.id, method === 'PUT')))
+                    return reply.code(404).send({ error: 'no such session' });
+                return reply.code(204).send();
+            },
+        });
+    }
+    // A name of the session's own, for every device and for its agent's conversation; never an empty one.
     app.patch('/api/m/:machine/sessions/:id', async (req, reply) => {
         const m = machineOr404(req, reply);
         if (!m)

package/dist/server/http/serve.js

@@ -73,7 +73,8 @@ export async function startServer(o) {
     // Push services want a contact URL; Apple rejects anything but https: or mailto:.
     const subject = o.config.origin.startsWith('https://') ? o.config.origin : 'mailto:workoffdesk@localhost';
     const apnsKey = loadApnsKey(o.home);
-    const pusher = new Pusher(store, { subject, send: o.pushSend, apns: apnsKey ? new Apns(apnsKey, o.apnsPost) : undefined });
+    const apns = apnsKey ? new Apns(apnsKey, o.apnsPost) : undefined;
+    const pusher = new Pusher(store, { subject, send: o.pushSend, apns });
     machine.setNotifier(pusher);
     const hooks = await startHookServer(hookSock, createHookHandler(machine, pusher), (id, payload) => machine.setUsage(id, usageFrom(payload)), createPermissionHandler(machine, pusher));
     const control = await startControlServer(socketPath(o.home, 'control.sock'), {
@@ -91,6 +92,7 @@ export async function startServer(o) {
                 return view;
             },
         },
+        activity: { working: () => machine.working(), onChange: (cb) => machine.onChange(cb) },
     });
     const stopWatch = machine.watch(o.watchMs ?? 2000);
     const { app } = await buildApp({
@@ -99,9 +101,11 @@ export async function startServer(o) {
         machine,
         origin: o.config.origin,
         rpId: o.config.rpId,
+        extraOrigins: o.config.extraOrigins,
         auditPath: join(o.home, 'logs/audit.log'),
         webDir: o.webDir,
         pusher,
+        relay: apns,
         claudeProjectsRoot: o.claudeProjectsRoot ?? join(homedir(), '.claude/projects'),
         claudeJobsRoot: o.claudeJobsRoot ?? join(homedir(), '.claude/jobs'),
         claudeDir: o.claudeDir ?? join(homedir(), '.claude'),
@@ -110,7 +114,7 @@ export async function startServer(o) {
         media: { uploadsDir: join(o.home, 'uploads') },
         appUpdate: o.appUpdate && { ...o.appUpdate, bundlesDir: join(o.home, 'app-bundles') },
         ops: o.ops,
-        extend: (a, ctx) => registerPasskeyRoutes(a, ctx, { store, origin: o.config.origin, rpId: o.config.rpId }),
+        extend: (a, ctx) => registerPasskeyRoutes(a, ctx, { store }),
     });
     return {
         app,
@@ -123,6 +127,8 @@ export async function startServer(o) {
             // Prompts held for the phone go back to the Mac's dialog alone.
             hooks.closeAllConnections();
             control.close();
+            // The menu bar app's watch ends, and it asks again of the next server.
+            control.closeAllConnections();
             machine.closeJournal();
         },
     };

package/dist/server/journal/db.js

@@ -74,6 +74,7 @@ export class JournalDb {
             allStates: p('SELECT name, v, body FROM state WHERE session = ? ORDER BY v'),
             itemsBefore: p('SELECT id, conv, pos, v, body FROM item WHERE session = ? AND conv = ? AND pos < ? ORDER BY pos DESC LIMIT ?'),
             newestFirst: p('SELECT body FROM item WHERE session = ? AND conv = ? ORDER BY pos DESC'),
+            itemCount: p('SELECT COUNT(*) AS n FROM item WHERE session = ?'),
             dropItems: p('DELETE FROM item WHERE session = ?'),
             dropMessages: p('DELETE FROM message WHERE session = ?'),
             dropStates: p('DELETE FROM state WHERE session = ?'),
@@ -207,6 +208,9 @@ export class JournalDb {
     heads() {
         return Object.fromEntries(this.q.heads.all().map((r) => [r.id, r.v]));
     }
+    itemCount(id) {
+        return this.q.itemCount.get(id).n;
+    }
     drop(id) {
         this.tx(() => {
             for (const q of [this.q.dropItems, this.q.dropMessages, this.q.dropStates, this.q.dropSession])

package/dist/server/journal/index.js

@@ -179,6 +179,10 @@ export class Journal {
         this.headListeners.add(cb);
         return () => this.headListeners.delete(cb);
     }
+    // How many items of what was said the session has.
+    itemCount(id) {
+        return this.db.itemCount(id);
+    }
     drop(id) {
         this.db.drop(id);
         this.screenLive.delete(id);

package/dist/server/journal/ingest.js

@@ -1,6 +1,7 @@
 import { sentWords } from '../agents/claude/transcript/chat.js';
+import { eventOf } from '../agents/claude/transcript/events.js';
 import { findTranscript, idItems, linesFrom } from '../agents/claude/transcript/transcriptFile.js';
-import { heldInTranscript } from '../agents/claude/transcript/turn.js';
+import { queueInTranscript } from '../agents/claude/transcript/turn.js';
 import { backgroundRunning, liveShown, taskList } from './derive.js';
 // The transcript records a prompt when Claude Code takes it, after it was pasted.
 const LANDS_AFTER_MS = -2000;
@@ -73,7 +74,7 @@ export async function ingest(db, id, conv, o) {
             if (items)
                 db.putState(id, 'live', { text: liveShown(o.live(true), db.turnTexts(id, conv)) });
             if (queueMoved)
-                wrote = inClaudesQueue(db, id, heldInTranscript(path)) || wrote;
+                wrote = inClaudesQueue(db, id, queueInTranscript(path), o.log) || wrote;
             db.setConv(id, conv, read.next);
             wrote ||= items;
         });
@@ -89,17 +90,20 @@ export async function ingest(db, id, conv, o) {
 function titleIn(line, found) {
     if (!line.includes('-title"'))
         return;
-    let r;
+    let v;
     try {
-        r = JSON.parse(line);
+        v = JSON.parse(line);
     }
     catch {
         return;
     }
-    if (r.type === 'custom-title' && typeof r.customTitle === 'string' && r.customTitle.trim())
-        found.custom = r.customTitle;
-    if (r.type === 'ai-title' && typeof r.aiTitle === 'string' && r.aiTitle.trim())
-        found.ai = r.aiTitle;
+    const e = eventOf(v);
+    if (e.k !== 'claude:title' || !e.text.trim())
+        return;
+    if (e.by === 'person')
+        found.custom = e.text;
+    else
+        found.ai = e.text;
 }
 // Lands the messages not landed that the conversation already has, each at the first prompt with its words
 // that no other message is: the prompt was read before the message was known to be on its way.
@@ -118,15 +122,24 @@ export function landFound(db, id, log) {
 }
 // A message on its way whose words Claude holds in its own queue is enqueued, the oldest first for words held
 // twice: one pasted while the status had not caught up with Claude being at work. One stays enqueued until it
-// lands, or is not found when the turn is over (pulled back into the prompt at the Mac). True when any
-// changed.
-function inClaudesQueue(db, id, held) {
-    const left = held.map((t) => t.trim());
+// lands, or is not found when the turn is over. One whose words were pulled back into the prompt at the Mac
+// after it was sent, and are not held again, is taken back. True when any changed.
+function inClaudesQueue(db, id, queue, log) {
+    const left = queue.held.map((t) => t.trim());
+    const pulled = queue.pulled.map((p) => ({ text: p.text.trim(), at: p.at }));
     let changed = false;
     for (const m of onTheirWay(db, id)) {
         const i = left.indexOf(pasted(m.text));
-        if (i < 0)
+        if (i < 0) {
+            const p = pulled.findIndex((x) => x.text === pasted(m.text) && !(x.at - m.sentAt < LANDS_AFTER_MS));
+            if (p < 0)
+                continue;
+            pulled.splice(p, 1);
+            db.putMessage(id, { ...m, state: 'taken', ord: null });
+            log('message pulled back at the Mac', { session: id, qid: m.id });
+            changed = true;
             continue;
+        }
         left.splice(i, 1);
         if (m.state === 'enqueued')
             continue;