Merge pull request #3 from Zelyanne/main

backend/api/posts.py

@@ -7,6 +7,7 @@ from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.content_service import ContentService
 from backend.services.linkedin_service import LinkedInService
 from backend.utils.image_utils import ensure_bytes_format
+from backend.utils.redis_job_store import get_redis_job_store
 
 posts_bp = Blueprint('posts', __name__)
 
@@ -107,16 +108,15 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
     Args:
         user_id (str): User ID for personalization
         job_id (str): Job ID to update status in job store
-        job_store (dict): Job store dictionary
+        job_store (dict): Job store dictionary (kept for backward compatibility, but now using Redis)
         hugging_key (str): Hugging Face API key
     """
     try:
+        # Get Redis job store
+        redis_job_store = get_redis_job_store()
+
         # Update job status to processing
-        job_store[job_id] = {
-            'status': 'processing',
-            'result': None,
-            'error': None
-        }
+        redis_job_store.update_job(job_id, status='processing')
 
         # Generate content using content service
         # Pass the Hugging Face key directly to the service
@@ -136,24 +136,23 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             image_data = None
 
         # Update job status to completed with result
-        job_store[job_id] = {
-            'status': 'completed',
-            'result': {
+        redis_job_store.update_job(job_id,
+            status='completed',
+            result={
                 'content': generated_content,
                 'image_data': image_data  # This could be bytes or a URL string
-            },
-            'error': None
-        }
+            }
+        )
 
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Generate post background task error: {error_message}")
         # Update job status to failed with error
-        job_store[job_id] = {
-            'status': 'failed',
-            'result': None,
-            'error': error_message
-        }
+        redis_job_store = get_redis_job_store()
+        redis_job_store.update_job(job_id,
+            status='failed',
+            error=error_message
+        )
 
 @posts_bp.route('/generate', methods=['POST'])
 @jwt_required()
@@ -184,12 +183,10 @@ def generate_post():
         # Create a job ID
         job_id = str(uuid.uuid4())
 
-        # Initialize job status
-        current_app.job_store[job_id] = {
-            'status': 'pending',
-            'result': None,
-            'error': None
-        }
+        # Initialize job status in Redis store
+        from backend.utils.redis_job_store import get_redis_job_store
+        redis_job_store = get_redis_job_store()
+        redis_job_store.create_job(job_id, 'pending')
 
         # Get Hugging Face key
         hugging_key = current_app.config['HUGGING_KEY']
@@ -227,8 +224,10 @@ def get_job_status(job_id):
         JSON: Job status and result if completed
     """
     try:
