main.py

import os
import subprocess
import shutil
import json
import logging
from flask import Flask, request, jsonify
from werkzeug.security import generate_password_hash, check_password_hash
import pwd
import psutil
import netifaces
from datetime import datetime
import argparse
import sys
import socket
import threading
import secrets
import ssl
from contextlib import contextmanager
import re
import uuid

# Configure logging
logging.basicConfig(
    filename='/var/log/bolt_server.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s: %(message)s'
)
logger = logging.getLogger(__name__)

# Configuration file paths
CONFIG_FILE = '/etc/bolt/config.json'
SANDBOX_BASE_DIR = '/var/bolt/sandboxes'
PROJECTS_BASE_DIR = '/var/bolt/projects'
DEBOOTSTRAP_DIR = '/usr/sbin/debootstrap'
CGROUP_BASE = '/sys/fs/cgroup'
SSL_CERT = '/etc/bolt/cert.pem'
SSL_KEY = '/etc/bolt/key.pem'

app = Flask(__name__)

# Default configuration
DEFAULT_CONFIG = {
    'admin_user': 'admin',
    'admin_password': generate_password_hash('admin'),
    'base_image_dir': '/var/bolt/base_images',
    'default_distro': 'debian:bullseye',
    'allowed_ports': list(range(10000, 20000)),
    'shell_port_range': list(range(20001, 25000)),
    'default_resource_limits': {
        'cpu_quota_us': 100000,
        'memory_limit_bytes': 512 * 1024 * 1024,
    },
    'shell_token_expiry': 3600  # 1 hour
}

# Load or create configuration
def load_config():
    if not os.path.exists(CONFIG_FILE):
        os.makedirs(os.path.dirname(CONFIG_FILE), exist_ok=True)
        with open(CONFIG_FILE, 'w') as f:
            json.dump(DEFAULT_CONFIG, f, indent=4)
        os.chmod(CONFIG_FILE, 0o600)
    with open(CONFIG_FILE, 'r') as f:
        return json.load(f)

config = load_config()

# Ensure required directories exist with correct permissions
def ensure_directories():
    for path in [SANDBOX_BASE_DIR, PROJECTS_BASE_DIR, config['base_image_dir'], os.path.join(CGROUP_BASE, 'cpu', 'bolt'), os.path.join(CGROUP_BASE, 'memory', 'bolt')]:
        os.makedirs(path, exist_ok=True)
        os.chmod(path, 0o750)
    os.chown(SANDBOX_BASE_DIR, pwd.getpwnam('bolt').pw_uid, pwd.getpwnam('bolt').pw_gid)
    os.chown(PROJECTS_BASE_DIR, pwd.getpwnam('bolt').pw_uid, pwd.getpwnam('bolt').pw_gid)

# Generate self-signed SSL certificate if not already present
def ensure_ssl():
    if not os.path.exists(SSL_CERT) or not os.path.exists(SSL_KEY):
        subprocess.run(['openssl', 'req', '-x509', '-newkey', 'rsa:2048', '-nodes', '-days', '365', '-subj', '/CN=localhost', '-keyout', SSL_KEY, '-out', SSL_CERT])
        os.chmod(SSL_CERT, 0o600)
        os.chmod(SSL_KEY, 0o600)

# Input sanitization
def sanitize_input(value):
    if not isinstance(value, str):
        return value
    # Remove dangerous characters and limit length
    return re.sub(r'[^\w\-.:]', '', value)[:100]

# Context manager for cgroup setup
@contextmanager
def cgroup_context(sandbox_name):
    cpu_cgroup = os.path.join(CGROUP_BASE, 'cpu', 'bolt', sanitize_input(sandbox_name))
    memory_cgroup = os.path.join(CGROUP_BASE, 'memory', 'bolt', sanitize_input(sandbox_name))
    os.makedirs(cpu_cgroup, exist_ok=True)
    os.makedirs(memory_cgroup, exist_ok=True)
    try:
        yield cpu_cgroup, memory_cgroup
    finally:
        pass

