Open-source gym & body-weight tracker, now in the App Store (iPhone + Apple Watch) and as an Android APK. Plan routines, log workouts, see which muscles are trained, import from Strong/Hevy/FitNotes. Self-host it or use it on the phone alone.
JavaScript apple-watchbodyweightdockerfitnessfitness-trackergymhealthiosmcpnodejspasskeysprogressive-web-applicationspwareactself-hostedself-hostingvitewebauthnweightliftingworkout-tracker
API: a request the client got wrong is a 400 (or 413), never a 500 with a stack trace — bad or non-object JSON, an array as the state document, null workout entries, a rest timer without seconds (QA C17, C19, C20, C16)
Duarte Santosf94f8ca32055
diff --git a/api/openapi.yaml b/api/openapi.yamlindex 14ecfdf12..fd2f23db2 100644--- a/api/openapi.yaml+++ b/api/openapi.yaml@@ -50,7 +50,11 @@ info:- Errors are always `{"error": "<human-readable message>"}`.- Unknown method+path pairs return `404 {"error":"not found"}`; an unhandledexception returns `500 {"error":"server error"}`.- - Request bodies are parsed as JSON regardless of Content-Type; max 5 MiB.+ - Request bodies are parsed as JSON regardless of Content-Type. A body that does+ not parse, or parses to anything but an object (`null`, a string, an array), is+ `400 {"error":"invalid json"}` on every route that reads one; an empty body counts+ as `{}`. A body over 5 MiB is `413 {"error":"body too large"}`; the rest of the+ upload is discarded so the answer reaches the client.- CORS: the request's `Origin` is reflected in `Access-Control-Allow-Origin`**without** `Allow-Credentials` — cross-origin callers can only everauthenticate with a Bearer token, never with the cookie.@@ -556,8 +560,10 @@ paths:- type: 'null''400':description: >-- `state` missing or not an object, or `workouts`/`routines` set to anything- other than an array or null.+ `state` missing or not an object, `state` an array, or `workouts`/`routines`+ set to anything other than an array or null. Entries inside those two arrays+ that are not objects (`null`, numbers, nested arrays) are dropped before the+ write rather than refused, so a client with a damaged copy still syncs.content:application/json:schema: { $ref: '#/components/schemas/Error' }@@ -725,7 +731,8 @@ paths:operationId: pushRestTimersummary: Schedule a server-side rest-timer pushdescription: |- Schedules one push after `seconds` (clamped to 1–3600). One pending timer per+ Schedules one push after `seconds` (a number or numeric string ≥ 1, clamped to+ 3600). One pending timer perdevice — `deviceId`, the same token the subscription was registered with; anew call from the same device replaces it, and the push goes only to thatdevice's subscriptions. Without a `deviceId` there is one timer per account@@ -733,9 +740,6 @@ paths:on rest start/extend and cancels on skip or on-screen completion — the pushonly actually fires when the tab was backgrounded/suspended and never got tocancel it. Timers live in memory: an API restart drops them.-- Note: the documented `400 seconds required` exists in the code but is- unreachable — the clamp turns any missing/invalid value into 1.requestBody:required: truecontent:@@ -759,6 +763,12 @@ paths:content:application/json:schema: { $ref: '#/components/schemas/Ok' }+ '400':+ description: '`seconds` missing, not numeric, or below 1. Nothing is scheduled.'+ content:+ application/json:+ schema: { $ref: '#/components/schemas/Error' }+ example: { error: "seconds required" }'401': { $ref: '#/components/responses/Unauthorized' }/api/push/rest-timer/cancel:diff --git a/api/server.js b/api/server.jsindex 5f2745cc3..8da9389b0 100644--- a/api/server.js+++ b/api/server.js@@ -513,21 +513,53 @@ function json(res, code, obj, extraHeaders) {res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', ...(extraHeaders || {}) });res.end(body);}+// A request the caller got wrong. The catch-all at the bottom answers it with this status and+// message and does not log it: three of the routes below are reachable without a session, and a+// stack trace per malformed body would let anyone fill the container log with noise that looks+// like a crash. Anything else that escapes a handler is still a real 500 and still logged.+class HttpError extends Error {+ constructor(status, message) { super(message); this.status = status; }+}function readBody(req) {return new Promise((resolve, reject) => {- let size = 0; const chunks = [];+ let size = 0, over = false; const chunks = [];req.on('data', d => {size += d.length;- if (size > MAX_BODY) { reject(new Error('body too large')); req.destroy(); return; }+ if (over) {+ // The 413 is already on its way. The rest of the upload is read and thrown away rather+ // than the socket destroyed under it: closing with unread bytes on the wire makes the+ // kernel send a reset, and a client (node's own http client included) that hits the+ // reset before it has parsed the answer reports a dropped connection instead of the+ // 413. A client that keeps streaming past twice the cap is not a mistaken one, and is+ // cut off.+ if (size > 2 * MAX_BODY) req.destroy();+ return;+ }+ if (size > MAX_BODY) {+ over = true; chunks.length = 0;+ reject(new HttpError(413, 'body too large'));+ return;+ }chunks.push(d);});req.on('end', () => {- try { resolve(chunks.length ? JSON.parse(Buffer.concat(chunks).toString('utf8')) : {}); }- catch { reject(new Error('bad json')); }+ if (over) return;+ if (!chunks.length) return resolve({});+ let body;+ try { body = JSON.parse(Buffer.concat(chunks).toString('utf8')); }+ catch { return reject(new HttpError(400, 'invalid json')); }+ // Every handler reads fields off the result, so a JSON `null`, string, number or array is+ // as much a client mistake as unparseable text — refused once here rather than dereferenced+ // (and turned into a TypeError) in each route.+ if (!body || typeof body !== 'object' || Array.isArray(body)) return reject(new HttpError(400, 'invalid json'));+ resolve(body);});req.on('error', reject);});}+// A caller-supplied field that is meant to be text. String() alone is not safe on a parsed body:+// `{"code":{"toString":1}}` is valid JSON and String() throws on it.+const text = v => (typeof v === 'string' ? v : typeof v === 'number' ? String(v) : '');const b64uToBuf = s => Buffer.from(s, 'base64url');/* ---------- live presence (in-memory) ---------- */@@ -658,9 +690,9 @@ const routes = {'POST /api/register/options': async (req, res) => {const body = await readBody(req);- const name = String(body.name || '').trim().slice(0, 40);+ const name = text(body.name).trim().slice(0, 40);if (!name) return json(res, 400, { error: 'name required' });- const code = String(body.code || '').trim().toUpperCase();+ const code = text(body.code).trim().toUpperCase();if (INVITE_ONLY && !db.invites.some(i => i.code === code && !i.usedBy && !i.revoked)) {// The rejected code itself is never recorded — a near-miss guess in the log is a liability.audit(req, 'auth.register.denied', { ok: false, name, msg: 'invite-rejected' });@@ -830,7 +862,7 @@ const routes = {// the code IS the credential, one-shot and 5-minute-lived like a WebAuthn challenge.'POST /api/pair/redeem': async (req, res) => {const body = await readBody(req);- const code = String(body.code || '').trim().toUpperCase();+ const code = text(body.code).trim().toUpperCase();const p = pairings.get(code);if (p) pairings.delete(code);if (!p || p.exp < Date.now()) {@@ -871,9 +903,17 @@ const routes = {if (!body.state || typeof body.state !== 'object') return json(res, 400, { error: 'state required' });// The reminder tick and the admin routes iterate these two on the server's side, so a truthy// non-array would throw there on every pass for as long as it sat on disk. Absent or null is- // fine — every client fills its own defaults.+ // fine — every client fills its own defaults. An array is `typeof 'object'` but no document:+ // `_rev` set on it is dropped by JSON.stringify, so the file would read back as rev 0 while+ // the response claimed the next revision.const list = v => v == null || Array.isArray(v);- if (!list(body.state.workouts) || !list(body.state.routines)) return json(res, 400, { error: 'invalid state' });+ if (Array.isArray(body.state) || !list(body.state.workouts) || !list(body.state.routines)) return json(res, 400, { error: 'invalid state' });+ // The same readers dereference every entry (`w.d`, `w.name`), so a null or non-object entry+ // would throw there — and blank the admin's drill-down of this profile. Dropped, not refused:+ // such an entry carries nothing worth keeping, whereas a 400 would strand a client whose own+ // copy is already malformed — it keeps re-sending the same document and never syncs again.+ const record = x => x && typeof x === 'object' && !Array.isArray(x);+ for (const k of ['workouts', 'routines']) if (Array.isArray(body.state[k])) body.state[k] = body.state[k].filter(record);// Conditional write: a `baseRev` that is not the current revision means this client last// read an older document — another device has written since — and the copy it is about to// push would silently drop that write. The current document travels back with the 409, so@@ -954,8 +994,13 @@ const routes = {const user = readSession(req);if (!user) return json(res, 401, { error: 'not signed in' });const body = await readBody(req);- const sec = Math.max(1, Math.min(3600, Math.round(+body.seconds || 0)));- if (!sec) return json(res, 400, { error: 'seconds required' });+ // Validated before it is clamped: the clamp used to run first, which turned a missing or+ // unusable value into a 1-second push and made the 400 below unreachable. `Number()` only+ // on a number or a string — on an object it can throw.+ const raw = body.seconds;+ const n = typeof raw === 'number' || typeof raw === 'string' ? Number(raw) : NaN;+ if (!(n >= 1)) return json(res, 400, { error: 'seconds required' });+ const sec = Math.min(3600, Math.round(n));scheduleRestTimer(user.id, deviceIdOf(body.deviceId), sec, readState(user.id)?.lang);json(res, 200, { ok: true });},@@ -975,7 +1020,7 @@ const routes = {const body = await readBody(req);if (body.active) {presence.set(user.id, {- name: String(body.name || '').slice(0, 60),+ name: text(body.name).slice(0, 60),exIdx: +body.exIdx || 0, exTotal: +body.exTotal || 0,setsDone: +body.setsDone || 0, setsTotal: +body.setsTotal || 0,startedAt: +body.startedAt || Date.now(),@@ -1054,7 +1099,7 @@ const routes = {// good, so the code itself has to be the thing that isn't worth guessing. Codes already in// db.json keep working — validation is an exact string compare, never a length or format check.do { code = crypto.randomBytes(8).toString('hex').toUpperCase(); } while (db.invites.some(i => i.code === code));- const invite = { code, note: String(body.note || '').slice(0, 60), createdBy: admin.id, created: new Date().toISOString() };+ const invite = { code, note: text(body.note).slice(0, 60), createdBy: admin.id, created: new Date().toISOString() };db.invites.push(invite);saveDb();audit(req, 'admin.invite.create', { user: admin, msg: code });@@ -1064,7 +1109,7 @@ const routes = {'POST /api/admin/invites/revoke': async (req, res) => {const admin = requireAdmin(req, res); if (!admin) return;const body = await readBody(req);- const inv = db.invites.find(i => i.code === String(body.code || '').toUpperCase());+ const inv = db.invites.find(i => i.code === text(body.code).toUpperCase());if (!inv) return json(res, 404, { error: 'no such code' });if (inv.usedBy) return json(res, 400, { error: 'already used — cannot revoke' });db.invites = db.invites.filter(i => i.code !== inv.code);@@ -1166,6 +1211,10 @@ http.createServer(async (req, res) => {}try { await handler(req, res); }catch (e) {+ if (e instanceof HttpError) {+ if (!res.headersSent) json(res, e.status, { error: e.message });+ return;+ }console.error(key, e);if (!res.headersSent) json(res, 500, { error: 'server error' });}diff --git a/api/test/server-bad-input.test.js b/api/test/server-bad-input.test.jsnew file mode 100644index 000000000..a734fe24f--- /dev/null+++ b/api/test/server-bad-input.test.js@@ -0,0 +1,183 @@+/* A client's mistake is a 400 (or a 413), never a 500 with a stack trace in the log: unparseable+ or non-object JSON bodies, a state document that is an array, null entries inside it, and a+ rest-timer request without a usable `seconds` (QA C17, C19, C20). Real server.js in a child. */+import { test } from 'node:test';+import assert from 'node:assert/strict';+import crypto from 'node:crypto';+import net from 'node:net';+import http from 'node:http';+import fs from 'node:fs';+import os from 'node:os';+import path from 'node:path';+import { spawn } from 'node:child_process';+import { fileURLToPath } from 'node:url';++const API = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');+const SECRET = crypto.randomBytes(32).toString('hex');++// Same construction as server.js makeSession(): payload `uid:exp:sv`, HMAC-SHA256 over SECRET.+function mintSession(uid, sv = 0) {+ const payload = `${uid}:${Date.now() + 86400000}:${sv}`;+ return payload + '.' + crypto.createHmac('sha256', SECRET).update(payload).digest('base64url');+}+const UID = 'u_bad_1';+const authed = { Cookie: `gymsid=${mintSession(UID)}`, 'Content-Type': 'application/json' };+const anon = { 'Content-Type': 'application/json' };++const freePort = () => new Promise(r => {+ const s = net.createServer(); s.listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => r(p)); });+});++async function startServer(t) {+ const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gym-bad-'));+ fs.writeFileSync(path.join(dataDir, 'secret'), SECRET, { mode: 0o600 });+ fs.writeFileSync(path.join(dataDir, 'db.json'), JSON.stringify({+ users: [{ id: UID, name: 'One', created: new Date().toISOString() }], creds: [], subs: [], invites: []+ }));+ const port = await freePort();+ const child = spawn(process.execPath, ['server.js'], {+ cwd: API, stdio: ['ignore', 'pipe', 'pipe'],+ env: { ...process.env, PORT: String(port), DATA_DIR: dataDir, ORIGIN: 'http://localhost:8080', RP_ID: 'localhost' }+ });+ const h = { api: `http://127.0.0.1:${port}`, log: '', dataDir };+ child.stdout.on('data', d => h.log += d);+ child.stderr.on('data', d => h.log += d);+ t.after(() => { child.kill('SIGKILL'); fs.rmSync(dataDir, { recursive: true, force: true }); });+ let up = false;+ for (let i = 0; i < 100 && !up; i++) {+ try { up = (await fetch(`${h.api}/api/health`)).ok; } catch { /* not up yet */ }+ if (!up) await new Promise(r => setTimeout(r, 100));+ }+ assert.ok(up, `server never came up:\n${h.log}`);+ // The boot line is fine; anything that looks like a stack frame after this is a defect.+ h.stackFrames = () => h.log.split('\n').filter(l => /^\s+at /.test(l)).length;+ return h;+}++const send = (h, method, p, headers, body) => fetch(`${h.api}${p}`, { method, headers, body });+const status = async (h, method, p, headers, body) => {+ const r = await send(h, method, p, headers, body);+ return { status: r.status, body: await r.json() };+};++test('malformed and non-object JSON bodies are a 400 with no stack trace, on every route', async t => {+ const h = await startServer(t);+ const bad = ['not json', '{bad', 'null', '"str"', '42', '[]'];+ const routes = [+ ['POST', '/api/register/options', anon],+ ['POST', '/api/register/verify', anon],+ ['POST', '/api/pair/redeem', anon],+ ['PUT', '/api/data', authed],+ ['POST', '/api/push/rest-timer', authed]+ ];+ for (const [method, p, headers] of routes) {+ for (const b of bad) {+ const r = await status(h, method, p, headers, b);+ assert.equal(r.status, 400, `${method} ${p} with body ${b}`);+ assert.equal(r.body.error, 'invalid json', `${method} ${p} with body ${b}`);+ }+ }+ // A field whose toString is not callable is valid JSON; String() on it used to throw.+ let r = await status(h, 'POST', '/api/register/options', anon, JSON.stringify({ name: 'x', code: { toString: 1 } }));+ assert.notEqual(r.status, 500);+ r = await status(h, 'POST', '/api/pair/redeem', anon, JSON.stringify({ code: { toString: 1 } }));+ assert.equal(r.status, 400);+ r = await status(h, 'POST', '/api/register/options', anon, JSON.stringify({ name: { toString: 1 } }));+ assert.equal(r.status, 400);+ assert.equal(r.body.error, 'name required');+ // An empty body is still "no fields", as the routes that send none rely on.+ r = await status(h, 'POST', '/api/logout', { Cookie: authed.Cookie });+ assert.equal(r.status, 200);+ // Well-formed controls keep their own answers.+ r = await status(h, 'POST', '/api/register/options', anon, '{}');+ assert.deepEqual(r, { status: 400, body: { error: 'name required' } });+ r = await status(h, 'PUT', '/api/data', authed, JSON.stringify({ state: { workouts: [], routines: [] }, baseRev: 0 }));+ assert.equal(r.status, 200);+ assert.equal(h.stackFrames(), 0, `stack traces in the log:\n${h.log}`);+ assert.doesNotMatch(h.log, /bad json|TypeError/);+});++// node's own http client, writing the whole body in one go on a keep-alive socket: the client+// the QA proxy (and any node-side caller) is, and the one that used to report a reset instead+// of the 413 when the server closed the socket under the still-running upload.+const rawPut = (h, agent, body) => new Promise((resolve, reject) => {+ const rq = http.request(`${h.api}/api/data`, { method: 'PUT', headers: authed, agent }, res => {+ let data = ''; res.on('data', d => data += d); res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(data) }));+ });+ rq.on('error', reject);+ rq.end(body);+});++test('a body over the 5 MiB cap is a 413 that every client gets to read, and nothing is written', async t => {+ const h = await startServer(t);+ const big = JSON.stringify({ state: { workouts: [], routines: [], pad: 'x'.repeat(6 * 1024 * 1024) }, baseRev: 0 });+ let r = await status(h, 'PUT', '/api/data', authed, big);+ assert.equal(r.status, 413);+ assert.equal(r.body.error, 'body too large');+ assert.equal(fs.existsSync(path.join(h.dataDir, `state-${UID}.json`)), false, 'nothing was written');+ const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });+ t.after(() => agent.destroy());+ for (let i = 0; i < 3; i++) {+ r = await rawPut(h, agent, big);+ assert.equal(r.status, 413, `node client, attempt ${i + 1}`);+ }+ // The same keep-alive socket, and the server as a whole, are still fine afterwards.+ r = await rawPut(h, agent, JSON.stringify({ state: { workouts: [], routines: [] }, baseRev: 0 }));+ assert.equal(r.status, 200);+ // Past twice the cap the upload is cut off rather than drained: the 413 may or may not+ // arrive, but the process must not be left reading, and must still serve.+ const huge = 'x'.repeat(11 * 1024 * 1024);+ await rawPut(h, new http.Agent(), huge).catch(() => {});+ r = await status(h, 'GET', '/api/health', {});+ assert.equal(r.status, 200);+ assert.equal(h.stackFrames(), 0, `stack traces in the log:\n${h.log}`);+});++test('PUT /api/data: an array is not a document, and null entries never reach the disk', async t => {+ const h = await startServer(t);+ const put = body => status(h, 'PUT', '/api/data', authed, JSON.stringify(body));+ const onDisk = () => JSON.parse(fs.readFileSync(path.join(h.dataDir, `state-${UID}.json`), 'utf8'));++ let r = await put({ state: { _ts: 100, workouts: [{ id: 'w1', d: '2026-09-01' }], routines: [], unit: 'kg' }, baseRev: 0 });+ assert.equal(r.status, 200);+ assert.equal(r.body.rev, 1);++ // An array passes `typeof === 'object'`; it used to be written as `[]`, losing the document+ // and, since `_rev` cannot live on an array, resetting the revision to 0 while the response+ // claimed rev 2.+ r = await put({ state: [], baseRev: 1 });+ assert.equal(r.status, 400);+ assert.equal(r.body.error, 'invalid state');+ assert.equal(onDisk()._rev, 1);+ assert.deepEqual(onDisk().workouts.map(w => w.id), ['w1']);+ r = await status(h, 'GET', '/api/data/rev', authed);+ assert.deepEqual(r.body, { rev: 1 });++ // Null and other non-object entries are dropped: every server-side reader of the document+ // (reminder tick, admin drill-down) dereferences the entries, and a 400 would strand a client+ // whose own copy is already malformed.+ r = await put({ state: { workouts: [null, { id: 'w2', d: '2026-09-02' }, 7, 'x', [], { id: 'w3', d: '2026-09-03' }], routines: [null, { id: 'r1', name: 'A', ex: [] }] }, baseRev: 1 });+ assert.equal(r.status, 200);+ assert.equal(r.body.rev, 2);+ assert.deepEqual(onDisk().workouts.map(w => w.id), ['w2', 'w3']);+ assert.deepEqual(onDisk().routines.map(x => x.id), ['r1']);+ // Absent lists stay absent — every client fills its own defaults.+ r = await put({ state: { unit: 'kg' }, baseRev: 2 });+ assert.equal(r.status, 200);+ assert.equal('workouts' in onDisk(), false);+ assert.equal(h.stackFrames(), 0, `stack traces in the log:\n${h.log}`);+});++test('POST /api/push/rest-timer: a missing or invalid `seconds` is a 400, never a 1-second timer', async t => {+ const h = await startServer(t);+ const post = b => status(h, 'POST', '/api/push/rest-timer', authed, b);+ for (const b of ['{}', '{"seconds":"abc"}', '{"seconds":0}', '{"seconds":-5}', '{"seconds":null}', '{"seconds":0.4}', '{"seconds":{"valueOf":1}}', '{"seconds":[90]}']) {+ const r = await post(b);+ assert.deepEqual(r, { status: 400, body: { error: 'seconds required' } }, `body ${b}`);+ }+ for (const b of ['{"seconds":90}', '{"seconds":"90"}', '{"seconds":1}', '{"seconds":99999}']) {+ const r = await post(b);+ assert.deepEqual(r, { status: 200, body: { ok: true } }, `body ${b}`);+ }+ assert.equal(h.stackFrames(), 0, `stack traces in the log:\n${h.log}`);+});