workoffdesk 1.0.1 → 1.0.2

package/dist/server/notify/apns.js

@@ -19,15 +19,17 @@ export function loadApnsKey(home) {
     catch {
         throw wrong('not JSON');
     }
-    const { teamId, keyId, keyFile } = raw ?? {};
+    const { teamId, keyId, keyFile, relayTopic } = raw ?? {};
     if (typeof teamId !== 'string' || !teamId)
         throw wrong('"teamId" is missing (the Team ID in the Apple Developer account)');
     if (typeof keyId !== 'string' || !keyId)
         throw wrong('"keyId" is missing (the 10 characters in AuthKey_<keyId>.p8)');
     if (typeof keyFile !== 'string' || !existsSync(keyFile))
         throw wrong(`"keyFile" names no file: ${String(keyFile)}`);
+    if (relayTopic !== undefined && (typeof relayTopic !== 'string' || !/^[A-Za-z0-9.-]{1,155}$/.test(relayTopic)))
+        throw wrong(`"relayTopic" is not a bundle id: ${String(relayTopic)}`);
     try {
-        return { teamId, keyId, key: createPrivateKey(readFileSync(keyFile)) };
+        return { teamId, keyId, key: createPrivateKey(readFileSync(keyFile)), ...(relayTopic ? { relayTopic } : {}) };
     }
     catch {
         throw wrong(`"keyFile" is not a .p8 key: ${keyFile}`);
@@ -43,6 +45,9 @@ export class Apns {
         this.post = post;
         this.now = now;
     }
+    get relayTopic() {
+        return this.key.relayTopic;
+    }
     // A device that has not answered yet is tried on the production service (TestFlight and the App Store),
     // then on the sandbox (builds from Xcode). host: the service it answered on.
     async send(device, payload, collapseId) {
@@ -62,18 +67,18 @@ export class Apns {
                 res = await this.post(host, `/3/device/${device.token}`, headers, body);
             }
             catch {
-                return { host: device.host, gone: false };
+                return { host: device.host, gone: false, sent: false };
             }
             if (res.status === 200)
-                return { host, gone: false };
+                return { host, gone: false, sent: true };
             if (res.status === 410)
-                return { host, gone: true };
+                return { host, gone: true, sent: false };
             if (res.status === 403 && /ProviderToken/.test(res.reason ?? ''))
                 this.token = null;
             if (res.reason !== 'BadDeviceToken')
-                return { host: device.host ?? host, gone: false };
+                return { host: device.host ?? host, gone: false, sent: false };
         }
-        return { gone: true };
+        return { gone: true, sent: false };
     }
     bearer() {
         const t = this.now();

package/dist/server/notify/push.js

@@ -1,4 +1,5 @@
 import webpush from 'web-push';
+import { seal, threadOf } from './seal.js';
 const COOLDOWN = 30_000;
 // The most of what Claude said a notification carries; the phone shows the first lines of it.
 const SAID_MAX = 300;
@@ -15,12 +16,15 @@ export function plainLine(said) {
     const chars = Array.from(text);
     return chars.length > SAID_MAX ? `${chars.slice(0, SAID_MAX - 1).join('')}…` : text;
 }
+const RELAY_WAIT_MS = 10_000;
+const relayFetch = (url, body) => fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body, signal: AbortSignal.timeout(RELAY_WAIT_MS) }).then((r) => r.status);
 export class Pusher {
     store;
     send;
     now;
     subject;
     apns;
+    relayPost;
     lastSent = new Map();
     visible = new Map();
     constructor(store, opts) {
@@ -29,6 +33,7 @@ export class Pusher {
         this.now = opts.now ?? Date.now;
         this.subject = opts.subject;
         this.apns = opts.apns;
+        this.relayPost = opts.relayPost ?? relayFetch;
     }
     // Whether the iPhone app can be sent notifications from here.
     get toPhones() {
@@ -48,7 +53,7 @@ export class Pusher {
     async notify(sessionId, title, event, said) {
         const { vapid, pushSubs, apnsDevices } = this.store.get();
         const browsers = vapid ? pushSubs : [];
-        const phones = this.apns ? apnsDevices : [];
+        const phones = apnsDevices.filter((d) => (this.relayed(d) ? true : !!this.apns));
         if ((!browsers.length && !phones.length) || this.visible.has(sessionId))
             return;
         const t = this.now();
@@ -85,11 +90,21 @@ export class Pusher {
             });
         }
     }
+    // An App Store app's device goes through its relay, unless this server is that relay; any other, to Apple
+    // with this server's key.
+    relayed(d) {
+        return !!d.relay && this.apns?.relayTopic !== d.topic;
+    }
     async toApp(devices, sessionId, title, event, said) {
-        const apns = this.apns;
-        if (!devices.length || !apns)
+        if (!devices.length)
             return;
-        const results = await Promise.all(devices.map((d) => apns.send(d, { aps: { alert: alertOf(title, d.words[event], event, said), sound: 'default', 'thread-id': sessionId }, body: { sessionId } }, sessionId).then((r) => ({ token: d.token, ...r }))));
+        const results = await Promise.all(devices.map(async (d) => {
+            const alert = alertOf(title, d.words[event], event, said);
+            if (this.relayed(d))
+                return { token: d.token, gone: await this.throughRelay(d, sessionId, alert) };
+            const { host, gone } = await this.apns.send(d, { aps: { alert, sound: 'default', 'thread-id': sessionId }, body: { sessionId } }, sessionId);
+            return { token: d.token, host, gone };
+        }));
         const gone = new Set(results.filter((r) => r.gone).map((r) => r.token));
         const learned = new Map(results.filter((r) => !r.gone && r.host).map((r) => [r.token, r.host]));
         const known = new Map(devices.map((d) => [d.token, d.host]));
@@ -99,6 +114,17 @@ export class Pusher {
             s.apnsDevices = s.apnsDevices.filter((d) => !gone.has(d.token)).map((d) => (learned.has(d.token) ? { ...d, host: learned.get(d.token) } : d));
         });
     }
+    // Whether the relay says the device is gone.
+    async throughRelay(d, sessionId, alert) {
+        const { url, key } = d.relay;
+        const body = { token: d.token, topic: d.topic, sealed: seal(key, { alert, sessionId }), thread: threadOf(key, sessionId), hidden: d.words.hidden ?? '' };
+        try {
+            return (await this.relayPost(`${url}/api/push/relay`, JSON.stringify(body))) === 410;
+        }
+        catch {
+            return false;
+        }
+    }
 }
 // The phone's words for the event say what happened, and what Claude said, what about. A finished turn's
 // reply says by itself that the turn is over.

