qwen-api-proxy 1.0.10

package/src/browser/browser.js

@@ -0,0 +1,233 @@
+import puppeteer from 'puppeteer-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+import { saveSession, saveAuthToken } from './session.js';
+import { startManualAuthentication } from './auth.js';
+import { clearPagePool, getAuthToken } from '../api/chat.js';
+import fs from 'fs';
+import path from 'path';
+import { logInfo, logError, logWarn, logDebug } from '../logger/index.js';
+import {
+    CHAT_PAGE_URL, NAVIGATION_TIMEOUT, RETRY_DELAY,
+    VIEWPORT_WIDTH, VIEWPORT_HEIGHT, USER_AGENT,
+    SESSION_DIR, ACCOUNTS_DIR
+} from '../config.js';
+
+puppeteer.use(StealthPlugin());
+
+let browserInstance = null;
+let browserContext = null;
+export let isAuthenticated = false;
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+export async function initBrowser(visibleMode = true, skipManualRestart = false) {
+    if (browserInstance) return true;
+
+    logInfo('Инициализация браузера с Puppeteer Stealth...');
+    try {
+        browserInstance = await puppeteer.launch({
+            headless: !visibleMode,
+            slowMo: visibleMode ? 30 : 0,
+            executablePath: process.env.CHROME_PATH || undefined,
+            args: [
+                '--no-sandbox', '--disable-setuid-sandbox',
+                '--disable-blink-features=AutomationControlled',
+                '--disable-dev-shm-usage', '--disable-web-security',
+                '--disable-features=IsolateOrigins,site-per-process',
+                `--window-size=${VIEWPORT_WIDTH},${VIEWPORT_HEIGHT}`,
+                '--start-maximized', '--disable-infobars',
+                '--disable-extensions', '--disable-gpu',
+                '--no-first-run', '--no-default-browser-check',
+                '--ignore-certificate-errors', '--ignore-certificate-errors-spki-list'
+            ],
+            defaultViewport: { width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT },
+            ignoreHTTPSErrors: true
+        });
+
+        const pages = await browserInstance.pages();
+        const page = pages.length > 0 ? pages[0] : await browserInstance.newPage();
+
+        await page.setUserAgent(USER_AGENT);
+        await page.setViewport({ width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT, deviceScaleFactor: 1 });
+        await page.setExtraHTTPHeaders({
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1'
+        });
+
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
+            Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8 });
+            Object.defineProperty(navigator, 'deviceMemory', { get: () => 8 });
+            Object.defineProperty(navigator, 'plugins', {
+                get: () => [{ 0: { type: 'application/x-google-chrome-pdf', suffixes: 'pdf', description: 'Portable Document Format' }, description: 'Portable Document Format', filename: 'internal-pdf-viewer', length: 1, name: 'Chrome PDF Plugin' }]
+            });
+            Object.defineProperty(navigator, 'connection', {
+                get: () => ({ effectiveType: '4g', rtt: 50, downlink: 10, saveData: false })
+            });
+            if (!navigator.getBattery) {
+                navigator.getBattery = () => Promise.resolve({ charging: true, chargingTime: 0, dischargingTime: Infinity, level: 1 });
+            }
+
+            const originalAddEventListener = EventTarget.prototype.addEventListener;
+            EventTarget.prototype.addEventListener = function (type, listener, options) {
+                if (type === 'mousemove' || type === 'mousedown' || type === 'mouseup') {
+                    const wrappedListener = function (event) { setTimeout(() => listener.call(this, event), Math.random() * 3); };
+                    return originalAddEventListener.call(this, type, wrappedListener, options);
+                }
+                return originalAddEventListener.call(this, type, listener, options);
+            };
+
+            const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+            HTMLCanvasElement.prototype.toDataURL = function (type) {
+                const context = this.getContext('2d');
+                if (context) {
+                    const imageData = context.getImageData(0, 0, this.width, this.height);
+                    const data = imageData.data;
+                    for (let i = 0; i < data.length; i += 4) {
+                        const noise = Math.floor(Math.random() * 5) - 2;
+                        data[i] = Math.max(0, Math.min(255, data[i] + noise));
+                        data[i + 1] = Math.max(0, Math.min(255, data[i + 1] + noise));
+                        data[i + 2] = Math.max(0, Math.min(255, data[i + 2] + noise));
+                    }
+                    context.putImageData(imageData, 0, 0);
+                }
+                return originalToDataURL.apply(this, arguments);
+            };
+        });
+
+        browserContext = page;
+        logInfo('Браузер инициализирован с максимальной защитой от обнаружения');
+
+        if (visibleMode) {
+            await startManualAuthenticationPuppeteer(page, skipManualRestart);
+        }
+        // loadSessionPuppeteer removed — was dead code (always returned false)
+
+        return true;
+    } catch (error) {
+        logError('Ошибка при инициализации браузера', error);
+        return false;
+    }
+}
+
+async function saveSessionPuppeteer(page) {
+    try {
+        const cookies = await page.cookies();
+        const sessionDir = path.join(process.cwd(), SESSION_DIR, ACCOUNTS_DIR);
+        if (!fs.existsSync(sessionDir)) fs.mkdirSync(sessionDir, { recursive: true });
+
+        const accountId = `acc_${Date.now()}`;
+        const accountDir = path.join(sessionDir, accountId);
+        if (!fs.existsSync(accountDir)) fs.mkdirSync(accountDir, { recursive: true });
+
+        fs.writeFileSync(path.join(accountDir, 'cookies.json'), JSON.stringify(cookies, null, 2));
+        logInfo(`Cookies сохранены для аккаунта ${accountId}`);
+        return accountId;
+    } catch (error) {
+        logError('Ошибка при сохранении сессии', error);
+        return null;
+    }
+}
+
+async function startManualAuthenticationPuppeteer(page, skipManualRestart) {
+    try {
+        logInfo('Открытие страницы для ручной авторизации...');
+        await page.goto(CHAT_PAGE_URL, { waitUntil: 'networkidle2', timeout: NAVIGATION_TIMEOUT });
+        await delay(5000);
+
+        console.log('------------------------------------------------------');
+        console.log('               НЕОБХОДИМА АВТОРИЗАЦИЯ');
+        console.log('------------------------------------------------------');
+        console.log('Пожалуйста, выполните следующие действия:');
+        console.log('1. Войдите в систему в открытом браузере');
+        console.log('2. ВАЖНО: Двигайте мышью естественно, не спешите');
+        console.log('3. Если появится слайдер капчи - решите её медленно');
+        console.log('4. Дождитесь полной загрузки главной страницы');
+        console.log('5. После успешной авторизации нажмите ENTER в консоли');
+        console.log('------------------------------------------------------');
+        console.log('После успешной авторизации нажмите ENTER для продолжения...');
+
+        await new Promise((resolve) => {
+            if (process.stdin.isTTY) process.stdin.setRawMode(false);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            const onData = (key) => {
+                if (key === '\n' || key === '\r' || key.charCodeAt(0) === 13) {
+                    process.stdin.pause();
+                    process.stdin.removeListener('data', onData);
+                    logInfo('Получено подтверждение, продолжаем...');
+                    resolve();
+                }
+            };
+            process.stdin.on('data', onData);
+        });
+
+        const cookies = await page.cookies();
+        logInfo(`Сохранено ${cookies.length} cookies`);
+
+        const token = await page.evaluate(() =>
+            localStorage.getItem('token') || localStorage.getItem('auth_token') ||
+            localStorage.getItem('access_token') || sessionStorage.getItem('token') ||
+            sessionStorage.getItem('auth_token') || null
+        );
+
+        if (token) {
+            logInfo('Токен найден и будет сохранен');
+            saveAuthToken(token);
+        } else {
+            logWarn('Токен не найден в localStorage/sessionStorage');
+            logInfo('Попытка извлечь токен из cookies...');
+            const tokenCookie = cookies.find(c => c.name.toLowerCase().includes('token') || c.name.toLowerCase().includes('auth'));
+            if (tokenCookie) {
+                logInfo(`Токен найден в cookie: ${tokenCookie.name}`);
+                saveAuthToken(tokenCookie.value);
+            }
+        }
+
+        const accountId = await saveSessionPuppeteer(page);
+        if (accountId) logInfo(`Сессия сохранена с ID: ${accountId}`);
+
+        setAuthenticationStatus(true);
+        logInfo('Авторизация завершена успешно');
+
+        if (!skipManualRestart) await restartBrowserInHeadlessMode();
+    } catch (error) {
+        logError('Ошибка при ручной авторизации', error);
+        throw error;
+    }
+}
+
+export async function restartBrowserInHeadlessMode() {
+    logInfo('Перезапуск браузера в фоновом режиме...');
+    const token = getAuthToken();
+    if (token) { logDebug('Сохранение токена...'); saveAuthToken(token); await delay(1000); }
+    await shutdownBrowser();
+    await delay(RETRY_DELAY);
+    const success = await initBrowser(false);
+    logInfo(success ? 'Браузер перезапущен в фоновом режиме' : 'Ошибка при перезапуске браузера');
+}
+
+export async function shutdownBrowser() {
+    try {
+        try { await clearPagePool(); } catch (e) { logError('Ошибка при очистке пула страниц', e); }
+        if (browserInstance) {
+            try {
+                const pages = await browserInstance.pages();
+                for (const page of pages) await page.close().catch(() => {});
+                await browserInstance.close();
+            } catch (e) { logError('Ошибка при закрытии браузера', e); }
+        }
+        browserContext = null;
+        browserInstance = null;
+        logInfo('Браузер закрыт');
+    } catch (error) {
+        logError('Ошибка при завершении работы браузера', error);
+    }
+}
+
+export function getBrowserContext() { return browserContext; }
+export function setAuthenticationStatus(status) { isAuthenticated = status; }
+export function getAuthenticationStatus() { return isAuthenticated; }

