SeedBox Control Panel

Python Backend (Flask API)

Create project structure:

mkdir -p /opt/seedbox-panel
cd /opt/seedbox-panel
python3 -m venv venv
source venv/bin/activate
pip install flask flask-cors docker psutil gunicorn

Create app.py:

#!/usr/bin/env python3
"""
SeedBox Control Panel - Backend API
Save as: /opt/seedbox-panel/app.py
"""

from flask import Flask, jsonify, request
from flask_cors import CORS
import docker
import psutil
import os
import time
from datetime import datetime, timedelta

app = Flask(__name__)
CORS(app)

# Docker client
client = docker.from_env()

# App configurations
APPS = {
    'radarr': {
        'name': 'Radarr',
        'image': 'linuxserver/radarr:latest',
        'port': 7878,
        'volumes': {'/opt/seedbox/radarr/config': {'bind': '/config', 'mode': 'rw'},
                    '/opt/seedbox/downloads': {'bind': '/downloads', 'mode': 'rw'},
                    '/opt/seedbox/movies': {'bind': '/movies', 'mode': 'rw'}},
        'environment': {'PUID': '1000', 'PGID': '1000', 'TZ': 'UTC'}
    },
    'sonarr': {
        'name': 'Sonarr',
        'image': 'linuxserver/sonarr:latest',
        'port': 8989,
        'volumes': {'/opt/seedbox/sonarr/config': {'bind': '/config', 'mode': 'rw'},
                    '/opt/seedbox/downloads': {'bind': '/downloads', 'mode': 'rw'},
                    '/opt/seedbox/tv': {'bind': '/tv', 'mode': 'rw'}},
        'environment': {'PUID': '1000', 'PGID': '1000', 'TZ': 'UTC'}
    },
    'plex': {
        'name': 'Plex',
        'image': 'linuxserver/plex:latest',
        'port': 32400,
        'volumes': {'/opt/seedbox/plex/config': {'bind': '/config', 'mode': 'rw'},
                    '/opt/seedbox/movies': {'bind': '/movies', 'mode': 'rw'},
                    '/opt/seedbox/tv': {'bind': '/tv', 'mode': 'rw'}},
        'environment': {'PUID': '1000', 'PGID': '1000', 'TZ': 'UTC', 'VERSION': 'docker'}
    },
    'utorrent': {
        'name': 'uTorrent',
        'image': 'ekho/utorrent:latest',
        'port': 8080,
        'volumes': {'/opt/seedbox/utorrent/config': {'bind': '/utorrent/settings', 'mode': 'rw'},
                    '/opt/seedbox/downloads': {'bind': '/data', 'mode': 'rw'}},
        'environment': {}
    },
    'overseerr': {
        'name': 'Overseerr',
        'image': 'linuxserver/overseerr:latest',
        'port': 5055,
        'volumes': {'/opt/seedbox/overseerr/config': {'bind': '/config', 'mode': 'rw'}},
        'environment': {'PUID': '1000', 'PGID': '1000', 'TZ': 'UTC'}
    }
}

def get_container(app_id):
    """Get container by app_id"""
    try:
        return client.containers.get(f"seedbox-{app_id}")
    except docker.errors.NotFound:
        return None

@app.route('/api/health', methods=['GET'])
def health():
    return jsonify({'status': 'ok', 'timestamp': datetime.now().isoformat()})

@app.route('/api/system/stats', methods=['GET'])
def system_stats():
    """Get system statistics"""
    # CPU
    cpu_percent = psutil.cpu_percent(interval=1)
    
    # Memory
    memory = psutil.virtual_memory()
    memory_used = memory.used / (1024**3)  # GB
    memory_total = memory.total / (1024**3)  # GB
    
    # Disk
    disk = psutil.disk_usage('/')
    disk_used = disk.used / (1024**4)  # TB
    disk_total = disk.total / (1024**4)  # TB
    disk_free = disk.free / (1024**4)  # TB
    
    # Uptime
    boot_time = datetime.fromtimestamp(psutil.boot_time())
    uptime = datetime.now() - boot_time
    
    return jsonify({
        'cpu': {'percent': cpu_percent},
        'memory': {
            'used': round(memory_used, 2),
            'total': round(memory_total, 2),
            'percent': memory.percent
        },
        'disk': {
            'used': round(disk_used, 2),
            'total': round(disk_total, 2),
            'free': round(disk_free, 2),
            'percent': disk.percent
        },
        'uptime': {
            'days': uptime.days,
            'hours': uptime.seconds // 3600,
            'minutes': (uptime.seconds % 3600) // 60,
            'formatted': f"{uptime.days}d {uptime.seconds // 3600}h {(uptime.seconds % 3600) // 60}m"
        }
    })