package/dist/server/notify/seal.js

@@ -0,0 +1,12 @@
+import { createCipheriv, createHmac, randomBytes } from 'node:crypto';
+// A notification for the App Store app goes through a relay that must not read it. It is sealed with the key
+// the phone gave this server: AES-256-GCM, as nonce, ciphertext and tag one after another, which is how
+// CryptoKit's AES.GCM.SealedBox(combined:) in the phone's notification extension reads it.
+export function seal(keyB64, said) {
+    const nonce = randomBytes(12);
+    const c = createCipheriv('aes-256-gcm', Buffer.from(keyB64, 'base64'), nonce);
+    const text = Buffer.concat([c.update(JSON.stringify(said), 'utf8'), c.final()]);
+    return Buffer.concat([nonce, text, c.getAuthTag()]).toString('base64');
+}
+// The thread a session's notifications are grouped under, which the relay sees.
+export const threadOf = (keyB64, sessionId) => createHmac('sha256', Buffer.from(keyB64, 'base64')).update(sessionId).digest('hex').slice(0, 16);

package/dist/server/ops/doctor.js

@@ -61,12 +61,13 @@ async function serviceChecks(d, doc, config) {
                 ? fail('service', doc.otherVersion(local, service.version, d.version), doc.restartFix(config.serviceLabel))
                 : pass('service', doc.running(local, service.version)),
     ];
-    if (LOCAL.test(config.origin)) {
-        checks.push(pass('origin', doc.localOnly(config.origin)));
-    }
-    else {
-        const there = await d.fetch(`${config.origin}/healthz`);
-        checks.push(there.ok ? pass('origin', config.origin) : fail('origin', doc.notReached(config.origin), doc.originFix(config.origin, local)));
+    for (const origin of [config.origin, ...config.extraOrigins]) {
+        if (LOCAL.test(origin)) {
+            checks.push(pass('origin', doc.localOnly(origin)));
+            continue;
+        }
+        const there = await d.fetch(`${origin}/healthz`);
+        checks.push(there.ok ? pass('origin', origin) : fail('origin', doc.notReached(origin), doc.originFix(origin, local)));
     }
     return checks;
 }

package/dist/server/ops/problems.js

