@rmdes/indiekit-endpoint-microsub 1.0.21 → 1.0.24

package/assets/styles.css

@@ -763,3 +763,176 @@
     width: 100%;
   }
 }
+
+/* ==========================================================================
+   Badge extensions for search results
+   ========================================================================== */
+
+/* Extend Indiekit badges with small variant for inline use */
+.badge--small {
+  font-size: var(--font-size-small);
+  padding: 2px var(--space-xs);
+}
+
+/* ==========================================================================
+   Search Enhancements (feed validation)
+   ========================================================================== */
+
+.search__name {
+  display: block;
+  font-weight: 600;
+  margin-bottom: var(--space-xs);
+}
+
+.search__type {
+  margin-left: var(--space-xs);
+}
+
+.search__error {
+  color: var(--color-error, #ff4444);
+  display: block;
+  font-size: var(--font-size-small);
+  margin-top: var(--space-xs);
+}
+
+.search__item--invalid {
+  opacity: 0.7;
+}
+
+.search__item--comments {
+  border-left: 3px solid var(--color-warning, #ffcc00);
+}
+
+
+.search__subscribe {
+  align-items: center;
+  display: flex;
+  gap: var(--space-s);
+}
+
+/* ==========================================================================
+   Notices (inline errors, warnings)
+   ========================================================================== */
+
+.notice {
+  border-radius: var(--border-radius-small, var(--border-radius));
+  margin-bottom: var(--space-m);
+  padding: var(--space-m);
+}
+
+.notice--error {
+  background: var(--color-red90, #fef2f2);
+  border: 1px solid var(--color-error, var(--color-red45));
+  color: var(--color-red10, #7f1d1d);
+}
+
+.notice--warning {
+  background: var(--color-yellow90, #fefce8);
+  border: 1px solid var(--color-yellow50, #eab308);
+  color: var(--color-yellow10, #713f12);
+}
+
+.notice--success {
+  background: var(--color-green90, #f0fdf4);
+  border: 1px solid var(--color-success, var(--color-green50));
+  color: var(--color-green10, #14532d);
+}
+
+/* ==========================================================================
+   Feed Management Enhancements
+   ========================================================================== */
+
+.feeds__item--error {
+  border-left: 3px solid var(--color-error, #ff4444);
+}
+
+.feeds__error {
+  color: var(--color-error, #ff4444);
+  display: block;
+  font-size: var(--font-size-small);
+  margin-top: var(--space-xs);
+}
+
+.feeds__error-count {
+  color: var(--color-warning, #ffcc00);
+  display: block;
+  font-size: var(--font-size-small);
+}
+
+.feeds__meta {
+  color: var(--color-text-muted);
+  display: block;
+  font-size: var(--font-size-small);
+}
+
+.feeds__details {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-width: 0;
+}
+
+.feeds__actions {
+  align-items: center;
+  display: flex;
+  flex-shrink: 0;
+  gap: var(--space-xs);
+}
+
+.feeds__actions form {
+  display: inline;
+  margin: 0;
+}
+
+
+/* ==========================================================================
+   Feed Edit Page
+   ========================================================================== */
+
+.feed-edit {
+  max-width: 40rem;
+}
+
+.feed-edit__current {
+  background: var(--color-offset);
+  border-radius: var(--border-radius);
+  margin-bottom: var(--space-l);
+  padding: var(--space-m);
+}
+
+.feed-edit__url {
+  color: var(--color-text-muted);
+  font-size: var(--font-size-small);
+  overflow-wrap: break-word;
+  word-break: break-all;
+}
+
+.feed-edit__title {
+  font-weight: 600;
+}
+
+.feed-edit__form {
+  margin-bottom: var(--space-l);
+}
+
+.feed-edit__help {
+  color: var(--color-text-muted);
+  font-size: var(--font-size-small);
+  margin-bottom: var(--space-m);
+}
+
+.feed-edit__actions {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-m);
+}
+
+.feed-edit__action {
+  background: var(--color-offset);
+  border-radius: var(--border-radius);
+  padding: var(--space-m);
+}
+
+.feed-edit__action p {
+  margin-bottom: var(--space-s);
+}

package/index.js

@@ -3,10 +3,11 @@ import path from "node:path";
 import express from "express";
 
 import { microsubController } from "./lib/controllers/microsub.js";
+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 { createIndexes } from "./lib/storage/items.js";
+import { cleanupAllReadItems, createIndexes } from "./lib/storage/items.js";
 import { webmentionReceiver } from "./lib/webmention/receiver.js";
 import { websubHandler } from "./lib/websub/handler.js";
 
@@ -90,6 +91,26 @@ export default class MicrosubEndpoint {
       "/channels/:uid/feeds/remove",
       readerController.removeFeed,
     );
+    readerRouter.get(
+      "/channels/:uid/feeds/:feedId",
+      readerController.feedDetails,
+    );
+    readerRouter.get(
+      "/channels/:uid/feeds/:feedId/edit",
+      readerController.editFeedForm,
+    );
+    readerRouter.post(
+      "/channels/:uid/feeds/:feedId/edit",
+      readerController.updateFeedUrl,
+    );
+    readerRouter.post(
+      "/channels/:uid/feeds/:feedId/rediscover",
+      readerController.rediscoverFeed,
+    );
+    readerRouter.post(
+      "/channels/:uid/feeds/:feedId/refresh",
+      readerController.refreshFeed,
+    );
     readerRouter.get("/item/:id", readerController.item);
     readerRouter.get("/compose", readerController.compose);
     readerRouter.post("/compose", readerController.submitCompose);
@@ -97,6 +118,7 @@ export default class MicrosubEndpoint {
     readerRouter.post("/search", readerController.searchFeeds);
     readerRouter.post("/subscribe", readerController.subscribe);
     readerRouter.post("/api/mark-read", readerController.markAllRead);
+    readerRouter.get("/opml", opmlController.exportOpml);
     router.use("/reader", readerRouter);
 
     return router;
@@ -157,6 +179,11 @@ export default class MicrosubEndpoint {
       createIndexes(indiekit).catch((error) => {
         console.warn("[Microsub] Index creation failed:", error.message);
       });
+
+      // Cleanup old read items on startup
+      cleanupAllReadItems(indiekit).catch((error) => {
+        console.warn("[Microsub] Startup cleanup failed:", error.message);
+      });
     } else {
       console.warn(
         "[Microsub] Database not available at init, scheduler not started",

package/lib/controllers/opml.js

@@ -0,0 +1,151 @@
+/**
+ * OPML export controller
+ * @module controllers/opml
+ */
+
+import { getChannels } from "../storage/channels.js";
+import { getFeedsForChannel } from "../storage/feeds.js";
+import { getUserId } from "../utils/auth.js";
+
+/**
+ * Generate OPML export of all subscriptions
+ * GET /opml
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+async function exportOpml(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channels = await getChannels(application, userId);
+
+  // Build OPML structure
+  const outlines = [];
+
+  for (const channel of channels) {
+    const feeds = await getFeedsForChannel(application, channel._id);
+
+    if (feeds.length === 0) continue;
+
+    const channelOutlines = feeds.map((feed) => ({
+      text: feed.title || extractDomain(feed.url),
+      title: feed.title || "",
+      type: "rss",
+      xmlUrl: feed.url,
+      htmlUrl: deriveSiteUrl(feed.url),
+    }));
+
+    outlines.push({
+      text: channel.name,
+      title: channel.name,
+      children: channelOutlines,
+    });
+  }
+
+  const siteUrl = application.publication?.me || "https://example.com";
+  const siteName = extractDomain(siteUrl);
+
+  const opml = generateOpmlXml({
+    title: `${siteName} - Microsub Subscriptions`,
+    dateCreated: new Date().toUTCString(),
+    ownerName: userId,
+    outlines,
+  });
+
+  response.set("Content-Type", "text/x-opml");
+  response.set(
+    "Content-Disposition",
+    'attachment; filename="subscriptions.opml"',
+  );
+  response.send(opml);
+}
+
+/**
+ * Generate OPML XML from data
+ * @param {object} data - OPML data
+ * @param {string} data.title - Document title
+ * @param {string} data.dateCreated - Creation date
+ * @param {string} data.ownerName - Owner name
+ * @param {Array} data.outlines - Outline items
+ * @returns {string} OPML XML string
+ */
+function generateOpmlXml({ title, dateCreated, ownerName, outlines }) {
+  const renderOutline = (outline, indent = "    ") => {
+    if (outline.children) {
+      const childrenXml = outline.children
+        .map((child) => renderOutline(child, indent + "  "))
+        .join("\n");
+      return `${indent}<outline text="${escapeXml(outline.text)}" title="${escapeXml(outline.title)}">\n${childrenXml}\n${indent}</outline>`;
+    }
+    return `${indent}<outline text="${escapeXml(outline.text)}" title="${escapeXml(outline.title)}" type="${outline.type}" xmlUrl="${escapeXml(outline.xmlUrl)}" htmlUrl="${escapeXml(outline.htmlUrl)}"/>`;
+  };
+
+  const outlinesXml = outlines.map((o) => renderOutline(o)).join("\n");
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<opml version="2.0">
+  <head>
+    <title>${escapeXml(title)}</title>
+    <dateCreated>${dateCreated}</dateCreated>
+    <ownerName>${escapeXml(ownerName)}</ownerName>
+  </head>
+  <body>
+${outlinesXml}
+  </body>
+</opml>`;
+}
+
+/**
+ * Escape XML special characters
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeXml(str) {
+  if (!str) return "";
+  return String(str)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+/**
+ * Extract domain from URL
+ * @param {string} url - URL to extract domain from
+ * @returns {string} Domain
+ */
+function extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+
+/**
+ * Derive site URL from feed URL
+ * @param {string} feedUrl - Feed URL
+ * @returns {string} Site URL
+ */
+function deriveSiteUrl(feedUrl) {
+  try {
+    const url = new URL(feedUrl);
+    // Remove common feed paths
+    const path = url.pathname
+      .replace(/\/feed\/?$/, "")
+      .replace(/\/rss\/?$/, "")
+      .replace(/\/atom\.xml$/, "")
+      .replace(/\/rss\.xml$/, "")
+      .replace(/\/feed\.xml$/, "")
+      .replace(/\/index\.xml$/, "")
+      .replace(/\.rss$/, "")
+      .replace(/\.atom$/, "");
+    return `${url.origin}${path || "/"}`;
+  } catch {
+    return feedUrl;
+  }
+}
+
+export const opmlController = { exportOpml };

package/lib/controllers/reader.js

@@ -3,7 +3,9 @@
  * @module controllers/reader
  */
 
-import { discoverFeedsFromUrl } from "../feeds/fetcher.js";
+import { discoverAndValidateFeeds, getBestFeed } from "../feeds/discovery.js";
+import { validateFeedUrl } from "../feeds/validator.js";
+import { ObjectId } from "mongodb";
 import { refreshFeedNow } from "../polling/scheduler.js";
 import {
   getChannels,
@@ -14,8 +16,11 @@ import {
 } from "../storage/channels.js";
 import {
   getFeedsForChannel,
+  getFeedById,
   createFeed,
   deleteFeed,
+  updateFeed,
+  updateFeedStatus,
 } from "../storage/feeds.js";
 import {
   getTimelineItems,
@@ -585,7 +590,7 @@ export async function searchPage(request, response) {
 }
 
 /**
- * Search for feeds from URL
+ * Search for feeds from URL - enhanced with validation
  * @param {object} request - Express request
  * @param {object} response - Express response
  * @returns {Promise<void>}
@@ -598,11 +603,14 @@ export async function searchFeeds(request, response) {
   const channelList = await getChannels(application, userId);
 
   let results = [];
+  let discoveryError = null;
+
   if (query) {
     try {
-      results = await discoverFeedsFromUrl(query);
-    } catch {
-      // Ignore discovery errors
+      // Use enhanced discovery with validation
+      results = await discoverAndValidateFeeds(query);
+    } catch (error) {
+      discoveryError = error.message;
     }
   }
 
@@ -611,13 +619,14 @@ export async function searchFeeds(request, response) {
     channels: channelList,
     query,
     results,
+    discoveryError,
     searched: true,
     baseUrl: request.baseUrl,
   });
 }
 
 /**
- * Subscribe to a feed from search results
+ * Subscribe to a feed from search results - with validation
  * @param {object} request - Express request
  * @param {object} response - Express response
  * @returns {Promise<void>}
@@ -625,13 +634,34 @@ export async function searchFeeds(request, response) {
 export async function subscribe(request, response) {
   const { application } = request.app.locals;
   const userId = getUserId(request);
-  const { url, channel: channelUid } = request.body;
+  const { url, channel: channelUid, skipValidation } = request.body;
 
   const channelDocument = await getChannel(application, channelUid, userId);
   if (!channelDocument) {
     return response.status(404).render("404");
   }
 
+  // Validate feed unless explicitly skipped (for power users)
+  if (!skipValidation) {
+    const validation = await validateFeedUrl(url);
+
+    if (!validation.valid) {
+      const channelList = await getChannels(application, userId);
+      return response.render("search", {
+        title: request.__("microsub.search.title"),
+        channels: channelList,
+        query: url,
+        validationError: validation.error,
+        baseUrl: request.baseUrl,
+      });
+    }
+
+    // Warn about comments feeds but allow subscription
+    if (validation.isCommentsFeed) {
+      console.warn(`[Microsub] Subscribing to comments feed: ${url}`);
+    }
+  }
+
   // Create feed subscription
   const feed = await createFeed(application, {
     channelId: channelDocument._id,
@@ -675,6 +705,210 @@ export async function markAllRead(request, response) {
   response.redirect(`${request.baseUrl}/channels/${channelUid}`);
 }
 
+/**
+ * View single feed details with status - redirects to edit form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function feedDetails(request, response) {
+  const { uid, feedId } = request.params;
+  // Redirect to edit form which shows all details
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds/${feedId}/edit`);
+}
+
+/**
+ * Edit feed URL form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function editFeedForm(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  response.render("feed-edit", {
+    title: request.__("microsub.feeds.edit"),
+    channel: channelDocument,
+    feed,
+    baseUrl: request.baseUrl,
+  });
+}
+
+/**
+ * Update feed URL
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function updateFeedUrl(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+  const { url: newUrl } = request.body;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  // Validate the new URL is a valid feed
+  const validation = await validateFeedUrl(newUrl);
+
+  if (!validation.valid) {
+    return response.render("feed-edit", {
+      title: request.__("microsub.feeds.edit"),
+      channel: channelDocument,
+      feed,
+      error: validation.error,
+      baseUrl: request.baseUrl,
+    });
+  }
+
+  // Update the feed URL and reset error state
+  await updateFeed(application, feedId, {
+    url: newUrl,
+    title: validation.title || feed.title,
+    status: "active",
+    lastError: undefined,
+    lastErrorAt: undefined,
+    consecutiveErrors: 0,
+  });
+
+  // Trigger immediate fetch
+  refreshFeedNow(application, feedId).catch((error) => {
+    console.error(
+      `[Microsub] Error refreshing updated feed ${newUrl}:`,
+      error.message,
+    );
+  });
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}
+
+/**
+ * Rediscover feed - run discovery on URL to find actual RSS feed
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function rediscoverFeed(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  // Run feed discovery on the current URL
+  try {
+    const discoveredFeeds = await discoverAndValidateFeeds(feed.url);
+    const bestFeed = getBestFeed(discoveredFeeds);
+
+    if (bestFeed && bestFeed.url !== feed.url) {
+      // Found a different (better) feed URL - update the record
+      await updateFeed(application, feedId, {
+        url: bestFeed.url,
+        title: bestFeed.title || feed.title,
+        status: "active",
+        lastError: undefined,
+        lastErrorAt: undefined,
+        consecutiveErrors: 0,
+      });
+
+      console.info(
+        `[Microsub] Rediscovered feed: ${feed.url} -> ${bestFeed.url}`,
+      );
+
+      // Trigger immediate fetch
+      refreshFeedNow(application, feedId).catch((error) => {
+        console.error(
+          `[Microsub] Error refreshing rediscovered feed:`,
+          error.message,
+        );
+      });
+    } else if (bestFeed) {
+      // Same URL but valid - just reset error state and refresh
+      await updateFeedStatus(application, feedId, { success: true });
+      await updateFeed(application, feedId, {
+        status: "active",
+        lastError: undefined,
+        lastErrorAt: undefined,
+        consecutiveErrors: 0,
+      });
+
+      refreshFeedNow(application, feedId).catch((error) => {
+        console.error(`[Microsub] Error refreshing feed:`, error.message);
+      });
+    } else {
+      // No valid feed found
+      await updateFeedStatus(application, feedId, {
+        success: false,
+        error: "No valid feed found at this URL",
+      });
+    }
+  } catch (error) {
+    await updateFeedStatus(application, feedId, {
+      success: false,
+      error: error.message,
+    });
+  }
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}
+
+/**
+ * Force refresh a feed
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function refreshFeed(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid, feedId } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const feed = await getFeedById(application, feedId);
+  if (!feed || feed.channelId.toString() !== channelDocument._id.toString()) {
+    return response.status(404).render("404");
+  }
+
+  // Trigger immediate fetch
+  refreshFeedNow(application, feedId).catch((error) => {
+    console.error(`[Microsub] Error refreshing feed ${feed.url}:`, error.message);
+  });
+
+  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+}
+
 export const readerController = {
   index,
   channels,
@@ -688,6 +922,11 @@ export const readerController = {
   feeds,
   addFeed,
   removeFeed,
+  feedDetails,
+  editFeedForm,
+  updateFeedUrl,
+  rediscoverFeed,
+  refreshFeed,
   item,
   compose,
   submitCompose,

package/lib/feeds/discovery.js

@@ -0,0 +1,95 @@
+/**
+ * Enhanced feed discovery with type labels and validation
+ * @module feeds/discovery
+ */
+
+import { discoverFeedsFromUrl } from "./fetcher.js";
+import { validateFeedUrl } from "./validator.js";
+
+/**
+ * Feed type display labels
+ */
+const FEED_TYPE_LABELS = {
+  rss: "RSS Feed",
+  atom: "Atom Feed",
+  jsonfeed: "JSON Feed",
+  hfeed: "h-feed (Microformats)",
+  activitypub: "ActivityPub",
+  unknown: "Unknown",
+};
+
+/**
+ * Discover and validate all feeds from a URL
+ * @param {string} url - Page or feed URL
+ * @returns {Promise<Array>} Array of discovered feeds with validation status
+ */
+export async function discoverAndValidateFeeds(url) {
+  // First discover feeds from the URL
+  const feeds = await discoverFeedsFromUrl(url);
+
+  // If no feeds found, return empty with error info
+  if (feeds.length === 0) {
+    return [
+      {
+        url,
+        type: "unknown",
+        typeLabel: "No feed found",
+        valid: false,
+        error: "No feeds were discovered at this URL",
+        isCommentsFeed: false,
+      },
+    ];
+  }
+
+  // Validate each discovered feed in parallel
+  const validatedFeeds = await Promise.all(
+    feeds.map(async (feed) => {
+      const validation = await validateFeedUrl(feed.url);
+
+      return {
+        url: feed.url,
+        type: validation.feedType || feed.type,
+        typeLabel:
+          FEED_TYPE_LABELS[validation.feedType] ||
+          FEED_TYPE_LABELS[feed.type] ||
+          "Feed",
+        valid: validation.valid,
+        error: validation.error,
+        isCommentsFeed: validation.isCommentsFeed || false,
+        title: validation.title || feed.title,
+        rel: feed.rel,
+      };
+    }),
+  );
+
+  // Sort: valid feeds first, non-comments before comments, then alphabetically
+  return validatedFeeds.sort((a, b) => {
+    // Valid feeds first
+    if (a.valid !== b.valid) return a.valid ? -1 : 1;
+    // Non-comments before comments
+    if (a.isCommentsFeed !== b.isCommentsFeed) return a.isCommentsFeed ? 1 : -1;
+    // Then by URL
+    return a.url.localeCompare(b.url);
+  });
+}
+
+/**
+ * Filter to only main content feeds (exclude comments)
+ * @param {Array} feeds - Array of feed objects
+ * @returns {Array} Filtered array of main content feeds
+ */
+export function filterMainFeeds(feeds) {
+  return feeds.filter((feed) => feed.valid && !feed.isCommentsFeed);
+}
+
+/**
+ * Get the best feed from a list (first valid, non-comments feed)
+ * @param {Array} feeds - Array of feed objects
+ * @returns {object|undefined} Best feed or undefined
+ */
+export function getBestFeed(feeds) {
+  const mainFeeds = filterMainFeeds(feeds);
+  return mainFeeds.length > 0 ? mainFeeds[0] : undefined;
+}
+
+export { FEED_TYPE_LABELS };

package/lib/feeds/validator.js

@@ -0,0 +1,128 @@
+/**
+ * Feed validation utilities
+ * @module feeds/validator
+ */
+
+import { fetchFeed } from "./fetcher.js";
+import { detectFeedType } from "./parser.js";
+
+/**
+ * Feed types that are valid subscriptions
+ */
+const VALID_FEED_TYPES = ["rss", "atom", "jsonfeed", "hfeed"];
+
+/**
+ * Patterns that indicate a comments feed (not a main feed)
+ */
+const COMMENTS_PATTERNS = [
+  /\/comments\/?$/i,
+  /\/feed\/comments/i,
+  /commentsfeed/i,
+  /comment-feed/i,
+  /-comments\.xml$/i,
+  /\/replies\/?$/i,
+  /comments\.rss$/i,
+  /comments\.atom$/i,
+];
+
+/**
+ * Validate a URL is actually a feed
+ * @param {string} url - URL to validate
+ * @returns {Promise<object>} Validation result
+ */
+export async function validateFeedUrl(url) {
+  try {
+    const result = await fetchFeed(url, { timeout: 15000 });
+
+    if (result.notModified || !result.content) {
+      return {
+        valid: false,
+        error: "Unable to fetch content from URL",
+      };
+    }
+
+    const feedType = detectFeedType(result.content, result.contentType);
+
+    if (feedType === "activitypub") {
+      return {
+        valid: false,
+        error:
+          "URL returns ActivityPub JSON instead of a feed. Try the direct feed URL.",
+        feedType,
+      };
+    }
+
+    if (!VALID_FEED_TYPES.includes(feedType)) {
+      return {
+        valid: false,
+        error: `URL does not contain a valid feed (detected: ${feedType})`,
+        feedType,
+      };
+    }
+
+    // Check if it's a comments feed
+    const isCommentsFeed = COMMENTS_PATTERNS.some((pattern) =>
+      pattern.test(url),
+    );
+
+    return {
+      valid: true,
+      feedType,
+      isCommentsFeed,
+      title: extractFeedTitle(result.content, feedType),
+      contentType: result.contentType,
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * Extract feed title from content
+ * @param {string} content - Feed content
+ * @param {string} feedType - Type of feed
+ * @returns {string|undefined} Feed title
+ */
+function extractFeedTitle(content, feedType) {
+  if (feedType === "jsonfeed") {
+    try {
+      const json = JSON.parse(content);
+      return json.title;
+    } catch {
+      return undefined;
+    }
+  }
+
+  // Extract title from XML (RSS or Atom)
+  // Try channel/title first (RSS), then just title (Atom)
+  const channelTitleMatch = content.match(
+    /<channel[^>]*>[\s\S]*?<title[^>]*>([^<]+)<\/title>/i,
+  );
+  if (channelTitleMatch) {
+    return decodeXmlEntities(channelTitleMatch[1].trim());
+  }
+
+  const titleMatch = content.match(/<title[^>]*>([^<]+)<\/title>/i);
+  return titleMatch ? decodeXmlEntities(titleMatch[1].trim()) : undefined;
+}
+
+/**
+ * Decode XML entities
+ * @param {string} str - String with XML entities
+ * @returns {string} Decoded string
+ */
+function decodeXmlEntities(str) {
+  return str
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10)))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, code) =>
+      String.fromCharCode(parseInt(code, 16)),
+    );
+}

package/lib/polling/processor.js

@@ -6,7 +6,11 @@
 import { getRedisClient, publishEvent } from "../cache/redis.js";
 import { fetchAndParseFeed } from "../feeds/fetcher.js";
 import { getChannel } from "../storage/channels.js";
-import { updateFeedAfterFetch, updateFeedWebsub } from "../storage/feeds.js";
+import {
+  updateFeedAfterFetch,
+  updateFeedStatus,
+  updateFeedWebsub,
+} from "../storage/feeds.js";
 import { passesRegexFilter, passesTypeFilter } from "../storage/filters.js";
 import { addItem } from "../storage/items.js";
 import {
@@ -167,9 +171,21 @@ export async function processFeed(application, feed) {
 
     result.success = true;
     result.tier = tierResult.tier;
+
+    // Update feed status to active on success
+    await updateFeedStatus(application, feed._id, {
+      success: true,
+      itemCount: parsed.items?.length || 0,
+    });
   } catch (error) {
     result.error = error.message;
 
+    // Update feed status to error
+    await updateFeedStatus(application, feed._id, {
+      success: false,
+      error: error.message,
+    });
+
     // Still update the feed to prevent retry storms
     try {
       const tierResult = calculateNewTier({
@@ -182,8 +198,6 @@ export async function processFeed(application, feed) {
         tier: Math.min(tierResult.tier + 1, 10), // Increase tier on error
         unmodified: tierResult.consecutiveUnchanged,
         nextFetchAt: tierResult.nextFetchAt,
-        lastError: error.message,
-        lastErrorAt: new Date(),
       });
     } catch {
       // Ignore update errors

package/lib/storage/feeds.js

@@ -297,3 +297,68 @@ export async function updateFeedWebsub(application, id, websub) {
 export async function getFeedBySubscriptionId(application, subscriptionId) {
   return getFeedById(application, subscriptionId);
 }
+
+/**
+ * Update feed status after processing
+ * Tracks health status, errors, and success metrics
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} id - Feed ObjectId
+ * @param {object} status - Status update
+ * @param {boolean} status.success - Whether fetch was successful
+ * @param {string} [status.error] - Error message if failed
+ * @param {number} [status.itemCount] - Number of items in feed
+ * @returns {Promise<object|null>} Updated feed
+ */
+export async function updateFeedStatus(application, id, status) {
+  const collection = getCollection(application);
+  const objectId = typeof id === "string" ? new ObjectId(id) : id;
+
+  const updateFields = {
+    updatedAt: new Date(),
+  };
+
+  if (status.success) {
+    updateFields.status = "active";
+    updateFields.lastSuccessAt = new Date();
+    updateFields.consecutiveErrors = 0;
+    updateFields.lastError = undefined;
+    updateFields.lastErrorAt = undefined;
+
+    if (status.itemCount !== undefined) {
+      updateFields.itemCount = status.itemCount;
+    }
+  } else {
+    updateFields.status = "error";
+    updateFields.lastError = status.error;
+    updateFields.lastErrorAt = new Date();
+  }
+
+  // Use $set for most fields, $inc for consecutiveErrors on failure
+  const updateOp = { $set: updateFields };
+
+  if (!status.success) {
+    // Increment consecutive errors
+    updateOp.$inc = { consecutiveErrors: 1 };
+  }
+
+  return collection.findOneAndUpdate({ _id: objectId }, updateOp, {
+    returnDocument: "after",
+  });
+}
+
+/**
+ * Get feeds with errors
+ * @param {object} application - Indiekit application
+ * @param {number} [minErrors=3] - Minimum consecutive errors
+ * @returns {Promise<Array>} Array of feeds with errors
+ */
+export async function getFeedsWithErrors(application, minErrors = 3) {
+  const collection = getCollection(application);
+
+  return collection
+    .find({
+      status: "error",
+      consecutiveErrors: { $gte: minErrors },
+    })
+    .toArray();
+}

package/lib/storage/items.js

@@ -328,6 +328,68 @@ async function cleanupOldReadItems(collection, channelObjectId, userId) {
   }
 }
 
+/**
+ * Cleanup all read items across all channels (startup cleanup)
+ * @param {object} application - Indiekit application
+ * @returns {Promise<number>} Total number of items deleted
+ */
+export async function cleanupAllReadItems(application) {
+  const collection = getCollection(application);
+  const channelsCollection = application.collections.get("microsub_channels");
+
+  // Get all channels
+  const channels = await channelsCollection.find({}).toArray();
+  let totalDeleted = 0;
+
+  for (const channel of channels) {
+    // Get unique userIds who have read items in this channel
+    const readByUsers = await collection.distinct("readBy", {
+      channelId: channel._id,
+      readBy: { $exists: true, $ne: [] },
+    });
+
+    for (const userId of readByUsers) {
+      if (!userId) continue;
+
+      const readCount = await collection.countDocuments({
+        channelId: channel._id,
+        readBy: userId,
+      });
+
+      if (readCount > MAX_READ_ITEMS) {
+        const itemsToDelete = await collection
+          .find({
+            channelId: channel._id,
+            readBy: userId,
+          })
+          .sort({ published: -1, _id: -1 })
+          .skip(MAX_READ_ITEMS)
+          .project({ _id: 1 })
+          .toArray();
+
+        if (itemsToDelete.length > 0) {
+          const idsToDelete = itemsToDelete.map((item) => item._id);
+          const deleteResult = await collection.deleteMany({
+            _id: { $in: idsToDelete },
+          });
+          totalDeleted += deleteResult.deletedCount;
+          console.info(
+            `[Microsub] Startup cleanup: deleted ${deleteResult.deletedCount} old items from channel "${channel.name}"`,
+          );
+        }
+      }
+    }
+  }
+
+  if (totalDeleted > 0) {
+    console.info(
+      `[Microsub] Startup cleanup complete: ${totalDeleted} total items deleted`,
+    );
+  }
+
+  return totalDeleted;
+}
+
 export async function markItemsRead(application, channelId, entryIds, userId) {
   const collection = getCollection(application);
   const channelObjectId =

package/locales/en.json

@@ -34,7 +34,15 @@
       "unfollow": "Unfollow",
       "empty": "No feeds followed in this channel",
       "url": "Feed URL",
-      "urlPlaceholder": "https://example.com/feed.xml"
+      "urlPlaceholder": "https://example.com/feed.xml",
+      "edit": "Edit feed",
+      "rediscover": "Rediscover feed",
+      "refresh": "Refresh now",
+      "status": {
+        "active": "Active",
+        "error": "Error",
+        "stale": "Stale"
+      }
     },
     "item": {
       "reply": "Reply",

package/package.json

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

package/views/feed-edit.njk

@@ -0,0 +1,84 @@
+{% extends "layouts/reader.njk" %}
+
+{% block reader %}
+  <div class="settings">
+    <a href="{{ baseUrl }}/channels/{{ channel.uid }}/feeds" class="back-link">
+      {{ icon("previous") }} {{ __("microsub.feeds.title") }}
+    </a>
+
+    <h2>{{ __("microsub.feeds.edit") }}</h2>
+
+    {% if error %}
+    <div class="notice notice--error">
+      <p>{{ error }}</p>
+    </div>
+    {% endif %}
+
+    <div class="feed-edit">
+      <div class="feed-edit__current">
+        <h3>Current Feed</h3>
+        <p class="feed-edit__url">{{ feed.url }}</p>
+        {% if feed.title %}
+        <p class="feed-edit__title">{{ feed.title }}</p>
+        {% endif %}
+        {% if feed.status == 'error' %}
+        <div class="notice notice--error">
+          <p><strong>Status:</strong> Error</p>
+          {% if feed.lastError %}
+          <p><strong>Last error:</strong> {{ feed.lastError }}</p>
+          {% endif %}
+          {% if feed.consecutiveErrors %}
+          <p><strong>Consecutive errors:</strong> {{ feed.consecutiveErrors }}</p>
+          {% endif %}
+        </div>
+        {% endif %}
+      </div>
+
+      <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/{{ feed._id }}/edit" class="feed-edit__form">
+        {{ input({
+          id: "url",
+          name: "url",
+          label: "New Feed URL",
+          type: "url",
+          required: true,
+          value: feed.url,
+          placeholder: "https://example.com/feed.xml",
+          autocomplete: "off"
+        }) }}
+
+        <p class="feed-edit__help">
+          Enter the direct URL to the RSS, Atom, or JSON Feed. The URL will be validated before updating.
+        </p>
+
+        <div class="button-group">
+          {{ button({ text: "Update Feed URL" }) }}
+          <a href="{{ baseUrl }}/channels/{{ channel.uid }}/feeds" class="button button--secondary">
+            Cancel
+          </a>
+        </div>
+      </form>
+
+      <div class="divider"></div>
+
+      <div class="feed-edit__actions">
+        <h3>Other Actions</h3>
+
+        <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/{{ feed._id }}/rediscover" class="feed-edit__action">
+          <p>Run feed discovery on the current URL to find the actual RSS/Atom feed.</p>
+          {{ button({
+            text: "Rediscover Feed",
+            classes: "button--secondary"
+          }) }}
+        </form>
+
+        <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/{{ feed._id }}/refresh" class="feed-edit__action">
+          <p>Force refresh this feed now.</p>
+          {{ button({
+            text: "Refresh Now",
+            classes: "button--secondary"
+          }) }}
+        </form>
+      </div>
+    </div>
+  </div>
+{% endblock %}

package/views/feeds.njk

@@ -13,7 +13,7 @@
     {% if feeds.length > 0 %}
     <div class="feeds__list">
       {% for feed in feeds %}
-      <div class="feeds__item">
+      <div class="feeds__item{% if feed.status == 'error' %} feeds__item--error{% endif %}">
         <div class="feeds__info">
           {% if feed.photo %}
           <img src="{{ feed.photo }}"
@@ -25,19 +25,51 @@
                onerror="this.style.display='none'">
           {% endif %}
           <div class="feeds__details">
-            <span class="feeds__name">{{ feed.title or feed.url }}</span>
+            <span class="feeds__name">
+              {{ feed.title or feed.url }}
+              {% if feed.status == 'error' %}
+              <span class="badge badge--red">Error</span>
+              {% elif feed.status == 'active' %}
+              <span class="badge badge--green">Active</span>
+              {% endif %}
+            </span>
             <a href="{{ feed.url }}" class="feeds__url" target="_blank" rel="noopener">
               {{ feed.url | replace("https://", "") | replace("http://", "") }}
             </a>
+            {% if feed.lastError %}
+            <span class="feeds__error">{{ feed.lastError }}</span>
+            {% endif %}
+            {% if feed.consecutiveErrors > 0 %}
+            <span class="feeds__error-count">{{ feed.consecutiveErrors }} consecutive errors</span>
+            {% endif %}
+            {% if feed.lastSuccessAt %}
+            <span class="feeds__meta">Last success: {{ feed.lastSuccessAt | date("relative") }}</span>
+            {% endif %}
           </div>
         </div>
-        <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/remove" class="feeds__actions">
-          <input type="hidden" name="url" value="{{ feed.url }}">
-          {{ button({
-            text: __("microsub.feeds.unfollow"),
-            classes: "button--secondary button--small"
-          }) }}
-        </form>
+        <div class="feeds__actions">
+          <a href="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/{{ feed._id }}/edit"
+             class="button button--secondary button--small"
+             title="Edit feed URL">
+            {{ icon("edit") }}
+          </a>
+          <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/{{ feed._id }}/rediscover" style="display:inline;">
+            <button type="submit" class="button button--secondary button--small" title="Rediscover feed">
+              {{ icon("discover") }}
+            </button>
+          </form>
+          <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/{{ feed._id }}/refresh" style="display:inline;">
+            <button type="submit" class="button button--secondary button--small" title="Refresh now">
+              {{ icon("refresh") }}
+            </button>
+          </form>
+          <form method="post" action="{{ baseUrl }}/channels/{{ channel.uid }}/feeds/remove" style="display:inline;">
+            <input type="hidden" name="url" value="{{ feed.url }}">
+            <button type="submit" class="button button--warning button--small" title="Unfollow">
+              {{ icon("delete") }}
+            </button>
+          </form>
+        </div>
       </div>
       {% endfor %}
     </div>

package/views/search.njk

@@ -25,16 +25,40 @@
       </div>
     </form>
 
+    {% if validationError %}
+    <div class="notice notice--error">
+      <p>{{ validationError }}</p>
+    </div>
+    {% endif %}
+
+    {% if discoveryError %}
+    <div class="notice notice--error">
+      <p>{{ discoveryError }}</p>
+    </div>
+    {% endif %}
+
     {% if results and results.length > 0 %}
     <div class="search__results">
       <h3>{{ __("microsub.search.title") }}</h3>
       <div class="search__list">
         {% for result in results %}
-        <div class="search__item">
+        <div class="search__item{% if not result.valid %} search__item--invalid{% endif %}{% if result.isCommentsFeed %} search__item--comments{% endif %}">
           <div class="search__feed">
-            <span class="search__name">{{ result.title or "Feed" }}</span>
+            <span class="search__name">
+              {{ result.title or "Feed" }}
+              <span class="search__type badge badge--small{% if result.valid %} badge--green{% else %} badge--yellow{% endif %}">
+                {{ result.typeLabel }}
+              </span>
+              {% if result.isCommentsFeed %}
+              <span class="search__type badge badge--small badge--yellow">Comments</span>
+              {% endif %}
+            </span>
             <span class="search__url">{{ result.url | replace("https://", "") | replace("http://", "") }}</span>
+            {% if not result.valid %}
+            <span class="search__error">{{ result.error }}</span>
+            {% endif %}
           </div>
+          {% if result.valid %}
           <form method="post" action="{{ baseUrl }}/subscribe" class="search__subscribe">
             <input type="hidden" name="url" value="{{ result.url }}">
             <label for="channel-{{ loop.index }}" class="visually-hidden">{{ __("microsub.channels.title") }}</label>
@@ -48,6 +72,9 @@
               classes: "button--small"
             }) }}
           </form>
+          {% else %}
+          <span class="badge badge--small badge--red">Invalid</span>
+          {% endif %}
         </div>
         {% endfor %}
       </div>