workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/http/app.js

@@ -0,0 +1,144 @@
+import { appendFileSync } from 'node:fs';
+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 { DomainError, errorReply } from '../system/errors.js';
+import { EventHub } from '../sessions/events.js';
+import { register as appUpdate } from './routes/appUpdate.js';
+import { register as auth } from './routes/auth.js';
+import { register as chat } from './routes/chat.js';
+import { register as claude } from './routes/claude.js';
+import { register as codex } from './routes/codex.js';
+import { register as health } from './routes/health.js';
+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 sessions } from './routes/sessions.js';
+import { register as web } from './routes/web.js';
+import { VERSION } from '../system/version.js';
+const CSP = [
+    "default-src 'self'",
+    "connect-src 'self' wss: ws:",
+    "img-src 'self' data:",
+    "style-src 'self' 'unsafe-inline'",
+    "frame-ancestors 'none'",
+    "base-uri 'none'",
+    "form-action 'self'",
+].join('; ');
+export async function buildApp(deps) {
+    const { store, machine, origin } = deps;
+    const now = deps.now ?? Date.now;
+    const app = Fastify({
+        trustProxy: false,
+        bodyLimit: 64 * 1024,
+        loggerInstance: deps.logger,
+        logController: new LogController({ disableRequestLogging: true }),
+    });
+    app.setErrorHandler((e, req, reply) => {
+        // fastify's own errors (a body that is not JSON, or too large) carry a status below 500.
+        const own = e;
+        if (!(e instanceof DomainError) && own.statusCode && own.statusCode < 500)
+            return reply.code(own.statusCode).send({ error: own.message });
+        const { status, body } = errorReply(e);
+        if (status >= 500)
+            req.log.error({ err: e }, 'request failed');
+        return reply.code(status).send(body);
+    });
+    const logins = new LoginSessions(store, now);
+    const guard = new Guard(logins, origin);
+    const secure = origin.startsWith('https://');
+    const hub = new EventHub(machine, async (s) => {
+        if (s.kind === 'codex')
+            return machine.lastReply(s.id);
+        const path = s.claudeSessionId && deps.claudeProjectsRoot ? await findTranscript(deps.claudeProjectsRoot, s.claudeSessionId) : null;
+        return path ? lastReply(path) : null;
+    });
+    const audit = (req, method, ok) => {
+        const line = { t: new Date(now()).toISOString(), ip: clientIp(req), ua: req.headers['user-agent'] ?? '', method, ok };
+        appendFileSync(deps.auditPath, `${JSON.stringify(line)}\n`, { mode: 0o600 });
+    };
+    const createLogin = (req, method) => logins.create(String(req.headers['user-agent'] ?? ''), method);
+    const startLogin = (req, reply, method) => {
+        reply.header('set-cookie', sessionCookie(createLogin(req, method), secure));
+    };
+    // An open socket lives only as long as the login it was opened with.
+    const sockets = new Map();
+    const dropRevokedSockets = () => {
+        for (const [socket, loginId] of sockets)
+            if (!logins.validate(loginId))
+                socket.close(4401, 'login ended');
+    };
+    const sweep = setInterval(dropRevokedSockets, 2000);
+    const admit = (socket, req) => {
+        const code = guard.wsRejectCode(req);
+        if (code) {
+            socket.close(code);
+            return false;
+        }
+        sockets.set(socket, guard.currentLogin(req).loginId);
+        socket.on('close', () => sockets.delete(socket));
+        return true;
+    };
+    await app.register(fastifyWebsocket, {
+        options: { maxPayload: 1 << 20 },
+        // On shutdown every socket is told 4012, "restarting", so the phone comes back soon instead of
+        // taking it for a dropped line. Not the standard 1012: Safari reports that one as 1005.
+        preClose: (done) => {
+            for (const socket of app.websocketServer.clients)
+                socket.close(4012, 'restarting');
+            app.websocketServer.close(done);
+        },
+    });
+    app.addHook('onSend', async (req, reply, payload) => {
+        reply.header('content-security-policy', CSP);
+        reply.header('x-frame-options', 'DENY');
+        reply.header('x-content-type-options', 'nosniff');
+        reply.header('referrer-policy', 'no-referrer');
+        reply.header('x-workoffdesk-version', VERSION);
+        if (req.routeOptions.url?.startsWith('/api/') && !reply.hasHeader('cache-control'))
+            reply.header('cache-control', 'no-store');
+        return payload;
+    });
+    // Only what someone would look for: a request that failed or took long, and every write, whose arrival is
+    // logged too, so one that never answers still shows. The route, not the URL, so nothing in a query string
+    // reaches the log.
+    app.addHook('onRequest', async (req) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD')
+            req.log.info({ method: req.method, url: req.routeOptions.url ?? '(no route)' }, 'write arrived');
+    });
+    app.addHook('onResponse', async (req, reply) => {
+        const ms = Math.round(reply.elapsedTime);
+        if (reply.statusCode < 400 && ms <= 1000 && (req.method === 'GET' || req.method === 'HEAD'))
+            return;
+        req.log.info({ method: req.method, url: req.routeOptions.url ?? '(no route)', status: reply.statusCode, ms }, 'request');
+    });
+    app.addHook('onClose', async () => {
+        clearInterval(sweep);
+        hub.close();
+    });
+    // Every matched route requires a login unless it opts out with `config: { public: true }`.
+    // The decision reads the matched route, never the raw URL, which the router decodes first,
+    // and comes before the body is read. WebSocket routes answer with close codes instead (see Guard.wsRejectCode).
+    app.addHook('onRequest', async (req, reply) => {
+        if (req.ws || req.is404 || req.routeOptions.config.public)
+            return;
+        if (!guard.check(req, reply))
+            return reply;
+    });
+    const machineOr404 = (req, reply) => {
+        if (req.params.machine === machine.id)
+            return machine;
+        reply.code(404).send({ error: 'unknown machine' });
+        return null;
+    };
+    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.extend)
+        await deps.extend(app, ctx);
+    await web(app, ctx);
+    return { app, ctx };
+}

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