@@ -38,17 +38,22 @@ function parse(text) {
         return null;
     return { at: new Date(time).toISOString(), level: named, msg: typeof msg === 'string' ? msg : '', detail: JSON.stringify(rest).slice(0, DETAIL_MAX) };
 }
+// The newest first, the same words at the same level said once: limit is of different problems.
 export function recentProblems(logFile, limit = 50) {
-    const found = [];
+    const found = new Map();
     for (const file of [logFile, `${logFile}.1`]) {
         const lines = tail(file).split('\n');
-        for (let i = lines.length - 1; i >= 0 && found.length < limit; i--) {
+        for (let i = lines.length - 1; i >= 0; i--) {
             const p = lines[i] && parse(lines[i]);
-            if (p)
-                found.push(p);
+            if (!p)
+                continue;
+            const key = `${p.level} ${p.msg}`;
+            const seen = found.get(key);
+            if (seen)
+                seen.count++;
+            else if (found.size < limit)
+                found.set(key, { ...p, count: 1 });
         }
-        if (found.length >= limit)
-            break;
     }
-    return found;
+    return [...found.values()];
 }

package/dist/server/sessions/control.js

@@ -15,6 +15,25 @@ function openSession(open, body) {
         return bad('kind must be claude or codex');
     return open({ kind: r.kind, cwd: r.cwd, resumeId: r.resumeId, env: r.env }).then((id) => ({ status: 201, body: { id } }), (e) => ({ status: 400, body: { error: e instanceof Error ? e.message : String(e) } }));
 }
+// The working count as a line of JSON at once, then again each time it changes, until the client goes away.
+function streamActivity(activity, res) {
+    res.writeHead(200, { 'content-type': 'application/x-ndjson' });
+    let last = -1;
+    const check = () => {
+        const working = activity.working();
+        if (working === last)
+            return;
+        last = working;
+        res.write(`${JSON.stringify({ working })}\n`);
+    };
+    check();
+    const unwatch = activity.onChange(check);
+    const timer = setInterval(check, activity.recheckMs ?? 2000).unref();
+    res.on('close', () => {
+        unwatch();
+        clearInterval(timer);
+    });
+}
 export function startControlServer(sockPath, o) {
     const answered = (view) => view.then((body) => ({ status: 200, body }), (e) => {
         const r = errorReply(e);
@@ -46,6 +65,8 @@ export function startControlServer(sockPath, o) {
                 res.writeHead(status, { 'content-type': 'application/json' });
                 res.end(JSON.stringify(body));
             };
+            if (req.method === 'GET' && req.url === '/activity')
+                return streamActivity(o.activity, res);
             const route = routes[`${req.method} ${req.url}`];
             if (!route)
                 return reply({ status: 404, body: { error: 'not found' } });
@@ -95,3 +116,47 @@ export async function askToOpen(sockPath, r) {
 export const askAccounts = (sockPath) => ask(sockPath, 'GET', '/accounts');
 export const askToPick = (sockPath, id) => ask(sockPath, 'PUT', '/account', { id });
 export const askToMove = (sockPath) => ask(sockPath, 'POST', '/account/move');
+// Each working count the server sends, until stop() or the server ends the stream; done fails when no server
+// answers.
+const readCount = (line) => {
+    try {
+        const working = JSON.parse(line).working;
+        return typeof working === 'number' ? working : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export function watchActivity(sockPath, onCount) {
+    let stopped = false;
+    let req;
+    const done = new Promise((resolve, reject) => {
+        req = request({ socketPath: sockPath, method: 'GET', path: '/activity' }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                return reject(new Error(`server answered ${res.statusCode}`));
+            }
+            let rest = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                const lines = (rest + chunk).split('\n');
+                rest = lines.pop();
+                for (const line of lines) {
+                    const working = readCount(line);
+                    if (working !== undefined)
+                        onCount(working);
+                }
+            });
+            res.on('close', () => resolve());
+        });
+        req.on('error', (e) => (stopped ? resolve() : reject(e)));
+        req.end();
+    });
+    return {
+        done,
+        stop: () => {
+            stopped = true;
+            req?.destroy();
+        },
+    };
+}

package/dist/server/sessions/events.js

@@ -1,12 +1,12 @@
 export class EventHub {
     machine;
-    lastReply;
+    lastSaid;
     clients = new Set();
     pending = null;
     pendingHeads = null;
-    constructor(machine, lastReply = async () => null) {
+    constructor(machine, lastSaid = async () => ({ reply: null, at: null })) {
         this.machine = machine;
-        this.lastReply = lastReply;
+        this.lastSaid = lastSaid;
         machine.onChange(() => this.schedule());
         machine.journal.onHead(() => this.scheduleHeads());
     }
@@ -63,8 +63,10 @@ export class EventHub {
         const sessions = await this.machine.listSessions().catch(() => null);
         if (!sessions)
             return null;
-        const replies = await Promise.all(sessions.map((s) => this.lastReply(s).catch(() => null)));
-        return { type: 'sessions', machine: this.machine.id, asOf, sessions: sessions.map((s, i) => ({ ...s, lastReply: replies[i] })) };
+        const said = await Promise.all(sessions.map((s) => this.lastSaid(s).catch(() => null)));
+        // A session is as recent as its conversation; tmux sees only keys typed at a terminal.
+        const shown = sessions.map((s, i) => ({ ...s, lastActivity: said[i]?.at ?? s.lastActivity, lastReply: said[i]?.reply ?? null }));
+        return { type: 'sessions', machine: this.machine.id, asOf, sessions: shown };
     }
     close() {
         if (this.pending)

package/dist/server/sessions/machine/input.js

@@ -37,13 +37,13 @@ export class Input {
         // before its thread starts (trust this folder?).
         if (this.d.store.get().sessions[id]?.kind === 'codex') {
             const choices = this.beforeThread(id) ? codexChoices(await this.d.tmux.screen(tmuxName(id))) : null;
-            const screen = { choices, panel: null, suggestion: null, mode: null };
+            const screen = { choices, panel: null, suggestion: null, mode: null, background: false };
             this.d.journal.screenAsIs(id, screen);
             return { ...screen, live: null, asks: this.d.codex?.asks(id) ?? [] };
         }
         if (Date.now() - (this.s.macLooks.get(id) ?? 0) >= MAC_LOOK_MS) {
             this.s.macLooks.set(id, Date.now());
-            void this.p.lifecycle.openOnMac();
+            this.p.lifecycle.openOnMac().catch(() => { });
         }
         const { screen, compacting } = await this.d.claude.read(tmuxName(id), this.s.statuses.get(id) === 'working');
         this.p.status.compactingOnScreen(id, compacting);
@@ -69,6 +69,17 @@ export class Input {
         const pressed = await this.d.claude.tick(tmuxName(id), ticked, labels);
         return this.readAfter(id, pressed, (s) => s.choices?.options.map((o) => o.label).join('\n') !== labels.join('\n'));
     }
+    async toBackground(id) {
+        if (!ID.test(id))
+            throw new InvalidRequest('bad session id');
+        if (this.d.store.get().sessions[id]?.kind !== 'claude')
+            return false;
+        // Answered once the screen no longer offers it, so a second press finds nothing to send.
+        if (!(await this.d.claude.toBackground(tmuxName(id))))
+            return false;
+        await this.screenOnceShown(id, (s) => !s.background, () => null).catch(() => null);
+        return true;
+    }
     // The screen as it is once a choice was answered, or found changed, goes into the journal for the phone:
     // read now when nothing was pressed, else until the options pressed are gone.
     readAfter(id, pressed, gone) {
@@ -145,6 +156,8 @@ export class Input {
         if (!(await this.p.status.agentRuns(id)) || (await this.dialogOpen(id)))
             return false;
         await this.d.tmux.leaveCopyMode(tmuxName(id));
+        if (!(await this.promptCleared(id)))
+            return false;
         await this.d.tmux.sendRaw(tmuxName(id), `${command}\r`);
         return true;
     }
@@ -194,10 +207,16 @@ export class Input {
         const meta = this.d.store.get().sessions[id];
         return meta?.kind === 'codex' && !meta.codexThreadId;
     }
+    // What is already typed at Claude's prompt is put aside first: pasted after it, the two would go as one.
     async paste(id, text) {
         await this.d.tmux.leaveCopyMode(tmuxName(id));
+        if (!(await this.promptCleared(id)))
+            throw new Error('what is typed at the prompt would not go aside');
         await this.d.tmux.paste(tmuxName(id), text.replace(CONTROL, ''));
     }
+    promptCleared(id) {
+        return this.d.store.get().sessions[id]?.kind === 'claude' ? this.d.claude.clearPrompt(tmuxName(id)) : Promise.resolve(true);
+    }
     async fitForChat(id) {
         if (!ID.test(id))
             throw new InvalidRequest('bad session id');