@rmdes/indiekit-endpoint-microsub 1.0.0 → 1.0.1

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,8 +151,8 @@ 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: {
       feedUrl,
       feedType,

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/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

@@ -229,7 +229,7 @@ export async function markItemsRead(application, channelId, entryIds, userId) {
       try {
         return new ObjectId(id);
       } catch {
-        return undefined;
+        return;
       }
     })
     .filter(Boolean);
@@ -277,7 +277,7 @@ export async function markItemsUnread(
       try {
         return new ObjectId(id);
       } catch {
-        return undefined;
+        return;
       }
     })
     .filter(Boolean);
@@ -316,7 +316,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.1",
   "description": "Microsub endpoint for Indiekit. Enables subscribing to feeds and reading content using the Microsub protocol.",
   "keywords": [
     "indiekit",