package/src/browser/session.js

@@ -0,0 +1,134 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logInfo, logError, logWarn } from '../logger/index.js';
+import { SESSION_DIR } from '../config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const SESSION_PATH = path.resolve(__dirname, '..', '..', SESSION_DIR);
+const TOKEN_FILE = path.join(SESSION_PATH, 'auth_token.txt');
+
+function getSessionFilePath(accountId, fileName) {
+    return accountId
+        ? path.join(SESSION_PATH, 'accounts', accountId, fileName)
+        : path.join(SESSION_PATH, fileName);
+}
+
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+}
+
+export function initSessionDirectory() {
+    ensureDir(SESSION_PATH);
+}
+
+export async function saveSession(context, accountId = null) {
+    try {
+        initSessionDirectory();
+        const isPuppeteer = context && typeof context.goto === 'function';
+        const isPlaywright = context && typeof context.storageState === 'function';
+
+        if (isPuppeteer) {
+            const cookies = await context.cookies();
+            const sessionPath = getSessionFilePath(accountId, 'cookies.json');
+            ensureDir(path.dirname(sessionPath));
+            fs.writeFileSync(sessionPath, JSON.stringify(cookies, null, 2));
+            logInfo('Сессия Puppeteer сохранена');
+            return true;
+        }
+
+        if (isPlaywright && context.browser()) {
+            const sessionPath = getSessionFilePath(accountId, 'state.json');
+            ensureDir(path.dirname(sessionPath));
+            await context.storageState({ path: sessionPath });
+            logInfo('Сессия Playwright сохранена');
+            return true;
+        }
+
+        logError('Неизвестный тип контекста браузера');
+        return false;
+    } catch (error) {
+        logError('Ошибка при сохранении сессии', error);
+        return false;
+    }
+}
+
+export async function loadSession(context, accountId = null) {
+    try {
+        const isPuppeteer = context && typeof context.goto === 'function';
+        const isPlaywright = context && typeof context.storageState === 'function';
+
+        if (isPuppeteer) {
+            const sessionPath = getSessionFilePath(accountId, 'cookies.json');
+            if (fs.existsSync(sessionPath)) {
+                const cookies = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+                await context.setCookie(...cookies);
+                logInfo('Сессия Puppeteer загружена');
+                return true;
+            }
+        } else if (isPlaywright) {
+            const sessionPath = getSessionFilePath(accountId, 'state.json');
+            if (fs.existsSync(sessionPath)) {
+                await context.storageState({ path: sessionPath });
+                logInfo('Сессия Playwright загружена');
+                return true;
+            }
+        }
+    } catch (error) {
+        logError('Ошибка при загрузке сессии', error);
+    }
+    return false;
+}
+
+export function clearSession(accountId = null) {
+    try {
+        const paths = [
+            getSessionFilePath(accountId, 'state.json'),
+            getSessionFilePath(accountId, 'cookies.json')
+        ];
+        let cleared = false;
+        for (const p of paths) {
+            if (fs.existsSync(p)) { fs.unlinkSync(p); cleared = true; }
+        }
+        if (cleared) logInfo('Сессия очищена');
+        return cleared;
+    } catch (error) {
+        logError('Ошибка при очистке сессии', error);
+        return false;
+    }
+}
+
+export function hasSession(accountId = null) {
+    return [
+        getSessionFilePath(accountId, 'state.json'),
+        getSessionFilePath(accountId, 'cookies.json')
+    ].some(p => fs.existsSync(p));
+}
+
+export function saveAuthToken(token) {
+    try {
+        initSessionDirectory();
+        if (token) {
+            fs.writeFileSync(TOKEN_FILE, token, 'utf8');
+            logInfo('Токен авторизации сохранен');
+            return true;
+        }
+    } catch (error) {
+        logError('Ошибка при сохранении токена авторизации', error);
+    }
+    return false;
+}
+
+export function loadAuthToken() {
+    try {
+        if (fs.existsSync(TOKEN_FILE)) {
+            const token = fs.readFileSync(TOKEN_FILE, 'utf8');
+            logInfo('Токен авторизации загружен');
+            return token;
+        }
+    } catch (error) {
+        logError('Ошибка при загрузке токена авторизации', error);
+    }
+    return null;
+}

