@rmdes/indiekit-endpoint-microsub 1.0.61 → 1.0.64

package/views/partials/item-card.njk

@@ -153,12 +153,6 @@
 
   {# Inline actions (Aperture pattern) #}
   <div class="ms-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="ms-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="ms-item-actions__button" target="_blank" rel="noopener" title="View original">
       {{ icon("syndicate") }}

package/views/settings.njk

@@ -49,6 +49,43 @@
         value: channel.settings.excludeRegex
       }) }}
 
+      {% if channel.uid !== "notifications" %}
+      <fieldset class="ms-retention-settings">
+        <legend>{{ __("microsub.settings.retentionTitle") }}</legend>
+        <p class="hint">{{ __("microsub.settings.retentionHelp") }}</p>
+
+        {{ input({
+          id: "maxItems",
+          name: "maxItems",
+          type: "number",
+          label: __("microsub.settings.maxItems"),
+          hint: __("microsub.settings.maxItemsHelp", { default: retentionDefaults.maxItems }),
+          attributes: { min: 10, max: 100000, placeholder: retentionDefaults.maxItems },
+          value: channel.settings.maxItems
+        }) }}
+
+        {{ input({
+          id: "maxItemsPerFeed",
+          name: "maxItemsPerFeed",
+          type: "number",
+          label: __("microsub.settings.maxItemsPerFeed"),
+          hint: __("microsub.settings.maxItemsPerFeedHelp", { default: retentionDefaults.maxItemsPerFeed }),
+          attributes: { min: 1, max: 10000, placeholder: retentionDefaults.maxItemsPerFeed },
+          value: channel.settings.maxItemsPerFeed
+        }) }}
+
+        {{ input({
+          id: "maxUnreadAgeDays",
+          name: "maxUnreadAgeDays",
+          type: "number",
+          label: __("microsub.settings.maxUnreadAgeDays"),
+          hint: __("microsub.settings.maxUnreadAgeDaysHelp", { default: retentionDefaults.maxUnreadAgeDays }),
+          attributes: { min: 1, max: 3650, placeholder: retentionDefaults.maxUnreadAgeDays },
+          value: channel.settings.maxUnreadAgeDays
+        }) }}
+      </fieldset>
+      {% endif %}
+
       <div class="button-group">
         {{ button({
           text: __("microsub.settings.save")

package/lib/activitypub/outbox-fetcher.js

@@ -1,267 +0,0 @@
-/**
- * Fetch a remote ActivityPub actor's outbox for on-demand reading.
- * Returns ephemeral jf2 items — nothing is stored in MongoDB.
- *
- * @module activitypub/outbox-fetcher
- */
-
-import sanitizeHtml from "sanitize-html";
-
-import { isPrivateUrl } from "../media/proxy.js";
-import { SANITIZE_OPTIONS } from "../utils/sanitize.js";
-
-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 rawHtml = object.content || "";
-  const contentHtml = rawHtml ? sanitizeHtml(rawHtml, SANITIZE_OPTIONS) : "";
-  const contentText = stripHtml(rawHtml);
-
-  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;
-
-  // SSRF protection — block private/internal IPs (including DNS rebinding)
-  if (await isPrivateUrl(url)) {
-    console.warn(`[Microsub] AP fetch blocked private URL: ${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/reader/actor.js

@@ -1,142 +0,0 @@
-/**
- * ActivityPub actor profiles
- * @module controllers/reader/actor
- */
-
-import { fetchActorOutbox } from "../../activitypub/outbox-fetcher.js";
-
-const ACTOR_OUTBOX_LIMIT = 30;
-
-/**
- * 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",
-  );
-}
-
-/**
- * Actor profile — fetch and display a remote AP actor's recent posts
- * @param {object} request - Express request
- * @param {object} response - Express response
- */
-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: ACTOR_OUTBOX_LIMIT });
-
-    response.render("actor", {
-      title: actor.name || "Actor",
-      actor,
-      items,
-      actorUrl,
-      isFollowing,
-      canFollow,
-      baseUrl: request.baseUrl,
-      readerBaseUrl: request.baseUrl,
-      activeView: "channels",
-      breadcrumbs: [
-        { text: "Reader", href: request.baseUrl },
-        { text: actor.name || "Actor" },
-      ],
-    });
-  } 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,
-      readerBaseUrl: request.baseUrl,
-      activeView: "channels",
-      error: "Could not fetch this actor's profile. They may have restricted access.",
-      breadcrumbs: [
-        { text: "Reader", href: request.baseUrl },
-        { text: "Actor" },
-      ],
-    });
-  }
-}
-
-/**
- * Follow an ActivityPub actor
- * @param {object} request - Express request
- * @param {object} response - Express response
- */
-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)}`,
-  );
-}
-
-/**
- * Unfollow an ActivityPub actor
- * @param {object} request - Express request
- * @param {object} response - Express response
- */
-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)}`,
-  );
-}

package/lib/search/indexer.js

@@ -1,90 +0,0 @@
-/**
- * Search indexer for MongoDB text search
- * @module search/indexer
- */
-
-/**
- * Create text indexes for microsub items
- * @param {object} application - Indiekit application
- * @returns {Promise<void>}
- */
-export async function createSearchIndexes(application) {
-  const itemsCollection = application.collections.get("microsub_items");
-
-  // Create compound text index for full-text search
-  await itemsCollection.createIndex(
-    {
-      name: "text",
-      "content.text": "text",
-      "content.html": "text",
-      summary: "text",
-      "author.name": "text",
-    },
-    {
-      name: "text_search",
-      weights: {
-        name: 10,
-        "content.text": 5,
-        summary: 3,
-        "author.name": 2,
-      },
-      default_language: "english",
-      background: true,
-    },
-  );
-
-  // Create index for channel + published for efficient timeline queries
-  await itemsCollection.createIndex(
-    { channelId: 1, published: -1 },
-    { name: "channel_timeline" },
-  );
-
-  // Create index for deduplication
-  await itemsCollection.createIndex(
-    { channelId: 1, uid: 1 },
-    { name: "channel_uid", unique: true },
-  );
-
-  // Create index for feed-based queries
-  await itemsCollection.createIndex({ feedId: 1 }, { name: "feed_items" });
-}
-
-/**
- * Rebuild search indexes (drops and recreates)
- * @param {object} application - Indiekit application
- * @returns {Promise<void>}
- */
-export async function rebuildSearchIndexes(application) {
-  const itemsCollection = application.collections.get("microsub_items");
-
-  // Drop existing text index
-  try {
-    await itemsCollection.dropIndex("text_search");
-  } catch {
-    // Index may not exist
-  }
-
-  // Recreate indexes
-  await createSearchIndexes(application);
-}
-
-/**
- * Get search index stats
- * @param {object} application - Indiekit application
- * @returns {Promise<object>} Index statistics
- */
-export async function getSearchIndexStats(application) {
-  const itemsCollection = application.collections.get("microsub_items");
-
-  const indexes = await itemsCollection.indexes();
-  const stats = await itemsCollection.stats();
-
-  return {
-    indexes: indexes.map((index) => ({
-      name: index.name,
-      key: index.key,
-    })),
-    totalDocuments: stats.count,
-    size: stats.size,
-  };
-}

package/lib/storage/items-search.js

@@ -1,34 +0,0 @@
-/**
- * Timeline item search
- * @module storage/items-search
- */
-
-import { ObjectId } from "mongodb";
-
-import { getCollection, transformToJf2 } from "./items.js";
-
-/**
- * Search items by text
- * @param {object} application - Indiekit application
- * @param {ObjectId|string} channelId - Channel ObjectId
- * @param {string} query - Search query
- * @param {number} [limit] - Max results
- * @returns {Promise<Array>} Array of matching items
- */
-export async function searchItems(application, channelId, query, limit = 20) {
-  const collection = getCollection(application);
-  const objectId =
-    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
-
-  // Use MongoDB text index for efficient full-text search
-  const items = await collection
-    .find({
-      channelId: objectId,
-      $text: { $search: query },
-    })
-    .sort({ score: { $meta: "textScore" } })
-    .limit(limit)
-    .toArray();
-
-  return items.map((item) => transformToJf2(item));
-}