kk

backend/__init__.py

@@ -0,0 +1,2 @@
+# backend/__init__.py
+# This file makes the backend directory a Python package

backend/api/posts.py

@@ -141,12 +141,23 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
         # Generate content using content service
         # Pass the Hugging Face key directly to the service
         content_service = ContentService(hugging_key=hugging_key)
-        generated_content = content_service.generate_post_content(user_id)
+        generated_result = content_service.generate_post_content(user_id)
+        
+        # Handle the case where generated_result might be a tuple (content, image_data)
+        # image_data could be bytes (from base64) or a string (URL)
+        if isinstance(generated_result, tuple):
+            generated_content, image_data = generated_result
+        else:
+            generated_content = generated_result
+            image_data = None
         
         # Update job status to completed with result
         job_store[job_id] = {
             'status': 'completed',
-            'result': generated_content,
+            'result': {
+                'content': generated_content,
+                'image_data': image_data  # This could be bytes or a URL string
+            },
             'error': None
         }
         
@@ -248,7 +259,25 @@ def get_job_status(job_id):
         
         # Include result or error if available
         if job['status'] == 'completed':
-            response_data['content'] = job['result']
+            # Handle the new structure of the result
+            if isinstance(job['result'], dict) and 'content' in job['result']:
+                response_data['content'] = job['result']['content']
+                # Handle image_data which could be bytes or a URL string
+                image_data = job['result'].get('image_data')
+                if isinstance(image_data, bytes):
+                    # If it's bytes, we can't send it directly in JSON
+                    # For now, we'll set it to None and let the frontend know
+                    # In a future update, we might save it to storage and return a URL
+                    response_data['image_url'] = None
+                    response_data['has_image_data'] = True  # Flag to indicate image data exists
+                else:
+                    # If it's a string, assume it's a URL
+                    response_data['image_url'] = image_data
+                    response_data['has_image_data'] = False
+            else:
+                response_data['content'] = job['result']
+                response_data['image_url'] = None
+                response_data['has_image_data'] = False
         elif job['status'] == 'failed':
             response_data['error'] = job['error']
             
@@ -335,12 +364,24 @@ def publish_post_direct():
             }), 400
         
         # Get optional fields
-        image_url = data.get('image_content_url')
+        image_data = data.get('image_content_url')  # This could be bytes or a URL string
+        
+        # Handle image data - if it's bytes, we need to convert it for LinkedIn
+        image_url_for_linkedin = None
+        if image_data:
+            if isinstance(image_data, bytes):
+                # If it's bytes, we can't directly send it to LinkedIn
+                # For now, we'll skip sending the image to LinkedIn
+                # In a future update, we might save it to storage and get a URL
+                current_app.logger.warning("Image data is in bytes format, skipping LinkedIn upload for now")
+            else:
+                # If it's a string, assume it's a URL
+                image_url_for_linkedin = image_data
         
         # Publish to LinkedIn
         linkedin_service = LinkedInService()
         publish_response = linkedin_service.publish_post(
-            access_token, user_sub, text_content, image_url
+            access_token, user_sub, text_content, image_url_for_linkedin
         )
         
         # Save to database as published
@@ -351,8 +392,8 @@ def publish_post_direct():
         }
         
         # Add optional fields if provided
-        if image_url:
-            post_data['image_content_url'] = image_url
+        if image_data:
+            post_data['image_content_url'] = image_data
             
         if 'scheduled_at' in data:
             post_data['scheduled_at'] = data['scheduled_at']
@@ -462,9 +503,12 @@ def create_post():
             'is_published': data.get('is_published', True)  # Default to True
         }
         
+        # Handle image data - could be bytes or a URL string
+        image_data = data.get('image_content_url')
+        
         # Add optional fields if provided
-        if 'image_content_url' in data:
-            post_data['image_content_url'] = data['image_content_url']
+        if image_data is not None:
+            post_data['image_content_url'] = image_data
             
         if 'scheduled_at' in data:
             post_data['scheduled_at'] = data['scheduled_at']

backend/models/post.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Union
 from datetime import datetime
 
 @dataclass
@@ -10,7 +10,7 @@ class Post:
     Text_content: str
     is_published: bool = True
     sched: Optional[str] = None