# TCP Shell Server
class ShellServer:
    def __init__(self, sandbox, port, token):
        self.sandbox = sandbox
        self.port = port
        self.token = token
        self.server = None
        self.running = False

    def start(self):
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server.bind(('0.0.0.0', self.port))
        self.server.listen(1)
        self.running = True
        logger.info(f"Shell server started for {self.sandbox.name} on port {self.port}")
        threading.Thread(target=self.accept_connections, daemon=True).start()

    def accept_connections(self):
        while self.running:
            try:
                client, addr = self.server.accept()
                logger.info(f"Shell connection from {addr} for {self.sandbox.name}")
                threading.Thread(target=self.handle_client, args=(client, addr), daemon=True).start()
            except Exception as e:
                logger.error(f"Shell server error: {str(e)}")
                break

    def handle_client(self, client, addr):
        try:
            client.send(b"Enter token: ")
            token = client.recv(1024).decode().strip()
            if token != self.token:
                client.send(b"Invalid token\n")
                client.close()
                logger.warning(f"Invalid shell token from {addr}")
                return
            client.send(b"Bolt Shell\n")
            while self.running:
                client.send(b"$ ")
                command = client.recv(1024).decode().strip()
                if not command:
                    break
                if command.lower() in ['exit', 'quit']:
                    break
                command = sanitize_input(command)
                try:
                    cmd = ['unshare', '-m', '-u', '-n', 'chroot', self.sandbox.rootfs, '/bin/bash', '-c', command]
                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
                    client.send(result.stdout.encode() + result.stderr.encode())
                except subprocess.TimeoutExpired:
                    client.send(b"Command timed out\n")
                except Exception as e:
                    client.send(f"Error: {str(e)}\n".encode())
        except Exception as e:
            logger.error(f"Shell client error: {str(e)}")
        finally:
            client.close()

    def stop(self):
        self.running = False
        if self.server:
            self.server.close()
        logger.info(f"Shell server stopped for {self.sandbox.name}")

# Project class
class Project:
    def __init__(self, name):
        self.name = sanitize_input(name)
        self.path = os.path.join(PROJECTS_BASE_DIR, self.name)
        self.config_file = os.path.join(self.path, 'project.json')
        self.config = {'sandboxes': [], 'resource_limits': config['default_resource_limits'].copy(), 'created_at': datetime.now().isoformat()}

    def create(self):
        try:
            os.makedirs(self.path, exist_ok=True)
            with open(self.config_file, 'w') as f:
                json.dump(self.config, f, indent=4)
            os.chmod(self.config_file, 0o600)
            logger.info(f"Project {self.name} created")
        except Exception as e:
            logger.error(f"Failed to create project {self.name}: {str(e)}")
            raise

    def delete(self):
        try:
            self.load()
            for sandbox_name in self.config['sandboxes']:
                sandbox = Sandbox(sandbox_name, self)
                sandbox.delete()
            shutil.rmtree(self.path)
            logger.info(f"Project {self.name} deleted")
        except Exception as e:
            logger.error(f"Failed to delete project {self.name}: {str(e)}")
            raise

    def load(self):
        if os.path.exists(self.config_file):
            with open(self.config_file, 'r') as f:
                self.config = json.load(f)

    def save(self):
        with open(self.config_file, 'w') as f:
            json.dump(self.config, f, indent=4)
        os.chmod(self.config_file, 0o600)

    def set_resource_limits(self, cpu_quota_us=None, memory_limit_bytes=None):
        if cpu_quota_us is not None:
            self.config['resource_limits']['cpu_quota_us'] = int(cpu_quota_us)
        if memory_limit_bytes is not None:
            self.config['resource_limits']['memory_limit_bytes'] = int(memory_limit_bytes)
        self.save()
        for sandbox_name in self.config['sandboxes']:
            sandbox = Sandbox(sandbox_name, self)
            sandbox.apply_resource_limits()

