social-light 0.1.1 → 0.1.3

package/README.md

@@ -19,9 +19,6 @@ An AI-powered social media scheduling tool for Bluesky with CLI and web interfac
 
 [Node.js/npm](https://nodejs.org) must be installed on your system
 
-> [!WARNING]  
-> There's a know issues with the latest version of Node.js (v23) and 'better-sqlite3'. Please use Node.js v22 (LTS) or lower.
-
 ## Accounts
 
 You will need an account on [blue sky](https://bsky.app) and an [OpenAI](https://openai.com) account to use the AI features.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-light",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "AI-powered social media scheduling tool",
   "main": "src/index.mjs",
   "type": "module",
@@ -24,7 +24,7 @@
   "license": "MIT",
   "dependencies": {
     "ai": "^2.2.31",
-    "better-sqlite3": "^9.3.0",
+    "better-sqlite3": "^11.9.1",
     "chalk": "^5.3.0",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",

package/src/commands/init.mjs

@@ -3,7 +3,6 @@ import ora from "ora";
 import inquirer from "inquirer";
 import fs from "fs-extra";
 import path from "path";
-import os from "os";
 import dotenv from "dotenv";
 
 import {
@@ -158,6 +157,7 @@ export const initialize = async (argv) => {
           {
             type: "input",
             name: "openaiKey",
+            mask: "*",
             message:
               "Enter your OpenAI API key for AI features (press Enter to skip):",
           },

package/src/commands/uninit.mjs

@@ -0,0 +1,114 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import fs from "fs-extra";
+import path from "path";
+import dotenv from "dotenv";
+import os from "os";
+
+import { configExists } from "../utils/config.mjs";
+
+// Load environment variables
+dotenv.config();
+
+/**
+ * Remove the Social Light application configuration
+ * @example
+ * await uninitialize();
+ */
+export const uninitialize = async () => {
+  const spinner = ora("Removing Social Light...").start();
+  const deletedFiles = [];
+
+  try {
+    const exists = configExists();
+
+    // If config already prompt for confirmation
+    if (exists) {
+      spinner.stop();
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Delete Social Light configuration?",
+          default: false,
+        },
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.yellow("Unitialization cancelled."));
+        return;
+      }
+
+      spinner.start("Removing Social Light configuration...");
+
+      // Remove configuration file in current directory
+      const configPath = path.join(process.cwd(), "config.json");
+      if (fs.existsSync(configPath)) {
+        fs.removeSync(configPath);
+        deletedFiles.push(configPath);
+        spinner.text = "Configuration file removed...";
+      }
+
+      // Remove database files
+      const dbDir = path.join(process.cwd(), "data");
+      if (fs.existsSync(dbDir)) {
+        fs.removeSync(dbDir);
+        deletedFiles.push(dbDir);
+        spinner.text = "Database files removed...";
+      }
+
+      // Remove configuration in $HOME/.social-light directory
+      const homeSocialLightDir = path.join(os.homedir(), ".social-light");
+      if (fs.existsSync(homeSocialLightDir)) {
+        // Get list of files before deletion for reporting
+        const configFiles = fs
+          .readdirSync(homeSocialLightDir)
+          .map((file) => path.join(homeSocialLightDir, file));
+
+        // Add them to deleted files list
+        deletedFiles.push(...configFiles);
+
+        // Remove the directory and all contents
+        fs.removeSync(homeSocialLightDir);
+        spinner.text = "Home social-light directory removed...";
+      }
+
+      // Clean environment variables related to Social Light
+      const envPath = path.join(process.cwd(), ".env");
+      if (fs.existsSync(envPath)) {
+        fs.removeSync(envPath);
+        deletedFiles.push(envPath);
+        spinner.text = "Environment file removed...";
+      }
+
+      spinner.succeed("Social Light configuration removed successfully!");
+
+      // Print list of deleted files
+      console.log(
+        chalk.green("\n✓ All Social Light configurations have been removed.")
+      );
+
+      if (deletedFiles.length > 0) {
+        console.log(chalk.cyan("\nDeleted files and directories:"));
+        deletedFiles.forEach((file) => {
+          console.log(chalk.gray(`  • ${file}`));
+        });
+      }
+
+      console.log(
+        chalk.cyan("\nYou can reinitialize anytime with:"),
+        chalk.cyan("social-light init")
+      );
+      return;
+    }
+
+    spinner.info("Not initialized. No configuration to remove.");
+    return;
+  } catch (error) {
+    spinner.fail(`Unintialization failed: ${error.message}`);
+    console.error(chalk.red("Error details:"), error);
+    process.exit(1);
+  }
+};

package/src/index.mjs

@@ -10,6 +10,7 @@ import { hideBin } from "yargs/helpers";
 import chalk from "chalk";
 
 import { initialize } from "./commands/init.mjs";
+import { uninitialize } from "./commands/uninit.mjs";
 import { createPost } from "./commands/create.mjs";
 
 import { list } from "./commands/list.mjs";
@@ -41,6 +42,7 @@ const main = async () => {
       console.log(NPMPackage.version);
     })
     .command("init", "Initialize Social Light configuration", {}, initialize)
+    .command("uninit", "Remove Social Light configuration", {}, uninitialize)
     .command(
       "create",
       "Create a new social media post",

package/delete/tiktok.mjs

@@ -1,315 +0,0 @@
-import { SocialPlatform } from "./base.mjs";
-import fetch from "node-fetch";
-
-/**
- * TikTok Platform API Implementation
- * Uses TikTok's Content Posting API for posting and managing content
- */
-export class TikTokPlatform extends SocialPlatform {
-  /**
-   * Constructor for TikTok platform
-   * @param {Object} config - Platform-specific configuration
-   * @param {string} config.accessToken - TikTok API access token
-   * @param {string} config.clientKey - TikTok client key
-   * @param {string} config.clientSecret - TikTok client secret
-   */
-  constructor(config = {}) {
-    super(config);
-    this.name = "tiktok";
-    this.baseUrl = "https://open.tiktokapis.com/v2";
-    this.authenticated = false;
-  }
-
-  /**
-   * Check if platform is properly configured
-   * @returns {boolean} True if platform is configured
-   */
-  isConfigured() {
-    return Boolean(
-      this.config.accessToken &&
-        this.config.clientKey &&
-        this.config.clientSecret
-    );
-  }
-
-  /**
-   * Authenticate with the TikTok API
-   * @returns {Promise<boolean>} True if authentication successful
-   */
-  async authenticate() {
-    if (!this.isConfigured()) {
-      throw new Error("TikTok API not properly configured");
-    }
-
-    try {
-      // Query creator info to verify access token is valid
-      const response = await fetch(
-        `${this.baseUrl}/post/publish/creator_info/query/`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.config.accessToken}`,
-            "Content-Type": "application/json; charset=UTF-8",
-          },
-          body: JSON.stringify({}),
-        }
-      );
-
-      if (!response.ok) {
-        const error = await response.json();
-        throw new Error(
-          `TikTok authentication failed: ${JSON.stringify(error)}`
-        );
-      }
-
-      const creatorInfo = await response.json();
-      this.creatorInfo = creatorInfo.data;
-      this.authenticated = true;
-      return true;
-    } catch (error) {
-      console.error("TikTok authentication error:", error);
-      this.authenticated = false;
-      throw error;
-    }
-  }
-
-  /**
-   * Post content to TikTok
-   * @param {Object} post - Post content and metadata
-   * @param {string} post.text - Text content/caption of the post
-   * @param {Array<string>} post.mediaUrls - URLs of videos/images to post (required)
-   * @param {Object} post.options - TikTok-specific options
-   * @returns {Promise<Object>} Response including publish ID
-   */
-  async post(post) {
-    if (!this.authenticated && !(await this.authenticate())) {
-      throw new Error("TikTok authentication required");
-    }
-
-    if (!post.mediaUrls || post.mediaUrls.length === 0) {
-      throw new Error("TikTok post requires at least one video or image URL");
-    }
-
-    // TikTok API has different endpoints for videos and images
-    const mediaType = this._determineMediaType(post.mediaUrls[0]);
-
-    if (mediaType === "video") {
-      return this._postVideo(post);
-    } else if (mediaType === "image") {
-      return this._postImage(post);
-    } else {
-      throw new Error(`Unsupported media type: ${mediaType}`);
-    }
-  }
-
-  /**
-   * Get status of a TikTok post
-   * @param {string} publishId - Publish ID of the post to check
-   * @returns {Promise<Object>} Post status information
-   */
-  async getPostStatus(publishId) {
-    if (!this.authenticated && !(await this.authenticate())) {
-      throw new Error("TikTok authentication required");
-    }
-
-    try {
-      const response = await fetch(
-        `${this.baseUrl}/post/publish/status/fetch/`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.config.accessToken}`,
-            "Content-Type": "application/json; charset=UTF-8",
-          },
-          body: JSON.stringify({
-            publish_id: publishId,
-          }),
-        }
-      );
-
-      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 {
-        publishId,
-        status: result.data.status,
-        statusMessage: result.data.status_msg,
-        videoId: result.data.video_id,
-        shareUrl: result.data.share_url,
-      };
-    } catch (error) {
-      console.error("TikTok get status error:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * Delete a TikTok post
-   * Note: TikTok Content Posting API doesn't directly support post deletion
-   * @param {string} postId - ID of the post to delete
-   * @returns {Promise<boolean>} True if deletion successful
-   */
-  async deletePost(postId) {
-    throw new Error(
-      "TikTok API does not support post deletion via the Content Posting API"
-    );
-  }
-
-  /**
-   * Post a video to TikTok
-   * @param {Object} post - Post content and metadata
-   * @returns {Promise<Object>} Response with publish ID
-   * @private
-   */
-  async _postVideo(post) {
-    try {
-      // Prepare post data
-      const postInfo = {
-        title: post.text || "",
-        privacy_level: post.options?.privacyLevel || "PUBLIC_TO_EVERYONE",
-        disable_duet: post.options?.disableDuet || false,
-        disable_comment: post.options?.disableComment || false,
-        disable_stitch: post.options?.disableStitch || false,
-      };
-
-      if (post.options?.videoCoverTimestamp) {
-        postInfo.video_cover_timestamp_ms = post.options.videoCoverTimestamp;
-      }
-
-      // Initialize video upload
-      const initResponse = await fetch(
-        `${this.baseUrl}/post/publish/video/init/`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.config.accessToken}`,
-            "Content-Type": "application/json; charset=UTF-8",
-          },
-          body: JSON.stringify({
-            post_info: postInfo,
-            source_info: {
-              source: "PULL_FROM_URL",
-              video_url: post.mediaUrls[0],
-            },
-          }),
-        }
-      );
-
-      if (!initResponse.ok) {
-        const error = await initResponse.json();
-        throw new Error(
-          `TikTok video post initialization failed: ${JSON.stringify(error)}`
-        );
-      }
-
-      const initResult = await initResponse.json();
-      const publishId = initResult.data.publish_id;
-
-      return {
-        publishId,
-        status: "PROCESSING",
-        type: "video",
-      };
-    } catch (error) {
-      console.error("TikTok video post error:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * Post an image to TikTok
-   * @param {Object} post - Post content and metadata
-   * @returns {Promise<Object>} Response with publish ID
-   * @private
-   */
-  async _postImage(post) {
-    try {
-      // Prepare post data
-      const postInfo = {
-        title: post.text || "",
-        privacy_level: post.options?.privacyLevel || "PUBLIC_TO_EVERYONE",
-        disable_comment: post.options?.disableComment || false,
-      };
-
-      // Initialize image upload
-      const initResponse = await fetch(
-        `${this.baseUrl}/post/publish/content/init/`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.config.accessToken}`,
-            "Content-Type": "application/json; charset=UTF-8",
-          },
-          body: JSON.stringify({
-            post_info: postInfo,
-            media_type: "PHOTO",
-            post_mode: "DIRECT_POST",
-            source_info: {
-              source: "PULL_FROM_URL",
-              photo_urls: post.mediaUrls.slice(0, 9), // TikTok supports up to 9 images
-            },
-          }),
-        }
-      );
-
-      if (!initResponse.ok) {
-        const error = await initResponse.json();
-        throw new Error(
-          `TikTok image post initialization failed: ${JSON.stringify(error)}`
-        );
-      }
-
-      const initResult = await initResponse.json();
-      const publishId = initResult.data.publish_id;
-
-      return {
-        publishId,
-        status: "PROCESSING",
-        type: "image",
-      };
-    } catch (error) {
-      console.error("TikTok image post error:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * Determine media type from URL
-   * @param {string} url - Media URL
-   * @returns {string} Media type: 'video', 'image', or 'unknown'
-   * @private
-   */
-  _determineMediaType(url) {
-    const lowercaseUrl = url.toLowerCase();
-    const videoExtensions = [".mp4", ".mov", ".avi", ".wmv", ".flv", ".webm"];
-    const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".webp"];
-
-    for (const ext of videoExtensions) {
-      if (lowercaseUrl.endsWith(ext)) {
-        return "video";
-      }
-    }
-
-    for (const ext of imageExtensions) {
-      if (lowercaseUrl.endsWith(ext)) {
-        return "image";
-      }
-    }
-
-    // If we can't determine from extension, check for common patterns
-    if (lowercaseUrl.includes("video") || lowercaseUrl.includes("mov")) {
-      return "video";
-    } else if (
-      lowercaseUrl.includes("image") ||
-      lowercaseUrl.includes("photo")
-    ) {
-      return "image";
-    }
-
-    // Default to video as it's more common for TikTok
-    return "video";
-  }
-}

package/delete/twitter.mjs

@@ -1,258 +0,0 @@
-import { SocialPlatform } from './base.mjs';
-import fetch from 'node-fetch';
-
-/**
- * Twitter (X) Platform API Implementation
- * Uses Twitter API v2 for posting and managing tweets
- */
-export class TwitterPlatform extends SocialPlatform {
-  /**
-   * Constructor for Twitter platform
-   * @param {Object} config - Platform-specific configuration
-   * @param {string} config.apiKey - Twitter API key
-   * @param {string} config.apiSecret - Twitter API secret
-   * @param {string} config.accessToken - Twitter access token
-   * @param {string} config.accessTokenSecret - Twitter access token secret
-   */
-  constructor(config = {}) {
-    super(config);
-    this.name = 'twitter';
-    this.baseUrl = 'https://api.twitter.com/2';
-    this.authenticated = false;
-    this.bearerToken = null;
-  }
-
-  /**
-   * Check if platform is properly configured
-   * @returns {boolean} True if platform is configured
-   */
-  isConfigured() {
-    return Boolean(
-      this.config.apiKey &&
-      this.config.apiSecret &&
-      this.config.accessToken &&
-      this.config.accessTokenSecret
-    );
-  }
-
-  /**
-   * Authenticate with the Twitter API
-   * @returns {Promise<boolean>} True if authentication successful
-   */
-  async authenticate() {
-    if (!this.isConfigured()) {
-      throw new Error('Twitter API not properly configured');
-    }
-
-    try {
-      // For OAuth 1.0a authentication, we need to implement a proper signature method
-      // This is a simplified version for demonstration purposes
-      // In a real implementation, you'd use a library like 'oauth-1.0a'
-      const authHeader = this._generateOAuthHeader();
-      
-      const response = await fetch(`${this.baseUrl}/users/me`, {
-        method: 'GET',
-        headers: {
-          Authorization: authHeader
-        }
-      });
-
-      if (!response.ok) {
-        const error = await response.json();
-        throw new Error(`Twitter authentication failed: ${JSON.stringify(error)}`);
-      }
-
-      this.authenticated = true;
-      return true;
-    } catch (error) {
-      console.error('Twitter authentication error:', error);
-      this.authenticated = false;
-      throw error;
-    }
-  }
-
-  /**
-   * Post content to Twitter
-   * @param {Object} post - Post content and metadata
-   * @param {string} post.text - Text content of the tweet (required)
-   * @param {Array<string>} post.mediaUrls - URLs of media to attach (optional)
-   * @param {Object} post.options - Twitter-specific options
-   * @returns {Promise<Object>} Response including tweet ID
-   */
-  async post(post) {
-    if (!this.authenticated && !await this.authenticate()) {
-      throw new Error('Twitter authentication required');
-    }
-
-    if (!post.text) {
-      throw new Error('Tweet text is required');
-    }
-
-    try {
-      const tweetData = {
-        text: post.text
-      };
-
-      // Handle media attachments if provided
-      if (post.mediaUrls && post.mediaUrls.length > 0) {
-        const mediaIds = await this._uploadMedia(post.mediaUrls);
-        if (mediaIds.length > 0) {
-          tweetData.media = {
-            media_ids: mediaIds
-          };
-        }
-      }
-
-      // Add any Twitter-specific options
-      if (post.options) {
-        // Handle reply settings if provided
-        if (post.options.replySettings) {
-          tweetData.reply_settings = post.options.replySettings;
-        }
-
-        // Handle quote tweet if provided
-        if (post.options.quoteTweetId) {
-          tweetData.quote_tweet_id = post.options.quoteTweetId;
-        }
-
-        // Handle reply if provided
-        if (post.options.inReplyToTweetId) {
-          tweetData.reply = {
-            in_reply_to_tweet_id: post.options.inReplyToTweetId
-          };
-        }
-      }
-
-      const authHeader = this._generateOAuthHeader('POST', `${this.baseUrl}/tweets`);
-      
-      const response = await fetch(`${this.baseUrl}/tweets`, {
-        method: 'POST',
-        headers: {
-          'Authorization': authHeader,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(tweetData)
-      });
-
-      if (!response.ok) {
-        const error = await response.json();
-        throw new Error(`Twitter post failed: ${JSON.stringify(error)}`);
-      }
-
-      const result = await response.json();
-      return {
-        id: result.data.id,
-        text: result.data.text,
-        url: `https://twitter.com/user/status/${result.data.id}`
-      };
-    } catch (error) {
-      console.error('Twitter post error:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get status of a tweet
-   * @param {string} tweetId - ID of the tweet to check
-   * @returns {Promise<Object>} Tweet status information
-   */
-  async getPostStatus(tweetId) {
-    if (!this.authenticated && !await this.authenticate()) {
-      throw new Error('Twitter authentication required');
-    }
-
-    try {
-      const authHeader = this._generateOAuthHeader('GET', `${this.baseUrl}/tweets/${tweetId}`);
-      
-      const response = await fetch(`${this.baseUrl}/tweets/${tweetId}?tweet.fields=public_metrics`, {
-        method: 'GET',
-        headers: {
-          Authorization: authHeader
-        }
-      });
-
-      if (!response.ok) {
-        const error = await response.json();
-        throw new Error(`Failed to get tweet status: ${JSON.stringify(error)}`);
-      }
-
-      const result = await response.json();
-      return {
-        id: result.data.id,
-        text: result.data.text,
-        metrics: result.data.public_metrics,
-        url: `https://twitter.com/user/status/${result.data.id}`
-      };
-    } catch (error) {
-      console.error('Twitter get status error:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Delete a tweet
-   * @param {string} tweetId - ID of the tweet to delete
-   * @returns {Promise<boolean>} True if deletion successful
-   */
-  async deletePost(tweetId) {
-    if (!this.authenticated && !await this.authenticate()) {
-      throw new Error('Twitter authentication required');
-    }
-
-    try {
-      const authHeader = this._generateOAuthHeader('DELETE', `${this.baseUrl}/tweets/${tweetId}`);
-      
-      const response = await fetch(`${this.baseUrl}/tweets/${tweetId}`, {
-        method: 'DELETE',
-        headers: {
-          Authorization: authHeader
-        }
-      });
-
-      if (!response.ok) {
-        const error = await response.json();
-        throw new Error(`Failed to delete tweet: ${JSON.stringify(error)}`);
-      }
-
-      return true;
-    } catch (error) {
-      console.error('Twitter delete error:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Upload media to Twitter
-   * @param {Array<string>} mediaUrls - Array of media URLs to upload
-   * @returns {Promise<Array<string>>} Array of media IDs
-   * @private
-   */
-  async _uploadMedia(mediaUrls) {
-    // This is a placeholder implementation
-    // In a real implementation, you would:
-    // 1. Download each media file or read from local file
-    // 2. Upload to Twitter's media endpoint (v1.1/media/upload)
-    // 3. Return the media IDs
-    
-    const mediaIds = [];
-    // Implementation would go here
-    
-    return mediaIds;
-  }
-
-  /**
-   * Generate OAuth 1.0a header for Twitter API
-   * @param {string} method - HTTP method
-   * @param {string} url - Request URL
-   * @returns {string} OAuth header string
-   * @private
-   */
-  _generateOAuthHeader(method = 'GET', url = '') {
-    // This is a simplified placeholder implementation
-    // In a real implementation, you would use a library like 'oauth-1.0a'
-    // to generate proper OAuth 1.0a signatures
-    
-    // Return simplified header for demo purposes
-    return `OAuth oauth_consumer_key="${this.config.apiKey}", oauth_token="${this.config.accessToken}"`;
-  }
-}