social-light 0.0.1

package/src/utils/social/bluesky.mjs

@@ -0,0 +1,302 @@
+import { SocialPlatform } from './base.mjs';
+import fetch from 'node-fetch';
+
+/**
+ * Bluesky Platform API Implementation
+ * Uses Bluesky's AT Protocol for posting and managing content
+ */
+export class BlueskyPlatform extends SocialPlatform {
+  /**
+   * Constructor for Bluesky platform
+   * @param {Object} config - Platform-specific configuration
+   * @param {string} config.handle - Bluesky handle (username)
+   * @param {string} config.password - Bluesky app password
+   * @param {string} config.service - Bluesky service URL (default: https://bsky.social)
+   */
+  constructor(config = {}) {
+    super(config);
+    this.name = 'bluesky';
+    this.service = config.service || 'https://bsky.social';
+    this.authenticated = false;
+    this.session = null;
+  }
+
+  /**
+   * Check if platform is properly configured
+   * @returns {boolean} True if platform is configured
+   */
+  isConfigured() {
+    // Check config for credentials
+    const hasConfigCreds = Boolean(
+      this.config.handle &&
+      this.config.password
+    );
+
+    // Also check environment variables
+    const hasEnvCreds = Boolean(
+      process.env.BLUESKY_HANDLE &&
+      process.env.BLUESKY_APP_PASSWORD
+    );
+
+    return hasConfigCreds || hasEnvCreds;
+  }
+
+  /**
+   * Authenticate with the Bluesky API
+   * @returns {Promise<boolean>} True if authentication successful
+   */
+  async authenticate() {
+    if (!this.isConfigured()) {
+      throw new Error('Bluesky API not properly configured');
+    }
+
+    // Get credentials from config or environment variables
+    const handle = this.config.handle || process.env.BLUESKY_HANDLE;
+    const password = this.config.password || process.env.BLUESKY_APP_PASSWORD;
+    const service = this.config.service || process.env.BLUESKY_SERVICE || this.service;
+
+    try {
+      const response = await fetch(`${service}/xrpc/com.atproto.server.createSession`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          identifier: handle,
+          password: password
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Bluesky authentication failed: ${JSON.stringify(error)}`);
+      }
+
+      this.session = await response.json();
+      this.authenticated = true;
+      return true;
+    } catch (error) {
+      console.error('Bluesky authentication error:', error);
+      this.authenticated = false;
+      throw error;
+    }
+  }
+
+  /**
+   * Post content to Bluesky
+   * @param {Object} post - Post content and metadata
+   * @param {string} post.text - Text content of the post (required)
+   * @param {Array<string>} post.mediaUrls - URLs of media to attach (optional)
+   * @param {Object} post.options - Bluesky-specific options
+   * @returns {Promise<Object>} Response including post URI and CID
+   */
+  async post(post) {
+    if (!this.authenticated && !await this.authenticate()) {
+      throw new Error('Bluesky authentication required');
+    }
+
+    if (!post.text) {
+      throw new Error('Post text is required');
+    }
+
+    try {
+      // Create basic post record
+      const record = {
+        $type: 'app.bsky.feed.post',
+        text: post.text,
+        createdAt: new Date().toISOString()
+      };
+
+      // Handle languages if specified
+      if (post.options && post.options.langs) {
+        record.langs = Array.isArray(post.options.langs) ? post.options.langs : [post.options.langs];
+      }
+
+      // Handle media attachments if provided
+      if (post.mediaUrls && post.mediaUrls.length > 0) {
+        const images = await Promise.all(
+          post.mediaUrls.map(url => this._uploadImage(url))
+        );
+
+        if (images.length > 0) {
+          record.embed = {
+            $type: 'app.bsky.embed.images',
+            images: images.map(img => ({
+              alt: post.options?.imageAlt || 'Image',
+              image: img
+            }))
+          };
+        }
+      }
+
+      // Handle external link embedding if provided
+      if (post.options && post.options.externalLink) {
+        record.embed = {
+          $type: 'app.bsky.embed.external',
+          external: {
+            uri: post.options.externalLink.uri,
+            title: post.options.externalLink.title || '',
+            description: post.options.externalLink.description || ''
+          }
+        };
+
+        if (post.options.externalLink.thumbnailUrl) {
+          const thumb = await this._uploadImage(post.options.externalLink.thumbnailUrl);
+          record.embed.external.thumb = thumb;
+        }
+      }
+
+      // Create the post
+      const response = await fetch(`${this.service}/xrpc/com.atproto.repo.createRecord`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.session.accessJwt}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          repo: this.config.handle,
+          collection: 'app.bsky.feed.post',
+          record: record
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Bluesky post failed: ${JSON.stringify(error)}`);
+      }
+
+      const result = await response.json();
+      return {
+        id: result.uri.split('/').pop(),
+        uri: result.uri,
+        cid: result.cid
+      };
+    } catch (error) {
+      console.error('Bluesky post error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get status of a post
+   * @param {string} postUri - URI of the post to check
+   * @returns {Promise<Object>} Post status information
+   */
+  async getPostStatus(postUri) {
+    if (!this.authenticated && !await this.authenticate()) {
+      throw new Error('Bluesky authentication required');
+    }
+
+    try {
+      // Parse URI to get repo and record ID
+      const parts = postUri.split('/');
+      const repo = parts[2];
+      const recordId = parts.pop();
+      const collection = 'app.bsky.feed.post';
+
+      const response = await fetch(`${this.service}/xrpc/com.atproto.repo.getRecord?repo=${repo}&collection=${collection}&rkey=${recordId}`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${this.session.accessJwt}`
+        }
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Failed to get post status: ${JSON.stringify(error)}`);
+      }
+
+      const result = await response.json();
+      return {
+        uri: postUri,
+        cid: result.cid,
+        record: result.value
+      };
+    } catch (error) {
+      console.error('Bluesky get status error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a post from Bluesky
+   * @param {string} postUri - URI of the post to delete
+   * @returns {Promise<boolean>} True if deletion successful
+   */
+  async deletePost(postUri) {
+    if (!this.authenticated && !await this.authenticate()) {
+      throw new Error('Bluesky authentication required');
+    }
+
+    try {
+      // Parse URI to get repo and record ID
+      const parts = postUri.split('/');
+      const repo = parts[2];
+      const recordId = parts.pop();
+      const collection = 'app.bsky.feed.post';
+
+      const response = await fetch(`${this.service}/xrpc/com.atproto.repo.deleteRecord`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.session.accessJwt}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          repo,
+          collection,
+          rkey: recordId
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Failed to delete post: ${JSON.stringify(error)}`);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Bluesky delete error:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Upload an image to Bluesky
+   * @param {string} imageUrl - URL of the image to upload
+   * @returns {Promise<Object>} Blob reference
+   * @private
+   */
+  async _uploadImage(imageUrl) {
+    try {
+      // Fetch the image data
+      const imageResponse = await fetch(imageUrl);
+      if (!imageResponse.ok) {
+        throw new Error(`Failed to fetch image: ${imageResponse.statusText}`);
+      }
+
+      const imageBuffer = await imageResponse.buffer();
+      const contentType = imageResponse.headers.get('content-type') || 'image/jpeg';
+
+      // Upload the image blob
+      const uploadResponse = await fetch(`${this.service}/xrpc/com.atproto.repo.uploadBlob`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.session.accessJwt}`,
+          'Content-Type': contentType
+        },
+        body: imageBuffer
+      });
+
+      if (!uploadResponse.ok) {
+        const error = await uploadResponse.json();
+        throw new Error(`Failed to upload image: ${JSON.stringify(error)}`);
+      }
+
+      const result = await uploadResponse.json();
+      return result.blob;
+    } catch (error) {
+      console.error('Bluesky image upload error:', error);
+      throw error;
+    }
+  }
+}

package/src/utils/social/index.mjs

@@ -0,0 +1,300 @@
+import { PlatformFactory } from "./base.mjs";
+import { getConfig, getCredentials } from "../config.mjs";
+import { logAction } from "../db.mjs";
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+/**
+ * Social API manager for handling multiple platforms
+ */
+export class SocialAPI {
+  /**
+   * Constructor for the Social API manager
+   * @param {Object} options - Configuration options
+   */
+  constructor(options = {}) {
+    this.platforms = new Map();
+    this.config = getConfig();
+    this.options = options;
+  }
+
+  /**
+   * Initialize a specific platform
+   * @param {string} platform - Platform name
+   * @param {Object} config - Platform-specific configuration
+   * @returns {Promise<boolean>} True if initialization successful
+   */
+  async initPlatform(platform, config = {}) {
+    try {
+      // Get credentials from config.json
+      const platformCredentials = getCredentials(platform);
+      
+      // Merge provided config and stored credentials
+      const mergedConfig = {
+        ...platformCredentials,
+        ...config
+      };
+      
+      // Get platform instance from factory
+      const platformInstance = await PlatformFactory.create(platform, mergedConfig);
+
+      // Store the platform instance
+      this.platforms.set(platform.toLowerCase(), platformInstance);
+
+      // Attempt authentication if configured
+      if (platformInstance.isConfigured()) {
+        await platformInstance.authenticate();
+      }
+
+      return true;
+    } catch (error) {
+      console.error(`Failed to initialize ${platform}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Get a platform instance by name
+   * @param {string} platform - Platform name
+   * @returns {SocialPlatform|null} Platform instance or null if not found
+   */
+  getPlatform(platform) {
+    return this.platforms.get(platform.toLowerCase()) || null;
+  }
+
+  /**
+   * Check if a platform is initialized and authenticated
+   * @param {string} platform - Platform name
+   * @returns {boolean} True if platform is ready
+   */
+  isPlatformReady(platform) {
+    const platformInstance = this.getPlatform(platform);
+    return platformInstance && platformInstance.authenticated;
+  }
+
+  /**
+   * Post content to multiple platforms
+   * @param {Object} post - Post content and metadata
+   * @param {string} post.text - Text content of the post
+   * @param {string} post.title - Title/caption of the post (optional)
+   * @param {Array<string>} post.mediaUrls - Media URLs to attach (optional)
+   * @param {Array<string>} post.platforms - Platforms to post to
+   * @param {Object} post.options - Platform-specific options
+   * @returns {Promise<Object>} Results for each platform
+   */
+  async post(post) {
+    if (!post.platforms || post.platforms.length === 0) {
+      throw new Error("No platforms specified for posting");
+    }
+
+    const results = {};
+    const errors = [];
+
+    // Post to each platform
+    for (const platform of post.platforms) {
+      try {
+        const platformLower = platform.toLowerCase();
+        let platformInstance = this.getPlatform(platformLower);
+
+        if (!platformInstance) {
+          await this.initPlatform(platformLower);
+          platformInstance = this.getPlatform(platformLower);
+        }
+
+        if (!platformInstance) {
+          throw new Error(`Platform ${platform} not initialized`);
+        }
+
+        if (!platformInstance.authenticated) {
+          await platformInstance.authenticate();
+        }
+
+        // Get platform-specific options if provided
+        const platformOptions =
+          post.options && post.options[platformLower]
+            ? post.options[platformLower]
+            : {};
+
+        // Create platform-specific post object
+        const platformPost = {
+          text: post.text,
+          title: post.title,
+          mediaUrls: post.mediaUrls,
+          options: platformOptions,
+        };
+
+        // Post to the platform
+        const result = await platformInstance.post(platformPost);
+
+        // Store result
+        results[platformLower] = {
+          success: true,
+          postId: result.id || result.uri || result.publishId,
+          ...result,
+        };
+
+        // Log the action
+        logAction("post_created", {
+          platform: platformLower,
+          postId: result.id || result.uri || result.publishId,
+          content: post.text?.substring(0, 100),
+        });
+      } catch (error) {
+        console.error(`Error posting to ${platform}:`, error);
+
+        // Store error
+        results[platform.toLowerCase()] = {
+          success: false,
+          error: error.message,
+        };
+
+        errors.push({
+          platform,
+          message: error.message,
+        });
+
+        // Log the error
+        logAction("post_error", {
+          platform: platform.toLowerCase(),
+          error: error.message,
+          content: post.text?.substring(0, 100),
+        });
+      }
+    }
+
+    return {
+      results,
+      success: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Get status of posts across platforms
+   * @param {Object} postIds - Map of platform to post ID
+   * @returns {Promise<Object>} Status for each platform
+   */
+  async getPostStatus(postIds) {
+    const results = {};
+    const errors = [];
+
+    for (const [platform, postId] of Object.entries(postIds)) {
+      try {
+        const platformLower = platform.toLowerCase();
+        const platformInstance = this.getPlatform(platformLower);
+
+        if (!platformInstance) {
+          throw new Error(`Platform ${platform} not initialized`);
+        }
+
+        if (!platformInstance.authenticated) {
+          await platformInstance.authenticate();
+        }
+
+        const status = await platformInstance.getPostStatus(postId);
+
+        results[platformLower] = {
+          success: true,
+          status,
+        };
+      } catch (error) {
+        console.error(`Error getting status from ${platform}:`, error);
+
+        results[platform.toLowerCase()] = {
+          success: false,
+          error: error.message,
+        };
+
+        errors.push({
+          platform,
+          message: error.message,
+        });
+      }
+    }
+
+    return {
+      results,
+      success: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Delete posts across platforms
+   * @param {Object} postIds - Map of platform to post ID
+   * @returns {Promise<Object>} Results for each platform
+   */
+  async deletePosts(postIds) {
+    const results = {};
+    const errors = [];
+
+    for (const [platform, postId] of Object.entries(postIds)) {
+      try {
+        const platformLower = platform.toLowerCase();
+        const platformInstance = this.getPlatform(platformLower);
+
+        if (!platformInstance) {
+          throw new Error(`Platform ${platform} not initialized`);
+        }
+
+        if (!platformInstance.authenticated) {
+          await platformInstance.authenticate();
+        }
+
+        const success = await platformInstance.deletePost(postId);
+
+        results[platformLower] = {
+          success,
+        };
+
+        // Log the action
+        logAction("post_deleted", {
+          platform: platformLower,
+          postId,
+        });
+      } catch (error) {
+        console.error(`Error deleting post from ${platform}:`, error);
+
+        results[platform.toLowerCase()] = {
+          success: false,
+          error: error.message,
+        };
+
+        errors.push({
+          platform,
+          message: error.message,
+        });
+
+        // Log the error
+        logAction("delete_error", {
+          platform: platform.toLowerCase(),
+          postId,
+          error: error.message,
+        });
+      }
+    }
+
+    return {
+      results,
+      success: errors.length === 0,
+      errors,
+    };
+  }
+}
+
+// Export a singleton instance
+let instance = null;
+
+/**
+ * Get the Social API instance
+ * @param {Object} options - Configuration options
+ * @returns {SocialAPI} SocialAPI instance
+ */
+export const getSocialAPI = (options = {}) => {
+  if (!instance) {
+    instance = new SocialAPI(options);
+  }
+  return instance;
+};