@mjasnikovs/pi-task 0.13.6 → 0.13.8

package/dist/config/register.js

@@ -11,7 +11,7 @@ const ITEMS = [
     {
         id: 'autoCommit',
         label: 'auto-commit',
-        description: 'git commit after each /task-auto sub-task'
+        description: 'git commit around each /task-auto sub-task (checkpoint before, snapshot after)'
     }
 ];
 function makeTheme(theme) {

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

@@ -5,7 +5,7 @@ import { reset, addUserTurn } from './session-state.js';
 import { html } from './ui.js';
 import { qrLines } from './qr.js';
 import { startServer, formatAddresses } from './server.js';
-import { ensureTailscaleServe, teardownTailscaleServe, planRemoteUrls } from './tailscale.js';
+import { ensureTailscaleServe, teardownTailscaleServe, planRemoteUrls, hostFromResult } from './tailscale.js';
 import { isAgentIdle } from './state.js';
 const _g = globalThis;
 if (!_g.__piRemote)
@@ -105,10 +105,14 @@ export function registerRemote(pi) {
                 const server = await ensureServer();
                 const httpPrimary = `http://${server.ip}:${server.port}`;
                 const result = S.serveResult ?? { state: 'unavailable' };
-                const plan = planRemoteUrls(httpPrimary, result);
+                const plan = planRemoteUrls(httpPrimary, result, server.port);
                 const primaryUrl = plan.primaryUrl;
                 const qr = await qrLines(primaryUrl);
-                const addrs = [...plan.urlLines, ...formatAddresses(server.ips, server.port)];
+                const tsHost = hostFromResult(result);
+                const addrs = [
+                    ...plan.urlLines,
+                    ...formatAddresses(server.ips, server.port, tsHost)
+                ];
                 const labelW = addrs.reduce((m, a) => Math.max(m, a.label.length), 0);
                 const addrLines = [
                     ...addrs.map(a => (a.label ? `${a.label.padEnd(labelW)}  ${a.url}` : a.url)),

package/dist/remote/server.d.ts

@@ -24,7 +24,9 @@ export interface ServerHandle {
 type MessageCallback = (text: string) => void;
 export declare function getLocalIPs(nets?: NodeJS.Dict<import("node:os").NetworkInterfaceInfo[]>): LocalIPs;
 /** Build the labeled URL lines shown under the QR code. Both Tailscale and LAN
- *  when present; a single unlabeled primary URL when neither resolves. */
-export declare function formatAddresses(ips: LocalIPs, port: number): AddressLine[];
+ *  when present; a single unlabeled primary URL when neither resolves. The
+ *  Tailscale line uses the MagicDNS host when known (resolves to the same node,
+ *  but is what SSH and webpush certs need), falling back to the raw IP. */
+export declare function formatAddresses(ips: LocalIPs, port: number, tsHost?: string): AddressLine[];
 export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string): Promise<ServerHandle>;
 export {};

package/dist/remote/server.js

@@ -33,10 +33,14 @@ export function getLocalIPs(nets = networkInterfaces()) {
     return { tailscale, lan, primary: tailscale ?? lan ?? '127.0.0.1' };
 }
 /** Build the labeled URL lines shown under the QR code. Both Tailscale and LAN
- *  when present; a single unlabeled primary URL when neither resolves. */
-export function formatAddresses(ips, port) {
+ *  when present; a single unlabeled primary URL when neither resolves. The
+ *  Tailscale line uses the MagicDNS host when known (resolves to the same node,
+ *  but is what SSH and webpush certs need), falling back to the raw IP. */
+export function formatAddresses(ips, port, tsHost) {
     const out = [];
-    if (ips.tailscale)
+    if (tsHost)
+        out.push({ label: 'Tailscale', url: `http://${tsHost}:${port}` });
+    else if (ips.tailscale)
         out.push({ label: 'Tailscale', url: `http://${ips.tailscale}:${port}` });
     if (ips.lan)
         out.push({ label: 'LAN', url: `http://${ips.lan}:${port}` });

package/dist/remote/tailscale.d.ts

@@ -9,6 +9,7 @@ export interface Run {
 export type ServeResult = {
     state: 'served';
     url: string;
+    host: string;
 } | {
     state: 'foreign-conflict';
     host: string;
@@ -18,6 +19,8 @@ export type ServeResult = {
 } | {
     state: 'unavailable';
 };
+/** The MagicDNS host of a serve result, or undefined when the daemon had no name. */
+export declare function hostFromResult(result: ServeResult): string | undefined;
 export interface RemoteUrlPlan {
     /** URL to encode in the QR and announce; the https one when serve is live. */
     primaryUrl: string;
@@ -41,5 +44,8 @@ export declare function ensureTailscaleServe(port: number, run?: Run): Promise<S
  *  Best-effort; callers should additionally `.catch()` since it may run during
  *  shutdown. */
 export declare function teardownTailscaleServe(port: number, run?: Run): Promise<void>;
-/** Pure: pick the primary URL and any hint lines from a serve result. */
-export declare function planRemoteUrls(httpPrimary: string, result: ServeResult): RemoteUrlPlan;
+/** Pure: pick the primary URL (what the QR encodes) and any hint lines from a
+ *  serve result. Prefers the MagicDNS host over the raw IP whenever it's known —
+ *  the https URL when serve is live, else http://<host>:<port> — so the QR and
+ *  the announced URL carry the tailnet name (needed for SSH and webpush certs). */
+export declare function planRemoteUrls(httpPrimary: string, result: ServeResult, port: number): RemoteUrlPlan;

package/dist/remote/tailscale.js

@@ -1,4 +1,8 @@
 import { execFile } from 'node:child_process';
+/** The MagicDNS host of a serve result, or undefined when the daemon had no name. */
+export function hostFromResult(result) {
+    return result.state === 'unavailable' ? undefined : result.host;
+}
 const defaultRun = (cmd, args) => new Promise(resolve => {
     execFile(cmd, args, { timeout: 5000 }, (err, stdout, stderr) => {
         const exitCode = err && typeof err.code === 'number' ?
@@ -54,7 +58,7 @@ export async function ensureTailscaleServe(port, run = defaultRun) {
     const serve = await run('tailscale', ['serve', 'status', '--json']);
     const target = serve443Target(serve.stdout);
     if (target === ours)
-        return { state: 'served', url: `https://${host}` };
+        return { state: 'served', url: `https://${host}`, host };
     if (target !== undefined)
         return { state: 'foreign-conflict', host };
     // No :443 handler yet — check cert capability before trying to create one.
@@ -64,7 +68,7 @@ export async function ensureTailscaleServe(port, run = defaultRun) {
     }
     const set = await run('tailscale', ['serve', '--bg', '--https=443', ours]);
     if (set.exitCode === 0)
-        return { state: 'served', url: `https://${host}` };
+        return { state: 'served', url: `https://${host}`, host };
     return { state: 'certs-disabled', host };
 }
 /** Tear down the :443 serve handler ONLY if it currently points at our port.
@@ -76,8 +80,11 @@ export async function teardownTailscaleServe(port, run = defaultRun) {
         await run('tailscale', ['serve', '--https=443', 'off']);
     }
 }
-/** Pure: pick the primary URL and any hint lines from a serve result. */
-export function planRemoteUrls(httpPrimary, result) {
+/** Pure: pick the primary URL (what the QR encodes) and any hint lines from a
+ *  serve result. Prefers the MagicDNS host over the raw IP whenever it's known —
+ *  the https URL when serve is live, else http://<host>:<port> — so the QR and
+ *  the announced URL carry the tailnet name (needed for SSH and webpush certs). */
+export function planRemoteUrls(httpPrimary, result, port) {
     switch (result.state) {
         case 'served':
             return {
@@ -87,7 +94,7 @@ export function planRemoteUrls(httpPrimary, result) {
             };
         case 'foreign-conflict':
             return {
-                primaryUrl: httpPrimary,
+                primaryUrl: `http://${result.host}:${port}`,
                 urlLines: [],
                 hintLines: [
                     'HTTPS: port 443 is already used by another tailscale serve config; not touching it.',
@@ -96,7 +103,7 @@ export function planRemoteUrls(httpPrimary, result) {
             };
         case 'certs-disabled':
             return {
-                primaryUrl: httpPrimary,
+                primaryUrl: `http://${result.host}:${port}`,
                 urlLines: [],
                 hintLines: [
                     'HTTPS (for phone notifications): enable HTTPS in the Tailscale admin console, then restart the remote.'

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;