@rmdes/indiekit-endpoint-activitypub 3.6.2 → 3.6.4

package/lib/mastodon/backfill-timeline.js

@@ -21,6 +21,7 @@ export async function backfillTimeline(collections) {
 
   // Get local profile for author info
   const profile = await ap_profile?.findOne({});
+  const siteUrl = profile?.url?.replace(/\/$/, "") || "";
   const author = profile
     ? {
         name: profile.name || "",
@@ -58,24 +59,30 @@ export async function backfillTimeline(collections) {
       continue;
     }
 
-    // Map JF2 properties to timeline item format
-    const content = normalizeContent(props.content);
+    // Build content — interaction types (bookmark, like, repost) may not have
+    // body content, so synthesize it from the interaction target URL
+    const content = buildContent(props);
     const type = mapPostType(props["post-type"]);
 
+    // Extract categories + inline hashtags from content
+    const categories = normalizeArray(props.category);
+    const inlineHashtags = extractHashtags(content.text + " " + (content.html || ""));
+    const mergedCategories = mergeCategories(categories, inlineHashtags);
+
     const timelineItem = {
       uid,
       url: uid,
       type,
-      content,
+      content: rewriteHashtagLinks(content, siteUrl),
       author,
       published: props.published || props.date || new Date().toISOString(),
       createdAt: props.published || props.date || new Date().toISOString(),
       visibility: "public",
       sensitive: false,
-      category: normalizeArray(props.category),
-      photo: normalizeMediaArray(props.photo),
-      video: normalizeMediaArray(props.video),
-      audio: normalizeMediaArray(props.audio),
+      category: mergedCategories,
+      photo: normalizeMediaArray(props.photo, siteUrl),
+      video: normalizeMediaArray(props.video, siteUrl),
+      audio: normalizeMediaArray(props.audio, siteUrl),
       readBy: [],
     };
 
@@ -107,6 +114,55 @@ export async function backfillTimeline(collections) {
   return { total: allPosts.length, inserted, skipped };
 }
 
+// ─── Content Building ─────────────────────────────────────────────────────────
+
+/**
+ * Build content from JF2 properties, synthesizing content for interaction types.
+ * Bookmarks, likes, and reposts often have no body text — show the target URL.
+ */
+function buildContent(props) {
+  const raw = normalizeContent(props.content);
+
+  // If there's already content, use it
+  if (raw.text || raw.html) return raw;
+
+  // Synthesize content for interaction types
+  const bookmarkOf = props["bookmark-of"];
+  const likeOf = props["like-of"];
+  const repostOf = props["repost-of"];
+  const name = props.name;
+
+  if (bookmarkOf) {
+    const label = name || bookmarkOf;
+    return {
+      text: `Bookmarked: ${label}`,
+      html: `<p>Bookmarked: <a href="${escapeHtml(bookmarkOf)}">${escapeHtml(label)}</a></p>`,
+    };
+  }
+
+  if (likeOf) {
+    return {
+      text: `Liked: ${likeOf}`,
+      html: `<p>Liked: <a href="${escapeHtml(likeOf)}">${escapeHtml(likeOf)}</a></p>`,
+    };
+  }
+
+  if (repostOf) {
+    const label = name || repostOf;
+    return {
+      text: `Reposted: ${label}`,
+      html: `<p>Reposted: <a href="${escapeHtml(repostOf)}">${escapeHtml(label)}</a></p>`,
+    };
+  }
+
+  // Article with title but no body
+  if (name) {
+    return { text: name, html: `<p>${escapeHtml(name)}</p>` };
+  }
+
+  return raw;
+}
+
 /**
  * Normalize content from JF2 properties to { text, html } format.
  */
@@ -122,6 +178,58 @@ function normalizeContent(content) {
   return { text: "", html: "" };
 }
 
+// ─── Hashtag Handling ─────────────────────────────────────────────────────────
+
+/**
+ * Extract hashtags from text content.
+ * Matches #word patterns, returns lowercase tag names without the # prefix.
+ */
+function extractHashtags(text) {
+  if (!text) return [];
+  const matches = text.match(/(?:^|\s)#([a-zA-Z_]\w*)/g);
+  if (!matches) return [];
+  return [...new Set(matches.map((m) => m.trim().slice(1).toLowerCase()))];
+}
+
+/**
+ * Merge explicit categories with inline hashtags (deduplicated, case-insensitive).
+ */
+function mergeCategories(categories, hashtags) {
+  const seen = new Set(categories.map((c) => c.toLowerCase()));
+  const result = [...categories];
+  for (const tag of hashtags) {
+    if (!seen.has(tag)) {
+      seen.add(tag);
+      result.push(tag);
+    }
+  }
+  return result;
+}
+
+/**
+ * Rewrite hashtag links in HTML from site-internal (/categories/tag/) to
+ * Mastodon-compatible format. Mastodon clients use the tag objects, not
+ * inline links, but having correct href helps with link following.
+ */
+function rewriteHashtagLinks(content, siteUrl) {
+  if (!content.html) return content;
+  // Rewrite /categories/tag/ links to /tags/tag (Mastodon convention)
+  let html = content.html.replace(
+    /href="\/categories\/([^/"]+)\/?"/g,
+    (_, tag) => `href="${siteUrl}/tags/${tag}" class="hashtag" rel="tag"`,
+  );
+  // Also rewrite absolute site category links
+  if (siteUrl) {
+    html = html.replace(
+      new RegExp(`href="${escapeRegex(siteUrl)}/categories/([^/"]+)/?"`, "g"),
+      (_, tag) => `href="${siteUrl}/tags/${tag}" class="hashtag" rel="tag"`,
+    );
+  }
+  return { ...content, html };
+}
+
+// ─── Post Type Mapping ────────────────────────────────────────────────────────
+
 /**
  * Map Micropub post-type to timeline type.
  */
@@ -138,12 +246,15 @@ function mapPostType(postType) {
     case "repost":
       return "boost";
     case "like":
+    case "bookmark":
       return "note";
     default:
       return "note";
   }
 }
 
