@mjasnikovs/pi-task 0.13.5 → 0.13.7

package/dist/remote/bridge.js

@@ -1,4 +1,4 @@
-import { broadcast as wsBroadcast, hasConnectedClients } from './broadcast.js';
+import { broadcast as wsBroadcast } from './broadcast.js';
 import { pushNotify } from './push.js';
 import { setPrompt, clearPrompt } from './session-state.js';
 const g = globalThis;
@@ -56,9 +56,10 @@ export class SessionUI {
             allowSkip: spec.allowSkip
         };
         setPrompt(prompt);
-        // Reaches a backgrounded/suspended phone, which the in-page UI can't.
-        if (!hasConnectedClients())
-            void pushNotify('pi needs your input', spec.question, 'pi-prompt').catch(() => { });
+        // Reaches a backgrounded/suspended phone, which the in-page UI can't. The
+        // service worker drops the banner if a window is visible+focused (sw.ts),
+        // so we always push and let delivery-time visibility decide.
+        void pushNotify('pi needs your input', spec.question, 'pi-prompt').catch(() => { });
         // Local: resolves to a value/undefined, or undefined on abort. Swallow
         // the rejection some implementations throw on abort so it never leaks.
         const local = this.ctx.hasUI ?

package/dist/remote/broadcast.d.ts

@@ -3,4 +3,3 @@ export declare function addClient(ws: WebSocket): void;
 export declare function removeClient(ws: WebSocket): void;
 export declare function broadcast(msg: unknown): void;
 export declare function sendTo(ws: WebSocket, msg: unknown): void;
-export declare function hasConnectedClients(): boolean;

package/dist/remote/broadcast.js

@@ -22,10 +22,3 @@ export function sendTo(ws, msg) {
         ws.send(JSON.stringify(msg));
     }
 }
-export function hasConnectedClients() {
-    for (const ws of clients) {
-        if (ws.readyState === ws.OPEN)
-            return true;
-    }
-    return false;
-}

package/dist/remote/events.js

@@ -1,7 +1,6 @@
 import { setAgentIdle } from './state.js';
 import { pushNotify } from './push.js';
 import { publishNotify } from './bridge.js';
-import { hasConnectedClients } from './broadcast.js';
 import { agentStart, appendText, textEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
 /** Mirror pi agent events into the authoritative SessionState. Each handler
  *  drives a mutator, which updates the snapshot AND broadcasts the live delta. */
@@ -23,8 +22,10 @@ export function setupEvents(pi) {
             if (errorMessage || ae.reason === 'error') {
                 const message = errorMessage || 'Request failed';
                 addError(message);
-                if (!hasConnectedClients())
-                    void pushNotify('Agent error', message, 'pi-error').catch(() => { });
+                // Always push; the service worker suppresses the banner when a
+                // window is actually visible+focused (sw.ts), which is the only
+                // reliable foreground signal — an open WebSocket is not one.
+                void pushNotify('Agent error', message, 'pi-error').catch(() => { });
             }
         }
     });
@@ -43,8 +44,7 @@ export function setupEvents(pi) {
     pi.on('agent_end', (_event, ctx) => {
         setAgentIdle(true);
         agentEnd(ctx.getContextUsage());
-        if (!hasConnectedClients())
-            void pushNotify('Task finished', '', 'pi-end').catch(() => { });
+        void pushNotify('Task finished', '', 'pi-end').catch(() => { });
     });
     pi.on('input', (event, _ctx) => {
         if (event.source === 'interactive' && typeof event.text === 'string') {

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/server.js

@@ -121,21 +121,6 @@ export async function startServer(onMessage, getHtml) {
         handle.onFirstConnect = null;
         // One authoritative snapshot — the client replaces its whole view with it.
         sendTo(ws, snapshot());
-        // Heartbeat: ping every 30 s; terminate if the client doesn't respond.
-        // This catches phones that close/sleep without sending a TCP FIN, so the
-        // server's client-set stays accurate and push notifications fire correctly.
-        let alive = true;
-        const heartbeat = setInterval(() => {
-            if (!alive) {
-                ws.terminate();
-                return;
-            }
-            alive = false;
-            ws.ping();
-        }, 10_000);
-        ws.on('pong', () => {
-            alive = true;
-        });
         ws.on('message', data => {
             let msg;
             try {
@@ -157,7 +142,6 @@ export async function startServer(onMessage, getHtml) {
             onMessage(msg.text);
         });
         ws.on('close', () => {
-            clearInterval(heartbeat);
             removeClient(ws);
         });
     });

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;