# Sandbox management class
class Sandbox:
    def __init__(self, name, project=None, distro=None):
        self.name = sanitize_input(name)
        self.project = project
        self.distro = distro or config['default_distro']
        self.rootfs = os.path.join(project.path if project else SANDBOX_BASE_DIR, self.name)
        self.base_image = os.path.join(config['base_image_dir'], self.distro.replace(':', '_'))
        self.port_mappings = {}
        self.reverse_port_mappings = {}
        self.shell_server = None
        self.shell_port = None
        self.shell_token = None
        self.created_at = datetime.now().isoformat()

    def create(self):
        try:
            if os.path.exists(self.rootfs):
                raise ValueError(f"Sandbox {self.name} already exists")
            if not os.path.exists(self.base_image):
                logger.info(f"Creating base image for {self.distro}")
                distro_name = self.distro.split(':')[1]
                cmd = [DEBOOTSTRAP_DIR, '--variant=minbase', distro_name, self.base_image]
                subprocess.run(cmd, check=True, preexec_fn=lambda: os.setuid(pwd.getpwnam('bolt').pw_uid))
                logger.info(f"Base image created at {self.base_image}")
            shutil.copytree(self.base_image, self.rootfs)
            os.chown(self.rootfs, pwd.getpwnam('bolt').pw_uid, pwd.getpwnam('bolt').pw_gid)
            self.apply_resource_limits()
            if self.project:
                self.project.load()
                self.project.config['sandboxes'].append(self.name)
                self.project.config['sandboxes'] = list(dict.fromkeys(self.project.config['sandboxes']))  # Remove duplicates
                self.project.save()
            logger.info(f"Sandbox {self.name} created at {self.rootfs}")
            return True
        except Exception as e:
            logger.error(f"Failed to create sandbox {self.name}: {str(e)}")
            raise

    def delete(self):
        try:
            if not os.path.exists(self.rootfs):
                raise ValueError(f"Sandbox {self.name} does not exist")
            if self.shell_server:
                self.shell_server.stop()
            cpu_cgroup = os.path.join(CGROUP_BASE, 'cpu', 'bolt', self.name)
            memory_cgroup = os.path.join(CGROUP_BASE, 'memory', 'bolt', self.name)
            shutil.rmtree(cpu_cgroup, ignore_errors=True)
            shutil.rmtree(memory_cgroup, ignore_errors=True)
            for host_port in list(self.port_mappings.keys()):
                self.remove_port_forward(host_port)
            for container_port in list(self.reverse_port_mappings.keys()):
                self.remove_reverse_port_forward(container_port)
            shutil.rmtree(self.rootfs)
            if self.project:
                self.project.load()
                if self.name in self.project.config['sandboxes']:
                    self.project.config['sandboxes'].remove(self.name)
                    self.project.save()
            logger.info(f"Sandbox {self.name} deleted")
            return True
        except Exception as e:
            logger.error(f"Failed to delete sandbox {self.name}: {str(e)}")
            raise

    def apply_resource_limits(self):
        try:
            limits = self.project.config['resource_limits'] if self.project else config['default_resource_limits']
            with cgroup_context(self.name) as (cpu_cgroup, memory_cgroup):
                with open(os.path.join(cpu_cgroup, 'cpu.cfs_quota_us'), 'w') as f:
                    f.write(str(limits['cpu_quota_us']))
                with open(os.path.join(cpu_cgroup, 'cpu.cfs_period_us'), 'w') as f:
                    f.write('100000')
                with open(os.path.join(memory_cgroup, 'memory.limit_in_bytes'), 'w') as f:
                    f.write(str(limits['memory_limit_bytes']))
                pid = str(os.getpid())
                with open(os.path.join(cpu_cgroup, 'tasks'), 'w') as f:
                    f.write(pid)
                with open(os.path.join(memory_cgroup, 'tasks'), 'w') as f:
                    f.write(pid)
            logger.info(f"Resource limits applied for sandbox {self.name}")
        except Exception as e:
            logger.error(f"Failed to apply resource limits for sandbox {self.name}: {str(e)}")
            raise

    def forward_port(self, host_port, container_port):
        try:
            host_port, container_port = int(host_port), int(container_port)
            if host_port not in config['allowed_ports']:
                raise ValueError(f"Host port {host_port} not in allowed range")
            if not os.path.exists(self.rootfs):
                raise ValueError(f"Sandbox {self.name} does not exist")
            cmd = [
                'iptables', '-t', 'nat', '-A', 'PREROUTING',
                '-p', 'tcp', '--dport', str(host_port),
                '-j', 'REDIRECT', '--to-ports', str(container_port)
            ]
            subprocess.run(cmd, check=True)
            self.port_mappings[host_port] = container_port
            logger.info(f"Port forwarding set: {host_port} -> {container_port} for sandbox {self.name}")
            return True
        except Exception as e:
            logger.error(f"Failed to forward port for sandbox {self.name}: {str(e)}")
            raise

    def reverse_port_forward(self, container_port, host_port):
        try:
            container_port, host_port = int(container_port), int(host_port)
            if host_port not in config['allowed_ports']:
                raise ValueError(f"Host port {host_port} not in allowed range")
            if not os.path.exists(self.rootfs):
                raise ValueError(f"Sandbox {self.name} does not exist")
            cmd = [
                'iptables', '-t', 'nat', '-A', 'OUTPUT',
                '-p', 'tcp', '--sport', str(container_port),
                '-j', 'REDIRECT', '--to-ports', str(host_port)
            ]
            subprocess.run(cmd, check=True)
            self.reverse_port_mappings[container_port] = host_port
            logger.info(f"Reverse port forwarding set: {container_port} -> {host_port} for sandbox {self.name}")
            return True
        except Exception as e:
            logger.error(f"Failed to reverse forward port for sandbox {self.name}: {str(e)}")
            raise

    def remove_port_forward(self, host_port):
        try:
            host_port = int(host_port)
            if host_port not in self.port_mappings:
                raise ValueError(f"No port forwarding for {host_port}")
            cmd = [
                'iptables', '-t', 'nat', '-D', 'PREROUTING',
                '-p', 'tcp', '--dport', str(host_port),
                '-j', 'REDIRECT', '--to-ports', str(self.port_mappings[host_port])
            ]
            subprocess.run(cmd, check=True)
            del self.port_mappings[host_port]
            logger.info(f"Removed port forwarding for {host_port} in sandbox {self.name}")
            return True
        except Exception as e:
            logger.error(f"Failed to remove port forwarding for sandbox {self.name}: {str(e)}")
            raise

    def remove_reverse_port_forward(self, container_port):
        try:
            container_port = int(container_port)
            if container_port not in self.reverse_port_mappings:
                raise ValueError(f"No reverse port forwarding for {container_port}")
            cmd = [
                'iptables', '-t', 'nat', '-D', 'OUTPUT',
                '-p', 'tcp', '--sport', str(container_port),
                '-j', 'REDIRECT', '--to-ports', str(self.reverse_port_mappings[container_port])
            ]
            subprocess.run(cmd, check=True)
            del self.reverse_port_mappings[container_port]
            logger.info(f"Removed reverse port forwarding for {container_port} in sandbox {self.name}")
            return True
        except Exception as e:
            logger.error(f"Failed to remove reverse port forwarding for sandbox {self.name}: {str(e)}")
            raise

    def start_shell(self):
        try:
            if not os.path.exists(self.rootfs):
                raise ValueError(f"Sandbox {self.name} does not exist")
            if self.shell_server:
                raise ValueError(f"Shell server already running on port {self.shell_port}")
            for port in config['shell_port_range']:
                try:
                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    sock.bind(('0.0.0.0', port))
                    sock.close()
                    self.shell_port = port
                    break
                except:
                    continue
            else:
                raise ValueError("No available shell ports")
            self.shell_token = secrets.token_hex(16)
            self.shell_server = ShellServer(self, self.shell_port, self.shell_token)
            self.shell_server.start()
            logger.info(f"Shell server started for {self.name} on port {self.shell_port}")
            return self.shell_port, self.shell_token
        except Exception as e:
            logger.error(f"Failed to start shell for sandbox {self.name}: {str(e)}")
            raise

