@rmdes/indiekit-endpoint-microsub 1.0.0 → 1.0.2

package/index.js

@@ -83,10 +83,7 @@ export default class MicrosubEndpoint {
       "/channels/:uid/settings",
       readerController.updateSettings,
     );
-    readerRouter.post(
-      "/channels/:uid/delete",
-      readerController.deleteChannel,
-    );
+    readerRouter.post("/channels/:uid/delete", readerController.deleteChannel);
     readerRouter.get("/channels/:uid/feeds", readerController.feeds);
     readerRouter.post("/channels/:uid/feeds", readerController.addFeed);
     readerRouter.post(

package/lib/controllers/follow.js

@@ -13,8 +13,8 @@ import {
   getFeedByUrl,
   getFeedsForChannel,
 } from "../storage/feeds.js";
-import { createFeedResponse } from "../utils/jf2.js";
 import { getUserId } from "../utils/auth.js";
+import { createFeedResponse } from "../utils/jf2.js";
 import { validateChannel, validateUrl } from "../utils/validation.js";
 import {
   unsubscribe as websubUnsubscribe,

package/lib/controllers/reader.js

@@ -392,10 +392,16 @@ export async function submitCompose(request, response) {
       body: micropubData.toString(),
     });
 
-    if (micropubResponse.ok || micropubResponse.status === 201 || micropubResponse.status === 202) {
+    if (
+      micropubResponse.ok ||
+      micropubResponse.status === 201 ||
+      micropubResponse.status === 202
+    ) {
       // Success - get the Location header for the new post URL
       const location = micropubResponse.headers.get("Location");
-      console.info(`[Microsub] Created post via Micropub: ${location || "success"}`);
+      console.info(
+        `[Microsub] Created post via Micropub: ${location || "success"}`,
+      );
 
       // Redirect back to reader with success message
       return response.redirect(`${request.baseUrl}/channels`);
@@ -403,7 +409,9 @@ export async function submitCompose(request, response) {
 
     // Handle error
     const errorBody = await micropubResponse.text();
-    console.error(`[Microsub] Micropub error: ${micropubResponse.status} ${errorBody}`);
+    console.error(
+      `[Microsub] Micropub error: ${micropubResponse.status} ${errorBody}`,
+    );
 
     return response.status(micropubResponse.status).render("error", {
       title: "Error",

package/lib/feeds/fetcher.js

@@ -150,7 +150,7 @@ function extractSelfFromLinkHeader(linkHeader) {
  * @returns {Promise<object>} Parsed feed
  */
 export async function fetchAndParseFeed(url, options = {}) {
-  const { parseFeed } = await import("./parser.js");
+  const { parseFeed, detectFeedType } = await import("./parser.js");
 
   const result = await fetchFeed(url, options);
 
@@ -161,6 +161,32 @@ export async function fetchAndParseFeed(url, options = {}) {
     };
   }
 
+  // Check if we got a parseable feed
+  const feedType = detectFeedType(result.content, result.contentType);
+
+  // If we got ActivityPub or unknown, try common feed paths
+  if (feedType === "activitypub" || feedType === "unknown") {
+    const fallbackFeed = await tryCommonFeedPaths(url, options);
+    if (fallbackFeed) {
+      // Fetch and parse the discovered feed
+      const feedResult = await fetchFeed(fallbackFeed.url, options);
+      if (!feedResult.notModified) {
+        const parsed = await parseFeed(feedResult.content, fallbackFeed.url, {
+          contentType: feedResult.contentType,
+        });
+        return {
+          ...feedResult,
+          ...parsed,
+          hub: feedResult.hub || parsed._hub,
+          discoveredFrom: url,
+        };
+      }
+    }
+    throw new Error(
+      `Unable to find a feed at ${url}. Try the direct feed URL.`,
+    );
+  }
+
   const parsed = await parseFeed(result.content, url, {
     contentType: result.contentType,
   });
@@ -172,6 +198,48 @@ export async function fetchAndParseFeed(url, options = {}) {
   };
 }
 
+/**
+ * Common feed paths to try when discovery fails
+ */
+const COMMON_FEED_PATHS = ["/feed/", "/feed", "/rss", "/rss.xml", "/atom.xml"];
+
+/**
+ * Try to fetch a feed from common paths
+ * @param {string} baseUrl - Base URL of the site
+ * @param {object} options - Fetch options
+ * @returns {Promise<object|undefined>} Feed result or undefined
+ */
+async function tryCommonFeedPaths(baseUrl, options = {}) {
+  const base = new URL(baseUrl);
+
+  for (const feedPath of COMMON_FEED_PATHS) {
+    const feedUrl = new URL(feedPath, base).href;
+    try {
+      const result = await fetchFeed(feedUrl, { ...options, timeout: 10_000 });
+      const contentType = result.contentType?.toLowerCase() || "";
+
+      // Check if we got a feed
+      if (
+        contentType.includes("xml") ||
+        contentType.includes("rss") ||
+        contentType.includes("atom") ||
+        (contentType.includes("json") &&
+          result.content?.includes("jsonfeed.org"))
+      ) {
+        return {
+          url: feedUrl,
+          type: contentType.includes("json") ? "jsonfeed" : "xml",
+          rel: "alternate",
+        };
+      }
+    } catch {
+      // Try next path
+    }
+  }
+
+  return;
+}
+
 /**
  * Discover feeds from a URL
  * @param {string} url - Page URL
@@ -187,19 +255,62 @@ export async function discoverFeedsFromUrl(url, options = {}) {
   if (
     contentType.includes("xml") ||
     contentType.includes("rss") ||
-    contentType.includes("atom") ||
-    contentType.includes("json")
+    contentType.includes("atom")
   ) {
     return [
       {
         url,
-        type: contentType.includes("json") ? "jsonfeed" : "xml",
+        type: "xml",
         rel: "self",
       },
     ];
   }
 
-  // Otherwise, discover feeds from HTML
-  const feeds = await discoverFeeds(result.content, url);
-  return feeds;
+  // Check for JSON Feed specifically
+  if (
+    contentType.includes("json") &&
+    result.content?.includes("jsonfeed.org")
+  ) {
+    return [
+      {
+        url,
+        type: "jsonfeed",
+        rel: "self",
+      },
+    ];
+  }
+
+  // Check if we got ActivityPub JSON or other non-feed JSON
+  // This happens with WordPress sites using ActivityPub plugin
+  if (
+    contentType.includes("json") ||
+    (result.content?.trim().startsWith("{") &&
+      result.content?.includes("@context"))
+  ) {
+    // Try common feed paths as fallback
+    const fallbackFeed = await tryCommonFeedPaths(url, options);
+    if (fallbackFeed) {
+      return [fallbackFeed];
+    }
+  }
+
+  // If content looks like HTML, discover feeds from it
+  if (
+    contentType.includes("html") ||
+    result.content?.includes("<!DOCTYPE html") ||
+    result.content?.includes("<html")
+  ) {
+    const feeds = await discoverFeeds(result.content, url);
+    if (feeds.length > 0) {
+      return feeds;
+    }
+  }
+
+  // Last resort: try common feed paths
+  const fallbackFeed = await tryCommonFeedPaths(url, options);
+  if (fallbackFeed) {
+    return [fallbackFeed];
+  }
+
+  return [];
 }

package/lib/feeds/normalizer.js

@@ -7,6 +7,66 @@ import crypto from "node:crypto";
 
 import sanitizeHtml from "sanitize-html";
 
+/**
+ * Parse a date string with fallback for non-standard formats
+ * @param {string|Date} dateInput - Date string or Date object
+ * @returns {Date|undefined} Parsed Date or undefined if invalid
+ */
+function parseDate(dateInput) {
+  if (!dateInput) {
+    return;
+  }
+
+  // Already a valid Date
+  if (dateInput instanceof Date && !Number.isNaN(dateInput.getTime())) {
+    return dateInput;
+  }
+
+  const dateString = String(dateInput).trim();
+
+  // Try standard parsing first
+  let date = new Date(dateString);
+  if (!Number.isNaN(date.getTime())) {
+    return date;
+  }
+
+  // Handle "YYYY-MM-DD HH:MM" format (missing seconds and timezone)
+  // e.g., "2026-01-28 08:40"
+  const shortDateTime = dateString.match(
+    /^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})$/,
+  );
+  if (shortDateTime) {
+    date = new Date(`${shortDateTime[1]}T${shortDateTime[2]}:00Z`);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+
+  // Handle "YYYY-MM-DD HH:MM:SS" without timezone
+  const dateTimeNoTz = dateString.match(
+    /^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})$/,
+  );
+  if (dateTimeNoTz) {
+    date = new Date(`${dateTimeNoTz[1]}T${dateTimeNoTz[2]}Z`);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+
+  // If all else fails, return undefined
+  return;
+}
+
+/**
+ * Safely convert date to ISO string
+ * @param {string|Date} dateInput - Date input
+ * @returns {string|undefined} ISO string or undefined
+ */
+function toISOStringSafe(dateInput) {
+  const date = parseDate(dateInput);
+  return date ? date.toISOString() : undefined;
+}
+
 /**
  * Sanitize HTML options
  */
@@ -91,9 +151,10 @@ export function normalizeItem(item, feedUrl, feedType) {
     uid,
     url,
     name: item.title || undefined,
-    published: item.pubdate ? new Date(item.pubdate).toISOString() : undefined,
-    updated: item.date ? new Date(item.date).toISOString() : undefined,
+    published: toISOStringSafe(item.pubdate),
+    updated: toISOStringSafe(item.date),
     _source: {
+      url: feedUrl,
       feedUrl,
       feedType,
       originalId: item.guid,
@@ -250,6 +311,7 @@ export function normalizeJsonFeedItem(item, feedUrl) {
       ? new Date(item.date_modified).toISOString()
       : undefined,
     _source: {
+      url: feedUrl,
       feedUrl,
       feedType: "jsonfeed",
       originalId: item.id,
@@ -391,6 +453,7 @@ export function normalizeHfeedItem(entry, feedUrl) {
     uid,
     url,
     _source: {
+      url: feedUrl,
       feedUrl,
       feedType: "hfeed",
       originalId: getFirst(properties.uid),
@@ -536,6 +599,24 @@ export function normalizeHfeedMeta(hfeed, feedUrl) {
   return normalized;
 }
 
+/**
+ * Extract URL string from a photo value
+ * @param {object|string} photo - Photo value (can be string URL or object with value/url)
+ * @returns {string|undefined} Photo URL string
+ */
+function extractPhotoUrl(photo) {
+  if (!photo) {
+    return;
+  }
+  if (typeof photo === "string") {
+    return photo;
+  }
+  if (typeof photo === "object") {
+    return photo.value || photo.url || photo.src;
+  }
+  return;
+}
+
 /**
  * Normalize h-card author
  * @param {object|string} hcard - h-card or author name string
@@ -556,7 +637,7 @@ function normalizeHcard(hcard) {
     type: "card",
     name: getFirst(properties.name),
     url: getFirst(properties.url),
-    photo: getFirst(properties.photo),
+    photo: extractPhotoUrl(getFirst(properties.photo)),
   };
 }
 

package/lib/feeds/parser.js

@@ -51,13 +51,18 @@ export function detectFeedType(content, contentType = "") {
   // Fall back to content inspection
   const trimmed = content.trim();
 
-  // JSON Feed
+  // JSON content
   if (trimmed.startsWith("{")) {
     try {
       const json = JSON.parse(trimmed);
+      // JSON Feed
       if (json.version && json.version.includes("jsonfeed.org")) {
         return "jsonfeed";
       }
+      // ActivityPub - return special type to indicate we need feed discovery
+      if (json["@context"] || json.type === "Group" || json.inbox) {
+        return "activitypub";
+      }
     } catch {
       // Not JSON
     }
@@ -112,6 +117,12 @@ export async function parseFeed(content, feedUrl, options = {}) {
       return parseHfeed(content, feedUrl);
     }
 
+    case "activitypub": {
+      throw new Error(
+        `URL returns ActivityPub JSON instead of a feed. Try the direct feed URL (e.g., ${feedUrl}feed/)`,
+      );
+    }
+
     default: {
       throw new Error(`Unable to detect feed type for ${feedUrl}`);
     }

package/lib/media/proxy.js

@@ -9,13 +9,13 @@ import { getCache, setCache } from "../cache/redis.js";
 
 const MAX_SIZE = 2 * 1024 * 1024; // 2MB max image size
 const CACHE_TTL = 4 * 60 * 60; // 4 hours
-const ALLOWED_TYPES = [
+const ALLOWED_TYPES = new Set([
   "image/jpeg",
   "image/png",
   "image/gif",
   "image/webp",
   "image/svg+xml",
-];
+]);
 
 /**
  * Generate a hash for a URL to use as cache key
@@ -120,15 +120,19 @@ export async function fetchImage(redis, url) {
     });
 
     if (!response.ok) {
-      console.error(`[Microsub] Media proxy fetch failed: ${response.status} for ${url}`);
-      return null;
+      console.error(
+        `[Microsub] Media proxy fetch failed: ${response.status} for ${url}`,
+      );
+      return;
     }
 
     // Check content type
     const contentType = response.headers.get("content-type")?.split(";")[0];
-    if (!ALLOWED_TYPES.includes(contentType)) {
-      console.error(`[Microsub] Media proxy rejected type: ${contentType} for ${url}`);
-      return null;
+    if (!ALLOWED_TYPES.has(contentType)) {
+      console.error(
+        `[Microsub] Media proxy rejected type: ${contentType} for ${url}`,
+      );
+      return;
     }
 
     // Check content length
@@ -137,14 +141,16 @@ export async function fetchImage(redis, url) {
       10,
     );
     if (contentLength > MAX_SIZE) {
-      console.error(`[Microsub] Media proxy rejected size: ${contentLength} for ${url}`);
-      return null;
+      console.error(
+        `[Microsub] Media proxy rejected size: ${contentLength} for ${url}`,
+      );
+      return;
     }
 
     // Read the body
     const buffer = await response.arrayBuffer();
     if (buffer.byteLength > MAX_SIZE) {
-      return null;
+      return;
     }
 
     const imageData = {
@@ -161,7 +167,7 @@ export async function fetchImage(redis, url) {
     return imageData;
   } catch (error) {
     console.error(`[Microsub] Media proxy error: ${error.message} for ${url}`);
-    return null;
+    return;
   }
 }
 

package/lib/polling/processor.js

@@ -73,6 +73,11 @@ export async function processFeed(application, feed) {
         continue;
       }
 
+      // Enrich item source with feed metadata
+      if (item._source) {
+        item._source.name = feed.title || parsed.name;
+      }
+
       // Store the item
       const stored = await addItem(application, {
         channelId: feed.channelId,

package/lib/storage/channels.js

@@ -5,9 +5,10 @@
 
 import { ObjectId } from "mongodb";
 
+import { generateChannelUid } from "../utils/jf2.js";
+
 import { deleteFeedsForChannel } from "./feeds.js";
 import { deleteItemsForChannel } from "./items.js";
-import { generateChannelUid } from "../utils/jf2.js";
 
 /**
  * Get channels collection from application

package/lib/storage/items.js

@@ -121,6 +121,50 @@ export async function getTimelineItems(application, channelId, options = {}) {
   };
 }
 
+/**
+ * Extract URL string from a media value
+ * @param {object|string} media - Media value (can be string URL or object)
+ * @returns {string|undefined} URL string
+ */
+function extractMediaUrl(media) {
+  if (!media) {
+    return;
+  }
+  if (typeof media === "string") {
+    return media;
+  }
+  if (typeof media === "object") {
+    return media.value || media.url || media.src;
+  }
+}
+
+/**
+ * Normalize media array to URL strings
+ * @param {Array} mediaArray - Array of media items
+ * @returns {Array} Array of URL strings
+ */
+function normalizeMediaArray(mediaArray) {
+  if (!mediaArray || !Array.isArray(mediaArray)) {
+    return [];
+  }
+  return mediaArray.map((media) => extractMediaUrl(media)).filter(Boolean);
+}
+
+/**
+ * Normalize author object to ensure photo is a URL string
+ * @param {object} author - Author object
+ * @returns {object} Normalized author
+ */
+function normalizeAuthor(author) {
+  if (!author) {
+    return;
+  }
+  return {
+    ...author,
+    photo: extractMediaUrl(author.photo),
+  };
+}
+
 /**
  * Transform database item to jf2 format
  * @param {object} item - Database item
@@ -142,11 +186,17 @@ function transformToJf2(item, userId) {
   if (item.content) jf2.content = item.content;
   if (item.summary) jf2.summary = item.summary;
   if (item.updated) jf2.updated = item.updated.toISOString();
-  if (item.author) jf2.author = item.author;
+  if (item.author) jf2.author = normalizeAuthor(item.author);
   if (item.category?.length > 0) jf2.category = item.category;
-  if (item.photo?.length > 0) jf2.photo = item.photo;
-  if (item.video?.length > 0) jf2.video = item.video;
-  if (item.audio?.length > 0) jf2.audio = item.audio;
+
+  // Normalize media arrays to ensure they contain URL strings
+  const photos = normalizeMediaArray(item.photo);
+  const videos = normalizeMediaArray(item.video);
+  const audios = normalizeMediaArray(item.audio);
+
+  if (photos.length > 0) jf2.photo = photos;
+  if (videos.length > 0) jf2.video = videos;
+  if (audios.length > 0) jf2.audio = audios;
 
   // Interaction types
   if (item.likeOf?.length > 0) jf2["like-of"] = item.likeOf;
@@ -161,18 +211,33 @@ function transformToJf2(item, userId) {
 }
 
 /**
- * Get an item by ID
+ * Get an item by ID (MongoDB _id or uid)
  * @param {object} application - Indiekit application
- * @param {ObjectId|string} id - Item ObjectId
+ * @param {ObjectId|string} id - Item ObjectId or uid string
  * @param {string} [userId] - User ID for read state
- * @returns {Promise<object|null>} jf2 item or null
+ * @returns {Promise<object|undefined>} jf2 item or undefined
  */
 export async function getItemById(application, id, userId) {
   const collection = getCollection(application);
-  const objectId = typeof id === "string" ? new ObjectId(id) : id;
 
-  const item = await collection.findOne({ _id: objectId });
-  if (!item) return;
+  let item;
+
+  // Try MongoDB ObjectId first
+  try {
+    const objectId = typeof id === "string" ? new ObjectId(id) : id;
+    item = await collection.findOne({ _id: objectId });
+  } catch {
+    // Invalid ObjectId format, will try uid lookup
+  }
+
+  // If not found by _id, try uid
+  if (!item) {
+    item = await collection.findOne({ uid: id });
+  }
+
+  if (!item) {
+    return;
+  }
 
   return transformToJf2(item, userId);
 }
@@ -229,7 +294,7 @@ export async function markItemsRead(application, channelId, entryIds, userId) {
       try {
         return new ObjectId(id);
       } catch {
-        return undefined;
+        return;
       }
     })
     .filter(Boolean);
@@ -277,7 +342,7 @@ export async function markItemsUnread(
       try {
         return new ObjectId(id);
       } catch {
-        return undefined;
+        return;
       }
     })
     .filter(Boolean);
@@ -316,7 +381,7 @@ export async function removeItems(application, channelId, entryIds) {
       try {
         return new ObjectId(id);
       } catch {
-        return undefined;
+        return;
       }
     })
     .filter(Boolean);

package/lib/utils/auth.js

@@ -10,7 +10,6 @@
  * 1. request.session.userId (if explicitly set)
  * 2. request.session.me (from token introspection)
  * 3. application.publication.me (single-user fallback)
- *
  * @param {object} request - Express request
  * @returns {string|undefined} User ID
  */

package/lib/webmention/receiver.js

@@ -4,6 +4,7 @@
  */
 
 import { getUserId } from "../utils/auth.js";
+
 import { processWebmention } from "./processor.js";
 
 /**

package/package.json

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

package/views/404.njk

@@ -0,0 +1,17 @@
+{% extends "document.njk" %}
+
+{% block main %}
+<article class="main__container -!-container">
+  <header class="heading">
+    <h1 class="heading__title">
+      {{ __("microsub.error.notFound.title") | default("Not found") }}
+    </h1>
+  </header>
+  {{ prose({ text: __("microsub.error.notFound.description") | default("The item you're looking for could not be found.") }) }}
+  <p>
+    <a href="{{ baseUrl }}/channels" class="button button--secondary">
+      {{ __("microsub.reader.backToChannels") | default("Back to channels") }}
+    </a>
+  </p>
+</article>
+{% endblock %}

package/views/item.njk

@@ -50,19 +50,19 @@
     </div>
     {% endif %}
 
-    {% if item.inReplyTo or item.likeOf or item.repostOf or item.bookmarkOf %}
+    {% if item["in-reply-to"] or item["like-of"] or item["repost-of"] or item["bookmark-of"] %}
     <div class="item__context">
-      {% if item.inReplyTo %}
-      <p>{{ icon("reply") }} {{ __("Reply to") }}: <a href="{{ item.inReplyTo[0] }}">{{ item.inReplyTo[0] }}</a></p>
+      {% if item["in-reply-to"] %}
+      <p>{{ icon("reply") }} {{ __("Reply to") }}: <a href="{{ item["in-reply-to"][0] }}">{{ item["in-reply-to"][0] }}</a></p>
       {% endif %}
-      {% if item.likeOf %}
-      <p>{{ icon("like") }} {{ __("Liked") }}: <a href="{{ item.likeOf[0] }}">{{ item.likeOf[0] }}</a></p>
+      {% if item["like-of"] %}
+      <p>{{ icon("like") }} {{ __("Liked") }}: <a href="{{ item["like-of"][0] }}">{{ item["like-of"][0] }}</a></p>
       {% endif %}
-      {% if item.repostOf %}
-      <p>{{ icon("repost") }} {{ __("Reposted") }}: <a href="{{ item.repostOf[0] }}">{{ item.repostOf[0] }}</a></p>
+      {% if item["repost-of"] %}
+      <p>{{ icon("repost") }} {{ __("Reposted") }}: <a href="{{ item["repost-of"][0] }}">{{ item["repost-of"][0] }}</a></p>
       {% endif %}
-      {% if item.bookmarkOf %}
-      <p>{{ icon("bookmark") }} {{ __("Bookmarked") }}: <a href="{{ item.bookmarkOf[0] }}">{{ item.bookmarkOf[0] }}</a></p>
+      {% if item["bookmark-of"] %}
+      <p>{{ icon("bookmark") }} {{ __("Bookmarked") }}: <a href="{{ item["bookmark-of"][0] }}">{{ item["bookmark-of"][0] }}</a></p>
       {% endif %}
     </div>
     {% endif %}

package/views/partials/item-card.njk

@@ -1,6 +1,6 @@
 {# Item card for timeline display #}
 <article class="item-card{% if item._is_read %} item-card--read{% endif %}">
-  <a href="{{ baseUrl }}/item/{{ item.uid }}" class="item-card__link">
+  <a href="{{ baseUrl }}/item/{{ item._id }}" class="item-card__link">
     {% if item.author %}
     <div class="item-card__author">
       {% if item.author.photo %}