@rmdes/indiekit-endpoint-microsub 1.0.31 → 1.0.33

package/assets/styles.css

@@ -936,3 +936,81 @@
 .feed-edit__action p {
   margin-bottom: var(--space-s);
 }
+
+/* ==========================================================================
+   Actor Profile
+   ========================================================================== */
+
+.actor-profile {
+  background: var(--color-offset);
+  border-radius: var(--border-radius);
+  margin-bottom: var(--space-m);
+  padding: var(--space-m);
+}
+
+.actor-profile__header {
+  align-items: flex-start;
+  display: flex;
+  gap: var(--space-m);
+}
+
+.actor-profile__avatar {
+  border-radius: 50%;
+  flex-shrink: 0;
+  object-fit: cover;
+}
+
+.actor-profile__info {
+  flex: 1;
+  min-width: 0;
+}
+
+.actor-profile__name {
+  font-size: 1.25em;
+  margin: 0 0 2px;
+}
+
+.actor-profile__handle {
+  color: var(--color-text-muted, #666);
+  font-size: 0.9em;
+}
+
+.actor-profile__summary {
+  font-size: 0.9em;
+  margin: var(--space-xs) 0 0;
+}
+
+.actor-profile__stats {
+  color: var(--color-text-muted, #666);
+  display: flex;
+  font-size: 0.85em;
+  gap: var(--space-m);
+  margin-top: var(--space-xs);
+}
+
+.actor-profile__actions {
+  display: flex;
+  gap: var(--space-s);
+  margin-top: var(--space-s);
+}
+
+/* ==========================================================================
+   AP Badge
+   ========================================================================== */
+
+.item-card__badge {
+  border-radius: 3px;
+  display: inline-block;
+  font-size: 0.7em;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  line-height: 1;
+  padding: 2px 4px;
+  text-transform: uppercase;
+  vertical-align: middle;
+}
+
+.item-card__badge--ap {
+  background: #7c3aed20;
+  color: #7c3aed;
+}

package/index.js

@@ -8,6 +8,7 @@ import { opmlController } from "./lib/controllers/opml.js";
 import { readerController } from "./lib/controllers/reader.js";
 import { handleMediaProxy } from "./lib/media/proxy.js";
 import { startScheduler, stopScheduler } from "./lib/polling/scheduler.js";
+import { ensureActivityPubChannel } from "./lib/storage/channels.js";
 import { cleanupAllReadItems, createIndexes } from "./lib/storage/items.js";
 import { webmentionReceiver } from "./lib/webmention/receiver.js";
 import { websubHandler } from "./lib/websub/handler.js";
@@ -126,6 +127,9 @@ export default class MicrosubEndpoint {
     readerRouter.get("/search", readerController.searchPage);
     readerRouter.post("/search", readerController.searchFeeds);
     readerRouter.post("/subscribe", readerController.subscribe);
+    readerRouter.get("/actor", readerController.actorProfile);
+    readerRouter.post("/actor/follow", readerController.followActorAction);
+    readerRouter.post("/actor/unfollow", readerController.unfollowActorAction);
     readerRouter.post("/api/mark-read", readerController.markAllRead);
     readerRouter.get("/opml", opmlController.exportOpml);
     router.use("/reader", readerRouter);
@@ -184,6 +188,14 @@ export default class MicrosubEndpoint {
       console.info("[Microsub] Database available, starting scheduler");
       startScheduler(indiekit);
 
+      // Ensure system channels exist
+      ensureActivityPubChannel(indiekit).catch((error) => {
+        console.warn(
+          "[Microsub] ActivityPub channel creation failed:",
+          error.message,
+        );
+      });
+
       // Create indexes for optimal performance (runs in background)
       createIndexes(indiekit).catch((error) => {
         console.warn("[Microsub] Index creation failed:", error.message);

package/lib/activitypub/outbox-fetcher.js

@@ -0,0 +1,255 @@
+/**
+ * Fetch a remote ActivityPub actor's outbox for on-demand reading.
+ * Returns ephemeral jf2 items — nothing is stored in MongoDB.
+ *
+ * @module activitypub/outbox-fetcher
+ */
+
+const AP_ACCEPT =
+  'application/activity+json, application/ld+json; profile="https://www.w3.org/ns/activitystreams"';
+const FETCH_TIMEOUT = 10_000;
+const USER_AGENT = "Indiekit/1.0 (Microsub reader)";
+
+/**
+ * Fetch a remote actor's profile and recent posts from their outbox.
+ *
+ * @param {string} actorUrl - Full URL of the AP actor
+ * @param {object} [options]
+ * @param {number} [options.limit=20] - Max items to return
+ * @returns {Promise<{ actor: object, items: Array }>}
+ */
+export async function fetchActorOutbox(actorUrl, options = {}) {
+  const limit = options.limit || 20;
+
+  // 1. Fetch actor profile
+  const actor = await fetchJson(actorUrl);
+  if (!actor || !actor.outbox) {
+    throw new Error("Could not resolve actor or outbox URL");
+  }
+
+  const actorInfo = {
+    name:
+      actor.name ||
+      actor.preferredUsername ||
+      new URL(actorUrl).pathname.split("/").pop(),
+    url: actor.url || actor.id || actorUrl,
+    photo: actor.icon?.url || actor.icon || "",
+    summary: stripHtml(actor.summary || ""),
+    handle: actor.preferredUsername || "",
+    followersCount: 0,
+    followingCount: 0,
+  };
+
+  // Resolve follower/following counts if available
+  if (typeof actor.followers === "string") {
+    try {
+      const followersCollection = await fetchJson(actor.followers);
+      actorInfo.followersCount = followersCollection?.totalItems || 0;
+    } catch {
+      /* ignore */
+    }
+  }
+  if (typeof actor.following === "string") {
+    try {
+      const followingCollection = await fetchJson(actor.following);
+      actorInfo.followingCount = followingCollection?.totalItems || 0;
+    } catch {
+      /* ignore */
+    }
+  }
+
+  // 2. Fetch outbox (OrderedCollection)
+  const outboxUrl =
+    typeof actor.outbox === "string" ? actor.outbox : actor.outbox?.id;
+  const outbox = await fetchJson(outboxUrl);
+  if (!outbox) {
+    return { actor: actorInfo, items: [] };
+  }
+
+  // 3. Get items — may be inline or on a first page
+  let activities = [];
+
+  if (outbox.orderedItems?.length > 0) {
+    activities = outbox.orderedItems;
+  } else if (outbox.first) {
+    const firstPageUrl =
+      typeof outbox.first === "string" ? outbox.first : outbox.first?.id;
+    if (firstPageUrl) {
+      const firstPage = await fetchJson(firstPageUrl);
+      activities = firstPage?.orderedItems || firstPage?.items || [];
+    }
+  }
+
+  // 4. Convert Create activities to jf2 items
+  const items = [];
+  for (const activity of activities) {
+    if (items.length >= limit) break;
+
+    const item = activityToJf2(activity, actorInfo);
+    if (item) items.push(item);
+  }
+
+  return { actor: actorInfo, items };
+}
+
+/**
+ * Convert a single AP activity (or bare object) to jf2 format.
+ * @param {object} activity - AP activity or object
+ * @param {object} actorInfo - Actor profile info
+ * @returns {object|null} jf2 item or null if not displayable
+ */
+function activityToJf2(activity, actorInfo) {
+  // Unwrap Create/Announce — the displayable content is the inner object
+  let object = activity;
+  const activityType = activity.type;
+
+  if (activityType === "Create" || activityType === "Announce") {
+    object = activity.object;
+    if (!object || typeof object === "string") return null; // Unresolved reference
+  }
+
+  // Skip non-content types (Follow, Like, etc.)
+  const contentTypes = new Set([
+    "Note",
+    "Article",
+    "Page",
+    "Video",
+    "Audio",
+    "Image",
+    "Event",
+    "Question",
+  ]);
+  if (!contentTypes.has(object.type)) return null;
+
+  const contentHtml = object.content || "";
+  const contentText = stripHtml(contentHtml);
+
+  const jf2 = {
+    type: "entry",
+    url: object.url || object.id || "",
+    uid: object.id || object.url || "",
+    name: object.name || undefined,
+    content: contentHtml ? { text: contentText, html: contentHtml } : undefined,
+    summary: object.summary ? stripHtml(object.summary) : undefined,
+    published: object.published || activity.published || undefined,
+    author: {
+      name: actorInfo.name,
+      url: actorInfo.url,
+      photo: actorInfo.photo,
+    },
+    category: extractTags(object.tag),
+    photo: extractMedia(object.attachment, "image"),
+    video: extractMedia(object.attachment, "video"),
+    audio: extractMedia(object.attachment, "audio"),
+    _source: { type: "activitypub", actorUrl: actorInfo.url },
+  };
+
+  // Boost attribution
+  if (activityType === "Announce" && activity.actor) {
+    jf2._boostedBy = actorInfo;
+    // The inner object may have its own author
+    if (object.attributedTo) {
+      const attributedUrl =
+        typeof object.attributedTo === "string"
+          ? object.attributedTo
+          : object.attributedTo?.id || object.attributedTo?.url;
+      if (attributedUrl) {
+        jf2.author = {
+          name:
+            object.attributedTo?.name ||
+            object.attributedTo?.preferredUsername ||
+            attributedUrl,
+          url: attributedUrl,
+          photo: object.attributedTo?.icon?.url || "",
+        };
+      }
+    }
+  }
+
+  if (object.inReplyTo) {
+    const replyUrl =
+      typeof object.inReplyTo === "string"
+        ? object.inReplyTo
+        : object.inReplyTo?.id;
+    if (replyUrl) jf2["in-reply-to"] = [replyUrl];
+  }
+
+  return jf2;
+}
+
+/**
+ * Extract hashtags from AP tag array.
+ * @param {Array} tags - AP tag objects
+ * @returns {Array<string>}
+ */
+function extractTags(tags) {
+  if (!Array.isArray(tags)) return [];
+  return tags
+    .filter((t) => t.type === "Hashtag" || t.type === "Tag")
+    .map((t) => (t.name || "").replace(/^#/, ""))
+    .filter(Boolean);
+}
+
+/**
+ * Extract media URLs from AP attachment array.
+ * @param {Array} attachments - AP attachment objects
+ * @param {string} mediaPrefix - "image", "video", or "audio"
+ * @returns {Array<string>}
+ */
+function extractMedia(attachments, mediaPrefix) {
+  if (!Array.isArray(attachments)) return [];
+  return attachments
+    .filter((a) => (a.mediaType || "").startsWith(`${mediaPrefix}/`))
+    .map((a) => a.url || a.href || "")
+    .filter(Boolean);
+}
+
+/**
+ * Fetch a URL as ActivityPub JSON.
+ * @param {string} url
+ * @returns {Promise<object|null>}
+ */
+async function fetchJson(url) {
+  if (!url) return null;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: AP_ACCEPT,
+        "User-Agent": USER_AGENT,
+      },
+      signal: controller.signal,
+      redirect: "follow",
+    });
+
+    if (!response.ok) {
+      console.warn(
+        `[Microsub] AP fetch failed: ${response.status} for ${url}`,
+      );
+      return null;
+    }
+
+    return await response.json();
+  } catch (error) {
+    if (error.name === "AbortError") {
+      console.warn(`[Microsub] AP fetch timeout for ${url}`);
+    } else {
+      console.warn(`[Microsub] AP fetch error for ${url}: ${error.message}`);
+    }
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Strip HTML tags for plain text.
+ * @param {string} html
+ * @returns {string}
+ */
+function stripHtml(html) {
+  return (html || "").replace(/<[^>]*>/g, "").trim();
+}

package/lib/controllers/follow.js

@@ -5,6 +5,7 @@
 
 import { IndiekitError } from "@indiekit/error";
 
+import { detectCapabilities } from "../feeds/capabilities.js";
 import { refreshFeedNow } from "../polling/scheduler.js";
 import { getChannel } from "../storage/channels.js";
 import {
@@ -12,6 +13,7 @@ import {
   deleteFeed,
   getFeedByUrl,
   getFeedsForChannel,
+  updateFeed,
 } from "../storage/feeds.js";
 import { getUserId } from "../utils/auth.js";
 import { notifyBlogroll } from "../utils/blogroll-notify.js";
@@ -79,6 +81,15 @@ export async function follow(request, response) {
     console.error(`[Microsub] Error fetching new feed ${url}:`, error.message);
   });
 
+  // Detect source capabilities (fire-and-forget)
+  detectCapabilities(url).then((capabilities) => {
+    updateFeed(application, feed._id, { capabilities }).catch((error) => {
+      console.error(`[Microsub] Capability storage error:`, error.message);
+    });
+  }).catch((error) => {
+    console.error(`[Microsub] Capability detection error for ${url}:`, error.message);
+  });
+
   // Notify blogroll plugin (fire-and-forget)
   notifyBlogroll(application, "follow", {
     url,

package/lib/controllers/reader.js

@@ -28,6 +28,7 @@ import {
   markItemsRead,
   countReadItems,
 } from "../storage/items.js";
+import { fetchActorOutbox } from "../activitypub/outbox-fetcher.js";
 import { getUserId } from "../utils/auth.js";
 import {
   validateChannelName,
@@ -207,8 +208,8 @@ export async function deleteChannelAction(request, response) {
   const userId = getUserId(request);
   const { uid } = request.params;
 
-  // Don't allow deleting notifications channel
-  if (uid === "notifications") {
+  // Don't allow deleting system channels
+  if (uid === "notifications" || uid === "activitypub") {
     return response.redirect(`${request.baseUrl}/channels`);
   }
 
@@ -346,6 +347,20 @@ function ensureString(value) {
   return String(value);
 }
 
+/**
+ * Detect the protocol of a URL for auto-syndication targeting
+ * @param {string} url - URL to classify
+ * @returns {string} "atmosphere" | "fediverse" | "web"
+ */
+function detectProtocol(url) {
+  if (!url || typeof url !== "string") return "web";
+  const lower = url.toLowerCase();
+  if (lower.includes("bsky.app") || lower.includes("bluesky")) return "atmosphere";
+  if (lower.includes("mastodon.") || lower.includes("mstdn.") || lower.includes("fosstodon.") ||
+      lower.includes("pleroma.") || lower.includes("misskey.") || lower.includes("pixelfed.")) return "fediverse";
+  return "web";
+}
+
 /**
  * Fetch syndication targets from Micropub config
  * @param {object} application - Indiekit application
@@ -405,6 +420,20 @@ export async function compose(request, response) {
     ? await getSyndicationTargets(application, token)
     : [];
 
+  // Auto-select syndication target based on interaction URL protocol
+  const interactionUrl = ensureString(replyTo || reply || likeOf || like || repostOf || repost);
+  if (interactionUrl && syndicationTargets.length > 0) {
+    const protocol = detectProtocol(interactionUrl);
+    for (const target of syndicationTargets) {
+      const targetId = (target.uid || target.name || "").toLowerCase();
+      if (protocol === "atmosphere" && (targetId.includes("bluesky") || targetId.includes("bsky"))) {
+        target.checked = true;
+      } else if (protocol === "fediverse" && (targetId.includes("mastodon") || targetId.includes("mstdn"))) {
+        target.checked = true;
+      }
+    }
+  }
+
   response.render("compose", {
     title: request.__("microsub.compose.title"),
     replyTo: ensureString(replyTo || reply),
@@ -909,6 +938,118 @@ export async function refreshFeed(request, response) {
   response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
 }
 
+/**
+ * Actor profile — fetch and display a remote AP actor's recent posts
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+/**
+ * Find the ActivityPub plugin instance from installed plugins.
+ * @param {object} request - Express request
+ * @returns {object|undefined} The AP plugin instance
+ */
+function getApPlugin(request) {
+  const installedPlugins = request.app.locals.installedPlugins;
+  if (!installedPlugins) return undefined;
+  return [...installedPlugins].find(
+    (p) => p.name === "ActivityPub endpoint",
+  );
+}
+
+export async function actorProfile(request, response) {
+  const actorUrl = request.query.url;
+  if (!actorUrl) {
+    return response.status(400).render("404");
+  }
+
+  // Check if we already follow this actor
+  const { application } = request.app.locals;
+  const apFollowing = application?.collections?.get("ap_following");
+  let isFollowing = false;
+  if (apFollowing) {
+    const existing = await apFollowing.findOne({ actorUrl });
+    isFollowing = !!existing;
+  }
+
+  // Check if AP plugin is available (for follow button visibility)
+  const apPlugin = getApPlugin(request);
+  const canFollow = !!apPlugin;
+
+  try {
+    const { actor, items } = await fetchActorOutbox(actorUrl, { limit: 30 });
+
+    response.render("actor", {
+      title: actor.name || "Actor",
+      actor,
+      items,
+      actorUrl,
+      isFollowing,
+      canFollow,
+      baseUrl: request.baseUrl,
+    });
+  } catch (error) {
+    console.error(`[Microsub] Actor profile fetch failed: ${error.message}`);
+    response.render("actor", {
+      title: "Actor",
+      actor: { name: actorUrl, url: actorUrl, photo: "", summary: "" },
+      items: [],
+      actorUrl,
+      isFollowing,
+      canFollow,
+      baseUrl: request.baseUrl,
+      error: "Could not fetch this actor's profile. They may have restricted access.",
+    });
+  }
+}
+
+export async function followActorAction(request, response) {
+  const { actorUrl, actorName } = request.body;
+  if (!actorUrl) {
+    return response.status(400).redirect(request.baseUrl + "/channels/activitypub");
+  }
+
+  const apPlugin = getApPlugin(request);
+  if (!apPlugin) {
+    console.error("[Microsub] Cannot follow: ActivityPub plugin not installed");
+    return response.redirect(
+      `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+    );
+  }
+
+  const result = await apPlugin.followActor(actorUrl, { name: actorName });
+  if (!result.ok) {
+    console.error(`[Microsub] Follow via AP plugin failed: ${result.error}`);
+  }
+
+  return response.redirect(
+    `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+  );
+}
+
+export async function unfollowActorAction(request, response) {
+  const { actorUrl } = request.body;
+  if (!actorUrl) {
+    return response.status(400).redirect(request.baseUrl + "/channels/activitypub");
+  }
+
+  const apPlugin = getApPlugin(request);
+  if (!apPlugin) {
+    console.error("[Microsub] Cannot unfollow: ActivityPub plugin not installed");
+    return response.redirect(
+      `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+    );
+  }
+
+  const result = await apPlugin.unfollowActor(actorUrl);
+  if (!result.ok) {
+    console.error(`[Microsub] Unfollow via AP plugin failed: ${result.error}`);
+  }
+
+  return response.redirect(
+    `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+  );
+}
+
 export const readerController = {
   index,
   channels,
@@ -933,4 +1074,7 @@ export const readerController = {
   searchPage,
   searchFeeds,
   subscribe,
+  actorProfile,
+  followActorAction,
+  unfollowActorAction,
 };

package/lib/feeds/capabilities.js

@@ -0,0 +1,204 @@
+/**
+ * Source capability detection
+ * Detects what a feed source supports (webmention, micropub, platform API)
+ * @module feeds/capabilities
+ */
+
+/**
+ * Known Fediverse domain patterns
+ */
+const FEDIVERSE_PATTERNS = [
+  "mastodon.",
+  "mstdn.",
+  "fosstodon.",
+  "pleroma.",
+  "misskey.",
+  "pixelfed.",
+  "fediverse",
+];
+
+/**
+ * Detect the capabilities of a feed source
+ * @param {string} feedUrl - The feed URL
+ * @param {string} [siteUrl] - Optional site homepage URL (if different from feed)
+ * @returns {Promise<object>} Capability profile
+ */
+export async function detectCapabilities(feedUrl, siteUrl) {
+  const result = {
+    source_type: "publication",
+    webmention: null,
+    micropub: null,
+    platform_api: null,
+    author_mode: "single",
+    interactions: [],
+    detected_at: new Date().toISOString(),
+  };
+
+  try {
+    // 1. Pattern-match feed URL for known platforms
+    const platformMatch = matchPlatform(feedUrl);
+    if (platformMatch) {
+      result.source_type = platformMatch.type;
+      result.platform_api = platformMatch.api;
+      result.interactions = platformMatch.interactions;
+      return result;
+    }
+
+    // 2. Fetch site homepage and check for rel links
+    const homepageUrl = siteUrl || deriveHomepage(feedUrl);
+    if (homepageUrl) {
+      const endpoints = await discoverEndpoints(homepageUrl);
+      result.webmention = endpoints.webmention;
+      result.micropub = endpoints.micropub;
+
+      if (endpoints.webmention && endpoints.micropub) {
+        result.source_type = "indieweb";
+        result.interactions = ["reply", "like", "repost", "bookmark"];
+      } else if (endpoints.webmention) {
+        result.source_type = "web";
+        result.interactions = ["reply"];
+      }
+    }
+  } catch (error) {
+    console.error(
+      `[Microsub] Capability detection failed for ${feedUrl}:`,
+      error.message,
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Pattern-match a feed URL against known platforms
+ * @param {string} url - Feed URL
+ * @returns {object|null} Platform match or null
+ */
+function matchPlatform(url) {
+  const lower = url.toLowerCase();
+
+  // Bluesky
+  if (lower.includes("bsky.app") || lower.includes("bluesky")) {
+    return {
+      type: "bluesky",
+      api: { type: "atproto", authed: false },
+      interactions: ["reply", "like", "repost"],
+    };
+  }
+
+  // Mastodon / Fediverse RSS (e.g., mastodon.social/@user.rss)
+  if (FEDIVERSE_PATTERNS.some((pattern) => lower.includes(pattern))) {
+    return {
+      type: "mastodon",
+      api: { type: "activitypub", authed: false },
+      interactions: ["reply", "like", "repost"],
+    };
+  }
+
+  // WordPress (common RSS patterns)
+  if (lower.includes("/wp-json/") || lower.includes("/feed/")) {
+    // Could be WordPress but also others — don't match too broadly
+    // Only match the /wp-json/ pattern which is WordPress-specific
+    if (lower.includes("/wp-json/")) {
+      return {
+        type: "wordpress",
+        api: { type: "wp-rest", authed: false },
+        interactions: ["reply"],
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Derive a homepage URL from a feed URL
+ * @param {string} feedUrl - Feed URL
+ * @returns {string|null} Homepage URL
+ */
+function deriveHomepage(feedUrl) {
+  try {
+    const url = new URL(feedUrl);
+    return `${url.protocol}//${url.host}/`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Discover webmention and micropub endpoints from a URL
+ * @param {string} url - URL to check for endpoint links
+ * @returns {Promise<object>} Discovered endpoints
+ */
+async function discoverEndpoints(url) {
+  const endpoints = {
+    webmention: null,
+    micropub: null,
+  };
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15_000);
+
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Accept: "text/html",
+        "User-Agent": "Microsub/1.0 (+https://indieweb.org/Microsub)",
+      },
+      redirect: "follow",
+    });
+
+    if (!response.ok) return endpoints;
+
+    // Check Link headers first
+    const linkHeader = response.headers.get("link");
+    if (linkHeader) {
+      const wmMatch = linkHeader.match(
+        /<([^>]+)>;\s*rel="?webmention"?/i,
+      );
+      if (wmMatch) endpoints.webmention = wmMatch[1];
+
+      const mpMatch = linkHeader.match(
+        /<([^>]+)>;\s*rel="?micropub"?/i,
+      );
+      if (mpMatch) endpoints.micropub = mpMatch[1];
+    }
+
+    // If not found in headers, check HTML
+    if (!endpoints.webmention || !endpoints.micropub) {
+      const html = await response.text();
+
+      if (!endpoints.webmention) {
+        const wmHtml = html.match(
+          /<link[^>]+rel="?webmention"?[^>]+href="([^"]+)"/i,
+        ) ||
+          html.match(
+            /<link[^>]+href="([^"]+)"[^>]+rel="?webmention"?/i,
+          );
+        if (wmHtml) endpoints.webmention = wmHtml[1];
+      }
+
+      if (!endpoints.micropub) {
+        const mpHtml = html.match(
+          /<link[^>]+rel="?micropub"?[^>]+href="([^"]+)"/i,
+        ) ||
+          html.match(
+            /<link[^>]+href="([^"]+)"[^>]+rel="?micropub"?/i,
+          );
+        if (mpHtml) endpoints.micropub = mpHtml[1];
+      }
+    }
+  } catch (error) {
+    if (error.name !== "AbortError") {
+      console.debug(
+        `[Microsub] Endpoint discovery failed for ${url}:`,
+        error.message,
+      );
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  return endpoints;
+}

package/lib/polling/processor.js

@@ -4,9 +4,11 @@
  */
 
 import { getRedisClient, publishEvent } from "../cache/redis.js";
+import { detectCapabilities } from "../feeds/capabilities.js";
 import { fetchAndParseFeed } from "../feeds/fetcher.js";
 import { getChannel } from "../storage/channels.js";
 import {
+  updateFeed,
   updateFeedAfterFetch,
   updateFeedStatus,
   updateFeedWebsub,
@@ -82,6 +84,15 @@ export async function processFeed(application, feed) {
         item._source.name = feed.title || parsed.name;
       }
 
+      // Attach source_type from feed capabilities (for protocol indicators)
+      // Falls back to URL-based inference when capabilities haven't been detected yet
+      item._source = item._source || {};
+      if (feed.capabilities?.source_type) {
+        item._source.source_type = feed.capabilities.source_type;
+      } else {
+        item._source.source_type = inferSourceType(feed.url);
+      }
+
       // Store the item
       const stored = await addItem(application, {
         channelId: feed.channelId,
@@ -177,6 +188,20 @@ export async function processFeed(application, feed) {
       success: true,
       itemCount: parsed.items?.length || 0,
     });
+
+    // Detect source capabilities on first successful fetch (if not yet detected)
+    if (!feed.capabilities) {
+      detectCapabilities(feed.url)
+        .then((capabilities) => {
+          updateFeed(application, feed._id, { capabilities }).catch(() => {});
+        })
+        .catch((error) => {
+          console.debug(
+            `[Microsub] Capability detection skipped for ${feed.url}:`,
+            error.message,
+          );
+        });
+    }
   } catch (error) {
     result.error = error.message;
 
@@ -208,6 +233,21 @@ export async function processFeed(application, feed) {
   return result;
 }
 
+/**
+ * Infer source type from feed URL when capabilities haven't been detected yet
+ * @param {string} url - Feed URL
+ * @returns {string} Source type
+ */
+function inferSourceType(url) {
+  if (!url) return "web";
+  const lower = url.toLowerCase();
+  if (lower.includes("bsky.app") || lower.includes("bluesky")) return "bluesky";
+  if (lower.includes("mastodon.") || lower.includes("mstdn.") ||
+      lower.includes("fosstodon.") || lower.includes("pleroma.") ||
+      lower.includes("misskey.") || lower.includes("pixelfed.")) return "mastodon";
+  return "web";
+}
+
 /**
  * Check if an item passes channel filters
  * @param {object} item - Feed item

package/lib/storage/channels.js

@@ -207,8 +207,8 @@ export async function deleteChannel(application, uid, userId) {
   const query = { uid };
   if (userId) query.userId = userId;
 
-  // Don't allow deleting notifications channel
-  if (uid === "notifications") {
+  // Don't allow deleting system channels
+  if (uid === "notifications" || uid === "activitypub") {
     return false;
   }
 
@@ -306,3 +306,39 @@ export async function ensureNotificationsChannel(application, userId) {
   await collection.insertOne(channel);
   return channel;
 }
+
+/**
+ * Ensure ActivityPub channel exists
+ * @param {object} application - Indiekit application
+ * @param {string} [userId] - User ID
+ * @returns {Promise<object>} ActivityPub channel
+ */
+export async function ensureActivityPubChannel(application, userId) {
+  const collection = getCollection(application);
+
+  const existing = await collection.findOne({
+    uid: "activitypub",
+    ...(userId && { userId }),
+  });
+
+  if (existing) {
+    return existing;
+  }
+
+  const channel = {
+    uid: "activitypub",
+    name: "Fediverse",
+    userId,
+    source: "activitypub",
+    order: -0.5, // After notifications (-1), before user channels (0+)
+    settings: {
+      excludeTypes: [],
+      excludeRegex: undefined,
+    },
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  await collection.insertOne(channel);
+  return channel;
+}

package/lib/storage/items.js

@@ -298,6 +298,10 @@ const MAX_FULL_READ_ITEMS = 200;
  * Cleanup old read items by stripping content but preserving dedup skeletons.
  * This prevents the vicious cycle where deleted read items get re-ingested as
  * unread by the poller because the dedup record (channelId + uid) was destroyed.
+ *
+ * AP items (feedId: null) are hard-deleted instead of stripped, since no poller
+ * re-ingests them — they arrive via inbox push and don't need dedup skeletons.
+ *
  * @param {object} collection - MongoDB collection
  * @param {ObjectId} channelObjectId - Channel ObjectId
  * @param {string} userId - User ID
@@ -310,22 +314,44 @@ async function cleanupOldReadItems(collection, channelObjectId, userId) {
 
   if (readCount > MAX_FULL_READ_ITEMS) {
     // Find old read items beyond the retention limit
-    const itemsToStrip = await collection
+    const itemsToCleanup = await collection
       .find({
         channelId: channelObjectId,
         readBy: userId,
-        _stripped: { $ne: true }, // Don't re-strip already-stripped items
+        _stripped: { $ne: true },
       })
       .sort({ published: -1, _id: -1 })
       .skip(MAX_FULL_READ_ITEMS)
-      .project({ _id: 1 })
+      .project({ _id: 1, feedId: 1 })
       .toArray();
 
-    if (itemsToStrip.length > 0) {
-      const idsToStrip = itemsToStrip.map((item) => item._id);
-      // Strip content but keep dedup skeleton (channelId, uid, feedId, readBy)
-      const result = await collection.updateMany(
-        { _id: { $in: idsToStrip } },
+    if (itemsToCleanup.length === 0) return;
+
+    // Separate AP items (feedId: null) from RSS items (feedId: ObjectId)
+    const apItemIds = [];
+    const rssItemIds = [];
+    for (const item of itemsToCleanup) {
+      if (item.feedId) {
+        rssItemIds.push(item._id);
+      } else {
+        apItemIds.push(item._id);
+      }
+    }
+
+    // Hard-delete AP items — no poller to re-ingest, skeletons are useless
+    if (apItemIds.length > 0) {
+      const deleted = await collection.deleteMany({
+        _id: { $in: apItemIds },
+      });
+      console.info(
+        `[Microsub] Deleted ${deleted.deletedCount} old AP read items`,
+      );
+    }
+
+    // Strip RSS items to dedup skeletons — poller would re-ingest if deleted
+    if (rssItemIds.length > 0) {
+      const stripped = await collection.updateMany(
+        { _id: { $in: rssItemIds } },
         {
           $set: { _stripped: true },
           $unset: {
@@ -346,7 +372,7 @@ async function cleanupOldReadItems(collection, channelObjectId, userId) {
         },
       );
       console.info(
-        `[Microsub] Stripped content from ${result.modifiedCount} old read items (keeping ${MAX_FULL_READ_ITEMS} full)`,
+        `[Microsub] Stripped ${stripped.modifiedCount} old RSS read items (keeping ${MAX_FULL_READ_ITEMS} full)`,
       );
     }
   }
@@ -354,16 +380,16 @@ async function cleanupOldReadItems(collection, channelObjectId, userId) {
 
 /**
  * Cleanup all read items across all channels (startup cleanup).
- * Strips content from old read items but preserves dedup skeletons.
+ * RSS items are stripped to dedup skeletons; AP items are hard-deleted.
  * @param {object} application - Indiekit application
- * @returns {Promise<number>} Total number of items stripped
+ * @returns {Promise<number>} Total number of items cleaned up
  */
 export async function cleanupAllReadItems(application) {
   const collection = getCollection(application);
   const channelsCollection = application.collections.get("microsub_channels");
 
   const channels = await channelsCollection.find({}).toArray();
-  let totalStripped = 0;
+  let totalCleaned = 0;
 
   for (const channel of channels) {
     const readByUsers = await collection.distinct("readBy", {
@@ -381,7 +407,7 @@ export async function cleanupAllReadItems(application) {
       });
 
       if (readCount > MAX_FULL_READ_ITEMS) {
-        const itemsToStrip = await collection
+        const itemsToCleanup = await collection
           .find({
             channelId: channel._id,
             readBy: userId,
@@ -389,48 +415,71 @@ export async function cleanupAllReadItems(application) {
           })
           .sort({ published: -1, _id: -1 })
           .skip(MAX_FULL_READ_ITEMS)
-          .project({ _id: 1 })
+          .project({ _id: 1, feedId: 1 })
           .toArray();
 
-        if (itemsToStrip.length > 0) {
-          const idsToStrip = itemsToStrip.map((item) => item._id);
-          const result = await collection.updateMany(
-            { _id: { $in: idsToStrip } },
-            {
-              $set: { _stripped: true },
-              $unset: {
-                name: "",
-                content: "",
-                summary: "",
-                author: "",
-                category: "",
-                photo: "",
-                video: "",
-                audio: "",
-                likeOf: "",
-                repostOf: "",
-                bookmarkOf: "",
-                inReplyTo: "",
-                source: "",
+        if (itemsToCleanup.length > 0) {
+          const apItemIds = [];
+          const rssItemIds = [];
+          for (const item of itemsToCleanup) {
+            if (item.feedId) {
+              rssItemIds.push(item._id);
+            } else {
+              apItemIds.push(item._id);
+            }
+          }
+
+          // Hard-delete AP items
+          if (apItemIds.length > 0) {
+            const deleted = await collection.deleteMany({
+              _id: { $in: apItemIds },
+            });
+            totalCleaned += deleted.deletedCount;
+            console.info(
+              `[Microsub] Startup cleanup: deleted ${deleted.deletedCount} AP items from channel "${channel.name}"`,
+            );
+          }
+
+          // Strip RSS items to skeletons
+          if (rssItemIds.length > 0) {
+            const stripped = await collection.updateMany(
+              { _id: { $in: rssItemIds } },
+              {
+                $set: { _stripped: true },
+                $unset: {
+                  name: "",
+                  content: "",
+                  summary: "",
+                  author: "",
+                  category: "",
+                  photo: "",
+                  video: "",
+                  audio: "",
+                  likeOf: "",
+                  repostOf: "",
+                  bookmarkOf: "",
+                  inReplyTo: "",
+                  source: "",
+                },
               },
-            },
-          );
-          totalStripped += result.modifiedCount;
-          console.info(
-            `[Microsub] Startup cleanup: stripped ${result.modifiedCount} old items from channel "${channel.name}"`,
-          );
+            );
+            totalCleaned += stripped.modifiedCount;
+            console.info(
+              `[Microsub] Startup cleanup: stripped ${stripped.modifiedCount} RSS items from channel "${channel.name}"`,
+            );
+          }
         }
       }
     }
   }
 
-  if (totalStripped > 0) {
+  if (totalCleaned > 0) {
     console.info(
-      `[Microsub] Startup cleanup complete: ${totalStripped} total items stripped`,
+      `[Microsub] Startup cleanup complete: ${totalCleaned} total items cleaned`,
     );
   }
 
-  return totalStripped;
+  return totalCleaned;
 }
 
 export async function markItemsRead(application, channelId, entryIds, userId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-microsub",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Microsub endpoint for Indiekit. Enables subscribing to feeds and reading content using the Microsub protocol.",
   "keywords": [
     "indiekit",

package/views/actor.njk

@@ -0,0 +1,179 @@
+{% extends "layouts/reader.njk" %}
+
+{% block reader %}
+  <div class="channel">
+    <header class="channel__header">
+      <a href="{{ baseUrl }}/channels/activitypub" class="back-link">
+        {{ icon("previous") }} Fediverse
+      </a>
+    </header>
+
+    {# Actor profile card #}
+    <div class="actor-profile">
+      <div class="actor-profile__header">
+        {% if actor.photo %}
+        <img src="{{ actor.photo }}"
+             alt=""
+             class="actor-profile__avatar"
+             width="80"
+             height="80"
+             onerror="this.style.display='none'">
+        {% endif %}
+        <div class="actor-profile__info">
+          <h2 class="actor-profile__name">{{ actor.name }}</h2>
+          {% if actor.handle %}
+          <span class="actor-profile__handle">@{{ actor.handle }}</span>
+          {% endif %}
+          {% if actor.summary %}
+          <p class="actor-profile__summary">{{ actor.summary }}</p>
+          {% endif %}
+          <div class="actor-profile__stats">
+            {% if actor.followersCount %}
+            <span>{{ actor.followersCount }} followers</span>
+            {% endif %}
+            {% if actor.followingCount %}
+            <span>{{ actor.followingCount }} following</span>
+            {% endif %}
+          </div>
+        </div>
+      </div>
+      <div class="actor-profile__actions">
+        <a href="{{ actor.url }}" class="button button--secondary button--small" target="_blank" rel="noopener">
+          {{ icon("external") }} View profile
+        </a>
+        {% if canFollow %}
+          {% if isFollowing %}
+          <form action="{{ baseUrl }}/actor/unfollow" method="POST" style="display: inline;">
+            <input type="hidden" name="actorUrl" value="{{ actorUrl }}">
+            <button type="submit" class="button button--secondary button--small">
+              {{ icon("checkboxChecked") }} Following
+            </button>
+          </form>
+          {% else %}
+          <form action="{{ baseUrl }}/actor/follow" method="POST" style="display: inline;">
+            <input type="hidden" name="actorUrl" value="{{ actorUrl }}">
+            <input type="hidden" name="actorName" value="{{ actor.name }}">
+            <button type="submit" class="button button--primary button--small">
+              {{ icon("syndicate") }} Follow
+            </button>
+          </form>
+          {% endif %}
+        {% endif %}
+      </div>
+    </div>
+
+    {% if error %}
+    <div class="reader__empty">
+      {{ icon("warning") }}
+      <p>{{ error }}</p>
+    </div>
+    {% elif items.length > 0 %}
+    <div class="timeline" id="timeline">
+      {% for item in items %}
+      <article class="item-card">
+        {# Author #}
+        {% if item.author %}
+        <div class="item-card__author" style="padding: 12px 16px 0;">
+          {% if item.author.photo %}
+          <img src="{{ item.author.photo }}"
+               alt=""
+               class="item-card__author-photo"
+               width="40"
+               height="40"
+               loading="lazy"
+               onerror="this.style.display='none'">
+          {% endif %}
+          <div class="item-card__author-info">
+            <span class="item-card__author-name">{{ item.author.name or "Unknown" }}</span>
+            {% if item.author.url %}
+            <span class="item-card__source">{{ item.author.url | replace("https://", "") | replace("http://", "") }}</span>
+            {% endif %}
+          </div>
+        </div>
+        {% endif %}
+
+        <a href="{{ item.url }}" class="item-card__link" target="_blank" rel="noopener">
+          {# Reply context #}
+          {% if item["in-reply-to"] and item["in-reply-to"].length > 0 %}
+          <div class="item-card__context">
+            {{ icon("reply") }}
+            <span>Reply to</span>
+            <span>{{ item["in-reply-to"][0] | replace("https://", "") | replace("http://", "") | truncate(50) }}</span>
+          </div>
+          {% endif %}
+
+          {# Title #}
+          {% if item.name %}
+          <h3 class="item-card__title">{{ item.name }}</h3>
+          {% endif %}
+
+          {# Content #}
+          {% if item.content %}
+          <div class="item-card__content{% if (item.content.text or '') | length > 300 %} item-card__content--truncated{% endif %}">
+            {% if item.content.html %}
+            {{ item.content.html | safe | striptags | truncate(400) }}
+            {% elif item.content.text %}
+            {{ item.content.text | truncate(400) }}
+            {% endif %}
+          </div>
+          {% endif %}
+
+          {# Tags #}
+          {% if item.category and item.category.length > 0 %}
+          <div class="item-card__categories">
+            {% for cat in item.category | slice(0, 5) %}
+            <span class="item-card__category">#{{ cat }}</span>
+            {% endfor %}
+          </div>
+          {% endif %}
+
+          {# Photos #}
+          {% if item.photo and item.photo.length > 0 %}
+          {% set photoCount = item.photo.length if item.photo.length <= 4 else 4 %}
+          <div class="item-card__photos item-card__photos--{{ photoCount }}">
+            {% for photo in item.photo | slice(0, 4) %}
+            <img src="{{ photo }}" alt="" class="item-card__photo" loading="lazy"
+                 onerror="this.parentElement.removeChild(this)">
+            {% endfor %}
+          </div>
+          {% endif %}
+
+          {# Footer #}
+          <footer class="item-card__footer">
+            {% if item.published %}
+            <time datetime="{{ item.published }}" class="item-card__date">
+              {{ item.published | date("PP", { locale: locale, timeZone: application.timeZone }) }}
+            </time>
+            {% endif %}
+          </footer>
+        </a>
+
+        {# Actions #}
+        <div class="item-actions">
+          <a href="{{ item.url }}" class="item-actions__button" target="_blank" rel="noopener" title="View original">
+            {{ icon("external") }}
+          </a>
+          <a href="{{ baseUrl }}/compose?reply={{ item.url | urlencode }}" class="item-actions__button" title="Reply">
+            {{ icon("reply") }}
+          </a>
+          <a href="{{ baseUrl }}/compose?like={{ item.url | urlencode }}" class="item-actions__button" title="Like">
+            {{ icon("like") }}
+          </a>
+          <a href="{{ baseUrl }}/compose?repost={{ item.url | urlencode }}" class="item-actions__button" title="Repost">
+            {{ icon("repost") }}
+          </a>
+          <a href="{{ baseUrl }}/compose?bookmark={{ item.url | urlencode }}" class="item-actions__button" title="Bookmark">
+            {{ icon("bookmark") }}
+          </a>
+        </div>
+      </article>
+      {% endfor %}
+    </div>
+    {% else %}
+    <div class="reader__empty">
+      {{ icon("syndicate") }}
+      <p>No posts found for this actor.</p>
+    </div>
+    {% endif %}
+  </div>
+{% endblock %}

package/views/partials/item-card.njk

@@ -64,7 +64,25 @@
       <div class="item-card__author-info">
         <span class="item-card__author-name">{{ item.author.name or "Unknown" }}</span>
         {% if item._source %}
-        <span class="item-card__source">{{ item._source.name or item._source.url }}</span>
+        <span class="item-card__source">
+          {# Protocol source indicator #}
+          {% set sourceUrl = item._source.url or item.author.url or "" %}
+          {% set sourceType = item._source.source_type or item._source.type %}
+          {% if sourceType == "activitypub" or sourceType == "mastodon" or ("mastodon." in sourceUrl) or ("mstdn." in sourceUrl) or ("fosstodon." in sourceUrl) or ("pleroma." in sourceUrl) or ("misskey." in sourceUrl) %}
+          <svg class="item-card__source-icon" viewBox="0 0 24 24" fill="#6364ff" aria-label="Fediverse" style="width:12px;height:12px;vertical-align:middle;margin-right:3px;display:inline-block">
+            <path d="M23.268 5.313c-.35-2.578-2.617-4.61-5.304-5.004C17.51.242 15.792 0 11.813 0h-.03c-3.98 0-4.835.242-5.288.309C3.882.692 1.496 2.518.917 5.127.64 6.412.61 7.837.661 9.143c.074 1.874.088 3.745.26 5.611.118 1.24.325 2.47.62 3.68.55 2.237 2.777 4.098 4.96 4.857 2.336.792 4.849.923 7.256.38.265-.061.527-.132.786-.213.585-.184 1.27-.39 1.774-.753a.057.057 0 0 0 .023-.043v-1.809a.052.052 0 0 0-.02-.041.053.053 0 0 0-.046-.01 20.282 20.282 0 0 1-4.709.545c-2.73 0-3.463-1.284-3.674-1.818a5.593 5.593 0 0 1-.319-1.433.053.053 0 0 1 .066-.054c1.517.363 3.072.546 4.632.546.376 0 .75 0 1.125-.01 1.57-.044 3.224-.124 4.768-.422.038-.008.077-.015.11-.024 2.435-.464 4.753-1.92 4.989-5.604.008-.145.03-1.52.03-1.67.002-.512.167-3.63-.024-5.545zm-3.748 9.195h-2.561V8.29c0-1.309-.55-1.976-1.67-1.976-1.23 0-1.846.79-1.846 2.35v3.403h-2.546V8.663c0-1.56-.617-2.35-1.848-2.35-1.112 0-1.668.668-1.668 1.977v6.218H4.822V8.102c0-1.31.337-2.35 1.011-3.12.696-.77 1.608-1.164 2.74-1.164 1.311 0 2.302.5 2.962 1.498l.638 1.06.638-1.06c.66-.999 1.65-1.498 2.96-1.498 1.13 0 2.043.395 2.74 1.164.675.77 1.012 1.81 1.012 3.12z"/>
+          </svg>
+          {% elif sourceType == "bluesky" or ("bsky.app" in sourceUrl) or ("bluesky" in sourceUrl) %}
+          <svg class="item-card__source-icon" viewBox="0 0 568 501" fill="#0085ff" aria-label="ATmosphere" style="width:12px;height:12px;vertical-align:middle;margin-right:3px;display:inline-block">
+            <path d="M123.121 33.664C188.241 82.553 258.281 181.68 284 234.873c25.719-53.192 95.759-152.32 160.879-201.21C491.866-1.611 568-28.906 568 57.947c0 17.346-9.945 145.713-15.778 166.555-20.275 72.453-94.155 90.933-159.875 79.748C507.222 323.8 536.444 388.56 473.333 453.32c-119.86 122.992-172.272-30.859-185.702-70.281-2.462-7.227-3.614-10.608-3.631-7.733-.017-2.875-1.169.506-3.631 7.733-13.43 39.422-65.842 193.273-185.702 70.281-63.111-64.76-33.89-129.52 80.986-149.071-65.72 11.185-139.6-7.295-159.875-79.748C9.945 203.659 0 75.291 0 57.946 0-28.906 76.135-1.612 123.121 33.664Z"/>
+          </svg>
+          {% else %}
+          <svg class="item-card__source-icon" viewBox="0 0 24 24" fill="none" stroke="#888" stroke-width="2" aria-label="Web" style="width:12px;height:12px;vertical-align:middle;margin-right:3px;display:inline-block">
+            <circle cx="12" cy="12" r="10"/><line x1="2" y1="12" x2="22" y2="12"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/>
+          </svg>
+          {% endif %}
+          {{ item._source.name or item._source.url }}
+        </span>
         {% elif item.author.url %}
         <span class="item-card__source">{{ item.author.url | replace("https://", "") | replace("http://", "") }}</span>
         {% endif %}
@@ -147,6 +165,12 @@
 
   {# Inline actions (Aperture pattern) #}
   <div class="item-actions">
+    {% if item._source and item._source.type === "activitypub" and item.author and item.author.url %}
+    <a href="{{ baseUrl }}/actor?url={{ item.author.url | urlencode }}" class="item-actions__button" title="View actor profile">
+      {{ icon("mention") }}
+      <span class="visually-hidden">Actor profile</span>
+    </a>
+    {% endif %}
     {% if item.url %}
     <a href="{{ item.url }}" class="item-actions__button" target="_blank" rel="noopener" title="View original">
       {{ icon("external") }}