social-light 0.0.1

package/src/utils/db.mjs

@@ -0,0 +1,260 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import Database from 'better-sqlite3';
+import { getConfig } from './config.mjs';
+
+/**
+ * Check if database tables are initialized
+ * @param {Object} db - Database connection
+ * @returns {boolean} True if tables are initialized
+ */
+const checkTablesInitialized = (db) => {
+  try {
+    const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='posts';").get();
+    return Boolean(tableExists);
+  } catch (error) {
+    console.error('Error checking database tables:', error);
+    return false;
+  }
+};
+
+/**
+ * Get database connection
+ * @returns {Object} Database connection
+ * @example
+ * const db = getDb();
+ * const posts = db.prepare('SELECT * FROM posts').all();
+ */
+export const getDb = () => {
+  const config = getConfig();
+  
+  // Resolve path with home directory if needed
+  const dbPath = config.dbPath.replace(/^~/, os.homedir());
+  
+  // Ensure directory exists
+  fs.ensureDirSync(path.dirname(dbPath));
+  
+  // Connect to database
+  const db = new Database(dbPath);
+  
+  // Check if tables exist and initialize if needed
+  if (!checkTablesInitialized(db)) {
+    // Create tables directly to avoid circular dependency
+    try {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS posts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          title TEXT,
+          content TEXT NOT NULL,
+          platforms TEXT,
+          publish_date TEXT,
+          published INTEGER DEFAULT 0,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+
+        CREATE TABLE IF NOT EXISTS logs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          action TEXT NOT NULL,
+          details TEXT,
+          timestamp TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+    } catch (error) {
+      console.error('Error initializing database tables:', error);
+    }
+  }
+  
+  return db;
+};
+
+/**
+ * Initialize database schema
+ * @param {Object} existingDb - Optional existing database connection
+ * @returns {boolean} True if successful
+ * @example
+ * const success = initializeDb();
+ */
+export const initializeDb = (existingDb = null) => {
+  // Use provided database connection or get a new one
+  const db = existingDb || getDb();
+  
+  try {
+    // Create posts table if it doesn't exist
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS posts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        title TEXT,
+        content TEXT NOT NULL,
+        platforms TEXT,
+        publish_date TEXT,
+        published INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        action TEXT NOT NULL,
+        details TEXT,
+        timestamp TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+    
+    return true;
+  } catch (error) {
+    console.error('Error initializing database:', error);
+    return false;
+  }
+};
+
+/**
+ * Get all posts with optional filters
+ * @param {Object} filters - Query filters
+ * @param {boolean} filters.published - Filter by published status
+ * @returns {Array} Array of post objects
+ * @example
+ * const unpublishedPosts = getPosts({ published: false });
+ */
+export const getPosts = (filters = {}) => {
+  const db = getDb();
+  
+  let query = 'SELECT * FROM posts';
+  const params = [];
+  
+  // Apply filters
+  if (filters.published !== undefined) {
+    query += ' WHERE published = ?';
+    params.push(Number(filters.published));
+  }
+  
+  // Add ordering
+  query += ' ORDER BY publish_date ASC';
+  
+  return db.prepare(query).all(...params);
+};
+
+/**
+ * Get a single post by ID
+ * @param {number} id - Post ID
+ * @returns {Object|null} Post object or null if not found
+ * @example
+ * const post = getPostById(1);
+ */
+export const getPostById = (id) => {
+  const db = getDb();
+  return db.prepare('SELECT * FROM posts WHERE id = ?').get(id);
+};
+
+/**
+ * Create a new post
+ * @param {Object} post - Post object
+ * @returns {number} ID of the created post
+ * @example
+ * const postId = createPost({
+ *   title: 'My first post',
+ *   content: 'Hello world!',
+ *   platforms: 'Twitter,Bluesky',
+ *   publish_date: '2023-01-01'
+ * });
+ */
+export const createPost = (post) => {
+  const db = getDb();
+  
+  const { title, content, platforms, publish_date } = post;
+  
+  const result = db.prepare(`
+    INSERT INTO posts (title, content, platforms, publish_date)
+    VALUES (?, ?, ?, ?)
+  `).run(title, content, platforms, publish_date);
+  
+  return result.lastInsertRowid;
+};
+
+/**
+ * Update an existing post
+ * @param {number} id - Post ID
+ * @param {Object} updates - Fields to update
+ * @returns {boolean} True if successful
+ * @example
+ * const success = updatePost(1, {
+ *   title: 'Updated title',
+ *   content: 'Updated content'
+ * });
+ */
+export const updatePost = (id, updates) => {
+  const db = getDb();
+  
+  // Build update query dynamically
+  const fields = Object.keys(updates).filter(field => 
+    ['title', 'content', 'platforms', 'publish_date', 'published'].includes(field)
+  );
+  
+  if (fields.length === 0) return false;
+  
+  const setClause = fields.map(field => `${field} = ?`).join(', ');
+  const params = fields.map(field => updates[field]);
+  
+  // Add updated_at
+  const query = `
+    UPDATE posts
+    SET ${setClause}, updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `;
+  
+  params.push(id);
+  
+  const result = db.prepare(query).run(...params);
+  return result.changes > 0;
+};
+
+/**
+ * Mark posts as published
+ * @param {Array|number} ids - Post ID or array of post IDs
+ * @returns {number} Number of posts updated
+ * @example
+ * const count = markAsPublished([1, 2, 3]);
+ */
+export const markAsPublished = (ids) => {
+  const db = getDb();
+  
+  if (!Array.isArray(ids)) {
+    ids = [ids];
+  }
+  
+  let totalChanges = 0;
+  
+  // Use a transaction for bulk updates
+  const updateStmt = db.prepare(`
+    UPDATE posts
+    SET published = 1, updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `);
+  
+  const transaction = db.transaction((postIds) => {
+    for (const id of postIds) {
+      const result = updateStmt.run(id);
+      totalChanges += result.changes;
+    }
+    return totalChanges;
+  });
+  
+  return transaction(ids);
+};
+
+/**
+ * Log an action to the database
+ * @param {string} action - Action name
+ * @param {Object} details - Additional details (will be JSON.stringified)
+ * @example
+ * logAction('post_created', { postId: 1, platforms: ['Twitter'] });
+ */
+export const logAction = (action, details = {}) => {
+  const db = getDb();
+  
+  db.prepare(`
+    INSERT INTO logs (action, details)
+    VALUES (?, ?)
+  `).run(action, JSON.stringify(details));
+};