@@ -0,0 +1,78 @@
+import { createHash } from 'node:crypto';
+export const COOKIE = 'wod_session';
+const BEARER = /^Bearer (\S+)$/i;
+const MAX_AGE_SEC = 30 * 24 * 60 * 60;
+export function parseCookies(header) {
+    const out = {};
+    for (const part of (header ?? '').split(';')) {
+        const i = part.indexOf('=');
+        if (i > 0)
+            out[part.slice(0, i).trim()] = part.slice(i + 1).trim();
+    }
+    return out;
+}
+export function sessionCookie(id, secure) {
+    return [`${COOKIE}=${id}`, 'HttpOnly', 'SameSite=Strict', 'Path=/', `Max-Age=${MAX_AGE_SEC}`, ...(secure ? ['Secure'] : [])].join('; ');
+}
+export function clearedCookie(secure) {
+    return [`${COOKIE}=`, 'HttpOnly', 'SameSite=Strict', 'Path=/', 'Max-Age=0', ...(secure ? ['Secure'] : [])].join('; ');
+}
+export function loginHandle(id) {
+    return createHash('sha256').update(id).digest('base64url').slice(0, 16);
+}
+export function clientIp(req) {
+    const cf = req.headers['cf-connecting-ip'];
+    return (Array.isArray(cf) ? cf[0] : cf) || req.ip;
+}
+export class Guard {
+    logins;
+    origin;
+    constructor(logins, origin) {
+        this.logins = logins;
+        this.origin = origin;
+    }
+    originOk(req) {
+        return req.headers.origin === this.origin;
+    }
+    // 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
+    // the header is sent the cookie is not looked at, so a made-up header cannot carry a real cookie past
+    // the Origin check.
+    credential(req) {
+        const auth = req.headers.authorization;
+        if (auth !== undefined)
+            return { id: BEARER.exec(auth)?.[1] ?? '', byCookie: false };
+        const id = parseCookies(req.headers.cookie)[COOKIE];
+        return id ? { id, byCookie: true } : null;
+    }
+    // Whether another site could have had a browser make this request: only by riding on the cookie.
+    crossSiteSafe(req) {
+        return this.credential(req)?.byCookie === false || this.originOk(req);
+    }
+    currentLogin(req) {
+        const c = this.credential(req);
+        const login = c?.id ? this.logins.validate(c.id) : null;
+        return login ? { ...login, loginId: c.id } : null;
+    }
+    // Returns true when the request may proceed; otherwise it has already replied.
+    check(req, reply) {
+        if (req.method !== 'GET' && req.method !== 'HEAD' && !this.crossSiteSafe(req)) {
+            reply.code(403).send({ error: 'bad origin' });
+            return false;
+        }
+        if (!this.currentLogin(req)) {
+            reply.code(401).send({ error: 'login required' });
+            return false;
+        }
+        return true;
+    }
+    // WebSocket handshakes cannot surface an HTTP status to the browser, so the
+    // verdict is delivered as a close code after the upgrade completes.
+    wsRejectCode(req) {
+        if (!this.crossSiteSafe(req))
+            return 4403;
+        if (!this.currentLogin(req))
+            return 4401;
+        return null;
+    }
+}

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

