workoffdesk 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,216 @@
+import { randomBytes } from 'node:crypto';
+import { findTranscript } from '../../agents/claude/transcript/transcriptFile.js';
+import { listCommands } from '../../agents/claude/offers/commands.js';
+import { listFiles } from '../../agents/claude/offers/files.js';
+import { listModels } from '../../agents/claude/offers/models.js';
+import { readMentionedImage } from '../../uploads/media.js';
+const MESSAGE_ID = /^[A-Za-z0-9_-]{8,64}$/;
+// A command, and what it is given, if anything (`/effort high`, `/model opus[1m]`).
+const COMMAND = /^\/[a-z][\w:-]{0,40}( [\w.:[\]-]{1,40})?$/;
+// Enough for a slider pushed from one end to the other, or a page of scrolling.
+const KEYS_MAX = 200;
+// What the chat of a session shows: the conversation, its images, what is on screen and the answers to it.
+export const register = (app, ctx) => {
+    const { deps, machineOr404 } = ctx;
+    // The message as the journal now has it, for the page to apply like any row.
+    const message = (session, qid) => deps.machine.message(session, qid);
+    app.get('/api/m/:machine/sessions/:id/choices', 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 m.onScreen(req.params.id);
+    });
+    app.get('/api/m/:machine/sessions/:id/screen', 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 { text: await m.screenText(req.params.id) };
+    });
+    // What can follow a `/` in the session, as Claude Code lists it; a shell takes none.
+    app.get('/api/m/:machine/sessions/:id/commands', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const s = (await m.listSessions()).find((x) => x.id === req.params.id);
+        if (!s)
+            return reply.code(404).send({ error: 'no such session' });
+        if (s.kind !== 'claude' || !deps.claudeDir)
+            return { commands: [] };
+        return { commands: await listCommands({ claudeDir: deps.claudeDir, cwd: s.cwd, claudeBin: deps.claudeBin }) };
+    });
+    // The models /model takes in the session, as Claude Code lists them for its folder; a shell takes none.
+    app.get('/api/m/:machine/sessions/:id/models', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const s = (await m.listSessions()).find((x) => x.id === req.params.id);
+        if (!s)
+            return reply.code(404).send({ error: 'no such session' });
+        if (s.kind !== 'claude' || !deps.claudeBin || !s.cwd)
+            return { models: [] };
+        return { models: await listModels(deps.claudeBin, s.cwd) };
+    });
+    // The files of the session's folder an `@` can name.
+    app.get('/api/m/:machine/sessions/:id/files', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const s = (await m.listSessions()).find((x) => x.id === req.params.id);
+        if (!s)
+            return reply.code(404).send({ error: 'no such session' });
+        return { files: s.cwd ? await listFiles(s.cwd) : [] };
+    });
+    // What the composer sends Claude: typed in now, or held, in order, while Claude cannot take it.
+    app.post('/api/m/:machine/sessions/:id/messages', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const text = req.body?.text;
+        if (typeof text !== 'string' || !text)
+            return reply.code(400).send({ error: 'text required' });
+        // The page names each message, so one sent again after its answer was lost is taken once.
+        const given = req.body?.id;
+        if (given !== undefined && (typeof given !== 'string' || !MESSAGE_ID.test(given)))
+            return reply.code(400).send({ error: 'bad message id' });
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        const qid = given ?? randomBytes(8).toString('hex');
+        return { queued: await m.sendMessage(req.params.id, text, qid), message: message(req.params.id, qid) };
+    });
+    // A slash command typed at Claude's prompt, as a key on the page would; nothing is typed while a dialog
+    // has the keyboard, where its Enter would take whatever the dialog has selected.
+    app.post('/api/m/:machine/sessions/:id/command', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const command = req.body?.command;
+        if (typeof command !== 'string' || !COMMAND.test(command))
+            return reply.code(400).send({ error: 'bad command' });
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        const { ran, screen } = await m.runCommand(req.params.id, command);
+        return screen ? { ran, screen } : { ran };
+    });
+    // Keys pressed in a dialog on screen, sent as a request rather than on the session's line, which a slow
+    // phone line can hold for seconds while it looks open; the answer brings the screen after them.
+    app.post('/api/m/:machine/sessions/:id/keys', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const keys = req.body?.keys;
+        if (typeof keys !== 'string' || !keys || keys.length > KEYS_MAX)
+            return reply.code(400).send({ error: 'bad keys' });
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        return { screen: await m.press(req.params.id, keys) };
+    });
+    // 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);
+        if (!m)
+            return reply;
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        return { screen: await m.close(req.params.id) };
+    });
+    // Takes back a held message; its text comes back, to put in the composer again.
+    app.delete('/api/m/:machine/sessions/:id/messages/:qid', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const text = m.unsend(req.params.id, req.params.qid);
+        if (text === null)
+            return reply.code(404).send({ error: 'already sent' });
+        return { text, message: message(req.params.id, req.params.qid) };
+    });
+    // A waiting message goes now, out of its turn, or moves a place earlier or later.
+    app.post('/api/m/:machine/sessions/:id/messages/:qid', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const move = req.body?.move;
+        if (move !== undefined && move !== -1 && move !== 1)
+            return reply.code(400).send({ error: 'bad move' });
+        const done = move === undefined ? await m.sendNow(req.params.id, req.params.qid) : m.moveQueued(req.params.id, req.params.qid, move);
+        if (!done)
+            return reply.code(404).send({ error: 'already sent' });
+        return { message: message(req.params.id, req.params.qid) };
+    });
+    // Answers the choice on screen: `index` and `label` take one option, with `text` typed into it when it
+    // is a field for an answer of one's own; `ticked` and `labels` send a question that takes several with
+    // those ticked. Options are named as well as numbered, so a tap on options that have since changed
+    // presses nothing.
+    app.post('/api/m/:machine/sessions/:id/choices', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const { index, label, text, ticked, labels } = req.body ?? {};
+        const several = ticked !== undefined || labels !== undefined;
+        const isIndex = (i) => Number.isSafeInteger(i) && i >= 0;
+        if (several) {
+            if (!Array.isArray(ticked) || !ticked.every(isIndex) || !Array.isArray(labels) || !labels.every((l) => typeof l === 'string')) {
+                return reply.code(400).send({ error: 'ticked and labels required' });
+            }
+        }
+        else if (!isIndex(index) || typeof label !== 'string') {
+            return reply.code(400).send({ error: 'index and label required' });
+        }
+        else if (text !== undefined && (typeof text !== 'string' || !text.trim())) {
+            return reply.code(400).send({ error: 'bad text' });
+        }
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        const pressed = several
+            ? await m.tick(req.params.id, ticked, labels)
+            : await m.choose(req.params.id, index, label, text);
+        if (!pressed)
+            return reply.code(409).send({ error: 'the options have changed' });
+        return reply.code(204).send();
+    });
+    // Answers what the session waits on the person for (OnScreen.asks); 409 when it is over, answered at the
+    // Mac or passed by, so an answer goes to the ask it was given for or nowhere.
+    app.post('/api/m/:machine/sessions/:id/asks/:askId', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const { allow, always } = req.body ?? {};
+        if (typeof allow !== 'boolean')
+            return reply.code(400).send({ error: 'allow required' });
+        if (always !== undefined && (always !== true || !allow))
+            return reply.code(400).send({ error: 'bad always' });
+        if (!(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        const answered = m.answer(req.params.id, req.params.askId, allow ? { allow, ...(always && { always }) } : { allow });
+        if (!answered)
+            return reply.code(409).send({ error: 'already answered' });
+        return reply.code(204).send();
+    });
+    // An image Claude named in the session, for the chat to show. Paths the transcript does not name are refused.
+    app.get('/api/m/:machine/sessions/:id/image', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        if (typeof req.query.path !== 'string')
+            return reply.code(400).send({ error: 'no path' });
+        const meta = m.sessionMeta(req.params.id);
+        if (!meta || !(await m.exists(req.params.id)))
+            return reply.code(404).send({ error: 'no such session' });
+        const transcript = meta.claudeSessionId && deps.claudeProjectsRoot ? await findTranscript(deps.claudeProjectsRoot, meta.claudeSessionId) : null;
+        if (!transcript)
+            return reply.code(404).send({ error: 'no transcript' });
+        const image = await readMentionedImage(transcript, req.query.path);
+        if (image === 'refused')
+            return reply.code(403).send({ error: 'not an image this session named' });
+        if (image === 'gone')
+            return reply.code(404).send({ error: 'image gone' });
+        return reply
+            .header('content-type', image.type)
+            .header('x-content-type-options', 'nosniff')
+            .header('cache-control', 'private, max-age=300')
+            .send(image.bytes);
+    });
+};

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

