Add Hugging Face Space support with streamlined README

- Rename video_trimmer_demo.py → app.py for HF Spaces
- Add HF metadata to README.md for Space deployment
- Separate documentation: README_DOCS.md for GitHub Pages
- Update GitHub Actions to use README_DOCS.md for docs site
- Maintain both GitHub repo and HF Space deployment options

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.github/workflows/pages.yml

@@ -21,7 +21,7 @@ jobs:
         
       - name: Copy README and assets to docs
         run: |
-          cp README.md docs/README.md
+          cp README_DOCS.md docs/index.md
           cp -r demo docs/
         
       - name: Setup Pages

README.md

@@ -1,284 +1,71 @@
-A fast and efficient video trimming toolkit with both a **web interface** and **command-line tool** for MP4 video processing. Features visual trimming with drag-to-scrub sliders and automatic audio extraction.
-
-**Documentation**: https://nipunbatra.github.io/video-toolkit/
-
-## Features
-
-- **Web Interface**: Interactive Gradio demo with drag-to-trim sliders
-- **Google Drive Integration**: Load videos from and upload results to Google Drive
-- **Command Line**: Fast bash script for automated processing  
-- **Smart Trimming**: Visual video scrubbing to find exact cut points
-- **Audio Extraction**: Automatic AAC extraction with built-in player
-- **Minimal Processing**: Stream copying when possible for speed
-- **Cross-Platform**: Works on macOS, Linux, and Windows WSL
-
-## Prerequisites
+---
+title: Video Trimmer Tool
+emoji: ✂️
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+license: mit
+---
 
-- **ffmpeg** (version 4.0 or higher) - The core dependency for video processing
-- **Bash shell** - Available on macOS, Linux, and Windows WSL
+# Video Trimmer Tool
 
-### Installing ffmpeg
+A fast and efficient video trimming toolkit with an interactive web interface for MP4 video processing. Features visual trimming with drag-to-scrub sliders and automatic audio extraction.
 