@@ -0,0 +1,41 @@
+const MIN = 60_000;
+const IP_WINDOW = 15 * MIN;
+const IP_MAX_FAILURES = 5;
+const IP_LOCK = 15 * MIN;
+const GLOBAL_WINDOW = 60 * MIN;
+const GLOBAL_MAX_FAILURES = 20;
+const GLOBAL_LOCK = 60 * MIN;
+export class Lockout {
+    now;
+    failures = new Map();
+    lockedUntil = new Map();
+    globalFailures = [];
+    globalLockedUntil = 0;
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    check(ip) {
+        const t = this.now();
+        const until = Math.max(this.lockedUntil.get(ip) ?? 0, this.globalLockedUntil);
+        return until > t ? { ok: false, retryAfterSec: Math.ceil((until - t) / 1000) } : { ok: true };
+    }
+    fail(ip) {
+        const t = this.now();
+        const recent = (this.failures.get(ip) ?? []).filter((x) => t - x < IP_WINDOW);
+        recent.push(t);
+        this.failures.set(ip, recent);
+        if (recent.length >= IP_MAX_FAILURES) {
+            this.lockedUntil.set(ip, t + IP_LOCK);
+            this.failures.delete(ip);
+        }
+        this.globalFailures = this.globalFailures.filter((x) => t - x < GLOBAL_WINDOW);
+        this.globalFailures.push(t);
+        if (this.globalFailures.length >= GLOBAL_MAX_FAILURES) {
+            this.globalLockedUntil = t + GLOBAL_LOCK;
+            this.globalFailures = [];
+        }
+    }
+    succeed(ip) {
+        this.failures.delete(ip);
+    }
+}

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

