@rmdes/indiekit-endpoint-microsub 1.0.43 → 1.0.45

package/assets/styles.css

@@ -416,7 +416,57 @@
   color: var(--color-background);
 }
 
-/* Mark as read button */
+/* Mark as read — split button group */
+.item-actions__mark-read-group {
+  display: inline-flex;
+  margin-left: auto;
+  position: relative;
+}
+
+.item-actions__mark-read-group .item-actions__mark-read {
+  border-bottom-right-radius: 0;
+  border-right: 0;
+  border-top-right-radius: 0;
+  margin-left: 0;
+}
+
+.item-actions__mark-read-caret {
+  border-bottom-left-radius: 0;
+  border-top-left-radius: 0;
+  font-size: 0.625rem;
+  padding: var(--space-xs) 6px;
+}
+
+.item-actions__mark-read-popover {
+  background: var(--color-background);
+  border: 1px solid var(--color-offset-active);
+  border-radius: var(--border-radius);
+  bottom: calc(100% + 4px);
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+  padding: var(--space-xs);
+  position: absolute;
+  right: 0;
+  white-space: nowrap;
+  z-index: 10;
+}
+
+.item-actions__mark-source-read {
+  background: transparent;
+  border: 0;
+  border-radius: var(--border-radius);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: var(--font-size-small);
+  padding: var(--space-xs) var(--space-s);
+  text-align: left;
+  width: 100%;
+}
+
+.item-actions__mark-source-read:hover {
+  background: var(--color-offset);
+}
+
+/* Mark as read button (standalone, no split group) */
 .item-actions__mark-read {
   margin-left: auto;
 }

package/lib/controllers/follow.js

@@ -67,13 +67,24 @@ export async function follow(request, response) {
     throw new IndiekitError("Channel not found", { status: 404 });
   }
 
-  // Create feed subscription
-  const feed = await createFeed(application, {
-    channelId: channelDocument._id,
-    url,
-    title: undefined, // Will be populated on first fetch
-    photo: undefined,
-  });
+  // Create feed subscription (throws DUPLICATE_FEED if already exists elsewhere)
+  let feed;
+  try {
+    feed = await createFeed(application, {
+      channelId: channelDocument._id,
+      url,
+      title: undefined, // Will be populated on first fetch
+      photo: undefined,
+    });
+  } catch (error) {
+    if (error.code === "DUPLICATE_FEED") {
+      throw new IndiekitError(
+        `Feed already exists in channel "${error.channelName}"`,
+        { status: 409 },
+      );
+    }
+    throw error;
+  }
 
   // Trigger immediate fetch in background (don't await)
   // This will also discover and subscribe to WebSub hubs

package/lib/controllers/reader.js

@@ -319,20 +319,43 @@ export async function addFeed(request, response) {
     return response.status(404).render("404");
   }
 
