@rmdes/indiekit-endpoint-activitypub 3.0.0 → 3.3.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

@@ -6,7 +6,9 @@
  */
 import express from "express";
 import { serializeCredentialAccount, serializeAccount } from "../entities/account.js";
+import { serializeStatus } from "../entities/status.js";
 import { accountId, remoteActorId } from "../helpers/id-mapping.js";
+import { buildPaginationQuery, parseLimit, setPaginationHeaders } from "../helpers/pagination.js";
 
 const router = express.Router(); // eslint-disable-line new-cap
 
@@ -133,47 +135,187 @@ 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 }),
-      );
+      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);
     }
 
-    // Search known actors (followers, following, timeline authors)
-    // by checking if the deterministic hash matches
-    const follower = await collections.ap_followers
-      .find({})
+    // 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" });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// ─── GET /api/v1/accounts/:id/statuses ──────────────────────────────────────
+
+router.get("/api/v1/accounts/:id/statuses", async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const collections = req.app.locals.mastodonCollections;
+    const baseUrl = `${req.protocol}://${req.get("host")}`;
+    const limit = parseLimit(req.query.limit);
+
+    // Resolve account ID to an author URL
+    const actorUrl = await resolveActorUrl(id, collections);
+    if (!actorUrl) {
+      return res.status(404).json({ error: "Record not found" });
+    }
+
+    // Build filter for this author's posts
+    const baseFilter = {
+      "author.url": actorUrl,
+      isContext: { $ne: true },
+    };
+
+    // Mastodon filters
+    if (req.query.only_media === "true") {
+      baseFilter.$or = [
+        { "photo.0": { $exists: true } },
+        { "video.0": { $exists: true } },
+        { "audio.0": { $exists: true } },
+      ];
+    }
+    if (req.query.exclude_replies === "true") {
+      baseFilter.inReplyTo = { $exists: false };
+    }
+    if (req.query.exclude_reblogs === "true") {
+      baseFilter.type = { $ne: "boost" };
+    }
+    if (req.query.pinned === "true") {
+      baseFilter.pinned = true;
+    }
+
+    const { filter, sort, reverse } = buildPaginationQuery(baseFilter, {
+      max_id: req.query.max_id,
+      min_id: req.query.min_id,
+      since_id: req.query.since_id,
+    });
+
+    let items = await collections.ap_timeline
+      .find(filter)
+      .sort(sort)
+      .limit(limit)
       .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 },
-          ),
-        );
+
+    if (reverse) {
+      items.reverse();
+    }
+
+    // Load interaction state if authenticated
+    let favouritedIds = new Set();
+    let rebloggedIds = new Set();
+    let bookmarkedIds = new Set();
+
+    if (req.mastodonToken && collections.ap_interactions) {
+      const lookupUrls = items.flatMap((i) => [i.uid, i.url].filter(Boolean));
+      if (lookupUrls.length > 0) {
+        const interactions = await collections.ap_interactions
+          .find({ objectUrl: { $in: lookupUrls } })
+          .toArray();
+        for (const ix of interactions) {
+          if (ix.type === "like") favouritedIds.add(ix.objectUrl);
+          else if (ix.type === "boost") rebloggedIds.add(ix.objectUrl);
+          else if (ix.type === "bookmark") bookmarkedIds.add(ix.objectUrl);
+        }
       }
     }
 
