@mjasnikovs/pi-task 0.13.6 → 0.13.7

package/dist/remote/push.d.ts

@@ -11,10 +11,16 @@ export interface VapidKeys {
     publicKey: string;
     privateKey: string;
 }
-/** Where the VAPID keypair is persisted. Follows the repo's XDG convention
- *  (see workers/docs-core.ts), but under data-home so it survives cache clears —
- *  losing these keys invalidates every existing browser subscription. */
+/** Where the VAPID keypair is persisted — losing these keys invalidates every
+ *  existing browser subscription. */
 export declare function vapidStorePath(): string;
+/** Where browser push subscriptions are mirrored to disk (next to vapid.json).
+ *  Without this, a server restart — e.g. after a rebuild — silently drops every
+ *  device: the in-memory store is empty, and a backgrounded/suspended PWA won't
+ *  re-register until the user next foregrounds it, which is exactly when the push
+ *  is no longer useful. The in-memory store stays authoritative within a process;
+ *  this is its durable mirror. */
+export declare function subscriptionsStorePath(): string;
 /** Diagnostic log file. Defaults to /tmp for easy tailing; override with
  *  PI_REMOTE_PUSH_LOG. (The VAPID key stays in its durable XDG location.) */
 export declare function pushLogPath(): string;
@@ -30,6 +36,9 @@ export declare function logPush(line: string): void;
 /** Load the persisted VAPID keypair, generating and saving one on first use or
  *  if the stored file is missing/corrupt. Stable across restarts. */
 export declare function loadOrCreateVapidKeys(file?: string): VapidKeys;
+/** Load persisted subscriptions into the in-memory store. Best-effort: a missing
+ *  or corrupt file just leaves the store as-is. Returns the resulting count. */
+export declare function loadSubscriptions(file?: string): number;
 export declare function addSubscription(sub: PushSubscriptionJSON): void;
 export declare function removeSubscription(endpoint: string): void;
 export declare function getSubscriptions(): PushSubscriptionJSON[];

package/dist/remote/push.js

@@ -2,12 +2,25 @@ import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import os from 'node:os';
 import path from 'node:path';
 import webpush from 'web-push';
-/** Where the VAPID keypair is persisted. Follows the repo's XDG convention
- *  (see workers/docs-core.ts), but under data-home so it survives cache clears —
- *  losing these keys invalidates every existing browser subscription. */
+/** Resolve the XDG data-home base. Under data-home (not cache) so the files it
+ *  roots survive cache clears. Follows the repo's XDG convention; see
+ *  workers/docs-core.ts. */
+function dataHome() {
+    return process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), '.local', 'share');
+}
+/** Where the VAPID keypair is persisted — losing these keys invalidates every
+ *  existing browser subscription. */
 export function vapidStorePath() {
-    const base = process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), '.local', 'share');
-    return path.join(base, 'pi-task', 'vapid.json');
+    return path.join(dataHome(), 'pi-task', 'vapid.json');
+}
+/** Where browser push subscriptions are mirrored to disk (next to vapid.json).
+ *  Without this, a server restart — e.g. after a rebuild — silently drops every
+ *  device: the in-memory store is empty, and a backgrounded/suspended PWA won't
+ *  re-register until the user next foregrounds it, which is exactly when the push
+ *  is no longer useful. The in-memory store stays authoritative within a process;
+ *  this is its durable mirror. */
+export function subscriptionsStorePath() {
+    return path.join(dataHome(), 'pi-task', 'subscriptions.json');
 }
 /** Diagnostic log file. Defaults to /tmp for easy tailing; override with
  *  PI_REMOTE_PUSH_LOG. (The VAPID key stays in its durable XDG location.) */
@@ -69,26 +82,67 @@ export function loadOrCreateVapidKeys(file = vapidStorePath()) {
     return keys;
 }
 // In-memory subscription store, keyed by endpoint. Persisted on globalThis so it
-// survives jiti re-evaluation on session switches (same pattern as broadcast.ts).
-// Subscriptions themselves are not written to disk: the browser re-subscribes on
-// every page load, so an in-memory set is sufficient and self-healing.
+// survives jiti re-evaluation on session switches (same pattern as broadcast.ts),
+// and mirrored to disk (subscriptionsStorePath) so it also survives a full
+// process restart. A re-subscribe on page load can't be relied on for that: the
+// devices that need server push are backgrounded/suspended and won't reload.
 const g = globalThis;
+const freshStore = !g.__piRemoteSubs;
 if (!g.__piRemoteSubs)
     g.__piRemoteSubs = new Map();
 const subs = g.__piRemoteSubs;
+// Hydrate once per process: a restarted server reloads the devices it knew so it
+// can keep reaching them without waiting for each to re-register.
+if (freshStore)
+    loadSubscriptions();
+function isSubscription(x) {
+    return (typeof x === 'object'
+        && x !== null
+        && typeof x.endpoint === 'string');
+}
+/** Load persisted subscriptions into the in-memory store. Best-effort: a missing
+ *  or corrupt file just leaves the store as-is. Returns the resulting count. */
+export function loadSubscriptions(file = subscriptionsStorePath()) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (Array.isArray(parsed)) {
+            for (const s of parsed)
+                if (isSubscription(s))
+                    subs.set(s.endpoint, s);
+        }
+    }
+    catch {
+        // missing or corrupt — keep whatever is already in memory
+    }
+    return subs.size;
+}
+/** Mirror the current store to disk. Best-effort; never throws, so a failed write
+ *  can't break a subscribe request or a push. */
+function saveSubscriptions(file = subscriptionsStorePath()) {
+    try {
+        mkdirSync(path.dirname(file), { recursive: true });
+        writeFileSync(file, JSON.stringify([...subs.values()]), 'utf8');
+    }
+    catch {
+        // persistence is best-effort; the in-memory store remains authoritative
+    }
+}
 export function addSubscription(sub) {
     if (!sub.endpoint)
         return;
     subs.set(sub.endpoint, sub);
+    saveSubscriptions();
 }
 export function removeSubscription(endpoint) {
-    subs.delete(endpoint);
+    if (subs.delete(endpoint))
+        saveSubscriptions();
 }
 export function getSubscriptions() {
     return [...subs.values()];
 }
 export function clearSubscriptions() {
     subs.clear();
+    saveSubscriptions();
 }
 /** True when the push service says the subscription is permanently gone and
  *  should be dropped (404 Not Found, 410 Gone). */

package/dist/remote/ui-script.d.ts

@@ -0,0 +1,3 @@
+/** The remote web client script (vanilla JS shipped as a string).
+ * `wsUrl` is the LAN/Tailscale fallback baked in as FALLBACK_WS_URL. */
+export declare function clientScript(wsUrl: string): string;