@@ -0,0 +1,69 @@
+import { findTranscript, readChat, readChatBefore } from '../../agents/claude/transcript/transcriptFile.js';
+import { heldInBackground, listProjectDirs, listRecentClaudeSessions } from '../../agents/claude/transcript/transcripts.js';
+import { isDir } from '../../system/dirs.js';
+// The Claude conversations people had on this Mac lately, and where each is open now.
+export async function recentClaude(deps) {
+    const { machine } = deps;
+    if (!deps.claudeProjectsRoot)
+        return [];
+    const [recent, sessions, held, onMac] = await Promise.all([
+        listRecentClaudeSessions(deps.claudeProjectsRoot),
+        machine.listSessions(),
+        deps.claudeJobsRoot ? heldInBackground(deps.claudeJobsRoot) : () => false,
+        machine.openOnMac(),
+    ]);
+    const open = new Map(sessions.filter((s) => s.claudeSessionId).map((s) => [s.claudeSessionId, s.id]));
+    return recent.map((r) => {
+        const there = onMac.get(r.sessionId);
+        return {
+            ...r,
+            title: machine.claudeName(r.sessionId) ?? r.title,
+            openIn: open.get(r.sessionId) ?? null,
+            background: held(r.sessionId),
+            onMac: there ? { status: there.status, terminals: there.claudes.length } : null,
+            takingOver: machine.takingOver(r.sessionId),
+            folderGone: !!r.cwd && !isDir(r.cwd),
+            agent: 'claude',
+        };
+    });
+}
+// 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));
+    // 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
+    // as a session's chat. Only a transcript under Claude Code's projects folder is read.
+    app.get('/api/claude/sessions/:sid/chat', async (req, reply) => {
+        const { sid } = req.params;
+        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))) };
+    });
+    // The Claude accounts on this Mac, the one new sessions run on, and a pick of another.
+    app.get('/api/claude/accounts', () => machine.claudeAccountsView());
+    app.put('/api/claude/account', async (req, reply) => {
+        if (typeof req.body?.id !== 'string')
+            return reply.code(400).send({ error: 'bad id' });
+        const view = await machine.pickClaudeAccount(req.body.id);
+        req.log.info({ account: req.body.id }, 'claude account picked');
+        return view;
+    });
+    app.post('/api/claude/account/move', async (req) => {
+        const view = await machine.moveToAccountInUse();
+        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 ?? []));
+};

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