+// ─── Normalization Helpers ────────────────────────────────────────────────────
+
 /**
  * Normalize a value to an array of strings.
  */
@@ -154,14 +265,47 @@ function normalizeArray(value) {
 }
 
 /**
- * Normalize media values (can be strings or objects with url property).
+ * Normalize media values — resolves relative URLs to absolute.
+ *
+ * @param {*} value - String, object with url, or array thereof
+ * @param {string} siteUrl - Base site URL for resolving relative paths
  */
-function normalizeMediaArray(value) {
+function normalizeMediaArray(value, siteUrl) {
   if (!value) return [];
   const arr = Array.isArray(value) ? value : [value];
   return arr.map((item) => {
-    if (typeof item === "string") return item;
-    if (typeof item === "object" && item.url) return item;
+    if (typeof item === "string") return resolveUrl(item, siteUrl);
+    if (typeof item === "object" && item.url) {
+      return { ...item, url: resolveUrl(item.url, siteUrl) };
+    }
     return null;
   }).filter(Boolean);
 }
+
+/**
+ * Resolve a URL — if relative, prepend the site URL.
+ */
+function resolveUrl(url, siteUrl) {
+  if (!url) return url;
+  if (url.startsWith("http://") || url.startsWith("https://")) return url;
+  if (url.startsWith("/")) return `${siteUrl}${url}`;
+  return `${siteUrl}/${url}`;
+}
+
+/**
+ * Escape HTML entities.
+ */
+function escapeHtml(str) {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+/**
+ * Escape regex special characters.
+ */
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/lib/mastodon/helpers/resolve-account.js

@@ -0,0 +1,79 @@
+/**
+ * Resolve a remote account via WebFinger + ActivityPub actor fetch.
+ * Uses the Fedify federation instance to perform discovery.
+ *
+ * Shared by accounts.js (lookup) and search.js (resolve=true).
+ */
+import { serializeAccount } from "../entities/account.js";
+
+/**
+ * @param {string} acct - Account identifier (user@domain or URL)
+ * @param {object} pluginOptions - Plugin options with federation, handle, publicationUrl
+ * @param {string} baseUrl - Server base URL
+ * @returns {Promise<object|null>} Serialized Mastodon Account or null
+ */
+export async function resolveRemoteAccount(acct, pluginOptions, baseUrl) {
+  const { federation, handle, publicationUrl } = pluginOptions;
+  if (!federation) return null;
+
+  try {
+    const ctx = federation.createContext(
+      new URL(publicationUrl),
+      { handle, publicationUrl },
+    );
+
+    // Determine lookup URI
+    let actorUri;
+    if (acct.includes("@")) {
+      const parts = acct.replace(/^@/, "").split("@");
+      const username = parts[0];
+      const domain = parts[1];
+      if (!username || !domain) return null;
+      actorUri = `acct:${username}@${domain}`;
+    } else if (acct.startsWith("http")) {
+      actorUri = acct;
+    } else {
+      return null;
+    }
+
+    const actor = await ctx.lookupObject(actorUri);
+    if (!actor) return null;
+
+    // Extract data from the Fedify actor object
+    const name = actor.name?.toString() || actor.preferredUsername?.toString() || "";
+    const actorUrl = actor.id?.href || "";
+    const username = actor.preferredUsername?.toString() || "";
+    const domain = actorUrl ? new URL(actorUrl).hostname : "";
+    const summary = actor.summary?.toString() || "";
+
+    // Get avatar
+    let avatarUrl = "";
+    try {
+      const icon = await actor.getIcon();
+      avatarUrl = icon?.url?.href || "";
+    } catch { /* ignore */ }
+
+    // Get header image
+    let headerUrl = "";
+    try {
+      const image = await actor.getImage();
+      headerUrl = image?.url?.href || "";
+    } catch { /* ignore */ }
+
+    return serializeAccount(
+      {
+        name,
+        url: actorUrl,
+        photo: avatarUrl,
+        handle: `@${username}@${domain}`,
+        summary,
+        image: headerUrl,
+        bot: actor.constructor?.name === "Service" || actor.constructor?.name === "Application",
+      },
+      { baseUrl },
+    );
+  } catch (error) {
+    console.warn(`[Mastodon API] Remote account resolution failed for ${acct}:`, error.message);
+    return null;
+  }
+}

package/lib/mastodon/routes/accounts.js

@@ -9,6 +9,7 @@ import { serializeCredentialAccount, serializeAccount } from "../entities/accoun
 import { serializeStatus } from "../entities/status.js";
 import { accountId, remoteActorId } from "../helpers/id-mapping.js";
 import { buildPaginationQuery, parseLimit, setPaginationHeaders } from "../helpers/pagination.js";
+import { resolveRemoteAccount } from "../helpers/resolve-account.js";
 
 const router = express.Router(); // eslint-disable-line new-cap
 
@@ -100,7 +101,7 @@ router.get("/api/v1/accounts/lookup", async (req, res, next) => {
       }
     }
 
-    // Check followers/following for known remote actors
+    // Check followers for known remote actors
     const follower = await collections.ap_followers.findOne({
       $or: [
         { handle: `@${bareAcct}` },
@@ -116,6 +117,38 @@ router.get("/api/v1/accounts/lookup", async (req, res, next) => {
       );
     }
 
+    // Check following
+    const following = await collections.ap_following.findOne({
+      $or: [
+        { handle: `@${bareAcct}` },
+        { handle: bareAcct },
+      ],
+    });
+    if (following) {
+      return res.json(
+        serializeAccount(
+          { name: following.name, url: following.actorUrl, photo: following.avatar, handle: following.handle },
+          { baseUrl },
+        ),
+      );
+    }
+
+    // Check timeline authors (people whose posts are in our timeline)
+    const timelineAuthor = await collections.ap_timeline.findOne({
+      "author.handle": { $in: [`@${bareAcct}`, bareAcct] },
+    });
+    if (timelineAuthor?.author) {
+      return res.json(
+        serializeAccount(timelineAuthor.author, { baseUrl }),
+      );
+    }
+
+    // Resolve remotely via federation (WebFinger + actor fetch)
+    const resolved = await resolveRemoteAccount(bareAcct, pluginOptions, baseUrl);
+    if (resolved) {
+      return res.json(resolved);
+    }
+
     return res.status(404).json({ error: "Record not found" });
   } catch (error) {
     next(error);

package/lib/mastodon/routes/search.js

@@ -7,6 +7,7 @@ import express from "express";
 import { serializeStatus } from "../entities/status.js";
 import { serializeAccount } from "../entities/account.js";
 import { parseLimit } from "../helpers/pagination.js";
+import { resolveRemoteAccount } from "../helpers/resolve-account.js";
 
 const router = express.Router(); // eslint-disable-line new-cap
 
@@ -21,6 +22,9 @@ router.get("/api/v2/search", async (req, res, next) => {
     const limit = parseLimit(req.query.limit);
     const offset = Math.max(0, Number.parseInt(req.query.offset, 10) || 0);
 
+    const resolve = req.query.resolve === "true";
+    const pluginOptions = req.app.locals.mastodonPluginOptions || {};
+
     if (!query) {
       return res.json({ accounts: [], statuses: [], hashtags: [] });
     }
@@ -75,6 +79,14 @@ router.get("/api/v2/search", async (req, res, next) => {
         }
         if (results.accounts.length >= limit) break;
       }
+
+      // If no local results and resolve=true, try remote lookup
+      if (results.accounts.length === 0 && resolve && query.includes("@")) {
+        const resolved = await resolveRemoteAccount(query, pluginOptions, baseUrl);
+        if (resolved) {
+          results.accounts.push(resolved);
+        }
+      }
     }
 
     // ─── Status search ───────────────────────────────────────────────────

package/lib/mastodon/routes/statuses.js

@@ -219,6 +219,34 @@ router.post("/api/v1/statuses", async (req, res, next) => {
     const handle = pluginOptions.handle || "user";
     const actorUrl = profile?.url || `${publicationUrl}/users/${handle}`;
 
+    // Extract hashtags from status text and merge with any Micropub categories
+    const categories = data.properties.category || [];
+    const inlineHashtags = (statusText || "").match(/(?:^|\s)#([a-zA-Z_]\w*)/g);
+    if (inlineHashtags) {
+      const existing = new Set(categories.map((c) => c.toLowerCase()));
+      for (const match of inlineHashtags) {
+        const tag = match.trim().slice(1).toLowerCase();
+        if (!existing.has(tag)) {
+          existing.add(tag);
+          categories.push(tag);
+        }
+      }
+    }
+
+    // Resolve relative media URLs to absolute
+    const resolveMedia = (items) => {
+      if (!items || !items.length) return [];
+      return items.map((item) => {
+        if (typeof item === "string") {
+          return item.startsWith("http") ? item : `${publicationUrl.replace(/\/$/, "")}/${item.replace(/^\//, "")}`;
+        }
+        if (item?.url && !item.url.startsWith("http")) {
+          return { ...item, url: `${publicationUrl.replace(/\/$/, "")}/${item.url.replace(/^\//, "")}` };
+        }
+        return item;
+      });
+    };
+
     const now = new Date().toISOString();
     const timelineItem = await addTimelineItem(collections, {
       uid: postUrl,
@@ -234,16 +262,16 @@ router.post("/api/v1/statuses", async (req, res, next) => {
       createdAt: now,
       author: {
         name: profile?.name || handle,
-        url: actorUrl,
+        url: profile?.url || publicationUrl,
         photo: profile?.icon || "",
         handle: `@${handle}`,
         emojis: [],
         bot: false,
       },
-      photo: data.properties.photo || [],
-      video: data.properties.video || [],
-      audio: data.properties.audio || [],
-      category: data.properties.category || [],
+      photo: resolveMedia(data.properties.photo || []),
+      video: resolveMedia(data.properties.video || []),
+      audio: resolveMedia(data.properties.audio || []),
+      category: categories,
       counts: { replies: 0, boosts: 0, likes: 0 },
       linkPreviews: [],
       mentions: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-activitypub",
-  "version": "3.6.2",
+  "version": "3.6.4",
   "description": "ActivityPub federation endpoint for Indiekit via Fedify. Adds full fediverse support: actor, inbox, outbox, followers, following, syndication, and Mastodon migration.",
   "keywords": [
     "indiekit",