@rmdes/indiekit-syndicator-bluesky 1.0.0

package/index.js

@@ -0,0 +1,110 @@
+import process from "node:process";
+import { IndiekitError } from "@indiekit/error";
+import { Bluesky } from "./lib/bluesky.js";
+
+const defaults = {
+  handle: "",
+  password: process.env.BLUESKY_PASSWORD,
+  profileUrl: "https://bsky.app/profile",
+  serviceUrl: "https://bsky.social",
+  includePermalink: false,
+  syndicateExternalLikes: true, // NEW: Enable syndication of external likes
+  checked: false,
+};
+
+export default class BlueskySyndicator {
+  name = "Bluesky syndicator";
+
+  /**
+   * @param {object} [options] - Plug-in options
+   * @param {string} [options.profileUrl] - Profile URL
+   * @param {string} [options.serviceUrl] - Service URL
+   * @param {string} [options.handle] - Handle
+   * @param {string} [options.password] - Password
+   * @param {boolean} [options.includePermalink] - Include permalink in status
+   * @param {boolean} [options.syndicateExternalLikes] - Syndicate likes of external URLs as posts
+   * @param {boolean} [options.checked] - Check syndicator in UI
+   */
+  constructor(options = {}) {
+    this.options = { ...defaults, ...options };
+  }
+
+  get #profileUrl() {
+    return new URL(this.options.profileUrl).href;
+  }
+
+  get #serviceUrl() {
+    return new URL(this.options.serviceUrl).href;
+  }
+
+  get #user() {
+    return this.options?.handle
+      ? `@${this.options.handle.replace("@", "")}`
+      : false;
+  }
+
+  get environment() {
+    return ["BLUESKY_PASSWORD"];
+  }
+
+  get info() {
+    const userName = this.options?.handle?.replace("@", "");
+    const url = new URL(this.options.profileUrl).href + "/" + userName;
+
+    const info = {
+      checked: this.options.checked,
+      name: this.#user,
+      uid: url,
+      service: {
+        name: "Bluesky",
+        photo: "/assets/@indiekit-syndicator-bluesky/icon.svg",
+        url: this.#serviceUrl,
+      },
+      user: {
+        name: this.#user,
+        url,
+      },
+    };
+
+    if (!this.#user) {
+      info.error = "User identifier required";
+    }
+
+    return info;
+  }
+
+  get prompts() {
+    return [
+      {
+        type: "text",
+        name: "handle",
+        message: "What is your Bluesky handle (without the @)?",
+      },
+    ];
+  }
+
+  async syndicate(properties, publication) {
+    try {
+      const bluesky = new Bluesky({
+        identifier: this.options?.handle,
+        password: this.options?.password,
+        profileUrl: this.#profileUrl,
+        serviceUrl: this.#serviceUrl,
+        includePermalink: this.options.includePermalink,
+        syndicateExternalLikes: this.options.syndicateExternalLikes,
+      });
+
+      return await bluesky.post(properties, publication.me);
+    } catch (error) {
+      throw new IndiekitError(error.message, {
+        cause: error,
+        plugin: this.name,
+        status: error.statusCode,
+      });
+    }
+  }
+
+  init(Indiekit) {
+    Indiekit.addSyndicator(this);
+  }
+}

package/lib/bluesky.js

