@rmdes/indiekit-syndicator-bluesky 1.0.1 → 1.0.3

package/lib/bluesky.js

@@ -1,5 +1,4 @@
 import { AtpAgent } from "@atproto/api";
-import { IndiekitError } from "@indiekit/error";
 import { getCanonicalUrl, isSameOrigin } from "@indiekit/util";
 
 import {
@@ -9,6 +8,8 @@ import {
   getLikePostText,
   getPostParts,
   uriToPostUrl,
+  fetchOpenGraphData,
+  getExternalUrl,
 } from "./utils.js";
 
 export class Bluesky {
@@ -121,26 +122,109 @@ export class Bluesky {
     return uriToPostUrl(this.profileUrl, quotePost.uri);
   }
 
+  /**
+   * Upload image from URL (for OG thumbnails)
+   * @param {string} imageUrl - URL of image to upload
+   * @returns {Promise<object|null>} Blob reference or null
+   */
+  async uploadImageFromUrl(imageUrl) {
+    if (!imageUrl) return null;
+
+    try {
+      const client = await this.#client();
+      const response = await fetch(imageUrl, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; IndiekitBot/1.0)",
+        },
+        redirect: "follow",
+      });
+
+      if (!response.ok) return null;
+
+      let blob = await response.blob();
+      let encoding = response.headers.get("Content-Type") || "image/jpeg";
+
+      // Compress if needed
+      if (encoding?.startsWith("image/")) {
+        const buffer = Buffer.from(await blob.arrayBuffer());
+        const image = await getPostImage(buffer, encoding);
+        blob = new Blob([new Uint8Array(image.buffer)], {
+          type: image.mimeType,
+        });
+        encoding = image.mimeType;
+      }
+
+      const uploadResponse = await client.com.atproto.repo.uploadBlob(blob, {
+        encoding,
+      });
+
+      return uploadResponse.data.blob;
+    } catch (error) {
+      console.error(`Failed to upload OG image: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Create external link embed
+   * @param {string} url - External URL
+   * @returns {Promise<object|null>} External embed or null
+   */
+  async createExternalEmbed(url) {
+    if (!url) return null;
+
+    try {
+      const ogData = await fetchOpenGraphData(url);
+      let thumb = null;
+
+      if (ogData.imageUrl) {
+        thumb = await this.uploadImageFromUrl(ogData.imageUrl);
+      }
+
+      return {
+        $type: "app.bsky.embed.external",
+        external: {
+          uri: url,
+          title: ogData.title || url,
+          description: ogData.description || "",
+          ...(thumb && { thumb }),
+        },
+      };
+    } catch (error) {
+      console.error(`Failed to create external embed: ${error.message}`);
+      return null;
+    }
+  }
+
   /**
    * Post a regular post
    * @param {object} richText - Rich text
-   * @param {Array} [images] - Images
+   * @param {object} [options] - Post options
+   * @param {Array} [options.images] - Images
+   * @param {object} [options.externalEmbed] - External link embed
    * @returns {Promise<string>} Bluesky post URL
    */
-  async postPost(richText, images) {
+  async postPost(richText, options = {}) {
     const client = await this.#client();
+    const { images, externalEmbed } = options;
+
+    // Determine embed type - images take priority over external
+    let embed = null;
+    if (images?.length > 0) {
+      embed = {
+        $type: "app.bsky.embed.images",
+        images,
+      };
+    } else if (externalEmbed) {
+      embed = externalEmbed;
+    }
 
     const postData = {
       $type: "app.bsky.feed.post",
       text: richText.text,
       facets: richText.facets,
       createdAt: new Date().toISOString(),
-      ...(images?.length > 0 && {
-        embed: {
-          $type: "app.bsky.embed.images",
-          images,
-        },
-      }),
+      ...(embed && { embed }),
     };
 
     const post = await client.post(postData);
@@ -166,7 +250,7 @@ export class Bluesky {
       const mediaResponse = await fetch(mediaUrl);
 
       if (!mediaResponse.ok) {
-        throw await IndiekitError.fromFetch(mediaResponse);
+        throw new Error(`Failed to fetch media: ${mediaResponse.status} ${mediaResponse.statusText}`);
       }
 
       let blob = await mediaResponse.blob();
@@ -235,21 +319,43 @@ export class Bluesky {
           return this.postLike(likeOfUrl);
         }
 
-        // NEW: Syndicate likes of external URLs as posts
+        // Syndicate likes of external URLs as posts with link card
         if (this.syndicateExternalLikes) {
           const text = getLikePostText(properties, likeOfUrl);
           const richText = await createRichText(client, text);
-          return this.postPost(richText, images);
+          // Create external embed for the liked URL
+          const externalEmbed = await this.createExternalEmbed(likeOfUrl);
+          return this.postPost(richText, { images, externalEmbed });
         }
 
         // Don't syndicate if option is disabled
         return;
       }
 
-      // Regular post
+      // Handle bookmarks - similar to likes but with bookmark-of
+      const bookmarkOfUrl = properties["bookmark-of"];
+      if (bookmarkOfUrl) {
+        const text = getPostText(properties, this.includePermalink);
+        const richText = await createRichText(client, text);
+        // Create external embed for the bookmarked URL
+        const externalEmbed = await this.createExternalEmbed(bookmarkOfUrl);
+        return this.postPost(richText, { images, externalEmbed });
+      }
+
+      // Regular post - check for external URL in content to create link card
       const text = getPostText(properties, this.includePermalink);
       const richText = await createRichText(client, text);
-      return this.postPost(richText, images);
+
+      // If no images, try to create external embed from URLs in content
+      let externalEmbed = null;
+      if (!images?.length) {
+        const externalUrl = getExternalUrl(properties);
+        if (externalUrl) {
+          externalEmbed = await this.createExternalEmbed(externalUrl);
+        }
+      }
+
+      return this.postPost(richText, { images, externalEmbed });
     } catch (error) {
       throw new Error(error.message);
     }

package/lib/utils.js

@@ -1,6 +1,7 @@
 import { RichText } from "@atproto/api";
 import { htmlToText } from "html-to-text";
 import sharp from "sharp";
+import { JSDOM } from "jsdom";
 
 const AT_URI = /at:\/\/(?<did>did:[^/]+)\/(?<type>[^/]+)\/(?<rkey>[^/]+)/;
 
@@ -160,3 +161,95 @@ export const htmlToStatusText = (html) => {
   const statusText = lastHref ? `${text} ${lastHref}` : text;
   return statusText;
 };
+
+/**
+ * Fetch OpenGraph metadata from a URL
+ * @param {string} url - URL to fetch OG data from
+ * @returns {Promise<{title: string, description: string, imageUrl: string|null}>} OG metadata
+ */
+export async function fetchOpenGraphData(url) {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; IndiekitBot/1.0)",
+        Accept: "text/html,application/xhtml+xml",
+      },
+      redirect: "follow",
+      timeout: 10000,
+    });
+
+    if (!response.ok) {
+      return { title: url, description: "", imageUrl: null };
+    }
+
+    const html = await response.text();
+    const dom = new JSDOM(html);
+    const doc = dom.window.document;
+
+    // Get OG title, fallback to regular title
+    const ogTitle =
+      doc.querySelector('meta[property="og:title"]')?.getAttribute("content") ||
+      doc.querySelector("title")?.textContent ||
+      url;
+
+    // Get OG description, fallback to meta description
+    const ogDescription =
+      doc
+        .querySelector('meta[property="og:description"]')
+        ?.getAttribute("content") ||
+      doc.querySelector('meta[name="description"]')?.getAttribute("content") ||
+      "";
+
+    // Get OG image
+    let ogImage =
+      doc.querySelector('meta[property="og:image"]')?.getAttribute("content") ||
+      null;
+
+    // Handle relative URLs for image
+    if (ogImage && !ogImage.startsWith("http")) {
+      const baseUrl = new URL(url);
+      ogImage = new URL(ogImage, baseUrl.origin).href;
+    }
+
+    return {
+      title: ogTitle.slice(0, 300), // Bluesky title limit
+      description: ogDescription.slice(0, 1000), // Reasonable limit
+      imageUrl: ogImage,
+    };
+  } catch (error) {
+    console.error(`Failed to fetch OG data for ${url}:`, error.message);
+    return { title: url, description: "", imageUrl: null };
+  }
+}
+
+/**
+ * Extract the primary URL from post properties
+ * @param {object} properties - JF2 properties
+ * @returns {string|null} Primary URL to create card for
+ */
+export function getExternalUrl(properties) {
+  // For likes, use the liked URL
+  if (properties["like-of"]) {
+    return properties["like-of"];
+  }
+
+  // For bookmarks, use the bookmarked URL
+  if (properties["bookmark-of"]) {
+    return properties["bookmark-of"];
+  }
+
+  // For replies, use the in-reply-to URL
+  if (properties["in-reply-to"]) {
+    return properties["in-reply-to"];
+  }
+
+  // For regular posts with content, try to extract URL from content
+  if (properties.content?.html) {
+    const hrefs = [...properties.content.html.matchAll(/href="(https?:\/\/[^"]+)"/g)];
+    if (hrefs.length > 0) {
+      return hrefs.at(-1)[1];
+    }
+  }
+
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-syndicator-bluesky",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Bluesky syndicator for Indiekit with external like support",
   "type": "module",
   "main": "index.js",
@@ -20,6 +20,8 @@
   },
   "dependencies": {
     "@atproto/api": "^0.14.0",
+    "html-to-text": "^9.0.0",
+    "jsdom": "^24.0.0",
     "sharp": "^0.33.0"
   },
   "peerDependencies": {