-    const following = await collections.ap_following
+    const statuses = items.map((item) =>
+      serializeStatus(item, {
+        baseUrl,
+        favouritedIds,
+        rebloggedIds,
+        bookmarkedIds,
+        pinnedIds: new Set(),
+      }),
+    );
+
+    setPaginationHeaders(res, req, items, limit);
+    res.json(statuses);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// ─── GET /api/v1/accounts/:id/followers ─────────────────────────────────────
+
+router.get("/api/v1/accounts/:id/followers", async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const collections = req.app.locals.mastodonCollections;
+    const baseUrl = `${req.protocol}://${req.get("host")}`;
+    const limit = parseLimit(req.query.limit);
+    const profile = await collections.ap_profile.findOne({});
+
+    // Only serve followers for the local account
+    if (!profile || profile._id.toString() !== id) {
+      return res.json([]);
+    }
+
+    const followers = await collections.ap_followers
       .find({})
+      .limit(limit)
       .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 accounts = followers.map((f) =>
+      serializeAccount(
+        { name: f.name, url: f.actorUrl, photo: f.avatar, handle: f.handle },
+        { baseUrl },
+      ),
+    );
+
+    res.json(accounts);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// ─── GET /api/v1/accounts/:id/following ─────────────────────────────────────
+
+router.get("/api/v1/accounts/:id/following", async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const collections = req.app.locals.mastodonCollections;
+    const baseUrl = `${req.protocol}://${req.get("host")}`;
+    const limit = parseLimit(req.query.limit);
+    const profile = await collections.ap_profile.findOne({});
+
+    // Only serve following for the local account
+    if (!profile || profile._id.toString() !== id) {
+      return res.json([]);
     }
 
-    // Try timeline authors
-    const timelineItem = await collections.ap_timeline.findOne({
-      $expr: { $ne: [{ $type: "$author.url" }, "missing"] },
-    });
-    // For now, if not found in known actors, return 404
-    return res.status(404).json({ error: "Record not found" });
+    const following = await collections.ap_following
+      .find({})
+      .limit(limit)
+      .toArray();
+
+    const accounts = following.map((f) =>
+      serializeAccount(
+        { name: f.name, url: f.actorUrl, photo: f.avatar, handle: f.handle },
+        { baseUrl },
+      ),
+    );
+
+    res.json(accounts);
   } catch (error) {
     next(error);
   }
@@ -546,7 +688,69 @@ async function resolveActorUrl(id, collections) {
     }
   }
 
+  // Check timeline authors
+  const timelineItems = await collections.ap_timeline
+    .find({ "author.url": { $exists: true } })
+    .project({ "author.url": 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 authorUrl;
+    }
+  }
+
   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

@@ -3,6 +3,8 @@
  *
  * GET /api/v1/statuses/:id — single status
  * GET /api/v1/statuses/:id/context — thread context (ancestors + descendants)
+ * POST /api/v1/statuses — create post via Micropub pipeline
+ * DELETE /api/v1/statuses/:id — delete post via Micropub pipeline
  * POST /api/v1/statuses/:id/favourite — like a post
  * POST /api/v1/statuses/:id/unfavourite — unlike a post
  * POST /api/v1/statuses/:id/reblog — boost a post
@@ -13,12 +15,12 @@
 import express from "express";
 import { ObjectId } from "mongodb";
 import { serializeStatus } from "../entities/status.js";
-import { serializeAccount } from "../entities/account.js";
 import {
   likePost, unlikePost,
   boostPost, unboostPost,
   bookmarkPost, unbookmarkPost,
 } from "../helpers/interactions.js";
+import { addTimelineItem } from "../../storage/timeline.js";
 
 const router = express.Router(); // eslint-disable-line new-cap
 
@@ -142,6 +144,8 @@ router.get("/api/v1/statuses/:id/context", async (req, res, next) => {
 });
 
 // ─── POST /api/v1/statuses ───────────────────────────────────────────────────