@@ -0,0 +1,257 @@
+import { AtpAgent } from "@atproto/api";
+import { IndiekitError } from "@indiekit/error";
+import { getCanonicalUrl, isSameOrigin } from "@indiekit/util";
+
+import {
+  createRichText,
+  getPostImage,
+  getPostText,
+  getLikePostText,
+  getPostParts,
+  uriToPostUrl,
+} from "./utils.js";
+
+export class Bluesky {
+  /**
+   * @param {object} options - Syndicator options
+   * @param {string} options.identifier - User identifier
+   * @param {string} options.password - Password
+   * @param {string} options.profileUrl - Profile URL
+   * @param {string} options.serviceUrl - Service URL
+   * @param {boolean} [options.includePermalink] - Include permalink in status
+   * @param {boolean} [options.syndicateExternalLikes] - Syndicate likes of external URLs
+   */
+  constructor(options) {
+    this.identifier = options.identifier;
+    this.password = options.password;
+    this.profileUrl = options.profileUrl;
+    this.serviceUrl = options.serviceUrl;
+    this.includePermalink = options.includePermalink || false;
+    this.syndicateExternalLikes = options.syndicateExternalLikes !== false; // Default true
+  }
+
+  /**
+   * Initialise AT Protocol client
+   * @access private
+   * @returns {Promise<AtpAgent>} AT Protocol agent
+   */
+  async #client() {
+    const { identifier, password, serviceUrl } = this;
+    const agent = new AtpAgent({ service: serviceUrl });
+    await agent.login({ identifier, password });
+    return agent;
+  }
+
+  /**
+   * Get a post
+   * @param {string} postUrl - URL of post to like
+   * @returns {Promise<object>} Bluesky post record
+   */
+  async getPost(postUrl) {
+    const client = await this.#client();
+    const postParts = getPostParts(postUrl);
+    return await client.getPost({
+      repo: postParts.did,
+      rkey: postParts.rkey,
+    });
+  }
+
+  /**
+   * Post a like
+   * @param {string} postUrl - URL of post to like
+   * @returns {Promise<string>} Bluesky post URL
+   */
+  async postLike(postUrl) {
+    const client = await this.#client();
+    const post = await this.getPost(postUrl);
+    const like = await client.like(post.uri, post.cid);
+    return uriToPostUrl(this.profileUrl, like.uri);
+  }
+
+  /**
+   * Post a repost
+   * @param {string} postUrl - URL of post to repost
+   * @returns {Promise<string>} Bluesky post URL
+   */
+  async postRepost(postUrl) {
+    const client = await this.#client();
+    const post = await this.getPost(postUrl);
+    const repost = await client.repost(post.uri, post.cid);
+    return uriToPostUrl(this.profileUrl, repost.uri);
+  }
+
+  /**
+   * Post a quote post
+   * @param {string} postUrl - URL of post to quote
+   * @param {object} richText - Rich text
+   * @param {Array} [images] - Images
+   * @returns {Promise<string>} Bluesky post URL
+   */
+  async postQuotePost(postUrl, richText, images) {
+    const client = await this.#client();
+    const post = await this.getPost(postUrl);
+
+    const record = {
+      $type: "app.bsky.embed.record",
+      record: { uri: post.uri, cid: post.cid },
+    };
+
+    const media = {
+      $type: "app.bsky.embed.images",
+      images,
+    };
+
+    const recordWithMedia = {
+      $type: "app.bsky.embed.recordWithMedia",
+      record,
+      media,
+    };
+
+    const embed = images?.length > 0 ? recordWithMedia : record;
+
+    const postData = {
+      $type: "app.bsky.feed.post",
+      text: richText.text,
+      facets: richText.facets,
+      createdAt: new Date().toISOString(),
+      embed,
+    };
+
+    const quotePost = await client.post(postData);
+    return uriToPostUrl(this.profileUrl, quotePost.uri);
+  }
+
+  /**
+   * Post a regular post
+   * @param {object} richText - Rich text
+   * @param {Array} [images] - Images
+   * @returns {Promise<string>} Bluesky post URL
+   */
+  async postPost(richText, images) {
+    const client = await this.#client();
+
+    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,
+        },
+      }),
+    };
+
+    const post = await client.post(postData);
+    return uriToPostUrl(this.profileUrl, post.uri);
+  }
+
+  /**
+   * Upload media
+   * @param {object} media - JF2 media object
+   * @param {string} me - Publication URL
+   * @returns {Promise<object>} Blob reference for the uploaded media
+   */
+  async uploadMedia(media, me) {
+    const client = await this.#client();
+    const { url } = media;
+
+    if (typeof url !== "string") {
+      return;
+    }
+
+    try {
+      const mediaUrl = getCanonicalUrl(url, me);
+      const mediaResponse = await fetch(mediaUrl);
+
+      if (!mediaResponse.ok) {
+        throw await IndiekitError.fromFetch(mediaResponse);
+      }
+
+      let blob = await mediaResponse.blob();
+      let encoding = mediaResponse.headers.get("Content-Type");
+
+      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 response = await client.com.atproto.repo.uploadBlob(blob, {
+        encoding,
+      });
+
+      return response.data.blob;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+
+  /**
+   * Post to Bluesky
+   * @param {object} properties - JF2 properties
+   * @param {string} me - Publication URL
+   * @returns {Promise<string|boolean>} URL of syndicated status
+   */
+  async post(properties, me) {
+    try {
+      const client = await this.#client();
+
+      // Upload photos
+      let images = [];
+      if (properties.photo) {
+        const photos = properties.photo.slice(0, 4);
+        const uploads = photos.map(async (photo) => ({
+          alt: photo.alt || "",
+          image: await this.uploadMedia(photo, me),
+        }));
+        images = await Promise.all(uploads);
+      }
+
+      // Handle reposts
+      const repostUrl = properties["repost-of"];
+      if (repostUrl) {
+        if (isSameOrigin(repostUrl, this.profileUrl) && properties.content) {
+          const text = getPostText(properties, this.includePermalink);
+          const richText = await createRichText(client, text);
+          return this.postQuotePost(repostUrl, richText, images);
+        }
+        if (isSameOrigin(repostUrl, this.profileUrl)) {
+          return this.postRepost(repostUrl);
+        }
+        // Do not syndicate reposts of other URLs
+        return;
+      }
+
+      // Handle likes
+      const likeOfUrl = properties["like-of"];
+      if (likeOfUrl) {
+        // Native Bluesky like for Bluesky URLs
+        if (isSameOrigin(likeOfUrl, this.profileUrl)) {
+          return this.postLike(likeOfUrl);
+        }
+
+        // NEW: Syndicate likes of external URLs as posts
+        if (this.syndicateExternalLikes) {
+          const text = getLikePostText(properties, likeOfUrl);
+          const richText = await createRichText(client, text);
+          return this.postPost(richText, images);
+        }
+
+        // Don't syndicate if option is disabled
+        return;
+      }
+
+      // Regular post
+      const text = getPostText(properties, this.includePermalink);
+      const richText = await createRichText(client, text);
+      return this.postPost(richText, images);
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+}

package/lib/utils.js

@@ -0,0 +1,162 @@
+import { RichText } from "@atproto/api";
+import { htmlToText } from "html-to-text";
+import sharp from "sharp";
+
+const AT_URI = /at:\/\/(?<did>did:[^/]+)\/(?<type>[^/]+)\/(?<rkey>[^/]+)/;
+
+/**
+ * Convert plain text to rich text
+ * @param {import("@atproto/api").Agent} client - AT Protocol agent
+ * @param {string} text - Text to convert
+ * @returns {Promise<RichText>} Rich text
+ */
+export const createRichText = async (client, text) => {
+  const rt = new RichText({ text });
+  await rt.detectFacets(client);
+  return rt;
+};
+
+/**
+ * Get post parts (UID and CID)
+ * @param {string} url - Post URL
+ * @returns {object} Parts
+ */
+export const getPostParts = (url) => {
+  const pathParts = new URL(url).pathname.split("/");
+  const did = pathParts[2];
+  const rkey = pathParts[4];
+  return { did, rkey };
+};
+
+/**
+ * Convert Bluesky URI to post URL
+ * @param {string} profileUrl - Profile URL
+ * @param {string} uri - Bluesky URI
+ * @returns {string|undefined} Post URL
+ */
+export const uriToPostUrl = (profileUrl, uri) => {
+  const match = uri.match(AT_URI);
+  if (match) {
+    let { did, rkey, type } = match.groups;
+    type = type.split(".").at(-1);
+    return `${profileUrl}/${did}/${type}/${rkey}`;
+  }
+};
+
+/**
+ * Get post text from given JF2 properties
+ * @param {object} properties - JF2 properties
+ * @param {boolean} [includePermalink] - Include permalink in post
+ * @returns {string} Post text
+ */
+export const getPostText = (properties, includePermalink) => {
+  let text = "";
+
+  if (properties.name && properties.name !== "") {
+    text = `${properties.name} ${properties.url}`;
+  } else if (properties.content?.html) {
+    text = htmlToStatusText(properties.content.html);
+  } else if (properties.content?.text) {
+    text = properties.content.text;
+  }
+
+  // Truncate status if longer than 300 characters
+  if (text.length > 300) {
+    const suffix = includePermalink ? `\n\n${properties.url}` : "";
+    const maxLen = 300 - suffix.length - 3;
+    text = text.slice(0, maxLen).trim() + "..." + suffix;
+  } else if (includePermalink && !text.includes(properties.url)) {
+    text = `${text}\n\n${properties.url}`;
+  }
+
+  return text;
+};
+
+/**
+ * Get post text for a like of an external URL
+ * @param {object} properties - JF2 properties
+ * @param {string} likedUrl - The URL being liked
+ * @returns {string} Post text
+ */
+export const getLikePostText = (properties, likedUrl) => {
+  let text = "";
+
+  // Get the content/comment
+  if (properties.content?.html) {
+    text = htmlToStatusText(properties.content.html);
+  } else if (properties.content?.text) {
+    text = properties.content.text;
+  }
+
+  // If there's content, append the liked URL
+  if (text) {
+    // Check if the URL is already in the text
+    if (!text.includes(likedUrl)) {
+      text = `${text}\n\n❤️ ${likedUrl}`;
+    }
+  } else {
+    // No content, just post the liked URL with a heart
+    text = `❤️ ${likedUrl}`;
+  }
+
+  // Truncate if needed (Bluesky limit is 300 chars)
+  if (text.length > 300) {
+    const suffix = `\n\n❤️ ${likedUrl}`;
+    const maxLen = 300 - suffix.length - 3;
+    const contentPart = text.replace(suffix, "").slice(0, maxLen).trim();
+    text = contentPart + "..." + suffix;
+  }
+
+  return text;
+};
+
+/**
+ * Constrain image buffer to be under 1MB
+ * @param {Buffer} buffer - Image buffer
+ * @param {number} maxBytes - Maximum byte length
+ * @param {number} [quality] - Image quality
+ * @returns {Promise<Buffer>} Compressed image
+ */
+export async function constrainImage(buffer, maxBytes, quality = 90) {
+  const compressed = await sharp(buffer).jpeg({ quality }).toBuffer();
+  if (compressed.byteLength > maxBytes) {
+    return constrainImage(buffer, maxBytes, quality - 5);
+  }
+  return compressed;
+}
+
+/**
+ * Compress image buffer to be under 1MB for Bluesky
+ * @param {Buffer} buffer - Image buffer
+ * @param {string} mimeType - Original MIME type
+ * @returns {Promise<{buffer: Buffer, mimeType: string}>} Compressed image
+ */
+export async function getPostImage(buffer, mimeType) {
+  const MAX_SIZE = 1024 * 1024; // 1MB
+  if (buffer.length < MAX_SIZE) {
+    return { buffer, mimeType };
+  }
+  const compressed = await constrainImage(buffer, MAX_SIZE);
+  return { buffer: compressed, mimeType: "image/jpeg" };
+}
+
+/**
+ * Convert HTML to plain text, appending last link href if present
+ * @param {string} html - HTML
+ * @returns {string} Text
+ */
+export const htmlToStatusText = (html) => {
+  let hrefs = [...html.matchAll(/href="(https?:\/\/.+?)"/g)];
+  const lastHref = hrefs.length > 0 ? hrefs.at(-1)[1] : false;
+
+  const text = htmlToText(html, {
+    selectors: [
+      { selector: "a", options: { ignoreHref: true } },
+      { selector: "img", format: "skip" },
+    ],
+    wordwrap: false,
+  });
+
+  const statusText = lastHref ? `${text} ${lastHref}` : text;
+  return statusText;
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rmdes/indiekit-syndicator-bluesky",
+  "version": "1.0.0",
+  "description": "Bluesky syndicator for Indiekit with external like support",
+  "type": "module",
+  "main": "index.js",
+  "exports": "./index.js",
+  "keywords": [
+    "indiekit",
+    "indiekit-plugin",
+    "indieweb",
+    "bluesky",
+    "syndication"
+  ],
+  "author": "rmdes",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rmdes/indiekit-syndicator-bluesky"
+  },
+  "dependencies": {
+    "@atproto/api": "^0.14.0",
+    "@indiekit/error": "^1.0.0-beta.25",
+    "@indiekit/util": "^1.0.0-beta.25",
+    "sharp": "^0.33.0"
+  },
+  "peerDependencies": {
+    "@indiekit/indiekit": "1.x"
+  }
+}