@rmdes/indiekit-endpoint-microsub 1.0.55 → 1.0.57

package/lib/controllers/reader/compose.js

@@ -0,0 +1,242 @@
+/**
+ * Micropub compose
+ * @module controllers/reader/compose
+ */
+
+import { classifyUrl } from "../../utils/source-type.js";
+
+/**
+ * Ensure value is a string URL
+ * @param {string|object|undefined} value - Value to check
+ * @returns {string|undefined} String value or undefined
+ */
+function ensureString(value) {
+  if (!value) return;
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && value.url) return value.url;
+  return String(value);
+}
+
+/**
+ * Fetch syndication targets from Micropub config
+ * @param {object} application - Indiekit application
+ * @param {string} token - Auth token
+ * @returns {Promise<Array>} Syndication targets
+ */
+async function getSyndicationTargets(application, token) {
+  try {
+    const micropubEndpoint = application.micropubEndpoint;
+    if (!micropubEndpoint) return [];
+
+    const micropubUrl = micropubEndpoint.startsWith("http")
+      ? micropubEndpoint
+      : new URL(micropubEndpoint, application.url).href;
+
+    const configUrl = `${micropubUrl}?q=config`;
+    const configResponse = await fetch(configUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    });
+
+    if (!configResponse.ok) return [];
+
+    const config = await configResponse.json();
+    return config["syndicate-to"] || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Compose response form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function compose(request, response) {
+  const { application } = request.app.locals;
+
+  // Support both long-form (replyTo) and short-form (reply) query params
+  const {
+    replyTo,
+    reply,
+    likeOf,
+    like,
+    repostOf,
+    repost,
+    bookmarkOf,
+    bookmark,
+  } = request.query;
+
+  // Fetch syndication targets if user is authenticated
+  const token = request.session?.access_token;
+  const syndicationTargets = token
+    ? await getSyndicationTargets(application, token)
+    : [];
+
+  // Auto-select syndication target based on interaction URL protocol
+  const interactionUrl = ensureString(replyTo || reply || likeOf || like || repostOf || repost);
+  if (interactionUrl && syndicationTargets.length > 0) {
+    const protocol = classifyUrl(interactionUrl).protocol;
+    for (const target of syndicationTargets) {
+      const targetId = (target.uid || target.name || "").toLowerCase();
+      if (protocol === "atmosphere" && (targetId.includes("bluesky") || targetId.includes("bsky"))) {
+        target.checked = true;
+      } else if (protocol === "fediverse" && (targetId.includes("mastodon") || targetId.includes("mstdn"))) {
+        target.checked = true;
+      }
+    }
+  }
+
+  response.render("compose", {
+    title: request.__("microsub.compose.title"),
+    replyTo: ensureString(replyTo || reply),
+    likeOf: ensureString(likeOf || like),
+    repostOf: ensureString(repostOf || repost),
+    bookmarkOf: ensureString(bookmarkOf || bookmark),
+    syndicationTargets,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Compose" },
+    ],
+  });
+}
+
+/**
+ * Submit composed response via Micropub
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function submitCompose(request, response) {
+  const { application } = request.app.locals;
+  const { content } = request.body;
+  const inReplyTo = request.body["in-reply-to"];
+  const likeOf = request.body["like-of"];
+  const repostOf = request.body["repost-of"];
+  const bookmarkOf = request.body["bookmark-of"];
+  const syndicateTo = request.body["mp-syndicate-to"];
+
+  // Get Micropub endpoint
+  const micropubEndpoint = application.micropubEndpoint;
+  if (!micropubEndpoint) {
+    return response.status(500).render("error", {
+      title: "Error",
+      content: "Micropub endpoint not configured",
+    });
+  }
+
+  // Build absolute Micropub URL
+  const micropubUrl = micropubEndpoint.startsWith("http")
+    ? micropubEndpoint
+    : new URL(micropubEndpoint, application.url).href;
+
+  // Get auth token from session
+  const token = request.session?.access_token;
+  if (!token) {
+    return response.redirect("/session/login?redirect=" + request.originalUrl);
+  }
+
+  // Build Micropub request body
+  const micropubData = new URLSearchParams();
+  micropubData.append("h", "entry");
+
+  if (likeOf) {
+    // Like post - content is optional comment
+    micropubData.append("like-of", likeOf);
+    if (content && content.trim()) {
+      micropubData.append("content", content.trim());
+    }
+  } else if (repostOf) {
+    // Repost - content is optional comment
+    micropubData.append("repost-of", repostOf);
+    if (content && content.trim()) {
+      micropubData.append("content", content.trim());
+    }
+  } else if (bookmarkOf) {
+    // Bookmark - content is optional comment
+    micropubData.append("bookmark-of", bookmarkOf);
+    if (content && content.trim()) {
+      micropubData.append("content", content.trim());
+    }
+  } else if (inReplyTo) {
+    // Reply
+    micropubData.append("in-reply-to", inReplyTo);
+    micropubData.append("content", content || "");
+  } else {
+    // Regular note
+    micropubData.append("content", content || "");
+  }
+
+  // Add syndication targets
+  if (syndicateTo) {
+    const targets = Array.isArray(syndicateTo) ? syndicateTo : [syndicateTo];
+    for (const target of targets) {
+      micropubData.append("mp-syndicate-to", target);
+    }
+  }
+
+  try {
+    const micropubResponse = await fetch(micropubUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+      },
+      body: micropubData.toString(),
+    });
+
+    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"}`,
+      );
+
+      // Redirect back to reader with success message
+      return response.redirect(`${request.baseUrl}/channels`);
+    }
+
+    // Handle error
+    const errorBody = await micropubResponse.text();
+    const statusText = micropubResponse.statusText || "Unknown error";
+    console.error(
+      `[Microsub] Micropub error: ${micropubResponse.status} ${errorBody}`,
+    );
+
+    // Parse error message from response body if JSON
+    let errorMessage = `Micropub error: ${statusText}`;
+    try {
+      const errorJson = JSON.parse(errorBody);
+      if (errorJson.error_description) {
+        errorMessage = String(errorJson.error_description);
+      } else if (errorJson.error) {
+        errorMessage = String(errorJson.error);
+      }
+    } catch {
+      // Not JSON, use status text
+    }
+
+    return response.status(micropubResponse.status).render("error", {
+      title: "Error",
+      content: errorMessage,
+    });
+  } catch (error) {
+    console.error(`[Microsub] Micropub request failed: ${error.message}`);
+
+    return response.status(500).render("error", {
+      title: "Error",
+      content: `Failed to create post: ${error.message}`,
+    });
+  }
+}

package/lib/controllers/reader/deck.js

@@ -0,0 +1,129 @@
+/**
+ * Deck view
+ * @module controllers/reader/deck
+ */
+
+import { getChannelsWithColors } from "../../storage/channels.js";
+import { getTimelineItems } from "../../storage/items.js";
+import { getDeckConfig, saveDeckConfig } from "../../storage/deck.js";
+import { getUserId } from "../../utils/auth.js";
+import { proxyItemImages } from "../../media/proxy.js";
+
+/**
+ * Deck view - TweetDeck-style columns
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function deck(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channelList = await getChannelsWithColors(application, userId);
+  const deckConfig = await getDeckConfig(application, userId);
+
+  // Determine which channels to show as columns
+  let columnChannels;
+  if (deckConfig?.columns?.length > 0) {
+    // Use saved config order
+    const channelMap = new Map(channelList.map((ch) => [ch._id.toString(), ch]));
+    columnChannels = deckConfig.columns
+      .map((col) => channelMap.get(col.channelId.toString()))
+      .filter(Boolean);
+  } else {
+    // Default: all channels except notifications
+    columnChannels = channelList.filter((ch) => ch.uid !== "notifications");
+  }
+
+  // Fetch items for each column (limited to 10 per column for performance)
+  // Batch in groups of 4 to avoid overwhelming MongoDB with parallel queries
+  const proxyBaseUrl = application.url;
+  const columns = [];
+  for (let i = 0; i < columnChannels.length; i += 4) {
+    const batch = columnChannels.slice(i, i + 4);
+    const batchResults = await Promise.all(
+      batch.map(async (channel) => {
+        const result = await getTimelineItems(application, channel._id, {
+          userId,
+          limit: 10,
+        });
+
+        if (proxyBaseUrl && result.items) {
+          result.items = result.items.map((item) =>
+            proxyItemImages(item, proxyBaseUrl),
+          );
+        }
+
+        return {
+          channel,
+          items: result.items,
+          paging: result.paging,
+        };
+      }),
+    );
+    columns.push(...batchResults);
+  }
+
+  // Set view preference cookie
+  if (request.session) request.session.microsubView = "deck";
+
+  response.render("deck", {
+    title: "Deck",
+    columns,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "deck",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Deck" },
+    ],
+  });
+}
+
+/**
+ * Deck settings page
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function deckSettings(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channelList = await getChannelsWithColors(application, userId);
+  const deckConfig = await getDeckConfig(application, userId);
+
+  const selectedIds = deckConfig?.columns
+    ? deckConfig.columns.map((col) => col.channelId.toString())
+    : channelList.filter((ch) => ch.uid !== "notifications").map((ch) => ch._id.toString());
+
+  response.render("deck-settings", {
+    title: "Deck settings",
+    channels: channelList,
+    selectedIds,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "deck",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Deck", href: `${request.baseUrl}/deck` },
+      { text: "Settings" },
+    ],
+  });
+}
+
+/**
+ * Save deck settings
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function saveDeckSettings(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  let { columns } = request.body;
+  if (!columns) columns = [];
+  if (!Array.isArray(columns)) columns = [columns];
+
+  await saveDeckConfig(application, userId, columns);
+
+  response.redirect(`${request.baseUrl}/deck`);
+}

package/lib/controllers/reader/feed-repair.js

@@ -0,0 +1,117 @@
+/**
+ * Feed repair operations (rediscover + force refresh)
+ * @module controllers/reader/feed-repair
+ */
+
+import { discoverAndValidateFeeds, getBestFeed } from "../../feeds/discovery.js";
+import { refreshFeedNow } from "../../polling/scheduler.js";
+import { getChannel } from "../../storage/channels.js";
+import { getFeedById, updateFeed, updateFeedStatus } from "../../storage/feeds.js";
+import { getUserId } from "../../utils/auth.js";
+
+/**
+ * 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`);
+}