@@ -0,0 +1,151 @@
+import { generateAuthenticationOptions, generateRegistrationOptions, verifyAuthenticationResponse, verifyRegistrationResponse, } from '@simplewebauthn/server';
+const CHALLENGE_TTL = 5 * 60_000;
+const MAX_CHALLENGES = 100;
+export class ChallengeStore {
+    now;
+    items = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    add(challenge, purpose) {
+        this.items.set(challenge, { purpose, expires: this.now() + CHALLENGE_TTL });
+        while (this.items.size > MAX_CHALLENGES)
+            this.items.delete(this.items.keys().next().value);
+    }
+    // Any presentation burns the challenge, even a mismatched one.
+    consume(challenge, purpose) {
+        const item = this.items.get(challenge);
+        this.items.delete(challenge);
+        return !!item && item.purpose === purpose && item.expires >= this.now();
+    }
+}
+const PUBLIC = { config: { public: true } };
+function deviceName(ua) {
+    if (/iPhone/.test(ua))
+        return 'iPhone';
+    if (/iPad/.test(ua))
+        return 'iPad';
+    if (/Android/.test(ua))
+        return 'Android';
+    if (/Macintosh/.test(ua))
+        return 'Mac';
+    return 'Device';
+}
+export function registerPasskeyRoutes(app, ctx, deps) {
+    const { store, origin, rpId } = 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 () => {
+        const user = store.get().user;
+        const options = await generateRegistrationOptions({
+            rpName: 'WorkOffDesk',
+            rpID: rpId,
+            userName: user.username,
+            userID: Uint8Array.from(Buffer.from(user.username)),
+            attestationType: 'none',
+            excludeCredentials: store.get().passkeys.map((p) => ({
+                id: p.id,
+                transports: p.transports,
+            })),
+            authenticatorSelection: { residentKey: 'required', userVerification: 'required' },
+        });
+        challenges.add(options.challenge, 'register');
+        return options;
+    });
+    app.post('/api/auth/passkey/register/verify', async (req, reply) => {
+        const response = req.body?.response;
+        if (!response)
+            return reply.code(400).send({ error: 'registration failed' });
+        let result;
+        try {
+            result = await verifyRegistrationResponse({
+                response,
+                expectedChallenge: expect('register'),
+                expectedOrigin: origin,
+                expectedRPID: rpId,
+                requireUserVerification: true,
+            });
+        }
+        catch {
+            return reply.code(400).send({ error: 'registration failed' });
+        }
+        if (!result.verified || !result.registrationInfo)
+            return reply.code(400).send({ error: 'registration failed' });
+        const { credential } = result.registrationInfo;
+        const name = typeof req.body?.name === 'string' && req.body.name.trim()
+            ? req.body.name.trim().slice(0, 40)
+            : deviceName(String(req.headers['user-agent'] ?? ''));
+        const passkey = {
+            id: credential.id,
+            publicKey: Buffer.from(credential.publicKey).toString('base64url'),
+            counter: credential.counter,
+            transports: credential.transports,
+            name,
+            createdAt: now(),
+        };
+        store.update((s) => {
+            s.passkeys = [...s.passkeys.filter((p) => p.id !== passkey.id), passkey];
+        });
+        return reply.code(201).send({ id: passkey.id, name: passkey.name });
+    });
+    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' });
+        challenges.add(options.challenge, 'login');
+        return options;
+    });
+    app.post('/api/auth/passkey/login/verify', PUBLIC, async (req, reply) => {
+        if (!ctx.guard.originOk(req))
+            return reply.code(403).send({ error: 'bad origin' });
+        const response = req.body?.response;
+        const passkey = store.get().passkeys.find((p) => p.id === response?.id);
+        const fail = () => {
+            ctx.audit(req, 'passkey', false);
+            return reply.code(401).send({ error: 'passkey not accepted' });
+        };
+        if (!passkey || !response)
+            return fail();
+        let result;
+        try {
+            result = await verifyAuthenticationResponse({
+                response,
+                expectedChallenge: expect('login'),
+                expectedOrigin: origin,
+                expectedRPID: rpId,
+                requireUserVerification: true,
+                credential: {
+                    id: passkey.id,
+                    publicKey: Uint8Array.from(Buffer.from(passkey.publicKey, 'base64url')),
+                    counter: passkey.counter,
+                    transports: passkey.transports,
+                },
+            });
+        }
+        catch {
+            return fail();
+        }
+        if (!result.verified)
+            return fail();
+        store.update((s) => {
+            const p = s.passkeys.find((x) => x.id === passkey.id);
+            if (p) {
+                p.counter = result.authenticationInfo.newCounter;
+                p.lastUsedAt = now();
+            }
+        });
+        ctx.audit(req, 'passkey', true);
+        ctx.startLogin(req, reply, 'passkey');
+        return reply.code(204).send();
+    });
+    app.get('/api/auth/passkeys', async () => store.get().passkeys.map((p) => ({ id: p.id, name: p.name, createdAt: p.createdAt, lastUsedAt: p.lastUsedAt ?? null })));
+    app.delete('/api/auth/passkeys/:id', async (req, reply) => {
+        if (!store.get().passkeys.some((p) => p.id === req.params.id))
+            return reply.code(404).send({ error: 'not found' });
+        store.update((s) => {
+            s.passkeys = s.passkeys.filter((p) => p.id !== req.params.id);
+        });
+        return reply.code(204).send();
+    });
+}

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