@@ -0,0 +1,58 @@
+import { isDir } from '../../system/dirs.js';
+import { 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 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) {
+    const { machine } = deps;
+    const [threads, sessions] = await Promise.all([machine.codexOnMac().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,
+        cwd: t.cwd || null,
+        title: t.title,
+        lastActivity: t.lastActivity,
+        automated: false,
+        openIn: open.get(t.id) ?? null,
+        background: t.holder?.at === 'elsewhere',
+        lastPrompt: t.lastPrompt,
+        onMac: t.holder?.at === 'terminal' ? { status: t.busy ? 'busy' : 'idle', terminals: 1 } : null,
+        takingOver: machine.takingOver(t.id),
+        folderGone: !!t.cwd && !isDir(t.cwd),
+        agent: 'codex',
+    }));
+}
+// Codex threads on this Mac to read and pick up, and the list of every agent's conversations here.
+export const register = (app, ctx) => {
+    const { deps } = ctx;
+    const { machine } = deps;
+    app.get('/api/recent', async () => {
+        const [claude, codex] = await Promise.all([recentClaude(deps), recentCodex(deps)]);
+        return [...claude, ...codex].sort((a, b) => b.lastActivity - a.lastActivity);
+    });
+    // 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) => {
+        const { id } = req.params;
+        if (!UUID.test(id))
+            return reply.code(400).send({ error: 'bad thread id' });
+        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' });
+        const items = (await machine.codexChat(id)).map((e) => e.item);
+        const end = items.length;
+        const page = (start, stop) => ({ sid: id, items: items.slice(start, stop), from: start, next: stop, skipped: false });
+        if (req.query.sid !== id || from > end)
+            return page(Math.max(0, end - PAGE), end);
+        if (before !== null)
+            return page(Math.max(0, Math.min(before, end) - PAGE), Math.min(before, end));
+        return page(from, end);
+    });
+    // Stops waiting to take a thread over from the Mac.
+    app.delete('/api/codex/threads/:id/take-over', async (req, reply) => machine.cancelTakeOver(req.params.id) ? reply.code(204).send() : reply.code(404).send({ error: 'not waiting' }));
+};

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

@@ -0,0 +1 @@
+export const PUBLIC = { config: { public: true } };

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

