workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/journal/ingest.js

@@ -0,0 +1,151 @@
+import { sentWords } from '../agents/claude/transcript/chat.js';
+import { findTranscript, idItems, linesFrom } from '../agents/claude/transcript/transcriptFile.js';
+import { heldInTranscript } 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;
+const DERIVED = new Set(['task', 'todos', 'bg']);
+// What a paste keeps of a message (Machine.paste): no control characters but line breaks and tabs.
+const pasted = (text) => text.replace(/(?![\n\t])\p{Cc}/gu, '').trim();
+const ON_THEIR_WAY = new Set(['delivering', 'delivered', 'enqueued']);
+// The messages that went to Claude and are not known to have been taken in, oldest first.
+export const onTheirWay = (db, id) => db
+    .messages(id)
+    .filter((m) => ON_THEIR_WAY.has(m.state))
+    .sort((a, b) => a.sentAt - b.sentAt);
+// The messages a prompt in the transcript may be, oldest first: those on their way, and those not found when
+// a turn ended, which Claude may take in after it (once a slow line brings it).
+const notLanded = (db, id) => db
+    .messages(id)
+    .filter((m) => ON_THEIR_WAY.has(m.state) || m.state === 'unconfirmed')
+    .sort((a, b) => a.sentAt - b.sentAt);
+// Takes the session's conversation into the journal from where it stopped, in transactions of whole lines,
+// with what is worked out from it. True when anything was written.
+export async function ingest(db, id, conv, o) {
+    if (!conv)
+        return false;
+    const path = await findTranscript(o.root, conv);
+    if (!path)
+        return false;
+    let wrote = false;
+    let changedConv = db.session(id)?.conv !== conv;
+    const fresh = changedConv;
+    const found = {};
+    if (changedConv) {
+        db.tx(() => {
+            db.setConv(id, conv, 0);
+            db.putState(id, 'conv', { conv });
+        });
+        wrote = true;
+    }
+    for (;;) {
+        const from = db.session(id)?.convRead ?? 0;
+        const read = await linesFrom(path, from);
+        // The conversation may have changed while the file was read; the next ingest takes the new one.
+        if (db.session(id)?.conv !== conv || db.session(id)?.convRead !== from)
+            return wrote;
+        const more = read.next < read.size && read.lines.length > 0;
+        db.tx(() => {
+            let pos = db.lastPos(id, conv);
+            let derived = changedConv;
+            let items = false;
+            let queueMoved = false;
+            const waiting = notLanded(db, id);
+            for (const { at, line } of read.lines) {
+                queueMoved ||= line.includes('"queue-operation"');
+                titleIn(line, found);
+                for (const { id: itemId, item } of idItems(line, at)) {
+                    if (!db.putItem(id, conv, itemId, ++pos, item)) {
+                        pos--;
+                        continue;
+                    }
+                    items = true;
+                    if (DERIVED.has(item.k))
+                        derived = true;
+                    land(db, id, waiting, item, itemId, o.log);
+                }
+            }
+            if (derived) {
+                const all = db.itemsSince(id, conv, -1).map((r) => r.body);
+                db.putState(id, 'tasks', taskList(all));
+                db.putState(id, 'background', backgroundRunning(all));
+            }
+            if (items)
+                db.putState(id, 'live', { text: liveShown(o.live(true), db.turnTexts(id, conv)) });
+            if (queueMoved)
+                wrote = inClaudesQueue(db, id, heldInTranscript(path)) || wrote;
+            db.setConv(id, conv, read.next);
+            wrote ||= items;
+        });
+        changedConv = false;
+        if (more)
+            continue;
+        if (fresh || found.custom || found.ai)
+            o.titled?.(found, fresh);
+        return wrote;
+    }
+}
+// A record of a name the conversation was given, kept in found.
+function titleIn(line, found) {
+    if (!line.includes('-title"'))
+        return;
+    let r;
+    try {
+        r = 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;
+}
+// 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.
+export function landFound(db, id, log) {
+    const conv = db.session(id)?.conv;
+    const waiting = notLanded(db, id);
+    if (!conv || !waiting.length)
+        return;
+    const taken = new Set(db.messages(id).map((m) => m.item));
+    db.tx(() => {
+        for (const { id: itemId, body } of db.itemsSince(id, conv, -1)) {
+            if (!taken.has(itemId))
+                land(db, id, waiting, body, itemId, 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());
+    let changed = false;
+    for (const m of onTheirWay(db, id)) {
+        const i = left.indexOf(pasted(m.text));
+        if (i < 0)
+            continue;
+        left.splice(i, 1);
+        if (m.state === 'enqueued')
+            continue;
+        db.putMessage(id, { ...m, state: 'enqueued' });
+        changed = true;
+    }
+    return changed;
+}
+// The oldest message not known to be taken in whose words are the prompt's (or the command's) is it: it landed.
+function land(db, id, waiting, item, itemId, log) {
+    const words = sentWords(item);
+    if (words === null)
+        return;
+    const at = 'at' in item && item.at ? Date.parse(item.at) : NaN;
+    const text = words.trim();
+    const n = waiting.findIndex((m) => pasted(m.text) === text && !(at - m.sentAt < LANDS_AFTER_MS));
+    if (n < 0)
+        return;
+    const [m] = waiting.splice(n, 1);
+    db.putMessage(id, { ...m, state: 'landed', item: itemId });
+    log('message landed', { session: id, qid: m.id, item: itemId, was: m.state, ms: Date.now() - m.sentAt });
+}

package/dist/server/notify/apns.js

@@ -0,0 +1,126 @@
+import { createPrivateKey, sign } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { connect } from 'node:http2';
+import { join } from 'node:path';
+// Apple refuses a token older than an hour, and one renewed more often than every 20 minutes.
+const TOKEN_LIFE = 50 * 60_000;
+const ORIGINS = { production: 'https://api.push.apple.com', sandbox: 'https://api.sandbox.push.apple.com' };
+export class ApnsConfigError extends Error {
+}
+export function loadApnsKey(home) {
+    const file = join(home, 'apns.json');
+    if (!existsSync(file))
+        return null;
+    const wrong = (what) => new ApnsConfigError(`${file}: ${what}`);
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw wrong('not JSON');
+    }
+    const { teamId, keyId, keyFile } = 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)}`);
+    try {
+        return { teamId, keyId, key: createPrivateKey(readFileSync(keyFile)) };
+    }
+    catch {
+        throw wrong(`"keyFile" is not a .p8 key: ${keyFile}`);
+    }
+}
+export class Apns {
+    key;
+    post;
+    now;
+    token = null;
+    constructor(key, post = http2Post(), now = Date.now) {
+        this.key = key;
+        this.post = post;
+        this.now = now;
+    }
+    // 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) {
+        const hosts = device.host ? [device.host] : ['production', 'sandbox'];
+        const body = JSON.stringify(payload);
+        for (const host of hosts) {
+            const headers = {
+                authorization: `bearer ${this.bearer()}`,
+                'apns-topic': device.topic,
+                'apns-push-type': 'alert',
+                'apns-priority': '10',
+                'apns-expiration': String(Math.floor(this.now() / 1000) + 300),
+                'apns-collapse-id': collapseId,
+            };
+            let res;
+            try {
+                res = await this.post(host, `/3/device/${device.token}`, headers, body);
+            }
+            catch {
+                return { host: device.host, gone: false };
+            }
+            if (res.status === 200)
+                return { host, gone: false };
+            if (res.status === 410)
+                return { host, gone: true };
+            if (res.status === 403 && /ProviderToken/.test(res.reason ?? ''))
+                this.token = null;
+            if (res.reason !== 'BadDeviceToken')
+                return { host: device.host ?? host, gone: false };
+        }
+        return { gone: true };
+    }
+    bearer() {
+        const t = this.now();
+        if (this.token && t - this.token.at < TOKEN_LIFE)
+            return this.token.value;
+        const part = (o) => Buffer.from(JSON.stringify(o)).toString('base64url');
+        const unsigned = `${part({ alg: 'ES256', kid: this.key.keyId })}.${part({ iss: this.key.teamId, iat: Math.floor(t / 1000) })}`;
+        const sig = sign('sha256', Buffer.from(unsigned), { key: this.key.key, dsaEncoding: 'ieee-p1363' }).toString('base64url');
+        this.token = { value: `${unsigned}.${sig}`, at: t };
+        return this.token.value;
+    }
+}
+export function http2Post(origins = ORIGINS) {
+    const sessions = new Map();
+    const session = (host) => {
+        const open = sessions.get(host);
+        if (open && !open.closed && !open.destroyed)
+            return open;
+        const s = connect(origins[host]);
+        s.on('error', () => s.destroy());
+        s.on('close', () => sessions.get(host) === s && sessions.delete(host));
+        s.setTimeout(10 * 60_000, () => s.close());
+        s.unref();
+        sessions.set(host, s);
+        return s;
+    };
+    return (host, path, headers, body) => new Promise((resolve, reject) => {
+        const req = session(host).request({ ':method': 'POST', ':path': path, ...headers });
+        let status = 0;
+        let data = '';
+        req.setTimeout(15_000, () => req.close());
+        req.on('response', (h) => (status = Number(h[':status'])));
+        req.setEncoding('utf8');
+        req.on('data', (c) => (data += c));
+        req.on('error', reject);
+        req.on('close', () => {
+            if (!status)
+                return reject(new Error('no answer from APNs'));
+            let reason;
+            try {
+                reason = data ? JSON.parse(data).reason : undefined;
+            }
+            catch {
+                reason = undefined;
+            }
+            resolve({ status, reason });
+        });
+        req.end(body);
+    });
+}

package/dist/server/notify/push.js

@@ -0,0 +1,109 @@
+import webpush from 'web-push';
+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;
+// What Claude said, as a line of plain text: the marks of its markdown taken off, its start kept.
+export function plainLine(said) {
+    const text = said
+        .replace(/^\s*```.*$/gm, '')
+        .replace(/^\s*\|?[\s:|-]*-[\s:|-]*\|?\s*$/gm, '')
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/^\s{0,3}(?:#{1,6}\s+|>\s?|[-*+]\s+)/gm, '')
+        .replace(/\*\*|__|`|~~/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const chars = Array.from(text);
+    return chars.length > SAID_MAX ? `${chars.slice(0, SAID_MAX - 1).join('')}…` : text;
+}
+export class Pusher {
+    store;
+    send;
+    now;
+    subject;
+    apns;
+    lastSent = new Map();
+    visible = new Map();
+    constructor(store, opts) {
+        this.store = store;
+        this.send = opts.send ?? ((sub, payload, o) => webpush.sendNotification(sub, payload, o));
+        this.now = opts.now ?? Date.now;
+        this.subject = opts.subject;
+        this.apns = opts.apns;
+    }
+    // Whether the iPhone app can be sent notifications from here.
+    get toPhones() {
+        return !!this.apns;
+    }
+    setVisible(sessionId, connId, isVisible) {
+        const conns = this.visible.get(sessionId) ?? new Set();
+        if (isVisible)
+            conns.add(connId);
+        else
+            conns.delete(connId);
+        if (conns.size)
+            this.visible.set(sessionId, conns);
+        else
+            this.visible.delete(sessionId);
+    }
+    async notify(sessionId, title, event, said) {
+        const { vapid, pushSubs, apnsDevices } = this.store.get();
+        const browsers = vapid ? pushSubs : [];
+        const phones = this.apns ? apnsDevices : [];
+        if ((!browsers.length && !phones.length) || this.visible.has(sessionId))
+            return;
+        const t = this.now();
+        if (t - (this.lastSent.get(sessionId) ?? -Infinity) < COOLDOWN)
+            return;
+        this.lastSent.set(sessionId, t);
+        const line = plainLine(said);
+        await Promise.all([this.toBrowsers(browsers, sessionId, title, event, line), this.toApp(phones, sessionId, title, event, line)]);
+    }
+    async toBrowsers(subs, sessionId, title, event, said) {
+        const vapid = this.store.get().vapid;
+        if (!subs.length || !vapid)
+            return;
+        const payload = JSON.stringify({ title, event, said, url: `/m/local/s/${sessionId}`, tag: sessionId });
+        const opts = {
+            vapidDetails: { subject: this.subject, publicKey: vapid.publicKey, privateKey: vapid.privateKey },
+            TTL: 300,
+            urgency: 'high',
+        };
+        const gone = [];
+        await Promise.all(subs.map(async (sub) => {
+            try {
+                await this.send(sub, payload, opts);
+            }
+            catch (e) {
+                const status = e?.statusCode;
+                if (status === 404 || status === 410)
+                    gone.push(sub.endpoint);
+            }
+        }));
+        if (gone.length) {
+            this.store.update((s) => {
+                s.pushSubs = s.pushSubs.filter((x) => !gone.includes(x.endpoint));
+            });
+        }
+    }
+    async toApp(devices, sessionId, title, event, said) {
+        const apns = this.apns;
+        if (!devices.length || !apns)
+            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 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]));
+        if (!gone.size && [...learned].every(([token, host]) => known.get(token) === host))
+            return;
+        this.store.update((s) => {
+            s.apnsDevices = s.apnsDevices.filter((d) => !gone.has(d.token)).map((d) => (learned.has(d.token) ? { ...d, host: learned.get(d.token) } : d));
+        });
+    }
+}
+// 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.
+function alertOf(title, words, event, said) {
+    if (!said)
+        return { title, body: words };
+    return event === 'waiting' ? { title, subtitle: words, body: said } : { title, body: said };
+}

package/dist/server/ops/awake.js

@@ -0,0 +1,10 @@
+// A Mac that idle-sleeps takes its sessions off the phone. caffeinate -i holds off idle sleep only (the
+// display still sleeps, a closed lid still sleeps the Mac), and -w ends it with the process it watches.
+export function keepAwake(o) {
+    if (!o.enabled || o.platform !== 'darwin')
+        return undefined;
+    const child = o.spawn('caffeinate', ['-i', '-w', String(o.pid)], { stdio: 'ignore' });
+    child.on('error', (err) => o.log('caffeinate did not start; the Mac may idle-sleep', err));
+    child.unref();
+    return child;
+}

package/dist/server/ops/build.js

@@ -0,0 +1,40 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Which source a dist was built from. The build writes it last, into a dist it emptied first, so a build
+// that failed leaves no stamp, and one left over from another version names that version.
+export const BUILD_STAMP = 'dist/build.json';
+export function writeBuildStamp(root, stamp) {
+    writeFileSync(join(root, BUILD_STAMP), JSON.stringify(stamp));
+}
+export function readBuildStamp(root) {
+    try {
+        const s = JSON.parse(readFileSync(join(root, BUILD_STAMP), 'utf8'));
+        if (typeof s?.version !== 'string')
+            return null;
+        return { version: s.version, commit: typeof s.commit === 'string' ? s.commit : null, dirty: s.dirty === true };
+    }
+    catch {
+        return null;
+    }
+}
+const versionIn = (root) => String(JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version);
+// The build's last step. A tree that cannot say it is clean counts as having changes.
+export function stampBuild(root) {
+    const version = versionIn(root);
+    const git = (...args) => {
+        const r = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+        return r.status === 0 ? r.stdout.trim() : null;
+    };
+    const commit = git('rev-parse', 'HEAD');
+    const stamp = { version, commit, dirty: commit !== null && git('status', '--porcelain') !== '' };
+    writeBuildStamp(root, stamp);
+    return stamp;
+}
+// A dist that was not built for the version its package.json names, which deploy and pack refuse: one
+// left over from another version, or from a build that did not finish.
+export function staleBuild(root) {
+    const version = versionIn(root);
+    const built = readBuildStamp(root)?.version ?? null;
+    return built === version ? null : { version, built };
+}

package/dist/server/ops/doctor.js

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApnsConfigError, loadApnsKey } from '../notify/apns.js';
+import { ConfigError, loadConfig } from '../system/config.js';
+import { MIN_NODE, nodeTooOld } from '../system/node.js';
+import { m } from '../system/messages.js';
+import { Store } from '../system/store.js';
+const MIN_TMUX = [3, 3];
+const LOCAL = /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/;
+const pass = (id, detail) => ({ id, ok: true, detail });
+const fail = (id, detail, fix) => ({ id, ok: false, detail, fix });
+function tmuxCheck(r, d) {
+    if (!r.ok)
+        return fail('tmux', d.notFound, d.tmuxFix);
+    const v = /^tmux (?:next-)?(\d+)\.(\d+)/.exec(r.out.trim());
+    const version = r.out.trim().replace(/^tmux /, '');
+    if (!v)
+        return fail('tmux', d.unknownVersion(version), d.tmuxFix);
+    const [major, minor] = [Number(v[1]), Number(v[2])];
+    if (major < MIN_TMUX[0] || (major === MIN_TMUX[0] && minor < MIN_TMUX[1]))
+        return fail('tmux', d.tooOld(version, MIN_TMUX.join('.')), d.tmuxFix);
+    return pass('tmux', version);
+}
+function setupCheck(home, doc) {
+    if (!existsSync(join(home, 'config.json')))
+        return { check: fail('setup', doc.notSetUp(home), doc.setupFix) };
+    let config;
+    try {
+        config = loadConfig(home);
+    }
+    catch (e) {
+        if (e instanceof ConfigError)
+            return { check: fail('setup', e.message, doc.setupFix) };
+        throw e;
+    }
+    let user;
+    try {
+        user = new Store(join(home, 'state.json')).get().user?.username;
+    }
+    catch (e) {
+        return { check: fail('setup', e.message, doc.setupFix), config };
+    }
+    return { check: user ? pass('setup', doc.setUp(user, config.origin)) : fail('setup', doc.noUser, doc.setupFix), config };
+}
+// How to get a service that does not answer going, from what launchd has of it.
+async function startFix(d, doc, label) {
+    const plist = join(d.launchAgents, `${label}.plist`);
+    if (!existsSync(plist))
+        return doc.installFix;
+    if (!(await d.run('launchctl', ['list', label])).ok)
+        return doc.bootstrapFix(plist);
+    return doc.kickstartFix(label, join(d.home, 'logs', 'server.log'));
+}
+async function serviceChecks(d, doc, config) {
+    const local = `http://127.0.0.1:${config.port}`;
+    const service = await d.fetch(`${local}/healthz`);
+    const checks = [
+        !service.ok
+            ? fail('service', doc.notAnswering(local), await startFix(d, doc, config.serviceLabel))
+            : service.version && service.version !== d.version
+                ? 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)));
+    }
+    return checks;
+}
+function apnsCheck(home, doc) {
+    try {
+        const key = loadApnsKey(home);
+        return pass('apns', key ? doc.apnsKey(key.keyId) : doc.noApns);
+    }
+    catch (e) {
+        if (e instanceof ApnsConfigError)
+            return fail('apns', e.message, doc.apnsFix(join(home, 'apns.json')));
+        throw e;
+    }
+}
+export async function runDoctor(d) {
+    const doc = (d.messages ?? m).doctor;
+    const [tmux, claude, codex] = await Promise.all([
+        d.run('tmux', ['-V']),
+        d.run(d.claudeBin, ['--version']),
+        d.codexBin ? d.run(d.codexBin, ['--version']) : Promise.resolve(null),
+    ]);
+    const { check: setup, config } = setupCheck(d.home, doc);
+    return [
+        d.platform === 'darwin' ? pass('macos', d.platform) : fail('macos', d.platform, doc.macosOnly),
+        nodeTooOld(d.nodeVersion) ? fail('node', doc.tooOld(d.nodeVersion, MIN_NODE.join('.')), doc.nodeFix(MIN_NODE.join('.'))) : pass('node', d.nodeVersion),
+        tmuxCheck(tmux, doc),
+        claude.ok ? pass('claude', claude.out.trim()) : fail('claude', doc.notFound, doc.claudeFix),
+        pass('codex', codex?.ok ? codex.out.trim() : doc.noCodex),
+        setup,
+        // Without a config there is no port or address to ask.
+        ...(config ? await serviceChecks(d, doc, config) : []),
+        ...(config ? [config.preventSleep ? pass('sleep', doc.awake) : fail('sleep', doc.sleepsOff, doc.sleepFix(join(d.home, 'config.json')))] : []),
+        apnsCheck(d.home, doc),
+    ];
+}
+const WIDTH = 8;
+export function formatChecks(checks) {
+    return checks
+        .map((c) => `${c.ok ? '✓' : '✗'} ${c.id.padEnd(WIDTH)}${c.detail}${c.fix ? `\n${' '.repeat(2 + WIDTH)}${c.fix}` : ''}`)
+        .join('\n');
+}

