Upload 13 files

youtube automaton studiio

.dockerignore

@@ -0,0 +1,58 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.installed.cfg
+*.egg
+venv/
+env/
+ENV/
+
+# Documentation
+*.md
+!README.md
+DEPLOYMENT.md
+README_HF.md
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+downloads/*.mp4
+downloads/*.avi
+downloads/*.mov
+user_tokens/*.json
+temp_audio/*.mp3
+temp_audio/*.m4a
+flask_session/
+*.log
+
+# Environment
+.env
+.env.local
+.env.example
+
+# Build files
+render.yaml
+Procfile
+runtime.txt
+requirements_hf.txt
+
+# Test files
+test_*.py
+tests/

.gitignore

@@ -0,0 +1,67 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Flask
+instance/
+.webassets-cache
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+downloads/*.mp4
+downloads/*.avi
+downloads/*.mov
+temp_audio/
+user_tokens/
+flask_session/
+client_secret.json
+token.json
+token_*.json
+
+# Logs
+*.log
+logs/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Hugging Face
+.huggingface/

DEPLOYMENT_HF.md

@@ -0,0 +1,143 @@
+# Deployment Guide for Hugging Face Spaces
+
+## Prerequisites
+
+1. Hugging Face account (free)
+2. GitHub repository with your code
+3. Google Cloud OAuth credentials (`client_secret.json`)
+4. Required API keys:
+   - Google Gemini API key
+   - Instagram session ID
+
+## Step 1: Prepare Google Cloud OAuth
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com)
+2. Create a new project or select existing
+3. Enable **YouTube Data API v3**
+4. Go to **Credentials** → Create OAuth 2.0 Client ID
+5. Choose **Web application**
+6. Add authorized redirect URI:
+   ```
+   https://YOUR_USERNAME-youtube-automation-studio.hf.space/auth/callback
+   ```
+7. Download `client_secret.json`
+
+## Step 2: Get Instagram Session ID
+
+1. Open Instagram in Chrome browser
+2. Login to your Instagram account
+3. Press `F12` (Developer Tools)
+4. Go to **Application** tab → **Cookies** → `https://instagram.com`
+5. Find cookie named `sessionid`
+6. Copy the entire value (should be 40+ characters)
+
+## Step 3: Generate Secret Key
+
+Run this Python command:
+```bash
+python -c "import secrets; print(secrets.token_hex(32))"
+```
+Copy the output.
+
+## Step 4: Create Hugging Face Space
+
+1. Go to https://huggingface.co/spaces
+2. Click **Create new Space**
+3. Fill in details:
+   - **Space name**: `youtube-automation-studio`
+   - **License**: MIT
+   - **Select SDK**: Docker
+   - **Space hardware**: CPU basic (free)
+4. Click **Create Space**
+
+## Step 5: Configure Environment Variables
+
+In your Space settings → **Variables and secrets**:
+
+Add these **secrets**:
+
+```env
+ENVIRONMENT=production
+GEMINI_API_KEY=your-gemini-api-key-from-google-ai-studio
+IG_SESSIONID=your-instagram-sessionid-from-cookies
+SECRET_KEY=your-generated-secret-key-from-step3
+```
+
+## Step 6: Upload client_secret.json
+
+In your Space → **Files** tab:
+1. Click **Add file** → **Upload files**
+2. Upload your `client_secret.json`
+3. Mark it as **secret file** if option available
+
+## Step 7: Push Code to Hugging Face
+
+### Option A: Direct Git Push
+
+```bash
+# Clone your HF Space repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/youtube-automation-studio
+cd youtube-automation-studio
+
+# Copy all your project files
+cp -r /path/to/your/project/* .
+
+# Make sure these files are present:
+# - Dockerfile
+# - requirements.txt
+# - app.py
+# - All other Python files
+# - templates/ folder
+# - static/ folder
+# - client_secret.json (if not uploaded via UI)
+
+# Commit and push
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+### Option B: Via GitHub
+
+If your code is on GitHub:
+
+1. In your HF Space settings
+2. Go to **Files and versions** → **Settings**
+3. Connect to GitHub repository
+4. Select branch to deploy from
+
+## Step 8: Wait for Build
+
+- Build typically takes 5-10 minutes
+- Monitor logs in **Logs** tab
+- Check for any errors
+
+## Step 9: Test Your Deployment
+
+1. Once build completes, visit your Space URL:
+   ```
+   https://YOUR_USERNAME-youtube-automation-studio.hf.space
+   ```
+
+2. Test each feature:
+   - ✅ Homepage loads
+   - ✅ Sign in with YouTube works
+   - ✅ Download Instagram Reel
+   - ✅ AI metadata generation
+   - ✅ Video upload to YouTube
+
+## Step 10: Update OAuth Redirect URI (If Needed)
+
+If authentication fails:
+
+1. Go back to Google Cloud Console
+2. Edit your OAuth 2.0 Client
+3. Verify redirect URI matches exactly:
+   ```
+   https://YOUR_USERNAME-youtube-automation-studio.hf.space/auth/callback
+   ```
+4. Save and wait 5 minutes for changes to propagate
+
+## Monitoring & Maintenance
+
+### Check Logs

Dockerfile

@@ -0,0 +1,39 @@
+FROM python:3.11-slim
+
+# Install system dependencies including ffmpeg
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgl1-mesa-glx \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p downloads user_tokens /tmp/flask_session temp_audio
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV ENVIRONMENT=production
+ENV PORT=7860
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860", "--workers", "2", "--timeout", "600", "--log-level", "info"]

README.md

@@ -1,12 +1,85 @@
----
-title: Creatorplus
-emoji: 🐢
-colorFrom: purple
-colorTo: red
-sdk: docker
-pinned: false
-license: mit
-short_description: youtube automation studio
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: YouTube Automation Studio
+emoji: 🎬
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860
+---
+
+# 🎬 YouTube Automation Studio
+
+AI-powered automation tool for downloading Instagram Reels, generating metadata with Google Gemini AI, and uploading to YouTube automatically.
+
+## ✨ Features
+
+- 📥 **Instagram Reel Downloader**: Download Reels in HD quality with original audio
+- 🤖 **AI Metadata Generator**: Generate SEO-optimized titles, descriptions, tags using Google Gemini 2.0
+- 📤 **YouTube Auto Uploader**: Upload directly to YouTube with automated metadata
+- 🎵 **Video Editor**: Add background music and text overlays to videos
+- 🔐 **Multi-User Support**: Each user has their own isolated YouTube authentication
+
+## 🚀 Quick Start
+
+1. **Set Environment Variables** (Required):
+   - `GEMINI_API_KEY`: Get from [Google AI Studio](https://makersuite.google.com/app/apikey)
+   - `IG_SESSIONID`: Instagram session cookie (see below)
+   - `SECRET_KEY`: Generate with `python -c "import secrets; print(secrets.token_hex(32))"`
+
+2. **Upload client_secret.json**:
+   - Create OAuth credentials in [Google Cloud Console](https://console.cloud.google.com)
+   - Enable YouTube Data API v3
+   - Download and upload `client_secret.json` as a secret file
+
+3. **Access the app** and start automating!
+
+## 🔑 Getting Instagram Session ID
+
+1. Open Instagram in Chrome
+2. Press `F12` → Application → Cookies → instagram.com
+3. Find `sessionid` cookie and copy its value
+4. Add to Space secrets as `IG_SESSIONID`
+
+## 🎯 Usage
+
+1. **Sign in with YouTube** (OAuth 2.0 - secure & one-time)
+2. **Paste Instagram Reel URL**
+3. **(Optional) Add video editing**:
+   - Background music from YouTube or local file
+   - Text overlays with custom positioning
+4. **AI generates metadata** (title, description, tags, hashtags)
+5. **Video uploads to YouTube** automatically
+
+## 🛠️ Tech Stack
+
+- **Backend**: Flask, Python 3.11, Gunicorn
+- **AI**: Google Gemini 2.0 Flash
+- **APIs**: YouTube Data API v3, Instagram
+- **Video Processing**: MoviePy, OpenCV, FFmpeg
+- **Auth**: OAuth 2.0, Session-based authentication
+
+## 📋 Environment Variables
+
+Set these in your Hugging Face Space settings:
+
+```env
+ENVIRONMENT=production
+GEMINI_API_KEY=your-gemini-api-key-here
+IG_SESSIONID=your-instagram-sessionid-here
+SECRET_KEY=your-secret-key-here
+```
+
+## 🔒 Security
+
+- OAuth 2.0 for YouTube authentication
+- Session-based user isolation
+- Secure cookie handling
+- No password storage
+- Automatic credential refresh
+
+## 📝 OAuth Redirect URI
+
+Add this to your Google Cloud OAuth credentials:
+````

ai_genrator.py

@@ -0,0 +1,270 @@
+import google.generativeai as genai
+import os
+import json
+from typing import Dict, List, Optional
+import cv2
+from datetime import datetime
+from dotenv import load_dotenv
+import base64
+import tempfile
+from PIL import Image
+import numpy as np
+
+# Load environment variables from .env file
+load_dotenv()
+
+class AIMetadataGenerator:
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the AI Metadata Generator with Gemini 2.0 Flash"""
+        self.api_key = api_key or os.getenv('GEMINI_API_KEY')
+        if not self.api_key:
+            raise ValueError("Gemini API key not found. Please set GEMINI_API_KEY in .env file or pass it as parameter.")
+        
+        genai.configure(api_key=self.api_key) # type: ignore
+        self.model = genai.GenerativeModel('gemini-2.0-flash-exp') # type: ignore
+    
+    def extract_video_frames(self, video_path: str, num_frames: int = 3) -> List[str]:
+        """Extract representative frames from video for AI analysis"""
+        try:
+            cap = cv2.VideoCapture(video_path)
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            frames = []
+            
+            # Extract frames at regular intervals
+            for i in range(num_frames):
+                frame_number = int((i + 1) * frame_count / (num_frames + 1))
+                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+                ret, frame = cap.read()
+                
+                if ret:
+                    # Convert BGR to RGB
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    # Convert to PIL Image
+                    pil_image = Image.fromarray(frame_rgb)
+                    # Resize for efficient processing
+                    pil_image = pil_image.resize((512, 512), Image.Resampling.LANCZOS)
+                    frames.append(pil_image)
+            
+            cap.release()
+            return frames
+            
+        except Exception as e:
+            print(f"Error extracting frames: {e}")
+            return []
+    
+    def analyze_video_content(self, video_path: str) -> str:
+        """Analyze video content using AI vision to understand what's in the video frames"""
+        try:
+            # Extract video frames
+            frames = self.extract_video_frames(video_path, 3)  # Increased to 3 frames for better coverage
+            if not frames:
+                return "Unable to analyze video content"
+            
+            # Analyze frames for text and visual content
+            combined_analysis = []
+            
+            for i, frame in enumerate(frames):
+                prompt = f"""
+                Analyze this video frame {i+1} and describe what you see in detail. Focus on:
+                1. Any visible text in the frame
+                2. Main subject/person and their actions
+                3. Setting/location 
+                4. Key objects or activities visible
+                5. Overall mood and style
+                
+                Extract any text that appears in the image if present.
+                Provide detailed analysis of what's shown in the frame.
+                """
+                
+                response = self.model.generate_content([prompt, frame])
+                combined_analysis.append(response.text.strip())
+            
+            # Combine analyses from all frames
+            final_prompt = f"""
+            Based on the following analyses of different frames from a video, provide a comprehensive understanding of what the video is about:
+            
+            FRAME ANALYSES:
+            {' '.join(combined_analysis)}
+            
+            Create a concise summary that captures the essence of this video, focusing especially on any text that appears in the frames.
+            """
+            
+            final_response = self.model.generate_content(final_prompt)
+            return final_response.text.strip()
+            
+        except Exception as e:
+            print(f"Error analyzing video content: {e}")
+            return "Video content analysis unavailable"
+    
+    def generate_title(self, video_analysis: str) -> str:
+        """Generate engaging YouTube shorts title with tranding hashtags to viral a shorts and acc. to video """
+        prompt = f"""
+        Based on this video analysis, create a catchy YouTube Shorts title:
+        
+        VIDEO CONTENT: {video_analysis}
+        
+        Requirements:
+        - Make it extremely engaging, click-worthy and optimized for high CTR
+        - Keep it under 99 characters including hashtags
+        - Include tranding relevant hashtags related to short video directly in the title
+        - Focus on the most intriguing aspect of the video, especially any text that appears in the video
+        - Use trending language patterns popular in viral shorts
+        - Consider using emojis strategically
+        - Make it provocative but not clickbait
+        
+        The title should follow formats that are proven to work for viral shorts.
+        Return only the title with hashtags, nothing else.
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text.strip().replace('"', '').replace("'", "")
+        except Exception as e:
+            print(f"Error generating title: {e}")
+            return "🔥 Viral Moment You Won't Believe! #shorts #viral #trending"
+    
+    def generate_description(self, video_analysis: str) -> str:
+        """Generate YouTube shorts description optimized for virality based on text and visual content"""
+        prompt = f"""
+        Create a YouTube Shorts description based on this video analysis:
+        
+        VIDEO CONTENT: {video_analysis}
+        
+        Structure the description exactly like this:
+        
+         Write exactly 3-4 lines of engaging, high-emotion description that creates curiosity
+         Add a line break then write "Keywords:" followed by exactly 40-50 trending keywords line by line
+         Add a line break then write "Hashtags:" followed by exactly 60-70 viral hashtags (MUST include #shorts, #viral, #trending #shortvideo #shortsfeed #ytshorts #viralvideo more like this and other relevant ones)
+         Add a line break then add this call-to-action: "👉 subscribe for more content like this! 🔔 Turn on notifications!"
+         Add a line break then make copyright disclaimer to protect from strikes And copyright holder.
+        
+        Make the description extremely engaging and optimized for Shorts algorithm with high-emotion language patterns.
+        Focus on keywords and hashtags that are currently trending for short-form viral content.
+        If there was any text in the video, incorporate it into the description.
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text.strip()
+        except Exception as e:
+            print(f"Error generating description: {e}")
+            return self._fallback_description()
+    
+    def generate_tags_and_keywords(self, video_analysis: str) -> Dict:
+        """Generate optimized tags and keywords specifically for viral shorts"""
+        prompt = f"""
+        Based on this video analysis, generate optimized tags and keywords for a viral YouTube Short:
+        
+        VIDEO CONTENT: {video_analysis}
+        
+        Provide your response as JSON with these exact fields:
+        1. "tags": List of 30 tags optimized for YouTube search algorithm (keep each under 30 characters)
+        2. "keywords": List of 40 relevant keywords (single words or short phrases) related to the content
+        3. "trending_keywords": List of 15 currently trending keywords related to the content
+        
+        Tags should include general category terms, specific content descriptors, and trending terms.
+        Format the response as valid JSON only - no explanation or other text.
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            result = json.loads(response.text.strip())
+            return result
+        except Exception as e:
+            print(f"Error generating tags and keywords: {e}")
+            return {
+                "tags": ["shorts", "viral", "trending"],
+                "keywords": ["viral video", "trending content", "shorts"],
+                "trending_keywords": ["viral shorts", "trending now"]
+            }
+    
+    def _fallback_description(self) -> str:
+        """Fallback description when AI generation fails"""
+        return """Amazing video content that will keep you entertained!
+Watch this incredible moment captured on video.
+Perfect for sharing with friends and family.
+Don't forget to like and subscribe for more content.
+This video showcases some really cool stuff.
+You won't believe what happens in this video.
+Make sure to watch until the end.
+Comment below what you think about this.
+Share this video if you enjoyed it.
+Thanks for watching our content!
+
+Keywords: viral video, trending content, amazing moments, entertainment, social media, short video, funny clips, must watch, incredible, awesome, cool stuff, viral clips, trending now, popular video, engaging content, shareable, entertaining, video content, social sharing, watch now
+
+Hashtags: #shorts #viral #trending #amazing #entertainment #video #content #socialmedia #funny #cool #awesome #mustwatch #incredible #popular #engaging #shareable #entertaining #videooftheday #trend #viral2024 #shortsvideo #viralshorts #trendingshorts #amazingvideo #viralcontent #shortsfeed #explore #fyp #foryou #viralmoment
+
+⚠️ Copyright Disclaimer: This content is used for educational and entertainment purposes. All rights belong to their respective owners. If you are the owner and want this removed, please contact us."""
+    
+    def generate_complete_metadata(self, video_path: str, **kwargs) -> Dict:
+        """Generate complete metadata package based on video frame analysis"""
+        
+        print("🤖 Analyzing video frames with AI...")
+        video_analysis = self.analyze_video_content(video_path)
+        print(f"📹 Video analysis complete")
+        
+        print("🎯 Generating viral shorts title with hashtags...")
+        title = self.generate_title(video_analysis)
+        
+        print("📝 Generating description optimized for shorts...")
+        description = self.generate_description(video_analysis)
+        
+        print("🏷️ Generating optimized tags and keywords...")
+        tags_keywords = self.generate_tags_and_keywords(video_analysis)
+        
+        # Extract hashtags from description
+        description_lines = description.split('\n')
+        hashtags = []
+        keywords = []
+        
+        for line in description_lines:
+            if line.startswith('Hashtags:'):
+                hashtags_text = line.replace('Hashtags:', '').strip()
+                hashtags = [tag.strip() for tag in hashtags_text.split() if tag.startswith('#')]
+            elif line.startswith('Keywords:'):
+                keywords_text = line.replace('Keywords:', '').strip()
+                keywords = [kw.strip() for kw in keywords_text.split(',')]
+        
+        metadata = {
+            "video_analysis": video_analysis,
+            "title": title,
+            "description": description,
+            "tags": tags_keywords.get("tags", []),
+            "hashtags": hashtags,
+            "keywords": tags_keywords.get("keywords", []),
+            "trending_keywords": tags_keywords.get("trending_keywords", []),
+            "generated_at": datetime.now().isoformat()
+        }
+        
+        return metadata
+    
+    def save_metadata(self, metadata: Dict, output_path: str):
+        """Save metadata to JSON file"""
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+            print(f"Metadata saved to: {output_path}")
+        except Exception as e:
+            print(f"Error saving metadata: {e}")
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the generator (API key will be loaded from .env)
+    generator = AIMetadataGenerator()
+    
+    # Example video processing
+    video_path = r"c:\Users\DELL\OneDrive\Desktop\youtube automation ai\sample_video.mp4"
+    
+    # Generate complete metadata
+    metadata = generator.generate_complete_metadata(video_path=video_path)
+    
+    # Print results
+    print("Generated Metadata:")
+    print("-" * 50)
+    print(f"Title: {metadata['title']}")
+    print(f"\nDescription:\n{metadata['description']}")
+    
+    # Save to file
+    output_file = r"c:\Users\DELL\OneDrive\Desktop\youtube automation ai\metadata_output.json"
+    generator.save_metadata(metadata, output_file)

app.py

@@ -0,0 +1,1027 @@
+from flask import Flask, render_template, request, jsonify, send_file, redirect, url_for, session
+import os
+import uuid
+import threading
+from datetime import datetime
+from typing import Dict, Any, Optional
+import logging
+from dotenv import load_dotenv
+import secrets
+
+# Load environment variables from .env file
+load_dotenv()
+
+# ✅ FIX: Allow insecure transport for local OAuth (development only)
+os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+
+# Import our modules
+from downloader import download_reel_with_audio  # Ensure downloader.py defines this function
+from uploader import upload_to_youtube, check_authentication, authenticate_youtube, get_youtube_service, get_channel_info, logout_youtube
+from ai_genrator import AIMetadataGenerator  # Fixed import to use the correct class
+from video_editor import VideoEditor  # Import video editor
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__) 
+
+app = Flask(__name__)
+
+# Configuration
+DOWNLOAD_FOLDER = 'downloads'
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+# ✅ NEW: Store user tokens in a separate folder
+USER_TOKENS_FOLDER = 'user_tokens'
+os.makedirs(USER_TOKENS_FOLDER, exist_ok=True)
+
+# Ensure download folder exists
+os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
+
+# Task storage (in production, use Redis or database)
+tasks = {}
+
+class TaskStatus:
+    def __init__(self, task_id: str):
+        self.task_id = task_id
+        self.status = 'started'
+        self.progress = 0
+        self.message = 'Task started'
+        self.error = None
+        self.result = None
+        self.metadata = None
+        self.youtube_url = None
+        self.created_at = datetime.now()
+
+def update_task_status(task_id: str, status: str, message: str = '', progress: int = 0, **kwargs):
+    """Update task status"""
+    if task_id in tasks:
+        task = tasks[task_id]
+        task.status = status
+        task.message = message
+        task.progress = progress
+        
+        # Update additional fields
+        for key, value in kwargs.items():
+            setattr(task, key, value)
+        
+        logger.info(f"Task {task_id}: {status} - {message}")
+
+# ✅ NEW: Helper function to get user-specific token path
+def get_user_token_path():
+    """Get token path for current user session"""
+    if 'user_id' not in session:
+        session['user_id'] = str(uuid.uuid4())
+    
+    user_id = session['user_id']
+    return os.path.join(USER_TOKENS_FOLDER, f'token_{user_id}.json')
+
+def background_upload_task(task_id: str, reel_url: str, editing_options: Optional[dict] = None, token_path: str = 'token.json'):
+    """Background task for downloading, editing, and uploading"""
+    video_path = None
+    edited_video_path = None
+    uploaded_music_path = None  # ✅ NEW: Track uploaded music for cleanup
+    
+    try:
+        update_task_status(task_id, 'downloading', 'Downloading reel from Instagram...', 10)
+        
+        # Get sessionid from environment
+        sessionid = os.getenv("IG_SESSIONID")
+        if not sessionid:
+            raise Exception("IG_SESSIONID not configured in .env file")
+        
+        # Validate sessionid format (basic check)
+        if len(sessionid) < 20 or not sessionid.replace('%', '').replace(':', '').isalnum():
+            raise Exception("IG_SESSIONID appears to be invalid. Please update it in the .env file.")
+        
+        # Download the reel with sessionid
+        try:
+            video_path = download_reel_with_audio(reel_url, DOWNLOAD_FOLDER, sessionid)
+        except Exception as download_error:
+            error_msg = str(download_error)
+            # Check for Instagram authentication/permission errors
+            if "403" in error_msg or "Forbidden" in error_msg or "metadata failed" in error_msg.lower():
+                raise Exception(
+                    "Instagram session expired or invalid. Please update your IG_SESSIONID in the .env file"
+                )
+            elif "Login required" in error_msg or "Not logged in" in error_msg:
+                raise Exception(
+                    "Instagram login required. Your session has expired. Please update IG_SESSIONID in .env file."
+                )
+            else:
+                raise Exception(f"Failed to download reel: {error_msg}")
+        
+        if not video_path or not os.path.exists(video_path):
+            raise Exception("Failed to download video file")
+        
+        logger.info(f"✅ Video downloaded: {video_path}")
+        
+        # Determine final video path
+        final_video_path = video_path
+        
+        # ✅ Video Editing Step (FIXED to support local files)
+        if editing_options and editing_options.get('enabled'):
+            try:
+                update_task_status(task_id, 'editing', 'Editing video (adding music & text overlays)...', 30)
+                
+                logger.info(f"�� Starting video editing with options: {editing_options}")
+                
+                # Initialize video editor
+                editor = VideoEditor()
+                
+                # Generate edited video filename
+                base_name = os.path.splitext(os.path.basename(video_path))[0]
+                edited_video_path = os.path.join(DOWNLOAD_FOLDER, f"{base_name}_edited.mp4")
+                
+                # ✅ NEW: Determine music source (URL or local file)
+                music_source = editing_options.get('music_url') or editing_options.get('music_file')
+                uploaded_music_path = editing_options.get('music_file')  # Track for cleanup
+                
+                # Apply edits
+                editor.edit_video(
+                    video_path=video_path,
+                    output_path=edited_video_path,
+                    music_url=music_source,  # Can be either YouTube URL or local file path
+                    music_volume=editing_options.get('music_volume', 0.3),
+                    text_overlays=editing_options.get('text_overlays')
+                )
+                
+                logger.info(f"✅ Video editing completed: {edited_video_path}")
+                
+                # Use edited video for upload
+                final_video_path = edited_video_path
+                
+            except Exception as edit_error:
+                error_msg = str(edit_error)
+                logger.error(f"❌ Video editing failed: {error_msg}")
+                
+                # If editing fails, use original video
+                logger.warning("⚠️ Using original video due to editing failure")
+                final_video_path = video_path
+                
+                # Update status to show editing was skipped
+                update_task_status(
+                    task_id, 
+                    'generating_metadata', 
+                    f'Skipped editing (error: {error_msg[:50]}...). Using original video...', 
+                    50
+                )
+        
+        update_task_status(task_id, 'generating_metadata', 'AI analyzing video content and generating metadata...', 60)
+        
+        # Generate metadata using AI with actual video analysis
+        try:
+            # Create AI Metadata Generator instance
+            ai_generator = AIMetadataGenerator(GEMINI_API_KEY)
+            
+            # Generate metadata based on actual video content
+            generated_metadata = ai_generator.generate_complete_metadata(
+                video_path=final_video_path,
+                target_audience="social media users"
+            )
+            
+            # Extract needed fields for YouTube upload
+            metadata = {
+                'title': generated_metadata['title'],
+                'description': generated_metadata['description'],
+                'tags': generated_metadata['tags'],
+                'keywords': generated_metadata['keywords'],
+                'hashtags': generated_metadata['hashtags'],
+                'video_analysis': generated_metadata.get('video_analysis', 'Content analysis unavailable')
+            }
+            
+            logger.info(f"✅ AI metadata generated successfully")
+            logger.info(f"📝 Title: {metadata['title']}")
+            
+        except Exception as e:
+            logger.warning(f"AI metadata generation failed: {str(e)}. Using fallback metadata.")
+            # Fallback metadata
+            filename = os.path.basename(final_video_path)
+            metadata = {
+                'title': f'Amazing Social Media Content - {filename}',
+                'description': f'Check out this amazing content!\n\nOriginal source: {reel_url}\n\n#SocialMedia #Viral #Content #Entertainment',
+                'tags': ['social media', 'viral', 'entertainment', 'content', 'video'],
+                'keywords': ['social media video', 'viral content', 'entertainment'],
+                'hashtags': ['#SocialMedia', '#Viral', '#Content']
+            }
+        
+        update_task_status(task_id, 'uploading', 'Uploading to YouTube...', 85, metadata=metadata)
+        
+        # ✅ FIX: Pass token_path to upload_to_youtube
+        try:
+            video_id = upload_to_youtube(
+                video_path=final_video_path,
+                title=metadata['title'],
+                description=metadata['description'],
+                tags=metadata['tags'],
+                privacy_status="public",
+                token_path=token_path  # ✅ FIXED: Now passing token_path
+            )
+            
+            youtube_url = f"https://www.youtube.com/watch?v={video_id}"
+            
+            update_task_status(
+                task_id, 
+                'completed', 
+                'Upload completed successfully!', 
+                100,
+                result={'video_id': video_id},
+                youtube_url=youtube_url,
+                metadata=metadata
+            )
+            
+        except Exception as upload_error:
+            raise Exception(f"YouTube upload failed: {str(upload_error)}")
+        
+    except Exception as e:
+        logger.error(f"Task {task_id} failed: {str(e)}")
+        update_task_status(task_id, 'failed', str(e), error=str(e))
+    finally:
+        # Clean up downloaded files after successful upload or failure
+        for path in [video_path, edited_video_path, uploaded_music_path]:
+            if path and os.path.exists(path):
+                try:
+                    os.remove(path)
+                    logger.info(f"🧹 Cleaned up temporary file: {path}")
+                except Exception as cleanup_error:
+                    logger.warning(f"⚠️ Could not clean up file {path}: {cleanup_error}")
+
+@app.route('/')
+def index():
+    """Render the main page"""
+    return render_template('index.html')
+
+@app.route('/downloader')
+def downloader_page():
+    """Render the downloader page"""
+    return render_template('downloader.html')
+
+@app.route('/metadata-generator')
+def metadata_generator_page():
+    """Render the metadata generator page"""
+    return render_template('metadata_generator.html')
+
+@app.route('/uploader')
+def uploader_page():
+    """Render the uploader page"""
+    is_authenticated = check_authentication()
+    return render_template('uploader.html', authenticated=is_authenticated)
+
+@app.route('/check-auth')
+def check_auth():
+    """Check YouTube authentication status for current user"""
+    try:
+        # ✅ Pass user-specific token path
+        token_path = get_user_token_path()
+        is_authenticated = check_authentication(token_path)
+        channel_info = None
+        if is_authenticated:
+            channel_info = get_channel_info(token_path)
+        return jsonify({
+            'authenticated': is_authenticated,
+            'channel': channel_info
+        })
+    except Exception as e:
+        logger.error(f"Error checking authentication: {str(e)}")
+        return jsonify({'authenticated': False, 'error': str(e)})
+
+@app.route('/authenticate', methods=['POST'])
+def authenticate():
+    """Authenticate with YouTube for current user"""
+    try:
+        token_path = get_user_token_path()
+        credentials = authenticate_youtube(token_path)
+        if credentials:
+            return jsonify({'success': True, 'message': 'Authentication successful'})
+        else:
+            return jsonify({'success': False, 'error': 'Authentication failed'})
+    except Exception as e:
+        logger.error(f"Authentication error: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/auth/start')
+def start_auth():
+    """Start OAuth flow for current user"""
+    try:
+        import google_auth_oauthlib.flow
+        
+        scopes = ["https://www.googleapis.com/auth/youtube.upload"]
+        client_secrets_file = "client_secret.json"
+        
+        if not os.path.exists(client_secrets_file):
+            return jsonify({'error': 'client_secret.json not found'})
+        
+        flow = google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file(
+            client_secrets_file, scopes)
+        
+        redirect_uri = request.url_root.rstrip('/') + '/auth/callback'
+        
+        if os.getenv('ENVIRONMENT') != 'production':
+            if 'localhost' in redirect_uri or '127.0.0.1' in redirect_uri:
+                redirect_uri = redirect_uri.replace('https://', 'http://')
+        
+        flow.redirect_uri = redirect_uri
+        
+        auth_url, state = flow.authorization_url(
+            prompt='consent',
+            access_type='offline',
+            include_granted_scopes='true'
+        )
+        
+        # ✅ Store flow in user session (not shared globally)
+        session['oauth_flow_state'] = state
+        # Store flow data in a temporary file for this user
+        flow_data = {
+            'client_secrets_file': client_secrets_file,
+            'redirect_uri': redirect_uri,
+            'scopes': scopes
+        }
+        session['oauth_flow_data'] = flow_data
+        
+        return jsonify({'auth_url': auth_url})
+        
+    except Exception as e:
+        logger.error(f"Error starting auth: {str(e)}")
+        return jsonify({'error': str(e)})
+
+@app.route('/auth/callback')
+def auth_callback():
+    """Handle OAuth callback for current user"""
+    try:
+        # ✅ Reconstruct flow from session data
+        flow_data = session.get('oauth_flow_data')
+        state = session.get('oauth_flow_state')
+        
+        if not flow_data:
+            return "OAuth flow not found. Please restart the authentication process.", 400
+        
+        import google_auth_oauthlib.flow
+        flow = google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file(
+            flow_data['client_secrets_file'], flow_data['scopes'])
+        flow.redirect_uri = flow_data['redirect_uri']
+        
+        auth_code = request.args.get('code')
+        error = request.args.get('error')
+        
+        if error:
+            return f"Authentication failed: {error}", 400
+            
+        if not auth_code:
+            return "No authorization code received", 400
+        
+        try:
+            flow.fetch_token(code=auth_code)
+            credentials = flow.credentials
+        except Exception as token_error:
+            logger.error(f"Token exchange failed: {str(token_error)}")
+            return f"Token exchange failed: {str(token_error)}", 500
+        
+        # ✅ Save credentials to user-specific token file
+        token_path = get_user_token_path()
+        with open(token_path, 'w') as token:
+            token.write(credentials.to_json())
+        
+        # Clean up session
+        session.pop('oauth_flow_state', None)
+        session.pop('oauth_flow_data', None)
+        
+        return """
+        <html>
+        <head>
+            <style>
+                body {
+                    font-family: 'Inter', sans-serif;
+                    background: linear-gradient(135deg, #0f0f23 0%, #1a1a3e 100%);
+                    color: white;
+                    display: flex;
+                    justify-content: center;
+                    align-items: center;
+                    height: 100vh;
+                    margin: 0;
+                }
+                .container {
+                    text-align: center;
+                    background: rgba(255, 255, 255, 0.05);
+                    backdrop-filter: blur(20px);
+                    border: 1px solid rgba(255, 255, 255, 0.1);
+                    border-radius: 20px;
+                    padding: 50px;
+                    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+                }
+                h2 {
+                    color: #00E676;
+                    font-size: 32px;
+                    margin-bottom: 20px;
+                }
+                p {
+                    font-size: 18px;
+                    color: rgba(255, 255, 255, 0.7);
+                }
+                .icon {
+                    font-size: 80px;
+                    margin-bottom: 20px;
+                }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <div class="icon">✅</div>
+                <h2>Authentication Successful!</h2>
+                <p>You can now close this tab and return to the application.</p>
+            </div>
+            <script>
+                setTimeout(function() {
+                    window.close();
+                }, 3000);
+            </script>
+        </body>
+        </html>
+        """
+        
+    except Exception as e:
+        logger.error(f"Error in auth callback: {str(e)}")
+        return f"""
+        <html>
+        <head>
+            <style>
+                body {{
+                    font-family: 'Inter', sans-serif;
+                    background: linear-gradient(135deg, #0f0f23 0%, #1a1a3e 100%);
+                    color: white;
+                    display: flex;
+                    justify-content: center;
+                    align-items: center;
+                    height: 100vh;
+                    margin: 0;
+                }}
+                .container {{
+                    text-align: center;
+                    background: rgba(255, 255, 255, 0.05);
+                    backdrop-filter: blur(20px);
+                    border: 1px solid rgba(255, 255, 255, 0.1);
+                    border-radius: 20px;
+                    padding: 50px;
+                    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+                }}
+                h2 {{
+                    color: #FF1744;
+                    font-size: 32px;
+                    margin-bottom: 20px;
+                }}
+                p {{
+                    font-size: 16px;
+                    color: rgba(255, 255, 255, 0.7);
+                }}
+                .icon {{
+                    font-size: 80px;
+                    margin-bottom: 20px;
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <div class="icon">❌</div>
+                <h2>Authentication Failed</h2>
+                <p>{str(e)}</p>
+            </div>
+        </body>
+        </html>
+        """, 500
+
+@app.route('/download', methods=['POST'])
+def download_reel():
+    """Download reel only"""
+    try:
+        data = request.get_json(silent=True) or {}
+        reel_url = data.get('url') or request.form.get('url') or request.args.get('url')
+        
+        if not reel_url:
+            return jsonify({'success': False, 'error': 'URL is required'})
+        
+        # Get sessionid from environment
+        sessionid = os.getenv("IG_SESSIONID")
+        if not sessionid:
+            return jsonify({
+                'success': False, 
+                'error': 'IG_SESSIONID not configured. Please add it to your .env file.'
+            })
+        
+        # Validate sessionid format
+        if len(sessionid) < 20 or not sessionid.replace('%', '').replace(':', '').isalnum():
+            return jsonify({
+                'success': False,
+                'error': 'IG_SESSIONID appears to be invalid. Please update it in the .env file.'
+            })
+        
+        # Download the reel
+        try:
+            video_path = download_reel_with_audio(reel_url, DOWNLOAD_FOLDER, sessionid)
+        except Exception as download_error:
+            error_msg = str(download_error)
+            # Check for Instagram authentication errors
+            if "403" in error_msg or "Forbidden" in error_msg or "metadata failed" in error_msg.lower():
+                return jsonify({
+                    'success': False,
+                    'error': 'Instagram session expired or invalid',
+                    'details': 'Please update your IG_SESSIONID:\n1. Log into Instagram\n2. Copy sessionid cookie from browser\n3. Update .env file\n4. Restart app'
+                })
+            elif "Login required" in error_msg or "Not logged in" in error_msg:
+                return jsonify({
+                    'success': False,
+                    'error': 'Instagram login required. Session expired.',
+                    'details': 'Please update IG_SESSIONID in .env file'
+                })
+            else:
+                return jsonify({'success': False, 'error': f'Download failed: {error_msg}'})
+        
+        if not video_path or not os.path.exists(video_path):
+            return jsonify({'success': False, 'error': 'Failed to download video'})
+        
+        filename = os.path.basename(video_path)
+        
+        return jsonify({
+            'success': True,
+            'message': 'Download completed',
+            'filename': filename,
+            'filepath': video_path
+        })
+        
+    except Exception as e:
+        logger.error(f"Download error: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/auto-upload-async', methods=['POST'])
+def auto_upload_async():
+    """Start async upload process for current user"""
+    try:
+        # ✅ Check user-specific authentication
+        token_path = get_user_token_path()
+        if not check_authentication(token_path):
+            return jsonify({'success': False, 'error': 'Not authenticated with YouTube'}), 401
+        
+        data = request.get_json(silent=True) or {}
+        reel_url = data.get('url') or request.form.get('url') or request.args.get('url')
+        editing_options = data.get('editing')
+        
+        if not reel_url:
+            return jsonify({'success': False, 'error': 'URL is required'})
+        
+        task_id = str(uuid.uuid4())
+        tasks[task_id] = TaskStatus(task_id)
+        
+        # ✅ Pass user token path to background task
+        thread = threading.Thread(
+            target=background_upload_task,
+            args=(task_id, reel_url, editing_options, token_path)
+        )
+        thread.daemon = True
+        thread.start()
+        
+        return jsonify({
+            'success': True,
+            'task_id': task_id,
+            'message': 'Upload process started'
+        })
+        
+    except Exception as e:
+        logger.error(f"Auto upload error: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/task-status/<task_id>')
+def get_task_status(task_id):
+    """Get task status"""
+    try:
+        if task_id not in tasks:
+            return jsonify({'success': False, 'error': 'Task not found'})
+        
+        task = tasks[task_id]
+        
+        return jsonify({
+            'success': True,
+            'task': {
+                'id': task.task_id,
+                'status': task.status,
+                'message': task.message,
+                'progress': task.progress,
+                'error': task.error,
+                'result': task.result,
+                'metadata': task.metadata,
+                'youtube_url': task.youtube_url
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Error getting task status: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/get-video/<filename>')
+def get_video(filename):
+    """Download video file"""
+    try:
+        # Security: Only allow files from downloads folder
+        safe_filename = os.path.basename(filename)
+        file_path = os.path.join(DOWNLOAD_FOLDER, safe_filename)
+        
+        logger.info(f"Serving video request for: {safe_filename}")
+        logger.info(f"Full path: {file_path}")
+        logger.info(f"File exists: {os.path.exists(file_path)}")
+        
+        if not os.path.exists(file_path):
+            logger.error(f"File not found: {file_path}")
+            # List available files for debugging
+            available_files = os.listdir(DOWNLOAD_FOLDER) if os.path.exists(DOWNLOAD_FOLDER) else []
+            logger.error(f"Available files: {available_files}")
+            return jsonify({
+                'error': 'File not found',
+                'requested': safe_filename,
+                'available': available_files
+            }), 404
+        
+        # Verify it's a video file
+        if not file_path.lower().endswith(('.mp4', '.mov', '.avi', '.mkv', '.webm')):
+            logger.error(f"Invalid file type: {file_path}")
+            return jsonify({'error': 'Invalid file type'}), 400
+        
+        # Get file size for logging
+        file_size = os.path.getsize(file_path)
+        logger.info(f"Serving file: {safe_filename} ({file_size} bytes)")
+        
+        # Serve the file with proper headers
+        return send_file(
+            file_path,
+            mimetype='video/mp4',
+            as_attachment=True,
+            download_name=safe_filename
+        )
+        
+    except Exception as e:
+        logger.error(f"Error serving video: {str(e)}")
+        import traceback
+        logger.error(traceback.format_exc())
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/cleanup/<filename>', methods=['POST'])
+def cleanup_file(filename):
+    """Clean up downloaded file after user has downloaded it"""
+    try:
+        safe_filename = os.path.basename(filename)
+        file_path = os.path.join(DOWNLOAD_FOLDER, safe_filename)
+        
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            logger.info(f"Cleaned up file: {file_path}")
+            return jsonify({'success': True, 'message': 'File cleaned up'})
+        else:
+            return jsonify({'success': False, 'error': 'File not found'})
+            
+    except Exception as e:
+        logger.error(f"Error cleaning up file: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/list-downloads')
+def list_downloads():
+    """List all files in downloads folder (for debugging)"""
+    try:
+        files = os.listdir(DOWNLOAD_FOLDER)
+        files_info = []
+        for f in files:
+            filepath = os.path.join(DOWNLOAD_FOLDER, f)
+            files_info.append({
+                'name': f,
+                'size': os.path.getsize(filepath),
+                'exists': os.path.exists(filepath)
+            })
+        return jsonify({'files': files_info})
+    except Exception as e:
+        return jsonify({'error': str(e)})
+
+@app.route('/generate-preview', methods=['POST'])
+def generate_preview():
+    """Generate metadata preview by downloading and analyzing video"""
+    try:
+        data = request.get_json(silent=True) or {}
+        reel_url = data.get('url') or request.form.get('url') or request.args.get('url')
+        
+        if not reel_url:
+            return jsonify({'success': False, 'error': 'URL is required'})
+        
+        # Get sessionid from environment
+        sessionid = os.getenv("IG_SESSIONID")
+        if not sessionid:
+            return jsonify({
+                'success': False, 
+                'error': 'IG_SESSIONID not configured in .env file'
+            })
+        
+        # Validate sessionid format
+        if len(sessionid) < 20:
+            return jsonify({
+                'success': False,
+                'error': 'IG_SESSIONID appears to be invalid. Please update it in .env file.'
+            })
+        
+        # Download video temporarily for analysis
+        temp_video_path = None
+        try:
+            # Download the video for analysis
+            try:
+                temp_video_path = download_reel_with_audio(reel_url, DOWNLOAD_FOLDER, sessionid)
+            except Exception as download_error:
+                error_msg = str(download_error)
+                if "403" in error_msg or "Forbidden" in error_msg or "metadata failed" in error_msg.lower():
+                    return jsonify({
+                        'success': False,
+                        'error': 'Instagram session expired',
+                        'details': 'Please update your IG_SESSIONID in the .env file and restart the app'
+                    })
+                else:
+                    raise download_error
+            
+            # Create AI Metadata Generator instance
+            ai_generator = AIMetadataGenerator(GEMINI_API_KEY)
+            
+            # Generate metadata based on actual video content
+            generated_metadata = ai_generator.generate_complete_metadata(
+                video_path=temp_video_path,
+                target_audience="social media users"
+            )
+            
+            return jsonify({
+                'success': True,
+                'title': generated_metadata['title'],
+                'description': generated_metadata['description'],
+                'tags': generated_metadata['tags'],
+                'hashtags': generated_metadata['hashtags'],
+                'video_analysis': generated_metadata.get('video_analysis', 'Analysis unavailable')
+            })
+            
+        except Exception as e:
+            logger.warning(f"AI metadata generation preview failed: {str(e)}")
+            # Fallback metadata
+            return jsonify({
+                'success': True,
+                'title': 'Amazing Social Media Content',
+                'description': f'Check out this amazing content from social media!\n\nSource: {reel_url}\n\n#SocialMedia #Viral #Content',
+                'tags': ['social media', 'viral', 'entertainment', 'content'],
+                'hashtags': ['#SocialMedia', '#Viral', '#Content', '#Entertainment']
+            })
+        finally:
+            # Clean up temporary file
+            if temp_video_path and os.path.exists(temp_video_path):
+                try:
+                    os.remove(temp_video_path)
+                except Exception:
+                    pass
+        
+    except Exception as e:
+        logger.error(f"Preview generation error: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/get-channel-info')
+def channel_info():
+    """Get information about the connected YouTube channel for current user"""
+    try:
+        token_path = get_user_token_path()
+        if not check_authentication(token_path):
+            return jsonify({'authenticated': False})
+            
+        channel_data = get_channel_info(token_path)
+        if channel_data:
+            return jsonify({
+                'authenticated': True,
+                'channel': channel_data
+            })
+        else:
+            return jsonify({'authenticated': True, 'channel': None})
+    except Exception as e:
+        logger.error(f"Error getting channel info: {str(e)}")
+        return jsonify({'authenticated': False, 'error': str(e)})
+
+@app.route('/logout', methods=['POST'])
+def logout():
+    """Logout from YouTube for current user"""
+    try:
+        token_path = get_user_token_path()
+        success = logout_youtube(token_path)
+        
+        # ✅ Clear user session
+        if success and os.path.exists(token_path):
+            os.remove(token_path)
+            session.pop('user_id', None)
+        
+        return jsonify({'success': success})
+    except Exception as e:
+        logger.error(f"Error during logout: {str(e)}")
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/privacy-policy')
+def privacy_policy():
+    """Privacy policy page"""
+    from datetime import datetime
+    return render_template('privacy_policy.html', current_date=datetime.now().strftime('%B %d, %Y'))
+
+@app.route('/terms')
+def terms():
+    """Terms of service page"""
+    return render_template('terms.html')
+
+# ✅ Production configuration with better error handling
+if os.getenv('SPACE_ID'):  # Running on Hugging Face Spaces
+    print("🌐 Running on Hugging Face Spaces")
+    os.environ['ENVIRONMENT'] = 'production'
+    
+    # Allow insecure transport for Hugging Face internal routing
+    os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+    
+    # Hugging Face specific settings
+    app.config['SESSION_COOKIE_SECURE'] = False  # HF uses internal HTTP routing
+    app.config['SESSION_COOKIE_HTTPONLY'] = True
+    app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
+    
+    # Session configuration
+    app.config['SESSION_TYPE'] = 'filesystem'
+    app.config['SESSION_FILE_DIR'] = '/tmp/flask_session'
+    app.config['SESSION_PERMANENT'] = False
+    app.config['SESSION_USE_SIGNER'] = True
+    app.config['PERMANENT_SESSION_LIFETIME'] = 3600
+    
+    # Create session directory
+    os.makedirs('/tmp/flask_session', exist_ok=True)
+    
+    PORT = 7860  # Hugging Face Spaces port
+    app.debug = False
+    
+    print(f"📡 Port: {PORT}")
+    print("🔐 Secure sessions enabled")
+
+elif os.getenv('ENVIRONMENT') == 'production':
+    # Disable insecure transport in production
+    if 'OAUTHLIB_INSECURE_TRANSPORT' in os.environ:
+        del os.environ['OAUTHLIB_INSECURE_TRANSPORT']
+    
+    # Set secure session
+    app.config['SESSION_COOKIE_SECURE'] = True
+    app.config['SESSION_COOKIE_HTTPONLY'] = True
+    app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
+    
+    # Session configuration
+    app.config['SESSION_TYPE'] = 'filesystem'
+    app.config['SESSION_FILE_DIR'] = '/tmp/flask_session'
+    app.config['SESSION_PERMANENT'] = False
+    app.config['SESSION_USE_SIGNER'] = True
+    app.config['PERMANENT_SESSION_LIFETIME'] = 3600
+    
+    # Create session directory
+    os.makedirs('/tmp/flask_session', exist_ok=True)
+    
+    # ✅ FIX: Use PORT from environment (Render provides this)
+    # Render sets PORT to 10000 by default
+    PORT = int(os.getenv('PORT', 5000))
+    
+    # Disable debug mode
+    app.debug = False
+else:
+    # Development mode
+    os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+    PORT = int(os.getenv('PORT', 5000))
+    
+    # Session configuration for development
+    app.config['SESSION_TYPE'] = 'filesystem'
+    app.config['SESSION_PERMANENT'] = False
+    app.config['SESSION_USE_SIGNER'] = True
+    app.config['PERMANENT_SESSION_LIFETIME'] = 3600
+
+# Secret key for sessions - MUST be set for production
+app.secret_key = os.getenv('SECRET_KEY', secrets.token_hex(32))
+
+# ✅ Global error handlers
+@app.errorhandler(404)
+def not_found(error):
+    if request.path.startswith('/api/'):
+        return jsonify({'error': 'Endpoint not found'}), 404
+    return render_template('404.html'), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    logger.error(f"Internal server error: {str(error)}")
+    if request.path.startswith('/api/'):
+        return jsonify({'error': 'Internal server error', 'message': 'Please try again later'}), 500
+    return render_template('500.html'), 500
+
+@app.errorhandler(Exception)
+def handle_exception(e):
+    logger.error(f"Unhandled exception: {str(e)}")
+    import traceback
+    logger.error(traceback.format_exc())
+    
+    if request.path.startswith('/api/'):
+        return jsonify({
+            'error': 'An unexpected error occurred',
+            'message': str(e) if app.debug else 'Please try again later'
+        }), 500
+    
+    return render_template('500.html'), 500
+
+# ✅ Health check with detailed status
+@app.route('/health')
+def health_check():
+    """Health check endpoint for monitoring"""
+    try:
+        health_status = {
+            'status': 'healthy',
+            'version': '1.0.0',
+            'environment': os.getenv('ENVIRONMENT', 'development'),
+            'checks': {
+                'downloads_folder': os.path.exists(DOWNLOAD_FOLDER),
+                'user_tokens_folder': os.path.exists(USER_TOKENS_FOLDER),
+                'gemini_configured': bool(GEMINI_API_KEY and GEMINI_API_KEY != 'your-gemini-api-key-here'),
+                'ig_session_configured': bool(os.getenv('IG_SESSIONID') and len(os.getenv('IG_SESSIONID', '')) > 20)
+            }
+        }
+        
+        # Check if all critical services are OK
+        if not all(health_status['checks'].values()):
+            health_status['status'] = 'degraded'
+            return jsonify(health_status), 503
+        
+        return jsonify(health_status), 200
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}")
+        return jsonify({
+            'status': 'unhealthy',
+            'error': str(e)
+        }), 503
+
+# ✅ Request logging middleware
+@app.before_request
+def log_request():
+    """Log incoming requests"""
+    if not request.path.startswith('/static/'):
+        logger.info(f"{request.method} {request.path} - {request.remote_addr}")
+
+@app.after_request
+def log_response(response):
+    """Log responses"""
+    if not request.path.startswith('/static/'):
+        logger.info(f"{request.method} {request.path} - {response.status_code}")
+    return response
+
+# ✅ Startup validation
+def validate_environment():
+    """Validate critical environment variables"""
+    issues = []
+    
+    if not os.getenv('SECRET_KEY') and os.getenv('ENVIRONMENT') == 'production':
+        issues.append("SECRET_KEY not set (will use generated key)")
+    
+    if not os.getenv('GEMINI_API_KEY'):
+        issues.append("GEMINI_API_KEY not set - AI features will use fallback")
+    
+    if not os.getenv('IG_SESSIONID'):
+        issues.append("IG_SESSIONID not set - Instagram downloads will fail")
+    
+    if not os.path.exists('client_secret.json'):
+        issues.append("client_secret.json not found - YouTube authentication will fail")
+    
+    if issues:
+        logger.warning("⚠️  Environment validation issues:")
+        for issue in issues:
+            logger.warning(f"   - {issue}")
+    else:
+        logger.info("✅ Environment validation passed")
+
+if __name__ == "__main__":
+    print(f"🚀 YouTube Automation Machine Starting...")
+    print(f"📁 Downloads folder: {DOWNLOAD_FOLDER}")
+    print(f"📁 User tokens folder: {USER_TOKENS_FOLDER}")
+    print(f"🤖 Gemini AI: {'Configured' if GEMINI_API_KEY and GEMINI_API_KEY != 'your-gemini-api-key-here' else 'Not configured (using fallback)'}")
+
+    # Validate Instagram session
+    ig_session = os.getenv("IG_SESSIONID")
+    if ig_session and len(ig_session) > 20:
+        print(f"📸 Instagram Session: Configured (length: {len(ig_session)})")
+    else:
+        print("⚠️  Instagram Session: NOT CONFIGURED or INVALID")
+        print("   Please add IG_SESSIONID to your environment variables")
+
+    # Check environment
+    environment = os.getenv('ENVIRONMENT', 'development')
+    if environment == 'production':
+        print("🌐 Running in PRODUCTION mode (Render)")
+        print(f"📡 Port: {PORT}")
+        print("🔒 HTTPS enabled")
+        print("🔐 Secure sessions enabled")
+    else:
+        print("⚠️  Running in DEVELOPMENT mode")
+        print(f"📡 Port: {PORT}")
+    
+    print()
+    
+    # Validate environment
+    validate_environment()
+    
+    # Run with appropriate settings
+    debug = environment != 'production'
+    
+    # ✅ FIX: Bind to 0.0.0.0 and use PORT already configured above
+    app.run(host='0.0.0.0', port=PORT, debug=debug, threaded=True)
+
+

downloader.py

@@ -0,0 +1,96 @@
+import instaloader
+import os
+import requests
+from urllib.parse import urlparse
+from dotenv import load_dotenv
+import time
+
+# Load environment variables from .env file
+load_dotenv()
+
+def extract_shortcode(reel_url: str) -> str:
+    """Extract shortcode from Instagram URL"""
+    path = urlparse(reel_url).path.strip("/")
+    parts = [p for p in path.split("/") if p]
+    if len(parts) >= 2 and parts[0] in {"reel", "p"}:
+        return parts[1]
+    return parts[-1] if parts else ""
+
+def download_reel_with_audio(reel_url: str, output_folder: str, sessionid: str) -> str:
+    """
+    Download Instagram reel with audio
+    Returns the full path to the downloaded video file
+    """
+    try:
+        L = instaloader.Instaloader()
+
+        # 🔑 Use sessionid from environment
+        L.context._session.cookies.set("sessionid", sessionid, domain=".instagram.com")
+
+        shortcode = extract_shortcode(reel_url)
+        post = instaloader.Post.from_shortcode(L.context, shortcode)
+
+        video_url = post.video_url
+        if not video_url and post.typename == "GraphSidecar":
+            for node in post.get_sidecar_nodes():
+                if node.is_video:
+                    video_url = node.video_url
+                    break
+
+        if not video_url:
+            raise Exception("No video URL found for this post")
+
+        # Ensure the filename is valid and doesn't have special characters
+        video_filename = f"reel_{int(time.time())}_{shortcode}.mp4"
+        video_path = os.path.join(output_folder, video_filename)
+
+        print("⬇️ Downloading video with audio...")
+        r = requests.get(video_url, stream=True)
+        with open(video_path, "wb") as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+        # Verify file was written correctly
+        if not os.path.exists(video_path):
+            raise Exception(f"Failed to save video to {video_path}")
+
+        file_size = os.path.getsize(video_path)
+        if file_size == 0:
+            raise Exception("Downloaded file is empty")
+
+        print(f"✅ Video saved successfully: {video_path} ({file_size} bytes)")
+        return video_path
+
+    except Exception as e:
+        raise Exception(f"Download failed: {str(e)}")
+
+def main():
+    print("Instagram Reel Downloader with Audio")
+    print("="*40)
+
+    try:
+        reel_url = input("Enter Instagram reel URL: ").strip()
+        if not reel_url:
+            print("No URL provided")
+            return
+
+        # Get sessionid from environment variable (now loaded from .env)
+        sessionid = os.getenv("IG_SESSIONID")
+        if not sessionid:
+            raise Exception("No IG_SESSIONID found! Please set in .env file.")
+
+        video_path = download_reel_with_audio(reel_url, "downloads", sessionid)
+
+        print(f"\n✅ Successfully downloaded with audio!")
+        print(f"📁 File location: {video_path}")
+        print(f"📊 File size: {os.path.getsize(video_path) / 1024 / 1024:.2f} MB")
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}")
+        print("\nTips:")
+        print("- Make sure IG_SESSIONID is set in the .env file")
+        print("- If expired, grab a new sessionid from Chrome cookies")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,30 @@
+# Flask Web Framework
+Flask==3.1.2
+Flask-Session==0.8.0
+gunicorn==23.0.0
+python-dotenv==1.1.1
+
+# Video Processing (CRITICAL - MoviePy and dependencies)
+moviepy==2.2.1
+imageio==2.37.0
+imageio-ffmpeg==0.6.0
+opencv-python-headless==4.12.0.88
+Pillow==11.3.0
+numpy==2.2.6
+proglog==0.1.12
+decorator==5.2.1
+
+# Instagram Downloader
+instaloader==4.14.2
+yt-dlp==2025.9.26
+
+# Google APIs & AI
+google-api-python-client==2.184.0
+google-auth==2.41.1
+google-auth-httplib2==0.2.0
+google-auth-oauthlib==1.2.2
+google-generativeai==0.8.5
+
+# Utilities
+requests==2.32.5
+tqdm==4.67.1

runtime.txt

@@ -0,0 +1 @@
+python-3.11.7

token.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9ba428bdff7d2fbfa5d935dce7f974a0650b838922b99d26371d86307fbef96
+size 1038

uploader.py

@@ -0,0 +1,289 @@
+import os
+import argparse
+import google_auth_oauthlib.flow
+import googleapiclient.discovery
+import googleapiclient.errors
+from googleapiclient.http import MediaFileUpload
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ✅ FIX: Allow insecure transport for local OAuth (development only)
+os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+
+def get_credentials(token_path='token.json'):
+    """Get or refresh YouTube API credentials for specific user"""
+    creds = None
+    
+    # The file token.json stores the user's access and refresh tokens.
+    if os.path.exists(token_path):
+        try:
+            creds = Credentials.from_authorized_user_file(token_path, 
+                ["https://www.googleapis.com/auth/youtube.upload"])
+        except Exception as e:
+            logger.error(f"Failed to load credentials: {e}")
+            if os.path.exists(token_path):
+                os.remove(token_path)
+            return None
+    
+    # If there are no (valid) credentials available, let the user log in.
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            try:
+                logger.info("Refreshing expired credentials...")
+                creds.refresh(Request())
+                # Save the refreshed credentials
+                with open(token_path, 'w') as token:
+                    token.write(creds.to_json())
+                logger.info("✅ Credentials refreshed successfully")
+            except Exception as e:
+                logger.error(f"Token refresh failed: {e}")
+                if os.path.exists(token_path):
+                    os.remove(token_path)
+                return None
+        else:
+            return None
+    
+    return creds
+
+def authenticate_youtube(token_path='token.json'):
+    """Authenticate with YouTube API - creates new credentials if needed"""
+    try:
+        scopes = ["https://www.googleapis.com/auth/youtube.upload"]
+        client_secrets_file = "client_secret.json"
+        
+        if not os.path.exists(client_secrets_file):
+            raise Exception("client_secret.json file not found. Please download it from Google Cloud Console.")
+        
+        logger.info("Starting OAuth flow...")
+        flow = google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file(
+            client_secrets_file, scopes)
+        
+        # Try local server auth first
+        try:
+            logger.info("Attempting local server authentication...")
+            credentials = flow.run_local_server(
+                host='localhost',
+                port=8080,
+                prompt='consent',
+                authorization_prompt_message='Please visit this URL to authorize: {url}',
+                success_message='✅ Authentication successful! You may close this window.',
+                open_browser=True
+            )
+            logger.info("✅ Local server authentication successful")
+        except Exception as local_error:
+            logger.warning(f"Local server auth failed: {local_error}")
+            logger.info("Falling back to console-based authentication...")
+            flow.redirect_uri = 'urn:ietf:wg:oauth:2.0:oob'
+            auth_url, _ = flow.authorization_url(prompt='consent')
+            
+            print(f"\n📋 Please visit this URL to authorize:\n{auth_url}\n")
+            auth_code = input("Enter the authorization code: ").strip()
+            
+            if not auth_code:
+                raise Exception("No authorization code provided")
+            
+            flow.fetch_token(code=auth_code)
+            credentials = flow.credentials
+            logger.info("✅ Console-based authentication successful")
+        
+        # ✅ Save to specified token path
+        with open(token_path, 'w') as token:
+            token.write(credentials.to_json())
+        
+        logger.info(f"✅ Authentication complete and credentials saved to {token_path}!")
+        return credentials
+        
+    except Exception as e:
+        logger.error(f"Authentication failed: {str(e)}")
+        raise Exception(f"Authentication failed: {str(e)}")
+
+def check_authentication(token_path='token.json'):
+    """Check if valid YouTube authentication exists for specific user"""
+    try:
+        creds = get_credentials(token_path)
+        return creds is not None and creds.valid
+    except Exception:
+        return False
+
+def get_youtube_service(token_path='token.json'):
+    """Get authenticated YouTube service for specific user"""
+    creds = get_credentials(token_path)
+    if not creds:
+        raise Exception("Not authenticated. Please run authentication first.")
+    
+    return googleapiclient.discovery.build("youtube", "v3", credentials=creds)
+
+def upload_to_youtube(video_path, title, description, tags, privacy_status="public", category_id="22", token_path='token.json'):
+    """Upload video to YouTube with proper error handling for specific user"""
+    try:
+        # Verify file exists and is accessible
+        if not os.path.exists(video_path):
+            raise Exception(f"Video file not found: {video_path}")
+        
+        # Get file size for validation
+        file_size = os.path.getsize(video_path)
+        if file_size == 0:
+            raise Exception("Video file is empty")
+        
+        print(f"Uploading video: {os.path.basename(video_path)} ({file_size / 1024 / 1024:.2f} MB)")
+        print(f"Privacy status: {privacy_status}")
+        
+        # ✅ Get YouTube service for specific user
+        youtube = get_youtube_service(token_path)
+
+        # Prepare video metadata
+        video_metadata = {
+            "snippet": {
+                "title": title[:100],  # YouTube title limit
+                "description": description[:5000],  # YouTube description limit
+                "tags": tags[:500] if isinstance(tags, list) else [],  # YouTube tags limit
+                "categoryId": str(category_id)
+            },
+            "status": {
+                "privacyStatus": privacy_status,
+                "selfDeclaredMadeForKids": False
+            }
+        }
+
+        # Create media upload object
+        media = MediaFileUpload(
+            video_path, 
+            chunksize=1024*1024,  # 1MB chunks
+            resumable=True,
+            mimetype="video/*"
+        )
+
+        # Create upload request
+        request = youtube.videos().insert(
+            part="snippet,status",
+            body=video_metadata,
+            media_body=media
+        )
+
+        # Execute upload with retry logic
+        response = None
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                print(f"Upload attempt {retry_count + 1}/{max_retries}")
+                response = request.execute()
+                break
+            except Exception as upload_error:
+                retry_count += 1
+                if retry_count >= max_retries:
+                    raise upload_error
+                print(f"Upload failed, retrying... Error: {str(upload_error)}")
+        
+        if not response or 'id' not in response:
+            raise Exception("Upload completed but no video ID returned")
+            
+        video_id = response["id"]
+        print(f"✅ Upload successful! Video ID: {video_id}")
+        print(f"🔗 Video URL: https://www.youtube.com/watch?v={video_id}")
+        
+        return video_id
+        
+    except Exception as e:
+        print(f"❌ Upload failed: {str(e)}")
+        raise Exception(f"Failed to upload video: {str(e)}")
+
+def get_channel_info(token_path='token.json'):
+    """Get information about the authenticated YouTube channel for specific user"""
+    try:
+        youtube = get_youtube_service(token_path)
+        
+        # Call the channels.list method to get the channel info
+        request = youtube.channels().list(
+            part="snippet,statistics",
+            mine=True
+        )
+        response = request.execute()
+        
+        if not response.get('items'):
+            return None
+            
+        channel = response['items'][0]
+        
+        # Extract relevant information
+        channel_info = {
+            'id': channel['id'],
+            'title': channel['snippet']['title'],
+            'description': channel['snippet'].get('description', ''),
+            'thumbnail': channel['snippet']['thumbnails'].get('default', {}).get('url', ''),
+            'subscriberCount': channel['statistics'].get('subscriberCount', '0'),
+            'videoCount': channel['statistics'].get('videoCount', '0'),
+            'viewCount': channel['statistics'].get('viewCount', '0')
+        }
+        
+        return channel_info
+    except Exception as e:
+        print(f"Error getting channel info: {e}")
+        return None
+
+def logout_youtube(token_path='token.json'):
+    """Revoke credentials and log out from YouTube for specific user"""
+    try:
+        if os.path.exists(token_path):
+            creds = Credentials.from_authorized_user_file(token_path)
+            
+            # Revoke the token
+            import google.oauth2.credentials
+            import google.auth.transport.requests
+            import requests
+            
+            transport = google.auth.transport.requests.Request()
+            
+            # Try to revoke the token
+            try:
+                requests.post(
+                    'https://oauth2.googleapis.com/revoke',
+                    params={'token': creds.token},
+                    headers={'content-type': 'application/x-www-form-urlencoded'}
+                )
+            except Exception as e:
+                print(f"Error revoking token: {e}")
+            
+            # Remove the token file
+            os.remove(token_path)
+            return True
+    except Exception as e:
+        print(f"Error during logout: {e}")
+    
+    return False
+
+def main():
+    parser = argparse.ArgumentParser(description='Upload a video to YouTube')
+    parser.add_argument('--video-path', required=True, help='Path to the video file')
+    parser.add_argument('--title', required=True, help='Title of the video')
+    parser.add_argument('--description', default='', help='Description of the video')
+    parser.add_argument('--tags', nargs='*', default=[], help='Tags for the video')
+    parser.add_argument('--privacy', default='public', choices=['private', 'unlisted', 'public'], 
+                      help='Privacy setting (default: public)')
+
+    args = parser.parse_args()
+    
+    if not os.path.exists(args.video_path):
+        print(f"Error: Video file not found at {args.video_path}")
+        return
+    
+    try:
+        video_id = upload_to_youtube(
+            video_path=args.video_path,
+            title=args.title,
+            description=args.description,
+            tags=args.tags,
+            privacy_status=args.privacy
+        )
+        print(f"Video uploaded successfully! Video ID: {video_id}")
+    except Exception as e:
+        print(f"Error uploading video: {str(e)}")
+
+if __name__ == "__main__":
+    main()

video_editor.py

@@ -0,0 +1,467 @@
+import os
+import logging
+import warnings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Suppress MoviePy warnings about frame reading
+warnings.filterwarnings('ignore', category=UserWarning, module='moviepy')
+
+try:
+    from moviepy.editor import VideoFileClip, AudioFileClip, ImageClip, CompositeVideoClip, concatenate_audioclips
+    from moviepy.audio.AudioClip import CompositeAudioClip
+    from moviepy.audio.fx.volumex import volumex
+    MOVIEPY_AVAILABLE = True
+    logger.info("✅ MoviePy loaded successfully")
+except ImportError as e:
+    logger.error(f"❌ MoviePy not available: {e}")
+    MOVIEPY_AVAILABLE = False
+
+try:
+    import yt_dlp
+    YT_DLP_AVAILABLE = True
+    logger.info("✅ yt-dlp loaded successfully")
+except ImportError as e:
+    logger.error(f"❌ yt-dlp not available: {e}")
+    YT_DLP_AVAILABLE = False
+
+try:
+    from PIL import Image, ImageDraw, ImageFont
+    import numpy as np
+    PIL_AVAILABLE = True
+    logger.info("✅ PIL (Pillow) loaded successfully")
+except ImportError as e:
+    logger.error(f"❌ PIL not available: {e}")
+    PIL_AVAILABLE = False
+
+class VideoEditor:
+    def __init__(self, temp_folder='temp_audio'):
+        if not MOVIEPY_AVAILABLE:
+            raise ImportError("MoviePy is required for video editing. Install with: pip install moviepy")
+        
+        self.temp_folder = temp_folder
+        os.makedirs(temp_folder, exist_ok=True)
+        logger.info(f"✅ VideoEditor initialized with temp folder: {temp_folder}")
+    
+    def download_youtube_audio(self, youtube_url):
+        """Download audio from YouTube video"""
+        if not YT_DLP_AVAILABLE:
+            raise ImportError("yt-dlp is required. Install with: pip install yt-dlp")
+        
+        try:
+            audio_path = os.path.join(self.temp_folder, 'background_music.m4a')
+            
+            # Remove old file if exists
+            if os.path.exists(audio_path):
+                os.remove(audio_path)
+            
+            # Also check for mp3 version
+            mp3_path = os.path.join(self.temp_folder, 'background_music.mp3')
+            if os.path.exists(mp3_path):
+                os.remove(mp3_path)
+            
+            ydl_opts = {
+                'format': 'bestaudio/best',
+                'outtmpl': os.path.join(self.temp_folder, 'background_music.%(ext)s'),
+                'quiet': True,
+                'no_warnings': True
+            }
+            
+            logger.info(f"📥 Downloading audio from: {youtube_url}")
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:  # type: ignore
+                info = ydl.extract_info(youtube_url, download=True)
+                ext = info.get('ext', 'm4a')
+                actual_path = os.path.join(self.temp_folder, f'background_music.{ext}')
+            
+            # Check which file was created
+            if os.path.exists(actual_path):
+                logger.info(f"✅ Downloaded audio from YouTube: {actual_path}")
+                return actual_path
+            elif os.path.exists(audio_path):
+                logger.info(f"✅ Downloaded audio from YouTube: {audio_path}")
+                return audio_path
+            elif os.path.exists(mp3_path):
+                logger.info(f"✅ Downloaded audio from YouTube: {mp3_path}")
+                return mp3_path
+            else:
+                raise Exception("Audio file was not created")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to download YouTube audio: {str(e)}")
+            raise Exception(f"Failed to download music: {str(e)}")
+    
+    def add_background_music(self, video, audio_path, volume=0.3):
+        """Add background music to video with volume control"""
+        background_audio = None
+        try:
+            logger.info(f"🎵 Adding background music to video from: {audio_path}")
+            
+            # Check if audio_path is a local file or needs to be downloaded
+            if not os.path.exists(audio_path):
+                raise Exception(f"Audio file not found: {audio_path}")
+            
+            background_audio = AudioFileClip(audio_path)
+            
+            # Adjust background music duration to match video
+            if background_audio.duration > video.duration:
+                background_audio = background_audio.subclip(0, video.duration)
+            else:
+                # Loop if music is shorter than video
+                loops_needed = int(video.duration / background_audio.duration) + 1
+                background_audio = concatenate_audioclips([background_audio] * loops_needed).subclip(0, video.duration)
+            # Set background music volume
+            background_audio = volumex(background_audio, volume)
+            
+            # Replace original audio with background music (mute original)
+            video = video.set_audio(background_audio)
+            
+            logger.info("✅ Added background music to video (original audio muted)")
+            return video
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to add background music: {str(e)}")
+            raise Exception(f"Failed to add music: {str(e)}")
+    
+    def add_text_overlay(self, video, text, position='top', fontsize=50, color='white', 
+                         bg_color='black', duration=None):
+        """Add text overlay to video using PIL (no ImageMagick needed)"""
+        try:
+            if not PIL_AVAILABLE:
+                raise ImportError("PIL (Pillow) is required. Install with: pip install Pillow")
+            
+            if duration is None:
+                duration = video.duration
+            
+            logger.info(f"📝 Adding text overlay: {text[:30]}...")
+            
+            # Create an image with text using PIL
+            img_width, img_height = video.size
+            img = Image.new('RGBA', (img_width, img_height), (0, 0, 0, 0))
+            draw = ImageDraw.Draw(img)
+            
+            # Try to use a default font, fall back to default if not available
+            try:
+                font = ImageFont.truetype("arial.ttf", fontsize)
+            except:
+                try:
+                    font = ImageFont.truetype("Arial.ttf", fontsize)
+                except:
+                    try:
+                        # For Windows
+                        font = ImageFont.truetype("C:/Windows/Fonts/arial.ttf", fontsize)
+                    except:
+                        logger.warning("⚠️ Could not load Arial font, using default")
+                        font = ImageFont.load_default()
+            
+            # Get text bounding box
+            bbox = draw.textbbox((0, 0), text, font=font)
+            text_width = bbox[2] - bbox[0]
+            text_height = bbox[3] - bbox[1]
+            
+            # Position mapping
+            if position == 'top':
+                x = (img_width - text_width) // 2
+                y = 50
+            elif position == 'bottom':
+                x = (img_width - text_width) // 2
+                y = img_height - text_height - 50
+            elif position == 'center':
+                x = (img_width - text_width) // 2
+                y = (img_height - text_height) // 2
+            elif position == 'top-left':
+                x = 50
+                y = 50
+            elif position == 'top-right':
+                x = img_width - text_width - 50
+                y = 50
+            else:
+                x = (img_width - text_width) // 2
+                y = 50
+            
+            # Parse colors
+            color_map = {
+                'white': (255, 255, 255),
+                'black': (0, 0, 0),
+                'red': (255, 0, 0),
+                'blue': (0, 0, 255),
+                'green': (0, 255, 0),
+                'yellow': (255, 255, 0)
+            }
+            text_color = color_map.get(color.lower(), (255, 255, 255))
+            stroke_color = color_map.get(bg_color.lower(), (0, 0, 0))
+            
+            # Draw text with stroke (outline)
+            stroke_width = 3
+            for adj_x in range(-stroke_width, stroke_width + 1):
+                for adj_y in range(-stroke_width, stroke_width + 1):
+                    draw.text((x + adj_x, y + adj_y), text, font=font, fill=stroke_color)
+            
+            # Draw main text
+            draw.text((x, y), text, font=font, fill=text_color)
+            
+            # Convert PIL image to numpy array
+            img_array = np.array(img)
+            
+            # Create ImageClip from the array
+            txt_clip = ImageClip(img_array, transparent=True)
+            txt_clip = txt_clip.set_duration(duration)
+            
+            # Add fade in/out effects
+            txt_clip = txt_clip.fadein(0.5).fadeout(0.5)
+            
+            # Composite video with text
+            video = CompositeVideoClip([video, txt_clip])
+            
+            logger.info(f"✅ Added text overlay: {text}")
+            return video
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to add text overlay: {str(e)}")
+            raise Exception(f"Failed to add text: {str(e)}")
+    
+    def edit_video(self, video_path, output_path, music_url=None, music_volume=0.3,
+                   text_overlays=None):
+        """
+        Complete video editing with music and text overlays
+        
+        Args:
+            video_path: Path to input video
+            output_path: Path for output video
+            music_url: YouTube URL OR local file path for background music
+            music_volume: Volume of background music (0.0 to 1.0)
+            text_overlays: List of dict with keys: text, position, duration
+        """
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        
+        # Ensure output path is a file, not a directory
+        if os.path.isdir(output_path):
+            video_filename = os.path.basename(video_path)
+            output_path = os.path.join(output_path, os.path.splitext(video_filename)[0] + "_edited.mp4")
+            logger.info(f"Output is a directory, saving to: {output_path}")
+        
+        video = None
+        audio_path = None
+        try:
+            logger.info(f"🎬 Starting video editing for: {video_path}")
+            
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                video = VideoFileClip(video_path)
+            
+            logger.info(f"📊 Video info: {video.duration:.2f}s, {video.size[0]}x{video.size[1]}")
+            
+            # ✅ NEW: Handle both YouTube URLs and local files
+            if music_url:
+                # Check if it's a local file or YouTube URL
+                if os.path.exists(music_url):
+                    # It's a local file
+                    logger.info(f"🎵 Using local music file: {music_url}")
+                    audio_path = music_url
+                elif music_url.startswith('http'):
+                    # It's a YouTube URL
+                    logger.info(f"🎵 Downloading music from YouTube: {music_url}")
+                    audio_path = self.download_youtube_audio(music_url)
+                else:
+                    raise Exception(f"Invalid music source: {music_url}")
+                
+                video = self.add_background_music(video, audio_path, music_volume)
+            
+            # Add text overlays if provided
+            if text_overlays and len(text_overlays) > 0:
+                logger.info(f"📝 Adding {len(text_overlays)} text overlays")
+                for i, overlay in enumerate(text_overlays):
+                    logger.info(f"Adding overlay {i+1}/{len(text_overlays)}: {overlay.get('text', 'N/A')[:30]}")
+                    video = self.add_text_overlay(
+                        video,
+                        text=overlay.get('text', 'Subscribe!'),
+                        position=overlay.get('position', 'top'),
+                        fontsize=overlay.get('fontsize', 50),
+                        color=overlay.get('color', 'white'),
+                        duration=overlay.get('duration', min(5, video.duration))
+                    )
+            
+            # Write output video
+            logger.info(f"💾 Writing edited video to: {output_path}")
+            logger.info(f"⏳ This may take a few minutes... Please wait.")
+            
+            # Suppress warnings during video writing
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                video.write_videofile(
+                    output_path,
+                    codec='libx264',
+                    audio_codec='aac',
+                    temp_audiofile='temp-audio.m4a',
+                    remove_temp=True,
+                    fps=30,
+                    preset='medium',
+                    threads=4,
+                    logger=None  # Suppress moviepy's verbose logging
+                )
+            
+            # Verify output file was created
+            if not os.path.exists(output_path):
+                raise Exception(f"Output video file was not created: {output_path}")
+            
+            file_size = os.path.getsize(output_path)
+            if file_size == 0:
+                raise Exception(f"Output video file is empty (0 bytes): {output_path}")
+            
+            file_size_mb = file_size / (1024 * 1024)
+            logger.info(f"✅ Video editing completed: {output_path}")
+            logger.info(f"📊 Output file size: {file_size_mb:.2f} MB")
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"❌ Video editing failed: {str(e)}")
+            import traceback
+            logger.error(traceback.format_exc())
+            raise Exception(f"Video editing failed: {str(e)}")
+        finally:
+            # Cleanup - close video and wait a bit for file handles to release
+            if video:
+                try:
+                    video.close()
+                    import time
+                    time.sleep(0.5)  # Give time for file handles to release
+                except:
+                    pass
+            
+            # Clean up temp files
+            self.cleanup_temp_files()
+
+    def cleanup_temp_files(self):
+        """Clean up temporary files"""
+        try:
+            import time
+            import gc
+            
+            # Force garbage collection to release file handles
+            gc.collect()
+            time.sleep(0.5)
+            
+            if os.path.exists(self.temp_folder):
+                for file in os.listdir(self.temp_folder):
+                    file_path = os.path.join(self.temp_folder, file)
+                    try:
+                        if os.path.isfile(file_path):
+                            os.remove(file_path)
+                            logger.debug(f"🧹 Removed temp file: {file_path}")
+                    except PermissionError:
+                        # File still in use, skip it
+                        logger.debug(f"⏭️ Skipping temp file (still in use): {file_path}")
+                    except Exception as e:
+                        logger.warning(f"⚠️ Failed to remove {file_path}: {e}")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to cleanup temp files: {str(e)}")
+
+
+def main():
+    """Main function to run video editor with user input"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Edit videos with background music and text overlays')
+    parser.add_argument('--video', type=str, help='Path to input video file')
+    parser.add_argument('--music', type=str, help='YouTube URL for background music')
+    parser.add_argument('--output', type=str, help='Path for output video file')
+    parser.add_argument('--volume', type=float, default=0.3, help='Music volume (0.0 to 1.0, default: 0.3)')
+    parser.add_argument('--text', type=str, help='Text overlay (optional)')
+    parser.add_argument('--text-position', type=str, default='top', 
+                       choices=['top', 'bottom', 'center', 'top-left', 'top-right'],
+                       help='Text position (default: top)')
+    
+    args = parser.parse_args()
+    
+    print("\n" + "="*60)
+    print("🎬 VIDEO EDITOR - Add Background Music & Text")
+    print("="*60 + "\n")
+    
+    # Get video path
+    if args.video:
+        video_path = args.video
+    else:
+        video_path = input("📹 Enter path to your video file: ").strip().strip('"')
+    
+    # Validate video path
+    if not os.path.exists(video_path):
+        print(f"❌ Error: Video file not found: {video_path}")
+        return
+    
+    # Get music URL
+    if args.music:
+        music_url = args.music
+    else:
+        music_url = input("🎵 Enter YouTube URL for background music (or press Enter to skip): ").strip()
+        if not music_url:
+            music_url = None
+    
+    # Get output path
+    if args.output:
+        output_path = args.output
+    else:
+        default_output = os.path.splitext(video_path)[0] + "_edited.mp4"
+        output_path = input(f"💾 Enter output path (press Enter for '{default_output}'): ").strip().strip('"')
+        if not output_path:
+            output_path = default_output
+    
+    # Get volume
+    music_volume = args.volume
+    
+    # Get text overlay
+    text_overlays = None
+    if args.text:
+        text_overlays = [{
+            'text': args.text,
+            'position': args.text_position,
+            'duration': None
+        }]
+    else:
+        add_text = input("📝 Add text overlay? (y/n, press Enter to skip): ").strip().lower()
+        if add_text == 'y':
+            text = input("Enter text: ").strip()
+            position = input("Position (top/bottom/center, default: top): ").strip() or 'top'
+            text_overlays = [{
+                'text': text,
+                'position': position,
+                'duration': None
+            }]
+    
+    # Process video
+    try:
+        print("\n" + "="*60)
+        print("🚀 Starting video editing...")
+        print("="*60 + "\n")
+        
+        editor = VideoEditor()
+        result = editor.edit_video(
+            video_path=video_path,
+            output_path=output_path,
+            music_url=music_url,
+            music_volume=music_volume,
+            text_overlays=text_overlays
+        )
+        
+        print("\n" + "="*60)
+        print(f"✅ SUCCESS! Video saved to: {result}")
+        
+        # Verify and display file info
+        if os.path.exists(result):
+            file_size_mb = os.path.getsize(result) / (1024 * 1024)
+            print(f"📁 File size: {file_size_mb:.2f} MB")
+            print(f"📂 Open folder: {os.path.dirname(result)}")
+        else:
+            print("⚠️ Warning: Output file path shown but file not found!")
+        
+        print("="*60 + "\n")
+        
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}\n")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()