-    image_content_url: Optional[str] = None
+    image_content_url: Optional[Union[str, bytes]] = None  # Can be URL string or bytes
     created_at: Optional[datetime] = None
     scheduled_at: Optional[datetime] = None
     

backend/services/content_service.py

@@ -1,9 +1,12 @@
 import re
 import json
 import unicodedata
+import io
 from flask import current_app
 from gradio_client import Client
 import pandas as pd
+from PIL import Image
+import base64
 
 class ContentService:
     """Service for AI content generation using Hugging Face models."""
@@ -66,7 +69,45 @@ class ContentService:
         
         return validated
     
-    def generate_post_content(self, user_id: str) -> str:
+    def _is_base64_image(self, data):
+        """Check if the data is a base64 encoded image string."""
+        if not isinstance(data, str):
+            return False
+        
+        # Check if it starts with data URL prefix
+        if data.startswith('data:image/'):
+            return True
+        
+        # Try to decode as base64
+        try:
+            # Extract base64 part if it's a data URL
+            if ',' in data:
+                base64_part = data.split(',')[1]
+            else:
+                base64_part = data
+            
+            # Try to decode
+            base64.b64decode(base64_part, validate=True)
+            return True
+        except Exception:
+            return False
+    
+    def _base64_to_bytes(self, base64_string):
+        """Convert a base64 encoded string to bytes."""
+        try:
+            # If it's a data URL, extract the base64 part
+            if base64_string.startswith('data:image/'):
+                base64_part = base64_string.split(',')[1]
+            else:
+                base64_part = base64_string
+            
+            # Decode base64 to bytes
+            return base64.b64decode(base64_part, validate=True)
+        except Exception as e:
+            current_app.logger.error(f"Failed to decode base64 image: {str(e)}")
+            raise Exception(f"Failed to decode base64 image: {str(e)}")
+    
+    def generate_post_content(self, user_id: str) -> tuple:
         """
         Generate post content using AI.
         
@@ -74,7 +115,7 @@ class ContentService:
             user_id (str): User ID for personalization
             
         Returns:
-            str: Generated post content
+            tuple: (Generated post content, Image URL or None)
         """
         try:
             # Call the Hugging Face model to generate content
@@ -100,8 +141,11 @@ class ContentService:
             # Extract the first element if it's a list
             if isinstance(parsed_result, list):
                 generated_content = parsed_result[0] if parsed_result and parsed_result[0] is not None else "Generated content will appear here..."
+                # Extract the second element as image URL if it exists
+                image_data = parsed_result[1] if len(parsed_result) > 1 and parsed_result[1] is not None else None
             else:
                 generated_content = str(parsed_result) if parsed_result is not None else "Generated content will appear here..."
+                image_data = None
                 
             # Validate, sanitize, and preserve formatting of the generated content
             sanitized_content = self.sanitize_content_for_api(generated_content)
@@ -109,7 +153,17 @@ class ContentService:
             # Ensure paragraph breaks and formatting are preserved
             final_content = self.preserve_formatting(sanitized_content)
             
-            return final_content
+            # Handle image data - could be URL or base64
+            image_bytes = None
+            if image_data:
+                if self._is_base64_image(image_data):
+                    # Convert base64 to bytes for storage
+                    image_bytes = self._base64_to_bytes(image_data)
+                else:
+                    # It's a URL, keep as string
+                    image_bytes = image_data
+            
+            return (final_content, image_bytes)
             
         except Exception as e:
             error_message = str(e)

backend/services/linkedin_service.py

@@ -130,7 +130,7 @@ class LinkedInService:
             access_token (str): LinkedIn access token
             user_id (str): LinkedIn user ID
             text_content (str): Post content
-            image_url (str, optional): Image URL
+            image_url (str, optional): Image URL (must be a URL, not bytes)
             
         Returns:
             dict: Publish response
@@ -142,7 +142,8 @@ class LinkedInService:
             "Content-Type": "application/json"
         }
         