@@ -0,0 +1,23 @@
+import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
+const N = 2 ** 15;
+const R = 8;
+const P = 1;
+const KEYLEN = 64;
+// In characters, not bytes.
+export const MIN_PASSWORD = 12;
+function derive(pw, salt, opts) {
+    return new Promise((resolve, reject) => scrypt(pw, salt, KEYLEN, { ...opts, maxmem: 256 * N * R }, (err, key) => err ? reject(err) : resolve(key)));
+}
+export async function hashPassword(pw) {
+    const salt = randomBytes(16);
+    const key = await derive(pw, salt, { N, r: R, p: P });
+    return ['scrypt', N, R, P, salt.toString('base64'), key.toString('base64')].join('$');
+}
+export async function verifyPassword(pw, stored) {
+    const [alg, n, r, p, salt, hash] = stored.split('$');
+    if (alg !== 'scrypt' || !salt || !hash)
+        return false;
+    const expected = Buffer.from(hash, 'base64');
+    const key = await derive(pw, Buffer.from(salt, 'base64'), { N: +n, r: +r, p: +p });
+    return key.length === expected.length && timingSafeEqual(key, expected);
+}

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

@@ -0,0 +1,46 @@
+import { randomBytes } from 'node:crypto';
+const TTL = 30 * 24 * 60 * 60_000;
+const TOUCH_INTERVAL = 60_000;
+export class LoginSessions {
+    store;
+    now;
+    constructor(store, now = Date.now) {
+        this.store = store;
+        this.now = now;
+    }
+    create(ua, method) {
+        const id = randomBytes(32).toString('base64url');
+        const t = this.now();
+        this.store.update((s) => {
+            s.logins.push({ id, createdAt: t, lastSeen: t, ua, method });
+        });
+        return id;
+    }
+    validate(id) {
+        const t = this.now();
+        const login = this.store.get().logins.find((l) => l.id === id);
+        if (!login)
+            return null;
+        if (t - login.lastSeen > TTL) {
+            this.revoke(id);
+            return null;
+        }
+        if (t - login.lastSeen >= TOUCH_INTERVAL) {
+            this.store.update((s) => {
+                const l = s.logins.find((x) => x.id === id);
+                if (l)
+                    l.lastSeen = t;
+            });
+        }
+        return this.store.get().logins.find((l) => l.id === id) ?? null;
+    }
+    revoke(id) {
+        this.store.update((s) => {
+            s.logins = s.logins.filter((l) => l.id !== id);
+        });
+    }
+    list() {
+        const t = this.now();
+        return this.store.get().logins.filter((l) => t - l.lastSeen <= TTL);
+    }
+}

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

