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
Push: reminders owed within 15 minutes still arrive, the subscription heals itself on every boot, rest-timer alerts belong to the device that started the rest
Duarte Santos477fc07f8bd7
diff --git a/api/openapi.yaml b/api/openapi.yamlindex 4b9250366..a409874cb 100644--- a/api/openapi.yaml+++ b/api/openapi.yaml@@ -597,7 +597,9 @@ paths:the two protocol keys are kept. The endpoint must be a public `https://` URL —private/loopback/link-local addresses are refused (here and again at sendtime, against DNS rebinding). At most 20 subscriptions per user; the oldest- are dropped first. Re-subscribing an existing endpoint replaces it.+ are dropped first. Re-subscribing an existing endpoint replaces it and keeps+ its original `created` — the client re-sends its subscription on every+ signed-in boot, so a row the instance lost comes back on its own.requestBody:required: truecontent:@@ -607,6 +609,13 @@ paths:required: [subscription]properties:subscription: { $ref: '#/components/schemas/PushSubscription' }+ deviceId:+ type: string+ pattern: '^[A-Za-z0-9_-]{8,64}$'+ description: >-+ A token the browser made up for itself (stored in its localStorage),+ so rest-timer pushes can be aimed at the device that started the+ rest. Optional; anything that is not a short token is ignored.responses:'200':description: Stored.@@ -623,6 +632,33 @@ paths:private: { value: { error: "endpoint must not point at a private address" } }'401': { $ref: '#/components/responses/Unauthorized' }+ /api/push/status:+ get:+ tags: [push]+ operationId: pushStatus+ summary: Does the server hold this subscription?+ description: >-+ Whether the caller's account has a stored subscription with exactly this+ `endpoint`. The browser's `PushManager.getSubscription()` says nothing about+ the server's side — a row pruned after a dead send (404/410/403) leaves the+ browser subscribed to nowhere — so the client asks here before showing the+ notifications switch as on, and re-registers when the answer is no.+ parameters:+ - in: query+ name: endpoint+ required: true+ schema: { type: string, format: uri }+ responses:+ '200':+ description: The answer.+ content:+ application/json:+ schema:+ type: object+ properties:+ subscribed: { type: boolean }+ '401': { $ref: '#/components/responses/Unauthorized' }+/api/push/unsubscribe:post:tags: [push]@@ -654,7 +690,8 @@ paths:description: >-Sends a test push to all of the caller's subscriptions (localized with the`lang` in their synced state). Returns 200 even if delivery to individual- endpoints fails — dead endpoints (404/410) are pruned as a side effect.+ endpoints fails — dead endpoints (404/410, and 403 for a subscription made+ against a VAPID key the instance no longer has) are pruned as a side effect.responses:'200':description: Sends attempted.@@ -669,10 +706,14 @@ paths:operationId: pushRestTimersummary: Schedule a server-side rest-timer pushdescription: |- Schedules one push after `seconds` (clamped to 1–3600; one pending timer per- user, a new call replaces it). The client schedules this on rest start/extend- and cancels on skip or on-screen completion — the push only actually fires- when the tab was backgrounded/suspended and never got to cancel it.+ Schedules one push after `seconds` (clamped to 1–3600). One pending timer per+ device — `deviceId`, the same token the subscription was registered with; a+ new call from the same device replaces it, and the push goes only to that+ device's subscriptions. Without a `deviceId` there is one timer per account+ and the push goes to every subscription, as before. The client schedules this+ on rest start/extend and cancels on skip or on-screen completion — the push+ only actually fires when the tab was backgrounded/suspended and never got to+ cancel it. Timers live in memory: an API restart drops them.Note: the documented `400 seconds required` exists in the code but isunreachable — the clamp turns any missing/invalid value into 1.@@ -688,7 +729,11 @@ paths:type: numberminimum: 1maximum: 3600- example: { seconds: 90 }+ deviceId:+ type: string+ pattern: '^[A-Za-z0-9_-]{8,64}$'+ description: The browser's own token, see `POST /api/push/subscribe`. Optional.+ example: { seconds: 90, deviceId: "3f9c1d2e7b0a4c6d9e8f1a2b3c4d5e6f" }responses:'200':description: Timer scheduled.@@ -702,7 +747,19 @@ paths:tags: [push]operationId: pushRestTimerCancelsummary: Cancel the pending rest-timer push- description: Cancels the caller's scheduled rest-timer push, if any. Idempotent.+ description: >-+ Cancels the caller's scheduled rest-timer push, if any. With a `deviceId` only+ that device's timer; without one, every pending timer of the account. Idempotent.+ requestBody:+ required: false+ content:+ application/json:+ schema:+ type: object+ properties:+ deviceId:+ type: string+ pattern: '^[A-Za-z0-9_-]{8,64}$'responses:'200':description: Cancelled (or nothing was pending).diff --git a/api/server.js b/api/server.jsindex 15b510ddc..d27fe82f3 100644--- a/api/server.js+++ b/api/server.js@@ -185,8 +185,12 @@ function pushEndpointError(raw) {return null;}-async function sendPush(userId, payload) {- const subs = db.subs.filter(s => s.userId === userId);+// `deviceId` narrows the send to the subscriptions one browser registered (the rest-timer alert+// belongs to the device that started the rest); a subscription stored without one — an older+// client — still gets everything, as before.+async function sendPush(userId, payload, deviceId) {+ let subs = db.subs.filter(s => s.userId === userId);+ if (deviceId && subs.some(s => s.deviceId === deviceId)) subs = subs.filter(s => s.deviceId === deviceId);if (!subs.length) return;const body = JSON.stringify(payload);let dirty = false;@@ -212,7 +216,11 @@ async function sendPush(userId, payload) {{ urgency: 'high', timeout: PUSH_TIMEOUT_MS, agent: PUSH_AGENT });} catch (e) {console.error('push send failed', userId, e.statusCode, e.body || e.message);- if (e.statusCode === 404 || e.statusCode === 410) {+ // 404/410: the push service says the subscription is gone. 403: it refuses our VAPID+ // signature — a subscription made against a key this instance no longer has (data/vapid.json+ // regenerated). Neither will ever deliver again; keeping them only hides the fact from the+ // Settings toggle, which reads the browser's side. The client re-subscribes on its next boot.+ if (e.statusCode === 404 || e.statusCode === 410 || e.statusCode === 403) {db.subs = db.subs.filter(s => s.endpoint !== sub.endpoint); dirty = true;}}@@ -224,19 +232,30 @@ async function sendPush(userId, payload) {// Rest-timer alerts: client schedules on start/extend, cancels on skip or on-screen completion —// this only fires when the tab was backgrounded/suspended and never got to cancel it itself.-const restTimers = new Map(); // userId -> Timeout-function scheduleRestTimer(userId, sec, lang) {- const t = restTimers.get(userId);+// One timer per device, not per account: a phone resting in the gym and a desktop tab at home+// each carry their own, so the tab's on-screen completion (which cancels) cannot silence the+// phone's alert. A client that sends no device id gets the old account-wide behaviour.+// In memory only — an API restart drops whatever is pending.+const restTimers = new Map(); // `${userId}:${deviceId}` -> Timeout+const restKey = (userId, deviceId) => `${userId}:${deviceId || ''}`;+function scheduleRestTimer(userId, deviceId, sec, lang) {+ const k = restKey(userId, deviceId);+ const t = restTimers.get(k);if (t) clearTimeout(t);- restTimers.set(userId, setTimeout(() => {- restTimers.delete(userId);- sendPush(userId, restTimerPush(lang));+ restTimers.set(k, setTimeout(() => {+ restTimers.delete(k);+ sendPush(userId, restTimerPush(lang), deviceId);}, sec * 1000));}-function cancelRestTimer(userId) {- const t = restTimers.get(userId);- if (t) { clearTimeout(t); restTimers.delete(userId); }+function cancelRestTimer(userId, deviceId) {+ // no device id: an older client — clear everything the account has pending, as it always did+ for (const [k, t] of restTimers) {+ if (deviceId ? k === restKey(userId, deviceId) : k.startsWith(userId + ':')) { clearTimeout(t); restTimers.delete(k); }+ }}+// A device id is what the browser made up for itself (lib/push.js): one short token per browser+// profile, nothing identifying. Anything else is treated as absent.+const deviceIdOf = v => (typeof v === 'string' && /^[A-Za-z0-9_-]{8,64}$/.test(v) ? v : undefined);// "Workout planned today" reminder — one per user per day, at their chosen time.// Duplicated (not imported) from frontend/src/lib/history.js effectiveRoutineId — tiny pure helper, not worth sharing across the two runtimes.@@ -263,6 +282,34 @@ function userNow(tz) {return { date, hhmm: `${g('hour')}:${g('minute')}`, weekday: new Date(date + 'T12:00:00Z').getUTCDay() };} catch { return null; } // unknown/invalid tz string — skip this user rather than guess}+// The tick used to want the exact minute: `reminder.time === now.hhmm`, checked every 10 s. Any+// restart, redeploy or stalled event loop across that one minute lost the whole day's reminder —+// "sometimes it just doesn't come". A reminder that is due is now sent for up to this many+// minutes after its time, once per local date (`user.lastReminder`); later than that it is+// skipped rather than delivered at a time nobody asked for.+const REMINDER_WINDOW_MIN = 15;+// How often the tick looks. 10 s keeps a reminder within ~9 s of its minute; the tests shorten it.+const REMINDER_TICK_MS = Math.max(50, +(process.env.REMINDER_TICK_MS || 10000));+const hhmmToMin = v => {+ const m = /^(\d{2}):(\d{2})$/.exec(v || '');+ return m ? Number(m[1]) * 60 + Number(m[2]) : NaN;+};+// Minutes since the reminder's time on the user's clock; negative before it, NaN when either+// side does not parse. Same-day only — a 23:55 reminder is not owed at 00:05 the next day.+const minutesLate = (time, now) => hhmmToMin(now.hhmm) - hhmmToMin(time);+// The tick reads every subscribed user's state file every 10 s. Most of those files do not+// change between ticks; a stat is far cheaper than a read and a parse of a state that can be+// megabytes, and it keeps the tick short — a slow tick was one more way to miss the minute.+const stateCache = new Map(); // uid -> { mtimeMs, size, S }+function readStateCached(uid) {+ let st;+ try { st = fs.statSync(stateFile(uid)); } catch { stateCache.delete(uid); return null; }+ const hit = stateCache.get(uid);+ if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.S;+ const S = readState(uid);+ stateCache.set(uid, { mtimeMs: st.mtimeMs, size: st.size, S });+ return S;+}setInterval(() => {for (const user of db.users) {if (!db.subs.some(s => s.userId === user.id)) continue;@@ -270,10 +317,12 @@ setInterval(() => {// skipped, not allowed to take the process — and everyone else's reminders — down with it.// PUT /api/data refuses the obvious shapes, but a file already on disk answers to nobody.try {- const S = readState(user.id);+ const S = readStateCached(user.id);if (!S?.reminder?.on) continue;const now = userNow(S.reminder.tz || 'UTC');- if (!now || S.reminder.time !== now.hhmm) continue;+ if (!now) continue;+ const late = minutesLate(S.reminder.time, now);+ if (!(late >= 0 && late <= REMINDER_WINDOW_MIN)) continue;if (user.lastReminder === now.date) continue;if ((S.workouts || []).some(w => w.d === now.date)) continue;const rid = effectiveRoutineId(S, now.date);@@ -289,7 +338,7 @@ setInterval(() => {}// Checked every 10s (not 60s) — ticks aren't aligned to the top of the minute, so a 60s// interval could sit on your target minute for up to 59s before noticing. 10s caps that at ~9s.-}, 10000).unref();+}, REMINDER_TICK_MS).unref();/* ---------- sessions (signed cookie) ---------- */function sign(payload) {@@ -848,6 +897,11 @@ const routes = {// Only the two keys the push protocol needs are kept: `sub` is caller-supplied and would// otherwise put arbitrary fields into db.json, which every admin route reads back out.const keys = { p256dh: String(sub.keys.p256dh), auth: String(sub.keys.auth) };+ const deviceId = deviceIdOf(body.deviceId);+ // An upsert: the client re-sends its subscription on every boot (lib/push.js) so a row this+ // instance lost — pruned after a dead send, a rebuilt db.json — comes back without anyone+ // touching Settings. The same endpoint sent again keeps its original `created`.+ const prev = db.subs.find(s => s.endpoint === sub.endpoint);db.subs = db.subs.filter(s => s.endpoint !== sub.endpoint);// A browser holds one subscription per device, so this cap is far above real use. Without// it a single account could pile up endpoints without limit — every one of them a target@@ -857,11 +911,21 @@ const routes = {const drop = new Set(mine.slice(0, mine.length - MAX_SUBS_PER_USER + 1).map(s => s.endpoint));db.subs = db.subs.filter(s => !drop.has(s.endpoint));}- db.subs.push({ userId: user.id, endpoint: sub.endpoint, keys, created: new Date().toISOString() });+ db.subs.push({ userId: user.id, endpoint: sub.endpoint, keys, ...(deviceId ? { deviceId } : {}), created: prev?.created || new Date().toISOString() });saveDb();json(res, 200, { ok: true });},+ // Whether this instance still holds the caller's subscription for `endpoint`. The browser's+ // side (PushManager.getSubscription) says nothing about ours — a row pruned after a dead send+ // leaves the browser subscribed to nowhere — so Settings asks here before it shows "on".+ 'GET /api/push/status': async (req, res) => {+ const user = readSession(req);+ if (!user) return json(res, 401, { error: 'not signed in' });+ const endpoint = new URL(req.url, 'http://x').searchParams.get('endpoint') || '';+ json(res, 200, { subscribed: db.subs.some(s => s.userId === user.id && s.endpoint === endpoint) });+ },+'POST /api/push/unsubscribe': async (req, res) => {const user = readSession(req);if (!user) return json(res, 401, { error: 'not signed in' });@@ -884,14 +948,15 @@ const routes = {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' });- scheduleRestTimer(user.id, sec, readState(user.id)?.lang);+ scheduleRestTimer(user.id, deviceIdOf(body.deviceId), sec, readState(user.id)?.lang);json(res, 200, { ok: true });},'POST /api/push/rest-timer/cancel': async (req, res) => {const user = readSession(req);if (!user) return json(res, 401, { error: 'not signed in' });- cancelRestTimer(user.id);+ const body = await readBody(req);+ cancelRestTimer(user.id, deviceIdOf(body.deviceId));json(res, 200, { ok: true });},diff --git a/api/test/server-push-status.test.js b/api/test/server-push-status.test.jsnew file mode 100644index 000000000..459d4e82d--- /dev/null+++ b/api/test/server-push-status.test.js@@ -0,0 +1,110 @@+/* The subscription's server side. The browser keeps its PushSubscription through anything that+ happens here — a row pruned after a dead send, a rebuilt db.json — so the client re-sends it on+ every boot (an upsert that keeps `created`), asks /api/push/status before Settings shows "on",+ and tags it with a device id so a rest-timer alert goes to the device that started the rest.+ 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 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');++function mintSession(uid) {+ const payload = `${uid}:${Date.now() + 86400000}:0`;+ return payload + '.' + crypto.createHmac('sha256', SECRET).update(payload).digest('base64url');+}+const cookie = { Cookie: `gymsid=${mintSession('u_test_1')}` };+const other = { Cookie: `gymsid=${mintSession('u_test_2')}` };+const keys = { p256dh: 'p', auth: 'a' };++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, subs = []) {+ const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gym-pushstatus-'));+ fs.writeFileSync(path.join(dataDir, 'secret'), SECRET, { mode: 0o600 });+ fs.writeFileSync(path.join(dataDir, 'db.json'), JSON.stringify({+ users: [{ id: 'u_test_1', name: 'One', created: new Date().toISOString() }, { id: 'u_test_2', name: 'Two', 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}`, dataDir, log: '' };+ 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}`);+ return h;+}+const readDb = h => JSON.parse(fs.readFileSync(path.join(h.dataDir, 'db.json'), 'utf8'));+const post = (h, p, body, hdr = cookie) => fetch(`${h.api}${p}`, { method: 'POST', headers: hdr, body: JSON.stringify(body) });+const status = (h, endpoint, hdr = cookie) => fetch(`${h.api}/api/push/status?endpoint=${encodeURIComponent(endpoint)}`, { headers: hdr }).then(r => r.json());++test('status tells whether the server holds the endpoint; subscribe is an upsert that keeps created and stores the device id', async t => {+ const h = await startServer(t);+ const endpoint = 'https://push.example/one';+ assert.deepEqual(await status(h, endpoint), { subscribed: false });++ assert.equal((await post(h, '/api/push/subscribe', { subscription: { endpoint, keys }, deviceId: 'dev_aaaaaaaa' })).status, 200);+ assert.deepEqual(await status(h, endpoint), { subscribed: true });+ assert.deepEqual(await status(h, endpoint, other), { subscribed: false }, 'another account does not see it');+ const first = readDb(h).subs[0];+ assert.equal(first.deviceId, 'dev_aaaaaaaa');++ await new Promise(r => setTimeout(r, 20));+ assert.equal((await post(h, '/api/push/subscribe', { subscription: { endpoint, keys: { p256dh: 'p2', auth: 'a2' } }, deviceId: 'dev_bbbbbbbb' })).status, 200);+ const subs = readDb(h).subs;+ assert.equal(subs.length, 1, 'same endpoint sent again is one row');+ assert.equal(subs[0].created, first.created, 'created survives the re-send');+ assert.equal(subs[0].deviceId, 'dev_bbbbbbbb');+ assert.deepEqual(subs[0].keys, { p256dh: 'p2', auth: 'a2' });++ // a device id that is not a short token is dropped, not stored+ assert.equal((await post(h, '/api/push/subscribe', { subscription: { endpoint: 'https://push.example/two', keys }, deviceId: { evil: true } })).status, 200);+ assert.equal('deviceId' in readDb(h).subs.find(s => s.endpoint.endsWith('/two')), false);++ assert.equal((await fetch(`${h.api}/api/push/status?endpoint=x`)).status, 401);+});++test('a rest timer belongs to the device that set it: another device cancelling does not silence it', async t => {+ // localhost resolves to a loopback address, which PUSH_AGENT refuses — every send fails locally+ // and quietly, and "push send failed" in the log is the proof that a send was attempted.+ const mk = (deviceId, n) => ({ userId: 'u_test_1', endpoint: `https://localhost/${n}`, keys, deviceId, created: new Date().toISOString() });+ const h = await startServer(t, [mk('dev_phone000', 'phone'), mk('dev_desk0000', 'desk')]);+ const sends = () => (h.log.match(/push send failed u_test_1/g) || []).length;++ assert.equal((await post(h, '/api/push/rest-timer', { seconds: 1, deviceId: 'dev_phone000' })).status, 200);+ assert.equal((await post(h, '/api/push/rest-timer/cancel', { deviceId: 'dev_desk0000' })).status, 200);+ await new Promise(r => setTimeout(r, 2500));+ assert.equal(sends(), 1, `the phone's alert went out, to the phone's subscription only:\n${h.log}`);++ assert.equal((await post(h, '/api/push/rest-timer', { seconds: 1, deviceId: 'dev_phone000' })).status, 200);+ assert.equal((await post(h, '/api/push/rest-timer/cancel', { deviceId: 'dev_phone000' })).status, 200);+ await new Promise(r => setTimeout(r, 2500));+ assert.equal(sends(), 1, 'cancelled by its own device: nothing more went out');++ // an older client, no device id: the account-wide behaviour it always had+ assert.equal((await post(h, '/api/push/rest-timer', { seconds: 1 })).status, 200);+ assert.equal((await post(h, '/api/push/rest-timer/cancel', {})).status, 200);+ await new Promise(r => setTimeout(r, 2500));+ assert.equal(sends(), 1, 'legacy cancel clears the legacy timer');+ assert.equal((await post(h, '/api/push/rest-timer', { seconds: 1 })).status, 200);+ await new Promise(r => setTimeout(r, 2500));+ assert.equal(sends(), 3, 'a legacy timer goes to every subscription of the account');+});diff --git a/api/test/server-reminder.test.js b/api/test/server-reminder.test.jsindex 162dc660a..f3689bc18 100644--- a/api/test/server-reminder.test.js+++ b/api/test/server-reminder.test.js@@ -42,7 +42,7 @@ async function startServer(t, subs = []) {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' }+ env: { ...process.env, PORT: String(port), DATA_DIR: dataDir, ORIGIN: 'http://localhost:8080', RP_ID: 'localhost', REMINDER_TICK_MS: '300' }});const h = { api: `http://127.0.0.1:${port}`, dataDir, child, log: '' };child.stdout.on('data', d => h.log += d);@@ -113,3 +113,53 @@ test('a non-array workouts on disk is logged and skipped by the reminder tick; tconst db = JSON.parse(fs.readFileSync(path.join(h.dataDir, 'db.json'), 'utf8'));assert.ok(db.users.find(u => u.id === 'u_test_2').lastReminder, 'the good user\'s reminder was recorded');});++/* The catch-up window. The tick used to want the exact minute — an API restart or a stalled+ tick across those 60 s lost the whole day's reminder. A reminder is now owed for 15 minutes+ after its time, once per local date, and not later than that. */+const hhmmMinusMinutes = m => {+ const d = new Date(Date.now() - m * 60000);+ const parts = new Intl.DateTimeFormat('en-CA', { timeZone: 'UTC', hour12: false, hour: '2-digit', minute: '2-digit' }).formatToParts(d);+ const g = type => parts.find(p => p.type === type)?.value;+ return { hhmm: `${g('hour')}:${g('minute')}`, sameDay: d.getUTCDate() === new Date().getUTCDate() };+};+const goodState = (time, over = {}) => JSON.stringify({+ reminder: { on: true, time, tz: 'UTC' },+ routines: [{ id: 'r1', name: 'Full body', emoji: '💪', ex: [] }],+ week: { 0: 'r1', 1: 'r1', 2: 'r1', 3: 'r1', 4: 'r1', 5: 'r1', 6: 'r1' },+ workouts: [], ...over+});+const sub = { userId: 'u_test_1', endpoint: 'https://localhost/x', keys: { p256dh: 'p', auth: 'a' }, created: new Date().toISOString() };+const firings = log => (log.match(/reminder firing u_test_1 r1/g) || []).length;+const wait = ms => new Promise(r => setTimeout(r, ms));++test('a reminder whose minute passed 3 minutes ago still fires — once', async t => {+ const late = hhmmMinusMinutes(3);+ if (!late.sameDay) return t.skip('just after midnight UTC — a same-day window cannot be set up');+ const h = await startServer(t, [sub]);+ fs.writeFileSync(path.join(h.dataDir, 'state-u_test_1.json'), goodState(late.hhmm));+ const deadline = Date.now() + 30000;+ while (Date.now() < deadline && !firings(h.log)) await wait(300);+ assert.equal(firings(h.log), 1, h.log);+ // several more ticks: the date-level dedupe holds inside the window+ await wait(1500);+ assert.equal(firings(h.log), 1, 'fired again inside the window');+ const db = JSON.parse(fs.readFileSync(path.join(h.dataDir, 'db.json'), 'utf8'));+ assert.ok(db.users.find(u => u.id === 'u_test_1').lastReminder, 'the day is recorded');+});++test('a reminder 20 minutes past is not delivered late, and a day already trained is skipped', async t => {+ const stale = hhmmMinusMinutes(20);+ const late = hhmmMinusMinutes(2);+ if (!stale.sameDay || !late.sameDay) return t.skip('just after midnight UTC — a same-day window cannot be set up');+ const h = await startServer(t, [sub]);+ const file = path.join(h.dataDir, 'state-u_test_1.json');+ fs.writeFileSync(file, goodState(stale.hhmm));+ await wait(1500); // several ticks+ assert.equal(firings(h.log), 0, `20 minutes late must stay silent:\n${h.log}`);+ // inside the window but today's workout is already logged+ const today = new Intl.DateTimeFormat('en-CA', { timeZone: 'UTC', year: 'numeric', month: '2-digit', day: '2-digit' }).format(new Date());+ fs.writeFileSync(file, goodState(late.hhmm, { workouts: [{ id: 'w1', d: today }] }));+ await wait(1500);+ assert.equal(firings(h.log), 0, `a trained day must stay silent:\n${h.log}`);+});diff --git a/frontend/public/sw.js b/frontend/public/sw.jsindex 522f01302..7b21b7215 100644--- a/frontend/public/sw.js+++ b/frontend/public/sw.js@@ -8,15 +8,21 @@ self.addEventListener('activate', e => {Promise.all(keys.filter(k => k !== CACHE).map(k => caches.delete(k)))).then(() => self.clients.claim()))})+// Every push shows a notification, whatever the payload: a push that shows nothing counts+// against the site (Chrome revokes the subscription after a few), and a payload that fails to+// parse used to throw before waitUntil was ever reached — exactly such a silent push.self.addEventListener('push', e => {- const data = e.data ? e.data.json() : {}- e.waitUntil(self.registration.showNotification(data.title || 'openGym', {- body: data.body || '',- icon: 'icon-512.png',- badge: 'icon-180.png',- tag: data.tag || 'opengym',- renotify: true- }))+ e.waitUntil((async () => {+ let data = {}+ try { data = e.data ? e.data.json() : {} } catch { data = { body: (() => { try { return e.data.text() } catch { return '' } })() } }+ await self.registration.showNotification(data.title || 'openGym', {+ body: data.body || '',+ icon: 'icon-512.png',+ badge: 'icon-180.png',+ tag: data.tag || 'opengym',+ renotify: true+ })+ })())})self.addEventListener('notificationclick', e => {e.notification.close()@@ -26,6 +32,31 @@ self.addEventListener('notificationclick', e => {}))})+// The push service rotated the subscription (it does, unannounced, every few months on some+// platforms). Without this the server keeps sending to the old endpoint until it 410s, and the+// browser holds a new one nobody registered — "notifications just stopped". Re-subscribe with+// the same application server key and hand the new endpoint to the API; the session cookie+// travels with the same-origin fetch. Signed out, the API answers 401 and the next signed-in+// boot (lib/push.js syncPushSubscription) registers it instead.+const b64ToBytes = b64 => {+ const padded = (b64 + '='.repeat((4 - b64.length % 4) % 4)).replace(/-/g, '+').replace(/_/g, '/')+ return Uint8Array.from(atob(padded), c => c.charCodeAt(0))+}+self.addEventListener('pushsubscriptionchange', e => {+ e.waitUntil((async () => {+ let key = e.oldSubscription?.options?.applicationServerKey+ if (!key) {+ const r = await fetch(new URL('api/push/public-key', self.registration.scope))+ key = b64ToBytes((await r.json()).key)+ }+ const sub = e.newSubscription || await self.registration.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: key })+ await fetch(new URL('api/push/subscribe', self.registration.scope), {+ method: 'POST', headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify({ subscription: sub.toJSON() })+ })+ })().catch(() => {}))+})+self.addEventListener('fetch', e => {const url = new URL(e.request.url)if (e.request.method !== 'GET' || url.origin !== location.origin) returndiff --git a/frontend/src/App.jsx b/frontend/src/App.jsxindex c387d4a95..b6ba503aa 100644--- a/frontend/src/App.jsx+++ b/frontend/src/App.jsx@@ -10,6 +10,8 @@ import { initBackButton } from './lib/back.js'import { useWakeLock } from './lib/wakelock.js'import { installViewportGuard } from './lib/viewport-guard.js'import { installChipDrag } from './lib/hchips.js'+import { syncPushSubscription } from './lib/push.js'+import { MOBILE } from './lib/mobile.js'import { startFlow } from './sheets.jsx'import Icon from './components/Icon.jsx'import TabBar from './components/TabBar.jsx'@@ -84,6 +86,13 @@ function Shell() {// Click-drag a horizontal chip strip to scroll it sideways (lib/hchips.js) — on a desktop// browser there's otherwise no way to reach the filters past the edge.useEffect(() => installChipDrag(), [])+ // Once per signed-in boot, hand the server this browser's push subscription again (see+ // lib/push.js): a subscription the instance lost is back before the next reminder is due,+ // with nobody having to visit Settings. Web only — the APK has no service worker.+ useEffect(() => {+ if (MOBILE || !user || !ready) return+ syncPushSubscription().catch(() => {})+ }, [user?.id, ready])useEffect(() => {const onScroll = () => {// Modals pins the body while a sheet is open; scrollY is 0 then, not a position.diff --git a/frontend/src/lib/push.js b/frontend/src/lib/push.jsindex 4de1eba7d..83135185e 100644--- a/frontend/src/lib/push.js+++ b/frontend/src/lib/push.js@@ -2,7 +2,10 @@// server-side per user, same as everything else under /api).import { api } from './api.js'-export const pushSupported = () => 'serviceWorker' in navigator && 'PushManager' in window && 'Notification' in window+// main.jsx registers the service worker on https only, so on any other origin there is no+// worker and `navigator.serviceWorker.ready` never settles — the toggle looked usable and hung.+const secureOrigin = () => typeof location === 'undefined' || location.protocol === 'https:'+export const pushSupported = () => 'serviceWorker' in navigator && 'PushManager' in window && 'Notification' in window && secureOrigin()export const pushPermission = () => (pushSupported() ? Notification.permission : 'unsupported')const urlBase64ToUint8Array = b64 => {@@ -10,24 +13,78 @@ const urlBase64ToUint8Array = b64 => {const raw = atob(padded)return Uint8Array.from([...raw].map(c => c.charCodeAt(0)))}+const bytesToUrlBase64 = buf => btoa(String.fromCharCode(...new Uint8Array(buf))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')++// One token per browser profile, made up here and never shown: it tells the server which of+// the account's subscriptions belong to this device, so a rest-timer alert goes to the phone+// that started the rest and not to every tab of the account. Nothing identifying in it.+const DEVICE_KEY = 'gym_device'+export function deviceId() {+ try {+ let id = localStorage.getItem(DEVICE_KEY)+ if (!id) {+ id = (crypto.randomUUID?.() || Array.from(crypto.getRandomValues(new Uint8Array(16)), b => b.toString(16).padStart(2, '0')).join('')).replace(/-/g, '')+ localStorage.setItem(DEVICE_KEY, id)+ }+ return id+ } catch { return undefined }+}++// The worker is registered at boot; on https it is there within a moment, but a promise that+// never settles must not hang a settings screen or the boot path — give it a bounded wait.+const readyWorker = (ms = 8000) => Promise.race([+ navigator.serviceWorker.ready,+ new Promise((_, reject) => setTimeout(() => reject(new Error('Service worker not ready')), ms))+])++const register = sub => api('/api/push/subscribe', { method: 'POST', body: JSON.stringify({ subscription: sub.toJSON(), deviceId: deviceId() }) })export async function enablePush() {if (!pushSupported()) throw new Error('Push notifications are not supported in this browser')const perm = await Notification.requestPermission()if (perm !== 'granted') throw new Error('Notifications permission was not granted')- const reg = await navigator.serviceWorker.ready+ const reg = await readyWorker()const { key } = await api('/api/push/public-key')const subscription = await reg.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: urlBase64ToUint8Array(key) })- await api('/api/push/subscribe', { method: 'POST', body: JSON.stringify({ subscription: subscription.toJSON() }) })+ await register(subscription)}export async function disablePush() {if (!pushSupported()) return- const reg = await navigator.serviceWorker.ready+ const reg = await readyWorker()const sub = await reg.pushManager.getSubscription()if (!sub) returnawait sub.unsubscribe()await api('/api/push/unsubscribe', { method: 'POST', body: JSON.stringify({ endpoint: sub.endpoint }) }).catch(() => {})}+/* Brings the server's copy of this browser's subscription back in line with the browser's.+ Called once per signed-in boot and when Settings opens. The browser keeps its subscription+ through anything that happens on the server — a row pruned after a dead send, a rebuilt+ db.json, a regenerated VAPID key — and the toggle used to read "on" from the browser's side+ while nothing was ever going to arrive. Resolves to whether the server now holds it:+ - no permission or no subscription here → false, nothing to do;+ - the server already has this endpoint → true, no write;+ - the server lost it → re-registered, true;+ - the server's key changed → the old subscription is useless; unsubscribe, subscribe against+ the new key, register, true.+ Network failures propagate — the caller decides what "unknown" means for it. */+export async function syncPushSubscription() {+ if (!pushSupported() || Notification.permission !== 'granted') return false+ const reg = await readyWorker()+ let sub = await reg.pushManager.getSubscription()+ if (!sub) return false+ const { key } = await api('/api/push/public-key')+ const mine = sub.options?.applicationServerKey+ if (mine && key && bytesToUrlBase64(mine) !== key.replace(/=+$/, '')) {+ await sub.unsubscribe().catch(() => {})+ sub = await reg.pushManager.subscribe({ userVisibleOnly: true, applicationServerKey: urlBase64ToUint8Array(key) })+ await register(sub)+ return true+ }+ const { subscribed } = await api('/api/push/status?endpoint=' + encodeURIComponent(sub.endpoint))+ if (!subscribed) await register(sub)+ return true+}+export const sendTestPush = () => api('/api/push/test', { method: 'POST', body: '{}' })diff --git a/frontend/src/lib/push.test.js b/frontend/src/lib/push.test.jsnew file mode 100644index 000000000..b4b7d71f3--- /dev/null+++ b/frontend/src/lib/push.test.js@@ -0,0 +1,100 @@+// @vitest-environment happy-dom+// @vitest-environment-options { "url": "https://gym.test/" }+import { describe, it, expect, vi, beforeEach } from 'vitest'++const calls = []+vi.mock('./api.js', () => ({+ api: vi.fn(async (path, opts) => {+ calls.push([path, opts?.method || 'GET', opts?.body ? JSON.parse(opts.body) : null])+ if (path === '/api/push/public-key') return { key: KEY }+ if (path.startsWith('/api/push/status')) return { subscribed: serverHas }+ return { ok: true }+ })+}))++const KEY = 'BPqx2m6xQ6pQK5hQtMz6d3kM2s7gq4yHqQvWzZ1sK1c' // any base64url string+const keyBytes = b64 => {+ const padded = (b64 + '='.repeat((4 - b64.length % 4) % 4)).replace(/-/g, '+').replace(/_/g, '/')+ return Uint8Array.from(atob(padded), c => c.charCodeAt(0)).buffer+}+let serverHas = true+let sub = null+const makeSub = key => ({+ endpoint: 'https://push.example/e1', options: { applicationServerKey: keyBytes(key) },+ toJSON: () => ({ endpoint: 'https://push.example/e1', keys: { p256dh: 'p', auth: 'a' } }),+ unsubscribe: vi.fn(async () => { sub = null; return true })+})+const reg = {+ pushManager: {+ getSubscription: vi.fn(async () => sub),+ subscribe: vi.fn(async ({ applicationServerKey }) => { sub = makeSub(KEY); sub.options.applicationServerKey = applicationServerKey; return sub })+ }+}++beforeEach(() => {+ calls.length = 0+ serverHas = true+ sub = null+ localStorage.clear()+ Object.defineProperty(navigator, 'serviceWorker', { value: { ready: Promise.resolve(reg) }, configurable: true })+ globalThis.PushManager = function () {}+ globalThis.Notification = { permission: 'granted', requestPermission: vi.fn(async () => 'granted') }+})++describe('deviceId', () => {+ it('makes one token per browser and keeps it', async () => {+ const { deviceId } = await import('./push.js')+ const a = deviceId()+ expect(a).toMatch(/^[A-Za-z0-9_-]{8,64}$/)+ expect(deviceId()).toBe(a)+ expect(localStorage.getItem('gym_device')).toBe(a)+ })+})++describe('syncPushSubscription', () => {+ it('does nothing without permission or without a subscription', async () => {+ const { syncPushSubscription } = await import('./push.js')+ Notification.permission = 'default'+ expect(await syncPushSubscription()).toBe(false)+ Notification.permission = 'granted'+ expect(await syncPushSubscription()).toBe(false)+ expect(calls).toEqual([])+ })++ it('asks the server and does not write when it already holds the endpoint', async () => {+ const { syncPushSubscription } = await import('./push.js')+ sub = makeSub(KEY)+ expect(await syncPushSubscription()).toBe(true)+ expect(calls.map(c => c[1] + ' ' + c[0].split('?')[0])).toEqual(['GET /api/push/public-key', 'GET /api/push/status'])+ })++ it('re-registers a subscription the server lost, with the device id', async () => {+ const { syncPushSubscription, deviceId } = await import('./push.js')+ sub = makeSub(KEY)+ serverHas = false+ expect(await syncPushSubscription()).toBe(true)+ const post = calls.find(c => c[0] === '/api/push/subscribe')+ expect(post[2]).toEqual({ subscription: { endpoint: 'https://push.example/e1', keys: { p256dh: 'p', auth: 'a' } }, deviceId: deviceId() })+ expect(reg.pushManager.subscribe).not.toHaveBeenCalled()+ })++ it('replaces a subscription made against a key the server no longer has', async () => {+ const { syncPushSubscription } = await import('./push.js')+ const old = makeSub('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')+ sub = old+ expect(await syncPushSubscription()).toBe(true)+ expect(old.unsubscribe).toHaveBeenCalled()+ expect(reg.pushManager.subscribe).toHaveBeenCalledTimes(1)+ expect(new Uint8Array(reg.pushManager.subscribe.mock.calls[0][0].applicationServerKey)).toEqual(new Uint8Array(keyBytes(KEY)))+ expect(calls.some(c => c[0] === '/api/push/subscribe')).toBe(true)+ expect(calls.some(c => c[0].startsWith('/api/push/status'))).toBe(false)+ })+})++describe('pushSupported', () => {+ it('needs the service worker, PushManager, Notification and an https origin', async () => {+ const { pushSupported } = await import('./push.js')+ expect(pushSupported()).toBe(true)+ expect(location.protocol).toBe('https:')+ })+})diff --git a/frontend/src/store/useUI.js b/frontend/src/store/useUI.jsindex 884178958..801314e92 100644--- a/frontend/src/store/useUI.js+++ b/frontend/src/store/useUI.js@@ -3,12 +3,15 @@ import { uid } from '../lib/format.js'import { beep, vibrate } from '../lib/sound.js'import { api } from '../lib/api.js'import { t } from '../lib/i18n.js'+import { deviceId } from '../lib/push.js'import { useStore } from './useStore.js'// Fire-and-forget: lets the server push a "rest over" alert if this tab gets suspended-// before the local timer completes. No-ops for guests / offline.-const pushRestTimer = sec => { if (useStore.getState().user) api('/api/push/rest-timer', { method: 'POST', body: JSON.stringify({ seconds: sec }) }).catch(() => {}) }-const cancelPushRestTimer = () => { if (useStore.getState().user) api('/api/push/rest-timer/cancel', { method: 'POST', body: '{}' }).catch(() => {}) }+// before the local timer completes. No-ops for guests / offline. The device id keeps the+// timer this browser's own: a desktop tab finishing its rest on screen used to cancel the+// alert the phone in the gym was waiting for, because the server held one timer per account.+const pushRestTimer = sec => { if (useStore.getState().user) api('/api/push/rest-timer', { method: 'POST', body: JSON.stringify({ seconds: sec, deviceId: deviceId() }) }).catch(() => {}) }+const cancelPushRestTimer = () => { if (useStore.getState().user) api('/api/push/rest-timer/cancel', { method: 'POST', body: JSON.stringify({ deviceId: deviceId() }) }).catch(() => {}) }const notificationsSupported = () => typeof window !== 'undefined' && 'Notification' in windowlet requestRestNotificationPermissionP = nulldiff --git a/frontend/src/views/Settings.jsx b/frontend/src/views/Settings.jsxindex c4e7688ca..83d3d7e22 100644--- a/frontend/src/views/Settings.jsx+++ b/frontend/src/views/Settings.jsx@@ -7,7 +7,7 @@ import { useUI } from '../store/useUI.js'import { ACCENTS, todayISO, localTZ, weekStartOf, MONDAY, SUNDAY } from '../lib/format.js'import { effortOf } from '../lib/history.js'import { api, webauthnOK, passkeyLogin, passkeyRegister, IS_ANDROID } from '../lib/api.js'-import { pushSupported, enablePush, disablePush, sendTestPush } from '../lib/push.js'+import { pushSupported, enablePush, disablePush, sendTestPush, syncPushSubscription } from '../lib/push.js'import { wakeLockSupported } from '../lib/wakelock.js'import { t, LANGS, INSTR_LANGS } from '../lib/i18n.js'import { DEMO, REPO } from '../lib/demo.js'@@ -544,9 +544,17 @@ function PushCard({ S, update, toast }) {const [busy, setBusy] = useState(false)const supported = pushSupported()+ // "On" means the server holds this browser's subscription, not merely that the browser has+ // one: a row the instance dropped (dead send, rebuilt db.json) left the switch on with nothing+ // ever arriving. syncPushSubscription re-registers on the way; if the server cannot be asked+ // (offline), the browser's side is the best answer available.useEffect(() => {if (!supported) return- navigator.serviceWorker.ready.then(reg => reg.pushManager.getSubscription()).then(sub => setOn(!!sub)).catch(() => {})+ let gone = false+ syncPushSubscription()+ .then(ok => { if (!gone) setOn(ok) })+ .catch(() => navigator.serviceWorker.ready.then(reg => reg.pushManager.getSubscription()).then(sub => { if (!gone) setOn(!!sub) }).catch(() => {}))+ return () => { gone = true }}, [supported])const toggle = async v => {