-  // Create feed subscription
-  const feed = await createFeed(application, {
-    channelId: channelDocument._id,
-    url,
-    title: undefined,
-    photo: undefined,
-  });
+  try {
+    // Create feed subscription (throws DUPLICATE_FEED if already exists)
+    const feed = await createFeed(application, {
+      channelId: channelDocument._id,
+      url,
+      title: undefined,
+      photo: undefined,
+    });
 
-  // Trigger immediate fetch in background
-  refreshFeedNow(application, feed._id).catch((error) => {
-    console.error(`[Microsub] Error fetching new feed ${url}:`, error.message);
-  });
+    // Trigger immediate fetch in background
+    refreshFeedNow(application, feed._id).catch((error) => {
+      console.error(`[Microsub] Error fetching new feed ${url}:`, error.message);
+    });
 
-  response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+    response.redirect(`${request.baseUrl}/channels/${uid}/feeds`);
+  } catch (error) {
+    if (error.code === "DUPLICATE_FEED") {
+      // Re-render feeds page with error message
+      const feedList = await getFeedsForChannel(application, channelDocument._id);
+      return response.render("feeds", {
+        title: request.__("microsub.feeds.title"),
+        channel: channelDocument,
+        feeds: feedList,
+        baseUrl: request.baseUrl,
+        readerBaseUrl: request.baseUrl,
+        activeView: "channels",
+        error: `This feed already exists in channel "${error.channelName}"`,
+        breadcrumbs: [
+          { text: "Reader", href: request.baseUrl },
+          { text: "Channels", href: `${request.baseUrl}/channels` },
+          { text: channelDocument.name, href: `${request.baseUrl}/channels/${uid}` },
+          { text: "Feeds" },
+        ],
+      });
+    }
+    throw error;
+  }
 }
 
 /**
@@ -782,20 +805,40 @@ export async function subscribe(request, response) {
     }
   }
 
-  // Create feed subscription
-  const feed = await createFeed(application, {
-    channelId: channelDocument._id,
-    url,
-    title: undefined,
-    photo: undefined,
-  });
+  // Create feed subscription (throws DUPLICATE_FEED if already exists elsewhere)
+  try {
+    const feed = await createFeed(application, {
+      channelId: channelDocument._id,
+      url,
+      title: undefined,
+      photo: undefined,
+    });
 
-  // Trigger immediate fetch in background
-  refreshFeedNow(application, feed._id).catch((error) => {
-    console.error(`[Microsub] Error fetching new feed ${url}:`, error.message);
-  });
+    // Trigger immediate fetch in background
+    refreshFeedNow(application, feed._id).catch((error) => {
+      console.error(`[Microsub] Error fetching new feed ${url}:`, error.message);
+    });
 
-  response.redirect(`${request.baseUrl}/channels/${channelUid}/feeds`);
+    response.redirect(`${request.baseUrl}/channels/${channelUid}/feeds`);
+  } catch (error) {
+    if (error.code === "DUPLICATE_FEED") {
+      const channelList = await getChannels(application, userId);
+      return response.render("search", {
+        title: request.__("microsub.search.title"),
+        channels: channelList,
+        query: url,
+        validationError: `This feed already exists in channel "${error.channelName}"`,
+        baseUrl: request.baseUrl,
+        readerBaseUrl: request.baseUrl,
+        activeView: "channels",
+        breadcrumbs: [
+          { text: "Reader", href: request.baseUrl },
+          { text: "Search" },
+        ],
+      });
+    }
+    throw error;
+  }
 }
 
 /**

package/lib/controllers/timeline.js

@@ -9,6 +9,7 @@ import { proxyItemImages } from "../media/proxy.js";
 import { getChannel, getChannelById } from "../storage/channels.js";
 import {
   getTimelineItems,
+  markFeedItemsRead,
   markItemsRead,
   markItemsUnread,
   removeItems,
@@ -103,6 +104,22 @@ export async function action(request, response) {
       return response.json({ result: "ok", updated: count });
     }
 
+    case "mark_read_source": {
+      const feedId = request.body.feed;
+      if (!feedId) {
+        throw new IndiekitError("feed parameter required", {
+          status: 400,
+        });
+      }
+      const count = await markFeedItemsRead(
+        application,
+        channelDocument._id,
+        feedId,
+        userId,
+      );
+      return response.json({ result: "ok", updated: count });
+    }
+
     case "mark_unread": {
       validateEntries(entries);
       const count = await markItemsUnread(

package/lib/feeds/fetcher.js

@@ -171,12 +171,14 @@ export async function fetchAndParseFeed(url, options = {}) {
       // Fetch and parse the discovered feed
       const feedResult = await fetchFeed(fallbackFeed.url, options);
       if (!feedResult.notModified) {
+        const fallbackType = detectFeedType(feedResult.content, feedResult.contentType);
         const parsed = await parseFeed(feedResult.content, fallbackFeed.url, {
           contentType: feedResult.contentType,
         });
         return {
           ...feedResult,
           ...parsed,
+          feedType: fallbackType,
           hub: feedResult.hub || parsed._hub,
           discoveredFrom: url,
         };
@@ -194,6 +196,7 @@ export async function fetchAndParseFeed(url, options = {}) {
   return {
     ...result,
     ...parsed,
+    feedType: feedType,
     hub: result.hub || parsed._hub,
   };
 }

package/lib/polling/processor.js

@@ -132,13 +132,16 @@ export async function processFeed(application, feed) {
       lastModified: parsed.lastModified,
     };
 
-    // Update feed title/photo if discovered
+    // Update feed title/photo/feedType if discovered
     if (parsed.name && !feed.title) {
       updateData.title = parsed.name;
     }
     if (parsed.photo && !feed.photo) {
       updateData.photo = parsed.photo;
     }
+    if (parsed.feedType && !feed.feedType) {
+      updateData.feedType = parsed.feedType;
+    }
 
     await updateFeedAfterFetch(
       application,

package/lib/storage/feeds.js

@@ -16,6 +16,73 @@ function getCollection(application) {
   return application.collections.get("microsub_feeds");
 }
 
+/**
+ * Normalize a feed URL for duplicate comparison.
+ * Strips trailing slashes, normalizes protocol to https, lowercases hostname.
+ * @param {string} url - Feed URL
+ * @returns {string} Normalized URL
+ */
+export function normalizeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    // Normalize protocol to https
+    parsed.protocol = "https:";
+    // Lowercase hostname
+    parsed.hostname = parsed.hostname.toLowerCase();
+    // Remove trailing slash from path (but keep "/" for root)
+    if (parsed.pathname.length > 1 && parsed.pathname.endsWith("/")) {
+      parsed.pathname = parsed.pathname.slice(0, -1);
+    }
+    return parsed.href;
+  } catch {
+    return url;
+  }
+}
+
+/**
+ * Find an existing feed across ALL channels by normalized URL
+ * @param {object} application - Indiekit application
+ * @param {string} url - Feed URL to check
+ * @returns {Promise<object|null>} Existing feed with channel info, or null
+ */
+export async function findFeedAcrossChannels(application, url) {
+  const collection = getCollection(application);
+  const normalized = normalizeUrl(url);
+
+  // Get all feeds and check normalized URLs
+  // We check a few common URL variants directly for efficiency
+  const variants = new Set();
+  variants.add(url);
+  variants.add(normalized);
+  // Also try with/without trailing slash
+  if (url.endsWith("/")) {
+    variants.add(url.slice(0, -1));
+  } else {
+    variants.add(url + "/");
+  }
+  // Try http/https variants
+  if (url.startsWith("https://")) {
+    variants.add(url.replace("https://", "http://"));
+  } else if (url.startsWith("http://")) {
+    variants.add(url.replace("http://", "https://"));
+  }
+
+  const existing = await collection.findOne({
+    url: { $in: [...variants] },
+  });
+
+  if (!existing) return null;
+
+  // Look up the channel name for a useful error message
+  const channelsCollection = application.collections.get("microsub_channels");
+  const channel = await channelsCollection.findOne({ _id: existing.channelId });
+
+  return {
+    feed: existing,
+    channelName: channel?.name || "unknown channel",
+  };
+}
+
 /**
  * Create a new feed subscription
  * @param {object} application - Indiekit application
@@ -32,12 +99,24 @@ export async function createFeed(
 ) {
   const collection = getCollection(application);
 
-  // Check if feed already exists in channel
+  // Check if feed already exists in this channel (exact match)
   const existing = await collection.findOne({ channelId, url });
   if (existing) {
     return existing;
   }
 
+  // Check for duplicate across ALL channels (normalized URL)
+  const duplicate = await findFeedAcrossChannels(application, url);
+  if (duplicate) {
+    const error = new Error(
+      `Feed already exists in channel "${duplicate.channelName}"`,
+    );
+    error.code = "DUPLICATE_FEED";
+    error.existingFeed = duplicate.feed;
+    error.channelName = duplicate.channelName;
+    throw error;
+  }
+
   const feed = {
     channelId,
     url,

package/lib/storage/items.js

@@ -271,6 +271,7 @@ function transformToJf2(item, userId) {
     _id: item._id.toString(),
     _is_read: userId ? item.readBy?.includes(userId) : false,
     _channelId: item.channelId?.toString(),
+    _feedId: item.feedId?.toString(),
   };
 
   // Optional fields
@@ -695,6 +696,41 @@ export async function markItemsRead(application, channelId, entryIds, userId) {
   return result.modifiedCount;
 }
 
+/**
+ * Mark all items from a specific feed as read in a channel
+ * @param {object} application - Indiekit application
+ * @param {ObjectId|string} channelId - Channel ObjectId
+ * @param {ObjectId|string} feedId - Feed ObjectId
+ * @param {string} userId - User ID
+ * @returns {Promise<number>} Number of items updated
+ */
+export async function markFeedItemsRead(
+  application,
+  channelId,
+  feedId,
+  userId,
+) {
+  const collection = getCollection(application);
+  const channelObjectId =
+    typeof channelId === "string" ? new ObjectId(channelId) : channelId;
+  const feedObjectId =
+    typeof feedId === "string" ? new ObjectId(feedId) : feedId;
+
+  const result = await collection.updateMany(
+    { channelId: channelObjectId, feedId: feedObjectId },
+    { $addToSet: { readBy: userId } },
+  );
+
+  console.info(
+    `[Microsub] markFeedItemsRead: marked ${result.modifiedCount} items from feed ${feedId} as read`,
+  );
+
+  // Cleanup old read items
+  await cleanupOldReadItems(collection, channelObjectId, userId);
+
+  return result.modifiedCount;
+}
+
 /**
  * Mark items as unread
  * @param {object} application - Indiekit application

package/package.json

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

package/views/channel.njk

@@ -174,6 +174,84 @@
         }
       });
 
+      // Handle caret toggle for mark-source-read popover
+      timeline.addEventListener('click', (e) => {
+        const caret = e.target.closest('.item-actions__mark-read-caret');
+        if (!caret) return;
+
+        e.preventDefault();
+        e.stopPropagation();
+
+        // Close other open popovers
+        for (const p of timeline.querySelectorAll('.item-actions__mark-read-popover:not([hidden])')) {
+          if (p !== caret.nextElementSibling) p.hidden = true;
+        }
+
+        const popover = caret.nextElementSibling;
+        if (popover) popover.hidden = !popover.hidden;
+      });
+
+      // Handle mark-source-read button
+      timeline.addEventListener('click', async (e) => {
+        const button = e.target.closest('.item-actions__mark-source-read');
+        if (!button) return;
+
+        e.preventDefault();
+        e.stopPropagation();
+
+        const feedId = button.dataset.feedId;
+        if (!feedId) return;
+
+        button.disabled = true;
+
+        try {
+          const formData = new URLSearchParams();
+          formData.append('action', 'timeline');
+          formData.append('method', 'mark_read_source');
+          formData.append('channel', channelUid);
+          formData.append('feed', feedId);
+
+          const response = await fetch(microsubApiUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: formData.toString(),
+            credentials: 'same-origin'
+          });
+
+          if (response.ok) {
+            // Animate out all cards from this feed
+            const cards = timeline.querySelectorAll(`.item-card[data-feed-id="${feedId}"]`);
+            for (const card of cards) {
+              card.style.transition = 'opacity 0.3s ease, transform 0.3s ease';
+              card.style.opacity = '0';
+              card.style.transform = 'translateX(-20px)';
+            }
+            setTimeout(() => {
+              for (const card of [...cards]) {
+                card.remove();
+              }
+              if (timeline.querySelectorAll('.item-card').length === 0) {
+                location.reload();
+              }
+            }, 300);
+          } else {
+            button.disabled = false;
+          }
+        } catch (error) {
+          console.error('Error marking source as read:', error);
+          button.disabled = false;
+        }
+      });
+
+      // Close popovers on outside click
+      document.addEventListener('click', (e) => {
+        if (!e.target.closest('.item-actions__mark-read-group')) {
+          for (const p of timeline.querySelectorAll('.item-actions__mark-read-popover:not([hidden])')) {
+            p.hidden = true;
+          }
+        }
+      });
+
       // Handle save-for-later buttons
       timeline.addEventListener('click', async (e) => {
         const button = e.target.closest('.item-actions__save-later');

package/views/feeds.njk

@@ -10,6 +10,12 @@
 
     <h2>{{ __("microsub.feeds.title") }}</h2>
 
+    {% if error %}
+    <div class="notice notice--error" role="alert">
+      {{ error }}
+    </div>
+    {% endif %}
+
     {% if feeds.length > 0 %}
     <div class="feeds__list">
       {% for feed in feeds %}
@@ -27,6 +33,9 @@
           <div class="feeds__details">
             <span class="feeds__name">
               {{ feed.title or feed.url }}
+              {% if feed.feedType %}
+              <span class="badge badge--offset badge--small" title="Feed format">{{ feed.feedType | upper }}</span>
+              {% endif %}
               {% if feed.status == 'error' %}
               <span class="badge badge--red">Error</span>
               {% elif feed.status == 'active' %}

package/views/partials/item-card.njk

@@ -4,6 +4,7 @@
 #}
 <article class="item-card{% if item._is_read %} item-card--read{% endif %}"
          data-item-id="{{ item._id }}"
+         data-feed-id="{{ item._feedId or '' }}"
          data-is-read="{{ item._is_read | default(false) }}">
 
   {# Context bar for interactions (Aperture pattern) #}
@@ -198,6 +199,33 @@
       <span class="visually-hidden">Bookmark</span>
     </a>
     {% if not item._is_read %}
+    {% if item._feedId %}
+    <span class="item-actions__mark-read-group">
+      <button type="button"
+              class="item-actions__button item-actions__mark-read"
+              data-action="mark-read"
+              data-item-id="{{ item._id }}"
+              {% if item._channelUid %}data-channel-uid="{{ item._channelUid }}"{% endif %}
+              {% if item._channelId %}data-channel-id="{{ item._channelId }}"{% endif %}
+              title="Mark as read">
+        {{ icon("checkboxChecked") }}
+        <span class="visually-hidden">Mark read</span>
+      </button>
+      <button type="button"
+              class="item-actions__button item-actions__mark-read-caret"
+              aria-label="More mark-read options"
+              title="More options">&#9662;</button>
+      <div class="item-actions__mark-read-popover" hidden>
+        <button type="button"
+                class="item-actions__mark-source-read"
+                data-feed-id="{{ item._feedId }}"
+                {% if item._channelUid %}data-channel-uid="{{ item._channelUid }}"{% endif %}
+                {% if item._channelId %}data-channel-id="{{ item._channelId }}"{% endif %}>
+          Mark {{ item._source.name or item.author.name or "source" }} as read
+        </button>
+      </div>
+    </span>
+    {% else %}
     <button type="button"
             class="item-actions__button item-actions__mark-read"
             data-action="mark-read"
@@ -209,6 +237,7 @@
       <span class="visually-hidden">Mark read</span>
     </button>
     {% endif %}
+    {% endif %}
     {% if application.readlaterEndpoint %}
     <button type="button"
             class="item-actions__button item-actions__save-later"

package/views/timeline.njk

@@ -152,6 +152,88 @@
         }
       });
 
+      // Handle caret toggle for mark-source-read popover
+      timeline.addEventListener('click', (e) => {
+        const caret = e.target.closest('.item-actions__mark-read-caret');
+        if (!caret) return;
+
+        e.preventDefault();
+        e.stopPropagation();
+
+        // Close other open popovers
+        for (const p of timeline.querySelectorAll('.item-actions__mark-read-popover:not([hidden])')) {
+          if (p !== caret.nextElementSibling) p.hidden = true;
+        }
+
+        const popover = caret.nextElementSibling;
+        if (popover) popover.hidden = !popover.hidden;
+      });
+
+      // Handle mark-source-read button
+      timeline.addEventListener('click', async (e) => {
+        const button = e.target.closest('.item-actions__mark-source-read');
+        if (!button) return;
+
+        e.preventDefault();
+        e.stopPropagation();
+
+        const feedId = button.dataset.feedId;
+        const channelUid = button.dataset.channelUid;
+        const channelId = button.dataset.channelId;
+        if (!feedId || (!channelUid && !channelId)) return;
+
+        button.disabled = true;
+
+        try {
+          const formData = new URLSearchParams();
+          formData.append('action', 'timeline');
+          formData.append('method', 'mark_read_source');
+          formData.append('channel', channelUid || channelId);
+          formData.append('feed', feedId);
+
+          const response = await fetch(microsubApiUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: formData.toString(),
+            credentials: 'same-origin'
+          });
+
+          if (response.ok) {
+            // Animate out all cards from this feed
+            const cards = timeline.querySelectorAll(`.item-card[data-feed-id="${feedId}"]`);
+            for (const card of cards) {
+              card.style.transition = 'opacity 0.3s ease, transform 0.3s ease';
+              card.style.opacity = '0';
+              card.style.transform = 'translateX(-20px)';
+            }
+            setTimeout(() => {
+              for (const card of [...cards]) {
+                const wrapper = card.closest('.timeline-view__item');
+                if (wrapper) wrapper.remove();
+                else card.remove();
+              }
+              if (timeline.querySelectorAll('.item-card').length === 0) {
+                location.reload();
+              }
+            }, 300);
+          } else {
+            button.disabled = false;
+          }
+        } catch (error) {
+          console.error('Error marking source as read:', error);
+          button.disabled = false;
+        }
+      });
+
+      // Close popovers on outside click
+      document.addEventListener('click', (e) => {
+        if (!e.target.closest('.item-actions__mark-read-group')) {
+          for (const p of timeline.querySelectorAll('.item-actions__mark-read-popover:not([hidden])')) {
+            p.hidden = true;
+          }
+        }
+      });
+
       // Handle save-for-later buttons
       timeline.addEventListener('click', async (e) => {
         const button = e.target.closest('.item-actions__save-later');