@@ -0,0 +1,56 @@
+import { VERSION } from '../../system/version.js';
+import { PUBLIC } from './context.js';
+// For a supervisor or a deploy to ask "are you up, and which build": nothing about sessions or the user.
+export const register = (app, ctx) => {
+    const { store, machine } = ctx.deps;
+    // Requests that arrive while a check runs share it: the route is public, and each check starts tmux.
+    let running = null;
+    const check = () => (running ??= machine.listSessions().finally(() => (running = null)));
+    app.get('/healthz', PUBLIC, async (_req, reply) => {
+        try {
+            store.get();
+            await check();
+            return { ok: true, version: VERSION };
+        }
+        catch {
+            return reply.code(503).send({ ok: false });
+        }
+    });
+    // A signed-in device's requests that took it long (libs/client slow.ts), logged beside the server's own:
+    // the server answers in milliseconds what a phone may wait seconds for.
+    app.post('/api/slow', async (req, reply) => {
+        const slow = req.body?.slow;
+        if (!Array.isArray(slow) || slow.length > SLOW_MAX)
+            return reply.code(400).send({ error: 'bad report' });
+        for (const s of slow) {
+            if (!isSlow(s))
+                continue;
+            req.log.info({ method: s.method, path: s.path.slice(0, 200), ms: s.ms, outcome: s.outcome, device: req.headers['user-agent'] }, 'slow on device');
+        }
+        return reply.code(204).send();
+    });
+    // A phone's chat that came to rest at its scroll view's end with the last row still under the dock
+    // (mobile ChatList): what the list, the scroll view and the screen each measured then.
+    app.post('/api/chat-end', async (req, reply) => {
+        const numbers = req.body?.numbers;
+        if (!isNumbers(numbers))
+            return reply.code(400).send({ error: 'bad report' });
+        req.log.info({ ...numbers, device: req.headers['user-agent'] }, 'chat end hidden on device');
+        return reply.code(204).send();
+    });
+};
+const NUMBERS_MAX = 16;
+const isNumbers = (x) => typeof x === 'object' &&
+    x !== null &&
+    !Array.isArray(x) &&
+    Object.keys(x).length <= NUMBERS_MAX &&
+    Object.entries(x).every(([k, v]) => /^[a-zA-Z]{1,24}$/.test(k) && (v === null || Number.isFinite(v)));
+const SLOW_MAX = 20;
+const isSlow = (s) => {
+    const x = s;
+    return (typeof x?.method === 'string' &&
+        typeof x.path === 'string' &&
+        x.path.startsWith('/api/') &&
+        Number.isSafeInteger(x.ms) &&
+        (Number.isSafeInteger(x.outcome) || x.outcome === 'network'));
+};

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

@@ -0,0 +1,35 @@
+const CONV = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const count = (s) => (s === undefined ? 0 : /^\d{1,15}$/.test(s) ? Number(s) : NaN);
+// A session's journal for a copy to catch up on: the rows above the version it holds, and pages of older
+// items of a conversation (docs/design/2026-10-06-session-journal-design.md).
+export const register = (app, ctx) => {
+    const { deps, machineOr404 } = ctx;
+    const { machine } = deps;
+    app.get('/api/m/:machine/sessions/:id/journal', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const v = count(req.query.v);
+        if (!Number.isSafeInteger(v))
+            return reply.code(400).send({ error: 'bad version' });
+        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).
+        if (machine.sessionMeta(req.params.id)?.kind === 'claude')
+            await m.onScreen(req.params.id).catch(() => { });
+        await machine.ingest(req.params.id);
+        return machine.journal.sync(req.params.id, req.query.epoch, v);
+    });
+    app.get('/api/m/:machine/sessions/:id/journal/items', async (req, reply) => {
+        const m = machineOr404(req, reply);
+        if (!m)
+            return reply;
+        const before = req.query.before === undefined ? NaN : count(req.query.before);
+        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)))
+            return reply.code(404).send({ error: 'no such session' });
+        return machine.journal.older(req.params.id, conv, before);
+    });
+};

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