package/src/utils/fix-config.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+import { getConfig, updateConfig } from "./config.mjs";
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+
+// This is a utility script to properly set the platformConfigs in config.json
+console.log("Fixing configuration file...");
+
+// Get the current config
+const config = getConfig();
+console.log("Current config:", config);
+
+// Create platformConfigs if it doesn't exist
+if (!config.platformConfigs) {
+  config.platformConfigs = {};
+}
+
+// Get environment variables for Bluesky
+const blueskyHandle = process.env.BLUESKY_HANDLE;
+const blueskyPassword = process.env.BLUESKY_APP_PASSWORD;
+const pdsHost = process.env.PDSHOST || "https://bsky.social";
+
+// Check if we have Bluesky credentials in environment variables
+if (blueskyHandle && blueskyPassword) {
+  console.log("Found Bluesky credentials in environment variables");
+
+  // Add Bluesky configuration to platformConfigs
+  config.platformConfigs.bluesky = {
+    handle: blueskyHandle,
+    password: blueskyPassword,
+    pdshost: pdsHost,
+  };
+
+  // Ensure Bluesky is in defaultPlatforms
+  if (
+    !config.defaultPlatforms ||
+    !config.defaultPlatforms.includes("bluesky")
+  ) {
+    config.defaultPlatforms = ["bluesky"];
+  }
+} else {
+  console.log("No Bluesky credentials found in environment variables");
+
+  // Prompt user for credentials if in interactive mode
+  if (process.stdout.isTTY) {
+    console.log(
+      "Please run the following command to set up Bluesky credentials:"
+    );
+    console.log("social-light init");
+  }
+}
+
+// Save the updated config
+const configPath = path.join(os.homedir(), ".social-light", "config.json");
+fs.writeJsonSync(configPath, config, { spaces: 2 });
+
+console.log("Updated config:", config);
+console.log("Configuration file updated successfully!");

