qwen-api-proxy 1.0.10

package/src/api/chatHistory.js

@@ -0,0 +1,344 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+import { logInfo, logError, logDebug } from '../logger/index.js';
+import { SESSION_DIR, MAX_HISTORY_LENGTH } from '../config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const HISTORY_DIR = path.resolve(__dirname, '..', '..', SESSION_DIR, 'history');
+
+export function initHistoryDirectory() {
+    if (!fs.existsSync(HISTORY_DIR)) {
+        fs.mkdirSync(HISTORY_DIR, { recursive: true });
+        logInfo(`Создана директория для истории чатов: ${HISTORY_DIR}`);
+    }
+}
+
+export function generateChatId() {
+    return crypto.randomUUID();
+}
+
+export function createChat(chatName) {
+    const chatId = generateChatId();
+    const chatInfo = {
+        id: chatId,
+        name: chatName || `Новый чат ${new Date().toLocaleString()}`,
+        created: Date.now(),
+        messages: []
+    };
+    saveHistory(chatId, chatInfo);
+    logInfo(`Создан новый чат [${chatId}] с именем "${chatInfo.name}"`);
+    return chatId;
+}
+
+function getHistoryFilePath(chatId) {
+    return path.join(HISTORY_DIR, `${chatId}.json`);
+}
+
+export function saveHistory(chatId, data) {
+    try {
+        initHistoryDirectory();
+        const historyFilePath = getHistoryFilePath(chatId);
+        fs.writeFileSync(historyFilePath, JSON.stringify(data, null, 2), 'utf8');
+        logDebug(`История чата ${chatId} успешно сохранена`);
+        return true;
+    } catch (error) {
+        logError(`Ошибка при сохранении истории чата ${chatId}`, error);
+        return false;
+    }
+}
+
+export function loadHistory(chatId) {
+    try {
+        const historyFilePath = getHistoryFilePath(chatId);
+        if (fs.existsSync(historyFilePath)) {
+            const rawData = fs.readFileSync(historyFilePath, 'utf8');
+            logDebug(`Данные чата ${chatId} успешно загружены`);
+
+            let data;
+            try {
+                data = JSON.parse(rawData);
+                logDebug(`Данные чата ${chatId} успешно распарсены`);
+            } catch (parseErr) {
+                logError(`Ошибка при парсинге данных чата ${chatId}`, parseErr);
+                return {
+                    id: chatId,
+                    name: `Восстановленный чат ${new Date().toLocaleString()}`,
+                    created: Date.now(),
+                    messages: []
+                };
+            }
+
+            // Поддержка обратной совместимости со старым форматом
+            if (Array.isArray(data)) {
+                logDebug(`Чат ${chatId} использует устаревший формат, выполняется конвертация`);
+                return {
+                    id: chatId,
+                    name: `Чат от ${new Date().toLocaleString()}`,
+                    created: Date.now(),
+                    messages: data,
+                    wasConverted: true
+                };
+            }
+
+            // Проверяем наличие обязательных полей
+            if (!data.messages) {
+                logInfo(`Чат ${chatId} не содержит сообщений, инициализируем пустой массив`);
+                data.messages = [];
+            }
+
+            if (!data.name) {
+                data.name = `Чат ${chatId.substring(0, 6)}`;
+            }
+
+            if (!data.created) {
+                data.created = Date.now();
+            }
+
+            if (!data.id) {
+                data.id = chatId;
+            }
+
+            return data;
+        } else {
+            logInfo(`Файл истории для чата ${chatId} не найден`);
+        }
+    } catch (error) {
+        logError(`Ошибка при загрузке истории чата ${chatId}`, error);
+    }
+
+    // Если не удалось загрузить, создаем новые данные
+    logInfo(`Создаем новую историю для чата ${chatId}`);
+    return {
+        id: chatId,
+        name: `Новый чат ${new Date().toLocaleString()}`,
+        created: Date.now(),
+        messages: []
+    };
+}
+
+export function chatExists(chatId) {
+    const historyFilePath = getHistoryFilePath(chatId);
+    const exists = fs.existsSync(historyFilePath);
+    logDebug(`Проверка существования чата ${chatId}: ${exists ? 'найден' : 'не найден'}`);
+    return exists;
+}
+
+export function renameChat(chatId, newName) {
+    try {
+        if (!chatExists(chatId)) {
+            logError(`Попытка переименовать несуществующий чат ${chatId}`);
+            return false;
+        }
+
+        const chatData = loadHistory(chatId);
+        const oldName = chatData.name;
+        chatData.name = newName;
+        const success = saveHistory(chatId, chatData);
+        if (success) {
+            logInfo(`Чат ${chatId} переименован: "${oldName}" -> "${newName}"`);
+        } else {
+            logError(`Не удалось переименовать чат ${chatId}`);
+        }
+        return success;
+    } catch (error) {
+        logError(`Ошибка при переименовании чата ${chatId}`, error);
+        return false;
+    }
+}
+
+export function addUserMessage(chatId, content) {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const messageId = crypto.randomUUID();
+
+    // Определяем тип содержимого и его длину для логирования
+    let contentDesc;
+    if (Array.isArray(content)) {
+        // Составное сообщение (текст + изображения)
+        const textParts = content.filter(item => item.type === 'text');
+        const imageParts = content.filter(item => item.type === 'image');
+        const fileParts = content.filter(item => item.type === 'file');
+
+        contentDesc = `составное сообщение (${textParts.length} текст., ${imageParts.length} изобр., ${fileParts.length} файл.)`;
+    } else if (typeof content === 'object' && content !== null) {
+        contentDesc = 'объект-сообщение';
+    } else {
+        contentDesc = `текст длиной ${String(content).length}`;
+    }
+
+    const message = {
+        id: messageId,
+        role: "user",
+        content: content,
+        timestamp: timestamp,
+        chat_type: "t2t"
+    };
+
+    logInfo(`Добавление сообщения пользователя в чат ${chatId}: ${contentDesc}`);
+    return addMessageToHistory(chatId, message);
+}
+
+export function addAssistantMessage(chatId, content, info = {}) {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const messageId = crypto.randomUUID();
+
+    const message = {
+        id: messageId,
+        role: "assistant",
+        content: content,
+        timestamp: timestamp,
+        info: info,
+        chat_type: "t2t"
+    };
+
+    logInfo(`Добавление ответа ассистента в чат ${chatId}, длина: ${content.length}`);
+    return addMessageToHistory(chatId, message);
+}
+
+function addMessageToHistory(chatId, message) {
+    try {
+        let chatData = loadHistory(chatId);
+
+        if (chatData.messages.length >= MAX_HISTORY_LENGTH) {
+            logInfo(`Чат ${chatId} достиг максимальной длины (${MAX_HISTORY_LENGTH}), удаляем старые сообщения`);
+            chatData.messages = [chatData.messages[0], ...chatData.messages.slice(chatData.messages.length - MAX_HISTORY_LENGTH + 2)];
+        }
+
+        chatData.messages.push(message);
+        saveHistory(chatId, chatData);
+        logDebug(`Сообщение ${message.id} успешно добавлено в чат ${chatId}`);
+
+        return message.id;
+    } catch (error) {
+        logError(`Ошибка при добавлении сообщения в историю чата ${chatId}`, error);
+        return null;
+    }
+}
+
+export function getAllChats() {
+    try {
+        initHistoryDirectory();
+        const files = fs.readdirSync(HISTORY_DIR);
+        logDebug(`Получен список файлов чатов: ${files.length} файлов`);
+
+        let convertedCount = 0;
+        const chats = files
+            .filter(file => file.endsWith('.json'))
+            .map(file => {
+                const chatId = file.replace('.json', '');
+                const chatData = loadHistory(chatId);
+
+                if (chatData.wasConverted) {
+                    convertedCount++;
+                }
+
+                return {
+                    id: chatId,
+                    name: chatData.name || `Чат ${chatId.substring(0, 6)}`,
+                    created: chatData.created || 0,
+                    messageCount: chatData.messages ? chatData.messages.length : 0,
+                    userMessageCount: chatData.messages ?
+                        chatData.messages.filter(m => m.role === 'user').length : 0
+                };
+            });
+
+        if (convertedCount > 0) {
+            logInfo(`Конвертировано ${convertedCount} чатов из устаревшего формата`);
+        }
+
+        logInfo(`Обработано ${chats.length} чатов`);
+        return chats.sort((a, b) => b.created - a.created);
+    } catch (error) {
+        logError('Ошибка при получении списка чатов', error);
+        return [];
+    }
+}
+
+export function deleteChat(chatId) {
+    try {
+        const historyFilePath = getHistoryFilePath(chatId);
+        if (fs.existsSync(historyFilePath)) {
+            fs.unlinkSync(historyFilePath);
+            logInfo(`Чат ${chatId} успешно удален`);
+            return true;
+        } else {
+            logError(`Попытка удаления несуществующего чата ${chatId}`);
+        }
+    } catch (error) {
+        logError(`Ошибка при удалении чата ${chatId}`, error);
+    }
+    return false;
+}
+
+export function deleteChatsAutomatically(criteria = {}) {
+    try {
+        const { olderThan, userMessageCountLessThan, messageCountLessThan, maxChats } = criteria;
+        logInfo(`Автоудаление чатов с критериями: ${JSON.stringify(criteria)}`);
+
+        const chats = getAllChats();
+        logInfo(`Найдено ${chats.length} чатов для проверки`);
+
+        let chatsToDelete = [...chats];
+
+        // Фильтрация по возрасту (в миллисекундах)
+        if (olderThan) {
+            const cutoffTime = Date.now() - olderThan;
+            const oldChatsCount = chatsToDelete.filter(chat => chat.created < cutoffTime).length;
+            logInfo(`Чатов старше ${olderThan}мс (${new Date(cutoffTime).toLocaleString()}): ${oldChatsCount}`);
+            chatsToDelete = chatsToDelete.filter(chat => chat.created < cutoffTime);
+        }
+
+        if (userMessageCountLessThan !== undefined) {
+            const lowUserMsgChatsCount = chatsToDelete.filter(chat =>
+                chat.userMessageCount < userMessageCountLessThan).length;
+            logInfo(`Чатов с менее чем ${userMessageCountLessThan} сообщений пользователя: ${lowUserMsgChatsCount}`);
+            chatsToDelete = chatsToDelete.filter(chat =>
+                chat.userMessageCount < userMessageCountLessThan);
+        }
+
+        if (messageCountLessThan !== undefined) {
+            const lowMsgChatsCount = chatsToDelete.filter(chat =>
+                chat.messageCount < messageCountLessThan).length;
+            logInfo(`Чатов с менее чем ${messageCountLessThan} сообщений всего: ${lowMsgChatsCount}`);
+            chatsToDelete = chatsToDelete.filter(chat =>
+                chat.messageCount < messageCountLessThan);
+        }
+
+        if (maxChats && chats.length > maxChats) {
+            logInfo(`Общее количество чатов (${chats.length}) превышает лимит (${maxChats}), удаляем старые чаты`);
+            const sortedChats = [...chats].sort((a, b) => a.created - b.created);
+            const oldestChats = sortedChats.slice(0, chats.length - maxChats);
+
+            oldestChats.forEach(chat => {
+                if (!chatsToDelete.some(c => c.id === chat.id)) {
+                    chatsToDelete.push(chat);
+                }
+            });
+        }
+
+        // Удаление выбранных чатов
+        const deletedChats = [];
+        logInfo(`Найдено ${chatsToDelete.length} чатов для удаления`);
+
+        for (const chat of chatsToDelete) {
+            if (deleteChat(chat.id)) {
+                deletedChats.push(chat.id);
+            }
+        }
+
+        logInfo(`Удалено ${deletedChats.length} чатов`);
+        return {
+            success: true,
+            deletedCount: deletedChats.length,
+            deletedChats
+        };
+    } catch (error) {
+        logError('Ошибка при автоматическом удалении чатов', error);
+        return {
+            success: false,
+            error: error.message
+        };
+    }
+} 

