Refactor project structure and remove outdated documentation

- Deleted backend_structure.md, component_architecture.md, deployment_architecture.md, development_roadmap.md, frontend_requirements.md, frontend_structure.md to streamline project documentation.
- Updated Posts.jsx to handle new post generation result structure.
- Modified postService.js to accommodate changes in the generated content and image handling.
- Adjusted postsSlice.js to ensure proper handling of generated post results.
- Updated package.json to improve development command scripts and ensure compatibility.
- Introduced starty.py as a universal startup script for development servers, simplifying the process of starting frontend and backend.
- Added test_imports.py to verify backend imports and ensure proper module accessibility.

.gitignore

@@ -164,5 +164,8 @@ Thumbs.db
 # Supabase
 supabase/.temp/
 
+# Serena 
+.serena/
+
 # Docker
 docker-compose.override.yml

ACCOUNT_CREATION_ANALYSIS_SUMMARY.md

@@ -1,97 +0,0 @@
-# Account Creation Issue Analysis Summary
-
-## Problem Statement
-Users are unable to see LinkedIn accounts in their database despite successful OAuth authentication. The OAuth flow completes successfully, but accounts are not being saved to the database.
-
-## Investigation Results
-
-### ✅ What's Working
-1. **OAuth Authentication**: LinkedIn OAuth flow is working correctly
-2. **Frontend Callback**: LinkedInCallbackHandler processes the callback properly
-3. **API Endpoints**: GET /api/accounts returns successful responses
-4. **Database Queries**: Supabase queries are executing successfully
-
-### ❌ What's Not Working
-1. **Database Insertion**: OAuth callback handler fails to insert accounts into Social_network table
-2. **Error Handling**: Silent failures prevent proper debugging
-3. **Logging**: Insufficient logging to track the insertion process
-
-## Root Cause
-The OAuth callback handler in [`backend/api/accounts.py:126-207`](backend/api/accounts.py:126) is not successfully inserting account data into the Supabase database. The handler receives the OAuth code and processes it correctly, but the database insertion step is failing silently.
-
-## Key Findings
-
-### Log Analysis
-- **Successful Operations**: Multiple GET /api/accounts requests (200 responses)
-- **Successful OAuth**: LinkedIn callback with authorization code received
-- **Missing Evidence**: No logs showing successful database insertion
-- **Silent Failures**: Error handling may be suppressing exceptions
-
-### Technical Issues
-1. **Insufficient Logging**: No detailed logs in the OAuth callback handler
-2. **Silent Failures**: Database errors may be caught and suppressed
-3. **Missing Verification**: No confirmation that insertion was successful
-4. **Error Handling**: Generic error messages don't provide specific feedback
-
-## Recommended Solution
-
-### Immediate Actions (Priority: High)
-1. **Add Enhanced Logging** to the OAuth callback handler
-2. **Verify Database Connection** and permissions
-3. **Test Database Insertion** with sample data
-4. **Implement Proper Error Handling** with detailed feedback
-
-### Implementation Plan
-1. **Phase 1**: Debugging and Logging (1-2 days)
-2. **Phase 2**: Database Verification (1 day)
-3. **Phase 3**: Error Handling Enhancement (1 day)
-4. **Phase 4**: Testing and Verification (1-2 days)
-
-## Files Requiring Changes
-
-### Backend Files
-- [`backend/api/accounts.py`](backend/api/accounts.py) - OAuth callback handler
-- [`backend/services/linkedin_service.py`](backend/services/linkedin_service.py) - LinkedIn API integration
-- [`backend/utils/database.py`](backend/utils/database.py) - Database utilities
-
-### Frontend Files
-- [`frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx`](frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx) - Callback processing
-- [`frontend/src/services/accountService.js`](frontend/src/services/accountService.js) - API client
-
-## Success Criteria
-1. ✅ OAuth callback completes successfully
-2. ✅ Account data is properly inserted into database
-3. ✅ Account appears in user account list
-4. ✅ Error handling provides clear feedback
-5. ✅ Comprehensive logging for debugging
-
-## Risk Assessment
-- **High Risk**: Database connection or permission issues
-- **Medium Risk**: RLS policy conflicts
-- **Low Risk**: Frontend callback handling
-
-## Next Steps
-1. **Approve Implementation Plan**: Review and approve the proposed changes
-2. **Begin Phase 1**: Add enhanced logging to OAuth callback handler
-3. **Database Verification**: Check table structure and permissions
-4. **Testing**: Verify the fix works end-to-end
-
-## Documentation Created
-- [`ACCOUNT_CREATION_DIAGNOSTICS.md`](ACCOUNT_CREATION_DIAGNOSTICS.md) - Detailed analysis of the issue
-- [`ACCOUNT_CREATION_FIX_PLAN.md`](ACCOUNT_CREATION_FIX_PLAN.md) - Implementation plan with specific steps
-- [`ACCOUNT_CREATION_WORKFLOW.md`](ACCOUNT_CREATION_WORKFLOW.md) - Visual workflow diagram
-
-## Questions for Review
-1. Should we proceed with the implementation as outlined?
-2. Are there any specific concerns about the proposed changes?
-3. Do you have access to the Supabase dashboard to verify database structure?
-4. Should we create a backup before making changes?
-
-## Expected Timeline
-- **Implementation**: 3-5 days
-- **Testing**: 1-2 days
-- **Deployment**: 1 day
-- **Total**: 5-8 days
-
-## Contact Information
-For questions or clarification about this analysis, please refer to the documentation files or contact the development team.

ACCOUNT_CREATION_DIAGNOSTICS.md

@@ -1,91 +0,0 @@
-# Account Creation Issue Analysis
-
-## Problem Summary
-User is trying to add a LinkedIn account but despite successful API calls (200 responses), the account doesn't appear in the database.
-
-## Log Analysis
-
-### Successful Operations Observed:
-1. **GET /api/accounts** - Multiple successful requests returning 200
-2. **Supabase API calls** - Successful queries to `Social_network` table
-3. **POST /api/accounts** - Successful request returning 200
-4. **Auth callback** - Successful OAuth callback with authorization code
-
-### Key Issues Identified:
-1. **Missing database insertion** - No logs showing successful account creation in database
-2. **OAuth callback flow** - The callback handler may be failing silently
-3. **Data persistence** - Accounts are being retrieved but not stored properly
-
-## Root Cause Analysis
-
-### 1. OAuth Callback Flow Issue
-The logs show a successful auth callback:
-```
-GET /auth/callback?code=AQQe_UpcxzZsgqMcsO-CnPi07wyc-Uh6cv6WVwPbFWm-4MsQ-OvJCmDuyOWlvK5e_67rrpZjiunqWHLd8rv5uvDJg_T2pPhvDj6BJYzmpDF_RpktHJQnOqQEiEsuaG8ZImd_wFsRI9-6T5A3-9wYuZVQhtkwdIDsZ4Dofp54_jbyzCLUrahbzfkRlL2c29DeWvfP9jTy8bQF1AeYLEA&state=KUXEkZ7fZjsrZWxJxm4E-do2UysOvF45Kipvk00kfUM
-```
-
-But there's no corresponding log entry for the `/accounts/callback` POST request that should follow.
-
-### 2. Database Insertion Problem
-The OAuth callback handler in [`backend/api/accounts.py:169-183`](backend/api/accounts.py:169) should insert data into the `Social_network` table, but there's no evidence this is happening.
-
-### 3. Error Handling Issues
-The error handling in the OAuth callback may be swallowing exceptions and returning 200 even when failures occur.
-
-## Diagnostic Plan
-
-### Phase 1: Immediate Debugging
-1. **Add detailed logging** to track the complete OAuth flow
-2. **Verify database schema** and table structure
-3. **Test database permissions** and insert operations
-4. **Check user ID mapping** between auth and database
-
-### Phase 2: Flow Verification
-1. **Test the complete OAuth flow** end-to-end
-2. **Verify data insertion** at each step
-3. **Check for data validation** issues
-4. **Test error scenarios** and edge cases
-
-### Phase 3: Database Investigation
-1. **Check existing records** in Social_network table
-2. **Verify table constraints** and indexes
-3. **Test manual insertion** to isolate the issue
-4. **Check for triggers** or RLS policies
-
-## Technical Architecture
-
-### Account Creation Flow:
-```
-Frontend → POST /api/accounts → Initiate OAuth → Redirect to LinkedIn
-LinkedIn Callback → GET /auth/callback → Frontend handles callback
-Frontend → POST /accounts/callback → Backend processes OAuth code
-Backend → Insert into Supabase Social_network table → Return success
-```
-
-### Key Components:
-- **Frontend**: [`LinkedInCallbackHandler.jsx`](frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx)
-- **Backend**: [`accounts.py`](backend/api/accounts.py) - OAuth callback handler
-- **Database**: Supabase `Social_network` table
-- **Service**: [`LinkedInService`](backend/services/linkedin_service.py)
-
-## Recommended Actions
-
-### Immediate Actions:
-1. **Add debug logging** to the OAuth callback handler
-2. **Verify the callback endpoint** is being called
-3. **Check database connection** and permissions
-4. **Test manual insertion** to isolate the issue
-
-### Long-term Fixes:
-1. **Improve error handling** to provide detailed feedback
-2. **Add database validation** and constraints
-3. **Implement proper logging** for all operations
-4. **Add monitoring** for account creation success/failure rates
-
-## Next Steps
-
-1. Create a debug script to test the database connection and table structure
-2. Add detailed logging to track the OAuth callback flow
-3. Verify the callback endpoint is receiving the correct data
-4. Test the database insertion process with sample data
-5. Check for any RLS policies or triggers that might block insertion

ACCOUNT_CREATION_FINAL_FIX.md

@@ -1,201 +0,0 @@
-# LinkedIn Account Creation - Final Fix Summary
-
-## Problem Solved
-
-The user was experiencing an issue where LinkedIn accounts were not appearing in the database despite successful OAuth authentication. The logs showed that the OAuth callback was working, but the account creation process was failing.
-
-## Root Cause
-
-The original implementation had a complex multi-step process:
-1. Backend receives OAuth callback
-2. Backend stores OAuth data in session
-3. Frontend redirects to callback handler
-4. Frontend makes API call to complete OAuth flow
-5. Backend processes OAuth data and stores account
-
-This approach was failing because:
-- The frontend callback handler was trying to make additional API calls that weren't working properly
-- There was a circular dependency issue in the OAuth flow
-- The session management was complex and error-prone
-
-## Solution: Direct Backend Processing
-
-I implemented a much simpler and more robust solution by processing the complete OAuth flow directly in the backend callback handler.
-
-### Backend Changes (`backend/app.py`)
-
-**Key Changes:**
-1. **Complete OAuth Flow in Backend**: The `/auth/callback` endpoint now handles the entire OAuth process:
-   - Receives OAuth code and state from LinkedIn
-   - Verifies JWT token from cookies to get user ID
-   - Exchanges OAuth code for access token
-   - Fetches user information from LinkedIn API
-   - Stores account data directly in Supabase database
-   - Redirects to frontend with success/failure status
-
-**Code Flow:**
-```python
-@app.route('/auth/callback')
-def handle_auth_callback():
-    # 1. Parse OAuth parameters
-    code = request.args.get('code')
-    state = request.args.get('state')
-    
-    # 2. Verify JWT and get user ID
-    user_data = decode_token(token)
-    user_id = user_data['sub']
-    
-    # 3. Exchange code for access token
-    token_response = linkedin_service.get_access_token(code)
-    access_token = token_response['access_token']
-    
-    # 4. Get user info
-    user_info = linkedin_service.get_user_info(access_token)
-    
-    # 5. Store account in database
-    account_data = {
-        "social_network": "LinkedIn",
-        "account_name": user_info.get('name'),
-        "id_utilisateur": user_id,
-        "token": access_token,
-        "sub": user_info.get('sub'),
-        "given_name": user_info.get('given_name'),
-        "family_name": user_info.get('family_name'),
-        "picture": user_info.get('picture')
-    }
-    
-    response = app.supabase.table("Social_network").insert(account_data).execute()
-    
-    # 6. Redirect to frontend
-    redirect_url = f"{request.host_url.rstrip('/')}?oauth_success=true&account_linked=true&from=linkedin"
-    return redirect(redirect_url)
-```
-
-### Frontend Changes (`frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx`)
-
-**Key Changes:**
-1. **Simplified Callback Handler**: The frontend now just handles the redirect and displays appropriate messages
-2. **No Additional API Calls**: Removed the complex session data retrieval and OAuth completion calls
-3. **Direct Status Handling**: Simply checks for `oauth_success=true` and `account_linked=true` parameters
-
-**Code Flow:**
-```javascript
-useEffect(() => {
-  const handleCallback = async () => {
-    const urlParams = new URLSearchParams(location.search);
-    const error = urlParams.get('error');
-    const oauthSuccess = urlParams.get('oauth_success');
-    const accountLinked = urlParams.get('account_linked');
-    const from = urlParams.get('from');
-
-    if (from === 'linkedin') {
-      if (error) {
-        setStatus('error');
-        setMessage(`Authentication failed: ${error}`);
-      } else if (oauthSuccess === 'true' && accountLinked === 'true') {
-        setStatus('success');
-        setMessage('LinkedIn account linked successfully!');
-        await dispatch(fetchLinkedInAccounts());
-        setTimeout(() => navigate('/sources'), 2000);
-      }
-    }
-  };
-  
-  if (location.search.includes('oauth_success=') || location.search.includes('error=')) {
-    handleCallback();
-  }
-}, [dispatch, location, navigate]);
-```
-
-## Benefits of the New Approach
-
-### 1. **Simplified Architecture**
-- Single point of processing in the backend
-- No complex session management
-- Eliminated circular dependencies
-
-### 2. **Better Error Handling**
-- Comprehensive error logging at each step
-- Clear error messages for different failure scenarios
-- Proper error propagation to frontend
-
-### 3. **Improved Reliability**
-- Direct database insertion from backend
-- No intermediate API calls that could fail
-- JWT verification ensures proper user authentication
-
-### 4. **Enhanced Security**
-- OAuth tokens never exposed to frontend
-- User authentication verified before account creation
-- Secure token handling in backend
-
-### 5. **Better User Experience**
-- Faster processing (no round trips to frontend)
-- Clear success/failure feedback
-- Automatic redirection after successful linking
-
-## Expected Flow After Fix
-
-1. **User Initiates OAuth**: User clicks "Connect LinkedIn Account"
-2. **LinkedIn Authentication**: User is redirected to LinkedIn for authentication
-3. **LinkedIn Callback**: LinkedIn redirects back to `/auth/callback` with OAuth code
-4. **Backend Processing**: 
-   - Verifies user JWT token
-   - Exchanges OAuth code for access token
-   - Fetches user information
-   - Stores account in database
-5. **Frontend Redirect**: Backend redirects to frontend with success parameters
-6. **User Feedback**: Frontend shows success message and redirects to sources page
-
-## Testing and Verification
-
-### Backend Logs to Check
-```
-🔗 [OAuth] Direct callback handler triggered
-🔗 [OAuth] Processing OAuth for user: [user_id]
-🔗 [OAuth] Token exchange successful
-🔗 [OAuth] User info fetched
-🔗 [OAuth] Prepared account data: {...}
-🔗 [OAuth] Inserting account into database...
-🔗 [OAuth] Account linked successfully for user: [user_id]
-```
-
-### Database Verification
-After successful OAuth flow, check the `Social_network` table:
-```sql
-SELECT * FROM Social_network 
-WHERE id_utilisateur = '[user_id]' 
-AND social_network = 'LinkedIn';
-```
-
-### Frontend Verification
-- User should see "LinkedIn account linked successfully!" message
-- Account should appear in the UI after refresh
-- User should be redirected to the sources page
-
-## Troubleshooting
-
-### Common Issues and Solutions
-
-1. **JWT Token Verification Fails**
-   - Ensure user is properly authenticated
-   - Check that JWT token is present in cookies
-
-2. **Token Exchange Fails**
-   - Verify LinkedIn API credentials in environment variables
-   - Check that OAuth code is not expired
-
-3. **Database Insertion Fails**
-   - Verify Supabase database connection
-   - Check table schema and permissions
-   - Ensure user ID format matches database expectations
-
-4. **Frontend Not Redirecting**
-   - Check that callback parameters are properly passed
-   - Verify frontend routing configuration
-
-## Conclusion
-
-This fix simplifies the entire OAuth flow by processing everything directly in the backend, eliminating the complex multi-step process that was causing the account creation to fail. The new approach is more reliable, secure, and provides better error handling and user feedback.
-
-The key improvement is that the backend now handles the complete OAuth flow from start to finish, ensuring that accounts are properly created in the database without any intermediate steps that could fail.

ACCOUNT_CREATION_FIX_PLAN.md

