Вот части моего кода:
background.js:
```js
// js/background.js

const SERVER_URL = 'http://85.236.189.41:5011';  // Замените на ваш URL сервера Flask
const EXTENSION_VERSION = '1.0';

const SERVER_HOSTNAME = new URL(SERVER_URL).hostname;

let isConnected = false;
let heartbeatInterval = null;
let userKey = null;
let currentProxyConfig = null;


function displayUserStatus(data) {
    if (data.user_data) {
        const userInfoContainer = document.getElementById('userInfo');
        const n_data = data.user_data

        if (n_data.username && n_data.daysRemaining) {
            console.log("username = ", n_data.username)
            console.log("daysRemaining = ", n_data.daysRemaining)
        }
        else {
            console.log("No username, no daysRemaining")
        }

        let displayMessage;
        if (n_data.message === 'User not found') {
            displayMessage = `${n_data.username || 'Пользователь'} - unauthorized`;
        } else if (n_data.message === 'Subscription expired') {
            displayMessage = `${n_data.username || 'Пользователь'} - подписка истекла`;
        } else {
            displayMessage = `${n_data.username} - ${n_data.daysRemaining} дней`;
        }
        //else {
        //    displayMessage = `Ошибка: ${data.message}`;
        //}
        userInfoContainer.innerHTML = `<p style="color: red;">${displayMessage}</p>`;
        userInfoContainer.style.display = 'block';
    }
}


// Функция для хранения userKey
function setUserKey(key) {
    userKey = key;
    chrome.storage.sync.set({ userKey: key });
}

// Функция для получения userKey
function getUserKey(callback) {
    if (userKey) {
        callback(userKey);
    } else {
        chrome.storage.sync.get('userKey', function (data) {
            if (data.userKey) {
                userKey = data.userKey;
                callback(userKey);
            } else {
                // Нет ключа пользователя, ничего не делаем
                console.error('User key is not set.');
                callback(null);
            }
        });
    }
}

// Функция для подключения VPN с настройками прокси от сервера
function connectVPN(proxyConfig) {
    if (currentProxyConfig &&
        JSON.stringify(currentProxyConfig) === JSON.stringify(proxyConfig)) {
        // Конфигурация прокси не изменилась, нет необходимости устанавливать ее снова
        return;
    }

    chrome.proxy.settings.set({ value: proxyConfig, scope: 'regular' }, function () {
        if (chrome.runtime.lastError) {
            console.error('Proxy settings error: ', chrome.runtime.lastError);
            return;
        }
        currentProxyConfig = proxyConfig;
        console.log('VPN подключен.');
    });
}

// Функция для отключения VPN
function disconnectVPN() {
    chrome.proxy.settings.clear({ scope: 'regular' }, function () {
        if (chrome.runtime.lastError) {
            console.error('Error clearing proxy settings: ', chrome.runtime.lastError);
            return;
        }
        currentProxyConfig = null;
        console.log('VPN отключен.');
    });
}

// Функция для запуска отправки heartbeat каждые 10 секунд
function startHeartbeat() {
    if (heartbeatInterval) {
        clearInterval(heartbeatInterval);
    }

    heartbeatInterval = setInterval(function () {
        sendHeartbeat();
    }, 10000);

    // Отправка сразу при запуске
    sendHeartbeat();
}

// Функция для остановки отправки heartbeat
function stopHeartbeat() {
    if (heartbeatInterval) {
        clearInterval(heartbeatInterval);
        heartbeatInterval = null;
    }
}

// Функция для отправки heartbeat и получения настроек прокси
function sendHeartbeat() {
    getUserKey(function (userKey) {
        if (!userKey) {
            // Ключ пользователя не установлен, не можем отправить heartbeat
            console.error('Cannot send heartbeat without userKey.');
            disconnectVPN();
            return;
        }

        // Получение URL текущей активной вкладки
        chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
            const currentUrl = tabs && tabs.length > 0 && tabs[0].url ? tabs[0].url : 'unknown';

            fetch(`${SERVER_URL}/api/heartbeat`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    userKey: userKey,
                    version: EXTENSION_VERSION,
                    currentUrl: currentUrl,
                    isConnected: isConnected
                })
            })
                .then(response => response.json())
                .then(data => {
                    displayUserStatus(data)
                    if (data.status === 'ok') {
                        if (isConnected && data.proxy) {
                            // Получены детали прокси от сервера
                            const newProxyConfig = {
                                mode: "fixed_servers",
                                rules: {
                                    singleProxy: {
                                        scheme: data.proxy.scheme,
                                        host: data.proxy.host,
                                        port: data.proxy.port
                                    },
                                    bypassList: ["localhost", SERVER_HOSTNAME]
                                }
                            };

                            connectVPN(newProxyConfig);
                        }
                        // Получение информации о пользователе после успешного heartbeat
                        fetchUserInfo();
                    } else if (data.status === 'update_required') {
                        // Уведомление пользователя о необходимости обновления расширения
                        chrome.notifications.create({
                            type: 'basic',
                            iconUrl: 'icons/icon128.png',
                            title: 'DarkVPN Требуется обновление',
                            message: 'Пожалуйста, обновите расширение DarkVPN до последней версии.'
                        });
                        disconnectVPN();
                    } else if (data.status === 'unauthorized') {
                        // Неавторизованный доступ
                        disconnectVPN();
                        console.warn('Unauthorized access or VPN stopped/banned.');
                        // Очищаем сохранённый ключ пользователя
                        chrome.storage.sync.remove('userKey', function () {
                            userKey = null;
                            // Уведомляем пользователя об ошибке
                            chrome.notifications.create({
                                type: 'basic',
                                iconUrl: 'icons/icon128.png',
                                title: 'DarkVPN Ошибка',
                                message: 'Ключ пользователя недействителен. Пожалуйста, введите действительный ключ.'
                            });
                        });
                    } else if (data.status === 'subscription_expired') {
                        console.warn('Subscription expired.');
                        chrome.notifications.create({
                            type: 'basic',
                            iconUrl: 'icons/icon128.png',
                            title: 'DarkVPN Подписка истекла',
                            message: 'Ваша подписка истекла. Пожалуйста, обновите подписку.'
                        });
                        disconnectVPN();
                    } else {
                        // Другие ошибки
                        console.error('Ошибка от сервера:', data);
                        // Не отключаем VPN и не удаляем ключ
                    }
                })
                .catch(error => {
                    console.error('Ошибка при общении с сервером:', error);
                    chrome.notifications.create({
                        type: 'basic',
                        iconUrl: 'icons/icon128.png',
                        title: 'DarkVPN Ошибка связи',
                        message: 'Не удалось связаться с сервером. Пробуем снова...'
                    });
                    // Не отключаем VPN и не удаляем ключ
                });
        });
    });
}

// Функция для получения информации о пользователе
function fetchUserInfo() {
    if (!userKey) {
        return;
    }
    fetch(`${SERVER_URL}/api/user_info`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ userKey: userKey })
    })
        .then(response => response.json())
        .then(data => {
            if (data.status === 'ok') {
                chrome.storage.local.set({
                    daysRemaining: data.daysRemaining,
                    username: data.username
                });
            } else {
                // Обработка ошибок
                console.error('Error fetching user info:', data.message);
            }
        })
        .catch(error => {
            console.error('Error fetching user info:', error);
        });
}

function performLogout(sendResponse) {
    getUserKey(function(userKey) {
        if (!userKey) {
            console.error('Ключ пользователя не найден при выходе.');
            // Продолжаем очистку данных даже если ключ уже отсутствует
            disconnectVPN();
            stopHeartbeat();
            chrome.storage.local.set({ isConnected: false }, function() {
                chrome.storage.sync.remove('userKey', function() {
                    chrome.storage.local.remove(['daysRemaining', 'username'], function() {
                        sendResponse({ success: true });
                    });
                });
            });
            return;
        }

        // Отправляем финальный heartbeat
        fetch(`${SERVER_URL}/api/heartbeat`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                userKey: userKey,
                version: EXTENSION_VERSION,
                currentUrl: 'logout',
                isConnected: false
            })
        })
        .then(response => response.json())
        .then(data => {
            // Дополнительная обработка ответа от сервера при необходимости
        })
        .catch(error => {
            console.error('Ошибка при отправке heartbeat во время выхода:', error);
            // Несмотря на ошибку, продолжаем процесс выхода
        })
        .finally(() => {
            // Отключаем VPN и очищаем данные
            disconnectVPN();
            stopHeartbeat();
            chrome.storage.local.set({ isConnected: false }, function() {
                chrome.storage.sync.remove('userKey', function() {
                    chrome.storage.local.remove(['daysRemaining', 'username'], function() {
                        sendResponse({ success: true });
                    });
                });
            });
        });
    });
}

// Обработка сообщений от попапа
chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
    if (request.action === 'toggleConnection') {
        isConnected = !isConnected;
        chrome.storage.local.set({ isConnected: isConnected });

        if (isConnected) {
            // Запустить heartbeat и попытаться подключиться
            startHeartbeat();
            sendResponse({ isConnected: true });
        } else {
            // Отключить VPN, отправить финальный heartbeat и остановить heartbeat
            disconnectVPN();
            sendHeartbeat(); // Отправить финальный heartbeat, чтобы сообщить серверу
            stopHeartbeat();
            sendResponse({ isConnected: false });
        }
    } else if (request.action === 'userKeyUpdated') {
        setUserKey(request.userKey);
        sendResponse({});
    } else if (request.action === 'logout') {
        // Обработка выхода из аккаунта
        performLogout(sendResponse);
        return true; // Указывает, что sendResponse будет вызван асинхронно
    }
    return true; // Указывает, что sendResponse будет вызван асинхронно
});

// При запуске расширения получить состояние подключения
chrome.storage.local.get('isConnected', function (data) {
    isConnected = data.isConnected || false;
    if (isConnected) {
        startHeartbeat();
    } else {
        disconnectVPN();
    }
});

// Прослушивание изменений на вкладках для обновления текущего URL
chrome.tabs.onActivated.addListener(function (activeInfo) {
    if (isConnected) {
        sendHeartbeat();
    }
});

chrome.tabs.onUpdated.addListener(function (tabId, changeInfo, tab) {
    if (changeInfo.url && isConnected) {
        sendHeartbeat();
    }
});
```

