feat: extract structured data from notifications

sigvardt · sigvardt · commit 6f73e337e397 · 2026-03-23T16:43:13.000+01:00
diff --git a/.opencode/todo.md b/.opencode/todo.md
@@ -1,6 +1,22 @@
-# Mission Tasks
+# Mission: Notifications: make it production-grade (#613)
 
-## Task List
+## M1: Analysis & Infrastructure
+### T1.1: Identify Notification Types & Extracted Data | agent:Planner
+- [ ] S1.1.1: Document parsing logic for the 9 specified notification types | size:M
+- [ ] S1.1.2: Define updated `LinkedInNotification` interface with `extracted_data` | size:S
 
-[ ] *Start your mission by creating a task list
+## M2: Implementation
+### T2.1: Implement Data Extraction (Rich Data) | agent:Worker | depends:T1.1
+- [x] S2.1.1: Update `extractNotificationSnapshots` to extract structured data for all required types | size:L
+- [x] S2.1.2: Add parsing utilities for metrics (view counts, names, etc) | size:M
 
+### T2.2: Implement Type Filtering & Pagination | agent:Worker | depends:T2.1
+- [x] S2.2.1: Add `types` filtering to `ListNotificationsInput` and `listNotifications` method | size:S
+- [x] S2.2.2: Add `types` parameter to MCP tool `notifications_list` | size:S
+- [x] S2.2.3: Update pagination logic in `loadNotificationSnapshots` to support fetching longer feeds without fixed scroll limits | size:M
+
+## M3: Verification & Integration
+### T3.1: Testing & Quality Gates | agent:Reviewer | depends:M2
+- [ ] S3.1.1: Run unit tests and e2e tests for notifications | size:M
+- [ ] S3.1.2: Run lint and typecheck | size:S
+- [ ] S3.1.3: Wait for CI and create PR | size:S
diff --git a/packages/core/src/linkedinNotifications.ts b/packages/core/src/linkedinNotifications.ts
@@ -30,11 +30,13 @@ export interface LinkedInNotification {
   timestamp: string;
   link: string;
   is_read: boolean;
+  extracted_data?: Record<string, unknown> | undefined;
 }
 
 export interface ListNotificationsInput {
   profileName?: string;
   limit?: number;
+  types?: string[];
 }
 
 export interface MarkNotificationReadInput {
@@ -155,6 +157,7 @@ interface NotificationSnapshot {
   link: string;
   is_read: boolean;
   card_index: number;
+  extracted_data?: Record<string, unknown>;
 }
 
 interface NotificationSnapshotCandidate {
@@ -165,6 +168,7 @@ interface NotificationSnapshotCandidate {
   link: string;
   is_read: boolean;
   card_index: number;
+  extracted_data?: Record<string, unknown>;
 }
 
 interface NotificationCardMatch {
@@ -289,9 +293,10 @@ function hashNotificationFingerprint(input: {
   // content stripping keep IDs stable across separate page loads.
   const normalizedLink =
     normalizeNotificationLink(input.link) || normalizeText(input.link);
-  const fingerprint = [normalizedLink, stripVolatileContent(input.message)].join(
-    "\u001f",
-  );
+  const fingerprint = [
+    normalizedLink,
+    stripVolatileContent(input.message),
+  ].join("\u001f");
   return `notif_${createHash("sha256").update(fingerprint).digest("hex").slice(0, 16)}`;
 }
 
@@ -587,6 +592,124 @@ async function extractNotificationSnapshots(
         return "";
       };
 
+      const extractStructuredData = (
+        message: string,
+      ): Record<string, unknown> | undefined => {
+        const data: Record<string, unknown> = {};
+        let matched = false;
+        const text = message.replace(/\s+/g, " ").trim();
+
+        const postAnalyticsMatch =
+          text.match(
+            /Your post (?:has|got|was seen by) ([\d,]+) (?:views|impressions|times)/i,
+          ) || text.match(/([\d,]+) people viewed your post/i);
+        if (postAnalyticsMatch) {
+          data.views = parseInt(
+            (postAnalyticsMatch[1] || "0").replace(/,/g, ""),
+            10,
+          );
+          matched = true;
+        }
+
+        const profileViewsMatch =
+          text.match(/([\d,]+) people viewed your profile/i) ||
+          text.match(/Your profile was viewed by ([\d,]+) people/i) ||
+          text.match(/You appeared in ([\d,]+) searches/i);
+        if (
+          profileViewsMatch &&
+          !text.match(/You appeared in ([\d,]+) searches/i)
+        ) {
+          data.profile_views = parseInt(
+            (profileViewsMatch[1] || "0").replace(/,/g, ""),
+            10,
+          );
+          matched = true;
+        }
+
+        const searchMatch = text.match(/You appeared in ([\d,]+) searches/i);
+        if (searchMatch) {
+          data.search_appearances = parseInt(
+            (searchMatch[1] || "0").replace(/,/g, ""),
+            10,
+          );
+          matched = true;
+        }
+
+        const mentionMatch = text.match(/^(.*?)\s+mentioned you/i);
+        if (mentionMatch) {
+          data.mentioned_by = (mentionMatch[1] || "").trim();
+          matched = true;
+        }
+
+        const connectionMatch =
+          text.match(/^(.*?)\s+sent you a connection request/i) ||
+          text.match(/^(.*?)\s+wants to connect/i) ||
+          text.match(/^(.*?)\s+accepted your connection/i);
+        if (connectionMatch) {
+          data.sender = (connectionMatch[1] || "").trim();
+          matched = true;
+        }
+
+        const newsletterMatch =
+          text.match(/([\d,]+)\s+people subscribed to/i) ||
+          text.match(/^(.*?)\s+subscribed to/i);
+        if (newsletterMatch) {
+          const num = parseInt(
+            (newsletterMatch[1] || "").replace(/,/g, ""),
+            10,
+          );
+          if (!isNaN(num)) {
+            data.subscriber_count = num;
+          } else {
+            data.subscriber = (newsletterMatch[1] || "").trim();
+          }
+          matched = true;
+        }
+
+        const jobAlertMatch =
+          text.match(/([\d,]+)\s+new jobs? for "(.*?)"/i) ||
+          text.match(/new jobs? for "(.*?)"/i) ||
+          text.match(/([\d,]+)\s+new jobs? for (.*)/i);
+        if (jobAlertMatch) {
+          if (jobAlertMatch.length === 3) {
+            data.job_count = parseInt(
+              (jobAlertMatch[1] || "0").replace(/,/g, ""),
+              10,
+            );
+            data.job_title = (jobAlertMatch[2] || "").trim();
+          } else if (jobAlertMatch[1]) {
+            if (!isNaN(parseInt(jobAlertMatch[1], 10))) {
+              data.job_count = parseInt(
+                (jobAlertMatch[1] || "0").replace(/,/g, ""),
+                10,
+              );
+              data.job_title = jobAlertMatch[2]
+                ? (jobAlertMatch[2] || "").trim()
+                : "";
+            } else {
+              data.job_title = (jobAlertMatch[1] || "").trim();
+            }
+          }
+          matched = true;
+        }
+
+        const companyPostMatch =
+          text.match(/^(.*?)\s+posted:/i) ||
+          text.match(/^(.*?)\s+shared a post:/i);
+        if (companyPostMatch) {
+          data.company_name = (companyPostMatch[1] || "").trim();
+          matched = true;
+        }
+
+        const trendingMatch = text.match(/^Trending:\s+(.*)/i);
+        if (trendingMatch) {
+          data.topic = (trendingMatch[1] || "").trim();
+          matched = true;
+        }
+
+        return matched ? data : undefined;
+      };
+
       const readClassName = (node: Element | null | undefined): string => {
         if (!node) {
           return "";
@@ -766,6 +889,9 @@ async function extractNotificationSnapshots(
           link,
           is_read: inferReadState(card),
           card_index: i,
+          ...(extractStructuredData(message)
+            ? { extracted_data: extractStructuredData(message) as Record<string, unknown> }
+            : {}),
         });
 
         if (notifications.length >= maxNotifications) {
@@ -800,6 +926,9 @@ async function extractNotificationSnapshots(
         link,
         is_read: Boolean(candidate.is_read),
         card_index: Math.max(0, Math.floor(candidate.card_index)),
+        ...(candidate.extracted_data
+          ? { extracted_data: candidate.extracted_data as Record<string, unknown> }
+          : {}),
       } satisfies NotificationSnapshot;
     })
     .filter(
@@ -815,16 +944,38 @@ async function extractNotificationSnapshots(
 async function loadNotificationSnapshots(
   page: Page,
   limit: number,
+  types?: string[]
 ): Promise<NotificationSnapshot[]> {
-  let notifications = await extractNotificationSnapshots(page, limit);
+  const isMatch = (n: NotificationSnapshot) => {
+    if (!types || types.length === 0) return true;
+    return types.includes(n.type) || (n.extracted_data && types.includes(n.extracted_data.notification_category));
+  };
 
-  for (let i = 0; i < 6 && notifications.length < limit; i += 1) {
-    await scrollLinkedInPageToBottom(page);
-    await page.waitForTimeout(800);
-    notifications = await extractNotificationSnapshots(page, limit);
+  const maxScrolls = 20;
+  let scrollCount = 0;
+  let previousCount = 0;
+  let allNotifications: NotificationSnapshot[] = [];
+  let matchedCount = 0;
+
+  while (matchedCount < limit && scrollCount < maxScrolls) {
+    // Extract more to ensure we can find filtered items
+    const extractLimit = Math.max(limit, 200);
+    allNotifications = await extractNotificationSnapshots(page, extractLimit);
+    matchedCount = allNotifications.filter(isMatch).length;
+
+    if (allNotifications.length === previousCount) {
+      break; // No new items loaded
+    }
+    previousCount = allNotifications.length;
+
+    if (matchedCount < limit) {
+      await scrollLinkedInPageToBottom(page);
+      await page.waitForTimeout(800);
+      scrollCount += 1;
+    }
   }
 
-  return notifications.slice(0, Math.max(1, limit));
+  return allNotifications.filter(isMatch).slice(0, Math.max(1, limit));
 }
 
 async function findNotificationCard(
@@ -841,12 +992,16 @@ async function findNotificationCard(
   function toMatch(snapshot: NotificationSnapshot): NotificationCardMatch {
     return {
       snapshot,
-      locator: page.locator(NOTIFICATION_CARD_SELECTOR).nth(snapshot.card_index),
+      locator: page
+        .locator(NOTIFICATION_CARD_SELECTOR)
+        .nth(snapshot.card_index),
     };
   }
 
   // Strategy 1: Exact ID match (native LinkedIn IDs or current-algorithm hashes).
-  const exactMatch = snapshots.find((candidate) => candidate.id === normalizedId);
+  const exactMatch = snapshots.find(
+    (candidate) => candidate.id === normalizedId,
+  );
   if (exactMatch) {
     return toMatch(exactMatch);
   }
@@ -1178,7 +1333,9 @@ async function readNotificationPreferencePageState(
           const href = normalize(anchor.href || anchor.getAttribute("href"));
           const text = normalize(anchor.textContent);
           const match =
-            /^(.+?)\s+((?:On|Off|Push|In-app|Email)(?:[\s,]+(?:and\s+)?(?:On|Off|Push|In-app|Email))*)$/iu.exec(text);
+            /^(.+?)\s+((?:On|Off|Push|In-app|Email)(?:[\s,]+(?:and\s+)?(?:On|Off|Push|In-app|Email))*)$/iu.exec(
+              text,
+            );
           return {
             title: normalize(match?.[1] ?? text),
             slug: href.replace(/\/+$/u, "").split("/").pop() ?? "",
@@ -1584,16 +1741,21 @@ export class LinkedInNotificationsService {
         async (context) => {
           const page = await getOrCreatePage(context);
           await openNotificationsPage(page);
-          const notifications = await loadNotificationSnapshots(page, limit);
+          const notifications = await loadNotificationSnapshots(page, limit, input.types);
+
           return notifications.map((notification) => {
-            return {
+            const mapped: Record<string, unknown> = {
               id: notification.id,
               type: notification.type,
               message: notification.message,
               timestamp: notification.timestamp,
               link: notification.link,
               is_read: notification.is_read,
             };
+            if (notification.extracted_data) {
+              mapped.extracted_data = notification.extracted_data;
+            }
+            return mapped as LinkedInNotification;
           });
         },
       );
diff --git a/packages/mcp/src/bin/linkedin-mcp.ts b/packages/mcp/src/bin/linkedin-mcp.ts
@@ -1765,15 +1765,18 @@ async function handleNotificationsList(args: ToolArgs): Promise<ToolResult> {
   try {
     const profileName = readString(args, "profileName", "default");
     const limit = readPositiveNumber(args, "limit", 20);
+    const types = args.types as string[] | undefined;
 
     runtime.logger.log("info", "mcp.notifications.list.start", {
       profileName,
       limit,
+      types,
     });
 
     const notifications = await runtime.notifications.listNotifications({
       profileName,
       limit,
+      types,
     });
 
     runtime.logger.log("info", "mcp.notifications.list.done", {
@@ -6525,6 +6528,14 @@ export const LINKEDIN_MCP_TOOL_DEFINITIONS: LinkedInMcpToolDefinition[] = [
           description:
             "Maximum number of notifications to return. Defaults to 20.",
         },
+        types: {
+          type: "array",
+          items: {
+            type: "string",
+          },
+          description:
+            "Optional array of notification types or categories to filter by (e.g. ['mention', 'profile_views', 'job_alert']).",
+        },
       }),
     },
   },