+// Creates a post via the Micropub pipeline so it goes through the full flow:
+// Micropub → content file → Eleventy build → syndication → AP federation.
 
 router.post("/api/v1/statuses", async (req, res, next) => {
   try {
@@ -150,6 +154,7 @@ router.post("/api/v1/statuses", async (req, res, next) => {
       return res.status(401).json({ error: "The access token is invalid" });
     }
 
+    const { application, publication } = req.app.locals;
     const collections = req.app.locals.mastodonCollections;
     const pluginOptions = req.app.locals.mastodonPluginOptions || {};
     const baseUrl = `${req.protocol}://${req.get("host")}`;
@@ -168,7 +173,7 @@ router.post("/api/v1/statuses", async (req, res, next) => {
       return res.status(422).json({ error: "Validation failed: Text content is required" });
     }
 
-    // Resolve in_reply_to if provided
+    // Resolve in_reply_to URL from timeline ObjectId
     let inReplyTo = null;
     if (inReplyToId) {
       try {
@@ -183,33 +188,63 @@ router.post("/api/v1/statuses", async (req, res, next) => {
       }
     }
 
-    // Load local profile for the author field
+    // Build JF2 properties for the Micropub pipeline
+    const jf2 = {
+      type: "entry",
+      content: statusText || "",
+    };
+
+    if (inReplyTo) {
+      jf2["in-reply-to"] = inReplyTo;
+    }
+
+    if (spoilerText) {
+      jf2.summary = spoilerText;
+    }
+
+    if (sensitive === true || sensitive === "true") {
+      jf2.sensitive = "true";
+    }
+
+    if (visibility && visibility !== "public") {
+      jf2.visibility = visibility;
+    }
+
+    if (language) {
+      jf2["mp-language"] = language;
+    }
+
+    // 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
+    const { postData } = await import("@indiekit/endpoint-micropub/lib/post-data.js");
+    const { postContent } = await import("@indiekit/endpoint-micropub/lib/post-content.js");
+
+    const data = await postData.create(application, publication, jf2);
+    // postContent.create() handles: template rendering, file creation in store
+    await postContent.create(publication, data);
+
+    const postUrl = data.properties.url;
+    console.info(`[Mastodon API] Created post via Micropub: ${postUrl}`);
+
+    // 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}`;
 
-    // Generate post ID and URL
-    const postId = crypto.randomUUID();
-    const postUrl = `${publicationUrl.replace(/\/$/, "")}/posts/${postId}`;
-    const uid = postUrl;
-
-    // Build the timeline item
     const now = new Date().toISOString();
-    const timelineItem = {
-      uid,
+    const timelineItem = await addTimelineItem(collections, {
+      uid: postUrl,
       url: postUrl,
-      type: "note",
-      content: {
-        text: statusText || "",
-        html: linkifyAndParagraph(statusText || ""),
-      },
+      type: data.properties["post-type"] || "note",
+      content: data.properties.content || { text: statusText || "", html: "" },
       summary: spoilerText || "",
       sensitive: sensitive === true || sensitive === "true",
       visibility: visibility || "public",
       language: language || null,
       inReplyTo,
-      published: now,
+      published: data.properties.published || now,
       createdAt: now,
       author: {
         name: profile?.name || handle,
@@ -219,26 +254,15 @@ router.post("/api/v1/statuses", async (req, res, next) => {
         emojis: [],
         bot: false,
       },
-      photo: [],
-      video: [],
-      audio: [],
-      category: extractHashtags(statusText || ""),
+      photo: data.properties.photo || [],
+      video: data.properties.video || [],
+      audio: data.properties.audio || [],
+      category: data.properties.category || [],
       counts: { replies: 0, boosts: 0, likes: 0 },
       linkPreviews: [],
       mentions: [],
       emojis: [],
-    };
-
-    // Insert into timeline
-    const result = await collections.ap_timeline.insertOne(timelineItem);
-    timelineItem._id = result.insertedId;
-
-    // Trigger federation asynchronously (don't block the response)
-    if (pluginOptions.federation) {
-      federatePost(timelineItem, pluginOptions).catch((err) => {
-        console.error("[Mastodon API] Federation failed:", err.message);
-      });
-    }
+    });
 
     // Serialize and return
     const serialized = serializeStatus(timelineItem, {
@@ -256,6 +280,8 @@ router.post("/api/v1/statuses", async (req, res, next) => {
 });
 
 // ─── DELETE /api/v1/statuses/:id ────────────────────────────────────────────
+// Deletes via Micropub pipeline (removes content file + MongoDB post) and
+// cleans up the ap_timeline entry.
 
 router.delete("/api/v1/statuses/:id", async (req, res, next) => {
   try {
@@ -264,6 +290,7 @@ router.delete("/api/v1/statuses/:id", async (req, res, next) => {
       return res.status(401).json({ error: "The access token is invalid" });
     }
 
+    const { application, publication } = req.app.locals;
     const { id } = req.params;
     const collections = req.app.locals.mastodonCollections;
     const baseUrl = `${req.protocol}://${req.get("host")}`;
@@ -296,6 +323,23 @@ router.delete("/api/v1/statuses/:id", async (req, res, next) => {
     });
     serialized.text = item.content?.text || "";
 
+    // Delete via Micropub pipeline (removes content file from store + MongoDB posts)
+    const postUrl = item.uid || item.url;
+    try {
+      const { postData } = await import("@indiekit/endpoint-micropub/lib/post-data.js");
+      const { postContent } = await import("@indiekit/endpoint-micropub/lib/post-content.js");
+
+      const existingPost = await postData.read(application, postUrl);
+      if (existingPost) {
+        const deletedData = await postData.delete(application, postUrl);
+        await postContent.delete(publication, deletedData);
+        console.info(`[Mastodon API] Deleted post via Micropub: ${postUrl}`);
+      }
+    } catch (err) {
+      // Log but don't block — the post may not exist in Micropub (e.g. old pre-pipeline posts)
+      console.warn(`[Mastodon API] Micropub delete failed for ${postUrl}: ${err.message}`);
+    }
+
     // Delete from timeline
     await collections.ap_timeline.deleteOne({ _id: objectId });
 
@@ -304,8 +348,6 @@ router.delete("/api/v1/statuses/:id", async (req, res, next) => {
       await collections.ap_interactions.deleteMany({ objectUrl: item.uid });
     }
 
-    // TODO: Broadcast Delete activity via federation
-
     res.json(serialized);
   } catch (error) {
     next(error);
@@ -560,75 +602,4 @@ async function loadItemInteractions(collections, item) {
   return { favouritedIds, rebloggedIds, bookmarkedIds };
 }
 
-/**
- * Convert plain text to basic HTML (paragraphs + linkified URLs).
- */
-function linkifyAndParagraph(text) {
-  if (!text) return "";
-  const paragraphs = text.split(/\n\n+/).filter(Boolean);
-  return paragraphs
-    .map((p) => {
-      const withBreaks = p.replace(/\n/g, "<br>");
-      const linked = withBreaks.replace(
-        /(?<![=">])(https?:\/\/[^\s<"]+)/g,
-        '<a href="$1">$1</a>',
-      );
-      return `<p>${linked}</p>`;
-    })
-    .join("");
-}
-
-/**
- * Extract #hashtags from text content.
- */
-function extractHashtags(text) {
-  if (!text) return [];
-  const tags = [];
-  const regex = /#([\w]+)/g;
-  let match;
-  while ((match = regex.exec(text)) !== null) {
-    tags.push(match[1]);
-  }
-  return [...new Set(tags)];
-}
-
-/**
- * Federate a newly created post via ActivityPub.
- * Runs asynchronously — errors logged, don't block API response.
- */
-async function federatePost(item, pluginOptions) {
-  const { jf2ToAS2Activity } = await import("../../jf2-to-as2.js");
-
-  const handle = pluginOptions.handle || "user";
-  const publicationUrl = pluginOptions.publicationUrl;
-  const federation = pluginOptions.federation;
-  const actorUrl = `${publicationUrl.replace(/\/$/, "")}/users/${handle}`;
-
-  const ctx = federation.createContext(
-    new URL(publicationUrl),
-    { handle, publicationUrl },
-  );
-
-  const properties = {
-    "post-type": "note",
-    url: item.url,
-    content: item.content,
-    summary: item.summary || undefined,
-    "in-reply-to": item.inReplyTo || undefined,
-    category: item.category,
-    visibility: item.visibility,
-  };
-
-  const activity = jf2ToAS2Activity(properties, actorUrl, publicationUrl, {
-    visibility: item.visibility,
-  });
-
-  if (activity) {
-    await ctx.sendActivity({ identifier: handle }, "followers", activity, {
-      preferSharedInbox: true,
-    });
-    console.info(`[Mastodon API] Federated post: ${item.url}`);
-  }
-}
-
 export default router;

package/lib/mastodon/routes/timelines.js

@@ -99,7 +99,22 @@ router.get("/api/v1/timelines/public", async (req, res, next) => {
       visibility: "public",
     };
 
-    // Only original posts (exclude boosts from public timeline unless local=true)
+    // Local timeline: only posts from the local instance author
+    if (req.query.local === "true") {
+      const profile = await collections.ap_profile.findOne({});
+      if (profile?.url) {
+        baseFilter["author.url"] = profile.url;
+      }
+    }
+
+    // Remote-only: exclude local author posts
+    if (req.query.remote === "true") {
+      const profile = await collections.ap_profile.findOne({});
+      if (profile?.url) {
+        baseFilter["author.url"] = { $ne: profile.url };
+      }
+    }
+
     if (req.query.only_media === "true") {
       baseFilter.$or = [
         { "photo.0": { $exists: true } },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-activitypub",
-  "version": "3.0.0",
+  "version": "3.3.0",
   "description": "ActivityPub federation endpoint for Indiekit via Fedify. Adds full fediverse support: actor, inbox, outbox, followers, following, syndication, and Mastodon migration.",
   "keywords": [
     "indiekit",
@@ -47,6 +47,7 @@
     "unfurl.js": "^6.4.0"
   },
   "peerDependencies": {
+    "@indiekit/endpoint-micropub": "^1.0.0-beta.25",
     "@indiekit/error": "^1.0.0-beta.25",
     "@indiekit/frontend": "^1.0.0-beta.25"
   },