package/src/config.js

@@ -0,0 +1,116 @@
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+
+// Determine if running as global CLI or local development
+const isGlobalInstall = process.env.QWEN_API_PROXY_GLOBAL === 'true';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+// Use current working directory for global install, package root for development
+const BASE_DIR = isGlobalInstall ? process.cwd() : PACKAGE_ROOT;
+
+// Load .env file from working directory
+const envPath = path.join(BASE_DIR, '.env');
+const dotenvResult = dotenv.config({ path: envPath });
+if (dotenvResult.error) {
+    console.warn('⚠️  .env file not found, using environment variables');
+} else {
+    console.log('✅ .env file loaded');
+}
+
+// config.js — Единый источник конфигурации проекта.
+// Все значения читаются из env-переменных с фоллбэками на дефолты.
+
+function toBoolean(value) {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number') return value === 1;
+    if (typeof value !== 'string') return false;
+    return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+}
+
+// ─── API URLs ────────────────────────────────────────────────────────────────
+const QWEN_BASE_URL = process.env.QWEN_BASE_URL || 'https://chat.qwen.ai';
+
+export const CHAT_API_URL = process.env.CHAT_API_URL || `${QWEN_BASE_URL}/api/v2/chat/completions`;
+export const CREATE_CHAT_URL = process.env.CREATE_CHAT_URL || `${QWEN_BASE_URL}/api/v2/chats/new`;
+export const CHAT_PAGE_URL = process.env.CHAT_PAGE_URL || `${QWEN_BASE_URL}/`;
+export const TASK_STATUS_URL = process.env.TASK_STATUS_URL || `${QWEN_BASE_URL}/api/v1/tasks/status`;
+export const STS_TOKEN_API_URL = process.env.STS_TOKEN_API_URL || `${QWEN_BASE_URL}/api/v1/files/getstsToken`;
+export const AUTH_SIGNIN_URL = process.env.AUTH_SIGNIN_URL || `${QWEN_BASE_URL}/auth?action=signin`;
+export const OSS_SDK_URL = process.env.OSS_SDK_URL || 'https://gosspublic.alicdn.com/aliyun-oss-sdk-6.20.0.min.js';
+export const MODELS_API_URL = process.env.MODELS_API_URL || `${QWEN_BASE_URL}/api/v2/models`;
+
+// ─── Таймауты (мс) ──────────────────────────────────────────────────────────
+export const PAGE_TIMEOUT = Number(process.env.PAGE_TIMEOUT) || 120_000;
+export const AUTH_TIMEOUT = Number(process.env.AUTH_TIMEOUT) || 120_000;
+export const NAVIGATION_TIMEOUT = Number(process.env.NAVIGATION_TIMEOUT) || 60_000;
+export const RETRY_DELAY = Number(process.env.RETRY_DELAY) || 2_000;
+export const STREAMING_CHUNK_DELAY = Number(process.env.STREAMING_CHUNK_DELAY) || 20;
+
+// ─── Лимиты ─────────────────────────────────────────────────────────────────
+export const PAGE_POOL_SIZE = Number(process.env.PAGE_POOL_SIZE) || 3;
+export const MAX_FILE_SIZE = Number(process.env.MAX_FILE_SIZE) || 10 * 1024 * 1024; // 10 MB
+export const MAX_HISTORY_LENGTH = Number(process.env.MAX_HISTORY_LENGTH) || 100;
+export const MAX_RETRY_COUNT = Number(process.env.MAX_RETRY_COUNT) || 3;
+export const TASK_POLL_MAX_ATTEMPTS = Number(process.env.TASK_POLL_MAX_ATTEMPTS) || 90;
+export const TASK_POLL_INTERVAL = Number(process.env.TASK_POLL_INTERVAL) || 2_000;
+
+// ─── Paths (relative to working directory) ───────────────────────────────────────
+export const SESSION_DIR = process.env.SESSION_DIR || 'session';
+export const ACCOUNTS_DIR = 'accounts';
+export const UPLOADS_DIR = process.env.UPLOADS_DIR || 'uploads';
+export const LOGS_DIR = process.env.LOGS_DIR || 'logs';
+export const TEMP_DIR = process.env.TEMP_DIR || 'temp';
+
+// Export base directory for use in other modules
+export { BASE_DIR };
+
+// ─── Браузер ─────────────────────────────────────────────────────────────────
+export const VIEWPORT_WIDTH = Number(process.env.VIEWPORT_WIDTH) || 1920;
+export const VIEWPORT_HEIGHT = Number(process.env.VIEWPORT_HEIGHT) || 1080;
+export const USER_AGENT = process.env.USER_AGENT || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+
+// ─── Сервер ──────────────────────────────────────────────────────────────────
+export const PORT = Number(process.env.PORT) || 3264;
+export const HOST = process.env.HOST || '0.0.0.0';
+// DEFAULT_MODEL будет установлен динамически из списка моделей, если не задан в .env
+export const DEFAULT_MODEL = process.env.DEFAULT_MODEL || null;
+export const ALLOW_UNSCOPED_SESSION_CHAT_RESTORE = toBoolean(process.env.ALLOW_UNSCOPED_SESSION_CHAT_RESTORE);
+
+// ─── Режим сессий чата ──────────────────────────────────────────────────────
+// FORCE_NEW_CHAT_PER_REQUEST=true: каждый запрос создает новый диалог (как OpenAI API)
+// FORCE_NEW_CHAT_PER_REQUEST=false (по умолчанию): восстанавливает предыдущий диалог
+export const FORCE_NEW_CHAT_PER_REQUEST = toBoolean(process.env.FORCE_NEW_CHAT_PER_REQUEST);
+
+// ─── Логирование ─────────────────────────────────────────────────────────────
+export const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+export const LOG_MAX_SIZE = Number(process.env.LOG_MAX_SIZE) || 5_242_880; // 5 MB
+export const LOG_MAX_FILES = Number(process.env.LOG_MAX_FILES) || 5;
+
+// ─── Telegram уведомления ───────────────────────────────────────────────────
+export const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN || null;
+export const TELEGRAM_USER_IDS = process.env.TELEGRAM_USER_IDS
+    ? process.env.TELEGRAM_USER_IDS.split(',').map(id => id.trim()).filter(id => id)
+    : [];
+export const TOKEN_EXPIRY_WARNING_MS = Number(process.env.TOKEN_EXPIRY_WARNING_MS) || 3600000; // 1 hour
+
+// ─── Telegram прокси ────────────────────────────────────────────────────────
+export const TELEGRAM_PROXY = process.env.TELEGRAM_PROXY || null;
+export const TELEGRAM_PROXY_URL = process.env.TELEGRAM_PROXY_URL || null;
+
+// ─── Qwen LLM прокси ────────────────────────────────────────────────────────
+export const QWEN_PROXY = process.env.QWEN_PROXY || null;
+
+// ─── Прокси для скачивания файлов ───────────────────────────────────────────
+export const FILE_DOWNLOAD_PROXY = process.env.FILE_DOWNLOAD_PROXY || null;
+
+// ─── Генерация изображений ──────────────────────────────────────────────────
+// Режим генерации: 'dashscope' (по умолчанию) или 'browser'
+// 'dashscope' - использует DASHSCOPE_API_KEY напрямую через DashScope API
+// 'browser' - использует браузер (аналогично генерации текста через Qwen Chat)
+export const IMAGE_GENERATION_MODE = process.env.IMAGE_GENERATION_MODE || 'dashscope';
+
+// DashScope API ключ (требуется при IMAGE_GENERATION_MODE='dashscope')
+export const DASHSCOPE_API_KEY = process.env.DASHSCOPE_API_KEY || null;