@@ -1,166 +0,0 @@
-# Account Creation Fix Implementation Plan
-
-## Executive Summary
-The account creation process is failing during the OAuth callback phase. While the initial OAuth flow and callback are successful, the database insertion step is not working properly, resulting in accounts not being saved to the database.
-
-## Root Cause Analysis
-Based on the log analysis, the issue is in the OAuth callback handler in [`backend/api/accounts.py`](backend/api/accounts.py:126-207). The handler receives the OAuth code and state but fails to properly insert the account data into the Supabase `Social_network` table.
-
-## Implementation Plan
-
-### Phase 1: Immediate Debugging & Logging (Priority: High)
-
-#### 1.1 Enhanced Logging for OAuth Callback
-**File**: [`backend/api/accounts.py`](backend/api/accounts.py:126-207)
-**Changes**:
-- Add detailed logging at the beginning of `handle_oauth_callback`
-- Log all received parameters (user_id, code, state, social_network)
-- Add logging before and after database insertion
-- Log the exact data being inserted
-
-```python
-# Add to handle_oauth_callback function
-current_app.logger.info(f"🔗 [OAuth] Starting callback for user: {user_id}")
-current_app.logger.info(f"🔗 [OAuth] Received data: {data}")
-current_app.logger.info(f"🔗 [OAuth] Supabase client available: {hasattr(current_app, 'supabase')}")
-```
-
-#### 1.2 Database Connection Verification
-**File**: [`backend/api/accounts.py`](backend/api/accounts.py:169-183)
-**Changes**:
-- Add verification that Supabase client is properly initialized
-- Log the exact table name and data structure being used
-- Add error handling for database connection issues
-
-#### 1.3 Response Validation
-**File**: [`backend/api/accounts.py`](backend/api/accounts.py:184-195)
-**Changes**:
-- Add detailed logging of the database response
-- Log whether `response.data` exists and what it contains
-- Add validation to ensure the insertion was successful
-
-### Phase 2: Database Schema & Permissions (Priority: High)
-
-#### 2.1 Table Structure Verification
-**Action**: Verify the `Social_network` table structure in Supabase
-**Required Fields**:
-- `id` (UUID, primary key)
-- `social_network` (text)
-- `account_name` (text)
-- `id_utilisateur` (text, foreign key to users)
-- `token` (text, nullable)
-- `sub` (text, nullable)
-- `given_name` (text, nullable)
-- `family_name` (text, nullable)
-- `picture` (text, nullable)
-
-#### 2.2 RLS (Row Level Security) Policies
-**Action**: Check RLS policies on the `Social_network` table
-**Expected Policy**: Users should only be able to insert/update their own records
-**Verification**: Ensure the policy allows `id_utilisateur = auth.uid()`
-
-#### 2.3 Database Permissions
-**Action**: Verify service account has proper permissions
-**Required Permissions**: INSERT, SELECT, UPDATE, DELETE on `Social_network` table
-
-### Phase 3: OAuth Flow Verification (Priority: Medium)
-
-#### 3.1 Frontend Callback Handling
-**File**: [`frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx`](frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx:15-62)
-**Changes**:
-- Add logging to verify the callback is being processed
-- Log the URL parameters (code, state, error)
-- Verify the correct API endpoint is being called
-
-#### 3.2 API Endpoint Verification
-**File**: [`frontend/src/services/accountService.js`](frontend/src/services/accountService.js:82-101)
-**Changes**:
-- Add logging to verify the callback request is being sent
-- Log the request payload and response
-- Verify the correct endpoint `/accounts/callback` is being used
-
-### Phase 4: Data Validation & Error Handling (Priority: Medium)
-
-#### 4.1 Input Validation
-**File**: [`backend/api/accounts.py`](backend/api/accounts.py:144-149)
-**Changes**:
-- Add comprehensive validation for all required fields
-- Add logging for validation failures
-- Provide specific error messages for missing fields
-
-#### 4.2 Error Handling Enhancement
-**File**: [`backend/api/accounts.py`](backend/api/accounts.py:202-207)
-**Changes**:
-- Add specific error logging for different failure scenarios
-- Include the original error message in the response
-- Add try-catch blocks around database operations
-
-### Phase 5: Testing & Verification (Priority: Medium)
-
-#### 5.1 Unit Testing
-**Action**: Create unit tests for the OAuth callback handler
-**Coverage**:
-- Successful OAuth flow
-- Missing required fields
-- Database connection failures
-- Invalid user ID
-
-#### 5.2 Integration Testing
-**Action**: Test the complete OAuth flow end-to-end
-**Steps**:
-1. Initiate OAuth flow
-2. Complete LinkedIn authentication
-3. Handle callback in frontend
-4. Process callback in backend
-5. Verify database insertion
-6. Confirm account appears in UI
-
-#### 5.3 Database Testing
-**Action**: Test database operations directly
-**Verification**:
-- Manual insertion of test data
-- Verification of RLS policies
-- Testing of error scenarios
-
-## Implementation Timeline
-
-### Week 1: Immediate Fixes
-- [ ] Add enhanced logging to OAuth callback handler
-- [ ] Verify database connection and permissions
-- [ ] Test basic database insertion
-- [ ] Fix any immediate issues found
-
-### Week 2: Database & Security
-- [ ] Verify table structure and constraints
-- [ ] Check RLS policies and permissions
-- [ ] Implement proper error handling
-- [ ] Add input validation
-
-### Week 3: Testing & Verification
-- [ ] Create comprehensive unit tests
-- [ ] Perform end-to-end integration testing
-- [ ] Test error scenarios and edge cases
-- [ ] Verify fix works in production environment
-
-## Success Criteria
-1. ✅ OAuth callback completes successfully
-2. ✅ Account data is properly inserted into database
-3. ✅ Account appears in user account list
-4. ✅ Error handling provides clear feedback
-5. ✅ All tests pass
-
-## Monitoring & Maintenance
-1. **Logging**: Monitor OAuth callback success/failure rates
-2. **Database**: Regular backup and maintenance
-3. **Security**: Regular review of RLS policies and permissions
-4. **Performance**: Monitor database query performance
-
-## Risk Assessment
-- **High Risk**: Database connection issues
-- **Medium Risk**: RLS policy conflicts
-- **Low Risk**: Frontend callback handling
-
-## Contingency Plans
-1. **Database Issues**: Implement fallback logging and manual account creation
-2. **OAuth Issues**: Provide alternative authentication methods
-3. **Performance Issues**: Implement database connection pooling

ACCOUNT_CREATION_FIX_SUMMARY.md

@@ -1,184 +0,0 @@
-# LinkedIn Account Creation Fix Summary
-
-## Issue Analysis
-
-The user reported that they were trying to add a LinkedIn account but couldn't see it in their database despite successful API calls in the logs. After analyzing the logs and code, I identified the root cause:
-
-### Root Cause
-The OAuth callback handler was trying to make a POST request to the same server (`/api/accounts/callback`) from within the callback handler, which was causing a 500 error. This prevented the OAuth data from being properly processed and stored in the database.
-
-### Key Problems Identified
-
-1. **Callback Handler Architecture Issue**: The backend callback handler was attempting to make an internal API call to complete the OAuth flow, which created a circular dependency and failed.
-
-2. **Missing Session Management**: There was no proper session management to handle the OAuth data between the callback and the final account creation.
-
-3. **Frontend-Backend Communication Gap**: The frontend was expecting direct URL parameter handling, but the backend was trying to process everything internally.
-
-## Solution Implemented
-
-### 1. Backend OAuth Callback Handler Redesign
-
-**File**: `backend/app.py`
-
-- **Simplified Callback Flow**: Removed the internal API call attempt and instead store OAuth data in Flask session
-- **Proper Redirect**: Redirect back to the frontend with success/error indicators
-- **Session Storage**: Store OAuth data (`code`, `state`, `social_network`) in Flask session for later retrieval
-
-```python
-# Store the OAuth data in the session for the frontend to pick up
-from flask import session
-session['oauth_data'] = {
-    'code': code,
-    'state': state,
-    'social_network': 'LinkedIn'
-}
-
-# Redirect to frontend with success indication
-from flask import redirect
-redirect_url = f"{request.host_url.rstrip('/')}?oauth_success=true&from=linkedin"
-return redirect(redirect_url)
-```
-
-### 2. Frontend Callback Handler Update
-
-**File**: `frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx`
-
-- **Enhanced Parameter Handling**: Added support for `oauth_success` and `from` parameters
-- **Session Data Retrieval**: Implemented proper session data retrieval via API endpoint
-- **Improved Error Handling**: Added comprehensive error handling and logging
-
-```javascript
-// Check if we're coming from LinkedIn OAuth
-if (from === 'linkedin') {
-  if (oauthSuccess === 'true') {
-    // Get OAuth data from backend session
-    const sessionResponse = await apiClient.get('/accounts/session-data');
-    if (sessionResponse.data.success && sessionResponse.data.oauth_data) {
-      const oauthData = sessionResponse.data.oauth_data;
-      // Process OAuth callback
-    }
-  }
-}
-```
-
-### 3. Session Data API Endpoint
-
-**File**: `backend/api/accounts.py`
-
-- **New Endpoint**: Added `/api/accounts/session-data` endpoint to retrieve OAuth data from session
-- **Proper Authentication**: Ensured JWT protection for the endpoint
-- **Error Handling**: Added comprehensive error handling
-
-```python
-@accounts_bp.route('/session-data', methods=['GET'])
-@jwt_required()
-def get_session_data():
-    from flask import session
-    oauth_data = session.get('oauth_data', None)
-    
-    if oauth_data:
-        return jsonify({
-            'success': True,
-            'oauth_data': oauth_data
-        }), 200
-    else:
-        return jsonify({
-            'success': False,
-            'message': 'No OAuth data found in session'
-        }), 404
-```
-
-### 4. Enhanced Logging and Debugging
-
-**Files**: Multiple files updated with comprehensive logging
-
-- **Backend Logging**: Added detailed logging throughout the OAuth flow
-- **Frontend Logging**: Enhanced frontend callback handler with detailed debugging
-- **Error Tracking**: Improved error tracking and reporting
-
-## Technical Changes Summary
-
-### Backend Changes
-1. **OAuth Callback Handler**: Completely redesigned to use session-based approach
-2. **Session Management**: Implemented proper Flask session management
-3. **API Endpoint**: Added session data retrieval endpoint
-4. **Error Handling**: Enhanced error handling and logging
-
-### Frontend Changes
-1. **Callback Handler**: Updated to handle new URL parameters and session data
-2. **Error Handling**: Improved error handling and user feedback
-3. **Logging**: Enhanced debugging capabilities
-
-### Testing
-1. **Test Script**: Created `backend/test_oauth_callback.py` for testing the callback flow
-2. **Integration Testing**: Added comprehensive integration testing
-
-## Expected Behavior After Fix
-
-### Successful Account Creation Flow
-1. User clicks "Connect LinkedIn Account"
-2. User is redirected to LinkedIn for authentication
-3. After successful authentication, LinkedIn redirects back to `/auth/callback`
-4. Backend stores OAuth data in session and redirects to frontend with `?oauth_success=true&from=linkedin`
-5. Frontend detects the callback parameters and retrieves OAuth data from backend
-6. Frontend makes API call to `/api/accounts/callback` with OAuth data
-7. Backend processes OAuth data, exchanges code for access token, and stores account in database
-8. User sees success message and is redirected to sources page
-
-### Error Handling
-1. **Authentication Error**: If LinkedIn authentication fails, user is redirected back with error parameter
-2. **Missing Parameters**: If required parameters are missing, appropriate error is shown
-3. **Database Issues**: If database insertion fails, error is logged and user is informed
-4. **Session Issues**: If session data is missing, user is prompted to try again
-
-## Verification Steps
-
-To verify the fix works:
-
-1. **Start the backend server**: `python backend/app.py`
-2. **Start the frontend server**: `npm run dev` (in frontend directory)
-3. **Navigate to the application**: Open browser to the application URL
-4. **Add LinkedIn Account**: Click "Connect LinkedIn Account" button
-5. **Complete Authentication**: Follow through LinkedIn authentication process
-6. **Verify Success**: Check that the account appears in the database and UI
-
-### Testing with Test Script
-```bash
-cd backend
-python test_oauth_callback.py
-```
-
-## Monitoring and Debugging
-
-### Backend Logs
-Look for these key log messages:
-- `🔗 [OAuth] Direct callback handler triggered`
-- `🔗 [OAuth] OAuth data stored in session`
-- `🔗 [OAuth] Account linked successfully for user: [user_id]`
-
-### Frontend Logs
-Look for these key log messages:
-- `🔗 [Frontend] LinkedIn callback handler started`
-- `🔗 [Frontend] OAuth success detected, fetching session data...`
-- `🔗 [Frontend] LinkedIn account linked successfully!`
-
-## Database Verification
-
-After successful account creation, verify the account exists in the `Social_network` table:
-```sql
-SELECT * FROM Social_network WHERE id_utilisateur = '[user_id]' AND social_network = 'LinkedIn';
-```
-
-## Conclusion
-
-The fix addresses the core issue by implementing a proper session-based OAuth callback flow that avoids the circular dependency problem. The solution is more robust, maintainable, and provides better error handling and user feedback.
-
-The key improvements are:
-1. **Proper Session Management**: OAuth data is securely stored and retrieved
-2. **Clean Architecture**: Separation of concerns between frontend and backend
-3. **Better Error Handling**: Comprehensive error handling throughout the flow
-4. **Enhanced Logging**: Detailed logging for debugging and monitoring
-5. **User Experience**: Clear feedback and error messages for users
-
-This fix should resolve the issue where accounts were not appearing in the database despite successful API calls.

ACCOUNT_CREATION_WORKFLOW.md

@@ -1,150 +0,0 @@
-# Account Creation Workflow Diagram
-
-## Current Flow Analysis
-
-```mermaid
-graph TD
-    A[User Clicks "Add LinkedIn Account"] --> B[Frontend POST /api/accounts]
-    B --> C[Backend Initiate OAuth]
-    C --> D[Redirect to LinkedIn]
-    D --> E[User Authenticates with LinkedIn]
-    E --> F[LinkedIn Redirect to /auth/callback]
-    F --> G[Frontend LinkedInCallbackHandler]
-    G --> H[Frontend POST /accounts/callback]
-    H --> I[Backend handle_oauth_callback]
-    I --> J[Database Insert into Social_network]
-    J --> K[Return Success Response]
-    K --> L[Frontend Updates Account List]
-    L --> M[User Sees Account in UI]
-
-    style A fill:#e1f5fe
-    style M fill:#e8f5e8
-    style J fill:#ffebee
-    style K fill:#fff3e0
-```
-
-## Problem Identification
-
-Based on the log analysis, the issue is occurring at step **J** - Database Insert into Social_network. The OAuth flow is working correctly (steps A-I complete successfully), but the database insertion is failing silently.
-
-## Detailed Flow Breakdown
-
-### Step 1: Account Initiation
-- **Endpoint**: `POST /api/accounts`
-- **File**: [`backend/api/accounts.py:69-124`](backend/api/accounts.py:69)
-- **Action**: Initiates LinkedIn OAuth flow
-- **Status**: ✅ Working (200 response in logs)
-
-### Step 2: OAuth Redirect
-- **Action**: Redirects user to LinkedIn for authentication
-- **Status**: ✅ Working (successful LinkedIn auth in logs)
-
-### Step 3: Callback Handling
-- **Endpoint**: `GET /auth/callback`
-- **File**: [`frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx`](frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.jsx)
-- **Action**: Processes LinkedIn callback
-- **Status**: ✅ Working (successful callback in logs)
-
-### Step 4: Backend Processing
-- **Endpoint**: `POST /accounts/callback`
-- **File**: [`backend/api/accounts.py:126-207`](backend/api/accounts.py:126)
-- **Action**: Processes OAuth code and inserts into database
-- **Status**: ❓ Unknown (no logs for this endpoint)
-
-### Step 5: Database Insertion
-- **Table**: `Social_network`
-- **Action**: Insert account data
-- **Status**: ❓ Unknown (no evidence of success/failure)
-
-## Key Issues Identified
-
-### 1. Missing Logging
-The OAuth callback handler lacks sufficient logging to track:
-- Received parameters
-- Database connection status
-- Insertion attempts and results
-- Error conditions
-
-### 2. Silent Failures
-The error handling may be suppressing exceptions and returning 200 even when failures occur.
-
-### 3. Database Verification
-No verification that the database insertion was successful before returning a success response.
-
-## Recommended Workflow Enhancements
-
-### Enhanced Logging Flow
-```mermaid
-graph TD
-    A[OAuth Callback Received] --> B[Log Received Data]
-    B --> C[Validate Parameters]
-    C --> D[Log Validation Results]
-    D --> E[Exchange Code for Token]
-    E --> F[Log Token Exchange]
-    F --> G[Get User Info]
-    G --> H[Log User Info]
-    H --> I[Database Insertion]
-    I --> J[Log Insertion Result]
-    J --> K{Success?}
-    K -->|Yes| L[Return Success]
-    K -->|No| M[Return Error]
-    M --> N[Log Error Details]
-```
-
-### Error Handling Flow
-```mermaid
-graph TD
-    A[Error Occurs] --> B[Log Error]
-    B --> C[Determine Error Type]
-    C --> D{Database Error?}
-    D -->|Yes| E[Log Database Details]
-    D -->|No| F[Log General Error]
-    E --> G[Return 500 Error]
-    F --> G
-    G --> H[Add CORS Headers]
-```
-
-## Data Flow Analysis
-
-### OAuth Data Flow
-```
-LinkedIn → Authorization Code → Backend → Access Token → User Info → Database
-```
-
-### Database Schema Requirements
-```sql
-CREATE TABLE Social_network (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    social_network TEXT NOT NULL,
-    account_name TEXT NOT NULL,
-    id_utilisateur TEXT NOT NULL,
-    token TEXT,
-    sub TEXT,
-    given_name TEXT,
-    family_name TEXT,
-    picture TEXT,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-);
-
--- RLS Policy
-CREATE POLICY "Users can manage their own accounts"
-ON Social_network
-FOR ALL
-USING (auth.uid()::text = id_utilisateur);
-```
-
-## Next Steps
-
-1. **Add comprehensive logging** to track the complete OAuth flow
-2. **Verify database connection** and permissions
-3. **Test database insertion** with sample data
-4. **Implement proper error handling** with detailed feedback
-5. **Create monitoring** for account creation success/failure rates
-
-## Success Metrics
-
-- ✅ OAuth callback receives and processes data correctly
-- ✅ Database insertion succeeds consistently
-- ✅ Error handling provides clear feedback
-- ✅ Accounts appear in user interface immediately
-- ✅ Logging provides complete visibility into the process

CELERY_SCHEDULING_SETUP.md

