Улучши код, доработай расшифровку данных с WebSocket, я хочу чтобы они были читаемыми. 

```js

const http = require('http');
const https = require('https');
const fs = require('fs');
const WebSocket = require('ws');
const path = require('path');
const crypto = require('crypto');

// Порты для HTTP и HTTPS
const httpPort = 80;
const httpsPort = 443;

// Загрузка сертификатов и параметров для HTTPS
const httpsOptions = {
    key: fs.readFileSync('./security/server.key'),
    cert: fs.readFileSync('./security/server.crt'),
    ca: fs.readFileSync('./security/rootCA.crt'),
    dhparam: fs.readFileSync('./security/dhparam.pem')
};

// Лог-файлы
const requestLogPath = path.join(__dirname, 'requests.log');
const responseLogPath = path.join(__dirname, 'responses.log');

// Функция для записи логов
function logToFile(filePath, data) {
    const logEntry = `${new Date().toISOString()} - ${data}\n\n`;
    fs.appendFile(filePath, logEntry, (err) => {
        if (err) console.error('Ошибка при записи в лог-файл:', err);
    });
}

// Функция для логирования запросов
function logRequest(method, url, headers, body, domain) {
    const logData = `REQUEST: ${method} ${url}
Domain: ${domain}
Headers: ${JSON.stringify(headers, null, 2)}
Body: ${body || 'N/A'}`;
    logToFile(requestLogPath, logData);
}

// Функция для логирования ответов
function logResponse(statusCode, headers, body) {
    const logData = `RESPONSE: Status ${statusCode}