@@ -0,0 +1,97 @@
+import { readFileSync } from 'node:fs';
+import { loadAppUpdate, manifestOf, updateId } from '../../ios-update/appUpdate.js';
+import { bundlePatcher, keepBundle } from '../../ios-update/bundlePatch.js';
+import { PUBLIC } from './context.js';
+// The iPhone app's JS over the expo-updates protocol (v1, JSON form): the update this build carries, for
+// the native runtime it was built for, and nothing else. Public: the app keeps the headers it fetched an
+// update with next to the update, outside the Keychain, so a token has no place here; and the bundle is
+// the same one the npm package and the binary hold.
+const HOST = /^(?:[a-z0-9.-]+|\[[0-9a-f:.]+\])(?::\d{1,5})?$/i;
+// The server's own rule for its address: https, unless it is this machine (config.ts).
+const LOCAL_HOST = /^(?:localhost|127\.0\.0\.1)(?::\d+)?$/;
+const FILES_PATH = '/api/app-update/assets';
+const PROTOCOL = { 'expo-protocol-version': '1', 'expo-sfv-version': '0' };
+// When this release became current, which orders it after whatever the phones ran before, a rollback included.
+function activatedAt(file) {
+    if (!file)
+        return null;
+    try {
+        // An invalid date throws here too.
+        return new Date(readFileSync(file, 'utf8').trim()).toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+export const register = (app, ctx) => {
+    const where = ctx.deps.appUpdate;
+    let served = null;
+    try {
+        served = where ? loadAppUpdate(where.dir) : null;
+        if (!served)
+            app.log.info('no app update in this build');
+    }
+    catch (err) {
+        app.log.error({ err }, 'app update in this build is unusable');
+    }
+    const createdAt = served ? (activatedAt(where?.activatedFile) ?? served.build.builtAt) : '';
+    const currentId = served ? updateId(served.build.runtimeVersion, served.build.launchAsset.hash, createdAt) : '';
+    const reportedFailed = new Set();
+    const bundle = served?.files.get(served.build.launchAsset.file);
+    let patchFrom = null;
+    if (bundle && where?.bundlesDir) {
+        try {
+            keepBundle(where.bundlesDir, currentId, bundle.bytes);
+            patchFrom = bundlePatcher(where.bundlesDir, bundle.bytes);
+        }
+        catch (err) {
+            app.log.error({ err }, 'cannot keep this app update for patches');
+        }
+    }
+    app.get('/api/app-update/manifest', PUBLIC, async (req, reply) => {
+        const header = (name) => {
+            const v = req.headers[name];
+            return typeof v === 'string' ? v : '';
+        };
+        if (header('expo-protocol-version') !== '1')
+            return reply.code(400).send({ error: 'expo-protocol-version 1 only' });
+        const runtime = header('expo-runtime-version');
+        if (!runtime)
+            return reply.code(400).send({ error: 'expo-runtime-version is required' });
+        const failed = [...header('expo-recent-failed-update-ids').matchAll(/"([^"]*)"/g)].map((m) => m[1].toLowerCase());
+        if (currentId && failed.includes(currentId) && !reportedFailed.has(currentId)) {
+            reportedFailed.add(currentId);
+            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');
+        if (!served || header('expo-platform') !== 'ios' || runtime !== served.build.runtimeVersion) {
+            checked(null);
+            return reply.code(204).headers(PROTOCOL).send();
+        }
+        const host = header('host');
+        if (!HOST.test(host))
+            return reply.code(400).send({ error: 'bad host' });
+        const filesBase = `${LOCAL_HOST.test(host) ? 'http' : 'https'}://${host}${FILES_PATH}`;
+        checked(currentId);
+        return reply.headers(PROTOCOL).send(manifestOf(served.build, createdAt, filesBase));
+    });
+    app.get(`${FILES_PATH}/:file`, PUBLIC, async (req, reply) => {
+        const file = served?.files.get(req.params.file);
+        if (!file)
+            return reply.code(404).send({ error: 'not found' });
+        const base = req.headers['expo-current-update-id'];
+        if (patchFrom && file === bundle && typeof base === 'string' && base !== currentId && /\bbsdiff\b/i.test(String(req.headers['a-im'] ?? ''))) {
+            const patch = await patchFrom(base).catch((err) => {
+                req.log.error({ err, base }, 'app update patch failed');
+                return null;
+            });
+            if (patch) {
+                req.log.info({ base, bytes: patch.length }, 'app update sent as a patch');
+                // The same URL answers with the whole bundle to anyone else, so no cache may keep this.
+                return reply.code(226).type('application/octet-stream').headers({ im: 'bsdiff', 'expo-base-update-id': base.toLowerCase(), 'cache-control': 'no-store', vary: 'A-IM, Expo-Current-Update-ID' }).send(patch);
+            }
+        }
+        return reply.type(file.contentType).header('cache-control', 'public, max-age=31536000, immutable').send(file.bytes);
+    });
+};

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

@@ -0,0 +1,79 @@
+import { clientIp, clearedCookie, loginHandle } from '../auth/guard.js';
+import { Lockout } from '../auth/lockout.js';
+import { verifyPassword } from '../auth/password.js';
+import { PUBLIC } from './context.js';
+// A fixed hash keeps the wrong-username path as slow as the wrong-password path.
+const DUMMY_HASH = 'scrypt$32768$8$1$AAAAAAAAAAAAAAAAAAAAAA==$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==';
+// Signing in with the password, signing out, and the devices signed in.
+export const register = (app, ctx) => {
+    const { deps, guard, logins, audit, createLogin, startLogin, secure, now, dropRevokedSockets } = ctx;
+    const { store } = deps;
+    const lockout = new Lockout(now);
+    // One check at a time, so lockout counts every attempt before the next one starts.
+    let passwordTurn = Promise.resolve();
+    const oneAtATime = (fn) => {
+        const run = passwordTurn.then(fn);
+        passwordTurn = run.then(() => undefined, () => undefined);
+        return run;
+    };
+    app.post('/api/auth/password', PUBLIC, async (req, reply) => {
+        if (!guard.originOk(req))
+            return reply.code(403).send({ error: 'bad origin' });
+        return oneAtATime(() => passwordLogin(req, reply, () => {
+            startLogin(req, reply, 'password');
+            return reply.code(204).send();
+        }));
+    });
+    // The app's sign-in: the login comes back as a token for it to send in a header. No cookie is set, so
+    // there is nothing another site could ride on, and no Origin to check.
+    app.post('/api/auth/token', PUBLIC, async (req, reply) => oneAtATime(() => passwordLogin(req, reply, () => reply.send({ token: createLogin(req, 'password') }))));
+    const passwordLogin = async (req, reply, signIn) => {
+        const ip = clientIp(req);
+        const lock = lockout.check(ip);
+        if (!lock.ok) {
+            audit(req, 'password', false);
+            return reply.code(429).header('retry-after', String(lock.retryAfterSec)).send({ error: 'locked' });
+        }
+        const { username, password } = req.body ?? {};
+        const user = store.get().user;
+        const nameOk = !!user && typeof username === 'string' && username === user.username;
+        const pwOk = await verifyPassword(typeof password === 'string' ? password : '', nameOk ? user.hash : DUMMY_HASH);
+        const ok = nameOk && pwOk;
+        audit(req, 'password', ok);
+        if (!ok) {
+            lockout.fail(ip);
+            return reply.code(401).send({ error: 'wrong username or password' });
+        }
+        lockout.succeed(ip);
+        return signIn();
+    };
+    app.post('/api/auth/logout', PUBLIC, async (req, reply) => {
+        if (!guard.crossSiteSafe(req))
+            return reply.code(403).send({ error: 'bad origin' });
+        const login = guard.currentLogin(req);
+        if (login)
+            logins.revoke(login.loginId);
+        dropRevokedSockets();
+        return reply.code(204).header('set-cookie', clearedCookie(secure)).send();
+    });
+    app.get('/api/me', async () => ({ username: store.get().user?.username }));
+    app.get('/api/auth/logins', async (req) => {
+        const current = guard.currentLogin(req).loginId;
+        return logins.list().map((l) => ({
+            handle: loginHandle(l.id),
+            createdAt: l.createdAt,
+            lastSeen: l.lastSeen,
+            ua: l.ua,
+            method: l.method,
+            current: l.id === current,
+        }));
+    });
+    app.delete('/api/auth/logins/:handle', async (req, reply) => {
+        const target = logins.list().find((l) => loginHandle(l.id) === req.params.handle);
+        if (!target)
+            return reply.code(404).send({ error: 'not found' });
+        logins.revoke(target.id);
+        dropRevokedSockets();
+        return reply.code(204).send();
+    });
+};