package/src/api/fileUpload.js

@@ -0,0 +1,182 @@
+import { getBrowserContext } from '../browser/browser.js';
+import { logInfo, logError } from '../logger/index.js';
+import { getAuthToken, extractAuthToken, pagePool } from './chat.js';
+import { getAvailableToken } from './tokenManager.js';
+import fs from 'fs';
+import path from 'path';
+import { STS_TOKEN_API_URL, OSS_SDK_URL, UPLOADS_DIR } from '../config.js';
+
+const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'];
+const DOCUMENT_EXTENSIONS = ['.pdf', '.doc', '.docx', '.txt'];
+const DEFAULT_FILE_TYPE = 'file';
+const IMAGE_FILE_TYPE = 'image';
+const DOCUMENT_FILE_TYPE = 'document';
+
+function validateBrowserContext() {
+    const browserContext = getBrowserContext();
+    if (!browserContext) throw new Error('Браузер не инициализирован');
+    return browserContext;
+}
+
+async function validateAuthToken(browserContext) {
+    const tokenObj = await getAvailableToken();
+    if (tokenObj?.token) {
+        logInfo(`Используется токен из tokenManager: ${tokenObj.id}`);
+        return tokenObj.token;
+    }
+
+    let token = getAuthToken();
+    if (!token) {
+        logInfo('Токен авторизации не найден в памяти, пытаемся извлечь из браузера');
+        token = await extractAuthToken(browserContext);
+        if (!token) throw new Error('Не удалось получить токен авторизации');
+    }
+    return token;
+}
+
+export async function getStsToken(fileInfo) {
+    const browserContext = validateBrowserContext();
+    const token = await validateAuthToken(browserContext);
+    logInfo(`Запрос STS токена для файла: ${fileInfo.filename}`);
+
+    let page = null;
+    try {
+        page = await pagePool.getPage(browserContext);
+        const result = await page.evaluate(async (data) => {
+            try {
+                const response = await fetch(data.apiUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${data.token}`, 'Accept': 'application/json' },
+                    body: JSON.stringify(data.fileInfo)
+                });
+                if (response.ok) return { success: true, data: await response.json() };
+                return { success: false, status: response.status, statusText: response.statusText, errorBody: await response.text() };
+            } catch (error) { return { success: false, error: error.toString() }; }
+        }, { apiUrl: STS_TOKEN_API_URL, token, fileInfo });
+
+        if (result.success) {
+            logInfo(`STS токен успешно получен для файла: ${fileInfo.filename}`);
+            return result.data;
+        }
+        const errorMsg = result.errorBody || result.error || result.statusText || 'Unknown error';
+        logError(`Ошибка при получении STS токена: status=${result.status}, error=${errorMsg}`);
+        throw new Error(`Ошибка получения STS токена: ${result.statusText || ''} ${errorMsg}`);
+    } catch (error) {
+        logError(`Ошибка при получении STS токена: ${error.message}`, error);
+        throw error;
+    } finally {
+        if (page) { try { pagePool.releasePage(page); } catch (e) { logError('Ошибка при возврате страницы в пул', e); } }
+    }
+}
+
+export async function uploadFile(filePath, stsData) {
+    const browserContext = validateBrowserContext();
+    logInfo(`Начало загрузки файла: ${filePath}`);
+
+    if (!stsData?.file_path || !stsData?.access_key_id || !stsData?.access_key_secret ||
+        !stsData?.security_token || !stsData?.region || !stsData?.bucketname) {
+        throw new Error('Некорректные или неполные данные STS токена');
+    }
+
+    logInfo(`[OSS] Загрузка через браузер`);
+    logInfo(`[OSS] Регион: ${stsData.region}, Бакет: ${stsData.bucketname}`);
+    if (stsData.endpoint) logInfo(`[OSS] Endpoint: ${stsData.endpoint}`);
+    logInfo(`[OSS] File path: ${stsData.file_path}`);
+    logInfo(`[OSS] File URL: ${stsData.file_url}`);
+
+    const fileBuffer = fs.readFileSync(filePath);
+    const fileBase64 = fileBuffer.toString('base64');
+    logInfo(`[OSS] Размер файла: ${fileBuffer.length} байт`);
+
+    let page = null;
+    try {
+        page = await pagePool.getPage(browserContext);
+        const result = await page.evaluate(async (data) => {
+            try {
+                if (typeof window.OSS === 'undefined') {
+                    console.log('[OSS] Загрузка OSS SDK...');
+                    await new Promise((resolve, reject) => {
+                        const script = document.createElement('script');
+                        script.src = data.ossSdkUrl;
+                        script.onload = resolve;
+                        script.onerror = () => reject(new Error('Failed to load OSS SDK'));
+                        document.head.appendChild(script);
+                    });
+                    console.log('[OSS] SDK загружен успешно');
+                }
+                
+                console.log('[OSS] Создание Blob из файла...');
+                const blob = new Blob([Uint8Array.from(atob(data.fileBase64), c => c.charCodeAt(0))]);
+                console.log(`[OSS] Blob создан, размер: ${blob.size} байт`);
+                
+                console.log('[OSS] Создание OSS клиента...');
+                const client = new window.OSS({
+                    region: data.stsData.region,
+                    accessKeyId: data.stsData.access_key_id,
+                    accessKeySecret: data.stsData.access_key_secret,
+                    stsToken: data.stsData.security_token,
+                    bucket: data.stsData.bucketname,
+                    secure: true
+                });
+                
+                console.log(`[OSS] Загрузка файла в OSS: ${data.stsData.file_path}`);
+                await client.put(data.stsData.file_path, blob);
+                console.log('[OSS] Файл успешно загружен');
+                
+                return { success: true };
+            } catch (error) { 
+                console.error(`[OSS Browser] Ошибка: ${error.toString()}`);
+                console.error(`[OSS Browser] Stack: ${error.stack || 'N/A'}`);
+                return { success: false, error: error.toString() }; 
+            }
+        }, {
+            fileBase64,
+            ossSdkUrl: OSS_SDK_URL,
+            stsData: { region: stsData.region, bucketname: stsData.bucketname, file_path: stsData.file_path, access_key_id: stsData.access_key_id, access_key_secret: stsData.access_key_secret, security_token: stsData.security_token }
+        });
+
+        if (result.success) {
+            logInfo(`[OSS] Загрузка завершена успешно`);
+            return { success: true, fileName: path.basename(filePath), url: stsData.file_url, fileId: stsData.file_id, filePath: stsData.file_path };
+        }
+        logError(`[OSS] Ошибка загрузки: ${result.error}`);
+        throw new Error(`Ошибка загрузки в OSS: ${result.error}`);
+    } catch (error) {
+        logError(`Ошибка при загрузке файла в OSS: ${error.message}`, error);
+        throw error;
+    } finally {
+        if (page) { try { pagePool.releasePage(page); } catch (e) { logError('Ошибка при возврате страницы в пул', e); } }
+    }
+}
+
+export async function uploadFileToQwen(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) throw new Error(`Файл не найден: ${filePath}`);
+
+        const fileName = path.basename(filePath);
+        const fileSize = fs.statSync(filePath).size;
+        const fileExt = path.extname(fileName).toLowerCase();
+
+        let fileType = DEFAULT_FILE_TYPE;
+        if (IMAGE_EXTENSIONS.includes(fileExt)) fileType = IMAGE_FILE_TYPE;
+        else if (DOCUMENT_EXTENSIONS.includes(fileExt)) fileType = DOCUMENT_FILE_TYPE;
+
+        logInfo(`📤 Загрузка файла в Qwen: ${fileName} (${fileSize} байт, тип: ${fileType})`);
+        
+        const fileInfo = { filename: fileName, filesize: fileSize, filetype: fileType };
+        const stsData = await getStsToken(fileInfo);
+        
+        logInfo(`✅ STS токен получен, начинаем загрузку в OSS`);
+        
+        const uploadResult = await uploadFile(filePath, stsData);
+        
+        logInfo(`✅ Файл успешно загружен в Qwen`);
+        
+        return { ...uploadResult, fileInfo, stsData };
+    } catch (error) {
+        logError(`❌ Ошибка в процессе загрузки файла: ${error.message}`, error);
+        return { success: false, error: error.message };
+    }
+}
+
+export default { getStsToken, uploadFile, uploadFileToQwen };