@rmdes/indiekit-endpoint-activitypub 1.0.28 → 1.1.1

package/index.js

@@ -9,6 +9,28 @@ import {
   jf2ToAS2Activity,
 } from "./lib/jf2-to-as2.js";
 import { dashboardController } from "./lib/controllers/dashboard.js";
+import {
+  readerController,
+  notificationsController,
+  composeController,
+  submitComposeController,
+  remoteProfileController,
+  followController,
+  unfollowController,
+} from "./lib/controllers/reader.js";
+import {
+  likeController,
+  unlikeController,
+  boostController,
+  unboostController,
+} from "./lib/controllers/interactions.js";
+import {
+  muteController,
+  unmuteController,
+  blockController,
+  unblockController,
+  moderationController,
+} from "./lib/controllers/moderation.js";
 import { followersController } from "./lib/controllers/followers.js";
 import { followingController } from "./lib/controllers/following.js";
 import { activitiesController } from "./lib/controllers/activities.js";
@@ -38,6 +60,7 @@ import {
 } from "./lib/controllers/refollow.js";
 import { startBatchRefollow } from "./lib/batch-refollow.js";
 import { logActivity } from "./lib/activity-log.js";
+import { scheduleCleanup } from "./lib/timeline-cleanup.js";
 
 const defaults = {
   mountPath: "/activitypub",
@@ -54,6 +77,7 @@ const defaults = {
   redisUrl: "",
   parallelWorkers: 5,
   actorType: "Person",
+  timelineRetention: 1000,
 };
 
 export default class ActivityPubEndpoint {
@@ -72,8 +96,8 @@ export default class ActivityPubEndpoint {
 
   get navigationItems() {
     return {
-      href: this.options.mountPath,
-      text: "activitypub.title",
+      href: `${this.options.mountPath}/admin/reader`,
+      text: "activitypub.reader.title",
       requiresDatabase: true,
     };
   }
@@ -145,17 +169,33 @@ export default class ActivityPubEndpoint {
     const mp = this.options.mountPath;
 
     router.get("/", dashboardController(mp));
+    router.get("/admin/reader", readerController(mp));
+    router.get("/admin/reader/notifications", notificationsController(mp));
+    router.get("/admin/reader/compose", composeController(mp, this));
+    router.post("/admin/reader/compose", submitComposeController(mp, this));
+    router.post("/admin/reader/like", likeController(mp, this));
+    router.post("/admin/reader/unlike", unlikeController(mp, this));
+    router.post("/admin/reader/boost", boostController(mp, this));
+    router.post("/admin/reader/unboost", unboostController(mp, this));
+    router.get("/admin/reader/profile", remoteProfileController(mp, this));
+    router.post("/admin/reader/follow", followController(mp, this));
+    router.post("/admin/reader/unfollow", unfollowController(mp, this));
+    router.get("/admin/reader/moderation", moderationController(mp));
+    router.post("/admin/reader/mute", muteController(mp, this));
+    router.post("/admin/reader/unmute", unmuteController(mp, this));
+    router.post("/admin/reader/block", blockController(mp, this));
+    router.post("/admin/reader/unblock", unblockController(mp, this));
     router.get("/admin/followers", followersController(mp));
     router.get("/admin/following", followingController(mp));
     router.get("/admin/activities", activitiesController(mp));
     router.get("/admin/featured", featuredGetController(mp));
-    router.post("/admin/featured/pin", featuredPinController(mp));
-    router.post("/admin/featured/unpin", featuredUnpinController(mp));
+    router.post("/admin/featured/pin", featuredPinController(mp, this));
+    router.post("/admin/featured/unpin", featuredUnpinController(mp, this));
     router.get("/admin/tags", featuredTagsGetController(mp));
-    router.post("/admin/tags/add", featuredTagsAddController(mp));
-    router.post("/admin/tags/remove", featuredTagsRemoveController(mp));
+    router.post("/admin/tags/add", featuredTagsAddController(mp, this));
+    router.post("/admin/tags/remove", featuredTagsRemoveController(mp, this));
     router.get("/admin/profile", profileGetController(mp));
-    router.post("/admin/profile", profilePostController(mp));
+    router.post("/admin/profile", profilePostController(mp, this));
     router.get("/admin/migrate", migrateGetController(mp, this.options));
     router.post("/admin/migrate", migratePostController(mp, this.options));
     router.post(
@@ -483,7 +523,7 @@ export default class ActivityPubEndpoint {
             inbox,
             sharedInbox,
             followedAt: new Date().toISOString(),
-            source: "microsub-reader",
+            source: "reader",
           },
         },
         { upsert: true },
@@ -593,6 +633,59 @@ export default class ActivityPubEndpoint {
     }
   }
 
+  /**
+   * Send an Update(Person) activity to all followers so remote servers
+   * re-fetch the actor object (picking up profile changes, new featured
+   * collections, attachments, etc.).
+   */
+  async broadcastActorUpdate() {
+    if (!this._federation) return;
+
+    try {
+      const { Update } = await import("@fedify/fedify");
+      const handle = this.options.actor.handle;
+      const ctx = this._federation.createContext(
+        new URL(this._publicationUrl),
+        { handle, publicationUrl: this._publicationUrl },
+      );
+
+      // Retrieve the full actor from the dispatcher (same object remote
+      // servers will get when they re-fetch the actor URL)
+      const actor = await ctx.getActor(handle);
+      if (!actor) {
+        console.warn("[ActivityPub] broadcastActorUpdate: could not build actor");
+        return;
+      }
+
+      const update = new Update({
+        actor: ctx.getActorUri(handle),
+        object: actor,
+      });
+
+      await ctx.sendActivity(
+        { identifier: handle },
+        "followers",
+        update,
+        { preferSharedInbox: true },
+      );
+
+      console.info("[ActivityPub] Sent Update(Person) to followers");
+
+      await logActivity(this._collections.ap_activities, {
+        direction: "outbound",
+        type: "Update",
+        actorUrl: this._publicationUrl,
+        objectUrl: this._getActorUrl(),
+        summary: "Sent Update(Person) to followers",
+      }).catch(() => {});
+    } catch (error) {
+      console.error(
+        "[ActivityPub] broadcastActorUpdate failed:",
+        error.message,
+      );
+    }
+  }
+
   /**
    * Build the full actor URL from config.
    * @returns {string}
@@ -619,6 +712,12 @@ export default class ActivityPubEndpoint {
     Indiekit.addCollection("ap_profile");
     Indiekit.addCollection("ap_featured");
     Indiekit.addCollection("ap_featured_tags");
+    // Reader collections
+    Indiekit.addCollection("ap_timeline");
+    Indiekit.addCollection("ap_notifications");
+    Indiekit.addCollection("ap_muted");
+    Indiekit.addCollection("ap_blocked");
+    Indiekit.addCollection("ap_interactions");
 
     // Store collection references (posts resolved lazily)
     const indiekitCollections = Indiekit.collections;
@@ -631,16 +730,15 @@ export default class ActivityPubEndpoint {
       ap_profile: indiekitCollections.get("ap_profile"),
       ap_featured: indiekitCollections.get("ap_featured"),
       ap_featured_tags: indiekitCollections.get("ap_featured_tags"),
+      // Reader collections
+      ap_timeline: indiekitCollections.get("ap_timeline"),
+      ap_notifications: indiekitCollections.get("ap_notifications"),
+      ap_muted: indiekitCollections.get("ap_muted"),
+      ap_blocked: indiekitCollections.get("ap_blocked"),
+      ap_interactions: indiekitCollections.get("ap_interactions"),
       get posts() {
         return indiekitCollections.get("posts");
       },
-      // Lazy access to Microsub collections (may not exist if plugin not loaded)
-      get microsub_items() {
-        return indiekitCollections.get("microsub_items");
-      },
-      get microsub_channels() {
-        return indiekitCollections.get("microsub_channels");
-      },
       _publicationUrl: this._publicationUrl,
     };
 
@@ -675,6 +773,60 @@ export default class ActivityPubEndpoint {
       { background: true },
     );
 
+    // Reader indexes (timeline, notifications, moderation, interactions)
+    this._collections.ap_timeline.createIndex(
+      { uid: 1 },
+      { unique: true, background: true },
+    );
+    this._collections.ap_timeline.createIndex(
+      { published: -1 },
+      { background: true },
+    );
+    this._collections.ap_timeline.createIndex(
+      { "author.url": 1 },
+      { background: true },
+    );
+    this._collections.ap_timeline.createIndex(
+      { type: 1, published: -1 },
+      { background: true },
+    );
+
+    this._collections.ap_notifications.createIndex(
+      { uid: 1 },
+      { unique: true, background: true },
+    );
+    this._collections.ap_notifications.createIndex(
+      { published: -1 },
+      { background: true },
+    );
+    this._collections.ap_notifications.createIndex(
+      { read: 1 },
+      { background: true },
+    );
+
+    this._collections.ap_muted.createIndex(
+      { url: 1 },
+      { unique: true, sparse: true, background: true },
+    );
+    this._collections.ap_muted.createIndex(
+      { keyword: 1 },
+      { unique: true, sparse: true, background: true },
+    );
+
+    this._collections.ap_blocked.createIndex(
+      { url: 1 },
+      { unique: true, background: true },
+    );
+
+    this._collections.ap_interactions.createIndex(
+      { objectUrl: 1, type: 1 },
+      { unique: true, background: true },
+    );
+    this._collections.ap_interactions.createIndex(
+      { type: 1 },
+      { background: true },
+    );
+
     // Seed actor profile from config on first run
     this._seedProfile().catch((error) => {
       console.warn("[ActivityPub] Profile seed failed:", error.message);
@@ -720,6 +872,11 @@ export default class ActivityPubEndpoint {
         console.error("[ActivityPub] Batch refollow start failed:", error.message);
       });
     }, 10_000);
+
+    // Schedule timeline retention cleanup (runs on startup + every 24h)
+    if (this.options.timelineRetention > 0) {
+      scheduleCleanup(this._collections, this.options.timelineRetention);
+    }
   }
 
   /**

package/lib/controllers/compose.js

@@ -0,0 +1,323 @@
+/**
+ * Compose controllers — reply form via Micropub or direct AP.
+ */
+
+import { Temporal } from "@js-temporal/polyfill";
+import { getTimelineItem } from "../storage/timeline.js";
+import { getToken, validateToken } from "../csrf.js";
+
+/**
+ * Fetch syndication targets from the Micropub config endpoint.
+ * @param {object} application - Indiekit application locals
+ * @param {string} token - Session access token
+ * @returns {Promise<Array>}
+ */
+async function getSyndicationTargets(application, token) {
+  try {
+    const micropubEndpoint = application.micropubEndpoint;
+
+    if (!micropubEndpoint) return [];
+
+    const micropubUrl = micropubEndpoint.startsWith("http")
+      ? micropubEndpoint
+      : new URL(micropubEndpoint, application.url).href;
+
+    const configUrl = `${micropubUrl}?q=config`;
+    const configResponse = await fetch(configUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    });
+
+    if (configResponse.ok) {
+      const config = await configResponse.json();
+      return config["syndicate-to"] || [];
+    }
+
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * GET /admin/reader/compose — Show compose form.
+ * @param {string} mountPath - Plugin mount path
+ * @param {object} plugin - ActivityPub plugin instance
+ */
+export function composeController(mountPath, plugin) {
+  return async (request, response, next) => {
+    try {
+      const { application } = request.app.locals;
+      const replyTo = request.query.replyTo || "";
+
+      // Fetch reply context (the post being replied to)
+      let replyContext = null;
+
+      if (replyTo) {
+        const collections = {
+          ap_timeline: application?.collections?.get("ap_timeline"),
+        };
+
+        // Try to find the post in our timeline first
+        replyContext = await getTimelineItem(collections, replyTo);
+
+        // If not in timeline, try to look up remotely
+        if (!replyContext && plugin._federation) {
+          try {
+            const handle = plugin.options.actor.handle;
+            const ctx = plugin._federation.createContext(
+              new URL(plugin._publicationUrl),
+              { handle, publicationUrl: plugin._publicationUrl },
+            );
+            const remoteObject = await ctx.lookupObject(new URL(replyTo));
+
+            if (remoteObject) {
+              let authorName = "";
+              let authorUrl = "";
+
+              if (typeof remoteObject.getAttributedTo === "function") {
+                const author = await remoteObject.getAttributedTo();
+                const actor = Array.isArray(author) ? author[0] : author;
+
+                if (actor) {
+                  authorName =
+                    actor.name?.toString() ||
+                    actor.preferredUsername?.toString() ||
+                    "";
+                  authorUrl = actor.id?.href || "";
+                }
+              }
+
+              replyContext = {
+                url: replyTo,
+                name: remoteObject.name?.toString() || "",
+                content: {
+                  text:
+                    remoteObject.content?.toString()?.slice(0, 300) || "",
+                },
+                author: { name: authorName, url: authorUrl },
+              };
+            }
+          } catch {
+            // Could not resolve — form still works without context
+          }
+        }
+      }
+
+      // Fetch syndication targets for Micropub path
+      const token = request.session?.access_token;
+      const syndicationTargets = token
+        ? await getSyndicationTargets(application, token)
+        : [];
+
+      const csrfToken = getToken(request.session);
+
+      response.render("activitypub-compose", {
+        title: response.locals.__("activitypub.compose.title"),
+        replyTo,
+        replyContext,
+        syndicationTargets,
+        csrfToken,
+        mountPath,
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+
+/**
+ * POST /admin/reader/compose — Submit reply via Micropub or direct AP.
+ * @param {string} mountPath - Plugin mount path
+ * @param {object} plugin - ActivityPub plugin instance
+ */
+export function submitComposeController(mountPath, plugin) {
+  return async (request, response, next) => {
+    try {
+      if (!validateToken(request)) {
+        return response.status(403).render("error", {
+          title: "Error",
+          content: "Invalid CSRF token",
+        });
+      }
+
+      const { application } = request.app.locals;
+      const { content, mode } = request.body;
+      const inReplyTo = request.body["in-reply-to"];
+      const syndicateTo = request.body["mp-syndicate-to"];
+
+      if (!content || !content.trim()) {
+        return response.status(400).render("error", {
+          title: "Error",
+          content: response.locals.__("activitypub.compose.errorEmpty"),
+        });
+      }
+
+      // Quick reply — direct AP
+      if (mode === "quick") {
+        if (!plugin._federation) {
+          return response.status(503).render("error", {
+            title: "Error",
+            content: "Federation not initialized",
+          });
+        }
+
+        const { Create, Note } = await import("@fedify/fedify");
+        const handle = plugin.options.actor.handle;
+        const ctx = plugin._federation.createContext(
+          new URL(plugin._publicationUrl),
+          { handle, publicationUrl: plugin._publicationUrl },
+        );
+
+        const noteId = `urn:uuid:${crypto.randomUUID()}`;
+        const actorUri = ctx.getActorUri(handle);
+
+        const note = new Note({
+          id: new URL(noteId),
+          attribution: actorUri,
+          content: content.trim(),
+          inReplyTo: inReplyTo ? new URL(inReplyTo) : undefined,
+          published: Temporal.Now.instant(),
+        });
+
+        const create = new Create({
+          id: new URL(`${noteId}#activity`),
+          actor: actorUri,
+          object: note,
+        });
+
+        // Send to followers
+        await ctx.sendActivity({ identifier: handle }, "followers", create, {
+          preferSharedInbox: true,
+          syncCollection: true,
+          orderingKey: noteId,
+        });
+
+        // If replying, also send to the original author
+        if (inReplyTo) {
+          try {
+            const remoteObject = await ctx.lookupObject(new URL(inReplyTo));
+
+            if (
+              remoteObject &&
+              typeof remoteObject.getAttributedTo === "function"
+            ) {
+              const author = await remoteObject.getAttributedTo();
+              const recipient = Array.isArray(author)
+                ? author[0]
+                : author;
+
+              if (recipient) {
+                await ctx.sendActivity(
+                  { identifier: handle },
+                  recipient,
+                  create,
+                  { orderingKey: noteId },
+                );
+              }
+            }
+          } catch {
+            // Non-critical — followers still got it
+          }
+        }
+
+        console.info(
+          `[ActivityPub] Sent quick reply${inReplyTo ? ` to ${inReplyTo}` : ""}`,
+        );
+
+        return response.redirect(`${mountPath}/admin/reader`);
+      }
+
+      // Micropub path — post as blog reply
+      const micropubEndpoint = application.micropubEndpoint;
+
+      if (!micropubEndpoint) {
+        return response.status(500).render("error", {
+          title: "Error",
+          content: "Micropub endpoint not configured",
+        });
+      }
+
+      const micropubUrl = micropubEndpoint.startsWith("http")
+        ? micropubEndpoint
+        : new URL(micropubEndpoint, application.url).href;
+
+      const token = request.session?.access_token;
+
+      if (!token) {
+        return response.redirect(
+          "/session/login?redirect=" + request.originalUrl,
+        );
+      }
+
+      const micropubData = new URLSearchParams();
+      micropubData.append("h", "entry");
+      micropubData.append("content", content.trim());
+
+      if (inReplyTo) {
+        micropubData.append("in-reply-to", inReplyTo);
+      }
+
+      if (syndicateTo) {
+        const targets = Array.isArray(syndicateTo)
+          ? syndicateTo
+          : [syndicateTo];
+
+        for (const target of targets) {
+          micropubData.append("mp-syndicate-to", target);
+        }
+      }
+
+      const micropubResponse = await fetch(micropubUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json",
+        },
+        body: micropubData.toString(),
+      });
+
+      if (
+        micropubResponse.ok ||
+        micropubResponse.status === 201 ||
+        micropubResponse.status === 202
+      ) {
+        const location = micropubResponse.headers.get("Location");
+        console.info(
+          `[ActivityPub] Created blog reply via Micropub: ${location || "success"}`,
+        );
+
+        return response.redirect(`${mountPath}/admin/reader`);
+      }
+
+      const errorBody = await micropubResponse.text();
+      let errorMessage = `Micropub error: ${micropubResponse.statusText}`;
+
+      try {
+        const errorJson = JSON.parse(errorBody);
+
+        if (errorJson.error_description) {
+          errorMessage = String(errorJson.error_description);
+        } else if (errorJson.error) {
+          errorMessage = String(errorJson.error);
+        }
+      } catch {
+        // Not JSON
+      }
+
+      return response.status(micropubResponse.status).render("error", {
+        title: "Error",
+        content: errorMessage,
+      });
+    } catch (error) {
+      console.error("[ActivityPub] Compose submit failed:", error.message);
+      return response.status(500).render("error", {
+        title: "Error",
+        content: "Failed to create post. Please try again later.",
+      });
+    }
+  };
+}

package/lib/controllers/featured-tags.js

@@ -24,7 +24,7 @@ export function featuredTagsGetController(mountPath) {
   };
 }
 
-export function featuredTagsAddController(mountPath) {
+export function featuredTagsAddController(mountPath, plugin) {
   return async (request, response, next) => {
     try {
       const { application } = request.app.locals;
@@ -44,6 +44,11 @@ export function featuredTagsAddController(mountPath) {
         { upsert: true },
       );
 
+      // Notify followers so they re-fetch featured tags
+      if (plugin?.broadcastActorUpdate) {
+        plugin.broadcastActorUpdate().catch(() => {});
+      }
+
       response.redirect(`${mountPath}/admin/tags`);
     } catch (error) {
       next(error);
@@ -51,7 +56,7 @@ export function featuredTagsAddController(mountPath) {
   };
 }
 
-export function featuredTagsRemoveController(mountPath) {
+export function featuredTagsRemoveController(mountPath, plugin) {
   return async (request, response, next) => {
     try {
       const { application } = request.app.locals;
@@ -63,6 +68,11 @@ export function featuredTagsRemoveController(mountPath) {
 
       await collection.deleteOne({ tag });
 
+      // Notify followers so they re-fetch featured tags
+      if (plugin?.broadcastActorUpdate) {
+        plugin.broadcastActorUpdate().catch(() => {});
+      }
+
       response.redirect(`${mountPath}/admin/tags`);
     } catch (error) {
       next(error);

package/lib/controllers/featured.js

@@ -69,7 +69,7 @@ export function featuredGetController(mountPath) {
   };
 }
 
-export function featuredPinController(mountPath) {
+export function featuredPinController(mountPath, plugin) {
   return async (request, response, next) => {
     try {
       const { application } = request.app.locals;
@@ -90,6 +90,11 @@ export function featuredPinController(mountPath) {
         { upsert: true },
       );
 
+      // Notify followers so they re-fetch the featured collection
+      if (plugin?.broadcastActorUpdate) {
+        plugin.broadcastActorUpdate().catch(() => {});
+      }
+
       response.redirect(`${mountPath}/admin/featured`);
     } catch (error) {
       next(error);
@@ -97,7 +102,7 @@ export function featuredPinController(mountPath) {
   };
 }
 
-export function featuredUnpinController(mountPath) {
+export function featuredUnpinController(mountPath, plugin) {
   return async (request, response, next) => {
     try {
       const { application } = request.app.locals;
@@ -109,6 +114,11 @@ export function featuredUnpinController(mountPath) {
 
       await collection.deleteOne({ postUrl });
 
+      // Notify followers so they re-fetch the featured collection
+      if (plugin?.broadcastActorUpdate) {
+        plugin.broadcastActorUpdate().catch(() => {});
+      }
+
       response.redirect(`${mountPath}/admin/featured`);
     } catch (error) {
       next(error);