package/src/utils/social/base.mjs

@@ -0,0 +1,142 @@
+/**
+ * Base Social Platform API Interface
+ * All platform-specific API implementations should extend this class
+ */
+export class SocialPlatform {
+  /**
+   * Constructor for the base social platform
+   * @param {Object} config - Platform-specific configuration
+   */
+  constructor(config = {}) {
+    this.config = config;
+    this.name = "base";
+    this.authenticated = false;
+  }
+
+  /**
+   * Check if platform is properly configured
+   * @returns {boolean} True if platform is configured
+   */
+  isConfigured() {
+    return false;
+  }
+
+  /**
+   * Authenticate with the platform API
+   * @returns {Promise<boolean>} True if authentication successful
+   */
+  async authenticate() {
+    this.authenticated = false;
+    return false;
+  }
+
+  /**
+   * Post content to the platform
+   * @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 (if applicable)
+   * @param {Array<string>} post.mediaUrls - Array of media URLs to attach
+   * @param {Object} post.options - Platform-specific options
+   * @returns {Promise<Object>} Response data including post ID or errors
+   */
+  async post(post) {
+    throw new Error("Method not implemented");
+  }
+
+  /**
+   * Get status of a post
+   * @param {string} postId - ID of the post to check
+   * @returns {Promise<Object>} Status information
+   */
+  async getPostStatus(postId) {
+    throw new Error("Method not implemented");
+  }
+
+  /**
+   * Delete a post from the platform
+   * @param {string} postId - ID of the post to delete
+   * @returns {Promise<boolean>} True if deletion successful
+   */
+  async deletePost(postId) {
+    throw new Error("Method not implemented");
+  }
+}
+
+/**
+ * Placeholder for unsupported platforms
+ */
+class UnsupportedPlatform extends SocialPlatform {
+  /**
+   * Constructor for unsupported platform
+   * @param {string} platformName - Name of the unsupported platform
+   * @param {Object} config - Configuration
+   */
+  constructor(platformName, config = {}) {
+    super(config);
+    this.name = platformName.toLowerCase();
+    this.authenticated = false;
+  }
+
+  /**
+   * Check if platform is properly configured
+   * @returns {boolean} Always returns false
+   */
+  isConfigured() {
+    return false;
+  }
+
+  /**
+   * Authentication attempt (always fails)
+   * @returns {Promise<boolean>} Always returns false
+   */
+  async authenticate() {
+    console.warn(`Platform '${this.name}' is not currently supported.`);
+    return false;
+  }
+
+  /**
+   * Post attempt (always fails)
+   * @returns {Promise<Object>} Error response
+   */
+  async post() {
+    throw new Error(`Platform '${this.name}' is not currently supported.`);
+  }
+
+  /**
+   * Get status attempt (always fails)
+   * @returns {Promise<Object>} Error response
+   */
+  async getPostStatus() {
+    throw new Error(`Platform '${this.name}' is not currently supported.`);
+  }
+
+  /**
+   * Delete attempt (always fails)
+   * @returns {Promise<boolean>} Always returns false
+   */
+  async deletePost() {
+    throw new Error(`Platform '${this.name}' is not currently supported.`);
+  }
+}
+
+/**
+ * Factory for creating platform instances
+ */
+export const PlatformFactory = {
+  /**
+   * Create a new platform instance
+   * @param {string} platform - Platform name (only 'bluesky' is supported)
+   * @param {Object} config - Platform-specific configuration
+   * @returns {SocialPlatform} Platform instance
+   */
+  create(platform, config = {}) {
+    switch (platform.toLowerCase()) {
+      case "bluesky":
+        return import("./bluesky.mjs").then(
+          (module) => new module.BlueskyPlatform(config)
+        );
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+  },
+};