feat: hand off Today lock-screen actions privately (Closes #1172)

frontend/private-data-registry.js

@@ -6,6 +6,7 @@
     'stackchain-voice-transcripts-v1',
     'stackchain-search-reply-drafts-v1',
     'stackchain-conversation-reply-drafts-v1',
+    'stackchain-today-action-mailbox-v1',
   ]);
   if (typeof module !== 'undefined' && module.exports) module.exports = databases;
   else root.stackchainPrivateDatabases = databases;

frontend/service-worker.js

@@ -1,12 +1,67 @@
 const BASE = new URL('./', self.location.href).pathname;
 importScripts(BASE + 'static/private-data-registry.js');
 importScripts(BASE + 'static/background-issue-sync.js');
-const CACHE = 'stackchain-dashboard-shell-v125';
+const CACHE = 'stackchain-dashboard-shell-v126';
 const OFFLINE_LEASE_URL = new URL(BASE + '__offline-session-lease', self.location.origin).href;
 const OUTAGE_STATUSES = new Set([500, 502, 503, 504]);
 const NAVIGATION_TIMEOUT_MS = self.__STACKCHAIN_NAVIGATION_TIMEOUT_MS || 4000;
 const PUSH_ACTION_TIMEOUT_MS = self.__STACKCHAIN_PUSH_ACTION_TIMEOUT_MS || 8000;
+const TODAY_ACTION_TTL_MS = 2 * 60 * 1000;
 const PRIVATE_DATABASES = self.stackchainPrivateDatabases;
+
+function createTodayActionStore() {
+  const dbName = 'stackchain-today-action-mailbox-v1';
+  const storeName = 'commands';
+  const open = () => new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => request.result.createObjectStore(storeName, {keyPath:'clientId'});
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error || new Error('Today action mailbox unavailable.'));
+  });
+  return {
+    async put(clientId, command) {
+      const database = await open();
+      await new Promise((resolve, reject) => {
+        const transaction = database.transaction(storeName, 'readwrite');
+        transaction.objectStore(storeName).put({...command, clientId});
+        transaction.oncomplete = resolve;
+        transaction.onerror = () => reject(transaction.error || new Error('Today action could not be saved.'));
+        transaction.onabort = transaction.onerror;
+      });
+      database.close();
+    },
+    async claim(clientId, now) {
+      const database = await open();
+      let command = null;
+      await new Promise((resolve, reject) => {
+        const transaction = database.transaction(storeName, 'readwrite');
+        const store = transaction.objectStore(storeName);
+        const request = store.get(clientId);
+        request.onsuccess = () => {
+          command = request.result || null;
+          if (command) store.delete(clientId);
+        };
+        transaction.oncomplete = resolve;
+        transaction.onerror = () => reject(transaction.error || new Error('Today action could not be claimed.'));
+        transaction.onabort = transaction.onerror;
+      });
+      database.close();
+      return command && command.expiresAt > now ? command : null;
+    },
+    async purge() {
+      const database = await open();
+      await new Promise((resolve, reject) => {
+        const transaction = database.transaction(storeName, 'readwrite');
+        transaction.objectStore(storeName).clear();
+        transaction.oncomplete = resolve;
+        transaction.onerror = () => reject(transaction.error || new Error('Today actions could not be purged.'));
+        transaction.onabort = transaction.onerror;
+      });
+      database.close();
+    },
+  };
+}
+const todayActionStore = self.__STACKCHAIN_TODAY_ACTION_STORE || createTodayActionStore();
 const SHELL = [
   BASE,
   BASE + 'manifest.webmanifest',
@@ -473,6 +528,7 @@ self.addEventListener('message', event => {
   if (event.data?.type === 'stackchain-purge-outbox') event.waitUntil((async () => {
     try {
       await issueSync.purge();
+      await todayActionStore.purge();
       await deletePrivateDatabases();
       await updateTodayLockScreen(false, false);
       event.ports?.[0]?.postMessage({ ok: true });
@@ -481,12 +537,33 @@ self.addEventListener('message', event => {
     }
   })());
   if (event.data?.type === 'stackchain-today-lock-screen') {
-    event.waitUntil(updateTodayLockScreen(
-      event.data.active === true,
-      event.data.running === true,
-      String(event.data.actionToken || ''),
-      Number(event.data.breakDeadlineAt || 0)
-    ));
+    event.waitUntil((async () => {
+      const active = event.data.active === true;
+      if (!active) await todayActionStore.purge();
+      await updateTodayLockScreen(
+        active,
+        event.data.running === true,
+        String(event.data.actionToken || ''),
+        Number(event.data.breakDeadlineAt || 0)
+      );
+    })());
+  }
+  if (event.data?.type === 'stackchain-claim-today-action') {
+    event.waitUntil((async () => {
+      const source = event.source;
+      if (!source?.id || !String(source.url || '').startsWith(self.location.origin + BASE)) return;
+      let command;
+      try { command = await todayActionStore.claim(source.id, Date.now()); }
+      catch (_error) { return; }
+      if (!command || !['pause', 'resume', 'complete'].includes(command.action)) return;
+      if (command.actionToken && !/^[A-Za-z0-9_-]{16,128}$/.test(command.actionToken)) return;
+      if (command.action === 'complete' && !command.actionToken) return;
+      source.postMessage?.({
+        type:'stackchain-today-timer-action',
+        action:command.action,
+        ...(command.actionToken ? {actionToken:command.actionToken} : {}),
+      });
+    })());
   }
 });
 
@@ -608,10 +685,17 @@ async function applyTodayTimerAction(action, actionToken = '') {
     });
     return client.focus?.();
   }
-  const query = '?today_timer_action=' + action +
-    (actionToken ? '&today_action_token=' + encodeURIComponent(actionToken) : '');
-  const target = new URL(BASE + query + route, self.location.origin).href;
-  return self.clients.openWindow(target);
+  const target = new URL(BASE + route, self.location.origin).href;
+  const opened = await self.clients.openWindow(target);
+  if (!opened?.id) return opened;
+  try {
+    await todayActionStore.put(opened.id, {
+      action,
+      ...(actionToken ? {actionToken} : {}),
+      expiresAt:Date.now() + TODAY_ACTION_TTL_MS,
+    });
+  } catch (_error) { /* The clean Today route remains safe; fail the action closed. */ }
+  return opened;
 }
 
 self.addEventListener('notificationclick', event => {

frontend/today-lock-screen.js

@@ -149,16 +149,9 @@ function createTodayLockScreen({
     },
     consumeAction,
     async consumeLaunchAction() {
-      let url;
-      try { url = new URL(locationRef?.href || ''); }
-      catch (_error) { return false; }
-      const action = url.searchParams.get('today_timer_action');
-      if (!['pause', 'resume', 'complete'].includes(action)) return false;
-      const token = url.searchParams.get('today_action_token') || '';
-      url.searchParams.delete('today_timer_action');
-      url.searchParams.delete('today_action_token');
-      historyRef?.replaceState?.(null, '', url.pathname + url.search + url.hash);
-      return await consumeAction(action, token);
+      if (!enabled()) return false;
+      await post({type:'stackchain-claim-today-action'});
+      return true;
     },
     render,
   };