-        # Get job from store
-        job = current_app.job_store.get(job_id)
+        # Get job from Redis store
+        from backend.utils.redis_job_store import get_redis_job_store
+        redis_job_store = get_redis_job_store()
+        job = redis_job_store.get_job(job_id)
 
         if not job:
             return jsonify({
@@ -284,8 +283,12 @@ def get_job_status(job_id):
                 elif isinstance(image_data, str):
                     # Check if it's a local file path
                     if os.path.exists(image_data):
-                        # Store the file path in job store for later retrieval
-                        job['image_file_path'] = image_data
+                        # Store the file path in Redis job store for later retrieval
+                        redis_job_store.update_job(job_id, result={
+                            'content': job['result']['content'],
+                            'image_data': image_data,
+                            'image_file_path': image_data
+                        })
                         # Generate absolute URL instead of relative URL
                         base_url = request.host_url.rstrip('/')
                         response_data['image_url'] = f"{base_url}/api/posts/image/{job_id}"  # API endpoint to serve the image
@@ -330,8 +333,10 @@ def get_job_image(job_id):
         Image file
     """
     try:
-        # Get job from store
-        job = current_app.job_store.get(job_id)
+        # Get job from Redis store
+        from backend.utils.redis_job_store import get_redis_job_store
+        redis_job_store = get_redis_job_store()
+        job = redis_job_store.get_job(job_id)
 
         if not job:
             return jsonify({
@@ -340,7 +345,7 @@ def get_job_image(job_id):
             }), 404
 
         # Check if job has an image file path
-        image_file_path = job.get('image_file_path')
+        image_file_path = job.get('image_file_path') if job else None
         if not image_file_path or not os.path.exists(image_file_path):
             return jsonify({
                 'success': False,

backend/app.py

@@ -165,9 +165,19 @@ def create_app():
     # Initialize Supabase client
     app.supabase = init_supabase(app.config['SUPABASE_URL'], app.config['SUPABASE_KEY'])
 
-    # Initialize a simple in-memory job store for tracking async tasks
-    # In production, you'd use a database or Redis for this
-    app.job_store = {}
+    # Initialize Redis-based job store for tracking async tasks across multiple Gunicorn workers
+    try:
+        from backend.utils.redis_job_store import RedisJobStore
+        redis_url = app.config.get('REDIS_URL', 'redis://localhost:6379/0')
+        # Use configurable TTL from environment, default to 24 hours
+        job_ttl_hours = int(app.config.get('JOB_TTL_HOURS', 24))
+        app.redis_job_store = RedisJobStore(redis_url, default_ttl_hours=job_ttl_hours)
+        app.logger.info("Redis job store initialized successfully")
+    except Exception as e:
+        app.logger.error(f"Failed to initialize Redis job store: {str(e)}")
+        # Fallback to in-memory store if Redis is not available
+        app.job_store = {}
+        app.logger.warning("Using in-memory job store as fallback - not suitable for multi-worker production")
 
     # Initialize a ThreadPoolExecutor for running background tasks
     # In production, you'd use a proper task scheduler like APScheduler

backend/config.py

@@ -79,6 +79,9 @@ class Config:
     LOG_LEVEL = os.environ.get('LOG_LEVEL', 'INFO' if ENVIRONMENT == 'production' else 'DEBUG')
     UNICODE_SAFE_LOGGING = UNICODE_LOGGING and not IS_WINDOWS
 
+    # Redis configuration for job store
+    REDIS_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379/0')
+
     # Celery configuration
     CELERY_BROKER_URL = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
     CELERY_RESULT_BACKEND = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')

backend/utils/redis_job_store.py

@@ -0,0 +1,253 @@
+"""
+Redis-based job store for distributed job tracking across multiple Gunicorn workers.
+"""
+import json
+import uuid
+import redis
+from flask import current_app
+from datetime import datetime, timedelta
+import logging
+import re
+
+
+class RedisJobStore:
+    """
+    Redis-based job store for tracking background tasks across multiple Gunicorn workers.
+    """
+
+    # Valid job statuses
+    VALID_STATUSES = {'pending', 'processing', 'completed', 'failed', 'cancelled'}
+
+    def __init__(self, redis_url=None, default_ttl_hours=24):
+        """
+        Initialize Redis job store.
+
+        Args:
+            redis_url (str): Redis connection URL. If None, uses current_app.config['REDIS_URL']
+            default_ttl_hours (int): Default time-to-live for jobs in hours
+        """
+        self.default_ttl_hours = default_ttl_hours
+        if redis_url:
+            self.redis_client = redis.from_url(redis_url)
+        elif current_app and hasattr(current_app, 'config') and 'REDIS_URL' in current_app.config:
+            self.redis_client = redis.from_url(current_app.config['REDIS_URL'])
+        else:
+            # Default to localhost Redis
+            self.redis_client = redis.from_url('redis://localhost:6379/0')
+
+    def _validate_job_id(self, job_id):
+        """
+        Validate job ID format to prevent injection attacks.
+
+        Args:
+            job_id (str): Job ID to validate
+
+        Returns:
+            bool: True if valid, False otherwise
+        """
+        if not job_id or not isinstance(job_id, str):
+            return False
+        # Allow UUID format or alphanumeric with hyphens/underscores
+        return bool(re.match(r'^[a-zA-Z0-9_-]{1,64}$', job_id))
+
+    def _validate_status(self, status):
+        """
+        Validate job status value.
+
+        Args:
+            status (str): Status to validate
+
+        Returns:
+            bool: True if valid, False otherwise
+        """
+        return status in self.VALID_STATUSES
+
+    def create_job(self, job_id=None, initial_status='pending', initial_data=None):
+        """
+        Create a new job in Redis.
+
+        Args:
+            job_id (str): Job ID. If None, generates a new UUID.
+            initial_status (str): Initial job status.
+            initial_data (dict): Initial job data.
+
+        Returns:
+            str: Job ID
+        """
+        if initial_status and not self._validate_status(initial_status):
+            raise ValueError(f"Invalid status: {initial_status}. Valid statuses are: {self.VALID_STATUSES}")
+
+        if job_id and not self._validate_job_id(job_id):
+            raise ValueError(f"Invalid job ID format: {job_id}")
+
+        if job_id is None:
+            job_id = str(uuid.uuid4())
+
+        job_data = {
+            'status': initial_status,
+            'result': None,
+            'error': None,
+            'created_at': datetime.utcnow().isoformat(),
+            'updated_at': datetime.utcnow().isoformat()
+        }
+
+        if initial_data:
+            job_data.update(initial_data)
+
+        try:
+            # Store job data as JSON in Redis with expiration (24 hours)
+            self.redis_client.setex(
+                f"job:{job_id}",
+                timedelta(hours=self.default_ttl_hours),
+                json.dumps(job_data)
+            )
+        except redis.ConnectionError:
+            logging.error(f"Failed to connect to Redis when creating job {job_id}")
+            raise
+        except Exception as e:
+            logging.error(f"Unexpected error when creating job {job_id}: {str(e)}")
+            raise
+
+        return job_id
+
+    def get_job(self, job_id):
+        """
+        Get job data from Redis.
+
+        Args:
+            job_id (str): Job ID
+
+        Returns:
+            dict: Job data or None if not found
+        """
+        if not self._validate_job_id(job_id):
+            raise ValueError(f"Invalid job ID format: {job_id}")
+
+        try:
+            job_data_json = self.redis_client.get(f"job:{job_id}")
+            if job_data_json:
+                return json.loads(job_data_json)
+            return None
+        except redis.ConnectionError:
+            logging.error(f"Failed to connect to Redis when getting job {job_id}")
+            return None
+        except json.JSONDecodeError:
+            logging.error(f"Failed to decode JSON for job {job_id}")
+            return None
+        except Exception as e:
+            logging.error(f"Unexpected error when getting job {job_id}: {str(e)}")
+            return None
+
+    def update_job(self, job_id, status=None, result=None, error=None):
+        """
+        Update job status and data in Redis using atomic operations to prevent race conditions.
+
+        Args:
+            job_id (str): Job ID
+            status (str): New status
+            result (any): Result data
+            error (str): Error message
+
+        Returns:
+            bool: True if job was updated, False if not found
+        """
+        if not self._validate_job_id(job_id):
+            raise ValueError(f"Invalid job ID format: {job_id}")
+
+        if status is not None and not self._validate_status(status):
+            raise ValueError(f"Invalid status: {status}. Valid statuses are: {self.VALID_STATUSES}")
+
+        # Use Lua script for atomic read-modify-write operation
+        lua_script = """
+        local job_key = KEYS[1]
+        local job_data = redis.call('GET', job_key)
+
+        if not job_data then
+            return 0
+        end
+
+        local updated_data = cjson.decode(job_data)
+
+        if ARGV[1] ~= 'nil' then
+            updated_data.status = ARGV[1]
+        end
+        if ARGV[2] ~= 'nil' then
+            updated_data.result = cjson.decode(ARGV[2])
+        end
+        if ARGV[3] ~= 'nil' then
+            updated_data.error = ARGV[3]
+        end
+
+        updated_data.updated_at = ARGV[4]
+
+        local ttl = redis.call('TTL', job_key)
+        redis.call('SET', job_key, cjson.encode(updated_data), 'EX', ttl)
+
+        return 1
+        """
+
+        try:
+            # Prepare arguments for the Lua script
+            status_arg = status if status is not None else 'nil'
+            result_arg = json.dumps(result) if result is not None else 'nil'
+            error_arg = error if error is not None else 'nil'
+            updated_at_arg = datetime.utcnow().isoformat()
+
+            script = self.redis_client.register_script(lua_script)
+            result = script(keys=[f"job:{job_id}"],
+                           args=[status_arg, result_arg, error_arg, updated_at_arg])
+
+            return result == 1
+        except redis.ConnectionError:
+            logging.error(f"Failed to connect to Redis when updating job {job_id}")
+            return False
+        except Exception as e:
+            logging.error(f"Unexpected error when updating job {job_id}: {str(e)}")
+            return False
+
+    def delete_job(self, job_id):
+        """
+        Delete a job from Redis.
+
+        Args:
+            job_id (str): Job ID
+
+        Returns:
+            bool: True if job was deleted, False if not found
+        """
+        if not self._validate_job_id(job_id):
+            raise ValueError(f"Invalid job ID format: {job_id}")
+
+        try:
+            result = self.redis_client.delete(f"job:{job_id}")
+            return result > 0
+        except redis.ConnectionError:
+            logging.error(f"Failed to connect to Redis when deleting job {job_id}")
+            return False
+        except Exception as e:
+            logging.error(f"Unexpected error when deleting job {job_id}: {str(e)}")
+            return False
+
+    def cleanup_expired_jobs(self):
+        """
+        Clean up jobs that have expired based on their creation time.
+        This is a placeholder method - in a real implementation, you might want to
+        scan for expired jobs and remove them, but Redis automatically handles TTL.
+        """
+        # Redis handles TTL automatically, so this is mostly for documentation
+        # In a production system, you might want to implement custom cleanup logic
+        pass
+
+
+def get_redis_job_store():
+    """
+    Get the Redis job store instance from the current app context.
+
+    Returns:
+        RedisJobStore: Redis job store instance
+    """
+    if not hasattr(current_app, 'redis_job_store'):
+        redis_url = current_app.config.get('REDIS_URL', 'redis://localhost:6379/0')
+        current_app.redis_job_store = RedisJobStore(redis_url)
+
+    return current_app.redis_job_store

docs/sprint-artifacts/architecture.md

@@ -0,0 +1,507 @@
+# Lin - LinkedIn Community Manager Brownfield Enhancement Architecture
+
+## Change Log
+| Change | Date | Version | Description | Author |
+|--------|------|---------|-------------|---------|
+| Initial Draft | 2025-10-20 | 1.0 | Initial architecture document for UI/UX improvements, keyword analysis, and FLUX.1-dev image generation enhancements | Architect |
+
+## 1. Introduction
+
+This document outlines the architectural approach for enhancing Lin with UI/UX improvements, keyword relevance analysis, and upgraded image generation capabilities. Its primary goal is to serve as the guiding architectural blueprint for AI-driven development of new features while ensuring seamless integration with the existing system.
+
+**Relationship to Existing Architecture:**
+This document supplements existing project architecture by defining how new components will integrate with current systems. Where conflicts arise between new and existing patterns, this document provides guidance on maintaining consistency while implementing enhancements.
+
+### 1.1 Existing Project Analysis
+
+Based on my analysis of your project, I've identified the following about your existing system: 
+- The application is a LinkedIn community management tool with React frontend and Flask backend
+- Uses Supabase for authentication and database
+- Has established AI content generation using Gradio client
+- Current image generation uses Qwen/Qwen-Image model
+- Well-structured with clear separation of concerns between frontend and backend
+- Has established API patterns and Redux state management
+
+Please confirm these observations are accurate before I proceed with architectural recommendations.
+
+#### Current Project State
+- **Primary Purpose:** LinkedIn community management tool with AI-powered content generation
+- **Current Tech Stack:** React (frontend), Flask (backend), Supabase (database/auth), Gradio client (AI integration)
+- **Architecture Style:** Microservices-like with clear separation between frontend and backend
+- **Deployment Method:** Docker with docker-compose, with Nginx reverse proxy
+
+#### Available Documentation
+- README.md: Complete project documentation with setup instructions
+- Backend README.md: Detailed backend API documentation
+- Frontend README.md: Frontend development guide
+- docs/prd.md: Product requirements document
+
+#### Identified Constraints
+- Must maintain backward compatibility with existing user workflows
+- Authentication system is based on JWT tokens and Supabase
+- Image generation currently uses Qwen model through Gradio client
+- Existing API patterns must be preserved
+
+## 2. Enhancement Scope and Integration Strategy
+
+### 2.1 Enhancement Overview
+**Enhancement Type:** UI/UX Overhaul, New Feature Addition, Integration with New Systems
+**Scope:** UI/UX improvements to the dashboard, keyword relevance analysis feature, replacement of current image generation with FLUX.1-dev
+**Integration Impact:** Medium Impact (requires changes to existing code but maintains compatibility)
+
+### 2.2 Integration Approach
+**Code Integration Strategy:** Follow existing patterns and conventions in the codebase
+**Database Integration:** No schema changes required, leveraging existing tables
+**API Integration:** Extend existing API endpoints while maintaining compatibility
+**UI Integration:** Enhance existing UI components following established design patterns
+
+### 2.3 Compatibility Requirements
+- **Existing API Compatibility:** All new endpoints must follow existing authentication patterns
+- **Database Schema Compatibility:** No schema changes required, using existing tables
+- **UI/UX Consistency:** Follow existing design system and component patterns
+- **Performance Impact:** Maintain current performance characteristics
+
+## 3. Tech Stack
+
+### 3.1 Existing Technology Stack
+| Category | Current Technology | Version | Usage in Enhancement | Notes |
+|----------|-------------------|---------|---------------------|--------|
+| Frontend Framework | React | 18.2.0 | UI components for new features | Continue using existing patterns |
+| Build Tool | Vite | - | Build process for enhanced UI | Continue using existing configuration |
+| State Management | Redux Toolkit | - | State management for new features | Continue using existing patterns |
+| Styling | Tailwind CSS | - | Styling for new components | Follow existing design system |
+| Backend Framework | Flask | 3.1.1 | API endpoints for new features | Extend existing API structure |
+| Database | Supabase (PostgreSQL) | - | Data storage for new features | Use existing tables and auth |
+| Authentication | JWT + Supabase | - | Authentication for new features | Use existing auth patterns |
+| AI Integration | Gradio Client | - | Image generation replacement | Replace Qwen with FLUX.1-dev |
+| Task Queue | Celery + Redis | - | Async processing for image generation | Continue using existing setup |
+
+### 3.2 New Technology Additions
+No new major technologies are being introduced. The enhancement involves replacing the current Qwen image generation with FLUX.1-dev while maintaining all other existing technologies.
+
+## 4. Data Models and Schema Changes
+
+### 4.1 Schema Integration Strategy
+**Database Changes Required:**
+- **New Tables:** None
+- **Modified Tables:** None
+- **New Indexes:** None
+- **Migration Strategy:** None required
+
+**Backward Compatibility:**
+- No changes to existing data models
+- All existing functionality remains intact
+- New features use existing database structure
+
+## 5. Component Architecture
+
+### 5.1 New Components
+
+#### KeywordAnalysisService
+**Responsibility:** Handle keyword frequency analysis for content planning
+**Integration Points:** Integrated with existing content service and API endpoints
+
+**Key Interfaces:**
+- analyze_keyword_frequency(keywords: List[str]) -> Dict[str, str]
+
+**Dependencies:**
+- **Existing Components:** Uses existing database connection and authentication
+- **New Components:** None
+
+**Technology Stack:** Python, existing Flask framework
+
+#### ImageGenerationService (Updated)
+**Responsibility:** Handle image generation using FLUX.1-dev instead of Qwen
+**Integration Points:** Integrated with existing content service and AI workflow
+
+**Key Interfaces:**
+- generate_flux_image(prompt: str, seed: int, dimensions: tuple, guidance_scale: float, inference_steps: int) -> str
+
+**Dependencies:**
+- **Existing Components:** Uses existing gradio_client and authentication
+- **New Components:** None
+
+**Technology Stack:** Python, gradio_client, existing Flask framework
+
+### 5.2 Component Interaction Diagram
+```mermaid
+graph TB
+    subgraph "Frontend"
+        A[Posts Page] --> B[KeywordAnalysisPanel]
+        A --> C[ImageGenerationPanel]
+        B --> D[KeywordAnalysisService]
+        C --> E[ImageGenerationService]
+    end
+    
+    subgraph "Backend API"
+        F[app.py] --> G[posts_bp]
+        G --> H[content_service]
+        G --> I[keyword_analysis_service]
+    end
+    
+    subgraph "AI Services"
+        H --> J[FLUX.1-dev via gradio_client]
+        I --> K[Existing RSS/Post Data]
+    end
+    
+    subgraph "Database"
+        L[Supabase] --> H
+        L --> I
+    end
+    
+    D -.-> G
+    E -.-> G
+    B -.-> D
+    C -.-> E
+```
+
+## 6. API Design and Integration
+
+### 6.1 API Integration Strategy
+**API Integration Strategy:** Extend existing `/api/posts` endpoints while maintaining compatibility
+**Authentication:** Use existing JWT token authentication
+**Versioning:** No versioning needed, following existing API patterns
+
+### 6.2 New API Endpoints
+
+#### POST /api/posts/keyword-analysis
+**Method:** POST
+**Endpoint:** /api/posts/keyword-analysis
+**Purpose:** Analyze keyword frequency and relevance
+**Integration:** With existing posts API and authentication
+
+**Request:**
+```json
+{
+  "keywords": ["keyword1", "keyword2"]
+}
+```
+
+**Response:**
+```json
+{
+  "results": {
+    "keyword1": "daily",
+    "keyword2": "weekly"
+  },
+  "status": "success"
+}
+```
+
+## 7. External API Integration
+
+### 7.1 FLUX.1-dev API
+**Purpose:** High-quality image generation to replace current Qwen implementation
+**Documentation:** Available through Hugging Face Spaces
+**Base URL:** Hugging Face Space for FLUX.1-dev
+**Authentication:** Using existing HUGGING_KEY environment variable
+
+**Key Endpoints Used:**
+- `POST /infer` - Image generation with parameters
+
+**Error Handling:** Fallback to existing functionality if FLUX.1-dev fails
+
+## 8. Source Tree
+
+### 8.1 Existing Project Structure
+```
+Lin/
+├── .env.hf
+├── .gitattributes
+├── .gitignore
+├── .kilocodemodes
+├── app.py
+├── docker-compose.yml
+├── Dockerfile
+├── nginx.conf
+├── package-lock.json
+├── package.json
+├── README.md
+├── requirements.txt
+├── SETUP_GUIDE.md
+├── simple_timezone_test.py
+├── start_app.py
+├── start_celery.py
+├── start-dev.js
+├── starty.py
+├── test_apscheduler.py
+├── test_imports.py
+├── test_scheduler_integration.py
+├── test_scheduler_visibility.py
+├── test_timezone_functionality.py
+├── .qwen/
+├── backend/
+│   ├── __init__.py
+│   ├── .env.example
+│   ├── app.py
+│   ├── config.py
+│   ├── Dockerfile
+│   ├── README.md
+│   ├── requirements.txt
+│   ├── test_database_connection.py
+│   ├── test_oauth_callback.py
+│   ├── test_oauth_flow.py
+│   ├── TESTING_GUIDE.md
+│   ├── api/
+│   │   ├── __init__.py
+│   │   ├── accounts.py
+│   │   ├── auth.py
+│   │   ├── posts.py
+│   │   ├── schedules.py
+│   │   └── sources.py
+│   ├── models/
+│   │   ├── __init__.py
+│   │   ├── schedule.py
+│   │   └── user.py
+│   ├── scheduler/
+│   │   ├── __init__.py
+│   │   └── apscheduler_service.py
+│   ├── services/
+│   │   ├── __init__.py
+│   │   ├── auth_service.py
+��   │   ├── content_service.py
+│   │   ├── linkedin_service.py
+│   │   └── schedule_service.py
+│   ├── tests/
+│   │   ├── test_frontend_integration.py
+│   │   └── test_scheduler_image_integration.py
+│   ├── utils/
+│   │   ├── __init__.py
+│   │   ├── cookies.py
+│   │   ├── database.py
+│   │   ├── image_utils.py
+│   │   └── timezone_utils.py
+│   └── .gitignore
+├── docu_code/
+│   ├── My_data_base_schema_.txt
+│   └── supabase.txt
+├── fav/
+│   └── Capture d'écran 2025-08-16 223532.png
+├── frontend/
+│   ├── .env.development
+│   ├── .env.example
+│   ├── .env.production
+│   ├── .eslintrc.cjs
+│   ├── DESIGN_SYSTEM.md
+│   ├── Dockerfile
+│   ├── index.html
+│   ├── package-lock.json
+│   ├── package.json
+│   ├── postcss.config.js
+│   ├── README.md
+│   ├── RESPONSIVE_DESIGN_VALIDATION.md
+│   ├── tailwind.config.js
+│   ├── test-auth-fix.js
+│   ├── tsconfig.json
+│   ├── tsconfig.node.json
+│   ├── vite.config.js
+│   ├── public/
+│   │   ├── favicon.ico
+│   │   ├── favicon.png
+│   │   ├── index.html
+│   │   └── manifest.json
+│   ├── scripts/
+│   │   └── build-env.js
+│   ├── src/
+│   │   ├── App.css
+│   │   ├── App.jsx
+│   │   ├── index.css
+│   │   ├── index.jsx
+│   │   ├── layout-test.js
+│   │   ├── responsive-design-test.js
+│   │   ├── responsive.css
+│   │   ├── components/
+│   │   │   ├── FeatureCard.jsx
+│   │   │   ├── TestimonialCard.jsx
+│   │   │   ├── Header/
+│   │   │   │   ├── Header.css
+│   │   │   │   └── Header.jsx
+│   │   │   ├── LinkedInAccount/
+│   │   │   │   ├── LinkedInAccountCard.jsx
+│   │   │   │   ├── LinkedInAccountsManager.jsx
+│   │   │   │   └── LinkedInCallbackHandler.jsx
+│   │   │   └── Sidebar/
+│   │   │       └── Sidebar.jsx
+│   │   ├── css/
+│   │   │   ├── base.css
+│   │   │   ├── components.css.bak
+│   │   │   ├── main.css
+│   │   │   ├── responsive.css
+│   │   │   ├── typography.css
+│   │   │   ├── variables.css
+│   │   │   ├── components/
+│   │   │   ├── buttons.css
+│   │   │   │   ├── cards.css
+│   │   │   │   ├── forms.css
+│   │   │   │   ├── grid.css
+│   │   │   │   ├── header.css
+│   │   │   │   ├── linkedin.css
+│   │   │   │   ├── modal.css
+│   │   │   │   ├── navigation.css
+│   │   │   │   ├── sidebar.css
+│   │   │   │   ├── table.css
+│   │   │   │   └── utilities.css
+│   │   │   └── responsive/
+│   │   │       ├── accessibility.css
+│   │   │       ├── base.css
+│   │   │       ├── mobile-nav.css
+│   │   │       ├── performance.css
+│   │   │       └── performance/
+│   │   │           ├── lazy-loading.css
+│   │   │           └── mobile-optimization.css
+│   │   ├── debug/
+│   │   │   ├── testApi.js
+│   │   │   └── testApiIntegration.js
+│   │   ├── pages/
+│   │   │   ├── Accounts.jsx
+│   │   │   ├── Dashboard.jsx
+│   │   │   ├── ForgotPassword.jsx
+│   │   │   ├── Home.jsx
+│   │   │   ├── Login.jsx
+│   │   │   ├── Posts.jsx
+│   │   │   ├── Register.jsx
+│   │   │   ├── ResetPassword.jsx
+│   │   │   ├── Schedule.jsx
+│   │   │   └── Sources.jsx
+│   │   ├── services/
+│   │   │   ├── accountService.js
+│   │   │   ├── api.js
+│   │   │   ├── apiClient.js
+│   │   │   ├── authService.js
+│   │   │   ├── cacheService.js
+│   │   │   ├── cookieService.js
+│   │   │   ├── linkedinAuthService.js
+│   │   │   ├── postService.js
+│   │   │   ├── scheduleService.js
+│   │   │   ├── securityService.js
+│   │   │   ├── sourceService.js
+│   │   │   └── supabaseClient.js
+│   │   ├── store/
+│   │   │   ├── index.js
+│   │   │   └── reducers/
+│   │   │       ├── accountsSlice.js
+│   │   │       ├── authSlice.js
+│   │   │       ├── linkedinAccountsSlice.js
+│   │   │       ├── postsSlice.js
+│   │   │       ├── schedulesSlice.js
+│   │   │       └── sourcesSlice.js
+│   │   └─�� utils/
+│   │       └── timezoneUtils.js
+│   └── .gitignore
+├── Linkedin_poster_dev/
+│   ├── .gitattributes
+│   ├── ai_agent.py
+│   ├── app.py
+│   ├── README.md
+│   └── requirements.txt
+└── docs/
+    └── architecture.md
+```
+
+### 8.2 New File Organization
+```
+Lin/
+├── frontend/
+│   └── src/
+│       ├── components/
+│       │   └── KeywordAnalysis/     # New keyword analysis components
+│       │       ├── KeywordAnalysisPanel.jsx
+│       │       └── index.js
+│       └── services/
+│           └── keywordAnalysisService.js
+├── backend/
+│   ├── services/
+│   │   ├── keyword_analysis_service.py # New service
+│   │   └── content_service.py           # Updated with FLUX.1-dev
+│   └── api/
+│       └── posts.py                     # Extended with new endpoints
+└── Linkedin_poster_dev/
+    └── ai_agent.py                      # Updated with FLUX.1-dev
+```
+
+### 8.3 Integration Guidelines
+- **File Naming:** Follow existing snake_case for Python and camelCase for JavaScript
+- **Folder Organization:** Place new components in appropriate existing directories
+- **Import/Export Patterns:** Maintain existing patterns in the codebase
+
+## 9. Infrastructure and Deployment Integration
+
+### 9.1 Existing Infrastructure
+**Current Deployment:** Docker with docker-compose and Nginx reverse proxy
+**Infrastructure Tools:** Docker, docker-compose, Nginx, Redis for Celery
+**Environments:** Development and production configurations available
+
+### 9.2 Enhancement Deployment Strategy
+**Deployment Approach:** No infrastructure changes required, using existing setup
+**Infrastructure Changes:** None
+**Pipeline Integration:** No changes to existing deployment pipeline
+
+### 9.3 Rollback Strategy
+**Rollback Method:** Revert changes to ai_agent.py to restore Qwen functionality
+**Risk Mitigation:** Thorough testing before deployment
+**Monitoring:** Monitor API response times and error rates
+
+## 10. Coding Standards
+
+### 10.1 Existing Standards Compliance
+**Code Style:** Follow existing Python (PEP 8) and JavaScript (ESLint) standards
+**Linting Rules:** Use existing linting configurations
+**Testing Patterns:** Follow existing pytest and React testing patterns
+**Documentation Style:** Follow existing docstring and JSDoc patterns
+
+### 10.2 Critical Integration Rules
+- **Existing API Compatibility:** New endpoints must follow existing authentication patterns
+- **Database Integration:** Use existing Supabase connection and query patterns
+- **Error Handling:** Follow existing error response format
+- **Logging Consistency:** Use existing logging patterns
+
+## 11. Testing Strategy
+
+### 11.1 Integration with Existing Tests
+**Existing Test Framework:** pytest for backend, Jest/React Testing Library for frontend
+**Test Organization:** Follow existing test directory structure
+**Coverage Requirements:** Maintain existing coverage thresholds
+
+### 11.2 New Testing Requirements
+
+#### Unit Tests for New Components
+**Framework:** pytest for backend, React Testing Library for frontend
+**Location:** backend/tests/ and frontend/src/tests/
+**Coverage Target:** 80%+ for new code
+**Integration with Existing:** Follow existing test patterns
+
+#### Integration Tests
+**Scope:** Test new API endpoints with authentication
+**Existing System Verification:** Ensure existing functionality remains intact
+**New Feature Testing:** Validate keyword analysis and image generation
+
+#### Regression Testing
+**Existing Feature Verification:** Run all existing tests to ensure no regressions
+**Automated Regression Suite:** Use existing CI pipeline
+**Manual Testing Requirements:** Test end-to-end workflows manually
+
+## 12. Security Integration
+
+### 12.1 Existing Security Measures
+**Authentication:** JWT token-based authentication
+**Authorization:** Role-based access control
+**Data Protection:** Supabase security and encryption
+**Security Tools:** Built-in Flask security features
+
+### 12.2 Enhancement Security Requirements
+**New Security Measures:** Input validation for new API endpoints
+**Integration Points:** Use existing authentication for all new endpoints
+**Compliance Requirements:** Maintain existing data privacy standards
+
+### 12.3 Security Testing
+**Existing Security Tests:** Continue running existing security tests
+**New Security Test Requirements:** Validate input sanitization for new endpoints
+**Penetration Testing:** None specifically required for these enhancements
+
+## 13. Next Steps
+
+### 13.1 Story Manager Handoff
+The architecture document provides a clear roadmap for implementing the UI/UX improvements, keyword analysis feature, and FLUX.1-dev image generation. The key integration requirements have been validated with the existing system. Begin with implementing the keyword analysis feature, followed by the FLUX.1-dev integration, and finally the UI/UX enhancements. Emphasis should be placed on maintaining existing system integrity throughout implementation.
+
+### 13.2 Developer Handoff
+Developers should reference this architecture document and existing coding standards when starting implementation. The integration requirements with the existing codebase have been validated. Key technical decisions are based on real project constraints, and existing system compatibility requirements include specific verification steps for API compatibility. The implementation should follow a clear sequence to minimize risk to existing functionality: keyword analysis service first, then FLUX.1-dev integration, and finally UI enhancements.

docs/sprint-artifacts/tech_spec_job_tracking.md

@@ -0,0 +1,86 @@
+# Tech-Spec 1: Fix Background Task and Job Tracking in Gunicorn Environment
+
+**Created:** 2025-12-22
+**Status:** Completed
+
+## Overview
+
+### Problem Statement
+After migrating from Flask's development server to Gunicorn, the background task system for post generation is not working correctly. While tasks are submitted and processed successfully on the generation server, the job status tracking fails because job states are not accessible across multiple Gunicorn workers. This results in 404 errors when trying to fetch job status and causes the SSE connection to time out, preventing updates from reaching the frontend.
+
+### Solution
+Implemented a shared storage mechanism for job state management that works across multiple Gunicorn workers, ensuring consistent job tracking and proper SSE communication.
+
+### Scope (In/Out)
+
+**In Scope:**
+- Implement shared job state storage (Redis, database, or other shared storage)
+- Update background task management to use shared storage instead of in-memory storage
+- Fix SSE connection handling in multi-worker environment using Flask's streaming features
+- Update job status polling endpoints to access shared storage
+- Ensure proper request context handling for streaming responses
+
+**Out Scope:**
+- Changing the Gradio API integration
+- Modifying the frontend UI components
+- Refactoring the core post generation logic
+
+## Context for Development
+
+### Codebase Patterns
+- Flask REST API backend
+- Background task processing with job tracking
+- Server-sent events for real-time updates
+- Gradio API integration for content generation
+- Use of `stream_with_context` for streaming responses
+
+### Files to Reference
+- `app.py` - Main Flask application
+- `posts.py` - Contains the job submission and tracking logic (around line 196 based on logs)
+- `content_service.py` - Gradio API integration
+- `start_gunicorn.py` - Gunicorn configuration
+- Frontend JavaScript files handling SSE connections
+
+### Technical Decisions
+- Use Redis for shared job state storage (fast, simple, good for temporary job data)
+- Implement proper job lifecycle management (created, processing, completed, failed)
+- Use Flask's `stream_with_context` for proper SSE handling
+
+## Implementation Plan
+
+### Tasks
+
+- [x] Task 1: Set up Redis connection and configure Flask-Session with Redis backend
+- [x] Task 2: Update job creation and tracking to use Redis instead of in-memory storage
+- [x] Task 3: Modify background task handlers to update job state in Redis
+- [x] Task 4: Update job status polling endpoint to fetch from Redis
+- [x] Task 5: Fix SSE connection handling using Flask's streaming capabilities with `stream_with_context`
+- [x] Task 6: Test the complete flow from job submission to completion
+
+### Acceptance Criteria
+
+- [x] AC 1: Job state is accessible across all Gunicorn workers via Redis
+- [x] AC 2: Job status polling endpoint returns correct job status (not 404)
+- [x] AC 3: SSE connections receive real-time updates about job progress using proper streaming
+- [x] AC 4: Generated posts are properly displayed on the frontend after completion
+- [x] AC 5: No regressions in existing functionality
+
+## Additional Context
+
+### Dependencies
+- Redis server for shared storage
+- Updated Flask application with Redis integration
+- Flask-Session with Redis backend
+- Gunicorn configuration with appropriate worker settings
+
+### Testing Strategy
+- Unit tests for Redis job state management
+- Integration tests for job submission and status tracking
+- End-to-end test of the complete post generation flow
+- Test SSE connections with multiple Gunicorn workers
+
+### Notes
+- Consider job cleanup for completed/failed jobs to prevent Redis memory issues
+- Ensure proper error handling when Redis is unavailable
+- May need to adjust Gunicorn worker count to optimize for background tasks
+- Use Flask's `stream_with_context` to properly handle streaming responses in multi-worker environments

docs/sprint-artifacts/tech_spec_remote_logging.md

@@ -0,0 +1,159 @@
+# Tech-Spec 2: Remote Application Logging with Redis
+
+**Created:** 2025-12-22
+**Status:** Ready for Development
+
+## Overview
+
+### Problem Statement
+Need to centralize application logs in Redis to enable remote access and monitoring of application behavior across multiple Gunicorn workers. This will help with debugging issues like the background task tracking problem and provide better visibility into application performance.
+
+### Solution
+Implement a logging system that sends application logs to Redis, enabling remote access, centralized monitoring, and real-time log streaming.
+
+### Scope (In/Out)
+
+**In Scope:**
+- Implement Redis-based logging handler
+- Configure log formatting for Redis storage
+- Create log retrieval endpoints
+- Implement log streaming capabilities
+- Add log retention and cleanup policies
+
+**Out Scope:**
+- Replacing existing logging infrastructure completely
+- Implementing complex log analytics
+- Creating a full dashboard UI
+
+## Context for Development
+
+### Codebase Patterns
+- Flask application with existing logging infrastructure
+- Multiple Gunicorn workers requiring centralized logging
+- Need for remote log access and debugging
+
+### Files to Reference
+- `app.py` - Main Flask application where logging is configured
+- `gunicorn.conf.py` - Gunicorn configuration
+- Any existing logging configuration files
+
+### Technical Decisions
+- Use Redis lists for log storage with push operations
+- Implement log level filtering and retention
+- Use structured logging format for easier parsing
+- Add log rotation to prevent Redis memory issues
+
+## Implementation Plan
+
+### Tasks
+
+- [ ] Task 1: Set up Redis connection for logging
+- [ ] Task 2: Create custom Python logging handler for Redis
+- [ ] Task 3: Configure Flask application to use Redis logger
+- [ ] Task 4: Create API endpoints to retrieve logs from Redis
+- [ ] Task 5: Implement log retention and cleanup policies
+- [ ] Task 6: Test logging functionality with multiple Gunicorn workers
+
+### Acceptance Criteria
+
+- [ ] AC 1: Application logs are stored in Redis with proper formatting
+- [ ] AC 2: Remote access to logs via API endpoints
+- [ ] AC 3: Logs from all Gunicorn workers are consolidated in Redis
+- [ ] AC 4: Log retention prevents Redis memory overflow
+- [ ] AC 5: Structured logs include timestamp, level, module, and message
+
+## Additional Context
+
+### Implementation Details
+
+#### 1. Redis Logging Handler
+```python
+import redis
+import json
+import logging
+from datetime import datetime
+
+class RedisLogHandler(logging.Handler):
+    def __init__(self, redis_client, key='app_logs', max_logs=1000):
+        super().__init__()
+        self.redis_client = redis_client
+        self.key = key
+        self.max_logs = max_logs
+
+    def emit(self, record):
+        try:
+            log_entry = {
+                'timestamp': datetime.utcnow().isoformat(),
+                'level': record.levelname,
+                'module': record.module,
+                'function': record.funcName,
+                'line': record.lineno,
+                'message': record.getMessage(),
+                'logger': record.name
+            }
+            # Add exception info if present
+            if record.exc_info:
+                log_entry['exception'] = self.format(record)
+            
+            # Push to Redis list
+            self.redis_client.lpush(self.key, json.dumps(log_entry))
+            # Trim to max_logs to prevent memory issues
+            self.redis_client.ltrim(self.key, 0, self.max_logs - 1)
+        except Exception:
+            self.handleError(record)
+```
+
+#### 2. Flask Integration
+```python
+import redis
+from flask import Flask
+
+# Initialize Redis connection
+redis_client = redis.Redis(host='localhost', port=6379, db=0)
+
+# Configure logging
+app = Flask(__name__)
+redis_handler = RedisLogHandler(redis_client, key='flask_app_logs')
+redis_handler.setLevel(logging.INFO)
+
+# Add to Flask app logger
+app.logger.addHandler(redis_handler)
+```
+
+#### 3. API Endpoints for Log Retrieval
+```python
+from flask import jsonify
+
+@app.route('/api/logs')
+def get_logs():
+    count = request.args.get('count', 50, type=int)
+    logs = redis_client.lrange('flask_app_logs', 0, count - 1)
+    return jsonify([json.loads(log) for log in logs])
+
+@app.route('/api/logs/levels/<level>')
+def get_logs_by_level(level):
+    all_logs = redis_client.lrange('flask_app_logs', 0, -1)
+    filtered_logs = []
+    for log in all_logs:
+        log_data = json.loads(log)
+        if log_data['level'] == level.upper():
+            filtered_logs.append(log_data)
+    return jsonify(filtered_logs)
+```
+
+### Dependencies
+- `redis` - Python Redis client
+- `flask` - For API endpoints
+
+### Testing Strategy
+- Unit test the Redis logging handler
+- Integration test log storage and retrieval
+- Test with multiple Gunicorn workers to ensure logs are centralized
+- Test log retention policies
+
+### Notes
+- Consider using Redis streams instead of lists for more advanced log querying
+- Implement log rotation to prevent Redis memory issues
+- Add authentication/authorization for log access endpoints
+- Consider using a separate Redis database for logs
+- Monitor Redis memory usage with logging enabled

test_redis_job_store.py

@@ -0,0 +1,110 @@
+"""
+Test script to verify Redis job store functionality
+"""
+import sys
+import os
+
+# Add the project root to the Python path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from backend.utils.redis_job_store import RedisJobStore
+
+def test_redis_job_store():
+    """Test the Redis job store functionality."""
+    print("Testing Redis Job Store...")
+
+    # Initialize Redis job store
+    try:
+        redis_job_store = RedisJobStore('redis://localhost:6379/0')
+        print("[OK] Redis job store initialized successfully")
+    except Exception as e:
+        print(f"[ERROR] Failed to initialize Redis job store: {e}")
+        return False
+
+    # Test creating a job with default status
+    try:
+        job_id = redis_job_store.create_job(initial_status='pending', initial_data={'test': True})
+        print(f"[OK] Job created successfully with ID: {job_id}")
+    except Exception as e:
+        print(f"[ERROR] Failed to create job: {e}")
+        return False
+
+    # Test getting the job
+    try:
+        job = redis_job_store.get_job(job_id)
+        if job and job['status'] == 'pending':
+            print(f"[OK] Job retrieved successfully: {job}")
+        else:
+            print(f"[ERROR] Job not found or incorrect status: {job}")
+            return False
+    except Exception as e:
+        print(f"[ERROR] Failed to get job: {e}")
+        return False
+
+    # Test updating the job
+    try:
+        success = redis_job_store.update_job(job_id, status='completed', result={'data': 'test result'})
+        if success:
+            print("[OK] Job updated successfully")
+        else:
+            print("[ERROR] Job update failed")
+            return False
+    except Exception as e:
+        print(f"[ERROR] Failed to update job: {e}")
+        return False
+
+    # Test getting the updated job
+    try:
+        job = redis_job_store.get_job(job_id)
+        if job and job['status'] == 'completed' and job['result']['data'] == 'test result':
+            print(f"[OK] Updated job retrieved successfully: {job}")
+        else:
+            print(f"[ERROR] Job not updated correctly: {job}")
+            return False
+    except Exception as e:
+        print(f"[ERROR] Failed to get updated job: {e}")
+        return False
+
+    # Test deleting the job
+    try:
+        success = redis_job_store.delete_job(job_id)
+        if success:
+            print("[OK] Job deleted successfully")
+        else:
+            print("[ERROR] Job deletion failed")
+            return False
+    except Exception as e:
+        print(f"[ERROR] Failed to delete job: {e}")
+        return False
+
+    # Test validation functionality
+    try:
+        # Test invalid status
+        try:
+            redis_job_store.create_job(initial_status='invalid_status')
+            print("[ERROR] Should have failed with invalid status")
+            return False
+        except ValueError:
+            print("[OK] Correctly rejected invalid status")
+
+        # Test invalid job ID format
+        try:
+            redis_job_store.get_job("invalid job id with spaces")
+            print("[ERROR] Should have failed with invalid job ID format")
+            return False
+        except ValueError:
+            print("[OK] Correctly rejected invalid job ID format")
+    except Exception as e:
+        print(f"[ERROR] Validation tests failed: {e}")
+        return False
+
+    print("[OK] All Redis job store tests passed!")
+    return True
+
+if __name__ == "__main__":
+    success = test_redis_job_store()
+    if success:
+        print("\nRedis job store is working correctly!")
+    else:
+        print("\nRedis job store tests failed!")
+        sys.exit(1)