Вот popup.js:
```js
// js/popup.js

function displayUserStatus(data) {
    if (data.user_data) {
        const userInfoContainer = document.getElementById('userInfo');
        const n_data = data.user_data

        if (n_data.username && n_data.daysRemaining) {
            console.log("username = ", n_data.username)
            console.log("daysRemaining = ", n_data.daysRemaining)
        }
        else {
            console.log("No username, no daysRemaining")
        }

        let displayMessage;
        if (n_data.message === 'User not found') {
            displayMessage = `${n_data.username || 'Пользователь'} - unauthorized`;
        } else if (n_data.message === 'Subscription expired') {
            displayMessage = `${n_data.username || 'Пользователь'} - подписка истекла`;
        } else {
            displayMessage = `${n_data.username} - ${n_data.daysRemaining} дней`;
        }
        //else {
        //    displayMessage = `Ошибка: ${data.message}`;
        //}
        userInfoContainer.innerHTML = `<p style="color: red;">${displayMessage}</p>`;
        userInfoContainer.style.display = 'block';
    }
}

document.addEventListener('DOMContentLoaded', function () {
    const toggleButton = document.getElementById('toggleButton');
    const buttonTitle = document.querySelector('.b-title');
    const userKeySection = document.getElementById('userKeySection');
    const userKeyInput = document.getElementById('userKeyInput');
    const saveUserKeyButton = document.getElementById('saveUserKeyButton');

    let userKey = null;

    function getUserInfo(userKey) {
        fetch('http://85.236.189.41:5011/api/user_info', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({userKey: userKey})
        })
            .then(response => response.json())
            .then(data => {
                displayUserStatus(data);
                if (data.status === 'ok') {
                    chrome.storage.local.set({
                        daysRemaining: data.daysRemaining,
                        username: data.username
                    });
                    //displayUserStatus(data);
                }
                //////isSubscriptionExpired
            })
            .catch(error => {
                console.error('Ошибка при запросе к серверу:', error);
                userInfoContainer.innerHTML = `<p style="color: red;">Ошибка сети</p>`;
                userInfoContainer.style.display = 'block';
            });
    }

    function updateButtonState(isConnected) {
        console.log("isConnectedisConnected = ",isConnected)
        if (isConnected) {
            toggleButton.classList.add('connected');
            buttonTitle.textContent = "Отключить";
        } else {
            toggleButton.classList.remove('connected');
            buttonTitle.textContent = "Подключить";
        }
    }

    function checkUserKey() {
        chrome.storage.sync.get('userKey', function (data) {
            if (data.userKey) {
                userKey = data.userKey;
                // Ключ пользователя сохранён, скрываем раздел ввода ключа
                userKeySection.style.display = 'none';
                // Отображаем основной интерфейс
                document.querySelector('.toggle-container').style.display = 'flex';
                document.querySelector('.info-container').style.display = 'flex';
                // Получаем сохраненную информацию о пользователе
                chrome.storage.local.get(['daysRemaining', 'username'], function(info) {
                    if (info.daysRemaining !== undefined && info.username) {
                        displayUserStatus(data);
                    } else {
                        // Запрашиваем информацию о пользователе
                        getUserInfo(userKey);
                    }
                });
                // Получаем статус подключения
                chrome.storage.local.get('isConnected', function (data) {
                    updateButtonState(data.isConnected);
                });
            } else {
                // Ключ пользователя не сохранён, показываем раздел ввода ключа
                userKeySection.style.display = 'flex';
                // Скрываем основной интерфейс
                document.querySelector('.toggle-container').style.display = 'none';
                document.querySelector('.info-container').style.display = 'none';
                document.querySelector('.dark-vpn-title').style.opacity = '0';
            }
        });
    }

    // Обработчик нажатия на кнопку сохранения ключа
    saveUserKeyButton.addEventListener('click', function () {
        const userKey = userKeyInput.value.trim();
        if (userKey) {
            // Сохраняем ключ пользователя
            chrome.storage.sync.set({userKey: userKey}, function () {
                // Очищаем поле ввода
                userKeyInput.value = '';
                // Обновляем интерфейс
                checkUserKey();
                // Отправляем сообщение фоновому скрипту для обновления ключа
                chrome.runtime.sendMessage({action: 'userKeyUpdated', userKey: userKey}, function (response) {
                });
            });
        } else {
            alert('Пожалуйста, введите ключ пользователя.');
        }
    });

    // Обработчик переключения состояния VPN
    toggleButton.addEventListener('click', function () {
        chrome.runtime.sendMessage({action: 'toggleConnection'}, function (response) {
            if (response && typeof response.isConnected !== 'undefined') {
                updateButtonState(response.isConnected);
            }
        });
    });

    // Проверяем наличие ключа пользователя при загрузке
    checkUserKey();

    // Прослушивание изменений в хранилище (на случай изменения ключа в другом месте)
    chrome.storage.onChanged.addListener(function (changes, area) {
        if (area === 'sync' && changes.userKey) {
            checkUserKey();
        }
        if (area === 'local' && (changes.daysRemaining || changes.username)) {
            chrome.storage.local.get(['daysRemaining', 'username'], function(info) {
                if (info.daysRemaining !== undefined && info.username) {
                    displayUserStatus(data);
                }
            });
        }
    });
});
```
Я что-то совершенно не так сделал, наговнокодил. Вот код сервера:
```py
# auth_server.py

import os
from flask import Flask, request, jsonify, session, render_template, redirect, url_for
from flask_socketio import SocketIO, emit
from datetime import datetime, timedelta
import uuid
import threading
from flask_cors import CORS
import logging

# Load environment variables (optional)
from dotenv import load_dotenv

load_dotenv()

from database import Database

app = Flask(__name__)
app.secret_key = os.getenv('SECRET_KEY', 'default_secret_key')
CORS(app)

socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

db = Database()
admin_password = os.getenv('ADMIN_PASSWORD', 'viktortop4ik')
latest_extension_version = '1.0'

# Interval for checking user activity (seconds)
CHECK_INTERVAL = 10
TIMEOUT = 30  # Time without heartbeat before considering user disconnected


def check_user_activity():
    while True:
        socketio.sleep(CHECK_INTERVAL)
        now = datetime.utcnow()
        users = db.get_all_users()
        for user in users:
            if user['last_seen']:
                elapsed = (now - user['last_seen']).total_seconds()
                if elapsed > TIMEOUT and user['is_connected']:
                    user['is_connected'] = False
                    db.update_user(user)
                    emit_user_update(user)
                    logger.info(f"User {user['key']} disconnected due to timeout (last_seen: {user['last_seen']}).")


# Start background task for checking user activity
socketio.start_background_task(target=check_user_activity)


# API Endpoint for heartbeat
@app.route('/api/heartbeat', methods=['POST'])
def api_heartbeat():
    data = request.get_json()
    user_key = data.get('userKey')
    version = data.get('version')
    current_url = data.get('currentUrl')
    client_ip = request.remote_addr
    is_connected = data.get('isConnected', False)

    logger.info(
        f"Heartbeat received from userKey: {user_key}, IP: {client_ip}, URL: {current_url}, Connected: {is_connected}")

    if version != latest_extension_version:
        logger.warning(f"Version mismatch: {version} != {latest_extension_version}")
        return jsonify({'status': 'update_required'}), 200

    user = db.get_user_by_key(user_key)

    if not user:
        logger.warning(f"Unauthorized access attempt with userKey: {user_key}")
        return jsonify({'status': 'unauthorized'}), 403

    # Update user info
    user['last_seen'] = datetime.utcnow()
    user['ip'] = client_ip
    user['current_url'] = current_url
    user['is_connected'] = is_connected

    response_data = get_user_info(user)

    if not is_connected:
        # User is not connected, send update and don't provide proxy details
        db.update_user(user)
        emit_user_update(user)
        logger.info(f"User {user_key} is disconnected.")
        return jsonify({'status': 'disconnected', 'user_data': response_data}), 200

    if user['is_banned'] or user['is_stopped']:
        user['is_connected'] = False
        db.update_user(user)
        emit_user_update(user)
        logger.info(f"User {user_key} is {'banned' if user['is_banned'] else 'stopped'}.")
        return jsonify({'status': 'unauthorized', 'user_data': response_data}), 403

    if user['subscription_expires'] < datetime.utcnow():
        user['is_connected'] = False
        db.update_user(user)
        emit_user_update(user)
        logger.info(f"Subscription expired for user {user_key}.")
        return jsonify({'status': 'subscription_expired', 'user_data': response_data}), 403

    # User is authorized and connected, provide proxy details
    proxy_details = {
        'host': '185.106.94.81',
        'port': 44590,
        'scheme': 'socks5'
    }

    db.update_user(user)
    emit_user_update(user)
    logger.info(f"Proxy details sent to user {user_key}.")

    return jsonify({'status': 'ok', 'proxy': proxy_details, 'user_data': response_data}), 200

def get_user_info(user):
    if not user:
        return jsonify({'status': 'error', 'message': 'User not found'}), 404

    days_remaining = (user['subscription_expires'] - datetime.utcnow()).days
    subscription_expired = user['subscription_expires'] < datetime.utcnow()

    # Always include isSubscriptionExpired, defaulting to False
    response_data = {
        'status': 'ok',
        'username': user['username'],
        'daysRemaining': max(0, days_remaining),  # Ensure daysRemaining is not negative
        'isSubscriptionExpired': subscription_expired
    }
    return response_data


# LEGACY # LEGACY # LEGACY # LEGACY # LEGACY # LEGACY
@app.route('/api/user_info', methods=['POST'])
def api_user_info():
    data = request.get_json()
    user_key = data.get('userKey')

    user = db.get_user_by_key(user_key)
    response_data = get_user_info(user)

    return jsonify(response_data), 200
# LEGACY # LEGACY # LEGACY # LEGACY # LEGACY # LEGACY


# Function to send user updates to admin clients
def emit_user_update(user):
    socketio.emit('user_update', {
        'key': user['key'],
        'username': user['username'],
        'ip': user['ip'] or 'N/A',
        'current_url': user['current_url'] or 'N/A',
        'is_connected': user['is_connected'],
        'subscription_expires': user['subscription_expires'].isoformat(),
        'is_banned': user['is_banned'],
        'is_stopped': user['is_stopped']
    }, namespace='/')


# Admin login
@app.route('/admin', methods=['GET', 'POST'])
def admin_login():
    if 'admin_logged_in' in session:
        return redirect(url_for('admin_panel'))

    if request.method == 'POST':
        password = request.form.get('password')
        if password == admin_password:
            session['admin_logged_in'] = True
            logger.info("Admin logged in successfully.")
            return redirect(url_for('admin_panel'))
        else:
            logger.warning("Invalid admin password attempt.")
            return render_template('admin_login.html', error='Неверный пароль')

    return render_template('admin_login.html')


# Admin panel
@app.route('/admin/panel')
def admin_panel():
    if 'admin_logged_in' not in session:
        return redirect(url_for('admin_login'))

    return render_template('admin_panel.html')


# Admin route to add a new user
@app.route('/admin/add_user', methods=['POST'])
def admin_add_user():
    print("add_user")
    if 'admin_logged_in' not in session:
        return jsonify({'status': 'error', 'message': 'Unauthorized'}), 401

    try:
        data = request.get_json()
        username = data.get('username')
        days = int(data.get('days', 0))

        if not username or days <= 0:
            logger.error("Invalid data for adding user.")
            return jsonify({'status': 'error', 'message': 'Invalid data'}), 400

        user_key = str(uuid.uuid4())
        subscription_expires = datetime.utcnow() + timedelta(days=days)
        print(0)
        user = db.add_user(username, user_key, subscription_expires)
        print(1)
        emit_user_update(user)
        print(2)
        logger.info(f"New user added: {username} with key: {user_key}")

        return jsonify({'status': 'ok', 'userKey': user_key}), 200

    except (ValueError, TypeError) as e:
        logger.error(f"Error adding user: {e}")
        return jsonify({'status': 'error', 'message': 'Invalid input'}), 400


# Admin actions with users
@app.route('/admin/action', methods=['POST'])
def admin_action():
    if 'admin_logged_in' not in session:
        return jsonify({'status': 'error', 'message': 'Unauthorized'}), 401

    try:
        data = request.get_json()
        action = data.get('action')
        user_key = data.get('userKey')

        if not action or not user_key:
            logger.error("Missing action or userKey in admin_action.")
            return jsonify({'status': 'error', 'message': 'Invalid data'}), 400

        user = db.get_user_by_key(user_key)
        if not user:
            logger.warning(f"User not found: {user_key}")
            return jsonify({'status': 'error', 'message': 'User not found'}), 404

        if action == 'ban':
            user['is_banned'] = not user['is_banned']
            db.update_user(user)
            logger.info(f"User {user_key} ban status toggled to {user['is_banned']}.")
        elif action == 'stop':
            user['is_stopped'] = not user['is_stopped']
            db.update_user(user)
            logger.info(f"User {user_key} stop status toggled to {user['is_stopped']}.")
        elif action == 'renew':
            try:
                days = int(data.get('days'))  # Get days as an integer
            except (ValueError, TypeError):
                logger.error("Invalid days value for renewal.")
                return jsonify({'status': 'error', 'message': 'Invalid days value'}), 400

            if days == 0:  # Check if days is zero, then set expiration to now!!
                user['subscription_expires'] = datetime.utcnow()  # Set expiration to now
                db.update_user(user)
                logger.info(f"User {user_key} subscription set to expired.")
                emit_user_update(user)
                return jsonify({'status': 'ok'}), 200

            if days > 0:
                if user['subscription_expires'] < datetime.utcnow():
                    user['subscription_expires'] = datetime.utcnow() + timedelta(days=days)
                else:
                    user['subscription_expires'] += timedelta(days=days)
                logger.info(f"User {user_key} subscription renewed by {days} days.")

            elif days < 0:  # Handle negative days
                user['subscription_expires'] -= timedelta(days=abs(days))  # Subtract days
                logger.info(f"User {user_key} subscription reduced by {abs(days)} days.")

            db.update_user(user)  # Update user in the database
        elif action == 'delete':
            db.delete_user(user_key)
            logger.info(f"User {user_key} deleted.")
            socketio.emit('user_deleted', {'key': user_key}, namespace='/')
        else:
            logger.error(f"Invalid action: {action}")
            return jsonify({'status': 'error', 'message': 'Invalid action'}), 400

        if action != 'delete':
            emit_user_update(user)
        return jsonify({'status': 'ok'}), 200

    except (ValueError, TypeError) as e:
        logger.error(f"Error in admin_action: {e}")
        return jsonify({'status': 'error', 'message': 'Invalid input'}), 400


# SocketIO connection event for admin panel
@socketio.on('connect')
def handle_connect():
    if 'admin_logged_in' in session:
        logger.info("Admin client connected via SocketIO.")
        # Send all current users to connected admin client
        users = db.get_all_users()
        for user in users:
            emit_user_update(user)
    else:
        logger.warning("Unauthorized SocketIO connection attempt.")
        emit('error', {'message': 'Unauthorized'}, namespace='/')
        # Close the connection for unauthorized users
        return False  # Interrupt the connection


# Route to log out
@app.route('/admin/logout')
def admin_logout():
    session.pop('admin_logged_in', None)
    logger.info("Admin logged out.")
    return redirect(url_for('admin_login'))


# Run the application
if __name__ == '__main__':
    socketio.run(app, host='0.0.0.0', port=5011, allow_unsafe_werkzeug=True)
```
Перепиши код js, чтобы он работал нормально.

Спасибо!