@rmdes/indiekit-endpoint-activitypub 3.2.0 → 3.4.0

package/index.js

@@ -1552,6 +1552,20 @@ export default class ActivityPubEndpoint {
       keyRefreshHandle,
     );
 
+    // Backfill ap_timeline from posts collection (idempotent, runs on every startup)
+    import("./lib/mastodon/backfill-timeline.js").then(({ backfillTimeline }) => {
+      // Delay to let MongoDB connections settle
+      setTimeout(() => {
+        backfillTimeline(this._collections).then(({ total, inserted, skipped }) => {
+          if (inserted > 0) {
+            console.log(`[Mastodon API] Timeline backfill: ${inserted} posts added (${skipped} already existed, ${total} total)`);
+          }
+        }).catch((error) => {
+          console.warn("[Mastodon API] Timeline backfill failed:", error.message);
+        });
+      }, 5000);
+    });
+
     // Start async inbox queue processor (processes one item every 3s)
     this._inboxProcessorInterval = startInboxProcessor(
       this._collections,

package/lib/mastodon/backfill-timeline.js

@@ -0,0 +1,167 @@
+/**
+ * Backfill ap_timeline from the posts collection.
+ *
+ * Runs on startup (idempotent — uses upsert by uid).
+ * Converts Micropub JF2 posts into ap_timeline format so they
+ * appear in Mastodon Client API timelines and profile views.
+ */
+
+/**
+ * Backfill ap_timeline with published posts from the posts collection.
+ *
+ * @param {object} collections - MongoDB collections (must include posts, ap_timeline, ap_profile)
+ * @returns {Promise<{ total: number, inserted: number, skipped: number }>}
+ */
+export async function backfillTimeline(collections) {
+  const { posts, ap_timeline, ap_profile } = collections;
+
+  if (!posts || !ap_timeline) {
+    return { total: 0, inserted: 0, skipped: 0 };
+  }
+
+  // Get local profile for author info
+  const profile = await ap_profile?.findOne({});
+  const author = profile
+    ? {
+        name: profile.name || "",
+        url: profile.url || "",
+        photo: profile.icon || "",
+        handle: "",
+      }
+    : { name: "", url: "", photo: "", handle: "" };
+
+  // Fetch all published posts
+  const allPosts = await posts
+    .find({
+      "properties.post-status": { $ne: "draft" },
+      "properties.deleted": { $exists: false },
+      "properties.url": { $exists: true },
+    })
+    .toArray();
+
+  let inserted = 0;
+  let skipped = 0;
+
+  for (const post of allPosts) {
+    const props = post.properties;
+    if (!props?.url) {
+      skipped++;
+      continue;
+    }
+
+    const uid = props.url;
+
+    // Check if already in timeline (fast path to avoid unnecessary upserts)
+    const exists = await ap_timeline.findOne({ uid }, { projection: { _id: 1 } });
+    if (exists) {
+      skipped++;
+      continue;
+    }
+
+    // Map JF2 properties to timeline item format
+    const content = normalizeContent(props.content);
+    const type = mapPostType(props["post-type"]);
+
+    const timelineItem = {
+      uid,
+      url: uid,
+      type,
+      content,
+      author,
+      published: props.published || props.date || new Date().toISOString(),
+      createdAt: props.published || props.date || new Date().toISOString(),
+      visibility: "public",
+      sensitive: false,
+      category: normalizeArray(props.category),
+      photo: normalizeMediaArray(props.photo),
+      video: normalizeMediaArray(props.video),
+      audio: normalizeMediaArray(props.audio),
+      readBy: [],
+    };
+
+    // Optional fields
+    if (props.name) timelineItem.name = props.name;
+    if (props.summary) timelineItem.summary = props.summary;
+    if (props["in-reply-to"]) {
+      timelineItem.inReplyTo = Array.isArray(props["in-reply-to"])
+        ? props["in-reply-to"][0]
+        : props["in-reply-to"];
+    }
+
+    try {
+      const result = await ap_timeline.updateOne(
+        { uid },
+        { $setOnInsert: timelineItem },
+        { upsert: true },
+      );
+      if (result.upsertedCount > 0) {
+        inserted++;
+      } else {
+        skipped++;
+      }
+    } catch {
+      skipped++;
+    }
+  }
+
+  return { total: allPosts.length, inserted, skipped };
+}
+
+/**
+ * Normalize content from JF2 properties to { text, html } format.
+ */
+function normalizeContent(content) {
+  if (!content) return { text: "", html: "" };
+  if (typeof content === "string") return { text: content, html: `<p>${content}</p>` };
+  if (typeof content === "object") {
+    return {
+      text: content.text || content.value || "",
+      html: content.html || content.text || content.value || "",
+    };
+  }
+  return { text: "", html: "" };
+}
+
+/**
+ * Map Micropub post-type to timeline type.
+ */
+function mapPostType(postType) {
+  switch (postType) {
+    case "article":
+      return "article";
+    case "photo":
+    case "video":
+    case "audio":
+      return "note";
+    case "reply":
+      return "note";
+    case "repost":
+      return "boost";
+    case "like":
+      return "note";
+    default:
+      return "note";
+  }
+}
+
+/**
+ * Normalize a value to an array of strings.
+ */
+function normalizeArray(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map(String);
+  return [String(value)];
+}
+
+/**
+ * Normalize media values (can be strings or objects with url property).
+ */
+function normalizeMediaArray(value) {
+  if (!value) return [];
+  const arr = Array.isArray(value) ? value : [value];
+  return arr.map((item) => {
+    if (typeof item === "string") return item;
+    if (typeof item === "object" && item.url) return item;
+    return null;
+  }).filter(Boolean);
+}

package/lib/mastodon/routes/accounts.js

@@ -135,57 +135,27 @@ router.get("/api/v1/accounts/:id", async (req, res, next) => {
     // Check if it's the local profile
     const profile = await collections.ap_profile.findOne({});
     if (profile && profile._id.toString() === id) {
-      return res.json(
-        serializeAccount(profile, { baseUrl, isLocal: true, handle }),
-      );
-    }
-
-    // Search known actors (followers, following, timeline authors)
-    // by checking if the deterministic hash matches
-    const follower = await collections.ap_followers
-      .find({})
-      .toArray();
-    for (const f of follower) {
-      if (remoteActorId(f.actorUrl) === id) {
-        return res.json(
-          serializeAccount(
-            { name: f.name, url: f.actorUrl, photo: f.avatar, handle: f.handle },
-            { baseUrl },
-          ),
-        );
-      }
-    }
-
-    const following = await collections.ap_following
-      .find({})
-      .toArray();
-    for (const f of following) {
-      if (remoteActorId(f.actorUrl) === id) {
-        return res.json(
-          serializeAccount(
-            { name: f.name, url: f.actorUrl, photo: f.avatar, handle: f.handle },
-            { baseUrl },
-          ),
-        );
-      }
+      const [statuses, followers, following] = await Promise.all([
+        collections.ap_timeline.countDocuments({ "author.url": profile.url }),
+        collections.ap_followers.countDocuments({}),
+        collections.ap_following.countDocuments({}),
+      ]);
+      const account = serializeAccount(profile, { baseUrl, isLocal: true, handle });
+      account.statuses_count = statuses;
+      account.followers_count = followers;
+      account.following_count = following;
+      return res.json(account);
     }
 
-    // Try timeline authors — find any post whose author URL hashes to this ID
-    const timelineItems = await collections.ap_timeline
-      .find({ "author.url": { $exists: true } })
-      .project({ author: 1 })
-      .toArray();
-
-    const seenUrls = new Set();
-    for (const item of timelineItems) {
-      const authorUrl = item.author?.url;
-      if (!authorUrl || seenUrls.has(authorUrl)) continue;
-      seenUrls.add(authorUrl);
-      if (remoteActorId(authorUrl) === id) {
-        return res.json(
-          serializeAccount(item.author, { baseUrl }),
-        );
-      }
+    // Resolve remote actor from followers, following, or timeline
+    const { actor, actorUrl } = await resolveActorData(id, collections);
+    if (actor) {
+      const account = serializeAccount(actor, { baseUrl });
+      // Count this actor's posts in our timeline
+      account.statuses_count = await collections.ap_timeline.countDocuments({
+        "author.url": actorUrl,
+      });
+      return res.json(account);
     }
 
     return res.status(404).json({ error: "Record not found" });
@@ -737,4 +707,50 @@ async function resolveActorUrl(id, collections) {
   return null;
 }
 
+/**
+ * Resolve an account ID to both actor data and URL.
+ * Returns { actor, actorUrl } or { actor: null, actorUrl: null }.
+ */
+async function resolveActorData(id, collections) {
+  // Check followers
+  const followers = await collections.ap_followers.find({}).toArray();
+  for (const f of followers) {
+    if (remoteActorId(f.actorUrl) === id) {
+      return {
+        actor: { name: f.name, url: f.actorUrl, photo: f.avatar, handle: f.handle },
+        actorUrl: f.actorUrl,
+      };
+    }
+  }
+
+  // Check following
+  const following = await collections.ap_following.find({}).toArray();
+  for (const f of following) {
+    if (remoteActorId(f.actorUrl) === id) {
+      return {
+        actor: { name: f.name, url: f.actorUrl, photo: f.avatar, handle: f.handle },
+        actorUrl: f.actorUrl,
+      };
+    }
+  }
+
+  // Check timeline authors
+  const timelineItems = await collections.ap_timeline
+    .find({ "author.url": { $exists: true } })
+    .project({ author: 1 })
+    .toArray();
+
+  const seenUrls = new Set();
+  for (const item of timelineItems) {
+    const authorUrl = item.author?.url;
+    if (!authorUrl || seenUrls.has(authorUrl)) continue;
+    seenUrls.add(authorUrl);
+    if (remoteActorId(authorUrl) === id) {
+      return { actor: item.author, actorUrl: authorUrl };
+    }
+  }
+
+  return { actor: null, actorUrl: null };
+}
+
 export default router;

package/lib/mastodon/routes/statuses.js

@@ -214,9 +214,15 @@ router.post("/api/v1/statuses", async (req, res, next) => {
       jf2["mp-language"] = language;
     }
 
+    // Syndicate to AP only — posts from Mastodon clients belong to the fediverse.
+    // Never cross-post to Bluesky (conversations stay in their protocol).
+    // The publication URL is the AP syndicator's uid.
+    const publicationUrl = pluginOptions.publicationUrl || baseUrl;
+    jf2["mp-syndicate-to"] = [publicationUrl.replace(/\/$/, "") + "/"];
+
     // Create post via Micropub pipeline (same functions the Micropub endpoint uses)
     // postData.create() handles: normalization, post type detection, path rendering,
-    // mp-syndicate-to auto-set (from checked syndicators), MongoDB posts collection
+    // mp-syndicate-to validated against configured syndicators, MongoDB posts collection
     const { postData } = await import("@indiekit/endpoint-micropub/lib/post-data.js");
     const { postContent } = await import("@indiekit/endpoint-micropub/lib/post-content.js");
 
@@ -230,7 +236,6 @@ router.post("/api/v1/statuses", async (req, res, next) => {
     // Add to ap_timeline so the post is visible in the Mastodon Client API
     const profile = await collections.ap_profile.findOne({});
     const handle = pluginOptions.handle || "user";
-    const publicationUrl = pluginOptions.publicationUrl || baseUrl;
     const actorUrl = profile?.url || `${publicationUrl}/users/${handle}`;
 
     const now = new Date().toISOString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-activitypub",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "ActivityPub federation endpoint for Indiekit via Fedify. Adds full fediverse support: actor, inbox, outbox, followers, following, syndication, and Mastodon migration.",
   "keywords": [
     "indiekit",