-        if image_url:
+        # Skip image handling if image_url is not a string (i.e., if it's bytes)
+        if image_url and isinstance(image_url, str):
             # Handle image upload
             register_body = {
                 "registerUploadRequest": {

frontend/src/pages/Posts.jsx

@@ -22,6 +22,7 @@ const Posts = () => {
   
   const [selectedAccount, setSelectedAccount] = useState('');
   const [postContent, setPostContent] = useState('');
+  const [postImage, setPostImage] = useState(null); // State for image URL
   const [isGenerating, setIsGenerating] = useState(false);
   const [isCreating, setIsCreating] = useState(false);
   
@@ -34,19 +35,33 @@ const Posts = () => {
   
   const handleGeneratePost = async () => {
     setIsGenerating(true);
+    setPostImage(null); // Reset image when generating new post
     
     try {
       const result = await dispatch(generatePost()).unwrap();
       
       // Handle case where content might be a list
       let content = result.content || 'Generated content will appear here...';
+      let image = null;
       
-      // If content is an array, take the first element
+      // If content is an array, handle both content and image
       if (Array.isArray(content)) {
         content = content[0] || 'Generated content will appear here...';
+        image = content[1] || null; // Second element might be image URL
+      } 
+      // If result has image_url property (from backend)
+      else if (result.image_url) {
+        image = result.image_url;
+      }
+      // If result has has_image_data property, it means image data exists but is in bytes
+      else if (result.has_image_data) {
+        // For now, we'll just show a placeholder or message
+        // In a future update, we might fetch the image data separately
+        image = 'HAS_IMAGE_DATA_BUT_NOT_URL'; // Special marker
       }
       
       setPostContent(content);
+      setPostImage(image);
     } catch (err) {
       console.error('Failed to generate post:', err);
       // Show a user-friendly error message
@@ -73,26 +88,42 @@ const Posts = () => {
     try {
       // Publish directly to LinkedIn
       console.log('📝 [Posts] Publishing to LinkedIn');
-      const publishResult = await dispatch(publishPostDirect({
+      const publishData = {
         social_account_id: selectedAccount,
         text_content: postContent
-      })).unwrap();
+      };
+      
+      // Add image URL if available
+      if (postImage) {
+        publishData.image_content_url = postImage;
+      }
+      
+      const publishResult = await dispatch(publishPostDirect(publishData)).unwrap();
       
       console.log('📝 [Posts] Published to LinkedIn successfully:', publishResult);
       
       // Only save to database if LinkedIn publish was successful
       console.log('📝 [Posts] Saving post to database as published');
-      await dispatch(createPost({
+      const createData = {
         social_account_id: selectedAccount,
         text_content: postContent,
         is_published: true // Mark as published since we've already published it
-      })).unwrap();
+      };
+      
+      // Add image URL if available
+      if (postImage) {
+        createData.image_content_url = postImage;
+      }
+      
+      await dispatch(createPost(createData)).unwrap();
       
       console.log('📝 [Posts] Post saved to database');
       
       // Reset form
       setSelectedAccount('');
       setPostContent('');
+      setPostImage(null);
+      setPostImage(null);
     } catch (err) {
       console.error('📝 [Posts] Failed to publish post:', err);
       // Don't save to database if LinkedIn publish failed
@@ -111,6 +142,11 @@ const Posts = () => {
   
   const handleContentChange = (content) => {
     setPostContent(content);
+    // If user manually edits content, we should clear the AI-generated image
+    // as it might no longer be relevant
+    if (postImage) {
+      setPostImage(null);
+    }
   };
   
   // Filter published posts
@@ -319,6 +355,44 @@ const Posts = () => {
                 </div>
               </div>
               
+              {/* Image Preview */}
+              {postImage && postImage !== 'HAS_IMAGE_DATA_BUT_NOT_URL' && (
+                <div className="space-y-3 sm:space-y-4">
+                  <label className="block text-xs sm:text-sm font-semibold text-gray-700">Generated Image</label>
+                  <div className="relative border border-gray-300 rounded-xl overflow-hidden bg-gray-50">
+                    <img 
+                      src={postImage} 
+                      alt="Generated post content" 
+                      className="w-full max-h-96 object-contain"
+                      onError={(e) => {
+                        // If image fails to load, remove it from state
+                        setPostImage(null);
+                        e.target.style.display = 'none';
+                      }}
+                    />
+                    <div className="absolute top-2 right-2 bg-black/50 text-white text-xs px-2 py-1 rounded">
+                      AI Generated
+                    </div>
+                  </div>
+                </div>
+              )}
+              
+              {/* Image Data Exists Message */}
+              {postImage === 'HAS_IMAGE_DATA_BUT_NOT_URL' && (
+                <div className="space-y-3 sm:space-y-4">
+                  <label className="block text-xs sm:text-sm font-semibold text-gray-700">Generated Image</label>
+                  <div className="relative border border-gray-300 rounded-xl overflow-hidden bg-gray-50 p-4">
+                    <div className="text-center text-gray-500">
+                      <svg className="w-12 h-12 mx-auto mb-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
+                      </svg>
+                      <p className="text-sm">Image data exists but cannot be displayed directly</p>
+                      <p className="text-xs mt-1">The image will be included when you publish the post</p>
+                    </div>
+                  </div>
+                </div>
+              )}
+              
               {/* Create Post Form */}
               <form onSubmit={handleCreatePost} className="create-post-form grid grid-cols-1 sm:grid-cols-3 gap-3 sm:gap-4">
                 <div className="form-field sm:col-span-2">

frontend/src/store/reducers/postsSlice.js

@@ -91,10 +91,14 @@ const postsSlice = createSlice({
     },
     updatePostContent: (state, action) => {
       // This reducer can be used to update post content in the store
-      const { postId, content } = action.payload;
+      const { postId, content, image } = action.payload;
       const postIndex = state.items.findIndex(item => item.id === postId);
       if (postIndex !== -1) {
-        state.items[postIndex] = { ...state.items[postIndex], Text_content: content };
+        state.items[postIndex] = { 
+          ...state.items[postIndex], 
+          Text_content: content,
+          ...(image && { image_content_url: image }) // Only update image if provided
+        };
       }
     }
   },

frontend/vite.config.js

@@ -16,7 +16,7 @@ export default defineConfig({
   },
   server: {
     port: 3000,
-    host: true, // Allow access from external devices on the same network
+    host: 'localhost', // Explicitly bind to localhost
     proxy: {
       '/api': {
         target: 'http://localhost:5000',

package.json

@@ -9,8 +9,9 @@
     "install:all": "npm run install:frontend && npm run install:backend",
     "install:all:win": "npm run install:frontend && cd backend && python -m pip install -r requirements.txt",
     "dev:frontend": "cd frontend && npm run dev",
-    "dev:backend": "cd backend && python app.py",
+    "dev:backend": "cd backend && set PYTHONPATH=. && python app.py",
     "dev:all": "concurrently \"npm run dev:frontend\" \"npm run dev:backend\"",
+    "dev": "concurrently \"npm run dev:frontend\" \"npm run dev:backend\"",
     "build": "cd frontend && npm run build",
     "build:prod": "cd frontend && npm run build:prod",
     "preview": "cd frontend && npm run preview",
@@ -47,4 +48,4 @@
   "dependencies": {
     "@rushstack/eslint-patch": "^1.12.0"
   }
-}
+}

start-dev.js

@@ -0,0 +1,47 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+console.log('🚀 Starting Lin Development Environment...');
+console.log('==========================================\n');
+
+// Start backend process
+console.log('🔧 Starting Backend Server...');
+const backend = spawn('python', ['app.py'], {
+  cwd: path.join(__dirname, 'backend'),
+  stdio: 'inherit',
+  shell: true
+});
+
+// Start frontend process
+console.log('🎨 Starting Frontend Development Server...');
+const frontend = spawn('npm', ['run', 'dev'], {
+  cwd: path.join(__dirname, 'frontend'),
+  stdio: 'inherit',
+  shell: true
+});
+
+// Handle process events
+backend.on('close', (code) => {
+  console.log(`Backend process exited with code ${code}`);
+  frontend.kill();
+});
+
+frontend.on('close', (code) => {
+  console.log(`Frontend process exited with code ${code}`);
+  backend.kill();
+});
+
+// Handle exit signals
+process.on('SIGINT', () => {
+  console.log('\n🛑 Shutting down development servers...');
+  backend.kill();
+  frontend.kill();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.log('\n🛑 Shutting down development servers...');
+  backend.kill();
+  frontend.kill();
+  process.exit(0);
+});