package/dist/server/ops/lastOp.js

@@ -0,0 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeJsonAtomic } from '../system/paths.js';
+const fileOf = (home) => join(home, 'ops.json');
+export function readLastOp(home) {
+    try {
+        const r = JSON.parse(readFileSync(fileOf(home), 'utf8'));
+        return typeof r?.op === 'string' && typeof r.pid === 'number' ? r : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const pidAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+};
+export function opRunning(home, alive = pidAlive) {
+    const last = readLastOp(home);
+    return !!last && last.finishedAt === undefined && alive(last.pid);
+}
+export function beginOp(home, op, pid, now = Date.now()) {
+    writeJsonAtomic(fileOf(home), { op, pid, startedAt: now });
+}
+export function endOp(home, outcome, now = Date.now()) {
+    const last = readLastOp(home);
+    if (last)
+        writeJsonAtomic(fileOf(home), { ...last, finishedAt: now, ...outcome });
+}

package/dist/server/ops/problems.js

@@ -0,0 +1,54 @@
+import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+export const DETAIL_MAX = 4096;
+// Enough of the end of a file for any number of problems shown, without reading 10 MB each time.
+const TAIL_BYTES = 2 * 1024 * 1024;
+const LEVELS = { 40: 'warn', 50: 'error', 60: 'fatal' };
+function tail(file) {
+    let fd;
+    try {
+        fd = openSync(file, 'r');
+    }
+    catch {
+        return '';
+    }
+    try {
+        const size = fstatSync(fd).size;
+        const length = Math.min(size, TAIL_BYTES);
+        const buf = Buffer.alloc(length);
+        readSync(fd, buf, 0, length, size - length);
+        const text = buf.toString('utf8');
+        // A tail that starts mid-line drops that line.
+        return length < size ? text.slice(text.indexOf('\n') + 1) : text;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function parse(text) {
+    let line;
+    try {
+        line = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const { level, time, msg, pid: _pid, hostname: _host, ...rest } = line ?? {};
+    const named = typeof level === 'number' ? LEVELS[Math.min(60, Math.floor(level / 10) * 10)] : undefined;
+    if (!named || typeof time !== 'number')
+        return null;
+    return { at: new Date(time).toISOString(), level: named, msg: typeof msg === 'string' ? msg : '', detail: JSON.stringify(rest).slice(0, DETAIL_MAX) };
+}
+export function recentProblems(logFile, limit = 50) {
+    const found = [];
+    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--) {
+            const p = lines[i] && parse(lines[i]);
+            if (p)
+                found.push(p);
+        }
+        if (found.length >= limit)
+            break;
+    }
+    return found;
+}