package/src/logger/index.js

@@ -0,0 +1,89 @@
+import winston from 'winston';
+import morgan from 'morgan';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { LOG_LEVEL, LOG_MAX_SIZE, LOG_MAX_FILES, LOGS_DIR } from '../config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const LOG_DIR = path.resolve(__dirname, '..', '..', LOGS_DIR);
+if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+const { combine, timestamp, printf, colorize } = winston.format;
+
+const consoleFormat = combine(
+    colorize({ all: true }),
+    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    printf(({ level, message, timestamp }) => `${timestamp} [${level}]: ${message}`)
+);
+
+const fileFormat = combine(
+    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    printf(({ level, message, timestamp }) => `${timestamp} [${level}]: ${message}`)
+);
+
+const customLevels = {
+    levels: { error: 0, warn: 1, info: 2, http: 3, debug: 4, raw: 5 },
+    colors: { error: 'red', warn: 'yellow', info: 'green', http: 'cyan', debug: 'blue', raw: 'magenta' }
+};
+
+const logger = winston.createLogger({
+    levels: customLevels.levels,
+    level: LOG_LEVEL,
+    format: fileFormat,
+    transports: [
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'combined.log'),
+            maxsize: LOG_MAX_SIZE,
+            maxFiles: LOG_MAX_FILES
+        }),
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'http.log'),
+            level: 'http',
+            maxsize: LOG_MAX_SIZE,
+            maxFiles: LOG_MAX_FILES
+        }),
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'error.log'),
+            level: 'error',
+            maxsize: LOG_MAX_SIZE,
+            maxFiles: LOG_MAX_FILES
+        }),
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'raw-responses.log'),
+            level: 'raw',
+            maxsize: LOG_MAX_SIZE,
+            maxFiles: LOG_MAX_FILES
+        }),
+        new winston.transports.Console({ format: consoleFormat })
+    ]
+});
+
+winston.addColors(customLevels.colors);
+
+const morganStream = {
+    write: (message) => logger.http(message.trim())
+};
+
+const morganFormat = ':remote-addr :method :url :status :res[content-length] - :response-time ms';
+const httpLogger = morgan(morganFormat, { stream: morganStream });
+
+export const logHttpRequest = httpLogger;
+export const logInfo = (message) => logger.info(message);
+export const logError = (message, error) => {
+    if (error) {
+        logger.error(`${message}: ${error.message}`);
+        logger.error(error.stack);
+    } else {
+        logger.error(message);
+    }
+};
+export const logWarn = (message) => logger.warn(message);
+export const logDebug = (message) => logger.debug(message);
+export const logRaw = (message) => logger.raw(message);
+export const logHttp = (message) => logger.http(message);
+
+export default { logHttpRequest, logInfo, logError, logWarn, logDebug, logRaw, logHttp };