@@ -1,340 +0,0 @@
-# Celery Scheduling Setup Guide
-
-This guide explains how to set up and use the Celery scheduling system with your Lin application.
-
-## Overview
-
-The updated `start_app.py` now automatically starts both the Flask application and Celery components (worker and beat scheduler) when you run the application. This ensures that your scheduled tasks will execute properly.
-
-## Prerequisites
-
-### 1. Redis Server
-Celery requires Redis as a message broker. Make sure Redis is installed and running:
-
-**Windows:**
-```bash
-# Install Redis (if not installed)
-# Download from https://github.com/microsoftarchive/redis/releases
-
-# Start Redis server
-redis-server
-```
-
-**Linux/Mac:**
-```bash
-# Install Redis
-sudo apt-get install redis-server  # Ubuntu/Debian
-brew install redis                 # macOS
-
-# Start Redis
-sudo systemctl start redis
-sudo systemctl enable redis
-```
-
-### 2. Hugging Face Spaces / Production Deployment
-For Hugging Face Spaces or production deployments where you can't run Redis directly:
-
-**Option A: Use Redis Cloud (Recommended)**
-1. Create a free Redis Cloud account at https://redislabs.com/try-free/
-2. Create a Redis database (free tier available)
-3. Update your `.env` file:
-```env
-CELERY_BROKER_URL="redis://your-redis-host:port/0"
-CELERY_RESULT_BACKEND="redis://your-redis-host:port/0"
-```
-
-**Option B: Use Docker Compose**
-```yaml
-# docker-compose.yml
-version: '3.8'
-services:
-  redis:
-    image: redis:7-alpine
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis_data:/data
-    command: redis-server --appendonly yes
-
-volumes:
-  redis_data:
-```
-
-**Option C: Skip Celery (Basic Mode)**
-If Redis is not available, the Flask app will start without Celery functionality. Schedules will be saved but won't execute automatically.
-
-### 2. Python Dependencies
-Install the required packages:
-```bash
-pip install -r backend/requirements.txt
-```
-
-## Starting the Application
-
-### Using start_app.py (Recommended)
-```bash
-python start_app.py
-```
-
-This will:
-1. Check Redis connection
-2. Start Celery worker in the background
-3. Start Celery beat scheduler in the background
-4. Start the Flask application
-
-### Using Backend Scripts (Alternative)
-```bash
-# Start both worker and beat
-cd backend
-python start_celery.py all
-
-# Or start individually
-python start_celery.py worker  # Start Celery worker
-python start_celery.py beat   # Start Celery beat scheduler
-```
-
-## Configuration
-
-### Environment Variables
-Make sure these are set in your `.env` file:
-
-```env
-# Supabase configuration
-SUPABASE_URL="your_supabase_url"
-SUPABASE_KEY="your_supabase_key"
-
-# Redis configuration (if not using defaults)
-CELERY_BROKER_URL="redis://localhost:6379/0"
-CELERY_RESULT_BACKEND="redis://localhost:6379/0"
-
-# Scheduler configuration
-SCHEDULER_ENABLED=True
-```
-
-### Celery Configuration
-The unified configuration is in `backend/celery_config.py`:
-
-```python
-celery_app.conf.beat_schedule = {
-    'load-schedules': {
-        'task': 'backend.celery_tasks.schedule_loader.load_schedules_task',
-        'schedule': crontab(minute='*/5'),  # Every 5 minutes
-    },
-}
-```
-
-## How Scheduling Works
-
-### 1. Schedule Loading
-- **Immediate Updates**: When you create or delete a schedule via the API, Celery Beat is updated immediately
-- **Periodic Updates**: Celery Beat also runs every 5 minutes as a backup
-- Executes `load_schedules_task`
-- Fetches schedules from Supabase database
-- Creates individual periodic tasks for each schedule
-
-### 2. Task Execution
-- **Content Generation**: Runs 5 minutes before scheduled time
-- **Post Publishing**: Runs at the scheduled time
-- Tasks are queued in appropriate queues (content, publish)
-
-### 3. Database Integration
-- Uses Supabase for schedule storage
-- Automatically creates tasks based on schedule data
-- Handles social network authentication
-
-## Monitoring and Debugging
-
-### Checking Celery Status
-```bash
-# Check worker status
-celery -A celery_config inspect stats
-
-# Check scheduled tasks
-celery -A celery_config inspect scheduled
-
-# Check active tasks
-celery -A celery_config inspect active
-```
-
-### Viewing Logs
-- **Flask Application**: Check console output
-- **Celery Worker**: Look for worker process logs
-- **Celery Beat**: Look for beat process logs
-
-### Common Issues
-
-**1. Redis Connection Failed**
-```
-Error: Error 111 connecting to localhost:6379. Connection refused
-
-Solutions:
-1. Start Redis server locally (development):
-   Windows: redis-server
-   Linux/Mac: sudo systemctl start redis
-
-2. Use Redis Cloud (production/Hugging Face):
-   - Create free Redis Cloud account
-   - Update .env with Redis Cloud URL
-   - Set CELERY_BROKER_URL and CELERY_RESULT_BACKEND
-
-3. Use Docker Compose:
-   version: '3.8'
-   services:
-     redis:
-       image: redis:7-alpine
-       ports: ["6379:6379"]
-       volumes: [redis_data:/data]
-   volumes: redis_data:
-
-4. Skip Celery (basic mode):
-   - App will start without scheduling functionality
-   - Schedules saved but won't execute automatically
-```
-
-**2. Tasks Not Executing**
-```bash
-# Check if Celery worker is running
-celery -A celery_config inspect ping
-
-# Check if beat scheduler is running
-ps aux | grep celery
-```
-
-**3. Schedule Not Loading**
-- Check Supabase database connection
-- Verify schedule data in database
-- Check task registration in Celery
-
-## Testing the Scheduling System
-
-### Manual Testing
-```python
-# Test schedule loading task
-from backend.celery_tasks.schedule_loader import load_schedules_task
-result = load_schedules_task()
-print(result)
-```
-
-### API Testing (Recommended)
-1. **Create a schedule via the API**:
-   ```bash
-   curl -X POST http://localhost:5000/api/schedules/ \
-     -H "Content-Type: application/json" \
-     -H "Authorization: Bearer YOUR_JWT_TOKEN" \
-     -d '{
-       "social_network": "1",
-       "schedule_time": "09:00",
-       "days": ["Monday", "Wednesday", "Friday"]
-     }'
-   ```
-   
-2. **Check the response**: You should see a `celery_update_task_id` field indicating the scheduler was updated immediately
-
-3. **Verify in Celery**: Check if the individual tasks were created:
-   ```bash
-   celery -A celery_config inspect scheduled
-   ```
-
-### Database Testing
-1. Add a schedule directly in the Supabase database
-2. Wait 5 minutes for the loader task to run (or trigger via API)
-3. Check if individual tasks were created
-4. Verify task execution times
-
-## Production Deployment
-
-### Using Docker (Recommended for Hugging Face Spaces)
-```bash
-# Build the Docker image
-docker build -t lin-app .
-
-# Run the container
-docker run -p 7860:7860 lin-app
-
-# For Hugging Face Spaces deployment:
-# 1. Update your Dockerfile (already done above)
-# 2. Push to Hugging Face Spaces
-# 3. The container will automatically start Redis + your app
-```
-
-### Using Docker Compose (Local Development)
-```yaml
-# docker-compose.yml
-version: '3.8'
-services:
-  redis:
-    image: redis:7-alpine
-    ports: ["6379:6379"]
-    volumes: [redis_data:/data]
-    command: redis-server --appendonly yes
-  
-  app:
-    build: .
-    ports: ["7860:7860"]
-    depends_on: [redis]
-    environment:
-      - REDIS_URL=redis://redis:6379/0
-    volumes: [./:/app]
-
-volumes: redis_data:
-```
-
-```bash
-# Start all services
-docker-compose up -d
-
-# Check logs
-docker-compose logs -f
-```
-
-### Using Docker
-```bash
-# Build and start all services
-docker-compose up -d
-
-# Check logs
-docker-compose logs -f
-```
-
-### Using Supervisor (Linux)
-Create `/etc/supervisor/conf.d/lin.conf`:
-```ini
-[program:lin_worker]
-command=python start_app.py
-directory=/path/to/lin
-autostart=true
-autorestart=true
-user=www-data
-environment=PATH="/path/to/venv/bin"
-
-[program:lin_beat]
-command=python -m celery -A celery_config beat
-directory=/path/to/lin
-autostart=true
-autorestart=true
-user=www-data
-environment=PATH="/path/to/venv/bin"
-```
-
-## Troubleshooting Checklist
-
-1. ✅ Redis server is running
-2. ✅ All Python dependencies are installed
-3. ✅ Environment variables are set correctly
-4. ✅ Supabase database connection works
-5. ✅ Celery worker is running
-6. ✅ Celery beat scheduler is running
-7. ✅ Schedule data exists in database
-8. ✅ Tasks are properly registered
-9. ✅ Task execution permissions are correct
-
-## Support
-
-If you encounter issues:
-1. Check this guide first
-2. Review the logs for error messages
-3. Verify all prerequisites are met
-4. Test components individually
-5. Check the Celery documentation
-
-For additional help, refer to the Celery documentation at: https://docs.celeryq.dev/

DEPLOYMENT_VERIFICATION_CHECKLIST.md

@@ -1,165 +0,0 @@
-# Deployment Verification Checklist
-
-## Authentication Fix for Hugging Face Spaces
-
-This checklist will help you verify that the authentication fixes work correctly in your Hugging Face Space deployment.
-
-### ✅ Pre-Deployment Checks
-
-#### 1. Frontend Configuration
-- [ ] `.env.production` file has correct API URL: `https://zelyanoth-lin-cbfcff2.hf.space/api`
-- [ ] `VITE_NODE_ENV=production` is set in `.env.production`
-- [ ] Frontend has been built with `npm run build`
-- [ ] `dist/` folder exists and contains built files
-
-#### 2. Backend Configuration
-- [ ] `backend/app.py` imports `request` from Flask
-- [ ] CORS origins include `https://zelyanoth-lin-cbfcff2.hf.space`
-- [ ] Cookie service uses `sameSite: 'Lax'` for production
-- [ ] JWT secret key is properly configured
-
-#### 3. Cookie Security Settings
-- [ ] Production cookies use `sameSite: 'Lax'` (not 'Strict')
-- [ ] Production cookies use `secure: true`
-- [ ] All cookies have `httpOnly: true`
-- [ ] CORS allows credentials (`supports_credentials: true`)
-
-### ✅ Deployment Steps
-
-#### 1. Build Frontend
-```bash
-cd frontend
-npm run build
-cd ..
-```
-
-#### 2. Commit Changes
-```bash
-git add .
-git commit -m "fix: authentication fixes for Hugging Face Spaces deployment"
-git push origin main
-```
-
-#### 3. Monitor Hugging Face Build
-- [ ] Check build logs in Hugging Face Space dashboard
-- [ ] Verify no errors during build process
-- [ ] Confirm deployment completes successfully
-
-### ✅ Post-Deployment Testing
-
-#### 1. Basic Functionality Tests
-- [ ] Application loads at `https://zelyanoth-lin-cbfcff2.hf.space`
-- [ ] Health check endpoint works: `https://zelyanoth-lin-cbfcff2.hf.space/health`
-- [ ] API health check works: `https://zelyanoth-lin-cbfcff2.hf.space/api/health`
-
-#### 2. Authentication Flow Tests
-- [ ] **Login Page**: Access `/login` page
-- [ ] **Login Attempt**: Try to login with valid credentials
-- [ ] **Login Success**: Verify successful login redirects to dashboard
-- [ ] **Cookie Storage**: Check that cookies are set (use browser dev tools)
-- [ ] **Page Reload**: Refresh the page while logged in
-- [ ] **Session Persistence**: Verify you remain logged in after reload
-- [ ] **Protected Routes**: Access `/dashboard`, `/accounts`, etc. while logged in
-- [ ] **Logout**: Test logout functionality
-- [ ] **Post-Logout**: Verify redirect to login page after logout
-
-#### 3. Cookie Security Verification
-- [ ] **Cookie Attributes**: Check browser cookies for:
-  - `SameSite=Lax` (production setting)
-  - `Secure` flag (for HTTPS)
-  - `HttpOnly` flag (prevents JavaScript access)
-- [ ] **Cross-Origin Requests**: Verify CORS headers are present in API responses
-- [ ] **Token Validation**: JWT tokens are properly validated on server side
-
-#### 4. Error Handling Tests
-- [ ] **Invalid Credentials**: Try login with wrong password
-- [ ] **Expired Token**: Wait for token to expire (1 hour) and test reload
-- [ ] **Network Issues**: Test with network disabled then reconnected
-- [ ] **Browser Cache**: Clear browser cache and test authentication
-
-#### 5. Browser Compatibility
-- [ ] **Chrome**: Test all functionality
-- [ ] **Firefox**: Test all functionality
-- [ ] **Safari**: Test all functionality
-- [ ] **Mobile Chrome**: Test on mobile device
-- [ ] **Mobile Safari**: Test on mobile device
-
-### ✅ Monitoring and Logging
-
-#### 1. Browser Console
-- [ ] No JavaScript errors on page load
-- [ ] API requests show correct status codes
-- [ ] Authentication requests show proper headers
-
-#### 2. Network Tab
-- [ ] API requests include Authorization header when logged in
-- [ ] CORS requests show correct `Access-Control-Allow-*` headers
-- [ ] No failed authentication requests
-
-#### 3. Server Logs (Hugging Face Dashboard)
-- [ ] No Flask application errors
-- [ ] Successful health checks
-- [ ] Authentication requests logged properly
-- [ ] CORS headers applied correctly
-
-### ✅ Performance Tests
-
-#### 1. Load Time
-- [ ] Page loads within 3 seconds
-- [ ] API responses under 1 second
-- [ ] Login process completes within 2 seconds
-
-#### 2. Resource Usage
-- [ ] Memory usage is reasonable
-- [ ] No memory leaks detected
-- [ ] CPU usage normal for traffic level
-
-### ✅ Security Verification
-
-#### 1. Cookie Security
-- [ ] No sensitive data in localStorage (should use cookies only)
-- [ ] CSRF protection working (via SameSite policy)
-- [ ] XSS protection (HttpOnly cookies)
-
-#### 2. API Security
-- [ ] Unauthenticated requests to protected routes return 401
-- [ ] JWT tokens properly validated
-- [ ] No exposed sensitive data in API responses
-
-### 🚨 Troubleshooting Guide
-
-#### Common Issues and Solutions
-
-**Issue: "NameError: name 'request' is not defined"**
-- ✅ Fixed: Added `from flask import request` to `backend/app.py`
-
-**Issue: Authentication fails after page reload**
-- ✅ Fixed: Changed cookie `sameSite` from 'Strict' to 'Lax' for production
-- ✅ Fixed: Updated API client to use production URL
-
-**Issue: CORS errors in browser console**
-- ✅ Fixed: Added Hugging Face Space URL to CORS origins
-- ✅ Fixed: Ensured CORS headers include necessary fields
-
-**Issue: Cookies not being set**
-- ✅ Verify: `secure` flag matches HTTPS environment
-- ✅ Verify: `sameSite` policy is appropriate for deployment
-- ✅ Verify: CORS allows credentials
-
-### 📝 Final Verification
-
-#### Success Criteria
-- [ ] User can login successfully
-- [ ] User remains logged in after page reload
-- [ ] Protected routes are accessible only when authenticated
-- [ ] Logout functionality works correctly
-- [ ] No console errors or warnings
-- [ ] All security headers are present
-- [ ] Application works across different browsers
-
-#### Deployment Complete When:
-All checkboxes above are marked as complete ✅
-
----
-
-**Note**: If any test fails, refer to the troubleshooting guide above and ensure all fixes have been applied before redeploying.

FINAL_APSCHEDULER_MIGRATION_SUMMARY.md

@@ -1,60 +0,0 @@
-# APScheduler Migration - Implementation Complete
-
-## Summary
-
-We have successfully migrated the Lin application from Celery to APScheduler for task scheduling. This migration simplifies the architecture, reduces dependencies, and makes the application easier to deploy and maintain.
-
-## Key Changes
-
-1. **Removed Dependencies**:
-   - Removed `celery` and `redis` from requirements.txt
-   - Kept `apscheduler` as the scheduling library
-
-2. **New Scheduler Service**:
-   - Created `backend/scheduler/apscheduler_service.py` with full APScheduler implementation
-   - Implemented content generation and post publishing tasks
-   - Added immediate schedule loading on app startup
-   - Added periodic schedule reloading every 5 minutes
-
-3. **Updated Flask Application**:
-   - Modified `backend/app.py` to initialize APScheduler
-   - Added scheduler initialization when `SCHEDULER_ENABLED` is True
-
-4. **Updated API Endpoints**:
-   - Modified `backend/api/schedules.py` to trigger APScheduler updates
-   - Removed all references to Celery task IDs in responses
-
-5. **Simplified Startup**:
-   - Updated `start_app.py` to remove Celery initialization
-   - Application now starts with just Flask and APScheduler
-
-6. **Removed Files**:
-   - Removed all Celery-related files and directories
-   - Cleaned up the codebase from legacy components
-
-7. **Documentation**:
-   - Created comprehensive documentation for the new APScheduler setup
-   - Added migration guide and implementation summary
-
-## Benefits Achieved
-
-1. **Simplified Architecture**: Single process deployment with no external dependencies
-2. **Easier Setup**: No need to install and configure Redis
-3. **Reduced Complexity**: Fewer moving parts to manage
-4. **Better Resource Usage**: Lower memory and CPU footprint
-5. **Easier Debugging**: All logs in one place
-6. **Simplified Deployment**: No need for separate worker processes
-
-## Next Steps
-
-1. Test the application thoroughly to ensure all scheduling functionality works correctly
-2. Monitor logs for any issues with task execution
-3. Consider adding more comprehensive error handling and monitoring
-4. Update any remaining documentation references
-
-## Files to Review
-
-- `APSCHEDULER_SETUP.md` - Complete setup and usage guide
-- `MIGRATION_TO_APSCHEDULER.md` - Migration guide from Celery
-- `APSCHEDULER_IMPLEMENTATION_SUMMARY.md` - Technical implementation summary
-- `backend/scheduler/apscheduler_service.py` - Main scheduler implementation

FINAL_DOCUMENTATION.md