Headers: ${JSON.stringify(headers, null, 2)}
Body: ${body || 'N/A'}`;
    logToFile(responseLogPath, logData);
}

// Функция для получения домена из заголовка Host
function getDomainFromHeaders(headers) {
    const hostHeader = headers['host'];
    if (hostHeader) {
        return hostHeader.split(':')[0]; // Убираем порт, если он есть
    }
    return 'Unknown Domain';
}

// Функция для генерации JWT
function generateJWT(payload, secret = 'your_secret_key') {
    const header = {
        typ: 'JWT',
        alg: 'HS256'
    };

    const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64').replace(/=/g, '');
    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64').replace(/=/g, '');

    const signature = crypto
        .createHmac('sha256', secret)
        .update(`${encodedHeader}.${encodedPayload}`)
        .digest('base64')
        .replace(/=/g, '');

    return `${encodedHeader}.${encodedPayload}.${signature}`;
}

// Функция для создания ответа аутентификации
function createAuthResponse() {
    const now = Math.floor(Date.now() / 1000);
    const payload = {
        iss: "https://api.melonity.gg/auth",
        iat: now,
        exp: now + 1209600, // 14 days
        nbf: now,
        jti: crypto.randomBytes(10).toString('hex'),
        sub: "626766",
        prv: "23bd5c8949f600adb39e701c400872db7a5976f7"
    };

    const access_token = generateJWT(payload);

    return {
        access_token: access_token,
        expires_in: 1209600,
        token_type: "bearer",
        user: {
            award_balance: 0,
            balance: "0",
            ban_reason: null,
            cheat_version: "stable",
            cloud_slug: null,
            created_at: "2024-08-29T22:46:33.000000Z",
            display_login: "garkeparku",
            email: "garkeparku@gufum.com",
            expires_at: null,
            has_v2_access: 0,
            hwid: null,
            hwid_date: null,
            hwid_from: null,
            id: 626766,
            is_banned: 0,
            is_china: 0,
            is_cloud_radar_active: 0,
            is_recurrent_payments_enabled: 0,
            is_skinchanger: 0,
            login: "garkeparku",
            preferred_version: "stable",
            promocode_usage_datetime: null,
            reccurent_tries: 0,
            recurrent_payment_card_id: null,
            recurrent_product_id: null,
            recurrent_subscription_value: null,
            referral_code_id: null,
            register_country: "RU",
            role: "0",
            subscription_frozen_date: null,
            subscription_frozen_length: null,
            subscription_next_froze_date: null,
            subscription_unfrozen_date: null,
            telegram_id: null,
            test_status: 0,
            traffic_source: null,
            updated_at: "2024-08-29T23:32:50.000000Z",
            used_special_promocode: 0,
            used_special_promocode_days_value: null,
            valid_from: null,
            vk_confirmation_code: "1027-8928",
            vk_is_member: 0,
            vk_user_id: null
        }
    };
}

// Обработчик запросов
function requestHandler(req, res) {
    const domain = getDomainFromHeaders(req.headers);

    console.log(`${req.connection.encrypted ? 'HTTPS' : 'HTTP'} запрос: ${req.method} ${req.url} с домена ${domain}`);

    let body = '';

    req.on('data', (chunk) => {
        body += chunk.toString();
    });

    req.on('end', () => {
        // Логирование запроса
        logRequest(req.method, req.url, req.headers, body, domain);

        // Оригинальный метод end
        const originalEnd = res.end;

        // Переопределяем метод end для логирования ответа
        res.end = function(chunk, encoding) {
            // Вызываем оригинальный метод end
            originalEnd.apply(res, arguments);

            // Логируем ответ
            logResponse(res.statusCode, res.getHeaders(), chunk);
        };

        if (req.url === '/') {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end('Hi World!');
        } else if (req.url === '/server') {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end('http://helsinki-1.minority.gg 80 false');
        } else if (req.url === '/auth' && req.method === 'POST') {
            const response = createAuthResponse();
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(response));
        } else if (req.url === '/auth/me' && req.method === 'GET') {
            const authHeader = req.headers['authorization'];
            if (authHeader && authHeader.startsWith('Bearer ')) {
                // В реальном приложении здесь нужно проверить токен
                const response = createAuthResponse().user;
                res.writeHead(200, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify(response));
            } else {
                res.writeHead(401, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ error: 'Unauthorized' }));
            }
        } else if (req.url === '/websocket') {
            res.writeHead(426, { 'Content-Type': 'text/plain' }); // Upgrade Required
            res.end('Upgrade Required');
        } else {
            res.writeHead(404, { 'Content-Type': 'text/plain' });
            res.end('Not Found');
        }
    });
}

// Создание HTTP сервера
const httpServer = http.createServer(requestHandler);

// Создание HTTPS сервера
const httpsServer = https.createServer(httpsOptions, requestHandler);

// Создание WebSocket сервера поверх HTTPS сервера
const wss = new WebSocket.Server({ noServer: true });

// Обработка WebSocket соединений
wss.on('connection', (ws) => {
    console.log('Новое WebSocket соединение');

    ws.on('message', (message) => {
        console.log('Получено сообщение:', message);
        ws.send(`Echo: ${message}`);
        console.log('Отправлено сообщение:', `Echo: ${message}`);
    });

    ws.on('close', () => {
        console.log('WebSocket соединение закрыто');
    });

    ws.on('error', (error) => {
        console.error('WebSocket ошибка:', error);
    });
});

// Обработка запросов на WebSocket через HTTPS
httpsServer.on('upgrade', (request, socket, head) => {
    console.log(`Обработка запроса upgrade: ${request.method} ${request.url}`);

    if (request.url === '/websocket') {
        console.log('Запрос на WebSocket соединение');
        wss.handleUpgrade(request, socket, head, (ws) => {
            wss.emit('connection', ws, request);
            console.log('WebSocket соединение установлено');
        });
    } else {
        console.log(`Запрос не поддерживается: ${request.url}`);
        socket.destroy();
    }
});

// Запуск HTTP и HTTPS серверов
httpServer.listen(httpPort, () => {
    console.log(`HTTP сервер работает на http://localhost:${httpPort}`);
});

httpsServer.listen(httpsPort, () => {
    console.log(`HTTPS сервер работает на https://localhost:${httpsPort}`);
});

```