-| Platform | Command |
-|----------|---------|
-| macOS | `brew install ffmpeg` |
-| Ubuntu/Debian | `sudo apt update && sudo apt install ffmpeg` |
-| Fedora/CentOS | `sudo dnf install ffmpeg` |
-| Windows | Download from [ffmpeg.org](https://ffmpeg.org/download.html) or use `winget install FFmpeg` |
+🚀 **Try it live on Hugging Face Spaces!**
 
-## Installation
+📖 **Full Documentation**: https://nipunbatra.github.io/video-toolkit/
 
-### Quick Install (Recommended)
+## Quick Start
 
-**Step 1:** Download and make executable in one step
-```bash
-curl -O https://raw.githubusercontent.com/nipunbatra/video-toolkit/main/trim-convert.sh && chmod +x trim-convert.sh
-```
+### Hugging Face Spaces (Recommended)
+The easiest way to use this tool is through our Hugging Face Space - no installation required!
 
-**Step 2:** Verify the script works
-```bash
-./trim-convert.sh --help
-```
-
-### Manual Install
-
-**Step 1:** Clone this repository
+### Local Installation
 ```bash
 git clone https://github.com/nipunbatra/video-toolkit.git
 cd video-toolkit
-```
-
-**Step 2:** Make the script executable
-```bash
-chmod +x trim-convert.sh
-```
-
-**Note:** The `chmod +x` command grants execute permission to the script file. This is required for shell scripts to run.
-
-**Step 3:** Test the installation
-```bash
-./trim-convert.sh --help
-```
-
-### System-wide Installation (Optional)
-
-**Step 1:** Copy script to system directory
-```bash
-sudo cp trim-convert.sh /usr/local/bin/trim-convert
-```
-
-**Note:** The `sudo` command requires administrator privileges to copy files to system directories like `/usr/local/bin/`.
-
-**Step 2:** Test system-wide access
-```bash
-trim-convert --help
-```
-
-Now you can use `trim-convert` from any directory.
-
-## Gradio Web Interface
-
-For an interactive video trimming experience, use the web interface:
-
-![Video Trimmer Interface](demo/screenshot-ui.jpg)
-
-### Quick Start
-```bash
-# Install dependencies
 pip install -r requirements.txt
-
-# Launch the web interface
-./run_demo.sh
+python app.py
 ```
 
-### Features
-- **Video Upload**: Drag & drop MP4/MOV/AVI files or load from Google Drive
-- **Google Drive Integration**: Browse your entire Google Drive to pick videos
-- **Visual Trimming**: Scrub sliders to find exact start/end points
-- **Live Preview**: Video seeks to slider position for precise editing
-- **Audio Playback**: Built-in player for extracted audio
-- **Download**: Get both trimmed video and AAC audio files
-- **Google Drive Upload**: Upload trimmed files back to any folder in your Google Drive
-
-The web interface automatically converts times and calls the command-line script for processing.
-
-### Google Drive Setup (Optional)
-
-To enable Google Drive integration:
-
-1. **Create OAuth credentials**: Follow instructions in `SIMPLE_GOOGLE_SETUP.md`
-2. **Download `oauth_credentials.json`** and place in this directory
-3. **Run the app** - it will open your browser for one-time authentication
-4. **Done!** Browse your entire Google Drive and upload results back
-
-**Note**: Google Drive integration is completely optional - the app works perfectly without it.
-
-## File Permissions
-
-### Understanding Script Permissions
-
-Shell scripts require execute permission to run. When you download a script, it typically doesn't have execute permission by default for security reasons.
-
-### Setting Execute Permission
-
-```bash
-chmod +x trim-convert.sh
-```
-
-### Verifying Permissions
-
-Check if the script has execute permission:
-```bash
-ls -l trim-convert.sh
-```
-
-Look for `x` in the permissions (e.g., `-rwxr-xr-x`). The `x` indicates execute permission.
-
-### Common Permission Issues
-
-- **"Permission denied"**: Script lacks execute permission - run `chmod +x`
-- **"Operation not permitted"**: Need `sudo` for system directories
-- **"Command not found"**: Script not in current directory or PATH
-
-## Command Line Usage
-
-```bash
-./trim-convert.sh [options] input.mp4
-```
-
-### Options
-
-| Option | Description |
-|--------|-------------|
-| `-s, --start TIME` | Start time (format: HH:MM:SS or seconds) |
-| `-e, --end TIME` | End time (format: HH:MM:SS or seconds) |
-| `-o, --output PREFIX` | Output file prefix (default: "trimmed") |
-| `-h, --help` | Show help message |
-
-### Examples
-
-#### Basic Trimming
-```bash
-# Trim from 1m30s to 5m45s
-./trim-convert.sh -s 00:01:30 -e 00:05:45 video.mp4
-
-# Trim from start to 10 minutes
-./trim-convert.sh -e 00:10:00 video.mp4
-
-# Trim from 2 minutes to the end
-./trim-convert.sh -s 00:02:00 video.mp4
-```
-
-#### Advanced Usage
-```bash
-# Custom output name
-./trim-convert.sh -o my_clip -s 00:01:30 -e 00:05:45 video.mp4
-
-# Process entire file (extract audio only)
-./trim-convert.sh video.mp4
-
-# Using seconds instead of HH:MM:SS format
-./trim-convert.sh -s 90 -e 345 video.mp4
-
-# Batch processing multiple files
-for file in *.mp4; do
-    ./trim-convert.sh -s 00:00:10 -e 00:01:00 "$file"
-done
-```
-
-#### Time Format Options
-- **HH:MM:SS**: `00:01:30` (1 minute 30 seconds)
-- **MM:SS**: `01:30` (1 minute 30 seconds)
-- **Seconds**: `90` (90 seconds)
-- **Decimal seconds**: `90.5` (90.5 seconds)
-
-## How It Works
+## Features
 
-1. The script analyzes the input video to determine if it can use stream copying (no re-encoding) based on keyframe positioning
-2. It attempts to use the fastest method possible while maintaining quality
-3. If stream copying would result in imprecise cuts, it falls back to re-encoding
-4. The audio track is extracted as a separate AAC file
+- **Interactive Web Interface**: Visual video scrubbing with drag-to-trim sliders
+- **Smart Trimming**: Find exact cut points with real-time video seeking  
+- **Audio Extraction**: Automatic AAC extraction with built-in player
+- **Google Drive Integration**: Load videos from and upload results to Google Drive (local only)
+- **Multiple Formats**: Support for MP4, MOV, AVI, and MKV files
+- **Fast Processing**: Stream copying when possible for speed
+- **Command Line Tool**: Fast bash script for automated processing
 
-## Output
+## How to Use
 
-- `PREFIX.mp4`: The trimmed video file
-- `PREFIX.aac`: The extracted audio file
+1. **Upload Video**: Drag & drop your video file or click to upload
+2. **Set Trim Points**: Use the sliders to scrub through the video and find your desired start/end points
+3. **Trim**: Click "Trim Video" to process
+4. **Download**: Get your trimmed video and extracted audio files
 
 ## Technical Details
 
-- Uses ffmpeg's stream copying (`-c copy`) when possible to avoid quality loss
-- Falls back to high-quality, fast encoding when necessary (`-c:v libx264 -preset ultrafast -crf 17`)
-- Handles keyframe detection for optimal cutting points
-- Works with both relative (seconds) and absolute (HH:MM:SS) time formats
-
-## Demo Videos
-
-This repository includes sample copyright-free videos for testing:
-
-| File | Description | Source | License |
-|------|-------------|---------|---------|
-| `demo/sample-10s.mp4` | 10-second test pattern | Generated with ffmpeg | Public Domain |
-| `demo/sample-30s.mp4` | 30-second test pattern | Generated with ffmpeg | Public Domain |
-
-All demo videos are verified to be free to use, modify, and distribute.
-
-## Performance Notes
-
-- **Stream copying**: Fastest method, preserves original quality
-- **Re-encoding**: Used when precision is required, high-quality preset
-- **Memory usage**: Minimal - processes videos without loading entire file into memory
-- **Supported formats**: MP4, AVI, MOV, MKV (output always MP4)
-
-## Troubleshooting
+- Uses ffmpeg for high-quality video processing
+- Preserves original quality when possible through stream copying
+- Falls back to fast, high-quality encoding when precision is required
+- Outputs web-optimized MP4 video and AAC audio files
 
-### Common Issues
+## Supported Formats
 
-| Problem | Solution |
-|---------|----------|
-| "ffmpeg not found" | Install ffmpeg using your package manager |
-| "Permission denied" | Run `chmod +x trim-convert.sh` to make script executable |
-| "Invalid time format" | Use HH:MM:SS or seconds format |
-| "No keyframes found" | Video will be re-encoded (slower but precise) |
-| "Command not found" | Check if script is in current directory or PATH |
-| "Operation not permitted" | Use `sudo` for system-wide installation |
+- **Input**: MP4, MOV, AVI, MKV
+- **Output**: MP4 video + AAC audio
 
-### Performance Tips
+## Full Documentation
 
-- Use stream copying when possible by aligning cuts with keyframes
-- For bulk processing, consider processing multiple files in parallel
-- Use SSD storage for better I/O performance with large files
+For complete installation instructions, command-line usage, Google Drive setup, and advanced features, visit our documentation website:
 
-## Requirements
-
-- **ffmpeg** (version 4.0 or higher)
-- **Bash shell** (version 4.0 or higher recommended)
-- **Available disk space** equal to at least 2x the size of your largest video file
+**📖 https://nipunbatra.github.io/video-toolkit/**
 
 ## License
 
-MIT License - See [LICENSE](https://github.com/nipunbatra/video-toolkit/blob/main/LICENSE) file for details
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
----
-
-## 📖 Documentation Website
-
-This repository has an auto-generated documentation website at: **https://nipunbatra.github.io/video-toolkit**
-
-### How Documentation Works
-
-- **Single source**: Edit only this `README.md` file
-- **Auto-build**: GitHub Actions automatically updates the website
-- **No manual work**: Never touch the `docs/` folder
-- **Live updates**: Changes appear on the website when you push to main
-
-### Making Documentation Changes
-
-1. **Edit this file**: `README.md` (you're reading it now!)
-2. **Commit and push**: `git add . && git commit -m "Update docs" && git push`
-3. **Done**: Website updates automatically in ~2 minutes
-
-**⚠️ Important**: Never edit files in the `docs/` folder - they're auto-generated!
+MIT License - See [LICENSE](LICENSE) file for details.

README_DOCS.md

@@ -0,0 +1,284 @@
+A fast and efficient video trimming toolkit with both a **web interface** and **command-line tool** for MP4 video processing. Features visual trimming with drag-to-scrub sliders and automatic audio extraction.
+
+**Documentation**: https://nipunbatra.github.io/video-toolkit/
+
+## Features
+
+- **Web Interface**: Interactive Gradio demo with drag-to-trim sliders
+- **Google Drive Integration**: Load videos from and upload results to Google Drive
+- **Command Line**: Fast bash script for automated processing  
+- **Smart Trimming**: Visual video scrubbing to find exact cut points
+- **Audio Extraction**: Automatic AAC extraction with built-in player
+- **Minimal Processing**: Stream copying when possible for speed
+- **Cross-Platform**: Works on macOS, Linux, and Windows WSL
+
+## Prerequisites
+
+- **ffmpeg** (version 4.0 or higher) - The core dependency for video processing
+- **Bash shell** - Available on macOS, Linux, and Windows WSL
+
+### Installing ffmpeg
+
+| Platform | Command |
+|----------|---------|
+| macOS | `brew install ffmpeg` |
+| Ubuntu/Debian | `sudo apt update && sudo apt install ffmpeg` |
+| Fedora/CentOS | `sudo dnf install ffmpeg` |
+| Windows | Download from [ffmpeg.org](https://ffmpeg.org/download.html) or use `winget install FFmpeg` |
+
+## Installation
+
+### Quick Install (Recommended)
+
+**Step 1:** Download and make executable in one step
+```bash
+curl -O https://raw.githubusercontent.com/nipunbatra/video-toolkit/main/trim-convert.sh && chmod +x trim-convert.sh
+```
+
+**Step 2:** Verify the script works
+```bash
+./trim-convert.sh --help
+```
+
+### Manual Install
+
+**Step 1:** Clone this repository
+```bash
+git clone https://github.com/nipunbatra/video-toolkit.git
+cd video-toolkit
+```
+
+**Step 2:** Make the script executable
+```bash
+chmod +x trim-convert.sh
+```
+
+**Note:** The `chmod +x` command grants execute permission to the script file. This is required for shell scripts to run.
+
+**Step 3:** Test the installation
+```bash
+./trim-convert.sh --help
+```
+
+### System-wide Installation (Optional)
+
+**Step 1:** Copy script to system directory
+```bash
+sudo cp trim-convert.sh /usr/local/bin/trim-convert
+```
+
+**Note:** The `sudo` command requires administrator privileges to copy files to system directories like `/usr/local/bin/`.
+
+**Step 2:** Test system-wide access
+```bash
+trim-convert --help
+```
+
+Now you can use `trim-convert` from any directory.
+
+## Gradio Web Interface
+
+For an interactive video trimming experience, use the web interface:
+
+![Video Trimmer Interface](demo/screenshot-ui.jpg)
+
+### Quick Start
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Launch the web interface
+./run_demo.sh
+```
+
+### Features
+- **Video Upload**: Drag & drop MP4/MOV/AVI files or load from Google Drive
+- **Google Drive Integration**: Browse your entire Google Drive to pick videos
+- **Visual Trimming**: Scrub sliders to find exact start/end points
+- **Live Preview**: Video seeks to slider position for precise editing
+- **Audio Playback**: Built-in player for extracted audio
+- **Download**: Get both trimmed video and AAC audio files
+- **Google Drive Upload**: Upload trimmed files back to any folder in your Google Drive
+
+The web interface automatically converts times and calls the command-line script for processing.
+
+### Google Drive Setup (Optional)
+
+To enable Google Drive integration:
+
+1. **Create OAuth credentials**: Follow instructions in `SIMPLE_GOOGLE_SETUP.md`
+2. **Download `oauth_credentials.json`** and place in this directory
+3. **Run the app** - it will open your browser for one-time authentication
+4. **Done!** Browse your entire Google Drive and upload results back
+
+**Note**: Google Drive integration is completely optional - the app works perfectly without it.
+
+## File Permissions
+
+### Understanding Script Permissions
+
+Shell scripts require execute permission to run. When you download a script, it typically doesn't have execute permission by default for security reasons.
+
+### Setting Execute Permission
+
+```bash
+chmod +x trim-convert.sh
+```
+
+### Verifying Permissions
+
+Check if the script has execute permission:
+```bash
+ls -l trim-convert.sh
+```
+
+Look for `x` in the permissions (e.g., `-rwxr-xr-x`). The `x` indicates execute permission.
+
+### Common Permission Issues
+
+- **"Permission denied"**: Script lacks execute permission - run `chmod +x`
+- **"Operation not permitted"**: Need `sudo` for system directories
+- **"Command not found"**: Script not in current directory or PATH
+
+## Command Line Usage
+
+```bash
+./trim-convert.sh [options] input.mp4
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-s, --start TIME` | Start time (format: HH:MM:SS or seconds) |
+| `-e, --end TIME` | End time (format: HH:MM:SS or seconds) |
+| `-o, --output PREFIX` | Output file prefix (default: "trimmed") |
+| `-h, --help` | Show help message |
+
+### Examples
+
+#### Basic Trimming
+```bash
+# Trim from 1m30s to 5m45s
+./trim-convert.sh -s 00:01:30 -e 00:05:45 video.mp4
+
+# Trim from start to 10 minutes
+./trim-convert.sh -e 00:10:00 video.mp4
+
+# Trim from 2 minutes to the end
+./trim-convert.sh -s 00:02:00 video.mp4
+```
+
+#### Advanced Usage
+```bash
+# Custom output name
+./trim-convert.sh -o my_clip -s 00:01:30 -e 00:05:45 video.mp4
+
+# Process entire file (extract audio only)
+./trim-convert.sh video.mp4
+
+# Using seconds instead of HH:MM:SS format
+./trim-convert.sh -s 90 -e 345 video.mp4
+
+# Batch processing multiple files
+for file in *.mp4; do
+    ./trim-convert.sh -s 00:00:10 -e 00:01:00 "$file"
+done
+```
+
+#### Time Format Options
+- **HH:MM:SS**: `00:01:30` (1 minute 30 seconds)
+- **MM:SS**: `01:30` (1 minute 30 seconds)
+- **Seconds**: `90` (90 seconds)
+- **Decimal seconds**: `90.5` (90.5 seconds)
+
+## How It Works
+
+1. The script analyzes the input video to determine if it can use stream copying (no re-encoding) based on keyframe positioning
+2. It attempts to use the fastest method possible while maintaining quality
+3. If stream copying would result in imprecise cuts, it falls back to re-encoding
+4. The audio track is extracted as a separate AAC file
+
+## Output
+
+- `PREFIX.mp4`: The trimmed video file
+- `PREFIX.aac`: The extracted audio file
+
+## Technical Details
+
+- Uses ffmpeg's stream copying (`-c copy`) when possible to avoid quality loss
+- Falls back to high-quality, fast encoding when necessary (`-c:v libx264 -preset ultrafast -crf 17`)
+- Handles keyframe detection for optimal cutting points
+- Works with both relative (seconds) and absolute (HH:MM:SS) time formats
+
+## Demo Videos
+
+This repository includes sample copyright-free videos for testing:
+
+| File | Description | Source | License |
+|------|-------------|---------|---------|
+| `demo/sample-10s.mp4` | 10-second test pattern | Generated with ffmpeg | Public Domain |
+| `demo/sample-30s.mp4` | 30-second test pattern | Generated with ffmpeg | Public Domain |
+
+All demo videos are verified to be free to use, modify, and distribute.
+
+## Performance Notes
+
+- **Stream copying**: Fastest method, preserves original quality
+- **Re-encoding**: Used when precision is required, high-quality preset
+- **Memory usage**: Minimal - processes videos without loading entire file into memory
+- **Supported formats**: MP4, AVI, MOV, MKV (output always MP4)
+
+## Troubleshooting
+
+### Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| "ffmpeg not found" | Install ffmpeg using your package manager |
+| "Permission denied" | Run `chmod +x trim-convert.sh` to make script executable |
+| "Invalid time format" | Use HH:MM:SS or seconds format |
+| "No keyframes found" | Video will be re-encoded (slower but precise) |
+| "Command not found" | Check if script is in current directory or PATH |
+| "Operation not permitted" | Use `sudo` for system-wide installation |
+
+### Performance Tips
+
+- Use stream copying when possible by aligning cuts with keyframes
+- For bulk processing, consider processing multiple files in parallel
+- Use SSD storage for better I/O performance with large files
+
+## Requirements
+
+- **ffmpeg** (version 4.0 or higher)
+- **Bash shell** (version 4.0 or higher recommended)
+- **Available disk space** equal to at least 2x the size of your largest video file
+
+## License
+
+MIT License - See [LICENSE](https://github.com/nipunbatra/video-toolkit/blob/main/LICENSE) file for details
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+---
+
+## 📖 Documentation Website
+
+This repository has an auto-generated documentation website at: **https://nipunbatra.github.io/video-toolkit**
+
+### How Documentation Works
+
+- **Single source**: Edit only this `README.md` file
+- **Auto-build**: GitHub Actions automatically updates the website
+- **No manual work**: Never touch the `docs/` folder
+- **Live updates**: Changes appear on the website when you push to main
+
+### Making Documentation Changes
+
+1. **Edit this file**: `README.md` (you're reading it now!)
+2. **Commit and push**: `git add . && git commit -m "Update docs" && git push`
+3. **Done**: Website updates automatically in ~2 minutes
+
+**⚠️ Important**: Never edit files in the `docs/` folder - they're auto-generated!

README_HF.md

@@ -0,0 +1,33 @@
+# Video Trimmer Tool
+
+A fast and efficient video trimming toolkit with an interactive web interface for MP4 video processing. Features visual trimming with drag-to-scrub sliders and automatic audio extraction.
+
+## Features
+
+- **Interactive Web Interface**: Visual video scrubbing with drag-to-trim sliders
+- **Smart Trimming**: Find exact cut points with real-time video seeking
+- **Audio Extraction**: Automatic AAC extraction with built-in player
+- **Multiple Formats**: Support for MP4, MOV, AVI, and MKV files
+- **Fast Processing**: Stream copying when possible for speed
+- **Download**: Get both trimmed video and extracted audio files
+
+## How to Use
+
+1. **Upload Video**: Drag & drop your video file or click to upload
+2. **Set Trim Points**: Use the sliders to scrub through the video and find your desired start/end points
+3. **Trim**: Click "Trim Video" to process
+4. **Download**: Get your trimmed video and extracted audio files
+
+## Technical Details
+
+- Uses ffmpeg for high-quality video processing
+- Preserves original quality when possible through stream copying
+- Falls back to fast, high-quality encoding when precision is required
+- Outputs web-optimized MP4 video and AAC audio files
+
+## Supported Formats
+
+- **Input**: MP4, MOV, AVI, MKV
+- **Output**: MP4 video + AAC audio
+
+The tool automatically handles format conversion and optimization for web playback.

app.py

@@ -0,0 +1,695 @@
+import gradio as gr
+import subprocess
+import os
+import tempfile
+import shutil
+import logging
+import time
+from pathlib import Path
+from native_drive_picker import GoogleDrivePickerManager, get_native_picker_instructions, GOOGLE_DRIVE_AVAILABLE
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def process_video_trim(video_file, start_time, end_time):
+    """Process video trimming using the trim-convert.sh script"""
+    logger.info(f"🎬 Starting trim process: file={video_file}, start={start_time}, end={end_time}")
+    
+    if not video_file or start_time is None or end_time is None:
+        error_msg = "Please provide video file and both start/end times"
+        logger.error(f"❌ {error_msg}")
+        return None, None, None, error_msg
+    
+    try:
+        # start_time and end_time are now numbers (seconds) from sliders
+        start_seconds = float(start_time)
+        end_seconds = float(end_time)
+        
+        logger.info(f"📊 Parsed times: start={start_seconds}s, end={end_seconds}s")
+        
+        if start_seconds >= end_seconds:
+            error_msg = "Start time must be less than end time"
+            logger.error(f"❌ {error_msg}")
+            return None, None, None, error_msg
+        
+        # Check if input file exists
+        if not os.path.exists(video_file):
+            error_msg = f"Input video file not found: {video_file}"
+            logger.error(f"❌ {error_msg}")
+            return None, None, None, error_msg
+        
+        # Create temporary directory for output
+        temp_dir = tempfile.mkdtemp()
+        logger.info(f"📁 Created temp directory: {temp_dir}")
+        
+        input_path = video_file
+        
+        # Get the base filename without extension
+        base_name = Path(input_path).stem
+        output_prefix = os.path.join(temp_dir, f"{base_name}_trimmed")
+        
+        # The script will create these files based on the prefix
+        output_video = f"{output_prefix}.mp4"
+        output_audio = f"{output_prefix}.aac"
+        
+        logger.info(f"📤 Output files will be: video={output_video}, audio={output_audio}")
+        
+        # Check if trim-convert.sh script exists
+        script_path = "./trim-convert.sh"
+        if not os.path.exists(script_path):
+            error_msg = f"trim-convert.sh script not found at: {script_path}"
+            logger.error(f"❌ {error_msg}")
+            return None, None, None, error_msg
+        
+        # Convert seconds to HH:MM:SS format for the script
+        def seconds_to_time(seconds):
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            secs = seconds % 60
+            return f"{hours:02d}:{minutes:02d}:{secs:06.3f}"
+        
+        start_time_str = seconds_to_time(start_seconds)
+        end_time_str = seconds_to_time(end_seconds)
+        
+        logger.info(f"🕒 Converted times: start={start_time_str}, end={end_time_str}")
+        
+        # Call the trim-convert.sh script with proper format
+        cmd = [
+            "bash", script_path,
+            "-s", start_time_str,
+            "-e", end_time_str, 
+            "-o", output_prefix,
+            input_path
+        ]
+        
+        logger.info(f"🚀 Running command: {' '.join(cmd)}")
+        
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd='.')
+        
+        logger.info(f"📋 Command finished with return code: {result.returncode}")
+        logger.info(f"📤 STDOUT: {result.stdout}")
+        if result.stderr:
+            logger.warning(f"⚠️  STDERR: {result.stderr}")
+        
+        if result.returncode == 0:
+            # Check if files were created
+            video_exists = os.path.exists(output_video)
+            audio_exists = os.path.exists(output_audio)
+            
+            logger.info(f"📁 File check: video_exists={video_exists}, audio_exists={audio_exists}")
+            
+            if video_exists and audio_exists:
+                video_size = os.path.getsize(output_video)
+                audio_size = os.path.getsize(output_audio)
+                logger.info(f"📊 File sizes: video={video_size} bytes, audio={audio_size} bytes")
+                
+                # Check if video file is valid and convert for better web compatibility
+                try:
+                    test_duration = get_video_duration(output_video)
+                    logger.info(f"✅ Output video duration: {test_duration} seconds")
+                    if test_duration == 0:
+                        logger.warning("⚠️ Output video duration is 0, may have encoding issues")
+                    
+                    # Check if trimmed video is web-compatible, if not, convert only the headers
+                    display_video = output_video  # Start with original
+                    
+                    # Quick check if video might have compatibility issues
+                    try:
+                        # Test if ffprobe can read the file properly
+                        probe_cmd = ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", output_video]
+                        probe_result = subprocess.run(probe_cmd, capture_output=True, text=True)
+                        
+                        if probe_result.returncode == 0:
+                            import json
+                            probe_data = json.loads(probe_result.stdout)
+                            format_info = probe_data.get('format', {})
+                            
+                            # Check if it needs web optimization
+                            needs_conversion = False
+                            
+                            # If the file has issues or isn't web-optimized, do a quick fix
+                            if needs_conversion or True:  # Always do quick web optimization for now
+                                web_video_path = os.path.join(temp_dir, f"{base_name}_web.mp4")
+                                
+                                # Quick web compatibility fix - just fix headers and ensure proper format
+                                web_convert_cmd = [
+                                    "ffmpeg", "-y", "-i", output_video,
+                                    "-c", "copy",  # Copy streams (fast)
+                                    "-movflags", "+faststart",  # Optimize for web
+                                    "-f", "mp4",  # Ensure MP4 format
+                                    web_video_path
+                                ]
+                                
+                                logger.info(f"🌐 Quick web optimization (stream copy)...")
+                                web_result = subprocess.run(web_convert_cmd, capture_output=True, text=True)
+                                
+                                if web_result.returncode == 0 and os.path.exists(web_video_path):
+                                    web_size = os.path.getsize(web_video_path)
+                                    logger.info(f"✅ Web-optimized video: {web_video_path} ({web_size} bytes)")
+                                    display_video = web_video_path
+                                    
+                                    # Verify the optimized video
+                                    web_duration = get_video_duration(web_video_path)
+                                    logger.info(f"🎬 Optimized video duration: {web_duration} seconds")
+                                else:
+                                    logger.warning(f"⚠️ Quick optimization failed: {web_result.stderr}")
+                                    logger.info("Using original trimmed video")
+                        else:
+                            logger.warning("⚠️ Could not analyze trimmed video, using as-is")
+                            
+                    except Exception as e:
+                        logger.warning(f"⚠️ Video analysis failed: {e}, using original")
+                        
+                except Exception as e:
+                    logger.warning(f"⚠️ Could not verify output video: {e}")
+                    display_video = output_video
+                
+                # Create MP3 version for audio player (better browser compatibility)
+                timestamp = str(int(time.time() * 1000))
+                temp_audio_dir = os.path.dirname(output_audio)
+                audio_player_file = os.path.join(temp_audio_dir, f"player_audio_{timestamp}.mp3")
+                
+                # Convert AAC to MP3 for better browser support
+                convert_cmd = [
+                    "ffmpeg", "-y", "-i", output_audio, 
+                    "-codec:a", "libmp3lame", "-b:a", "128k",
+                    audio_player_file
+                ]
+                
+                logger.info(f"🔄 Converting audio for player: {' '.join(convert_cmd)}")
+                convert_result = subprocess.run(convert_cmd, capture_output=True, text=True)
+                
+                if convert_result.returncode == 0 and os.path.exists(audio_player_file):
+                    logger.info(f"🎵 Created MP3 audio player file: {audio_player_file}")
+                    logger.info(f"📊 Audio player file size: {os.path.getsize(audio_player_file)} bytes")
+                else:
+                    logger.warning(f"⚠️ MP3 conversion failed, using original AAC file")
+                    audio_player_file = output_audio
+                
+                success_msg = f"✅ Successfully trimmed video from {start_seconds:.1f}s to {end_seconds:.1f}s"
+                
+                # No automatic upload - will be done manually after trimming
+                
+                logger.info(success_msg)
+                return display_video, audio_player_file, output_audio, success_msg, output_video, output_audio
+            else:
+                error_msg = f"❌ Output files not created.\n\nScript STDOUT:\n{result.stdout}\n\nScript STDERR:\n{result.stderr}\n\nExpected files:\nVideo: {output_video}\nAudio: {output_audio}"
+                logger.error(error_msg)
+                return None, None, None, error_msg, None, None
+        else:
+            error_msg = f"❌ trim-convert.sh failed with return code {result.returncode}\n\nCommand run:\n{' '.join(cmd)}\n\nSTDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}"
+            logger.error(error_msg)
+            return None, None, None, error_msg
+            
+    except Exception as e:
+        error_msg = f"❌ Unexpected error: {str(e)}"
+        logger.exception(error_msg)
+        return None, None, None, error_msg
+
+def get_video_duration(video_file):
+    """Get video duration in seconds"""
+    if not video_file:
+        return 0
+    
+    try:
+        logger.info(f"📺 Getting duration for: {video_file}")
+        
+        # Use ffprobe to get video duration
+        cmd = [
+            "ffprobe", "-v", "quiet", "-print_format", "json", 
+            "-show_format", "-show_streams", video_file
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            import json
+            data = json.loads(result.stdout)
+            duration = float(data['format']['duration'])
+            logger.info(f"⏱️ Video duration: {duration} seconds")
+            return duration
+        else:
+            logger.warning(f"⚠️ Could not get duration: {result.stderr}")
+            return 0
+    except Exception as e:
+        logger.exception(f"❌ Error getting video duration: {e}")
+        return 0
+
+def format_time(seconds):
+    """Format seconds to mm:ss"""
+    if seconds is None:
+        return "0:00"
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    return f"{minutes}:{secs:02d}"
+
+def get_video_info(video_file):
+    """Get video duration and basic info"""
+    if not video_file:
+        return "No video uploaded", 0, 0, 0
+    
+    logger.info(f"📹 Processing video upload: {video_file}")
+    
+    duration = get_video_duration(video_file)
+    if duration > 0:
+        minutes = int(duration // 60)
+        seconds = int(duration % 60)
+        info = f"📹 Video loaded! Duration: {minutes}:{seconds:02d} ({duration:.1f}s)"
+        logger.info(f"✅ {info}")
+        return info, duration, 0, duration
+    else:
+        info = "📹 Video loaded! (Could not determine duration)"
+        logger.warning(f"⚠️ {info}")
+        return info, 100, 0, 100
+
+# Native Google Drive picker functions
+def open_file_picker(drive_manager):
+    """Open Google Drive for file selection (full access)"""
+    if not drive_manager or not drive_manager.is_available():
+        return "❌ Google Drive not available"
+    
+    instructions = drive_manager.open_drive_picker("file")
+    return instructions
+
+def open_folder_picker(drive_manager):
+    """Open Google Drive for folder selection"""
+    if not drive_manager or not drive_manager.is_available():
+        return "❌ Google Drive not available"
+    
+    instructions = drive_manager.open_drive_picker("folder")
+    return instructions
+
+def download_from_drive_url(drive_manager, drive_url, custom_filename=""):
+    """Download video from Google Drive URL"""
+    if not drive_manager or not drive_manager.is_available():
+        return None, "❌ Google Drive not available"
+    
+    if not drive_url or not drive_url.strip():
+        return None, "⚠️ Please paste a Google Drive link"
+    
+    filename = custom_filename.strip() if custom_filename.strip() else None
+    return drive_manager.download_file_from_url(drive_url, filename)
+
+def download_from_google_drive(file_id, file_display, drive_manager):
+    """Download selected file from Google Drive"""
+    if not file_id or not drive_manager or not drive_manager.is_available():
+        return None, "❌ No file selected or Google Drive unavailable"
+    
+    try:
+        # Extract filename from display string
+        filename = file_display.split(' (')[0] if file_display else f"video_{file_id}.mp4"
+        
+        logger.info(f"📥 Downloading {filename} from Google Drive...")
+        local_path = drive_manager.download_file(file_id, filename)
+        
+        if local_path and os.path.exists(local_path):
+            return local_path, f"✅ Downloaded: {filename}"
+        else:
+            return None, "❌ Download failed"
+    except Exception as e:
+        logger.error(f"Error downloading from Google Drive: {e}")
+        return None, f"❌ Download error: {str(e)}"
+
+# Initialize Google Drive manager
+try:
+    drive_manager = GoogleDrivePickerManager()
+    drive_available = drive_manager.is_available()
+except Exception as e:
+    logger.warning(f"Google Drive initialization failed: {e}")
+    drive_manager = None
+    drive_available = False
+
+# Create the Gradio interface with custom CSS and JS
+custom_css = """
+.video-container video {
+    width: 100%;
+    max-height: 400px;
+}
+.slider-container {
+    margin: 10px 0;
+}
+.drive-section {
+    border: 1px solid #e0e0e0;
+    padding: 15px;
+    border-radius: 8px;
+    margin: 10px 0;
+}
+"""
+
+custom_js = """
+function seekVideo(slider_value, video_id) {
+    const video = document.querySelector('#' + video_id + ' video');
+    if (video && !isNaN(slider_value)) {
+        video.currentTime = slider_value;
+    }
+    return slider_value;
+}
+"""
+
+with gr.Blocks(title="Video Trimmer Tool", theme=gr.themes.Soft(), css=custom_css, js=custom_js) as demo:
+    gr.Markdown("""
+    # 🎬 Video Trimmer Demo
+    Upload an MP4 video, set trim points, and generate trimmed video + audio files.
+    """)
+    
+    # Native Google Drive picker section
+    if drive_available:
+        user_email = drive_manager.get_user_info() if drive_manager else "Unknown"
+        with gr.Group():
+            gr.Markdown("### 🔗 Google Drive Integration (Native Picker)")
+            gr.Markdown(f"**👤 Signed in as:** {user_email}")
+            
+            # Video picker section
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("#### 📁 Load Any File from Google Drive")
+                    
+                    open_picker_btn = gr.Button(
+                        "🌍 Browse Your Entire Google Drive",
+                        variant="primary",
+                        size="lg"
+                    )
+                    
+                    picker_instructions = gr.Textbox(
+                        label="📝 Instructions",
+                        value="Click the button above to open your full Google Drive - browse any folder!",
+                        interactive=False,
+                        lines=6
+                    )
+                    
+                    drive_url_input = gr.Textbox(
+                        label="🔗 Paste Any Google Drive File Link",
+                        placeholder="https://drive.google.com/file/d/FILE_ID/view...",
+                        info="Works with any file type - videos, docs, etc. from any folder"
+                    )
+                    
+                    custom_filename_input = gr.Textbox(
+                        label="🏷️ Custom Filename (Optional)",
+                        placeholder="my_video.mp4"
+                    )
+                    
+                    download_from_url_btn = gr.Button(
+                        "📥 Download Video from Link",
+                        variant="secondary"
+                    )
+                
+                with gr.Column(scale=1):
+                    drive_status = gr.Textbox(
+                        label="📊 Status",
+                        value="✅ Ready to pick from Google Drive",
+                        interactive=False
+                    )
+            
+            # Simplified note
+            gr.Markdown("🚀 **Upload to Google Drive will be available after video trimming.**")
+    else:
+        with gr.Group():
+            gr.Markdown("### 🔗 Google Drive Integration")
+            if not GOOGLE_DRIVE_AVAILABLE:
+                gr.Markdown("**⚠️ Google Drive libraries not installed.**")
+                gr.Markdown("Install with: `pip install google-api-python-client google-auth google-auth-oauthlib`")
+            else:
+                gr.Markdown("**⚠️ Setup needed:** Create oauth_credentials.json file")
+            
+            with gr.Accordion("📋 Setup Instructions", open=False):
+                gr.Markdown(get_native_picker_instructions())
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            # Video upload and display
+            video_input = gr.File(
+                label="📁 Upload MP4 Video",
+                file_types=[".mp4", ".mov", ".avi", ".mkv"],
+                type="filepath"
+            )
+            
+            video_player = gr.Video(
+                label="🎥 Video Player",
+                show_label=True,
+                elem_id="main_video_player",
+                elem_classes=["video-container"]
+            )
+            
+            video_info = gr.Textbox(
+                label="📊 Video Info",
+                interactive=False,
+                value="Upload a video to see information"
+            )
+        
+        with gr.Column(scale=1):
+            # Trim controls
+            gr.Markdown("### ✂️ Trim Settings")
+            gr.Markdown("**🎯 Drag sliders to set trim points:**")
+            
+            with gr.Group():
+                gr.Markdown("**🎯 Scrub to find start point:**")
+                start_slider = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=0,
+                    step=0.1,
+                    label="⏯️ Start Time (scrub video)",
+                    info="Drag to seek video and set start position",
+                    elem_classes=["slider-container"]
+                )
+                
+                start_time_display = gr.Textbox(
+                    label="⏯️ Start Time",
+                    value="0:00",
+                    interactive=False,
+                    info="Current start time"
+                )
+            
+            with gr.Group():
+                gr.Markdown("**🎯 Scrub to find end point:**")
+                end_slider = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=100,
+                    step=0.1,
+                    label="⏹️ End Time (scrub video)",
+                    info="Drag to seek video and set end position",
+                    elem_classes=["slider-container"]
+                )
+                
+                end_time_display = gr.Textbox(
+                    label="⏹️ End Time",
+                    value="1:40",
+                    interactive=False,
+                    info="Current end time"
+                )
+            
+            trim_btn = gr.Button(
+                "✂️ Trim Video",
+                variant="primary",
+                size="lg"
+            )
+            
+            # Note about manual upload
+            gr.Markdown("📝 **Note:** Upload options will appear after trimming is complete.")
+            
+            status_msg = gr.Textbox(
+                label="📝 Status",
+                interactive=False,
+                value="Ready to trim..."
+            )
+    
+    # Output section
+    gr.Markdown("### 📤 Output Files")
+    
+    with gr.Row():
+        with gr.Column():
+            output_video = gr.Video(
+                label="🎬 Trimmed Video",
+                show_label=True
+            )
+        
+        with gr.Column():
+            output_audio_player = gr.Audio(
+                label="🎵 Play Extracted Audio",
+                show_label=True,
+                type="filepath"
+            )
+            
+            output_audio_download = gr.File(
+                label="💾 Download Audio (AAC)",
+                show_label=True
+            )
+    
+    # Post-processing upload section (appears after trimming)
+    if drive_available:
+        with gr.Group(visible=False) as post_upload_section:
+            gr.Markdown("### 🚀 Upload Trimmed Files to Google Drive")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    post_open_folder_btn = gr.Button(
+                        "🌍 Choose Google Drive Upload Folder",
+                        variant="primary"
+                    )
+                    
+                    post_folder_instructions = gr.Textbox(
+                        label="📝 Folder Instructions",
+                        value="Click button above to choose where to upload your trimmed files",
+                        interactive=False,
+                        lines=4
+                    )
+                    
+                    post_upload_folder_url = gr.Textbox(
+                        label="📁 Upload Folder Link",
+                        placeholder="https://drive.google.com/drive/folders/FOLDER_ID...",
+                        info="Leave empty to upload to My Drive root"
+                    )
+                    
+                    post_upload_btn = gr.Button(
+                        "📤 Upload Files to Google Drive",
+                        variant="secondary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=1):
+                    post_upload_status = gr.Textbox(
+                        label="📊 Upload Status",
+                        value="Ready to upload",
+                        interactive=False
+                    )
+        
+        # Hidden state to store file paths for post-upload
+        trimmed_video_path = gr.State(None)
+        trimmed_audio_path = gr.State(None)
+    
+    # Event handlers
+    def update_video_and_sliders(video_file):
+        info, duration, start_val, end_val = get_video_info(video_file)
+        return (
+            video_file,  # video_player
+            info,  # video_info
+            gr.Slider(minimum=0, maximum=duration, value=0, step=0.1),  # start_slider
+            gr.Slider(minimum=0, maximum=duration, value=duration, step=0.1),  # end_slider
+            "0:00",  # start_time_display
+            format_time(duration)  # end_time_display
+        )
+    
+    def update_start_display(start_val):
+        return format_time(start_val)
+    
+    def update_end_display(end_val):
+        return format_time(end_val)
+    
+    video_input.change(
+        fn=update_video_and_sliders,
+        inputs=[video_input],
+        outputs=[video_player, video_info, start_slider, end_slider, start_time_display, end_time_display]
+    )
+    
+    start_slider.change(
+        fn=update_start_display,
+        inputs=[start_slider],
+        outputs=[start_time_display],
+        js="(value) => { const video = document.querySelector('#main_video_player video'); if (video && !isNaN(value)) { video.currentTime = value; } return value; }"
+    )
+    
+    end_slider.change(
+        fn=update_end_display,
+        inputs=[end_slider],
+        outputs=[end_time_display],
+        js="(value) => { const video = document.querySelector('#main_video_player video'); if (video && !isNaN(value)) { video.currentTime = value; } return value; }"
+    )
+    
+    # Google Drive native picker event handlers
+    if drive_available:
+        # Open file picker (full Google Drive access)
+        open_picker_btn.click(
+            fn=lambda: open_file_picker(drive_manager),
+            outputs=[picker_instructions]
+        )
+        
+        # Download from URL
+        download_from_url_btn.click(
+            fn=lambda url, filename: download_from_drive_url(drive_manager, url, filename),
+            inputs=[drive_url_input, custom_filename_input],
+            outputs=[video_input, drive_status]
+        ).then(
+            fn=update_video_and_sliders,
+            inputs=[video_input],
+            outputs=[video_player, video_info, start_slider, end_slider, start_time_display, end_time_display]
+        )
+        
+        # No pre-upload handlers needed
+        
+        # Post-upload event handlers
+        post_open_folder_btn.click(
+            fn=lambda: open_folder_picker(drive_manager),
+            outputs=[post_folder_instructions]
+        )
+        
+        def post_upload_files(video_path, audio_path, folder_url):
+            if not video_path or not audio_path:
+                return "❌ No files to upload"
+            
+            try:
+                folder_url_clean = folder_url.strip() if folder_url and folder_url.strip() else None
+                
+                video_success, video_result = drive_manager.upload_file_to_folder(video_path, folder_url_clean)
+                audio_success, audio_result = drive_manager.upload_file_to_folder(audio_path, folder_url_clean)
+                
+                if video_success and audio_success:
+                    return f"✅ Files uploaded successfully:\n• {video_result}\n• {audio_result}"
+                elif video_success:
+                    return f"✅ {video_result}\n❌ Audio upload failed: {audio_result}"
+                elif audio_success:
+                    return f"✅ {audio_result}\n❌ Video upload failed: {video_result}"
+                else:
+                    return f"❌ Upload failed:\n• Video: {video_result}\n• Audio: {audio_result}"
+                    
+            except Exception as e:
+                return f"❌ Upload error: {str(e)}"
+        
+        post_upload_btn.click(
+            fn=post_upload_files,
+            inputs=[trimmed_video_path, trimmed_audio_path, post_upload_folder_url],
+            outputs=[post_upload_status]
+        )
+    
+    # Trim button handler with Google Drive upload support
+    if drive_available:
+        # Simplified trim function that shows upload section after completion
+        def trim_and_show_upload(video_file, start_time, end_time):
+            result = process_video_trim(video_file, start_time, end_time)
+            display_video, audio_player, audio_download, status, orig_video, orig_audio = result
+            
+            # Show post-upload section if trimming was successful
+            show_upload = orig_video is not None and orig_audio is not None
+            
+            return (
+                display_video, audio_player, audio_download, status,  # Original outputs
+                orig_video, orig_audio,  # Store paths for post-upload
+                gr.Group(visible=show_upload)  # Show/hide upload section
+            )
+        
+        trim_btn.click(
+            fn=trim_and_show_upload,
+            inputs=[video_input, start_slider, end_slider],
+            outputs=[output_video, output_audio_player, output_audio_download, status_msg, 
+                    trimmed_video_path, trimmed_audio_path, post_upload_section]
+        )
+    else:
+        # No Google Drive available - simple trim only
+        def simple_trim(video_file, start_time, end_time):
+            result = process_video_trim(video_file, start_time, end_time)
+            return result[:4]  # Return only the first 4 outputs
+        
+        trim_btn.click(
+            fn=simple_trim,
+            inputs=[video_input, start_slider, end_slider],
+            outputs=[output_video, output_audio_player, output_audio_download, status_msg]
+        )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=None,  # Auto-find available port
+        share=False,
+        show_error=True,
+        debug=True
+    )