@@ -1,692 +0,0 @@
-# Lin React Clone - Final Documentation
-
-## Project Overview
-
-This documentation provides a comprehensive overview of the Lin React Clone project, which is a modern reimplementation of the original Taipy-based Lin application using a React frontend with a Flask API backend. The project maintains all core functionality while improving the architecture for better maintainability and scalability.
-
-## Table of Contents
-
-1. [Architecture Overview](#architecture-overview)
-2. [Backend Implementation](#backend-implementation)
-3. [Frontend Implementation](#frontend-implementation)
-4. [API Documentation](#api-documentation)
-5. [Deployment Guide](#deployment-guide)
-6. [Testing Strategy](#testing-strategy)
-7. [Future Enhancements](#future-enhancements)
-
-## Architecture Overview
-
-### System Components
-
-The Lin React Clone consists of two main components:
-
-1. **Frontend (React)**
-   - User interface built with React
-   - State management with Redux Toolkit
-   - Responsive design for all device sizes
-   - Component-based architecture
-
-2. **Backend (Flask API)**
-   - RESTful API built with Flask
-   - Database integration with Supabase
-   - Task scheduling with APScheduler
-   - External API integrations (LinkedIn, Hugging Face)
-
-### Data Flow
-
-```
-[React Frontend] ↔ [Flask API] ↔ [Supabase Database]
-                        ↓
-              [External APIs: LinkedIn, Hugging Face]
-                        ↓
-                  [APScheduler Tasks]
-```
-
-### Technology Stack
-
-#### Backend
-- Flask (Python web framework)
-- Supabase (Database and authentication)
-- APScheduler (Task scheduling)
-- requests (HTTP library)
-- requests-oauthlib (OAuth support)
-- gradio-client (Hugging Face API)
-- Flask-JWT-Extended (JWT token management)
-
-#### Frontend
-- React (JavaScript library)
-- Redux Toolkit (State management)
-- React Router (Routing)
-- Axios (HTTP client)
-- Material-UI (UI components)
-
-## Backend Implementation
-
-### Project Structure
-
-```
-backend/
-├── app.py                 # Flask application entry point
-├── config.py              # Configuration settings
-├── requirements.txt       # Python dependencies
-├── .env.example          # Environment variables example
-├── models/                # Data models
-│   ├── user.py            # User model
-│   ├── social_account.py  # Social media account model
-│   ├── source.py          # RSS source model
-│   ├── post.py            # Post content model
-│   └── schedule.py        # Scheduling model
-├── api/                   # API endpoints
-│   ├── auth.py            # Authentication endpoints
-│   ├── sources.py         # Source management endpoints
-│   ├── accounts.py        # Social account endpoints
-│   ├── posts.py           # Post management endpoints
-│   └── schedules.py       # Scheduling endpoints
-├── services/              # Business logic
-│   ├── auth_service.py    # Authentication service
-│   ├── linkedin_service.py# LinkedIn integration service
-│   ├── content_service.py # Content generation service
-│   └── schedule_service.py# Scheduling service
-├── utils/                 # Utility functions
-│   └── database.py        # Database connection
-└── scheduler/             # Task scheduling
-    └── task_scheduler.py  # Scheduling implementation
-```
-
-### Key Features
-
-#### Authentication System
-- JWT-based authentication with secure token management
-- User registration with email confirmation
-- User login/logout functionality
-- Password hashing with bcrypt
-- Supabase Auth integration
-
-#### Source Management
-- CRUD operations for RSS sources
-- Integration with Supabase database
-- Validation and error handling
-
-#### Social Account Management
-- LinkedIn OAuth2 integration
-- Account linking and token storage
-- Profile information retrieval
-
-#### Post Management
-- AI-powered content generation using Hugging Face API
-- Post creation and storage
-- LinkedIn publishing integration
-- Image handling for posts
-
-#### Scheduling System
-- APScheduler for task management
-- Recurring schedule creation
-- Automatic content generation and publishing
-- Conflict resolution for overlapping schedules
-
-## Frontend Implementation
-
-### Project Structure
-
-```
-frontend/
-├── src/
-│   ├── components/        # Reusable components
-│   │   ├── Header/        # Application header
-│   │   └── Sidebar/       # Navigation sidebar
-│   ├── pages/             # Page components
-│   │   ├── Login.js       # Login page
-│   │   ├── Register.js    # Registration page
-│   │   ├── Dashboard.js   # Dashboard page
-│   │   ├── Sources.js     # Source management page
-│   │   ├── Posts.js       # Post management page
-│   │   └── Schedule.js    # Scheduling page
-│   ├── services/          # API service layer
-│   │   ├── api.js         # Axios instance and interceptors
-│   │   ├── authService.js # Authentication API calls
-│   │   ├── sourceService.js# Source management API calls
-│   │   ├── accountService.js# Account management API calls
-│   │   ├── postService.js # Post management API calls
-│   │   └── scheduleService.js# Scheduling API calls
-│   ├── store/             # Redux store
-│   │   ├── index.js       # Store configuration
-│   │   └── reducers/      # Redux reducers and actions
-│   ├── App.js             # Main application component
-│   ├── App.css            # Global application styles
-│   ├── index.js           # Application entry point
-│   └── index.css          # Global CSS styles
-├── public/                # Static assets
-└── package.json           # Project dependencies and scripts
-```
-
-### Key Features
-
-#### Authentication System
-- Login and registration forms
-- JWT token management in localStorage
-- Protected routes
-- User session management
-
-#### Dashboard
-- Overview statistics
-- Recent activity display
-- Quick action buttons
-
-#### Source Management
-- Add/delete RSS sources
-- List view of all sources
-- Form validation
-
-#### Post Management
-- AI content generation interface
-- Post creation form
-- Draft and published post management
-- Publish and delete functionality
-
-#### Scheduling
-- Schedule creation form with time selection
-- Day selection interface
-- List view of all schedules
-- Delete functionality
-
-## API Documentation
-
-### Authentication Endpoints
-
-#### POST /api/auth/register
-Register a new user
-
-**Request Body:**
-```json
-{
-  "email": "string",
-  "password": "string",
-  "confirm_password": "string"
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "User registered successfully",
-  "user": {
-    "id": "string",
-    "email": "string",
-    "created_at": "datetime"
-  }
-}
-```
-
-#### POST /api/auth/login
-Login user
-
-**Request Body:**
-```json
-{
-  "email": "string",
-  "password": "string"
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "token": "string",
-  "user": {
-    "id": "string",
-    "email": "string"
-  }
-}
-```
-
-#### POST /api/auth/logout
-Logout user
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Logged out successfully"
-}
-```
-
-#### GET /api/auth/user
-Get current user
-
-**Response:**
-```json
-{
-  "success": true,
-  "user": {
-    "id": "string",
-    "email": "string"
-  }
-}
-```
-
-### Source Endpoints
-
-#### GET /api/sources
-Get all sources for current user
-
-**Response:**
-```json
-{
-  "success": true,
-  "sources": [
-    {
-      "id": "string",
-      "user_id": "string",
-      "source": "string",
-      "category": "string",
-      "last_update": "datetime",
-      "created_at": "datetime"
-    }
-  ]
-}
-```
-
-#### POST /api/sources
-Add a new source
-
-**Request Body:**
-```json
-{
-  "source": "string"
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "source": {
-    "id": "string",
-    "user_id": "string",
-    "source": "string",
-    "category": "string",
-    "last_update": "datetime",
-    "created_at": "datetime"
-  }
-}
-```
-
-#### DELETE /api/sources/{id}
-Delete a source
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Source deleted successfully"
-}
-```
-
-### Account Endpoints
-
-#### GET /api/accounts
-Get all social accounts for current user
-
-**Response:**
-```json
-{
-  "success": true,
-  "accounts": [
-    {
-      "id": "string",
-      "user_id": "string",
-      "social_network": "string",
-      "account_name": "string",
-      "created_at": "datetime"
-    }
-  ]
-}
-```
-
-#### POST /api/accounts
-Add a new social account
-
-**Request Body:**
-```json
-{
-  "account_name": "string",
-  "social_network": "string"
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "account": {
-    "id": "string",
-    "user_id": "string",
-    "social_network": "string",
-    "account_name": "string",
-    "created_at": "datetime"
-  }
-}
-```
-
-#### DELETE /api/accounts/{id}
-Delete a social account
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Account deleted successfully"
-}
-```
-
-### Post Endpoints
-
-#### GET /api/posts
-Get all posts for current user
-
-**Query Parameters:**
-- `published` (boolean): Filter by published status
-
-**Response:**
-```json
-{
-  "success": true,
-  "posts": [
-    {
-      "id": "string",
-      "social_account_id": "string",
-      "text_content": "string",
-      "is_published": "boolean",
-      "sched": "string",
-      "image_content_url": "string",
-      "created_at": "datetime",
-      "scheduled_at": "datetime"
-    }
-  ]
-}
-```
-
-#### POST /api/posts/generate
-Generate AI content
-
-**Response:**
-```json
-{
-  "success": true,
-  "content": "string"
-}
-```
-
-#### POST /api/posts
-Create a new post
-
-**Request Body:**
-```json
-{
-  "social_account_id": "string",
-  "text_content": "string",
-  "image_content_url": "string",
-  "scheduled_at": "datetime"
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "post": {
-    "id": "string",
-    "social_account_id": "string",
-    "text_content": "string",
-    "is_published": "boolean",
-    "sched": "string",
-    "image_content_url": "string",
-    "created_at": "datetime",
-    "scheduled_at": "datetime"
-  }
-}
-```
-
-#### POST /api/posts/{id}/publish
-Publish a post
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Post published successfully"
-}
-```
-
-#### DELETE /api/posts/{id}
-Delete a post
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Post deleted successfully"
-}
-```
-
-### Schedule Endpoints
-
-#### GET /api/schedules
-Get all schedules for current user
-
-**Response:**
-```json
-{
-  "success": true,
-  "schedules": [
-    {
-      "id": "string",
-      "social_account_id": "string",
-      "schedule_time": "string",
-      "adjusted_time": "string",
-      "created_at": "datetime"
-    }
-  ]
-}
-```
-
-#### POST /api/schedules
-Create a new schedule
-
-**Request Body:**
-```json
-{
-  "social_network": "string",
-  "schedule_time": "string",
-  "days": ["string"]
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "schedules": [
-    {
-      "id": "string",
-      "social_account_id": "string",
-      "schedule_time": "string",
-      "adjusted_time": "string",
-      "created_at": "datetime"
-    }
-  ]
-}
-```
-
-#### DELETE /api/schedules/{id}
-Delete a schedule
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Schedule deleted successfully"
-}
-```
-
-## Deployment Guide
-
-### Backend Deployment
-
-1. **Environment Setup**
-   ```bash
-   # Copy environment example
-   cp .env.example .env
-   
-   # Edit .env with your values
-   ```
-
-2. **Install Dependencies**
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-3. **Run Application**
-   ```bash
-   python app.py
-   ```
-
-4. **Docker Deployment**
-   ```bash
-   docker build -t lin-backend .
-   docker run -p 5000:5000 lin-backend
-   ```
-
-### Frontend Deployment
-
-1. **Install Dependencies**
-   ```bash
-   npm install
-   ```
-
-2. **Build for Production**
-   ```bash
-   npm run build
-   ```
-
-3. **Serve Build**
-   ```bash
-   npm install -g serve
-   serve -s build
-   ```
-
-### Environment Variables
-
-#### Backend (.env)
-```
-SUPABASE_URL=your_supabase_project_url
-SUPABASE_KEY=your_supabase_api_key
-CLIENT_ID=your_linkedin_client_id
-CLIENT_SECRET=your_linkedin_client_secret
-REDIRECT_URL=your_redirect_url
-HUGGING_KEY=your_hugging_face_api_key
-JWT_SECRET_KEY=your_jwt_secret_key
-SECRET_KEY=your_secret_key
-DEBUG=True
-SCHEDULER_ENABLED=True
-PORT=5000
-```
-
-#### Frontend (.env)
-```
-REACT_APP_API_URL=http://localhost:5000/api
-```
-
-## Testing Strategy
-
-### Backend Testing
-
-1. **Unit Tests**
-   - Model validation tests
-   - Service layer tests
-   - Utility function tests
-
-2. **Integration Tests**
-   - API endpoint tests
-   - Database integration tests
-   - External API integration tests
-
-3. **Test Commands**
-   ```bash
-   # Run all tests
-   pytest
-   
-   # Run tests with coverage
-   pytest --cov=.
-   ```
-
-### Frontend Testing
-
-1. **Component Tests**
-   - Rendering tests
-   - User interaction tests
-   - State management tests
-
-2. **Integration Tests**
-   - Form submission tests
-   - API integration tests
-   - Routing tests
-
-3. **Test Commands**
-   ```bash
-   # Run all tests
-   npm test
-   
-   # Run tests in watch mode
-   npm test -- --watch
-   ```
-
-## Future Enhancements
-
-### Backend Enhancements
-1. **Advanced Analytics**
-   - Post performance tracking
-   - User engagement metrics
-   - Content effectiveness analysis
-
-2. **Multi-Platform Support**
-   - Twitter integration
-   - Facebook integration
-   - Instagram integration
-
-3. **Enhanced Scheduling**
-   - Advanced scheduling algorithms
-   - Timezone support
-   - Recurrence patterns
-
-4. **Performance Improvements**
-   - Caching strategies
-   - Database optimization
-   - Asynchronous processing
-
-### Frontend Enhancements
-1. **Advanced UI Components**
-   - Data visualization dashboards
-   - Real-time updates
-   - Drag-and-drop scheduling
-
-2. **Enhanced User Experience**
-   - Dark mode support
-   - Keyboard shortcuts
-   - Accessibility improvements
-
-3. **Mobile Enhancements**
-   - Progressive Web App (PWA) support
-   - Native mobile features
-   - Offline capabilities
-
-4. **Advanced Features**
-   - Content calendar view
-   - Team collaboration features
-   - Content approval workflows
-
-## Conclusion
-
-The Lin React Clone project successfully reimplements the original Taipy-based application with a modern, scalable architecture. The separation of concerns between the frontend and backend allows for independent development and deployment, while the RESTful API design ensures clear communication between components. The implementation includes all core features of the original application while providing a foundation for future enhancements and improvements.

LINKEDIN_AUTH_GUIDE.md

@@ -1,258 +0,0 @@
-# LinkedIn Authentication Implementation Guide
-
-This guide provides a comprehensive overview of the LinkedIn authentication implementation in the React Clone application.
-
-## Overview
-
-The LinkedIn authentication system allows users to connect multiple LinkedIn accounts to the application for posting content. The implementation follows OAuth 2.0 standards and includes proper error handling, state management, and user experience considerations.
-
-## Architecture
-
-### Frontend Components
-
-1. **LinkedInAuthService** (`frontend/src/services/linkedinAuthService.js`)
-   - Handles all API calls related to LinkedIn authentication
-   - Manages OAuth flow initiation and callback processing
-   - Provides methods for account management
-
-2. **LinkedInAccountsSlice** (`frontend/src/store/reducers/linkedinAccountsSlice.js`)
-   - Redux slice for managing LinkedIn accounts state
-   - Handles async operations for fetching, adding, and managing accounts
-   - Manages loading states and error handling
-
-3. **LinkedInAccountsManager** (`frontend/src/components/LinkedInAccount/LinkedInAccountsManager.js`)
-   - Main component for managing LinkedIn accounts
-   - Displays connected accounts and provides management options
-   - Handles the "Add Account" flow
-
-4. **LinkedInAccountCard** (`frontend/src/components/LinkedInAccount/LinkedInAccountCard.js`)
-   - Individual account display component
-   - Shows account information and actions (set primary, delete)
-   - Handles account-specific operations
-
-5. **LinkedInCallbackHandler** (`frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.js`)
-   - Handles the OAuth callback from LinkedIn
-   - Processes authorization code and exchanges it for access token
-   - Manages authentication states and error handling
-
-6. **Accounts Page** (`frontend/src/pages/Accounts.js`)
-   - Dedicated page for managing all social media accounts
-   - Provides a clean interface for LinkedIn account management
-   - Separates account management from RSS source management
-
-### Backend API
-
-1. **Accounts API** (`backend/api/accounts.py`)
-   - `/accounts` - GET: Fetch all accounts, POST: Initiate OAuth flow
-   - `/accounts/callback` - POST: Handle OAuth callback
-   - `/accounts/{id}` - DELETE: Remove account
-   - `/accounts/{id}/primary` - PUT: Set account as primary
-
-2. **LinkedInService** (`backend/services/linkedin_service.py`)
-   - Handles LinkedIn API interactions
-   - Manages OAuth token exchange
-   - Provides methods for user info retrieval and posting
-
-## Implementation Details
-
-### OAuth Flow
-
-1. **Initiation**
-   - User clicks "Add LinkedIn Account" button on the Accounts page
-   - Frontend calls `/accounts` endpoint with `social_network: 'LinkedIn'`
-   - Backend generates authorization URL and state parameter
-   - User is redirected to LinkedIn for authentication
-
-2. **Callback Handling**
-   - LinkedIn redirects back to `/linkedin/callback` with authorization code
-   - Frontend processes the callback and exchanges code for access token
-   - Backend validates the code and retrieves user information
-   - Account information is stored in the database
-
-3. **Account Management**
-   - Users can view all connected LinkedIn accounts on the Accounts page
-   - Primary account can be set for posting operations
-   - Accounts can be disconnected (deleted)
-
-### State Management
-
-The Redux store manages the following states for LinkedIn accounts:
-
-```javascript
-{
-  linkedinAccounts: {
-    items: [],           // Array of LinkedIn accounts
-    loading: false,      // Loading state
-    error: null,         // Error message
-    oauthLoading: false, // OAuth process loading
-    oauthError: null,    // OAuth error message
-    deletingAccount: null, // ID of account being deleted
-    settingPrimary: null   // ID of account being set as primary
-  }
-}
-```
-
-### Database Schema
-
-LinkedIn accounts are stored in the `Social_network` table with the following fields:
-
-- `id`: Unique identifier
-- `social_network`: 'LinkedIn'
-- `account_name`: Display name for the account
-- `id_utilisateur`: User ID (foreign key)
-- `token`: LinkedIn access token
-- `sub`: LinkedIn user ID
-- `given_name`: User's first name
-- `family_name`: User's last name
-- `picture`: Profile picture URL
-- `is_primary`: Boolean flag for primary account
-
-## Usage Instructions
-
-### Adding a LinkedIn Account
-
-1. Navigate to the **Accounts** page (`/accounts`)
-2. Click **"Add LinkedIn Account"**
-3. Follow the LinkedIn authentication flow
-4. After successful authentication, the account will appear in the list
-
-### Managing LinkedIn Accounts
-
-1. **View Accounts**: All connected accounts are displayed on the Accounts page
-2. **Set Primary**: Click "Set Primary" on the desired account
-3. **Disconnect**: Click "Disconnect" to remove an account (confirmation required)
-
-### Page Structure
-
-- **Sources Page** (`/sources`): Dedicated to RSS source management only
-- **Accounts Page** (`/accounts`): Dedicated to social media account management
-
-### Error Handling
-
-The implementation includes comprehensive error handling:
-
-- **OAuth Errors**: Invalid state, expired authorization codes
-- **Network Errors**: API timeouts, connection issues
-- **Authentication Errors**: Invalid tokens, permission denied
-- **Database Errors**: Failed storage operations
-
-### Security Considerations
-
-1. **State Parameter**: Randomly generated state parameter for CSRF protection
-2. **Token Storage**: Access tokens are stored securely in the database
-3. **User Validation**: All operations are validated against the authenticated user
-4. **HTTPS**: All API calls use HTTPS for secure communication
-
-## Configuration
-
-### Environment Variables
-
-Ensure the following environment variables are set:
-
-```bash
-# LinkedIn OAuth Configuration
-CLIENT_ID=your_linkedin_client_id
-CLIENT_SECRET=your_linkedin_client_secret
-REDIRECT_URL=your_redirect_url
-
-# Supabase Configuration
-SUPABASE_URL=your_supabase_url
-SUPABASE_KEY=your_supabase_key
-```
-
-### Backend Configuration
-
-The backend uses the following LinkedIn API endpoints:
-
-- Authorization: `https://www.linkedin.com/oauth/v2/authorization`
-- Token Exchange: `https://www.linkedin.com/oauth/v2/accessToken`
-- User Info: `https://api.linkedin.com/v2/userinfo`
-
-## Testing
-
-### Manual Testing Steps
-
-1. **Account Addition**
-   - Navigate to Accounts page
-   - Click "Add LinkedIn Account"
-   - Complete OAuth flow
-   - Verify account appears in the list
-
-2. **Account Management**
-   - Test setting primary account
-   - Test disconnecting accounts
-   - Verify error states and loading indicators
-
-3. **Page Navigation**
-   - Verify Sources page only shows RSS sources
-   - Verify Accounts page only shows social media accounts
-   - Test navigation between pages
-
-### Automated Testing
-
-The implementation includes Redux action and reducer tests that can be extended with:
-
-- OAuth flow simulation
-- API mocking
-- State validation
-- Error condition testing
-
-## Troubleshooting
-
-### Common Issues
-
-1. **OAuth State Mismatch**
-   - Ensure state parameter is properly generated and stored
-   - Check for proper state validation in callback handling
-
-2. **Token Exchange Failures**
-   - Verify client ID and client secret are correct
-   - Ensure redirect URL matches configuration
-   - Check for expired authorization codes
-
-3. **Account Not Displaying**
-   - Verify database insertion was successful
-   - Check user ID mapping
-   - Ensure API response is properly formatted
-
-4. **Page Navigation Issues**
-   - Verify routes are properly configured in App.js
-   - Check that components are imported correctly
-   - Ensure Redux state is properly connected
-
-### Debug Mode
-
-Enable debug logging by setting:
-
-```javascript
-// In development mode
-localStorage.setItem('debug', 'linkedin:*');
-
-// Backend logging
-export DEBUG=True
-```
-
-## Future Enhancements
-
-1. **Token Refresh**: Implement automatic token refresh
-2. **Account Permissions**: Request specific LinkedIn permissions
-3. **Batch Operations**: Support for managing multiple accounts simultaneously
-4. **Analytics**: Track account usage and posting statistics
-5. **Webhooks**: Implement LinkedIn webhook support for real-time updates
-6. **Additional Social Networks**: Extend to Twitter, Facebook, etc.
-
-## Support
-
-For issues or questions regarding the LinkedIn authentication implementation:
-
-1. Check the troubleshooting section above
-2. Review browser console and network tab for errors
-3. Check backend logs for API-related issues
-4. Verify environment configuration
-5. Ensure proper page navigation and routing
-
-## References
-
-- [LinkedIn OAuth 2.0 Documentation](https://learn.microsoft.com/en-us/linkedin/consumer/integrations/self-serve/sign-in-with-linkedin)
-- [React Redux Toolkit Documentation](https://redux-toolkit.js.org/)
-- [OAuth 2.0 Framework](https://datatracker.ietf.org/doc/html/rfc6749)

MIGRATION_TO_APSCHEDULER.md

@@ -1,84 +0,0 @@
-# Migrating from Celery to APScheduler
-
-This guide explains how to migrate from Celery to APScheduler in the Lin application.
-
-## Why Migrate to APScheduler?
-
-1. **Simplified Architecture**: APScheduler runs within the Flask application process, eliminating the need for separate worker processes
-2. **No External Dependencies**: Unlike Celery which requires Redis or RabbitMQ, APScheduler uses in-memory storage by default
-3. **Easier Deployment**: Simplifies deployment since there are fewer components to manage
-4. **Reduced Resource Usage**: Uses less memory and CPU compared to running separate Celery processes
-
-## Changes Made
-
-### 1. Removed Dependencies
-- Removed `celery` and `redis` from `requirements.txt`
-- Kept `apscheduler` as the scheduling library
-
-### 2. New Scheduler Service
-- Created `backend/scheduler/apscheduler_service.py` to handle all scheduling tasks
-- Implemented content generation and post publishing as APScheduler jobs
-
-### 3. Updated Flask Application
-- Modified `backend/app.py` to initialize APScheduler instead of Celery
-- Added scheduler initialization when `SCHEDULER_ENABLED` is True
-
-### 4. Updated API Endpoints
-- Modified `backend/api/schedules.py` to trigger APScheduler updates instead of Celery tasks
-- Removed all references to Celery task IDs in responses
-
-### 5. Simplified Startup Script
-- Updated `start_app.py` to remove Celery component initialization
-- The application now starts with just Flask and APScheduler
-
-### 6. Removed Files
-- Removed `backend/celery_app.py`
-- Removed `backend/celery_config.py`
-- Removed `backend/celery_tasks/` directory
-- Removed `backend/start_celery.py`
-
-## Migration Steps
-
-### 1. Update Dependencies
-```bash
-# Update requirements
-pip install -r backend/requirements.txt
-```
-
-### 2. Update Environment Variables
-No changes needed for basic setup. The scheduler is enabled by default.
-
-### 3. Remove Old Components
-The old Celery components have been removed from the codebase.
-
-### 4. Verify Functionality
-1. Start the application:
-   ```bash
-   python start_app.py
-   ```
-
-2. Create a test schedule via the API
-
-3. Check the console logs to verify that schedules are being loaded and tasks are being created
-
-## Benefits of the Migration
-
-1. **Simpler Setup**: No need to install and configure Redis
-2. **Easier Debugging**: All logs are in one place
-3. **Reduced Complexity**: Fewer moving parts to manage
-4. **Better Resource Usage**: Lower memory and CPU footprint
-5. **Simplified Deployment**: Single process deployment
-
-## Potential Considerations
-
-1. **Scalability**: For high-volume applications, Celery with multiple workers might be more appropriate
-2. **Persistence**: APScheduler uses in-memory storage by default, which means schedules are lost on application restart (this is mitigated by reloading from the database every 5 minutes)
-3. **Task Isolation**: All tasks run in the same process, so a long-running task could block others
-
-## Support
-
-If you encounter issues during migration:
-1. Check the application logs for error messages
-2. Verify that all dependencies are correctly installed
-3. Ensure the Supabase connection is working
-4. Test creating and deleting schedules via the API

api_design.md

@@ -1,348 +0,0 @@
-# API Design Document
-
-## Overview
-This document outlines the RESTful API endpoints for the Lin application backend. The API will be implemented using Flask and will follow REST conventions.
-
-## Authentication
-All endpoints (except authentication endpoints) require a valid JWT token in the Authorization header:
-```
-Authorization: Bearer <token>
-```
-
-## Error Handling
-All endpoints will return appropriate HTTP status codes:
-- 200: Success
-- 201: Created
-- 400: Bad Request
-- 401: Unauthorized
-- 404: Not Found
-- 500: Internal Server Error
-
-Error responses will follow this format:
-```json
-{
-  "error": "Error message",
-  "code": "ERROR_CODE"
-}
-```
-
-## Endpoints
-
-### Authentication
-
-#### Register User
-- **POST** `/api/auth/register`
-- **Description**: Register a new user
-- **Request Body**:
-```json
-{
-  "email": "string",
-  "password": "string",
-  "confirm_password": "string"
-}
-```
-- **Response**:
-```json
-{
-  "message": "User registered successfully",
-  "user": {
-    "id": "string",
-    "email": "string"
-  }
-}
-```
-
-#### Login User
-- **POST** `/api/auth/login`
-- **Description**: Authenticate a user
-- **Request Body**:
-```json
-{
-  "email": "string",
-  "password": "string"
-}
-```
-- **Response**:
-```json
-{
-  "token": "string",
-  "user": {
-    "id": "string",
-    "email": "string"
-  }
-}
-```
-
-#### Logout User
-- **POST** `/api/auth/logout`
-- **Description**: Logout current user
-- **Response**:
-```json
-{
-  "message": "Logged out successfully"
-}
-```
-
-#### Get Current User
-- **GET** `/api/auth/user`
-- **Description**: Get current authenticated user
-- **Response**:
-```json
-{
-  "user": {
-    "id": "string",
-    "email": "string"
-  }
-}
-```
-
-### Sources
-
-#### Get All Sources
-- **GET** `/api/sources`
-- **Description**: Get all sources for the current user
-- **Response**:
-```json
-{
-  "sources": [
-    {
-      "id": "string",
-      "user_id": "string",
-      "source": "string",
-      "category": "string",
-      "last_update": "datetime"
-    }
-  ]
-}
-```
-
-#### Add Source
-- **POST** `/api/sources`
-- **Description**: Add a new source
-- **Request Body**:
-```json
-{
-  "source": "string"
-}
-```
-- **Response**:
-```json
-{
-  "message": "Source added successfully",
-  "source": {
-    "id": "string",
-    "user_id": "string",
-    "source": "string",
-    "category": "string",
-    "last_update": "datetime"
-  }
-}
-```
-
-#### Delete Source
-- **DELETE** `/api/sources/{id}`
-- **Description**: Delete a source
-- **Response**:
-```json
-{
-  "message": "Source deleted successfully"
-}
-```
-
-### Social Accounts
-
-#### Get All Accounts
-- **GET** `/api/accounts`
-- **Description**: Get all social media accounts for the current user
-- **Response**:
-```json
-{
-  "accounts": [
-    {
-      "id": "string",
-      "user_id": "string",
-      "social_network": "string",
-      "account_name": "string",
-      "created_at": "datetime"
-    }
-  ]
-}
-```
-
-#### Add Account
-- **POST** `/api/accounts`
-- **Description**: Add a new social media account
-- **Request Body**:
-```json
-{
-  "account_name": "string",
-  "social_network": "string"
-}
-```
-- **Response**:
-```json
-{
-  "message": "Account added successfully",
-  "account": {
-    "id": "string",
-    "user_id": "string",
-    "social_network": "string",
-    "account_name": "string",
-    "created_at": "datetime"
-  }
-}
-```
-
-#### Delete Account
-- **DELETE** `/api/accounts/{id}`
-- **Description**: Delete a social media account
-- **Response**:
-```json
-{
-  "message": "Account deleted successfully"
-}
-```
-
-### Posts
-
-#### Get All Posts
-- **GET** `/api/posts`
-- **Description**: Get all posts for the current user
-- **Query Parameters**:
-  - `published` (boolean): Filter by published status
-- **Response**:
-```json
-{
-  "posts": [
-    {
-      "id": "string",
-      "user_id": "string",
-      "social_account_id": "string",
-      "text_content": "string",
-      "image_content_url": "string",
-      "is_published": "boolean",
-      "created_at": "datetime",
-      "scheduled_at": "datetime"
-    }
-  ]
-}
-```
-
-#### Generate Post
-- **POST** `/api/posts/generate`
-- **Description**: Generate a new post using AI
-- **Request Body**:
-```json
-{
-  "user_id": "string"
-}
-```
-- **Response**:
-```json
-{
-  "content": "string"
-}
-```
-
-#### Create Post
-- **POST** `/api/posts`
-- **Description**: Create a new post
-- **Request Body**:
-```json
-{
-  "social_account_id": "string",
-  "text_content": "string",
-  "image_content_url": "string",
-  "scheduled_at": "datetime"
-}
-```
-- **Response**:
-```json
-{
-  "message": "Post created successfully",
-  "post": {
-    "id": "string",
-    "user_id": "string",
-    "social_account_id": "string",
-    "text_content": "string",
-    "image_content_url": "string",
-    "is_published": "boolean",
-    "created_at": "datetime",
-    "scheduled_at": "datetime"
-  }
-}
-```
-
-#### Publish Post
-- **POST** `/api/posts/{id}/publish`
-- **Description**: Publish a post to social media
-- **Response**:
-```json
-{
-  "message": "Post published successfully"
-}
-```
-
-#### Delete Post
-- **DELETE** `/api/posts/{id}`
-- **Description**: Delete a post
-- **Response**:
-```json
-{
-  "message": "Post deleted successfully"
-}
-```
-
-### Schedules
-
-#### Get All Schedules
-- **GET** `/api/schedules`
-- **Description**: Get all schedules for the current user
-- **Response**:
-```json
-{
-  "schedules": [
-    {
-      "id": "string",
-      "social_account_id": "string",
-      "schedule_time": "string",
-      "adjusted_time": "string",
-      "created_at": "datetime"
-    }
-  ]
-}
-```
-
-#### Create Schedule
-- **POST** `/api/schedules`
-- **Description**: Create a new schedule
-- **Request Body**:
-```json
-{
-  "social_account_id": "string",
-  "schedule_time": "string",  // Format: "Monday 18:00"
-  "days": ["string"]          // Array of days
-}
-```
-- **Response**:
-```json
-{
-  "message": "Schedule created successfully",
-  "schedule": {
-    "id": "string",
-    "social_account_id": "string",
-    "schedule_time": "string",
-    "adjusted_time": "string",
-    "created_at": "datetime"
-  }
-}
-```
-
-#### Delete Schedule
-- **DELETE** `/api/schedules/{id}`
-- **Description**: Delete a schedule
-- **Response**:
-```json
-{
-  "message": "Schedule deleted successfully"
-}

architecture_summary.md

@@ -1,111 +0,0 @@
-# Lin React Clone - Architecture Summary
-
-## Project Overview
-This document provides a comprehensive summary of the architecture for the React clone of the Lin application, which includes a Flask API backend and a React frontend.
-
-## Current Status
-The current Taipy-based Lin application has been thoroughly analyzed, and a complete architecture plan has been created for the React clone with the following components:
-
-### Documentation Created
-1. [Project Analysis](project_analysis.md) - Analysis of the current Taipy application
-2. [README](README.md) - Overview of the React clone project
-3. [Backend Structure](backend_structure.md) - Planned structure for the Flask API backend
-4. [Frontend Structure](frontend_structure.md) - Planned structure for the React frontend
-5. [API Design](api_design.md) - Detailed RESTful API endpoints
-6. [Component Architecture](component_architecture.md) - React component hierarchy and design
-7. [Backend Requirements](backend_requirements.md) - Technical requirements for the Flask backend
-8. [Frontend Requirements](frontend_requirements.md) - Technical requirements for the React frontend
-9. [Deployment Architecture](deployment_architecture.md) - Infrastructure and deployment plan
-10. [Development Roadmap](development_roadmap.md) - Phased implementation plan
-
-## Key Architectural Decisions
-
-### Backend Architecture
-- **Framework**: Flask for lightweight, flexible API development
-- **Database**: Supabase (PostgreSQL-based) for data persistence
-- **Authentication**: JWT-based authentication with secure token management
-- **Scheduling**: APScheduler for task scheduling with conflict resolution
-- **External Integrations**: LinkedIn API and Hugging Face API
-- **Deployment**: Containerized deployment with horizontal scaling
-
-### Frontend Architecture
-- **Framework**: React with functional components and hooks
-- **State Management**: Redux Toolkit for predictable state management
-- **Routing**: React Router for client-side routing
-- **UI Components**: Material-UI for consistent, accessible components
-- **Form Handling**: Formik with Yup for form validation
-- **API Communication**: Axios with interceptors for HTTP requests
-- **Deployment**: Static hosting with CDN for optimal performance
-
-### Data Flow
-1. User interacts with React frontend
-2. Frontend makes API calls to Flask backend
-3. Backend processes requests and interacts with Supabase database
-4. Backend integrates with external APIs (LinkedIn, Hugging Face)
-5. Backend returns data to frontend
-6. Frontend updates UI based on response
-
-### Security Considerations
-- JWT tokens for secure authentication
-- HTTPS encryption for all communications
-- Input validation and sanitization
-- CORS policy configuration
-- Secure storage of sensitive data
-- Rate limiting for API endpoints
-
-## Implementation Roadmap
-
-The development is planned in 6 phases over 12 weeks:
-
-1. **Foundation** (Weeks 1-2): Project setup, authentication
-2. **Core Features** (Weeks 3-4): Source and account management
-3. **Content Management** (Weeks 5-6): Post creation and publishing
-4. **Scheduling System** (Weeks 7-8): Automated scheduling
-5. **Advanced Features** (Weeks 9-10): Analytics and optimization
-6. **Testing and Deployment** (Weeks 11-12): Production readiness
-
-## Technology Stack
-
-### Backend
-- Flask (Python web framework)
-- Supabase (Database and authentication)
-- APScheduler (Task scheduling)
-- requests (HTTP library)
-- python-dotenv (Environment management)
-
-### Frontend
-- React (JavaScript library)
-- Redux Toolkit (State management)
-- Material-UI (UI components)
-- React Router (Routing)
-- Axios (HTTP client)
-- Formik/Yup (Form handling)
-
-## Deployment Architecture
-
-The application will be deployed with:
-- CDN for frontend assets
-- Load balancer for backend API
-- Containerized Flask applications
-- Supabase for database and authentication
-- Monitoring and logging infrastructure
-- CI/CD pipeline for automated deployment
-
-## Next Steps
-
-To begin implementation, the following actions are recommended:
-
-1. Set up development environments for both frontend and backend
-2. Create GitHub repositories for version control
-3. Implement the foundation phase (authentication, project structure)
-4. Begin CI/CD pipeline setup
-5. Start frontend and backend development in parallel
-
-## Success Criteria
-
-The success of this architecture will be measured by:
-- Performance (API response times < 500ms)
-- Reliability (99.9% uptime)
-- Scalability (support for 10,000+ users)
-- User satisfaction (intuitive UI/UX)
-- Maintainability (modular, well-documented code)

backend/TASK_SCHEDULING_EVOLUTION.md

@@ -1,124 +0,0 @@
-# Task Scheduling Evolution: From APScheduler to Celery
-
-## Overview
-
-This document describes the evolution of the task scheduling system in the Lin application from using APScheduler to using Celery. This change was made to improve scalability, reliability, and maintainability of the scheduling system.
-
-## Previous Implementation (APScheduler)
-
-The previous implementation used APScheduler (Advanced Python Scheduler) for managing scheduled tasks. While APScheduler is a powerful library, it has some limitations in production environments:
-
-1. **Single Process**: APScheduler runs within the same process as the Flask application, which can lead to resource contention.
-2. **Limited Scalability**: Difficult to scale across multiple instances or servers.
-3. **Persistence Issues**: While APScheduler supports job persistence, it's not as robust as dedicated task queues.
-4. **Monitoring**: Limited built-in monitoring and management capabilities.
-
-### Key Components of APScheduler Implementation:
-
-- `backend/scheduler/task_scheduler.py`: Main scheduler implementation
-- `backend/app.py`: Scheduler initialization in Flask app
-- Jobs were stored in memory and periodically reloaded from the database
-
-## New Implementation (Celery)
-
-The new implementation uses Celery, a distributed task queue, which provides several advantages:
-
-1. **Distributed Processing**: Tasks can be distributed across multiple workers and machines.
-2. **Persistence**: Tasks are stored in a message broker (Redis) for reliability.
-3. **Scalability**: Easy to scale by adding more workers.
-4. **Monitoring**: Built-in monitoring tools and integration with Flower for web-based monitoring.
-5. **Fault Tolerance**: Workers can be restarted without losing tasks.
-6. **Flexible Routing**: Tasks can be routed to specific queues for better resource management.
-
-### Key Components of Celery Implementation:
-
-- `backend/celery_app.py`: Main Celery application configuration
-- `backend/celery_tasks/`: Directory containing Celery tasks
-  - `content_tasks.py`: Tasks for content generation and publishing
-  - `scheduler.py`: Scheduler functions for task management
-  - `schedule_loader.py`: Task for loading schedules from database
-- `backend/celery_beat_config.py`: Celery Beat configuration for periodic tasks
-- `backend/scheduler/task_scheduler.py`: Updated scheduler that works with Celery
-
-### Celery Architecture
-
-The new implementation follows this architecture:
-
-```
-[Flask App] --> [Redis Broker] --> [Celery Workers]
-                     ^
-                     |
-               [Celery Beat]
-```
-
-1. **Flask App**: The main web application that can trigger tasks
-2. **Redis Broker**: Message broker that stores tasks and results
-3. **Celery Workers**: Processes that execute tasks
-4. **Celery Beat**: Scheduler that triggers periodic tasks
-
-### Task Types
-
-1. **Content Generation Task**: Generates content for scheduled posts
-2. **Post Publishing Task**: Publishes posts to LinkedIn
-3. **Schedule Loader Task**: Periodically loads schedules from the database and updates Celery Beat
-
-### Configuration
-
-The Celery implementation is configured through environment variables:
-
-- `CELERY_BROKER_URL`: URL for the message broker (default: redis://localhost:6379/0)
-- `CELERY_RESULT_BACKEND`: URL for the result backend (default: redis://localhost:6379/0)
-
-### Running the System
-
-To run the new Celery-based system:
-
-1. **Start Redis Server**:
-   ```bash
-   redis-server
-   ```
-
-2. **Start Celery Workers**:
-   ```bash
-   cd backend
-   celery -A celery_app worker --loglevel=info
-   ```
-
-3. **Start Celery Beat (Scheduler)**:
-   ```bash
-   cd backend
-   celery -A celery_beat_config beat --loglevel=info
-   ```
-
-4. **Start Flask Application**:
-   ```bash
-   cd backend
-   python app.py
-   ```
-
-### Benefits of the Migration
-
-1. **Improved Reliability**: Tasks are persisted in Redis and survive worker restarts
-2. **Better Scalability**: Can easily add more workers to handle increased load
-3. **Enhanced Monitoring**: Can use Flower to monitor tasks and workers
-4. **Separation of Concerns**: Web application and task processing are now separate processes
-5. **Fault Tolerance**: If one worker fails, others can continue processing tasks
-6. **Flexible Deployment**: Workers can be deployed on different machines
-
-### Migration Process
-
-The migration was done in a way that maintains backward compatibility:
-
-1. **New Components Added**: All Celery components were added without removing the old ones
-2. **Configuration Update**: The Flask app was updated to use Celery instead of APScheduler
-3. **Task Refactoring**: Existing task logic was refactored into Celery tasks
-4. **Testing**: The new system was tested to ensure it works correctly
-5. **Documentation**: This document was created to explain the changes
-
-### Future Improvements
-
-1. **Add Flower for Monitoring**: Integrate Flower for web-based task monitoring
-2. **Implement Retry Logic**: Add more sophisticated retry logic for failed tasks
-3. **Add Task Priorities**: Implement task priorities for better resource management
-4. **Enhance Error Handling**: Improve error handling and logging for tasks
-5. **Add Task Chaining**: Use Celery's chaining capabilities for complex workflows

backend/api/posts.py

@@ -1,6 +1,8 @@
+import os
 import codecs
 import uuid
-from flask import Blueprint, request, jsonify, current_app
+import base64
+from flask import Blueprint, request, jsonify, current_app, send_file
 from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.content_service import ContentService
 from backend.services.linkedin_service import LinkedInService
@@ -98,27 +100,6 @@ def get_posts():
         response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
         response_data.headers.add('Access-Control-Allow-Credentials', 'true')
         return response_data, 500
-        
-        # Add CORS headers explicitly
-        response_data = jsonify({
-            'success': True,
-            'posts': user_posts
-        })
-        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
-        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
-        return response_data, 200
-        
-    except Exception as e:
-        error_message = str(e)
-        safe_log_message(f"Get posts error: {error_message}")
-        # Add CORS headers to error response
-        response_data = jsonify({
-            'success': False,
-            'message': 'An error occurred while fetching posts'
-        })
-        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
-        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
-        return response_data, 500
 
 def _generate_post_task(user_id, job_id, job_store, hugging_key):
     """
@@ -270,10 +251,35 @@ def get_job_status(job_id):
                     # 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
+                elif isinstance(image_data, dict):
+                    # Handle the case where image_data is a dict from Gradio API
+                    # The dict may contain 'path', 'url', or other keys
+                    if image_data.get('url'):
+                        response_data['image_url'] = image_data['url']
+                        response_data['has_image_data'] = True
+                    elif image_data.get('path'):
+                        # If we have a path, we might need to serve it or convert it to a URL
+                        # For now, we'll just indicate that image data exists
+                        response_data['image_url'] = None
+                        response_data['has_image_data'] = True
+                    else:
+                        response_data['image_url'] = None
+                        response_data['has_image_data'] = image_data is not None
+                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
+                        response_data['image_url'] = f"/api/posts/image/{job_id}"  # API endpoint to serve the image
+                        response_data['has_image_data'] = True
+                    else:
+                        # If it's a URL, use it directly
+                        response_data['image_url'] = image_data
+                        response_data['has_image_data'] = True
                 else:
-                    # If it's a string, assume it's a URL
-                    response_data['image_url'] = image_data
-                    response_data['has_image_data'] = False
+                    # If it's None or other type
+                    response_data['image_url'] = None
+                    response_data['has_image_data'] = image_data is not None
             else:
                 response_data['content'] = job['result']
                 response_data['image_url'] = None
@@ -291,11 +297,46 @@ def get_job_status(job_id):
             'message': f'An error occurred while fetching job status: {error_message}'
         }), 500
 
-@posts_bp.route('/', methods=['OPTIONS'])
-@posts_bp.route('', methods=['OPTIONS'])
-def handle_create_options():
-    """Handle OPTIONS requests for preflight CORS checks for create post route."""
-    return '', 200
+@posts_bp.route('/image/<job_id>', methods=['GET'])
+@jwt_required()
+def get_job_image(job_id):
+    """
+    Serve image file for a completed job.
+    
+    Path Parameters:
+        job_id (str): Job ID
+        
+    Returns:
+        Image file
+    """
+    try:
+        # Get job from store
+        job = current_app.job_store.get(job_id)
+        
+        if not job:
+            return jsonify({
+                'success': False,
+                'message': 'Job not found'
+            }), 404
+            
+        # Check if job has an image file path
+        image_file_path = job.get('image_file_path')
+        if not image_file_path or not os.path.exists(image_file_path):
+            return jsonify({
+                'success': False,
+                'message': 'Image not found'
+            }), 404
+            
+        # Serve the image file
+        return send_file(image_file_path)
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Get job image error: {error_message}")
+        return jsonify({
+            'success': False,
+            'message': f'An error occurred while fetching image: {error_message}'
+        }), 500
 
 @posts_bp.route('/publish-direct', methods=['OPTIONS'])
 def handle_publish_direct_options():

backend/app.py

@@ -2,6 +2,9 @@ import os
 import sys
 import locale
 import logging
+# Add the project root to the Python path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
 from flask import Flask, send_from_directory, request
 from flask_cors import CORS
 from flask_jwt_extended import JWTManager
@@ -101,11 +104,16 @@ def create_app():
             "https://zelyanoth-lin-cbfcff2.hf.space"
         ]
         
+        # Only add CORS headers if they haven't been set by Flask-CORS already
         if origin in allowed_origins:
-            response.headers.add('Access-Control-Allow-Origin', origin)
-            response.headers.add('Access-Control-Allow-Credentials', 'true')
-            response.headers.add('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS')
-            response.headers.add('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With')
+            if 'Access-Control-Allow-Origin' not in response.headers:
+                response.headers['Access-Control-Allow-Origin'] = origin
+            if 'Access-Control-Allow-Credentials' not in response.headers:
+                response.headers['Access-Control-Allow-Credentials'] = 'true'
+            if 'Access-Control-Allow-Methods' not in response.headers:
+                response.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS'
+            if 'Access-Control-Allow-Headers' not in response.headers:
+                response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization, X-Requested-With'
         
         return response
     

backend/services/__init__.py

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

backend/services/content_service.py

@@ -124,29 +124,35 @@ class ContentService:
                 api_name="/poster_linkedin"
             )
             
-            # Parse the result (assuming it returns a list with content as first element)
-            # First try to parse as JSON
-            try:
-                parsed_result = json.loads(result)
-            except json.JSONDecodeError:
-                # If JSON parsing fails, check if it's already a Python list/object
-                try:
-                    # Try to evaluate as Python literal (safe for lists/dicts)
-                    import ast
-                    parsed_result = ast.literal_eval(result)
-                except (ValueError, SyntaxError):
-                    # If that fails, treat the result as a plain string
-                    parsed_result = [result]
-            
-            # 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
+            # Handle the case where result might be a tuple from Gradio
+            # The Gradio API returns a tuple with (content, image_data)
+            if isinstance(result, tuple) and len(result) >= 2:
+                generated_content = result[0] if result[0] is not None else "Generated content will appear here..."
+                image_data = result[1] if 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
+                # Parse the result (assuming it returns a list with content as first element)
+                # First try to parse as JSON
+                try:
+                    parsed_result = json.loads(result)
+                except json.JSONDecodeError:
+                    # If JSON parsing fails, check if it's already a Python list/object
+                    try:
+                        # Try to evaluate as Python literal (safe for lists/dicts)
+                        import ast
+                        parsed_result = ast.literal_eval(result)
+                    except (ValueError, SyntaxError):
+                        # If that fails, treat the result as a plain string
+                        parsed_result = [result]
                 
+                # 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)
             

backend_requirements.md

@@ -1,163 +0,0 @@
-# Backend Requirements
-
-## Overview
-This document outlines the technical requirements for the Flask API backend of the Lin application.
-
-## Python Dependencies
-The backend will require the following Python packages:
-
-### Core Dependencies
-- Flask: Web framework
-- Flask-CORS: Cross-Origin Resource Sharing support
-- Flask-JWT-Extended: JWT token management
-- Flask-SQLAlchemy: ORM for database interactions
-- Flask-Migrate: Database migration support
-- python-dotenv: Environment variable management
-- requests: HTTP library for API calls
-- requests-oauthlib: OAuth support
-- apscheduler: Task scheduling
-- supabase: Supabase client for database operations
-- pandas: Data manipulation
-- gradio-client: Hugging Face API client
-
-### Development Dependencies
-- pytest: Testing framework
-- pytest-cov: Test coverage reporting
-- flake8: Code linting
-- black: Code formatting
-
-## Environment Variables
-The backend will require the following environment variables:
-
-- SUPABASE_URL: Supabase project URL
-- SUPABASE_KEY: Supabase API key
-- CLIENT_ID: LinkedIn OAuth client ID
-- CLIENT_SECRET: LinkedIn OAuth client secret
-- REDIRECT_URL: LinkedIn OAuth redirect URL
-- HUGGING_KEY: Hugging Face API key
-- JWT_SECRET_KEY: Secret key for JWT token generation
-- DATABASE_URL: Database connection string (if using PostgreSQL directly)
-
-## Database Requirements
-The application will use Supabase as the primary database, which is based on PostgreSQL. The following tables will be needed:
-
-### Users
-- id (UUID)
-- email (string)
-- password_hash (string)
-- created_at (timestamp)
-- email_confirmed_at (timestamp)
-
-### Social_network
-- id (UUID)
-- user_id (UUID, foreign key to Users)
-- social_network (string)
-- account_name (string)
-- token (string)
-- sub (string)
-- given_name (string)
-- family_name (string)
-- picture (string)
-- created_at (timestamp)
-
-### Source
-- id (UUID)
-- user_id (UUID, foreign key to Users)
-- source (string)
-- category (string)
-- last_update (timestamp)
-- created_at (timestamp)
-
-### Post_content
-- id (UUID)
-- social_account_id (UUID, foreign key to Social_network)
-- text_content (text)
-- image_content_url (bytea or URL)
-- is_published (boolean)
-- sched (UUID)
-- created_at (timestamp)
-- scheduled_at (timestamp)
-
-### Scheduling
-- id (UUID)
-- social_account_id (UUID, foreign key to Social_network)
-- schedule_time (string)
-- adjusted_time (string)
-- created_at (timestamp)
-
-## API Requirements
-
-### Authentication
-- JWT-based authentication
-- Password hashing with bcrypt
-- Email confirmation flow
-- Password reset functionality
-
-### Security
-- CORS policy configuration
-- Input validation and sanitization
-- Rate limiting for API endpoints
-- Secure headers implementation
-
-### Error Handling
-- Consistent error response format
-- Proper HTTP status codes
-- Logging of errors for debugging
-- Validation error handling
-
-## Integration Requirements
-
-### LinkedIn API
-- OAuth2 authentication flow
-- Post creation and publishing
-- User profile information retrieval
-- Image upload support
-
-### Hugging Face API
-- Content generation using Gradio client
-- Error handling for API failures
-- Timeout handling for long-running requests
-
-### Scheduling System
-- APScheduler for task management
-- Conflict resolution for overlapping schedules
-- Automatic adjustment of schedule times
-- Persistent storage of scheduled tasks
-
-## Deployment Requirements
-
-### Server
-- Python 3.8+
-- WSGI server (Gunicorn recommended)
-- Reverse proxy (Nginx recommended)
-- SSL certificate for HTTPS
-
-### Scalability
-- Stateless design for horizontal scaling
-- Database connection pooling
-- Caching strategy for frequently accessed data
-- Background task processing for long-running operations
-
-### Monitoring
-- Logging configuration
-- Health check endpoints
-- Performance monitoring
-- Error tracking integration
-
-## Testing Requirements
-
-### Unit Tests
-- Model validation tests
-- Service layer tests
-- Utility function tests
-
-### Integration Tests
-- API endpoint tests
-- Database integration tests
-- External API integration tests
-
-### Test Coverage
-- Minimum 80% code coverage
-- Testing of edge cases
-- Mocking of external dependencies
-- Continuous integration setup

backend_structure.md

@@ -1,78 +0,0 @@
-# Backend Structure Plan
-
-## Directory Structure
-```
-backend/
-├── app.py                 # Flask application entry point
-├── config.py              # Configuration settings
-├── requirements.txt       # Python dependencies
-├── .env                   # Environment variables
-├── models/                # Database models
-│   ├── __init__.py
-│   ├── user.py            # User model
-│   ├── social_account.py  # Social media account model
-│   ├── source.py          # RSS source model
-│   ├── post.py            # Post content model
-│   └── schedule.py        # Scheduling model
-├── api/                   # API endpoints
-│   ├── __init__.py
-│   ├── auth.py            # Authentication endpoints
-│   ├── sources.py         # Source management endpoints
-│   ├── accounts.py        # Social account endpoints
-│   ├── posts.py           # Post management endpoints
-│   └── schedules.py       # Scheduling endpoints
-├── services/              # Business logic
-│   ├── __init__.py
-│   ├── auth_service.py    # Authentication service
-│   ├── linkedin_service.py# LinkedIn integration service
-│   ├── content_service.py # Content generation service
-│   └── schedule_service.py# Scheduling service
-├── utils/                 # Utility functions
-│   ├── __init__.py
-│   ├── database.py        # Database connection
-│   └── helpers.py         # Helper functions
-└── scheduler/             # Task scheduling
-    ├── __init__.py
-    └── task_scheduler.py  # Scheduling implementation
-```
-
-## Key Components
-
-### app.py
-- Flask application initialization
-- Configuration loading
-- Blueprint registration
-- CORS setup
-- Error handlers
-
-### config.py
-- Environment-based configuration
-- Database settings
-- API keys and secrets
-- Scheduler settings
-
-### models/
-- SQLAlchemy models for all database entities
-- Relationship definitions
-- Validation logic
-
-### api/
-- RESTful endpoints for all features
-- Request validation
-- Response formatting
-- Authentication middleware
-
-### services/
-- Business logic implementation
-- External API integrations
-- Data processing and transformation
-
-### utils/
-- Database connection management
-- Helper functions for common operations
-- Error handling utilities
-
-### scheduler/
-- APScheduler implementation
-- Task scheduling and execution
-- Conflict resolution

component_architecture.md

@@ -1,237 +0,0 @@
-# React Component Architecture
-
-## Overview
-This document outlines the component architecture for the React frontend of the Lin application. The components are organized hierarchically to promote reusability and maintainability.
-
-## Component Hierarchy
-
-### App Component
-```
-App
-├── Header
-├── Sidebar
-├── Routes
-│   ├── Login
-│   │   ├── LoginForm
-│   │   └── RegisterForm
-│   ├── Register
-│   │   ├── RegisterForm
-│   │   └── LoginForm
-│   ├── Dashboard
-│   │   ├── SourceManager
-│   │   │   ├── SourceList
-│   │   │   └── AddSourceForm
-│   │   ├── PostManager
-│   │   │   ├── PostList
-│   │   │   ├── PostGenerator
-│   │   │   └── PostForm
-│   │   └── Scheduler
-│   │       ├── ScheduleList
-│   │       └── ScheduleForm
-│   ├── Sources
-│   │   ├── SourceList
-│   │   └── AddSourceForm
-│   ├── Posts
-│   │   ├── PostList
-│   │   ├── PostGenerator
-│   │   └── PostForm
-│   └── Schedule
-│       ├── ScheduleList
-│       └── ScheduleForm
-└── Footer
-```
-
-## Component Details
-
-### App
-- Root component that manages global state
-- Handles routing between pages
-- Manages authentication state
-
-### Header
-- Navigation bar at the top of the application
-- Contains application title and user menu
-- Shows current user information
-- Provides logout functionality
-
-### Sidebar
-- Navigation menu on the left side
-- Links to main sections (Dashboard, Sources, Posts, Schedule)
-- Responsive design for mobile devices
-
-### Login
-- Page for user authentication
-- Contains LoginForm component
-- Provides link to registration page
-
-### LoginForm
-- Form for user login
-- Email and password fields
-- Submit button
-- Validation and error handling
-
-### Register
-- Page for user registration
-- Contains RegisterForm component
-- Provides link to login page
-
-### RegisterForm
-- Form for user registration
-- Email, password, and confirm password fields
-- Submit button
-- Validation and error handling
-
-### Dashboard
-- Main dashboard page
-- Overview of all features
-- Quick access to main functions
-- Summary statistics
-
-### SourceManager
-- Component for managing RSS sources
-- Lists existing sources
-- Provides form to add new sources
-- Allows deletion of sources
-
-### SourceList
-- Displays list of sources in a table
-- Shows source URL and category
-- Provides delete functionality for each source
-- Responsive design for different screen sizes
-
-### AddSourceForm
-- Form for adding new sources
-- Source URL input field
-- Submit button
-- Validation and error handling
-
-### PostManager
-- Component for managing posts
-- Lists existing posts
-- Provides post generation functionality
-- Allows creation and publishing of posts
-
-### PostList
-- Displays list of posts in a table
-- Shows post content and status
-- Provides publish and delete functionality for each post
-- Filter by published status
-
-### PostGenerator
-- Component for AI-powered post generation
-- Button to trigger generation
-- Display area for generated content
-- Ability to edit generated content
-
-### PostForm
-- Form for creating new posts
-- Text content input (textarea)
-- Image upload functionality
-- Schedule posting option
-- Submit button
-
-### Scheduler
-- Component for managing post schedules
-- Lists existing schedules
-- Provides form to create new schedules
-
-### ScheduleList
-- Displays list of schedules in a table
-- Shows schedule time and associated account
-- Provides delete functionality for each schedule
-
-### ScheduleForm
-- Form for creating new schedules
-- Day selection (multiple days)
-- Time selection (hour and minute)
-- Account selection
-- Submit button
-
-### Footer
-- Footer component at the bottom of the application
-- Contains copyright information
-- Links to documentation or support
-
-## State Management
-
-### Global State (Redux Store)
-- User authentication state
-- Current user information
-- Social media accounts
-- Sources
-- Posts
-- Schedules
-
-### Component State
-- Form input values
-- Loading states
-- Error messages
-- UI-specific state (e.g., open/closed modals)
-
-## Data Flow
-
-1. **Authentication Flow**
-   - User submits login form
-   - LoginForm calls authService.login()
-   - authService makes API call to /api/auth/login
-   - API returns JWT token
-   - Token is stored in localStorage
-   - User state is updated in Redux store
-   - User is redirected to dashboard
-
-2. **Source Management Flow**
-   - User submits AddSourceForm
-   - AddSourceForm calls sourceService.addSource()
-   - sourceService makes API call to /api/sources
-   - API returns new source data
-   - Source is added to Redux store
-   - SourceList is automatically updated
-
-3. **Post Management Flow**
-   - User clicks "Generate Post" button
-   - PostGenerator calls postService.generatePost()
-   - postService makes API call to /api/posts/generate
-   - API returns generated content
-   - Content is displayed in PostGenerator
-   - User can edit content and submit PostForm
-   - PostForm calls postService.createPost()
-   - postService makes API call to /api/posts
-   - API returns new post data
-   - Post is added to Redux store
-   - PostList is automatically updated
-
-4. **Scheduling Flow**
-   - User submits ScheduleForm
-   - ScheduleForm calls scheduleService.createSchedule()
-   - scheduleService makes API call to /api/schedules
-   - API returns new schedule data
-   - Schedule is added to Redux store
-   - ScheduleList is automatically updated
-
-## Styling
-
-### CSS Strategy
-- CSS Modules for component-specific styles
-- Global CSS variables for consistent theming
-- Responsive design with media queries
-- Mobile-first approach
-
-### Theme
-- Primary color: #910029 (Burgundy)
-- Secondary color: #39404B (Dark Gray)
-- Background color: #ECF4F7 (Light Blue)
-- Text color: #2c3e50 (Dark Blue-Gray)
-- Accent color: #800020 (Dark Burgundy)
-
-## Responsive Design
-
-### Breakpoints
-- Mobile: 0px - 768px
-- Tablet: 769px - 1024px
-- Desktop: 1025px+
-
-### Adaptations
-- Sidebar becomes collapsible on mobile
-- Tables become card-based layouts on mobile
-- Forms stack vertically on mobile
-- Font sizes adjust for different screen sizes

deployment_architecture.md

@@ -1,235 +0,0 @@
-# Deployment Architecture
-
-## Overview
-This document outlines the deployment architecture for the Lin application, including both the React frontend and Flask API backend.
-
-## Architecture Diagram
-
-```mermaid
-graph TD
-    A[Client Browser] --> B[CDN - Frontend Assets]
-    A --> C[Load Balancer]
-    C --> D[API Gateway]
-    D --> E[Flask API Server 1]
-    D --> F[Flask API Server 2]
-    D --> G[Flask API Server N]
-    E --> H[Supabase Database]
-    F --> H
-    G --> H
-    H --> I[Supabase Auth]
-    H --> J[Supabase Storage]
-    E --> K[External APIs]
-    F --> K
-    G --> K
-    K --> L[LinkedIn API]
-    K --> M[Hugging Face API]
-```
-
-## Components
-
-### Client Layer
-- Web browsers (desktop and mobile)
-- Mobile applications (future consideration)
-- API consumers (third-party integrations)
-
-### Frontend Layer
-- React application hosted on CDN
-- Static assets (HTML, CSS, JavaScript, images)
-- Client-side routing
-- Browser-based caching
-
-### API Layer
-- Load balancer for traffic distribution
-- API gateway for request routing
-- Multiple Flask API server instances
-- Horizontal scaling capabilities
-
-### Backend Services Layer
-- Supabase as the primary database
-- Supabase Auth for user authentication
-- Supabase Storage for file storage
-- External API integrations
-
-### External Services
-- LinkedIn API for social media integration
-- Hugging Face API for content generation
-- Email service for user notifications
-
-## Deployment Environments
-
-### Development
-- Local development environments
-- Development database with sample data
-- Debugging tools enabled
-- Hot reloading for frontend development
-
-### Staging
-- Pre-production environment
-- Mirror of production configuration
-- Testing of new features
-- Performance testing
-
-### Production
-- Live environment for users
-- High availability configuration
-- Monitoring and alerting
-- Backup and disaster recovery
-
-## Infrastructure Requirements
-
-### Frontend Hosting
-- CDN for static asset delivery
-- HTTPS support
-- Custom domain configuration
-- Cache invalidation strategy
-
-### Backend Hosting
-- Cloud hosting platform (AWS, Google Cloud, Azure)
-- Container orchestration (Docker Swarm, Kubernetes)
-- Auto-scaling groups
-- Health monitoring
-
-### Database
-- Supabase project with production plan
-- Database backups
-- Point-in-time recovery
-- Read replicas for scaling
-
-### Networking
-- SSL certificates for HTTPS
-- DNS configuration
-- Firewall rules
-- DDoS protection
-
-## Scalability
-
-### Horizontal Scaling
-- Multiple API server instances
-- Load balancing across instances
-- Stateless application design
-- Shared database for consistency
-
-### Vertical Scaling
-- Increasing server resources (CPU, memory)
-- Database scaling options
-- CDN bandwidth scaling
-
-### Auto-scaling
-- CPU-based scaling policies
-- Request-based scaling policies
-- Minimum and maximum instance limits
-- Scaling cooldown periods
-
-## Security
-
-### Network Security
-- Firewall configuration
-- Private networks for backend services
-- SSL/TLS encryption
-- DDoS protection
-
-### Application Security
-- Authentication and authorization
-- Input validation and sanitization
-- Secure headers
-- CORS policy configuration
-
-### Data Security
-- Encryption at rest
-- Encryption in transit
-- Database access controls
-- Regular security audits
-
-## Monitoring and Logging
-
-### Application Monitoring
-- Uptime monitoring
-- Performance metrics
-- Error tracking
-- Custom dashboards
-
-### Infrastructure Monitoring
-- Server health metrics
-- Network performance
-- Database performance
-- Resource utilization
-
-### Logging
-- Centralized log management
-- Log retention policies
-- Log analysis tools
-- Alerting based on log patterns
-
-## Backup and Disaster Recovery
-
-### Data Backup
-- Automated database backups
-- Backup retention policies
-- Point-in-time recovery
-- Cross-region replication
-
-### Disaster Recovery
-- Recovery time objectives (RTO)
-- Recovery point objectives (RPO)
-- Failover procedures
-- Business continuity planning
-
-## CI/CD Pipeline
-
-### Continuous Integration
-- Automated testing on pull requests
-- Code quality checks
-- Security scanning
-- Build artifact generation
-
-### Continuous Deployment
-- Automated deployment to staging
-- Manual approval for production
-- Rollback capabilities
-- Blue-green deployment strategy
-
-### Environment Promotion
-- Development to staging
-- Staging to production
-- Feature flag management
-- A/B testing capabilities
-
-## Cost Considerations
-
-### Infrastructure Costs
-- Cloud hosting fees
-- CDN costs
-- Database hosting
-- External API usage
-
-### Operational Costs
-- Monitoring and logging tools
-- Backup storage
-- Support and maintenance
-- Team productivity tools
-
-### Optimization Strategies
-- Resource right-sizing
-- Caching strategies
-- Content delivery optimization
-- Usage-based scaling
-
-## Maintenance
-
-### Regular Maintenance
-- Security updates
-- Dependency updates
-- Performance tuning
-- Database maintenance
-
-### Scheduled Downtime
-- Maintenance windows
-- Communication plan
-- Rollback procedures
-- Post-maintenance validation
-
-### Incident Response
-- Incident classification
-- Escalation procedures
-- Communication protocols
-- Post-incident analysis

development_roadmap.md

@@ -1,312 +0,0 @@
-# Development Roadmap
-
-## Overview
-This document outlines the development roadmap for creating the React clone of the Lin application with a Flask API backend.
-
-## Phase 1: Foundation (Weeks 1-2)
-
-### Goals
-- Set up development environments
-- Create project structure
-- Implement basic authentication
-- Establish API communication
-
-### Tasks
-
-#### Backend
-- [ ] Set up Flask project structure
-- [ ] Configure environment variables
-- [ ] Implement database connection with Supabase
-- [ ] Create user model and authentication endpoints
-- [ ] Implement JWT token generation and validation
-- [ ] Set up API documentation (Swagger/OpenAPI)
-
-#### Frontend
-- [ ] Set up React project with Create React App or Vite
-- [ ] Configure routing with React Router
-- [ ] Set up Redux store and basic state management
-- [ ] Create authentication context
-- [ ] Implement login and registration forms
-- [ ] Set up API service layer
-
-#### Integration
-- [ ] Connect frontend to backend authentication API
-- [ ] Implement token storage and management
-- [ ] Create basic UI components
-- [ ] Set up development environment documentation
-
-### Deliverables
-- Functional authentication system
-- Basic project structure for both frontend and backend
-- API documentation
-- Development environment setup guide
-
-## Phase 2: Core Features (Weeks 3-4)
-
-### Goals
-- Implement source management
-- Implement social account management
-- Create basic UI for core features
-
-### Tasks
-
-#### Backend
-- [ ] Create source model and CRUD endpoints
-- [ ] Create social account model and CRUD endpoints
-- [ ] Implement RSS feed integration service
-- [ ] Add validation and error handling
-- [ ] Implement pagination for lists
-
-#### Frontend
-- [ ] Create dashboard layout
-- [ ] Implement source management UI
-- [ ] Implement social account management UI
-- [ ] Add form validation and error handling
-- [ ] Create reusable components for forms and lists
-
-#### Integration
-- [ ] Connect source management UI to backend API
-- [ ] Connect social account management UI to backend API
-- [ ] Implement loading states and user feedback
-- [ ] Add responsive design for mobile devices
-
-### Deliverables
-- Source management functionality
-- Social account management functionality
-- Basic dashboard UI
-- Responsive design implementation
-
-## Phase 3: Content Management (Weeks 5-6)
-
-### Goals
-- Implement post creation and management
-- Integrate AI content generation
-- Implement post publishing to LinkedIn
-
-### Tasks
-
-#### Backend
-- [ ] Create post model and CRUD endpoints
-- [ ] Implement Hugging Face API integration
-- [ ] Create content generation service
-- [ ] Implement LinkedIn API integration
-- [ ] Add image handling for posts
-
-#### Frontend
-- [ ] Create post management UI
-- [ ] Implement post creation form
-- [ ] Add AI content generation interface
-- [ ] Create post preview functionality
-- [ ] Implement image upload component
-
-#### Integration
-- [ ] Connect post management UI to backend API
-- [ ] Integrate AI content generation
-- [ ] Implement post publishing workflow
-- [ ] Add real-time updates for post status
-
-### Deliverables
-- Post creation and management functionality
-- AI content generation integration
-- LinkedIn publishing capability
-- Complete post workflow UI
-
-## Phase 4: Scheduling System (Weeks 7-8)
-
-### Goals
-- Implement scheduling functionality
-- Create scheduling UI
-- Integrate task scheduler with post generation and publishing
-
-### Tasks
-
-#### Backend
-- [ ] Create schedule model and CRUD endpoints
-- [ ] Implement APScheduler integration
-- [ ] Create scheduling service
-- [ ] Implement conflict resolution logic
-- [ ] Add recurring schedule support
-
-#### Frontend
-- [ ] Create scheduling UI
-- [ ] Implement schedule creation form
-- [ ] Add schedule visualization (calendar view)
-- [ ] Create schedule management interface
-- [ ] Add notifications for scheduled events
-
-#### Integration
-- [ ] Connect scheduling UI to backend API
-- [ ] Implement automatic post generation based on schedule
-- [ ] Implement automatic post publishing based on schedule
-- [ ] Add schedule conflict detection and resolution
-
-### Deliverables
-- Scheduling functionality
-- Calendar-based schedule visualization
-- Automated post generation and publishing
-- Schedule conflict management
-
-## Phase 5: Advanced Features (Weeks 9-10)
-
-### Goals
-- Implement analytics and reporting
-- Add advanced UI features
-- Optimize performance
-- Implement comprehensive testing
-
-### Tasks
-
-#### Backend
-- [ ] Implement analytics data collection
-- [ ] Create reporting endpoints
-- [ ] Add caching for improved performance
-- [ ] Implement advanced search and filtering
-- [ ] Add data export functionality
-
-#### Frontend
-- [ ] Create analytics dashboard
-- [ ] Implement data visualization components
-- [ ] Add advanced filtering and search
-- [ ] Implement data export features
-- [ ] Add keyboard shortcuts and accessibility features
-
-#### Integration
-- [ ] Connect analytics dashboard to backend API
-- [ ] Implement real-time data updates
-- [ ] Add performance optimizations
-- [ ] Implement comprehensive error handling
-
-### Deliverables
-- Analytics and reporting functionality
-- Advanced UI features
-- Performance optimizations
-- Comprehensive testing suite
-
-## Phase 6: Testing and Deployment (Weeks 11-12)
-
-### Goals
-- Complete comprehensive testing
-- Prepare for production deployment
-- Create deployment documentation
-- Implement monitoring and logging
-
-### Tasks
-
-#### Backend
-- [ ] Implement unit tests for all services
-- [ ] Create integration tests for API endpoints
-- [ ] Add load testing
-- [ ] Implement logging and monitoring
-- [ ] Create deployment scripts
-
-#### Frontend
-- [ ] Implement unit tests for components
-- [ ] Create end-to-end tests
-- [ ] Add performance testing
-- [ ] Implement error tracking
-- [ ] Create build and deployment scripts
-
-#### Integration
-- [ ] Conduct user acceptance testing
-- [ ] Perform security testing
-- [ ] Implement CI/CD pipeline
-- [ ] Create production deployment guide
-- [ ] Set up monitoring and alerting
-
-### Deliverables
-- Comprehensive test suite
-- Production-ready deployment
-- Monitoring and logging implementation
-- Deployment documentation
-
-## Risk Management
-
-### Technical Risks
-- LinkedIn API rate limiting
-- Hugging Face API availability
-- Database performance with large datasets
-- Scheduling conflicts and edge cases
-
-### Mitigation Strategies
-- Implement caching and retry mechanisms
-- Add fallback content generation methods
-- Optimize database queries and indexing
-- Thoroughly test scheduling edge cases
-
-### Timeline Risks
-- External API integration delays
-- Complexity of scheduling system
-- Performance optimization challenges
-
-### Mitigation Strategies
-- Build buffer time into schedule
-- Implement incremental development approach
-- Conduct regular performance testing
-
-## Success Metrics
-
-### Technical Metrics
-- API response times under 500ms
-- 99.9% uptime
-- Less than 1% error rate
-- Page load times under 2 seconds
-
-### User Experience Metrics
-- User satisfaction scores
-- Task completion rates
-- Feature adoption rates
-- Support ticket volume
-
-### Business Metrics
-- User retention rate
-- Daily/monthly active users
-- Content generation volume
-- Scheduled post success rate
-
-## Resource Requirements
-
-### Team Composition
-- 1 Full-stack developer (primary)
-- 1 Frontend developer (support)
-- 1 Backend developer (support)
-- 1 QA engineer
-- 1 DevOps engineer
-
-### Tools and Services
-- Development environments (IDEs, databases)
-- Testing tools (unit testing, end-to-end testing)
-- CI/CD platform
-- Monitoring and logging tools
-- Project management software
-
-## Milestones
-
-### Milestone 1: Foundation Complete (End of Week 2)
-- Authentication system functional
-- Basic project structure established
-- Development environments set up
-
-### Milestone 2: Core Features Complete (End of Week 4)
-- Source management implemented
-- Social account management implemented
-- Basic UI complete
-
-### Milestone 3: Content Management Complete (End of Week 6)
-- Post creation and management functional
-- AI content generation integrated
-- LinkedIn publishing working
-
-### Milestone 4: Scheduling System Complete (End of Week 8)
-- Scheduling functionality implemented
-- Automated post generation and publishing
-- Schedule conflict management
-
-### Milestone 5: Advanced Features Complete (End of Week 10)
-- Analytics and reporting functional
-- Advanced UI features implemented
-- Performance optimizations complete
-
-### Milestone 6: Production Ready (End of Week 12)
-- Comprehensive testing complete
-- Production deployment ready
-- Monitoring and logging implemented

frontend/src/pages/Posts.jsx

@@ -40,24 +40,13 @@ const Posts = () => {
     try {
       const result = await dispatch(generatePost()).unwrap();
       
-      // Handle case where content might be a list
+      // Handle the new structure of the result
       let content = result.content || 'Generated content will appear here...';
       let image = null;
       
-      // 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
+      // If result has image property (from updated backend/frontend)
+      if (result.image) {
+        image = result.image;
       }
       
       setPostContent(content);
@@ -94,7 +83,7 @@ const Posts = () => {
       };
       
       // Add image URL if available
-      if (postImage) {
+      if (postImage && postImage !== 'HAS_IMAGE_DATA_BUT_NOT_URL') {
         publishData.image_content_url = postImage;
       }
       
@@ -111,7 +100,7 @@ const Posts = () => {
       };
       
       // Add image URL if available
-      if (postImage) {
+      if (postImage && postImage !== 'HAS_IMAGE_DATA_BUT_NOT_URL') {
         createData.image_content_url = postImage;
       }
       
@@ -123,7 +112,6 @@ const Posts = () => {
       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

frontend/src/services/postService.js

@@ -40,12 +40,13 @@ class PostService {
       const jobId = startResponse.data.job_id;
       
       // Step 2: Poll for the result
-      const generatedContent = await this.pollForJobResult(jobId);
+      const generatedResult = await this.pollForJobResult(jobId);
       
       // Ensure we return a default value if content is null/undefined
-      const finalContent = generatedContent !== undefined && generatedContent !== null ? generatedContent : "Generated content will appear here...";
+      const finalContent = generatedResult.content !== undefined && generatedResult.content !== null ? generatedResult.content : "Generated content will appear here...";
+      const finalImage = generatedResult.image || null;
       
-      return { data: { success: true, content: finalContent } };
+      return { data: { success: true, content: finalContent, image: finalImage } };
     } catch (error) {
       if (import.meta.env.VITE_NODE_ENV === 'development') {
         console.error('📝 [Post] Generate post error:', error.response?.data || error.message);
@@ -79,8 +80,22 @@ class PostService {
               console.log('📝 [Post] Raw job data:', jobData);
             }
             
-            // Extract content, handling cases where it might be a list
-            let content = jobData.content;
+            // Extract content and image data from the job result
+            let content = '';
+            let imageData = null;
+            
+            // Handle the new structure of the result
+            if (jobData.content !== undefined) {
+              content = jobData.content;
+            }
+            
+            // Handle image data if it exists
+            if (jobData.image_url !== undefined && jobData.image_url !== null) {
+              imageData = jobData.image_url;
+            } else if (jobData.has_image_data) {
+              // Special marker for image data that exists but can't be displayed directly
+              imageData = 'HAS_IMAGE_DATA_BUT_NOT_URL';
+            }
             
             // If content is an array, take the first element
             if (Array.isArray(content)) {
@@ -88,7 +103,10 @@ class PostService {
             }
             
             // Ensure we return the content even if it's an empty string
-            return content !== undefined ? content : '';
+            return {
+              content: content !== undefined ? content : '',
+              image: imageData
+            };
           case 'failed':
             throw new Error(jobData.error || 'Job failed');
           case 'processing':

frontend/src/store/reducers/postsSlice.js

@@ -125,6 +125,7 @@ const postsSlice = createSlice({
       .addCase(generatePost.fulfilled, (state, action) => {
         state.loading = false;
         // We don't add generated content to the list, it's just for the form
+        // But we do need to handle the result properly
       })
       .addCase(generatePost.rejected, (state, action) => {
         state.loading = false;

frontend_requirements.md

@@ -1,235 +0,0 @@
-# Frontend Requirements
-
-## Overview
-This document outlines the technical requirements for the React frontend of the Lin application.
-
-## Core Technologies
-- React 18+
-- React Router v6+
-- Redux Toolkit for state management
-- Axios for HTTP requests
-- Material-UI (MUI) for UI components
-- Formik for form handling
-- Yup for form validation
-
-## Development Tools
-- Node.js 16+
-- npm or yarn package manager
-- Create React App or Vite for project setup
-- ESLint for code linting
-- Prettier for code formatting
-- Jest and React Testing Library for testing
-
-## Package Dependencies
-
-### Core Dependencies
-```json
-{
-  "@mui/material": "^5.0.0",
-  "@mui/icons-material": "^5.0.0",
-  "@reduxjs/toolkit": "^1.8.0",
-  "axios": "^0.27.0",
-  "formik": "^2.2.9",
-  "react": "^18.0.0",
-  "react-dom": "^18.0.0",
-  "react-redux": "^8.0.0",
-  "react-router-dom": "^6.3.0",
-  "yup": "^0.32.11"
-}
-```
-
-### Development Dependencies
-```json
-{
-  "@testing-library/jest-dom": "^5.16.4",
-  "@testing-library/react": "^13.3.0",
-  "@testing-library/user-event": "^14.2.0",
-  "eslint": "^8.18.0",
-  "prettier": "^2.7.1",
-  "jest": "^28.1.1"
-}
-```
-
-## Browser Support
-- Latest versions of Chrome, Firefox, Safari, and Edge
-- Mobile browsers (iOS Safari, Chrome for Android)
-- Responsive design for all screen sizes
-
-## UI/UX Requirements
-
-### Design System
-- Consistent color palette based on brand colors
-- Typography hierarchy with appropriate font sizes
-- Spacing system using consistent units
-- Component library with reusable UI elements
-
-### Responsive Design
-- Mobile-first approach
-- Flexible grid system
-- Adaptive components for different screen sizes
-- Touch-friendly interface elements
-
-### Accessibility
-- WCAG 2.1 AA compliance
-- Proper semantic HTML
-- Keyboard navigation support
-- Screen reader compatibility
-- Color contrast ratios meeting accessibility standards
-
-## State Management
-
-### Redux Store Structure
-```javascript
-{
-  auth: {
-    user: object,
-    isAuthenticated: boolean,
-    loading: boolean,
-    error: string
-  },
-  sources: {
-    items: array,
-    loading: boolean,
-    error: string
-  },
-  posts: {
-    items: array,
-    loading: boolean,
-    error: string
-  },
-  accounts: {
-    items: array,
-    loading: boolean,
-    error: string
-  },
-  schedules: {
-    items: array,
-    loading: boolean,
-    error: string
-  }
-}
-```
-
-### Actions and Reducers
-- Async thunks for API calls
-- Error handling in reducers
-- Loading states for async operations
-- Normalized data structure for efficient lookups
-
-## Routing
-
-### Routes Structure
-- `/` - Dashboard (protected)
-- `/login` - Login page (public)
-- `/register` - Registration page (public)
-- `/sources` - Source management (protected)
-- `/posts` - Post management (protected)
-- `/schedule` - Scheduling (protected)
-- `/*` - 404 page
-
-### Route Protection
-- Authentication guard for protected routes
-- Redirect logic for authenticated users
-- Loading states during authentication checks
-
-## API Integration
-
-### Service Layer
-- Axios instance with base URL configuration
-- Request and response interceptors
-- Error handling and transformation
-- Authentication token management
-
-### API Error Handling
-- Network error detection
-- HTTP error status handling
-- User-friendly error messages
-- Retry mechanism for failed requests
-
-## Form Handling
-
-### Form Libraries
-- Formik for form state management
-- Yup for form validation
-- Custom validation rules
-- Async validation support
-
-### Form Components
-- Reusable input components
-- Validation error display
-- Loading states during submission
-- Success feedback after submission
-
-## Testing Requirements
-
-### Unit Tests
-- Component rendering tests
-- Redux action and reducer tests
-- Utility function tests
-- Hook tests
-
-### Integration Tests
-- Form submission flows
-- API integration tests
-- Routing tests
-- Authentication flow tests
-
-### Test Coverage
-- Minimum 80% code coverage
-- Testing of edge cases
-- Mocking of external dependencies
-- Continuous integration setup
-
-## Performance Requirements
-
-### Loading States
-- Skeleton loaders for data fetching
-- Progress indicators for long operations
-- Optimistic updates where appropriate
-- Error boundaries for component failures
-
-### Bundle Optimization
-- Code splitting for route-based chunks
-- Lazy loading for non-critical components
-- Image optimization and lazy loading
-- Minification and compression
-
-### Caching Strategy
-- HTTP caching headers
-- Client-side caching for static data
-- Cache invalidation strategies
-- Service worker implementation (optional)
-
-## Security Considerations
-
-### Client-Side Security
-- XSS prevention through proper data escaping
-- CSRF protection for forms
-- Secure storage of authentication tokens
-- Input validation and sanitization
-
-### Authentication
-- Secure token storage (HttpOnly cookies or secure localStorage)
-- Token expiration and refresh mechanisms
-- Logout functionality
-- Session management
-
-## Deployment Requirements
-
-### Build Process
-- Production build optimization
-- Environment-specific configuration
-- Asset fingerprinting for cache busting
-- Source map generation for debugging
-
-### Hosting
-- Static file hosting (Netlify, Vercel, or similar)
-- CDN integration for asset delivery
-- SSL certificate for HTTPS
-- Custom domain support
-
-### CI/CD
-- Automated testing on pull requests
-- Automated deployment on merge to main branch
-- Environment-specific deployments
-- Rollback capabilities

frontend_structure.md

@@ -1,93 +0,0 @@
-# Frontend Structure Plan
-
-## Directory Structure
-```
-frontend/
-├── package.json           # Project dependencies and scripts
-├── public/                # Static assets
-│   ├── index.html         # Main HTML file
-│   └── favicon.ico        # Application icon
-├── src/                   # Source code
-│   ├── index.js           # Application entry point
-│   ├── App.js             # Root component
-│   ├── App.css            # Global styles
-│   ├── components/        # Reusable components
-│   │   ├── Header/        # Navigation header
-│   │   ├── Sidebar/       # Navigation sidebar
-│   │   ├── Auth/          # Authentication components
-│   │   │   ├── LoginForm.js
-│   │   │   └── RegisterForm.js
-│   │   ├── Dashboard/     # Dashboard components
-│   │   ├── Sources/       # Source management components
-│   │   ├── Posts/         # Post management components
-│   │   └── Scheduler/     # Scheduling components
-│   ├── pages/             # Page components
-│   │   ├── Home.js        # Home page
-│   │   ├── Login.js       # Login page
-│   │   ├── Register.js    # Registration page
-│   │   ├── Dashboard.js   # Main dashboard
-│   │   ├── Sources.js     # Source management page
-│   │   ├── Posts.js       # Post management page
-│   │   └── Schedule.js    # Scheduling page
-│   ├── services/          # API service layer
-│   │   ├── api.js         # Axios instance and interceptors
-│   │   ├── authService.js # Authentication API calls
-│   │   ├── sourceService.js# Source management API calls
-│   │   ├── postService.js # Post management API calls
-│   │   └── scheduleService.js# Scheduling API calls
-│   ├── store/             # Redux store
-│   │   ├── index.js       # Store configuration
-│   │   ├── actions/       # Action creators
-│   │   └── reducers/      # Reducers
-│   ├── hooks/             # Custom hooks
-│   │   └── useAuth.js     # Authentication hook
-│   ├── utils/             # Utility functions
-│   │   └── helpers.js     # Helper functions
-│   └── styles/            # CSS styles
-│       ├── variables.css  # CSS variables
-│       ├── auth.css       # Authentication styles
-│       ├── dashboard.css  # Dashboard styles
-│       ├── sources.css    # Source management styles
-│       ├── posts.css      # Post management styles
-│       └── schedule.css   # Scheduling styles
-└── README.md              # Frontend documentation
-```
-
-## Key Components
-
-### App.js
-- Main application component
-- Routing configuration
-- Authentication state management
-- Layout structure (Header, Sidebar)
-
-### Components
-- Reusable UI components
-- Presentational components with minimal logic
-- Styled with CSS modules or styled-components
-
-### Pages
-- Page-level components that compose multiple components
-- Route-specific logic
-- Data fetching and state management
-
-### Services
-- API communication layer
-- Request/response interceptors
-- Error handling
-- Authentication token management
-
-### Store
-- Redux store configuration
-- State management for the entire application
-- Actions and reducers for each feature
-
-### Hooks
-- Custom React hooks for reusable logic
-- Custom authentication hook
-- Data fetching hooks
-
-### Styles
-- CSS files organized by feature
-- Global styles and variables
-- Responsive design considerations

package.json

@@ -9,9 +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 && 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\"",
+    "dev:backend": "cd backend && python app.py",
+    "dev:all": "cd frontend && npx concurrently \"npm run dev:frontend\" \"npm run dev:backend\"",
+    "dev": "npm run dev:all",
     "build": "cd frontend && npm run build",
     "build:prod": "cd frontend && npm run build:prod",
     "preview": "cd frontend && npm run preview",
@@ -21,7 +21,7 @@
     "test:backend": "cd backend && pytest",
     "start": "npm run dev:all",
     "start:frontend": "npm run dev:frontend",
-    "start:backend": "npm run dev:backend",
+    "start:backend": "cd backend && python app.py",
     "setup": "npm run install:all && npm run build",
     "setup:win": "npm run install:all:win && npm run build",
     "clean": "cd frontend && npm run clean 2>/dev/null || true",

starty.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+Lin - Community Manager Assistant for LinkedIn
+Universal startup script for development servers
+"""
+import os
+import sys
+import subprocess
+import platform
+from pathlib import Path
+
+def is_windows():
+    """Check if the current OS is Windows"""
+    return platform.system().lower() == 'windows'
+
+def run_command(command, cwd=None, shell=False):
+    """Run a command and stream output"""
+    try:
+        # For Windows, we need to use shell=True for certain commands
+        use_shell = shell or is_windows()
+        
+        process = subprocess.Popen(
+            command, 
+            cwd=cwd, 
+            shell=use_shell,
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True
+        )
+        
+        # Stream output in real-time
+        for line in process.stdout:
+            print(line, end='')
+            
+        process.wait()
+        return process.returncode == 0
+    except Exception as e:
+        print(f"Error running command: {e}")
+        return False
+
+def start_frontend():
+    """Start the React frontend development server"""
+    print("Starting frontend development server...")
+    if is_windows():
+        cmd = "npm run dev:frontend"
+    else:
+        cmd = ["npm", "run", "dev:frontend"]
+    return run_command(cmd, shell=True)
+
+def start_backend():
+    """Start the Flask backend server"""
+    print("Starting backend server...")
+    
+    # Set environment variables and run the app
+    env = os.environ.copy()
+    # Add the project root to PYTHONPATH to ensure imports work correctly
+    env["PYTHONPATH"] = str(Path(__file__).parent)
+    
+    try:
+        # Run the Flask app directly from the root directory
+        process = subprocess.Popen(
+            [sys.executable, "app.py"],
+            cwd=Path(__file__).parent,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True
+        )
+        
+        # Stream output
+        for line in process.stdout:
+            print(line, end='')
+            
+        process.wait()
+        return process.returncode == 0
+    except Exception as e:
+        print(f"Error starting backend: {e}")
+        return False
+
+def start_all():
+    """Start both frontend and backend using npm concurrently script"""
+    print("Starting both frontend and backend servers...")
+    # Use the frontend's concurrently script to run both servers
+    if is_windows():
+        cmd = "cd frontend && npx concurrently \"npm run dev:frontend\" \"npm run dev:backend\""
+    else:
+        cmd = "cd frontend && npx concurrently \"npm run dev:frontend\" \"npm run dev:backend\""
+    return run_command(cmd, shell=True)
+
+def show_help():
+    """Display usage information"""
+    help_text = """
+Lin Development Launcher
+
+Usage:
+  python starty.py [command]
+
+Commands:
+  backend    Start only the backend server (default)
+  frontend   Start only the frontend development server
+  dev:all    Start both frontend and backend servers
+  help       Show this help message
+
+Examples:
+  python starty.py              # Start backend server
+  python starty.py backend      # Start backend server
+  python starty.py frontend     # Start frontend server
+  python starty.py dev:all      # Start both servers
+"""
+    print(help_text)
+
+def main():
+    """Main entry point"""
+    # Always ensure we're in the project root
+    project_root = Path(__file__).parent
+    os.chdir(project_root)
+    
+    if len(sys.argv) < 2:
+        # Default behavior - start backend
+        start_backend()
+        return
+    
+    command = sys.argv[1].lower()
+    
+    if command in ['help', '--help', '-h']:
+        show_help()
+    elif command == 'frontend':
+        start_frontend()
+    elif command == 'backend':
+        start_backend()
+    elif command in ['dev:all', 'all', 'both']:
+        # Instead of calling npm run dev:all (which creates a loop), 
+        # directly start both servers
+        start_all()
+    else:
+        print(f"Unknown command: {command}")
+        show_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

test_imports.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+Test script to verify backend imports work correctly
+"""
+import sys
+import os
+from pathlib import Path
+
+# Add the project root to the Python path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+print("Testing backend imports...")
+
+try:
+    # Test the import that was failing
+    from backend.services.content_service import ContentService
+    print("[SUCCESS] Successfully imported ContentService")
+except ImportError as e:
+    print(f"[ERROR] Failed to import ContentService: {e}")
+
+try:
+    # Test another service import
+    from backend.services.linkedin_service import LinkedInService
+    print("[SUCCESS] Successfully imported LinkedInService")
+except ImportError as e:
+    print(f"[ERROR] Failed to import LinkedInService: {e}")
+
+try:
+    # Test importing the app
+    from backend.app import create_app
+    print("[SUCCESS] Successfully imported create_app")
+except ImportError as e:
+    print(f"[ERROR] Failed to import create_app: {e}")
+
+print("Import test completed.")