@rmdes/indiekit-endpoint-microsub 1.0.56 → 1.0.57

package/lib/controllers/reader/actor.js

@@ -0,0 +1,142 @@
+/**
+ * ActivityPub actor profiles
+ * @module controllers/reader/actor
+ */
+
+import { fetchActorOutbox } from "../../activitypub/outbox-fetcher.js";
+
+const ACTOR_OUTBOX_LIMIT = 30;
+
+/**
+ * Find the ActivityPub plugin instance from installed plugins.
+ * @param {object} request - Express request
+ * @returns {object|undefined} The AP plugin instance
+ */
+function getApPlugin(request) {
+  const installedPlugins = request.app.locals.installedPlugins;
+  if (!installedPlugins) return undefined;
+  return [...installedPlugins].find(
+    (p) => p.name === "ActivityPub endpoint",
+  );
+}
+
+/**
+ * Actor profile — fetch and display a remote AP actor's recent posts
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function actorProfile(request, response) {
+  const actorUrl = request.query.url;
+  if (!actorUrl) {
+    return response.status(400).render("404");
+  }
+
+  // Check if we already follow this actor
+  const { application } = request.app.locals;
+  const apFollowing = application?.collections?.get("ap_following");
+  let isFollowing = false;
+  if (apFollowing) {
+    const existing = await apFollowing.findOne({ actorUrl });
+    isFollowing = !!existing;
+  }
+
+  // Check if AP plugin is available (for follow button visibility)
+  const apPlugin = getApPlugin(request);
+  const canFollow = !!apPlugin;
+
+  try {
+    const { actor, items } = await fetchActorOutbox(actorUrl, { limit: ACTOR_OUTBOX_LIMIT });
+
+    response.render("actor", {
+      title: actor.name || "Actor",
+      actor,
+      items,
+      actorUrl,
+      isFollowing,
+      canFollow,
+      baseUrl: request.baseUrl,
+      readerBaseUrl: request.baseUrl,
+      activeView: "channels",
+      breadcrumbs: [
+        { text: "Reader", href: request.baseUrl },
+        { text: actor.name || "Actor" },
+      ],
+    });
+  } catch (error) {
+    console.error(`[Microsub] Actor profile fetch failed: ${error.message}`);
+    response.render("actor", {
+      title: "Actor",
+      actor: { name: actorUrl, url: actorUrl, photo: "", summary: "" },
+      items: [],
+      actorUrl,
+      isFollowing,
+      canFollow,
+      baseUrl: request.baseUrl,
+      readerBaseUrl: request.baseUrl,
+      activeView: "channels",
+      error: "Could not fetch this actor's profile. They may have restricted access.",
+      breadcrumbs: [
+        { text: "Reader", href: request.baseUrl },
+        { text: "Actor" },
+      ],
+    });
+  }
+}
+
+/**
+ * Follow an ActivityPub actor
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function followActorAction(request, response) {
+  const { actorUrl, actorName } = request.body;
+  if (!actorUrl) {
+    return response.status(400).redirect(request.baseUrl + "/channels/activitypub");
+  }
+
+  const apPlugin = getApPlugin(request);
+  if (!apPlugin) {
+    console.error("[Microsub] Cannot follow: ActivityPub plugin not installed");
+    return response.redirect(
+      `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+    );
+  }
+
+  const result = await apPlugin.followActor(actorUrl, { name: actorName });
+  if (!result.ok) {
+    console.error(`[Microsub] Follow via AP plugin failed: ${result.error}`);
+  }
+
+  return response.redirect(
+    `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+  );
+}
+
+/**
+ * Unfollow an ActivityPub actor
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function unfollowActorAction(request, response) {
+  const { actorUrl } = request.body;
+  if (!actorUrl) {
+    return response.status(400).redirect(request.baseUrl + "/channels/activitypub");
+  }
+
+  const apPlugin = getApPlugin(request);
+  if (!apPlugin) {
+    console.error("[Microsub] Cannot unfollow: ActivityPub plugin not installed");
+    return response.redirect(
+      `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+    );
+  }
+
+  const result = await apPlugin.unfollowActor(actorUrl);
+  if (!result.ok) {
+    console.error(`[Microsub] Unfollow via AP plugin failed: ${result.error}`);
+  }
+
+  return response.redirect(
+    `${request.baseUrl}/actor?url=${encodeURIComponent(actorUrl)}`,
+  );
+}

package/lib/controllers/reader/channel.js

@@ -0,0 +1,301 @@
+/**
+ * Channel CRUD + HTML fragments
+ * @module controllers/reader/channel
+ */
+
+import {
+  getChannels,
+  getChannel,
+  createChannel,
+  updateChannelSettings,
+  deleteChannel,
+} from "../../storage/channels.js";
+import { getFeedsForChannel } from "../../storage/feeds.js";
+import { getTimelineItems } from "../../storage/items.js";
+import { countReadItems } from "../../storage/items-read-state.js";
+import { getUserId } from "../../utils/auth.js";
+import {
+  validateChannelName,
+  validateExcludeTypes,
+  validateExcludeRegex,
+} from "../../utils/validation.js";
+import { proxyItemImages } from "../../media/proxy.js";
+
+/**
+ * Reader index - redirect to channels
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function index(request, response) {
+  const lastView = request.session?.microsubView || "timeline";
+  const validViews = ["channels", "deck", "timeline"];
+  const view = validViews.includes(lastView) ? lastView : "timeline";
+  response.redirect(`${request.baseUrl}/${view}`);
+}
+
+/**
+ * List channels
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function channels(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+
+  const channelList = await getChannels(application, userId);
+
+  if (request.session) request.session.microsubView = "channels";
+
+  response.render("reader", {
+    title: request.__("microsub.views.channels"),
+    channels: channelList,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Channels" },
+    ],
+  });
+}
+
+/**
+ * New channel form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function newChannel(request, response) {
+  response.render("channel-new", {
+    title: request.__("microsub.channels.new"),
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Channels", href: `${request.baseUrl}/channels` },
+      { text: request.__("microsub.channels.new") },
+    ],
+  });
+}
+
+/**
+ * Create channel
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ */
+export async function createChannelAction(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { name } = request.body;
+
+  validateChannelName(name);
+
+  await createChannel(application, { name, userId });
+
+  response.redirect(`${request.baseUrl}/channels`);
+}
+
+/**
+ * View channel timeline
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function channel(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+  const { before, after, showRead } = request.query;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  // Check if showing read items
+  const showReadItems = showRead === "true";
+
+  const timeline = await getTimelineItems(application, channelDocument._id, {
+    before,
+    after,
+    userId,
+    showRead: showReadItems,
+  });
+
+  // Proxy images through media endpoint for privacy
+  const proxyBaseUrl = application.url;
+  if (proxyBaseUrl && timeline.items) {
+    timeline.items = timeline.items.map((item) =>
+      proxyItemImages(item, proxyBaseUrl),
+    );
+  }
+
+  // Count read items to show "View read items" button
+  const readCount = await countReadItems(
+    application,
+    channelDocument._id,
+    userId,
+  );
+
+  response.render("channel", {
+    title: channelDocument.name,
+    channel: channelDocument,
+    items: timeline.items,
+    paging: timeline.paging,
+    readCount,
+    showRead: showReadItems,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Channels", href: `${request.baseUrl}/channels` },
+      { text: channelDocument.name },
+    ],
+  });
+}
+
+/**
+ * Return rendered HTML fragments for infinite scroll
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function channelHtml(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+  const { before, after, showRead } = request.query;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).json({ error: "Channel not found" });
+  }
+
+  const showReadItems = showRead === "true";
+
+  const timeline = await getTimelineItems(application, channelDocument._id, {
+    before,
+    after,
+    userId,
+    showRead: showReadItems,
+  });
+
+  // Proxy images
+  const proxyBaseUrl = application.url;
+  if (proxyBaseUrl && timeline.items) {
+    timeline.items = timeline.items.map((item) =>
+      proxyItemImages(item, proxyBaseUrl),
+    );
+  }
+
+  // Render items via layout-less fragment template (standard response.render
+  // with callback returns HTML string without sending a response)
+  const fragmentHtml = await new Promise((resolve, reject) => {
+    response.render("partials/items-fragment", {
+      items: timeline.items,
+      channel: channelDocument,
+      baseUrl: request.baseUrl,
+    }, (error, html) => error ? reject(error) : resolve(html));
+  });
+
+  response.json({
+    html: fragmentHtml,
+    paging: timeline.paging,
+    count: timeline.items.length,
+  });
+}
+
+/**
+ * Channel settings form
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function settings(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  response.render("settings", {
+    title: request.__("microsub.settings.title", {
+      channel: channelDocument.name,
+    }),
+    channel: channelDocument,
+    baseUrl: request.baseUrl,
+    readerBaseUrl: request.baseUrl,
+    activeView: "channels",
+    breadcrumbs: [
+      { text: "Reader", href: request.baseUrl },
+      { text: "Channels", href: `${request.baseUrl}/channels` },
+      { text: channelDocument.name, href: `${request.baseUrl}/channels/${uid}` },
+      { text: "Settings" },
+    ],
+  });
+}
+
+/**
+ * Update channel settings
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function updateSettings(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+  const { excludeTypes, excludeRegex } = request.body;
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  const validatedTypes = validateExcludeTypes(
+    Array.isArray(excludeTypes) ? excludeTypes : [excludeTypes].filter(Boolean),
+  );
+  const validatedRegex = validateExcludeRegex(excludeRegex);
+
+  await updateChannelSettings(
+    application,
+    uid,
+    {
+      excludeTypes: validatedTypes,
+      excludeRegex: validatedRegex,
+    },
+    userId,
+  );
+
+  response.redirect(`${request.baseUrl}/channels/${uid}`);
+}
+
+/**
+ * Delete channel
+ * @param {object} request - Express request
+ * @param {object} response - Express response
+ * @returns {Promise<void>}
+ */
+export async function deleteChannelAction(request, response) {
+  const { application } = request.app.locals;
+  const userId = getUserId(request);
+  const { uid } = request.params;
+
+  // Don't allow deleting system channels
+  if (uid === "notifications" || uid === "activitypub") {
+    return response.redirect(`${request.baseUrl}/channels`);
+  }
+
+  const channelDocument = await getChannel(application, uid, userId);
+  if (!channelDocument) {
+    return response.status(404).render("404");
+  }
+
+  await deleteChannel(application, uid, userId);
+
+  response.redirect(`${request.baseUrl}/channels`);
+}

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}`,
+    });
+  }
+}