# Authentication middleware
def check_auth(username, password):
    return username == config['admin_user'] and check_password_hash(config['admin_password'], password)

def requires_auth(f):
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return jsonify({'error': 'Authentication required'}), 401
        return f(*args, **kwargs)
    return decorated

# API Endpoints
@app.route('/api/projects', methods=['POST'])
@requires_auth
def create_project():
    data = request.json
    name = sanitize_input(data.get('name'))
    if not name:
        return jsonify({'error': 'Project name required'}), 400
    try:
        project = Project(name)
        project.create()
        return jsonify({'message': f'Project {name} created successfully'}), 201
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<name>', methods=['DELETE'])
@requires_auth
def delete_project(name):
    name = sanitize_input(name)
    try:
        project = Project(name)
        project.delete()
        return jsonify({'message': f'Project {name} deleted successfully'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes', methods=['POST'])
@requires_auth
def create_sandbox(project_name):
    project_name = sanitize_input(project_name)
    data = request.json
    name = sanitize_input(data.get('name'))
    distro = sanitize_input(data.get('distro'))
    if not name:
        return jsonify({'error': 'Sandbox name required'}), 400
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project, distro)
        sandbox.create()
        return jsonify({'message': f'Sandbox {name} created in project {project_name}'}), 201
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes/<name>', methods=['DELETE'])
@requires_auth
def delete_sandbox(project_name, name):
    project_name, name = sanitize_input(project_name), sanitize_input(name)
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project)
        sandbox.delete()
        return jsonify({'message': f'Sandbox {name} deleted from project {project_name}'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes/<name>/shell', methods=['POST'])
@requires_auth
def open_shell(project_name, name):
    project_name, name = sanitize_input(project_name), sanitize_input(name)
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project)
        port, token = sandbox.start_shell()
        return jsonify({'message': f'Shell started for sandbox {name} on port {port}', 'port': port, 'token': token}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes/<name>/ports', methods=['POST'])
@requires_auth
def forward_port(project_name, name):
    project_name, name = sanitize_input(project_name), sanitize_input(name)
    data = request.json
    host_port = data.get('host_port')
    container_port = data.get('container_port')
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project)
        sandbox.forward_port(host_port, container_port)
        return jsonify({'message': f'Port {host_port} forwarded to {container_port}'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes/<name>/reverse_ports', methods=['POST'])
@requires_auth
def reverse_port_forward(project_name, name):
    project_name, name = sanitize_input(project_name), sanitize_input(name)
    data = request.json
    container_port = data.get('container_port')
    host_port = data.get('host_port')
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project)
        sandbox.reverse_port_forward(container_port, host_port)
        return jsonify({'message': f'Port {container_port} forwarded to host {host_port}'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes/<name>/ports/<int:host_port>', methods=['DELETE'])
@requires_auth
def remove_port_forward(project_name, name, host_port):
    project_name, name = sanitize_input(project_name), sanitize_input(name)
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project)
        sandbox.remove_port_forward(host_port)
        return jsonify({'message': f'Port forwarding for {host_port} removed'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/sandboxes/<name>/reverse_ports/<int:container_port>', methods=['DELETE'])
@requires_auth
def remove_reverse_port_forward(project_name, name, container_port):
    project_name, name = sanitize_input(project_name), sanitize_input(name)
    try:
        project = Project(project_name)
        project.load()
        sandbox = Sandbox(name, project)
        sandbox.remove_reverse_port_forward(container_port)
        return jsonify({'message': f'Reverse port forwarding for {container_port} removed'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/projects/<project_name>/resources', methods=['PUT'])
@requires_auth
def set_project_resources(project_name):
    project_name = sanitize_input(project_name)
    data = request.json
    cpu_quota_us = data.get('cpu_quota_us')
    memory_limit_bytes = data.get('memory_limit_bytes')
    try:
        project = Project(project_name)
        project.load()
        project.set_resource_limits(cpu_quota_us, memory_limit_bytes)
        return jsonify({'message': f'Resource limits updated for project {project_name}'}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 400

@app.route('/api/config', methods=['PUT'])
@requires_auth
def update_config():
    data = request.json
    new_user = sanitize_input(data.get('admin_user'))
    new_password = data.get('admin_password')
    try:
        if new_user:
            config['admin_user'] = new_user
        if new_password:
            config['admin_password'] = generate_password_hash(new_password)
        with open(CONFIG_FILE, 'w') as f:
            json.dump(config, f, indent=4)
        os.chmod(CONFIG_FILE, 0o600)
        logger.info("Configuration updated")
        return jsonify({'message': 'Configuration updated successfully'}), 200
    except Exception as e:
        logger.error(f"Failed to update config: {str(e)}")
        return jsonify({'error': str(e)}), 400

@app.route('/api/status', methods=['GET'])
@requires_auth
def status():
    try:
        projects = []
        for project_name in os.listdir(PROJECTS_BASE_DIR):
            project_path = os.path.join(PROJECTS_BASE_DIR, project_name)
            if os.path.isdir(project_path):
                project = Project(project_name)
                project.load()
                sandboxes = []
                for sandbox_name in project.config['sandboxes']:
                    sandbox = Sandbox(sandbox_name, project)
                    sandboxes.append({
                        'name': sandbox_name,
                        'distro': sandbox.distro,
                        'created_at': sandbox.created_at,
                        'port_mappings': sandbox.port_mappings,
                        'reverse_port_mappings': sandbox.reverse_port_mappings
                    })
                projects.append({
                    'name': project_name,
                    'sandboxes': sandboxes,
                    'resource_limits': project.config['resource_limits'],
                    'created_at': project.config['created_at']
                })
        return jsonify({
            'projects': projects,
            'system': {
                'cpu_usage': psutil.cpu_percent(),
                'memory_usage': psutil.virtual_memory().percent,
                'disk_usage': psutil.disk_usage('/').percent
            },
            'version': '1.0.0'
        }), 200
    except Exception as e:
        logger.error(f"Failed to get status: {str(e)}")
        return jsonify({'error': str(e)}), 400

@app.route('/api/update', methods=['GET'])
@requires_auth
def check_update():
    try:
        # Mocked update check (replace with real update server in production)
        latest_version = '1.0.1'  # Example
        current_version = '1.0.0'
        update_available = latest_version > current_version
        return jsonify({
            'update_available': update_available,
            'latest_version': latest_version,
            'current_version': current_version
        }), 200
    except Exception as e:
        logger.error(f"Failed to check update: {str(e)}")
        return jsonify({'error': str(e)}), 400

def check_requirements():
    if not os.path.exists(DEBOOTSTRAP_DIR):
        logger.error("debootstrap is not installed")
        sys.exit(1)
    if not shutil.which('iptables'):
        logger.error("iptables is not installed")
        sys.exit(1)
    if not os.path.exists(CGROUP_BASE):
        logger.error("cgroups not supported or mounted")
        sys.exit(1)
    try:
        pwd.getpwnam('bolt')
    except KeyError:
        logger.error("User 'bolt' does not exist")
        sys.exit(1)

def main():
    parser = argparse.ArgumentParser(description="Bolt Sandbox Server")
    parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')
    parser.add_argument('--port', type=int, default=5000, help='Port to listen on')
    args = parser.parse_args()

    check_requirements()
    ensure_directories()
    ensure_ssl()
    logger.info("Starting Bolt server")
    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    context.load_cert_chain(SSL_CERT, SSL_KEY)
    app.run(host=args.host, port=args.port, ssl_context=context)

if __name__ == '__main__':
    main()