@lelouchhe/webagent 0.9.0 → 0.10.0

package/lib/push-service.js

@@ -11,16 +11,16 @@ const VAPID_FILE = "vapid.json";
 const MAX_CONSECUTIVE_FAILURES = 5;
 /** Derive the push tag for an ACP event. Kept module-level so it can be
  *  reused by the close-on-handle path without instantiating the service. */
-export function pushTagForEvent(sessionId, event) {
+export function pushTagForEvent(taskId, event) {
     switch (event.type) {
         case "prompt_done":
-            return `sess-${sessionId}-done`;
+            return `sess-${taskId}-done`;
         case "permission_request":
-            return `sess-${sessionId}-perm-${event.eventId ?? "0"}`;
+            return `sess-${taskId}-perm-${event.eventId ?? "0"}`;
         case "bash_done":
-            return `sess-${sessionId}-bash-${event.eventId ?? "0"}`;
+            return `sess-${taskId}-bash-${event.eventId ?? "0"}`;
         default:
-            return `sess-${sessionId}-${event.type}`;
+            return `sess-${taskId}-${event.type}`;
     }
 }
 /**
@@ -97,8 +97,8 @@ export class PushService {
     // ---------------------------------------------------------------------------
     // Notification formatting
     // ---------------------------------------------------------------------------
-    formatNotification(sessionId, sessionTitle, eventType, eventData, tag) {
-        const title = sessionTitle ?? "WebAgent";
+    formatNotification(taskId, taskTitle, eventType, eventData, tag) {
+        const title = taskTitle ?? "WebAgent";
         let body;
         switch (eventType) {
             case "permission_request":
@@ -119,14 +119,14 @@ export class PushService {
             default:
                 body = eventType;
         }
-        return { kind: "notify", title, body, tag, data: { sessionId } };
+        return { kind: "notify", title, body, tag, data: { taskId } };
     }
     // ---------------------------------------------------------------------------
     // Endpoint mapping (transport-only as of Plan C Step 4)
     // ---------------------------------------------------------------------------
     /**
      * Set the push endpoint for a client. Identity-layer state (visibility,
-     * active session) goes through ClientRegistry.setVisibility, not here.
+     * active task) goes through ClientRegistry.setVisibility, not here.
      */
     updateClient(clientId, patch) {
         const prev = this.clients.get(clientId) ?? emptyClientState();
@@ -170,8 +170,8 @@ export class PushService {
     }
     /**
      * Check if any client (across all endpoints) is visible and viewing the
-     * given session. A client with no session set does not suppress any
-     * session's push. Stale records (older than `visibilityTtlMs` since the
+     * given task. A client with no task set does not suppress any
+     * task's push. Stale records (older than `visibilityTtlMs` since the
      * last heartbeat refresh) are ignored — this is the server-side safety
      * net for iOS PWA suspension, where the client's `visible:false` POST may
      * never leave the device.
@@ -179,10 +179,10 @@ export class PushService {
      * Returns false unconditionally when global suppression is disabled via
      * the `globalVisibilitySuppression` option (kill switch).
      */
-    isSessionVisibleToAnyClient(sessionId) {
+    isTaskVisibleToAnyClient(taskId) {
         if (!this.globalVisibilitySuppression)
             return false;
-        return this.clientRegistry.isSessionVisibleToAnyClient(sessionId);
+        return this.clientRegistry.isTaskVisibleToAnyClient(taskId);
     }
     // ---------------------------------------------------------------------------
     // High-level: decide whether to push, and if so, send
@@ -195,9 +195,9 @@ export class PushService {
     /**
      * Check if this event should trigger a push notification.
      * Returns true if a notification should be sent (caller should then call sendToAll).
-     * Global session visibility suppression happens inside sendToAll.
+     * Global task visibility suppression happens inside sendToAll.
      */
-    maybeNotify(sessionId, sessionTitle, eventType, _eventData) {
+    maybeNotify(taskId, taskTitle, eventType, _eventData) {
         if (!PushService.NOTIFIABLE.has(eventType))
             return false;
         return true;
@@ -209,12 +209,12 @@ export class PushService {
         const allSubs = this.store.getAllSubscriptions();
         if (allSubs.length === 0)
             return;
-        // Global visibility: if any client is viewing this session, suppress notify pushes.
+        // Global visibility: if any client is viewing this task, suppress notify pushes.
         // Close pushes are never suppressed — they're silent and are the mechanism
         // by which cross-device recall actually closes banners on the "losing" devices.
         if (notification.kind === "notify") {
-            const targetSession = notification.data.sessionId;
-            if (targetSession && this.isSessionVisibleToAnyClient(targetSession))
+            const targetTask = notification.data.taskId;
+            if (targetTask && this.isTaskVisibleToAnyClient(targetTask))
                 return;
         }
         // Skip Apple endpoints for silent close pushes to preserve iOS PWA's
@@ -332,12 +332,12 @@ export class PushService {
         const title = msg.from_label ?? msg.from_ref ?? "Message";
         const body = msg.body.length > 140 ? msg.body.slice(0, 137) + "…" : msg.body;
         const tag = msg.dedup_key ? `dedup-${msg.to}-${msg.dedup_key}` : msg.id;
-        // If this message targets a specific session, surface the sid in the
+        // If this message targets a specific task, surface the sid in the
         // push data so SW notificationclick can route the user there. Without
-        // this, clicks fall back to "/" and land on whatever session was last
-        // open — a confusing UX when multiple sessions get background pushes.
-        const sessionId = msg.to.startsWith("session:")
-            ? msg.to.slice("session:".length)
+        // this, clicks fall back to "/" and land on whatever task was last
+        // open — a confusing UX when multiple tasks get background pushes.
+        const taskId = msg.to.startsWith("task:")
+            ? msg.to.slice("task:".length)
             : undefined;
         // Observability signal #7 — sendForMessage entry.
         elog.info("sendForMessage", {
@@ -352,23 +352,21 @@ export class PushService {
             title,
             body,
             tag,
-            data: sessionId
-                ? { messageId: msg.id, sessionId }
-                : { messageId: msg.id },
+            data: taskId ? { messageId: msg.id, taskId } : { messageId: msg.id },
         });
         return true;
     }
     /**
-     * Send a push for an ACP session event (permission_request / prompt_done /
-     * bash_done). Handles tag derivation, visibility suppression, and session-
+     * Send a push for an ACP task event (permission_request / prompt_done /
+     * bash_done). Handles tag derivation, visibility suppression, and task-
      * title lookup. Returns `true` if a push attempt was made.
      */
-    async sendForEvent(sessionId, event) {
+    async sendForEvent(taskId, event) {
         if (!PushService.NOTIFIABLE.has(event.type))
             return false;
-        const session = this.store.getSession(sessionId);
-        const sessionTitle = session?.title ?? null;
-        const tag = pushTagForEvent(sessionId, event);
+        const task = this.store.getTask(taskId);
+        const taskTitle = task?.title ?? null;
+        const tag = pushTagForEvent(taskId, event);
         const eventData = {};
         if (event.type === "permission_request" && event.title !== undefined) {
             eventData.description = event.title;
@@ -379,16 +377,16 @@ export class PushService {
             if (event.exitCode !== undefined)
                 eventData.exitCode = event.exitCode;
         }
-        const suppressed = this.isSessionVisibleToAnyClient(sessionId);
+        const suppressed = this.isTaskVisibleToAnyClient(taskId);
         const subs = this.store.getAllSubscriptions();
         elog.info("sendForEvent", {
-            sess_id: sessionId.slice(0, 8),
+            sess_id: taskId.slice(0, 8),
             type: event.type,
             tag,
             endpoints: subs.length,
             suppressed_by_visibility: suppressed,
         });
-        const notification = this.formatNotification(sessionId, sessionTitle, event.type, eventData, tag);
+        const notification = this.formatNotification(taskId, taskTitle, event.type, eventData, tag);
         await this.sendToAll(notification);
         return true;
     }