@rmdes/indiekit-endpoint-conversations 2.1.1 → 2.1.3

package/lib/notifications/activitypub.js

@@ -48,7 +48,11 @@ export async function fetchActivityPubInteractions(options) {
   const items = [];
 
   for (const activity of activities) {
-    const avatar = await lookupAvatar(ap_followers, activity.actorUrl);
+    // Prefer avatar stored directly on the activity (added by inbox handler),
+    // fall back to ap_followers lookup for historical data without actorAvatar
+    const avatar =
+      activity.actorAvatar ||
+      (await lookupAvatar(ap_followers, activity.actorUrl));
     items.push(normalizeActivity(activity, avatar));
   }
 

package/lib/polling/scheduler.js

@@ -94,6 +94,117 @@ export async function runPollCycle(indiekit, options) {
     }
     await pollActivityPub(indiekit, stateCollection, state);
   }
+
+  // Backfill missing avatars from ap_notifications (one-time sweep per cycle)
+  await backfillMissingAvatars(indiekit, stateCollection);
+}
+
+/**
+ * Backfill empty author.photo fields in conversation_items using ap_notifications.
+ * The AP endpoint stores actorPhoto in notifications for all interactions,
+ * so we can use those to enrich conversation_items that were stored before
+ * the actorAvatar field was added to ap_activities.
+ */
+async function backfillMissingAvatars(indiekit, stateCollection) {
+  try {
+    const itemsCollection = indiekit.collections.get("conversation_items");
+    const notificationsCollection = indiekit.collections.get("ap_notifications");
+    const activitiesCollection = indiekit.collections.get("ap_activities");
+    const followersCollection = indiekit.collections.get("ap_followers");
+
+    if (!itemsCollection) return;
+
+    // Check if backfill already completed
+    const state = await stateCollection.findOne({ _id: "poll_cursors" });
+    if (state?.avatar_backfill_complete) return;
+
+    // Find conversation_items with empty author.photo
+    const itemsWithoutPhoto = await itemsCollection
+      .find({
+        $or: [
+          { "author.photo": "" },
+          { "author.photo": null },
+          { "author.photo": { $exists: false } },
+        ],
+      })
+      .limit(200)
+      .toArray();
+
+    if (itemsWithoutPhoto.length === 0) {
+      // Mark backfill as complete so we don't query every cycle
+      await stateCollection.findOneAndUpdate(
+        { _id: "poll_cursors" },
+        { $set: { avatar_backfill_complete: true } },
+        { upsert: true },
+      );
+      return;
+    }
+
+    let updated = 0;
+
+    for (const item of itemsWithoutPhoto) {
+      const actorUrl = item.author?.url;
+      if (!actorUrl) continue;
+
+      let photo = "";
+
+      // Strategy 1: Check ap_notifications (most reliable — has actorPhoto for all interaction types)
+      if (!photo && notificationsCollection) {
+        try {
+          const notification = await notificationsCollection.findOne({
+            actorUrl,
+            actorPhoto: { $ne: "" },
+          });
+          if (notification?.actorPhoto) photo = notification.actorPhoto;
+        } catch { /* ignore */ }
+      }
+
+      // Strategy 2: Check ap_activities for actorAvatar (new field from inbox handler fix)
+      if (!photo && activitiesCollection) {
+        try {
+          const activity = await activitiesCollection.findOne({
+            actorUrl,
+            actorAvatar: { $ne: "" },
+          });
+          if (activity?.actorAvatar) photo = activity.actorAvatar;
+        } catch { /* ignore */ }
+      }
+
+      // Strategy 3: Check ap_followers
+      if (!photo && followersCollection) {
+        try {
+          const follower = await followersCollection.findOne({ actorUrl });
+          if (follower?.avatar) photo = follower.avatar;
+        } catch { /* ignore */ }
+      }
+
+      if (photo) {
+        await itemsCollection.updateMany(
+          { "author.url": actorUrl, "author.photo": { $in: ["", null] } },
+          { $set: { "author.photo": photo } },
+        );
+        updated++;
+      }
+    }
+
+    if (updated > 0) {
+      console.info(
+        `[Conversations] Avatar backfill: updated ${updated} actors with photos`,
+      );
+    }
+
+    // If fewer than 200 items found, backfill is complete
+    if (itemsWithoutPhoto.length < 200) {
+      await stateCollection.findOneAndUpdate(
+        { _id: "poll_cursors" },
+        { $set: { avatar_backfill_complete: true } },
+        { upsert: true },
+      );
+    }
+  } catch (error) {
+    // Non-critical — log and continue
+    console.warn("[Conversations] Avatar backfill error:", error.message);
+  }
 }
 
 /**
@@ -323,6 +434,16 @@ async function pollActivityPub(indiekit, stateCollection, state) {
 
     if (!ap_activities) return;
 
+    // Resolve the site URL so we only store interactions about OUR content.
+    // indiekit may be the Indiekit class (from startPolling) or the
+    // application object (from triggerPoll via controller).
+    const siteUrl = (
+      indiekit.publication?.me ||
+      indiekit.url ||
+      process.env.PUBLICATION_URL ||
+      ""
+    ).replace(/\/$/, "");
+
     const result = await fetchActivityPubInteractions({
       ap_activities,
       ap_followers,
@@ -330,22 +451,30 @@ async function pollActivityPub(indiekit, stateCollection, state) {
     });
 
     let stored = 0;
+    let skipped = 0;
 
     for (const interaction of result.items) {
-      if (interaction.canonical_url) {
-        await upsertConversationItem(indiekit, {
-          canonical_url: interaction.canonical_url,
-          source: "activitypub",
-          type: interaction.type,
-          author: interaction.author,
-          content: interaction.content,
-          url: interaction.url,
-          bridgy_url: null,
-          platform_id: interaction.platform_id,
-          created_at: interaction.created_at,
-        });
-        stored++;
+      if (!interaction.canonical_url) continue;
+
+      // Only store interactions targeting our own content — skip activities
+      // about posts on other domains (e.g. forwarded via shared inbox).
+      if (siteUrl && !interaction.canonical_url.startsWith(siteUrl)) {
+        skipped++;
+        continue;
       }
+
+      await upsertConversationItem(indiekit, {
+        canonical_url: interaction.canonical_url,
+        source: "activitypub",
+        type: interaction.type,
+        author: interaction.author,
+        content: interaction.content,
+        url: interaction.url,
+        bridgy_url: null,
+        platform_id: interaction.platform_id,
+        created_at: interaction.created_at,
+      });
+      stored++;
     }
 
     // Update cursor and status
@@ -363,9 +492,9 @@ async function pollActivityPub(indiekit, stateCollection, state) {
       { upsert: true },
     );
 
-    if (stored > 0) {
+    if (stored > 0 || skipped > 0) {
       console.info(
-        `[Conversations] ActivityPub: stored ${stored}/${result.items.length} interactions`,
+        `[Conversations] ActivityPub: stored ${stored}, skipped ${skipped} (not our content) of ${result.items.length} interactions`,
       );
     }
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-conversations",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Conversation aggregation endpoint for Indiekit. Backend enrichment service that polls Mastodon/Bluesky notifications and serves JF2-compatible data for the interactions page.",
   "keywords": [
     "indiekit",