social-light 0.0.1

package/src/server/index.mjs

@@ -0,0 +1,315 @@
+import express from "express";
+import cors from "cors";
+import path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { exec } from "child_process";
+import {
+  getPosts,
+  getPostById,
+  createPost,
+  updatePost,
+  markAsPublished,
+  logAction,
+} from "../utils/db.mjs";
+import { getSocialAPI } from "../utils/social/index.mjs";
+import {
+  generateTitle,
+  suggestPublishDate,
+  enhanceContent,
+} from "../utils/ai.mjs";
+import { getConfig } from "../utils/config.mjs";
+
+// Get directory name in ESM
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Start the web server
+ * @param {Object} argv - Command arguments
+ */
+export const startServer = async (argv) => {
+  const app = express();
+  const port = argv.port || 3000;
+  const shouldOpen = !argv.noOpen; // Open by default, disabled with --no-open
+
+  // Middleware
+  app.use(cors());
+  app.use(express.json());
+
+  // Serve static files from 'client' directory
+  app.use(express.static(path.join(__dirname, "client")));
+
+  // API routes
+  setupApiRoutes(app);
+
+  // Serve React app for all other routes
+  app.get("*", (req, res) => {
+    res.sendFile(path.join(__dirname, "client", "index.html"));
+  });
+
+  // Start server
+  app.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log(chalk.green(`✓ Server started on port ${port}`));
+    console.log(
+      chalk.cyan(
+        `Opening ${url} in your browser...`
+      )
+    );
+    console.log(chalk.gray("Press Ctrl+C to stop the server"));
+    
+    // Open URL in default browser if not disabled
+    if (shouldOpen) {
+      // Open URL in default browser based on platform
+      let command;
+      switch (process.platform) {
+        case 'darwin': // macOS
+          command = `open ${url}`;
+          break;
+        case 'win32': // Windows
+          command = `start ${url}`;
+          break;
+        default: // Linux and others
+          command = `xdg-open ${url}`;
+      }
+      
+      // Execute the command to open the browser
+      exec(command, (error) => {
+        if (error) {
+          console.error(chalk.yellow(`Unable to open browser automatically: ${error.message}`));
+          console.log(chalk.cyan(`Open ${url} in your browser to access the web interface`));
+        }
+      });
+    } else {
+      console.log(chalk.cyan(`Open ${url} in your browser to access the web interface`));
+    }
+  });
+};
+
+/**
+ * Set up API routes
+ * @param {Express} app - Express app
+ */
+const setupApiRoutes = (app) => {
+  // Get API info
+  app.get("/api", (req, res) => {
+    res.json({
+      name: "Social Light API",
+      version: "1.0.0",
+      endpoints: [
+        "/api/posts",
+        "/api/posts/:id",
+        "/api/publish/:id",
+        "/api/ai/title",
+        "/api/ai/date",
+        "/api/ai/enhance",
+        "/api/config",
+      ],
+    });
+  });
+
+  // Get configuration
+  app.get("/api/config", (req, res) => {
+    const config = getConfig();
+
+    // Remove sensitive information
+    const safeConfig = {
+      ...config,
+      // Add default platforms for client
+      platforms: [
+        // { id: 'twitter', name: 'Twitter', icon: 'twitter' },
+        { id: "bluesky", name: "Bluesky", icon: "cloud" },
+        // { id: 'tiktok', name: 'TikTok', icon: 'music' }
+      ],
+    };
+
+    res.json(safeConfig);
+  });
+
+  // Get all posts
+  app.get("/api/posts", (req, res) => {
+    try {
+      const published = req.query.published === "true";
+      const posts = getPosts({ published });
+      res.json(posts);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get post by ID
+  app.get("/api/posts/:id", (req, res) => {
+    try {
+      const post = getPostById(parseInt(req.params.id, 10));
+
+      if (!post) {
+        return res.status(404).json({ error: "Post not found" });
+      }
+
+      res.json(post);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Create new post
+  app.post("/api/posts", async (req, res) => {
+    try {
+      const { title, content, platforms, publish_date } = req.body;
+
+      if (!content) {
+        return res.status(400).json({ error: "Content is required" });
+      }
+
+      const postId = createPost({
+        title,
+        content,
+        platforms: Array.isArray(platforms) ? platforms.join(",") : platforms,
+        publish_date,
+      });
+
+      logAction("post_created", { postId, source: "web" });
+
+      res.status(201).json({ id: postId });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Update post
+  app.put("/api/posts/:id", async (req, res) => {
+    try {
+      const id = parseInt(req.params.id, 10);
+      const { title, content, platforms, publish_date } = req.body;
+
+      const post = getPostById(id);
+
+      if (!post) {
+        return res.status(404).json({ error: "Post not found" });
+      }
+
+      const success = updatePost(id, {
+        title,
+        content,
+        platforms: Array.isArray(platforms) ? platforms.join(",") : platforms,
+        publish_date,
+      });
+
+      if (!success) {
+        return res.status(500).json({ error: "Failed to update post" });
+      }
+
+      logAction("post_updated", { postId: id, source: "web" });
+
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Publish post
+  app.post("/api/publish/:id", async (req, res) => {
+    try {
+      const id = parseInt(req.params.id, 10);
+      const post = getPostById(id);
+
+      if (!post) {
+        return res.status(404).json({ error: "Post not found" });
+      }
+
+      if (post.published) {
+        return res.status(400).json({ error: "Post is already published" });
+      }
+
+      if (!post.platforms) {
+        return res
+          .status(400)
+          .json({ error: "No platforms specified for post" });
+      }
+
+      // Initialize social API
+      const socialAPI = getSocialAPI();
+      const platforms = post.platforms.split(",").map((p) => p.trim());
+
+      // Publish post to specified platforms
+      const result = await socialAPI.post({
+        text: post.content,
+        title: post.title,
+        platforms,
+      });
+
+      // Check if post was successfully published to at least one platform
+      const anySuccess = Object.values(result.results).some((r) => r.success);
+
+      if (anySuccess) {
+        markAsPublished(id);
+
+        // Log the action with platform results
+        logAction("post_published", {
+          postId: id,
+          platforms: result.results,
+          source: "web",
+        });
+
+        res.json({
+          success: true,
+          platforms: result.results,
+        });
+      } else {
+        res.status(500).json({
+          success: false,
+          error: "Failed to publish to any platform",
+          platforms: result.results,
+        });
+      }
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Generate title with AI
+  app.post("/api/ai/title", async (req, res) => {
+    try {
+      const { content } = req.body;
+
+      if (!content) {
+        return res.status(400).json({ error: "Content is required" });
+      }
+
+      const title = await generateTitle(content);
+      res.json({ title });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Suggest publish date with AI
+  app.get("/api/ai/date", async (req, res) => {
+    try {
+      const date = await suggestPublishDate();
+      res.json({ date });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Enhance content with AI
+  app.post("/api/ai/enhance", async (req, res) => {
+    try {
+      const { content, platform } = req.body;
+
+      if (!content) {
+        return res.status(400).json({ error: "Content is required" });
+      }
+
+      if (!platform) {
+        return res.status(400).json({ error: "Platform is required" });
+      }
+
+      const enhanced = await enhanceContent(content, platform);
+      res.json({ enhanced });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+};

package/src/utils/ai.mjs

@@ -0,0 +1,201 @@
+import { OpenAI } from 'openai';
+import { getConfig } from './config.mjs';
+import { getPosts, getDb } from './db.mjs';
+
+// Initialize OpenAI client
+let openaiClient = null;
+
+/**
+ * Get OpenAI client instance
+ * @returns {OpenAI|null} OpenAI client or null if AI is disabled
+ * @example
+ * const openai = getOpenAIClient();
+ * if (openai) {
+ *   // Use openai client
+ * }
+ */
+export const getOpenAIClient = () => {
+  const config = getConfig();
+  
+  if (!config.aiEnabled) {
+    return null;
+  }
+  
+  if (!openaiClient) {
+    // Attempt to get API key from environment variable
+    const apiKey = process.env.OPENAI_API_KEY;
+    
+    if (!apiKey) {
+      console.warn('Warning: OPENAI_API_KEY environment variable not set. AI features will be limited.');
+      return null;
+    }
+    
+    openaiClient = new OpenAI({
+      apiKey
+    });
+  }
+  
+  return openaiClient;
+};
+
+/**
+ * Generate a title for a post using AI
+ * @param {string} content - Post content
+ * @returns {string} Generated title
+ * @example
+ * const title = await generateTitle('This is my first post about AI technology...');
+ */
+export const generateTitle = async (content) => {
+  const openai = getOpenAIClient();
+  
+  if (!openai) {
+    // Fallback to simple title generation if AI is disabled
+    return content.split(' ').slice(0, 5).join(' ') + '...';
+  }
+  
+  try {
+    const response = await openai.chat.completions.create({
+      model: 'gpt-3.5-turbo',
+      messages: [
+        {
+          role: 'system',
+          content: 'You are a headline writer assistant that creates catchy, engaging titles for social media posts. Generate a short, attention-grabbing title based on the content provided. Keep it under 60 characters if possible.'
+        },
+        {
+          role: 'user',
+          content: `Create a title for this social media post: "${content.substring(0, 500)}${content.length > 500 ? '...' : ''}"`
+        }
+      ],
+      max_tokens: 60
+    });
+    
+    return response.choices[0].message.content.trim().replace(/^"|"$/g, '');
+  } catch (error) {
+    console.error('Error generating title:', error.message);
+    // Fallback
+    return content.split(' ').slice(0, 5).join(' ') + '...';
+  }
+};
+
+/**
+ * Suggest a publish date for a post using AI
+ * @returns {string} Suggested publish date in YYYY-MM-DD format
+ * @example
+ * const date = await suggestPublishDate();
+ */
+export const suggestPublishDate = async () => {
+  const openai = getOpenAIClient();
+  
+  // Get database connection and check if posts table exists
+  const db = getDb();
+  
+  try {
+    // Check if posts table exists
+    const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='posts';").get();
+    
+    if (!tableExists) {
+      // If table doesn't exist, just return tomorrow's date
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      return tomorrow.toISOString().split('T')[0];
+    }
+    
+    // Get historical posts for analysis if table exists
+    const posts = getPosts();
+    const today = new Date();
+    
+    if (!openai || posts.length < 3) {
+      // Fallback to simple date suggestion if AI is disabled or not enough data
+      const tomorrow = new Date(today);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      return tomorrow.toISOString().split('T')[0];
+    }
+    
+    // Format post history for the AI
+    const postHistory = posts
+      .filter(post => post.publish_date)
+      .map(post => ({
+        date: post.publish_date,
+        platform: post.platforms
+      }));
+    
+    const response = await openai.chat.completions.create({
+      model: 'gpt-3.5-turbo',
+      messages: [
+        {
+          role: 'system',
+          content: 'You are a social media scheduling assistant. Based on the user\'s posting history, suggest an optimal date for their next post. Consider post frequency, patterns, and optimal timing. Return only the date in YYYY-MM-DD format.'
+        },
+        {
+          role: 'user',
+          content: `Here is my posting history: ${JSON.stringify(postHistory)}. Today is ${today.toISOString().split('T')[0]}. When should I schedule my next post?`
+        }
+      ],
+      max_tokens: 20
+    });
+    
+    const suggestedDate = response.choices[0].message.content.trim();
+    
+    // Validate date format
+    if (/^\d{4}-\d{2}-\d{2}$/.test(suggestedDate)) {
+      return suggestedDate;
+    }
+    
+    // Extract date if the AI included other text
+    const dateMatch = suggestedDate.match(/\d{4}-\d{2}-\d{2}/);
+    if (dateMatch) {
+      return dateMatch[0];
+    }
+    
+    // Fallback
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    return tomorrow.toISOString().split('T')[0];
+  } catch (error) {
+    console.error('Error suggesting publish date:', error.message);
+    
+    // Fallback
+    const today = new Date();
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    return tomorrow.toISOString().split('T')[0];
+  }
+};
+
+/**
+ * Enhance content with AI suggestions
+ * @param {string} content - Original content
+ * @param {string} platform - Target platform
+ * @returns {string} Enhanced content
+ * @example
+ * const enhanced = await enhanceContent('Check out our new product!', 'Twitter');
+ */
+export const enhanceContent = async (content, platform) => {
+  const openai = getOpenAIClient();
+  
+  if (!openai) {
+    return content;
+  }
+  
+  try {
+    const response = await openai.chat.completions.create({
+      model: 'gpt-3.5-turbo',
+      messages: [
+        {
+          role: 'system',
+          content: `You are a social media expert who helps enhance posts for ${platform}. Provide an improved version of the user's content, optimized for engagement on ${platform}. You may suggest hashtags, emojis, or slight rewording, but preserve the original message and voice.`
+        },
+        {
+          role: 'user',
+          content: `Enhance this ${platform} post: "${content}"`
+        }
+      ],
+      max_tokens: 1000
+    });
+    
+    return response.choices[0].message.content.trim().replace(/^"|"$/g, '');
+  } catch (error) {
+    console.error('Error enhancing content:', error.message);
+    return content;
+  }
+};

package/src/utils/config.mjs

@@ -0,0 +1,127 @@
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+
+// Default configuration
+const defaultConfig = {
+  dbPath: "~/.social-light/social-light.db",
+  defaultPlatforms: ["Bluesky"],
+  aiEnabled: true,
+  credentials: {
+    openai: {
+      apiKey: "",
+    },
+    bluesky: {
+      handle: "",
+      password: "",
+      service: "https://bsky.social",
+    },
+  },
+};
+
+/**
+ * Get config file path
+ * @returns {string} Path to config file
+ * @example
+ * const configPath = getConfigPath();
+ */
+export const getConfigPath = () => {
+  return path.join(os.homedir(), ".social-light", "config.json");
+};
+
+/**
+ * Check if config exists
+ * @returns {boolean} True if config exists
+ * @example
+ * const exists = configExists();
+ */
+export const configExists = () => {
+  return fs.existsSync(getConfigPath());
+};
+
+/**
+ * Create default config
+ * @returns {Object} Created config object
+ * @example
+ * const config = createDefaultConfig();
+ */
+export const createDefaultConfig = () => {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  fs.ensureDirSync(configDir);
+  fs.writeJsonSync(configPath, defaultConfig, { spaces: 2 });
+
+  return defaultConfig;
+};
+
+/**
+ * Get current config, creating default if it doesn't exist
+ * @returns {Object} Config object
+ * @example
+ * const config = getConfig();
+ * console.log(config.aiEnabled);
+ */
+export const getConfig = () => {
+  if (!configExists()) {
+    return createDefaultConfig();
+  }
+
+  return fs.readJsonSync(getConfigPath());
+};
+
+/**
+ * Update config
+ * @param {Object} updates - Config fields to update
+ * @returns {Object} Updated config
+ * @example
+ * const updatedConfig = updateConfig({ aiEnabled: false });
+ */
+export const updateConfig = (updates) => {
+  const config = getConfig();
+  const newConfig = { ...config, ...updates };
+
+  fs.writeJsonSync(getConfigPath(), newConfig, { spaces: 2 });
+
+  return newConfig;
+};
+
+/**
+ * Get credentials from config
+ * @param {string} platform - Platform name (e.g., 'bluesky', 'openai')
+ * @returns {Object} Credentials object
+ * @example
+ * const blueskyCredentials = getCredentials('bluesky');
+ */
+export const getCredentials = (platform) => {
+  const config = getConfig();
+  return config.credentials?.[platform.toLowerCase()] || {};
+};
+
+/**
+ * Update credentials in config
+ * @param {string} platform - Platform name (e.g., 'bluesky', 'openai')
+ * @param {Object} credentials - Credentials object
+ * @returns {Object} Updated config
+ * @example
+ * const updatedConfig = updateCredentials('bluesky', { handle: 'user.bsky.social', password: 'apppassword' });
+ */
+export const updateCredentials = (platform, credentials) => {
+  const config = getConfig();
+
+  // Ensure credentials object exists
+  if (!config.credentials) {
+    config.credentials = {};
+  }
+
+  // Update credentials for the platform
+  config.credentials[platform.toLowerCase()] = {
+    ...config.credentials[platform.toLowerCase()],
+    ...credentials,
+  };
+
+  // Save updated config
+  fs.writeJsonSync(getConfigPath(), config, { spaces: 2 });
+
+  return config;
+};