@@ -0,0 +1,39 @@
+import { join } from 'node:path';
+import { Conflict } from '../../system/errors.js';
+import { messagesFor } from '../../system/messages.js';
+import { beginOp, opRunning } from '../../ops/lastOp.js';
+import { recentProblems } from '../../ops/problems.js';
+import { macReport } from '../../ops/report.js';
+import { rollbackTarget } from '../../ops/release.js';
+// The This Mac page: what the Mac's checks say, which build runs, what went wrong lately, and a restart or a
+// rollback, done by a helper process since a server cannot restart itself.
+export const register = (app, ctx) => {
+    const ops = ctx.deps.ops;
+    if (!ops)
+        return;
+    app.get('/api/mac', async (req) => {
+        const languages = [req.query.lang ?? '', ...String(req.headers['accept-language'] ?? '').split(',').map((l) => l.split(';')[0].trim())];
+        return macReport(ops, messagesFor(languages.filter(Boolean)));
+    });
+    app.get('/api/mac/problems', async () => recentProblems(join(ops.home, 'logs/workoffdesk.log')));
+    const hand = (op) => {
+        if (!ops.managed)
+            throw new Conflict('this server was not started by launchd', 'not-managed');
+        if (opRunning(ops.home))
+            throw new Conflict('a restart or rollback is already running', 'op-busy');
+        beginOp(ops.home, op, ops.spawnOp(op));
+    };
+    app.post('/api/mac/restart', async (req, reply) => {
+        hand('restart');
+        req.log.info('restart asked for from a screen');
+        return reply.code(202).send({});
+    });
+    app.post('/api/mac/rollback', async (req, reply) => {
+        const to = rollbackTarget(ops.home);
+        if (!to || req.body?.to !== to)
+            throw new Conflict('the release before is not the one named', 'rollback-moved');
+        hand('rollback');
+        req.log.info({ to }, 'rollback asked for from a screen');
+        return reply.code(202).send({});
+    });
+};

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

@@ -0,0 +1,83 @@
+import { InvalidRequest } from '../../system/errors.js';
+import { createReadStream } from 'node:fs';
+import { appendPart, byteRange, finishPart, PART_MAX, partSize, videoCover, videoFile } from '../../uploads/fileUpload.js';
+import { readUpload, saveImage } from '../../uploads/media.js';
+// Images and files sent from the phone, for Claude to read.
+export const register = (app, ctx) => {
+    if (ctx.deps.media)
+        registerMediaRoutes(app, ctx.deps.media);
+};
+const UPLOAD_LIMIT = 30 * 1024 * 1024;
+// Images arrive as the raw file, and what they are is judged from the bytes alone: the Content-Type is
+// dropped unread, as phones send it missing, empty (React Native) or generic.
+function registerMediaRoutes(app, media) {
+    // An empty body is not parsed at all.
+    const raw = (body) => (Buffer.isBuffer(body) ? body : Buffer.alloc(0));
+    void app.register(async (upload) => {
+        upload.addContentTypeParser('*', { parseAs: 'buffer' }, (_req, body, done) => done(null, body));
+        upload.post('/api/uploads', {
+            bodyLimit: UPLOAD_LIMIT,
+            onRequest: async (req) => {
+                delete req.headers['content-type'];
+            },
+        }, async (req, reply) => reply.code(201).send({ path: await saveImage(media.uploadsDir, raw(req.body)) }));
+        // A part of a file, appended where the Mac's copy ends; `upload-offset` says where the phone thinks that is.
+        upload.put('/api/uploads/parts/:id', {
+            bodyLimit: PART_MAX,
+            onRequest: async (req) => {
+                delete req.headers['content-type'];
+            },
+        }, async (req) => {
+            const at = Number(req.headers['upload-offset']);
+            if (!Number.isSafeInteger(at) || at < 0)
+                throw new InvalidRequest('upload-offset is not a byte count');
+            return { size: await appendPart(media.uploadsDir, req.params.id, at, raw(req.body)) };
+        });
+    });
+    // How much of a file the Mac has, to go on from.
+    app.get('/api/uploads/parts/:id', async (req) => ({ size: await partSize(media.uploadsDir, req.params.id) }));
+    // The file is whole: where it is kept, and stills of it when it is a video.
+    app.post('/api/uploads/parts/:id/done', async (req, reply) => {
+        const { name, size } = req.body ?? {};
+        if (typeof name !== 'string' || typeof size !== 'number' || !Number.isSafeInteger(size) || size < 0)
+            throw new InvalidRequest('name and size are needed');
+        return reply.code(201).send(await finishPart(media.uploadsDir, req.params.id, name, size));
+    });
+    // A video's first still, shown for it.
+    app.get('/api/uploads/:folder/cover', async (req, reply) => {
+        const cover = await videoCover(media.uploadsDir, req.params.folder);
+        if (!cover)
+            return reply.code(404).send({ error: 'no cover' });
+        return reply.header('content-type', 'image/jpeg').header('cache-control', 'private, max-age=31536000, immutable').send(cover);
+    });
+    // A video sent from the phone, played on the phone in the ranges its player asks for.
+    app.get('/api/uploads/:folder/video', async (req, reply) => {
+        const video = await videoFile(media.uploadsDir, req.params.folder);
+        return video ? sendVideo(video, req.headers.range, reply) : reply.code(404).send({ error: 'no such file' });
+    });
+    // Names are unique, so the phone keeps what it has seen.
+    app.get('/api/uploads/:name', async (req, reply) => {
+        const image = await readUpload(media.uploadsDir, req.params.name);
+        if (!image)
+            return reply.code(404).send({ error: 'no such image' });
+        return reply
+            .header('content-type', image.type)
+            .header('x-content-type-options', 'nosniff')
+            .header('cache-control', 'private, max-age=31536000, immutable')
+            .send(image.bytes);
+    });
+}
+function sendVideo(video, rangeHeader, reply) {
+    const range = byteRange(rangeHeader, video.size);
+    if (range === 'unsatisfiable')
+        return reply.code(416).header('content-range', `bytes */${video.size}`).send();
+    const { start, end } = range ?? { start: 0, end: video.size - 1 };
+    if (range)
+        reply.code(206).header('content-range', `bytes ${start}-${end}/${video.size}`);
+    return reply
+        .header('content-type', video.type)
+        .header('accept-ranges', 'bytes')
+        .header('content-length', String(end - start + 1))
+        .header('cache-control', 'private, no-store')
+        .send(video.size ? createReadStream(video.file, { start, end }) : '');
+}

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