@app.route('/api/apps', methods=['GET'])
def list_apps():
    """List all applications with their status"""
    apps = []
    for app_id, config in APPS.items():
        container = get_container(app_id)
        status = 'stopped'
        if container:
            status = container.status
        
        apps.append({
            'id': app_id,
            'name': config['name'],
            'status': status,
            'port': config['port'],
            'image': config['image'],
            'installed': container is not None
        })
    return jsonify(apps)

@app.route('/api/apps//install', methods=['POST'])
def install_app(app_id):
    """Install/deploy an application"""
    if app_id not in APPS:
        return jsonify({'error': 'App not found'}), 404
    
    config = APPS[app_id]
    
    # Create directories
    for host_path in config['volumes'].keys():
        os.makedirs(host_path, exist_ok=True)
    
    try:
        # Pull image
        client.images.pull(config['image'])
        
        # Create and start container
        container = client.containers.run(
            config['image'],
            name=f"seedbox-{app_id}",
            detach=True,
            restart_policy={'Name': 'unless-stopped'},
            ports={f"{config['port']}/tcp": config['port']},
            volumes=config['volumes'],
            environment=config['environment']
        )
        
        return jsonify({
            'success': True,
            'message': f"{config['name']} installed successfully",
            'container_id': container.id[:12]
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/apps//start', methods=['POST'])
def start_app(app_id):
    """Start an application"""
    container = get_container(app_id)
    if not container:
        return jsonify({'error': 'Container not found'}), 404
    
    try:
        container.start()
        return jsonify({'success': True, 'message': f'{app_id} started'})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/apps//stop', methods=['POST'])
def stop_app(app_id):
    """Stop an application"""
    container = get_container(app_id)
    if not container:
        return jsonify({'error': 'Container not found'}), 404
    
    try:
        container.stop()
        return jsonify({'success': True, 'message': f'{app_id} stopped'})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/apps//restart', methods=['POST'])
def restart_app(app_id):
    """Restart an application"""
    container = get_container(app_id)
    if not container:
        return jsonify({'error': 'Container not found'}), 404
    
    try:
        container.restart()
        return jsonify({'success': True, 'message': f'{app_id} restarted'})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/apps//update', methods=['POST'])
def update_app(app_id):
    """Update an application to latest version"""
    if app_id not in APPS:
        return jsonify({'error': 'App not found'}), 404
    
    config = APPS[app_id]
    container = get_container(app_id)
    
    try:
        # Pull latest image
        client.images.pull(config['image'])
        
        if container:
            # Stop and remove old container
            container.stop()
            container.remove()
        
        # Create new container with updated image
        new_container = client.containers.run(
            config['image'],
            name=f"seedbox-{app_id}",
            detach=True,
            restart_policy={'Name': 'unless-stopped'},
            ports={f"{config['port']}/tcp": config['port']},
            volumes=config['volumes'],
            environment=config['environment']
        )
        
        return jsonify({
            'success': True,
            'message': f'{config["name"]} updated successfully',
            'container_id': new_container.id[:12]
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/apps//delete', methods=['DELETE'])
def delete_app(app_id):
    """Delete/uninstall an application"""
    container = get_container(app_id)
    if not container:
        return jsonify({'error': 'Container not found'}), 404
    
    try:
        container.stop()
        container.remove()
        return jsonify({'success': True, 'message': f'{app_id} deleted'})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/apps//logs', methods=['GET'])
def get_logs(app_id):
    """Get application logs"""
    container = get_container(app_id)
    if not container:
        return jsonify({'error': 'Container not found'}), 404
    
    try:
        logs = container.logs(tail=100, timestamps=True).decode('utf-8')
        return jsonify({'logs': logs.split('\n')})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

Create systemd service:

# Create service file
sudo nano /etc/systemd/system/seedbox-panel.service

[Unit]
Description=SeedBox Control Panel API
After=network.target docker.service

[Service]
Type=simple
User=root
WorkingDirectory=/opt/seedbox-panel
Environment=PATH=/opt/seedbox-panel/venv/bin
ExecStart=/opt/seedbox-panel/venv/bin/gunicorn -w 4 -b 127.0.0.1:5000 app:app
Restart=always

[Install]
WantedBy=multi-user.target

# Enable and start service
sudo systemctl daemon-reload
sudo systemctl enable seedbox-panel
sudo systemctl start seedbox-panel

Nginx Configuration

Create Nginx config:

sudo nano /etc/nginx/sites-available/seedbox-panel

# /etc/nginx/sites-available/seedbox-panel

upstream seedbox_api {
    server 127.0.0.1:5000;
}

server {
    listen 80;
    server_name your-domain.com;  # Replace with your domain or IP
    
    # Redirect to HTTPS (uncomment after SSL setup)
    # return 301 https://$server_name$request_uri;
    
    root /var/www/seedbox-panel;
    index index.html;
    
    # Frontend
    location / {
        try_files $uri $uri/ /index.html;
    }
    
    # API Proxy
    location /api/ {
        proxy_pass http://seedbox_api;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 86400;
    }
    
    # Proxy to Radarr
    location /radarr {
        proxy_pass http://127.0.0.1:7878;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
    
    # Proxy to Sonarr
    location /sonarr {
        proxy_pass http://127.0.0.1:8989;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
    
    # Proxy to Plex
    location /plex {
        proxy_pass http://127.0.0.1:32400;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
    
    # Proxy to uTorrent
    location /utorrent {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
    
    # Proxy to Overseerr
    location /overseerr {
        proxy_pass http://127.0.0.1:5055;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

# HTTPS Server (uncomment after SSL setup)
# server {
#     listen 443 ssl http2;
#     server_name your-domain.com;
#     
#     ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
#     ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
#     
#     # ... rest of config same as above
# }

Enable site and restart Nginx:

# Create web directory
sudo mkdir -p /var/www/seedbox-panel

# Copy index.html to web directory
sudo cp index.html /var/www/seedbox-panel/

# Enable site
sudo ln -s /etc/nginx/sites-available/seedbox-panel /etc/nginx/sites-enabled/

# Test and restart
sudo nginx -t
sudo systemctl restart nginx

Setup SSL with Let's Encrypt:

# Install Certbot
sudo apt install certbot python3-certbot-nginx -y

# Get certificate
sudo certbot --nginx -d your-domain.com

# Auto-renewal (already set up by certbot)
sudo certbot renew --dry-run

Docker Compose Setup

Alternative: Use Docker Compose for easier management of all containers.

Create docker-compose.yml:

# /opt/seedbox/docker-compose.yml

version: '3.8'

services:
  radarr:
    image: linuxserver/radarr:latest
    container_name: seedbox-radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=UTC
    volumes:
      - ./radarr/config:/config
      - ./downloads:/downloads
      - ./movies:/movies
    ports:
      - 7878:7878
    restart: unless-stopped

  sonarr:
    image: linuxserver/sonarr:latest
    container_name: seedbox-sonarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=UTC
    volumes:
      - ./sonarr/config:/config
      - ./downloads:/downloads
      - ./tv:/tv
    ports:
      - 8989:8989
    restart: unless-stopped

  plex:
    image: linuxserver/plex:latest
    container_name: seedbox-plex
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=UTC
      - VERSION=docker
    volumes:
      - ./plex/config:/config
      - ./movies:/movies
      - ./tv:/tv
    restart: unless-stopped

  utorrent:
    image: ekho/utorrent:latest
    container_name: seedbox-utorrent
    volumes:
      - ./utorrent/config:/utorrent/settings
      - ./downloads:/data
    ports:
      - 8080:8080
      - 6881:6881
      - 6881:6881/udp
    restart: unless-stopped

  overseerr:
    image: linuxserver/overseerr:latest
    container_name: seedbox-overseerr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=UTC
    volumes:
      - ./overseerr/config:/config
    ports:
      - 5055:5055
    restart: unless-stopped

  # Control Panel API
  seedbox-api:
    build: ./panel
    container_name: seedbox-api
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./:/opt/seedbox
    ports:
      - 5000:5000
    restart: unless-stopped
    depends_on:
      - radarr
      - sonarr
      - plex
      - overseerr

networks:
  default:
    name: seedbox-network

Create directory structure:

mkdir -p /opt/seedbox/{radarr,sonarr,plex,utorrent,overseerr}/config
mkdir -p /opt/seedbox/{downloads,movies,tv}
cd /opt/seedbox

# Set permissions
sudo chown -R 1000:1000 /opt/seedbox

Deploy with Docker Compose:

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f

# Stop all services
docker-compose down

# Update all services
docker-compose pull && docker-compose up -d

Final Steps & Security

1. Configure Firewall:

# Setup UFW firewall
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable

# Optional: Allow direct access to apps (if not using reverse proxy)
# sudo ufw allow 7878/tcp  # Radarr
# sudo ufw allow 8989/tcp  # Sonarr
# sudo ufw allow 32400/tcp # Plex
# sudo ufw allow 8080/tcp  # uTorrent
# sudo ufw allow 5055/tcp  # Overseerr

2. Setup Authentication:

# Install htpasswd utility
sudo apt install apache2-utils -y

# Create password file
sudo htpasswd -c /etc/nginx/.htpasswd admin

# Add to Nginx location blocks:
# auth_basic "Restricted";
# auth_basic_user_file /etc/nginx/.htpasswd;

3. Access Your Applications:

4. Maintenance Commands:

# Check container status
docker ps -a

# View container logs
docker logs -f seedbox-radarr

# Restart a container
docker restart seedbox-sonarr

# Update a container
docker pull linuxserver/radarr:latest
docker-compose up -d radarr

# Backup configs
tar -czvf seedbox-backup-$(date +%Y%m%d).tar.gz /opt/seedbox/*/config

# Monitor resources
docker stats