@@ -0,0 +1,78 @@
+// The phones that get a notification when Claude needs an answer.
+export const register = (app, ctx) => {
+    const { deps, now } = ctx;
+    const { store, pusher } = deps;
+    app.get('/api/push/key', async (_req, reply) => {
+        const vapid = store.get().vapid;
+        return vapid ? { publicKey: vapid.publicKey } : reply.code(404).send({ error: 'push not configured' });
+    });
+    app.post('/api/push/subscribe', async (req, reply) => {
+        const sub = parseSubscription(req.body);
+        if (!sub)
+            return reply.code(400).send({ error: 'invalid subscription' });
+        store.update((s) => {
+            s.pushSubs = [...s.pushSubs.filter((x) => x.endpoint !== sub.endpoint), { ...sub, createdAt: now() }];
+        });
+        return reply.code(204).send();
+    });
+    app.delete('/api/push/subscribe', async (req, reply) => {
+        const endpoint = req.body?.endpoint;
+        store.update((s) => {
+            s.pushSubs = s.pushSubs.filter((x) => x.endpoint !== endpoint);
+        });
+        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 }));
+    app.post('/api/push/apns', async (req, reply) => {
+        const d = parseDevice(req.body);
+        if (!d)
+            return reply.code(400).send({ error: 'invalid device' });
+        // 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)
+            return reply.code(204).send();
+        store.update((s) => {
+            const was = s.apnsDevices.find((x) => x.token === d.token);
+            s.apnsDevices = [...s.apnsDevices.filter((x) => x.token !== d.token), { ...d, host: was?.host, createdAt: was?.createdAt ?? now() }];
+        });
+        return reply.code(204).send();
+    });
+    app.delete('/api/push/apns', async (req, reply) => {
+        const token = req.body?.token;
+        store.update((s) => {
+            s.apnsDevices = s.apnsDevices.filter((x) => x.token !== token);
+        });
+        return reply.code(204).send();
+    });
+};
+const words = (v) => typeof v === 'string' && v.length > 0 && v.length <= 200;
+function parseDevice(body) {
+    const b = body;
+    if (!b || typeof b.token !== 'string' || !/^[0-9a-f]{64,200}$/i.test(b.token))
+        return null;
+    if (typeof b.topic !== 'string' || !/^[A-Za-z0-9.-]{1,155}$/.test(b.topic))
+        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 } };
+}
+function parseSubscription(body) {
+    const b = body;
+    if (!b || typeof b.endpoint !== 'string' || b.endpoint.length > 2048)
+        return null;
+    let url;
+    try {
+        url = new URL(b.endpoint);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:')
+        return null;
+    const { p256dh, auth } = b.keys ?? {};
+    if (typeof p256dh !== 'string' || typeof auth !== 'string' || !p256dh || !auth)
+        return null;
+    return { endpoint: b.endpoint, keys: { p256dh, auth } };
+}