Initial upload from Google Colab

.dockerignore

@@ -0,0 +1,10 @@
+node_modules
+npm-debug.log
+logs
+session
+uploads
+.git
+.gitignore
+*.log
+patch-cline.bat
+start.bat

.gitignore

@@ -0,0 +1,41 @@
+# Зависимости Node.js
+node_modules/
+package-lock.json
+yarn.lock
+
+# Данные сессии и кэш
+session/
+.cache/
+
+
+# Служебные файлы
+.DS_Store
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Логи
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Файлы Python
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+venv/
+.env/
+.venv/
+
+# Файлы редакторов
+.idea/
+.vscode/
+*.swp
+*.swo 
+
+src/Authorization.txt

Dockerfile

@@ -0,0 +1,22 @@
+# syntax=docker/dockerfile:1.6
+FROM mcr.microsoft.com/playwright:v1.55.1-jammy AS base
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --omit=dev
+
+COPY . .
+
+ENV NODE_ENV=production \
+    PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+RUN npx playwright install --with-deps chromium \
+ && mkdir -p /app/session /app/logs /app/uploads \
+ && chown -R pwuser:pwuser /app
+
+USER pwuser
+
+EXPOSE 3264
+
+CMD ["node", "index.js"]

docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+  qwen-proxy:
+    build: .
+    image: qwen-api-proxy:latest
+    container_name: qwen-proxy
+    environment:
+      - NODE_ENV=production
+      - PORT=${PORT:-3264}
+      - HOST=0.0.0.0
+      - SKIP_ACCOUNT_MENU=true
+    ports:
+      - "${PORT:-3264}:3264"
+    volumes:
+      - ./session:/app/session
+      - ./logs:/app/logs
+      - ./uploads:/app/uploads
+    restart: unless-stopped

docs/README.md

@@ -0,0 +1 @@
+ref

docs/README_CN.md

@@ -0,0 +1,586 @@
+# Qwen AI API 代理
+
+本地 API 代理服务器，通过浏览器模拟与 Qwen AI 交互。允许用户无需官方 API 密钥即可使用 Qwen 模型。
+
+- **免费访问**：无需支付 API 密钥费用即可使用 Qwen 模型
+- **完全兼容**：支持 OpenAI 兼容接口，便于集成
+
+## 📋 目录
+
+- [🚀 快速开始](#-快速开始)
+  - [安装](#安装)
+  - [启动](#启动)
+- [💡 功能](#-功能)
+- [📘 API 参考](#-api-参考)
+  - [主要端点](#主要端点)
+  - [请求格式](#请求格式)
+  - [对话历史管理](#对话历史管理)
+  - [图像处理](#图像处理)
+  - [文件上传](#文件上传)
+  - [对话管理](#对话管理)
+- [📝 使用示例](#-使用示例)
+  - [文本请求](#文本请求)
+  - [图像请求](#图像请求)
+  - [Postman 示例](#postman-示例)
+- [🔄 上下文管理](#-上下文管理)
+- [🔌 OpenAI API 兼容性](#-openai-api-兼容性)
+  - [主要特性](#主要特性)
+  - [流式输出支持](#流式输出支持)
+  - [OpenAI SDK 使用示例](#openai-sdk-使用示例)
+- [🔧 实现细节](#-实现细节)
+
+---
+
+## 🚀 快速开始
+
+### 安装
+
+1. 克隆仓库
+2. 安装依赖：
+
+```bash
+npm install
+```
+
+### 启动
+
+```bash
+npm start
+```
+
+也可以使用快速启动文件：
+
+```
+start.bat
+```
+
+> **注意：** 首次启动时会打开浏览器窗口，您需要在 Qwen AI 网站上进行登录授权。成功登录后，按回车键继续。
+
+---
+
+## 💡 功能
+
+本项目允许您：
+
+- 通过本地 API 使用 Qwen AI 模型
+- 在请求之间保存对话上下文
+- 通过 API 管理对话
+- 选择不同的 Qwen 模型生成回答
+- 发送图像进行分析
+- 使用支持流式输出的 OpenAI 兼容 API
+
+---
+
+## 📘 API 参考
+
+### 主要端点
+
+| 端点 | 方法 | 描述 |
+|----------|-------|----------|
+| `/api/chat` | POST | 发送消息并获取回复 |
+| `/api/chat/completions` | POST | 支持流式输出的 OpenAI 兼容端点 |
+| `/api/models` | GET | 获取可用模型列表 |
+| `/api/status` | GET | 检查授权状态 |
+| `/api/files/upload` | POST | 上传图像用于请求 |
+| `/api/chats` | POST/GET | 创建新对话 / 获取所有对话列表 |
+| `/api/chats/:chatId` | GET/DELETE | 获取对话历史 / 删除对话 |
+| `/api/chats/:chatId/rename` | PUT | 重命名对话 |
+| `/api/chats/cleanup` | POST | 根据条件自动删除对话 |
+
+### 请求格式
+
+代理支持两种向 `/api/chat` 发送请求的格式：
+
+#### 1. 使用 `message` 参数的简化格式
+
+```json
+{
+  "message": "消息文本",
+  "model": "qwen-max-latest",
+  "chatId": "对话ID"
+}
+```
+
+#### 2. 与官方 Qwen API 兼容的 `messages` 参数格式
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "你好，最近怎么样？"}
+  ],
+  "model": "qwen-max-latest",
+  "chatId": "对话ID"
+}
+```
+
+### 对话历史管理
+
+> **重要提示：** 代理在服务器上使用内部系统存储对话历史。
+
+1. 使用 `message` 格式时 - 消息直接添加到对话历史中。
+2. 使用 `messages` 格式时 - 只从数组中提取最后一条用户消息并添加到历史中。
+
+发送请求到官方 Qwen API 时，**始终**使用与指定 `chatId` 关联的完整对话历史。这意味着使用 `messages` 参数时，您只需包含带有 "user" 角色的新用户消息，而不是整个对话历史。
+
+### 图像处理
+
+代理支持在两种格式中发送带图像的消息：
+
+#### 带图像的 `message` 格式
+
+```json
+{
+  "message": [
+    {
+      "type": "text",
+      "text": "描述这张图片中的物体"
+    },
+    {
+      "type": "image",
+      "image": "图像URL"
+    }
+  ],
+  "model": "qwen3-235b-a22b",
+  "chatId": "对话ID"
+}
+```
+
+#### 带图像的 `messages` 格式
+
+```json
+{
+  "messages": [
+    {
+      "role": "user", 
+      "content": [
+        {
+          "type": "text",
+          "text": "描述这张图片中的物体"
+        },
+        {
+          "type": "image",
+          "image": "图像URL"
+        }
+      ]
+    }
+  ],
+  "model": "qwen3-235b-a22b",
+  "chatId": "对话ID"
+}
+```
+
+### 文件上传
+
+#### 上传图像
+
+```
+POST http://localhost:3264/api/files/upload
+```
+
+**请求格式：** `multipart/form-data`
+
+**参数：**
+
+- `file` - 图像文件（支持格式：jpg, jpeg, png, gif, webp）
+
+**使用 curl 的示例：**
+
+```bash
+curl -X POST http://localhost:3264/api/files/upload \
+  -F "file=@/path/to/image.jpg"
+```
+
+**响应示例：**
+
+```json
+{
+  "imageUrl": "https://cdn.qwenlm.ai/user-id/file-id_filename.jpg?key=..."
+}
+```
+
+#### 获取图像 URL
+
+要通过 API 代理发送图像，您首先需要获取图像 URL。可以通过两种方式实现：
+
+##### 方法 1：通过 API 代理上传
+
+如上所述，向 `/api/files/upload` 端点发送 POST 请求上传图像。
+
+##### 方法 2：通过 Qwen 网页界面获取 URL
+
+1. 在官方 Qwen 网页界面上传图像 (<https://chat.qwen.ai/>)
+2. 打开浏览器开发者工��（F12 或 Ctrl+Shift+I）
+3. 切换到 "Network"（网络）选项卡
+4. 找到包含您图像的 API Qwen 请求（通常是 GetsToken 请求）
+5. 在请求主体中找到图像 URL，格式类似：`https://cdn.qwenlm.ai/user-id/file-id_filename.jpg?key=...`
+6. 复制此 URL 以在 API 请求中使用
+
+### 对话管理
+
+#### 创建新对话
+
+```
+POST http://localhost:3264/api/chats
+```
+
+**请求体：**
+
+```json
+{
+  "name": "对话名称"
+}
+```
+
+**响应：**
+
+```json
+{
+  "chatId": "唯一标识符"
+}
+```
+
+#### 获取所有对话列表
+
+```
+GET http://localhost:3264/api/chats
+```
+
+#### 获取对话历史
+
+```
+GET http://localhost:3264/api/chats/:chatId
+```
+
+#### 删除对话
+
+```
+DELETE http://localhost:3264/api/chats/:chatId
+```
+
+#### 重命名对话
+
+```
+PUT http://localhost:3264/api/chats/:chatId/rename
+```
+
+**请求体：**
+
+```json
+{
+  "name": "新对话名称"
+}
+```
+
+#### 自动删除对话
+
+```
+POST http://localhost:3264/api/chats/cleanup
+```
+
+**请求体**（所有参数都是可选的）：
+
+```json
+{
+  "olderThan": 604800000, // 删除超过指定时间的对话（毫秒），例如 7 天
+  "userMessageCountLessThan": 3, // 删除用户消息少于 3 条的对话
+  "messageCountLessThan": 5, // 删除总消息少于 5 条的对话
+  "maxChats": 50 // 只保留最新的 50 个对话
+}
+```
+
+---
+
+## 📝 使用示例
+
+### 文本请求
+
+#### 简单文本请求示例
+
+```bash
+curl -X POST http://localhost:3264/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "什么是人工智能？",
+    "model": "qwen-max-latest"
+  }'
+```
+
+#### 官方 API 格式请求示例
+
+```bash
+curl -X POST http://localhost:3264/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "什么是人工智能？"}
+    ],
+    "model": "qwen-max-latest"
+  }'
+```
+
+### 图像请求
+
+#### 上传图像并发送请求示例
+
+```bash
+# 步骤 1：上传图像
+UPLOAD_RESPONSE=$(curl -s -X POST http://localhost:3264/api/files/upload \
+  -F "file=@/path/to/image.jpg")
+
+# 步骤 2：提取图像 URL
+IMAGE_URL=$(echo $UPLOAD_RESPONSE | grep -o '"imageUrl":"[^"]*"' | sed 's/"imageUrl":"//;s/"//')
+
+# 步骤 3：发送带图像的请求
+curl -X POST http://localhost:3264/api/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": [
+      {
+        "type": "text",
+        "text": "描述这张图片中的物体"
+      },
+      {
+        "type": "image",
+        "image": "'$IMAGE_URL'"
+      }
+    ],
+    "model": "qwen3-235b-a22b"
+  }'
+```
+
+### Postman 示例
+
+#### 上传并使用图像
+
+1. **上传图像**：
+   - 创建一个新的 POST 请求到 `http://localhost:3264/api/files/upload`
+   - 选择 "Body" 选项卡
+   - 选择类型 "form-data"
+   - 添加键 "file" 并选择类型 "File"
+   - 点击 "Select Files" 按钮上传图像
+   - 点击 "Send"
+
+   响应将包含图像 URL：
+
+   ```json
+   {
+     "imageUrl": "https://cdn.qwenlm.ai/user-id/file-id_filename.jpg?key=..."
+   }
+   ```
+
+2. **在请求中使用图像**：
+   - 创建一个新的 POST 请求到 `http://localhost:3264/api/chat`
+   - 选择 "Body" 选项卡
+   - 选择类型 "raw" 和格式 "JSON"
+   - 粘贴以下 JSON，将 `图像URL` 替换为获取的 URL：
+
+   ```json
+   {
+     "message": [
+       {
+         "type": "text",
+         "text": "描述这张图片中的物体"
+       },
+       {
+         "type": "image",
+         "image": "图像URL"
+       }
+     ],
+     "model": "qwen3-235b-a22b"
+   }
+   ```
+
+   - 点击 "Send"
+
+#### 使用 OpenAI 兼容端点
+
+1. **通过 OpenAI 兼容端点发送请求**：
+   - 创建一个新的 POST 请求到 `http://localhost:3264/api/chat/completions`
+   - 选择 "Body" 选项卡
+   - 选择类型 "raw" 和格式 "JSON"
+   - 粘贴以下 JSON，将 `图像URL` 替换为获取的 URL：
+
+   ```json
+   {
+     "messages": [
+       {
+         "role": "user",
+         "content": [
+           {
+             "type": "text",
+             "text": "描述这张图片中的内容是什么？"
+           },
+           {
+             "type": "image",
+             "image": "图像URL"
+           }
+         ]
+       }
+     ],
+     "model": "qwen3-235b-a22b"
+   }
+   ```
+
+   - 点击 "Send"
+
+2. **流式模式请求**：
+   - 使用相同的 URL 和请求体，但添加参数 `"stream": true`
+   - 注意：要在 Postman 中正确显示流，请在控制台中勾选 "Preserve log" 选项
+
+---
+
+## 🔄 上下文管理
+
+系统会自动保存对话历史并在每个请求中发送到 Qwen API。这使模型能够在生成回答时考虑之前的消息。
+
+### 上下文工作流程
+
+1. **首次请求**（不指定 `chatId`）：
+
+```json
+{
+  "message": "你好，你叫什么名字？"
+}
+```
+
+2. **响应**（包含 `chatId`）：
+
+```json
+{
+  "chatId": "abcd-1234-5678",
+  "choices": [...]
+}
+```
+
+3. **后续请求**（使用获得的 `chatId`）：
+
+```json
+{
+  "message": "2+2等于多少？",
+  "chatId": "abcd-1234-5678"
+}
+```
+
+---
+
+## 🔌 OpenAI API 兼容性
+
+代理支持 OpenAI API 兼容端点，用于连接使用 OpenAI API 的客户端：
+
+```
+POST /api/chat/completions
+```
+
+### 主要特性
+
+1. **为每个请求创建新对话：** 每个向 `/chat/completions` 的请求都会在系统中创建一个名为 "OpenAI API Chat" 的新对话。
+
+2. **保存完整消息历史：** 请求中的所有消息（包括系统消息、用户消息和助手消息）都会保存在对话历史中。
+
+3. **支持系统消息：** 代理正确处理并保存系统消息（`role: "system"`），这些消息通常用于配置模型行为。
+
+**带系统消息的请求示例：**
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "你是 JavaScript 专家。只回答关于 JavaScript 的问题。"},
+    {"role": "user", "content": "如何在 JavaScript 中创建类？"}
+  ],
+  "model": "qwen-max-latest"
+}
+```
+
+### 流式输出支持
+
+代理支持响应流式传输模式，允许您实时分批接收响应：
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "写一个关于太空的长故事"}
+  ],
+  "model": "qwen-max-latest",
+  "stream": true
+}
+```
+
+使用流式模式时，响应将以与 OpenAI API 兼容的 Server-Sent Events (SSE) 格式逐步返回。
+
+### OpenAI SDK 使用示例
+
+```javascript
+// 使用 OpenAI Node.js SDK 的示例
+import OpenAI from 'openai';
+import fs from 'fs';
+import axios from 'axios';
+
+const openai = new OpenAI({
+  baseURL: 'http://localhost:3264/api', // 代理的基本 URL
+  apiKey: 'dummy-key', // 不需要真实密钥，但库要求此字段
+});
+
+// 不使用流式输出的请求
+const completion = await openai.chat.completions.create({
+  messages: [{ role: 'user', content: '你好，最近怎么样？' }],
+  model: 'qwen-max-latest', // 使用的 Qwen 模型
+});
+
+console.log(completion.choices[0].message);
+
+// 使用流式输出的请求
+const stream = await openai.chat.completions.create({
+  messages: [{ role: 'user', content: '讲一个关于太空的长故事' }],
+  model: 'qwen-max-latest',
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices[0]?.delta?.content || '');
+}
+
+// 上传并使用图像
+async function uploadAndAnalyzeImage(imagePath) {
+  // 通过 API 代理上传图像
+  const formData = new FormData();
+  formData.append('file', fs.createReadStream(imagePath));
+  
+  const uploadResponse = await axios.post('http://localhost:3264/api/files/upload', formData, {
+    headers: { 'Content-Type': 'multipart/form-data' }
+  });
+  
+  const imageUrl = uploadResponse.data.imageUrl;
+  
+  // 创建带图像的请求
+  const completion = await openai.chat.completions.create({
+    messages: [
+      { 
+        role: 'user', 
+        content: [
+          { type: 'text', text: '描述这张图片中的内容是什么？' },
+          { type: 'image', image: imageUrl }
+        ] 
+      }
+    ],
+    model: 'qwen3-235b-a22b',
+  });
+  
+  console.log(completion.choices[0].message.content);
+}
+
+// 使用方法：uploadAndAnalyzeImage('./image.jpg');
+```
+
+> **兼容性限制：**
+>
+> 1. 一些 OpenAI 特有的参数（如 `logprobs`、`functions` 等）不受支持。
+> 2. 流式传输速度可能与原始 OpenAI API 不同。
+
+---
+
+## 🔧 实现细节
+
+- 代理通过无头浏览器模拟与 Qwen 网页界面的交互
+- 自动管理会话和授权
+- 通过浏览器页面池优化性能
+- 支持自动保存和恢复授权状态

examples/README.md

@@ -0,0 +1,120 @@
+# Примеры использования FreeQwenApi
+
+В этой директории собраны примеры использования API-прокси для Qwen AI.
+
+## Установка и запуск
+
+Установка зависимостей производится в корневой директории проекта:
+
+```bash
+# В корневой директории проекта
+npm install
+```
+
+Перед запуском примеров убедитесь, что сервер FreeQwenApi запущен и доступен по адресу `http://localhost:3264`.
+
+```bash
+# Запуск сервера
+npm start
+
+# В отдельном терминале запустите примеры
+npm run example:simple
+npm run example:stream
+# и т.д.
+```
+
+## Примеры с использованием OpenAI SDK
+
+### 1. Простой запрос (не потоковый)
+
+```bash
+npm run example:simple
+```
+
+Демонстрирует отправку простого запроса к Qwen AI с использованием OpenAI SDK.
+
+### 2. Потоковый запрос
+
+```bash
+npm run example:stream
+```
+
+Показывает, как получать ответ в потоковом режиме, где токены приходят по мере их генерации.
+
+### 3. Запрос с системным сообщением
+
+```bash
+npm run example:system
+```
+
+Пример использования системного сообщения для задания роли и инструкций модели.
+
+### 4. Анализ изображения
+
+```bash
+npm run example:image
+```
+
+Демонстрация отправки изображения для анализа моделью (требуется заменить URL изображения в примере).
+
+### 5. Диалог с несколькими сообщениями
+
+```bash
+npm run example:conversation
+```
+
+Пример поддержания диалога из нескольких сообщений с сохранением контекста.
+
+### 6. Совместимость с OpenAI API
+
+```bash
+npm run example:compatibility
+```
+
+Демонстрация полной совместимости с форматом API OpenAI.
+
+## Примеры прямого использования API
+
+### 1. Запрос с использованием fetch
+
+```bash
+npm run example:direct
+```
+
+Пример отправки прямого запроса к API без использования SDK, с использованием нативного fetch.
+
+### 2. Запрос с использованием axios
+
+```bash
+npm run example:axios
+```
+
+Пример использования библиотеки axios для отправки запросов к API.
+
+### 3. Управление диалогами
+
+```bash
+npm run example:chat-management
+```
+
+Демонстрация API для управления диалогами: создание, получение списка, получение истории, переименование и удаление.
+
+## Модификация примеров
+
+Вы можете модифицировать примеры для своих нужд:
+
+1. Изменяйте запросы и параметры в файлах примеров
+2. Попробуйте различные модели (список доступен через `/api/models`)
+3. Экспериментируйте с разными форматами запросов
+
+## Работа с изображениями
+
+Для примеров с изображениями необходимо:
+
+1. Загрузить изображение в официальном веб-интерфейсе Qwen
+2. Получить URL изображения из сетевых запросов (см. инструкцию в README.md основного проекта)
+3. Заменить `IMAGE_URL` в примере на полученный URL
+
+## Дополнительная информация
+
+Подробная документация API доступна в README.md основного проекта. 

examples/direct-api/axios-example.js

@@ -0,0 +1,53 @@
+// Пример прямого запроса к API прокси Qwen с использованием axios
+// Установка: npm install axios
+// Для запуска примера: node axios-example.js
+
+import axios from 'axios';
+
+async function axiosExample() {
+    try {
+        console.log('Отправка запроса через axios к API Qwen...\n');
+        
+        // Пример с форматом messages, совместимым с OpenAI
+        const response = await axios.post('http://localhost:3264/api/chat', {
+            messages: [
+                { role: 'system', content: 'Ты эксперт по программированию на JavaScript.' },
+                { role: 'user', content: 'Объясни, как работают асинхронные функции в JavaScript' }
+            ],
+            model: 'qwen-max-latest'
+        });
+        
+        console.log('Ответ от API:\n');
+        console.log(response.data.choices[0].message.content);
+        console.log('\nЗапрос успешно выполнен.');
+        
+        // Вывод дополнительной информации
+        console.log('\nИнформация о запросе:');
+        console.log(`ID чата: ${response.data.chatId}`);
+        console.log(`Модель: ${response.data.model}`);
+        
+        // Сохраняем ID чата для следующего примера
+        const chatId = response.data.chatId;
+        
+        // Продолжаем диалог в том же чате
+        console.log('\n\nОтправка второго сообщения в тот же чат...\n');
+        
+        const followUpResponse = await axios.post('http://localhost:3264/api/chat', {
+            message: 'Приведи пример использования async/await',
+            model: 'qwen-max-latest',
+            chatId: chatId
+        });
+        
+        console.log('Ответ на второе сообщение:\n');
+        console.log(followUpResponse.data.choices[0].message.content);
+        
+    } catch (error) {
+        console.error('Ошибка при выполнении запроса:', error);
+        if (error.response) {
+            console.error('Детали ошибки:', error.response.data);
+        }
+    }
+}
+
+// Запуск
+axiosExample(); 

examples/direct-api/chat-management.js

@@ -0,0 +1,80 @@
+// Пример управления диалогами через API прокси Qwen
+// Установка: npm install axios
+// Для запуска примера: node chat-management.js
+
+import axios from 'axios';
+
+const API_BASE_URL = 'http://localhost:3264/api';
+
+async function chatManagementExample() {
+    try {
+        console.log('Демонстрация API управления диалогами\n');
+        
+        // 1. Создание нового диалога
+        console.log('1. Создание нового диалога...');
+        const createResponse = await axios.post(`${API_BASE_URL}/chats`, {
+            name: 'Тестовый диалог о программировании'
+        });
+        
+        const chatId = createResponse.data.chatId;
+        console.log(`Создан диалог с ID: ${chatId}`);
+        
+        // 2. Отправка сообщения в этот диалог
+        console.log('\n2. Отправка сообщения в диалог...');
+        await axios.post(`${API_BASE_URL}/chat`, {
+            message: 'Расскажи о Python и его преимуществах',
+            chatId: chatId,
+            model: 'qwen-max-latest'
+        });
+        console.log('Сообщение отправлено');
+        
+        // 3. Получение списка всех диалогов
+        console.log('\n3. Получение списка всех диалогов...');
+        const chatsResponse = await axios.get(`${API_BASE_URL}/chats`);
+        console.log(`Найдено ${chatsResponse.data.chats.length} диалогов:`);
+        chatsResponse.data.chats.forEach(chat => {
+            console.log(`- ${chat.id}: ${chat.name} (${new Date(chat.createdAt).toLocaleString()})`);
+        });
+        
+        // 4. Получение истории конкретного диалога
+        console.log(`\n4. Получение истории диалога ${chatId}...`);
+        const historyResponse = await axios.get(`${API_BASE_URL}/chats/${chatId}`);
+        console.log(`Получена история диалога, ${historyResponse.data.history.messages.length} сообщений:`);
+        historyResponse.data.history.messages.forEach(msg => {
+            const timestamp = new Date(msg.timestamp * 1000).toLocaleTimeString();
+            console.log(`[${timestamp}] ${msg.role}: ${typeof msg.content === 'string' ? msg.content.substring(0, 50) + '...' : '[Составное сообщение]'}`);
+        });
+        
+        // 5. Переименование диалога
+        console.log(`\n5. Переименование диалога ${chatId}...`);
+        await axios.put(`${API_BASE_URL}/chats/${chatId}/rename`, {
+            name: 'Обновленное название диалога'
+        });
+        console.log('Диалог переименован');
+        
+        // 6. Автоудаление старых диалогов (демонстрация API)
+        console.log('\n6. Демонстрация API автоудаления диалогов...');
+        const cleanupResponse = await axios.post(`${API_BASE_URL}/chats/cleanup`, {
+            olderThan: 30 * 24 * 60 * 60 * 1000, // Диалоги старше 30 дней
+            userMessageCountLessThan: 2,        // С менее чем 2 сообщениями пользователя
+            maxChats: 100                       // Оставить максимум 100 диалогов
+        });
+        console.log(`Автоудаление: ${cleanupResponse.data.deletedCount} диалогов удалено`);
+        
+        // 7. Удаление тестового диалога
+        console.log(`\n7. Удаление тестового диалога ${chatId}...`);
+        await axios.delete(`${API_BASE_URL}/chats/${chatId}`);
+        console.log('Тестовый диалог удален');
+        
+        console.log('\nПример управления диалогами успешно завершен!');
+        
+    } catch (error) {
+        console.error('Ошибка в примере управления диалогами:', error);
+        if (error.response) {
+            console.error('Детали ошибки:', error.response.data);
+        }
+    }
+}
+
+// Запуск
+chatManagementExample(); 

examples/direct-api/fetch-example.js

@@ -0,0 +1,40 @@
+// Пример прямого запроса к API прокси Qwen с использованием fetch
+// Для запуска примера: node fetch-example.js
+
+async function directApiRequest() {
+    try {
+        console.log('Отправка прямого запроса к API Qwen...\n');
+        
+        const response = await fetch('http://localhost:3264/api/chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                message: 'Объясни простыми словами, что такое искусственный интеллект',
+                model: 'qwen-max-latest'
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP ошибка! Статус: ${response.status}`);
+        }
+        
+        const result = await response.json();
+        
+        console.log('Ответ от API:\n');
+        console.log(result.choices[0].message.content);
+        console.log('\nЗапрос успешно выполнен.');
+        
+        // Вывод дополнительной информации
+        console.log('\nИнформация о запросе:');
+        console.log(`ID чата: ${result.chatId}`);
+        console.log(`Модель: ${result.model}`);
+        
+    } catch (error) {
+        console.error('Ошибка при выполнении запроса:', error);
+    }
+}
+
+// Запуск
+directApiRequest(); 

examples/file-upload/test-file.txt

@@ -0,0 +1 @@
+Это тестовый файл для загрузки.

examples/file-upload/upload-example.js

@@ -0,0 +1,213 @@
+// Пример для тестирования загрузки файлов
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import axios from 'axios';
+import FormData from 'form-data';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// URL API
+const API_URL = 'http://localhost:3264/api';
+
+/**
+ * Загружает тестовый файл на сервер
+ * @param {string} filePath - Путь к файлу для загрузки
+ * @returns {Promise<Object>} - Результат загрузки файла
+ */
+async function uploadTestFile(filePath) {
+    try {
+        console.log(`Загрузка файла: ${filePath}`);
+        
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`Файл не найден: ${filePath}`);
+        }
+        
+        // Создаем FormData для загрузки файла
+        const formData = new FormData();
+        formData.append('file', fs.createReadStream(filePath));
+        
+        // Отправляем запрос на загрузку
+        const response = await axios.post(`${API_URL}/files/upload`, formData, {
+            headers: {
+                ...formData.getHeaders()
+            },
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity
+        });
+        
+        console.log('Файл успешно загружен:');
+        console.log(JSON.stringify(response.data, null, 2));
+        
+        return response.data;
+    } catch (error) {
+        console.error('Ошибка при загрузке файла:');
+        if (error.response) {
+            console.error(error.response.data);
+        } else {
+            console.error(error.message);
+        }
+        throw error;
+    }
+}
+
+/**
+ * Получает STS токен напрямую (для тестирования)
+ * @param {Object} fileInfo - Информация о файле
+ * @returns {Promise<Object>} - Данные STS токена
+ */
+async function getTestStsToken(fileInfo) {
+    try {
+        console.log(`Запрос STS токена для файла: ${fileInfo.filename}`);
+        
+        const response = await axios.post(`${API_URL}/files/getstsToken`, fileInfo);
+        
+        console.log('Получен STS токен:');
+        console.log(JSON.stringify(response.data, null, 2));
+        
+        return response.data;
+    } catch (error) {
+        console.error('Ошибка при получении STS токена:');
+        if (error.response) {
+            console.error(error.response.data);
+        } else {
+            console.error(error.message);
+        }
+        throw error;
+    }
+}
+
+/**
+ * Напрямую загружает файл через OSS (для тестирования)
+ * @param {string} filePath - Путь к файлу
+ * @param {Object} stsData - Данные STS токена
+ * @returns {Promise<Object>} - Результат загрузки
+ */
+async function directUploadFile(filePath, stsData) {
+    try {
+        console.log(`Прямая загрузка файла: ${filePath}`);
+        
+        if (!stsData || !stsData.file_url || !stsData.file_path) {
+            throw new Error('Некорректные данные STS токена');
+        }
+        
+        // Загружаем ali-oss библиотеку динамически
+        const OSS = (await import('ali-oss')).default;
+        
+        // Проверяем наличие необходимых данных для OSS
+        if (!stsData.access_key_id || !stsData.access_key_secret || !stsData.security_token ||
+            !stsData.region || !stsData.bucketname) {
+            throw new Error('Неполные данные STS токена для OSS');
+        }
+        
+        console.log(`Создание OSS клиента: регион ${stsData.region}, бакет ${stsData.bucketname}`);
+        
+        // Создаем клиент OSS с STS токеном
+        const client = new OSS({
+            region: stsData.region,
+            accessKeyId: stsData.access_key_id,
+            accessKeySecret: stsData.access_key_secret,
+            stsToken: stsData.security_token,
+            bucket: stsData.bucketname,
+            secure: true, // Используем HTTPS
+            timeout: 60000 // 60 секунд таймаут
+        });
+        
+        // Получаем имя объекта из file_path
+        const objectName = stsData.file_path;
+        
+        console.log(`Загрузка файла в OSS: ${objectName}`);
+        
+        // Загружаем файл
+        const result = await client.put(objectName, filePath);
+        
+        console.log('Файл успешно загружен в OSS:');
+        console.log(`URL: ${stsData.file_url}`);
+        console.log(`Ответ OSS: ${JSON.stringify(result)}`);
+        
+        // Проверяем, что файл действительно загружен
+        try {
+            const verifyResponse = await axios.get(stsData.file_url);
+            console.log(`Файл успешно проверен, статус: ${verifyResponse.status}`);
+        } catch (error) {
+            console.log(`Не удалось проверить файл: ${error.message}`);
+            // Это не критическая ошибка, так как файл может быть недоступен сразу
+        }
+        
+        return {
+            success: true,
+            fileName: path.basename(filePath),
+            url: stsData.file_url,
+            fileId: stsData.file_id,
+            ossResponse: result
+        };
+    } catch (error) {
+        console.error('Ошибка при загрузке файла в OSS:');
+        if (error.response) {
+            console.error(`Статус: ${error.response.status}`);
+            console.error(error.response.data);
+        } else {
+            console.error(error.message);
+        }
+        throw error;
+    }
+}
+
+// Основная функция для запуска тестов
+async function runTest() {
+    try {
+        // Путь к тестовому файлу (например, изображение)
+        const testFilePath = path.join(__dirname, 'test-image.jpg');
+        
+        // Если файл не существует, создадим простой текстовый файл для теста
+        if (!fs.existsSync(testFilePath)) {
+            console.log('Тестовый файл не найден, создаем текстовый файл для теста...');
+            
+            const textFilePath = path.join(__dirname, 'test-file.txt');
+            fs.writeFileSync(textFilePath, 'Это тестовый файл для загрузки.');
+            
+            console.log(`Создан тестовый файл: ${textFilePath}`);
+            
+            // Тестируем получение STS токена
+            const fileInfo = {
+                filename: 'test-file.txt',
+                filesize: fs.statSync(textFilePath).size,
+                filetype: 'file'
+            };
+            
+            const stsData = await getTestStsToken(fileInfo);
+            
+            // Тестируем прямую загрузку файла
+            console.log('\n--- Тестирование прямой загрузки файла ---');
+            await directUploadFile(textFilePath, stsData);
+            
+            // Тестируем загрузку через API
+            console.log('\n--- Тестирование загрузки через API ---');
+            await uploadTestFile(textFilePath);
+        } else {
+            // Тестируем получение STS токена
+            const fileInfo = {
+                filename: 'test-image.jpg',
+                filesize: fs.statSync(testFilePath).size,
+                filetype: 'image'
+            };
+            
+            const stsData = await getTestStsToken(fileInfo);
+            
+            // Тестируем прямую загрузку файла
+            console.log('\n--- Тестирование прямой загрузки файла ---');
+            await directUploadFile(testFilePath, stsData);
+            
+            // Тестируем загрузку через API
+            console.log('\n--- Тестирование загрузки через API ---');
+            await uploadTestFile(testFilePath);
+        }
+        
+        console.log('\nТестирование завершено успешно!');
+    } catch (error) {
+        console.error('Ошибка при выполнении теста:', error.message);
+    }
+}
+
+// Запускаем тест
+runTest(); 

examples/openai-sdk/conversation.js

@@ -0,0 +1,66 @@
+// Пример использования OpenAI SDK для диалога с несколькими сообщениями
+// Установка: npm install openai
+
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+    baseURL: 'http://localhost:3264/api', 
+    apiKey: 'dummy-key', // Ключ не используется, но требуется для SDK
+});
+
+async function conversationExample() {
+    try {
+        console.log('Начинаем диалог с Qwen AI...\n');
+        
+        // Первое сообщение пользователя
+        console.log('Пользователь: Привет! Расскажи о квантовой физике простыми словами.');
+        
+        let completion = await openai.chat.completions.create({
+            messages: [
+                { role: 'user', content: 'Привет! Расскажи о квантовой физике простыми словами.' }
+            ],
+            model: 'qwen-max-latest',
+        });
+        
+        const assistantResponse1 = completion.choices[0].message.content;
+        console.log('\nQwen:', assistantResponse1);
+        
+        // Второе сообщение пользователя, включающее историю беседы
+        console.log('\nПользователь: А как это связано с теорией относительности?');
+        
+        completion = await openai.chat.completions.create({
+            messages: [
+                { role: 'user', content: 'Привет! Расскажи о квантовой физике простыми словами.' },
+                { role: 'assistant', content: assistantResponse1 },
+                { role: 'user', content: 'А как это связано с теорией относительности?' }
+            ],
+            model: 'qwen-max-latest',
+        });
+        
+        const assistantResponse2 = completion.choices[0].message.content;
+        console.log('\nQwen:', assistantResponse2);
+        
+        // Третье сообщение пользователя
+        console.log('\nПользователь: Спасибо! Кто из ученых внес наибольший вклад в развитие этих теорий?');
+        
+        completion = await openai.chat.completions.create({
+            messages: [
+                { role: 'user', content: 'Привет! Расскажи о квантовой физике простыми словами.' },
+                { role: 'assistant', content: assistantResponse1 },
+                { role: 'user', content: 'А как это связано с теорией относительности?' },
+                { role: 'assistant', content: assistantResponse2 },
+                { role: 'user', content: 'Спасибо! Кто из ученых внес наибольший вклад в развитие этих теорий?' }
+            ],
+            model: 'qwen-max-latest',
+        });
+        
+        console.log('\nQwen:', completion.choices[0].message.content);
+        console.log('\nДиалог успешно завершен.');
+
+    } catch (error) {
+        console.error('Ошибка при выполнении диалога:', error);
+    }
+}
+
+// Запуск
+conversationExample(); 

examples/openai-sdk/image-analysis.js

@@ -0,0 +1,48 @@
+// Пример использования OpenAI SDK для анализа изображения
+// Установка: npm install openai
+
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+    baseURL: 'http://localhost:3264/api', 
+    apiKey: 'dummy-key', // Ключ не используется, но требуется для SDK
+});
+
+// ВАЖНО: Замените URL_ИЗОБРАЖЕНИЯ на реальный URL изображения, полученный из интерфейса Qwen
+// Инструкция по получению URL в README.md, раздел "Получение URL изображения из интерфейса Qwen"
+const IMAGE_URL = "https://cdn.qwenlm.ai/bf6238a3-4578-49d6-b4a9-516e8a5eb27b/c88bc915-6ae7-4057-9bf9-1185c9141a0a_image.png?key=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyZXNvdXJjZV91c2VyX2lkIjoiYmY2MjM4YTMtNDU3OC00OWQ2LWI0YTktNTE2ZThhNWViMjdiIiwicmVzb3VyY2VfaWQiOiJjODhiYzkxNS02YWU3LTQwNTctOWJmOS0xMTg1YzkxNDFhMGEiLCJyZXNvdXJjZV9jaGF0X2lkIjpudWxsfQ.qPvHr4fq23IgzxmxOyFJuFcVL0AJlpGgPlWB8BHkrlo";
+
+async function analyzeImage() {
+    try {
+        console.log('Отправка запроса с изображением к Qwen AI...\n');
+
+        const completion = await openai.chat.completions.create({
+            messages: [
+                { 
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Опиши подробно, что изображено на этой картинке'
+                        },
+                        {
+                            type: 'image',
+                            image: IMAGE_URL
+                        }
+                    ]
+                }
+            ],
+            model: 'qwen3-235b-a22b', // Используем модель с поддержкой изображений
+        });
+
+        console.log('Ответ от Qwen:\n');
+        console.log(completion.choices[0].message.content);
+        console.log('\nАнализ изображения успешно выполнен.');
+
+    } catch (error) {
+        console.error('Ошибка при выполнении запроса с изображением (Убедитесь, что размер изображения не превышает 10MB):', error);
+    }
+}
+
+// Запуск
+analyzeImage(); 

examples/openai-sdk/openai-compatibility.js

@@ -0,0 +1,78 @@
+// Пример, демонстрирующий совместимость с OpenAI API
+// Установка: npm install openai
+
+import OpenAI from 'openai';
+
+// Настройка клиента OpenAI с использованием нашего прокси как точки доступа
+const openai = new OpenAI({
+    baseURL: 'http://localhost:3264/api', 
+    apiKey: 'dummy-key', // Ключ не используется, но требуется для SDK
+});
+
+async function openaiCompatibilityExample() {
+    try {
+        console.log('Демонстрация совместимости с OpenAI API\n');
+        
+        // 1. Стандартный запрос в формате OpenAI
+        console.log('1. Стандартный запрос в формате OpenAI...');
+        
+        const completion = await openai.chat.completions.create({
+            model: 'qwen-max-latest',
+            messages: [
+                { role: 'system', content: 'Ты полезный ассистент, который дает краткие и четкие ответы.' },
+                { role: 'user', content: 'Что такое искусственный интеллект?' }
+            ],
+            temperature: 0.7,
+        });
+        
+        console.log('Ответ:');
+        console.log(completion.choices[0].message.content);
+        
+        // 2. Потоковый запрос в формате OpenAI
+        console.log('\n2. Потоковый запрос в формате OpenAI...');
+        
+        console.log('Ответ (потоковый режим):');
+        const stream = await openai.chat.completions.create({
+            model: 'qwen-max-latest',
+            messages: [
+                { role: 'system', content: 'Ты полезный ассистент, который отвечает кратко.' },
+                { role: 'user', content: 'Перечисли 5 самых популярных языков программирования' }
+            ],
+            stream: true,
+        });
+        
+        let streamedContent = '';
+        for await (const chunk of stream) {
+            const content = chunk.choices[0]?.delta?.content || '';
+            streamedContent += content;
+            process.stdout.write(content);
+        }
+        console.log('\n');
+        
+        // 3. Демонстрация структуры ответа в формате OpenAI
+        console.log('\n3. Структура ответа в формате OpenAI:');
+        
+        const responseDemo = await openai.chat.completions.create({
+            model: 'qwen-max-latest',
+            messages: [{ role: 'user', content: 'Привет!' }],
+        });
+        
+        // Выводим структуру ответа (без содержимого сообщения)
+        const { choices, ...responseWithoutChoices } = responseDemo;
+        console.log(JSON.stringify({
+            ...responseWithoutChoices,
+            choices: [{
+                ...choices[0],
+                message: { role: choices[0].message.role, content: '[содержимое сообщения скрыто для краткости]' }
+            }]
+        }, null, 2));
+        
+
+        
+    } catch (error) {
+        console.error('Ошибка при выполнении примера:', error);
+    }
+}
+
+// Запуск
+openaiCompatibilityExample(); 

examples/openai-sdk/simple.js

@@ -0,0 +1,32 @@
+// Пример использования OpenAI SDK с прокси для Qwen AI - обычный запрос
+// Установка: npm install openai
+
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+    baseURL: 'http://localhost:3264/api', 
+    apiKey: 'dummy-key', // Ключ не используется, но требуется для SDK
+});
+
+async function simpleRequest() {
+    try {
+        console.log('Отправка запроса к Qwen AI...\n');
+
+        const completion = await openai.chat.completions.create({
+            messages: [
+                { role: 'user', content: 'Напиши 5 интересных фактов о космосе' }
+            ],
+            model: 'qwen-max-latest', 
+        });
+
+        console.log('Ответ от Qwen:\n');
+        console.log(completion.choices[0].message.content);
+        console.log('\nЗапрос успешно выполнен.');
+
+    } catch (error) {
+        console.error('Ошибка при выполнении запроса:', error);
+    }
+}
+
+// Запуск
+simpleRequest(); 

examples/openai-sdk/streaming.js

@@ -0,0 +1,39 @@
+// Пример использования OpenAI SDK с прокси для Qwen AI в потоковом режиме
+// Установка: npm install openai
+
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+    baseURL: 'http://localhost:3264/api', 
+    apiKey: 'dummy-key', 
+});
+
+async function streamFromQwen() {
+    try {
+        console.log('Отправка потокового запроса к Qwen AI...\n');
+
+
+        const stream = await openai.chat.completions.create({
+            messages: [
+                { role: 'user', content: 'Напиши небольшую историю о космических путешествиях' }
+            ],
+            model: 'qwen-max-latest', 
+            stream: true, 
+        });
+
+        console.log('Ответ от Qwen (потоковый режим):\n');
+
+        for await (const chunk of stream) {
+            const content = chunk.choices[0]?.delta?.content || '';
+            process.stdout.write(content);
+        }
+
+        console.log('\n\nПотоковый ответ завершен.');
+
+    } catch (error) {
+        console.error('Ошибка при выполнении потокового запроса:', error);
+    }
+}
+
+// Запуск
+streamFromQwen(); 

examples/openai-sdk/system-message.js

@@ -0,0 +1,39 @@
+// Пример использования OpenAI SDK с системным сообщением
+// Установка: npm install openai
+
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+    baseURL: 'http://localhost:3264/api', 
+    apiKey: 'dummy-key', // Ключ не используется, но требуется для SDK
+});
+
+async function systemMessageExample() {
+    try {
+        console.log('Отправка запроса с системным сообщением к Qwen AI...\n');
+
+        const completion = await openai.chat.completions.create({
+            messages: [
+                { 
+                    role: 'system', 
+                    content: 'Ты опытный астроном, который специализируется на планетах Солнечной системы. Отвечай научно точно, но понятным языком.' 
+                },
+                { 
+                    role: 'user', 
+                    content: 'Расскажи мне о Марсе и его особенностях' 
+                }
+            ],
+            model: 'qwen-max-latest', 
+        });
+
+        console.log('Ответ от Qwen:\n');
+        console.log(completion.choices[0].message.content);
+        console.log('\nЗапрос с системным сообщением успешно выполнен.');
+
+    } catch (error) {
+        console.error('Ошибка при выполнении запроса:', error);
+    }
+}
+
+// Запуск
+systemMessageExample(); 

index.js

@@ -0,0 +1,234 @@
+import express from 'express';
+import bodyParser from 'body-parser';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import readline from 'readline';
+
+
+import { initBrowser, shutdownBrowser } from './src/browser/browser.js';
+import apiRoutes from './src/api/routes.js';
+import { getAvailableModelsFromFile, getApiKeys } from './src/api/chat.js';
+import { loadTokens } from './src/api/tokenManager.js';
+import { addAccountInteractive } from './src/utils/accountSetup.js';
+import { logHttpRequest, logInfo, logError, logWarn } from './src/logger/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+const app = express();
+
+const DEFAULT_PORT = 3264;
+const port = Number.parseInt(process.env.PORT ?? DEFAULT_PORT, 10);
+const host = process.env.HOST || '0.0.0.0';
+
+if (Number.isNaN(port) || port <= 0 || port > 65535) {
+    throw new Error(`Некорректное значение переменной PORT: ${process.env.PORT}`);
+}
+
+const skipAccountMenu = toBoolean(process.env.SKIP_ACCOUNT_MENU) || toBoolean(process.env.NON_INTERACTIVE);
+
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(res => rl.question(question, ans => { rl.close(); res(ans.trim()); }));
+}
+
+function toBoolean(value) {
+    if (typeof value !== 'string') return false;
+    return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+}
+
+function ensureNonInteractiveTokens() {
+    const tokens = loadTokens();
+    if (!tokens.length) {
+        logError('Не найдено ни одного аккаунта. Запустите скрипт авторизации перед запуском сервера.');
+        process.exit(1);
+    }
+
+    const now = Date.now();
+    const validTokens = tokens.filter(t => (!t.resetAt || new Date(t.resetAt).getTime() <= now) && !t.invalid);
+
+    if (!validTokens.length) {
+        logError('Все аккаунты недоступны. Перезапустите авторизацию перед запуском сервера.');
+        process.exit(1);
+    }
+
+    logInfo(`Автоматический запуск: обнаружено ${tokens.length} аккаунтов, из них ${validTokens.length} активны.`);
+}
+
+// Middleware для логирования HTTP-запросов
+app.use(logHttpRequest);
+
+app.use(bodyParser.json({ limit: '150mb' }));
+app.use(bodyParser.urlencoded({ limit: '150mb', extended: true }));
+
+app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+
+    if (req.method === 'OPTIONS') {
+        return res.sendStatus(200);
+    }
+
+    next();
+});
+
+app.use('/api', apiRoutes);
+
+// Обработчик 404
+app.use((req, res) => {
+    logWarn(`404 Not Found: ${req.method} ${req.originalUrl}`);
+    res.status(404).json({ error: 'Эндпоинт не найден' });
+});
+
+// Обработчик ошибок
+app.use((err, req, res, next) => {
+    logError('Внутренняя ошибка сервера', err);
+    res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+});
+
+process.on('SIGINT', handleShutdown);
+process.on('SIGTERM', handleShutdown);
+process.on('SIGHUP', handleShutdown);
+
+process.on('uncaughtException', async (error) => {
+    logError('Необработанное исключение', error);
+    await handleShutdown();
+});
+
+async function handleShutdown() {
+    logInfo('\nПолучен сигнал завершения. Закрываем браузер...');
+    await shutdownBrowser();
+    logInfo('Завершение работы.');
+
+    process.exit(0);
+}
+
+async function startServer() {
+    console.log(`
+███████ ██████  ███████ ███████  ██████  ██     ██ ███████ ███    ██  █████  ██████  ██ 
+██      ██   ██ ██      ██      ██    ██ ██     ██ ██      ████   ██ ██   ██ ██   ██ ██ 
+█████   ██████  █████   █████   ██    ██ ██  █  ██ █████   ██ ██  ██ ███████ ██████  ██ 
+██      ██   ██ ██      ██      ██ ▄▄ ██ ██ ███ ██ ██      ██  ██ ██ ██   ██ ██      ██ 
+██      ██   ██ ███████ ███████  ██████   ███ ███  ███████ ██   ████ ██   ██ ██      ██ 
+                                    ▀▀                                                    
+   API-прокси для Qwen 
+`);
+
+    logInfo('Запуск сервера...');
+
+    if (!skipAccountMenu) {
+        // Меню управления аккаунтами перед запуском прокси
+        while (true) {
+            const tokens = loadTokens();
+            console.log('\nСписок аккаунтов:');
+            if (!tokens.length) {
+                console.log('  (пусто)');
+            } else {
+                tokens.forEach((token, i) => {
+                    const now = Date.now();
+                    const isInvalid = token.invalid === true;
+                    const isWaiting = Boolean(token.resetAt && new Date(token.resetAt).getTime() > now);
+                    const statusCode = isInvalid ? 0 : isWaiting ? 1 : 2;
+                    const statusLabel = isInvalid ? '❌ Недействителен' : isWaiting ? '⏳ Ожидание сброса' : '✅ OK';
+                    console.log(`${String(i + 1).padStart(2, ' ')} | ${token.id} | ${statusLabel} (${statusCode})`);
+                });
+            }
+            console.log('\n=== Меню ===');
+            console.log('1 - Добавить новый аккаунт');
+            console.log('2 - Перелогинить аккаунт с истекшим токеном');
+            console.log('3 - Запустить прокси (по умолчанию)');
+            console.log('4 - Удалить аккаунт');
+            let choice = await prompt('Ваш выбор (Enter = 3): ');
+            if (!choice) choice = '3';
+            if (choice === '1') {
+                await addAccountInteractive();
+            } else if (choice === '2') {
+                const { reloginAccountInteractive } = await import('./src/utils/accountSetup.js');
+                await reloginAccountInteractive();
+            } else if (choice === '3') {
+                const hasValidToken = tokens.some(token => {
+                    if (token.invalid) return false;
+                    if (!token.resetAt) return true;
+                    return new Date(token.resetAt).getTime() <= Date.now();
+                });
+
+                if (!tokens.length || !hasValidToken) {
+                    console.log('Нужен хотя бы один валидный аккаунт для запуска.');
+                    continue;
+                }
+                break;
+            } else if (choice === '4') {
+                const { removeAccountInteractive } = await import('./src/utils/accountSetup.js');
+                await removeAccountInteractive();
+            }
+        }
+    } else {
+        ensureNonInteractiveTokens();
+    }
+
+    //=====================================================================================================
+    //const sim = await prompt('Смоделировать ошибку RateLimited для первого запроса? (y/N): ');
+    //if (sim.toLowerCase() === 'y') {
+    //    global.simulateRateLimit = true;
+    // }
+    //=====================================================================================================
+
+    const browserInitialized = await initBrowser(false);
+    if (!browserInitialized) {
+        logError('Не удалось инициализировать браузер. Завершение работы.');
+        process.exit(1);
+    }
+
+    try {
+        app.listen(port, host, () => {
+            const displayHost = host === '0.0.0.0' ? 'localhost' : host;
+            logInfo(`Сервер запущен на ${host}:${port}`);
+            logInfo(`API доступен по адресу: http://${displayHost}:${port}/api`);
+            logInfo('Для проверки статуса авторизации: GET /api/status');
+            logInfo('Для отправки сообщения: POST /api/chat');
+            logInfo('Для получения списка моделей: GET /api/models');
+            logInfo('======================================================');
+            logInfo('API v2 - История чатов хранится на серверах Qwen');
+            logInfo('Создать новый чат: POST /api/chats');
+            logInfo('Отправить сообщение: POST /api/chat (с chatId и parentId)');
+            logInfo('======================================================');
+            logInfo('Доступно 19 моделей Qwen (через систему маппинга):');
+            logInfo('- Стандартные: qwen-max, qwen-plus, qwen-turbo и их latest-версии');
+            logInfo('- Coder: qwen3-coder-plus, qwen2.5-coder-*b-instruct (0.5b - 32b)');
+            logInfo('- Визуальные: qwen-vl-max, qwen-vl-plus и их latest-версии');
+            logInfo('- Qwen 3: qwen3, qwen3-max, qwen3-plus, qwen3-omni-flash');
+            logInfo('======================================================');
+            logInfo('Формат JSON запроса на чат:');
+            logInfo('{ "message": "т��кст сообщения", "model": "название модели (опционально)", "chatId": "ID чата (опционально)", "parentId": "ID родительского сообщения (опционально)" }');
+            logInfo('Пример первого запроса: { "message": "Привет, как дела?" }');
+            logInfo('Пример второго запроса: { "message": "А что ты умеешь?", "chatId": "полученный_id_чата", "parentId": "полученный_parentId" }');
+            logInfo('======================================================');
+            logInfo('Поддержка OpenAI совместимого API: POST /api/chat/completions');
+            logInfo('В ответе возвращаются chatId и parentId для продолжения диалога');
+            logInfo('======================================================');
+
+
+            getApiKeys();
+
+            getAvailableModelsFromFile();
+        });
+    } catch (err) {
+        if (err.code === 'EADDRINUSE') {
+            logError(`Порт ${port} уже используется. Возможно, сервер уже запущен.`);
+            logError('Завершите работу существующего сервера или используйте другой порт.');
+            await shutdownBrowser();
+            process.exit(1);
+        } else {
+            throw err;
+        }
+    }
+}
+
+startServer().catch(async error => {
+    logError('Ошибка при запуске сервера:', error);
+    await shutdownBrowser();
+
+    process.exit(1);
+});

package.json

@@ -0,0 +1,39 @@
+{
+    "name": "qwen-api-proxy",
+    "version": "1.0.0",
+    "description": "Прокси-сервер для доступа к Qwen API через эмуляцию браузера",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "start": "node index.js",
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "example:stream": "node examples/openai-sdk/streaming.js",
+        "example:simple": "node examples/openai-sdk/simple.js",
+        "example:system": "node examples/openai-sdk/system-message.js",
+        "example:image": "node examples/openai-sdk/image-analysis.js",
+        "example:conversation": "node examples/openai-sdk/conversation.js",
+        "example:compatibility": "node examples/openai-sdk/openai-compatibility.js",
+        "example:direct": "node examples/direct-api/fetch-example.js",
+        "example:axios": "node examples/direct-api/axios-example.js",
+        "example:chat-management": "node examples/direct-api/chat-management.js",
+        "example:file-upload": "node examples/file-upload/upload-example.js",
+        "auth": "node scripts/auth.js"
+    },
+    "dependencies": {
+        "ali-oss": "^6.23.0",
+        "axios": "^1.9.0",
+        "body-parser": "^1.20.2",
+        "express": "^4.18.2",
+        "form-data": "^4.0.2",
+        "morgan": "^1.10.0",
+        "multer": "^2.0.0",
+        "node-fetch": "^3.3.2",
+        "openai": "^4.104.0",
+        "playwright": "^1.35.0",
+        "playwright-extra": "^4.3.6",
+        "puppeteer": "^24.31.0",
+        "puppeteer-extra": "^3.3.6",
+        "puppeteer-extra-plugin-stealth": "^2.11.2",
+        "winston": "^3.17.0"
+    }
+}

patch-cline.bat

@@ -0,0 +1,57 @@
+@echo off
+setlocal EnableDelayedExpansion
+:: Остановим все процессы VSCode
+echo Останавливаю Visual Studio Code...
+taskkill /im "Code.exe" /f >nul 2>&1
+
+:: Путь к файлу extension.js — автоматически определяем из профиля пользователя
+set USERPROFILE=%USERPROFILE%
+set EXT_PATH=%USERPROFILE%\.vscode\extensions\saoudrizwan.claude-dev-3.17.8\dist\extension.js
+
+:: Проверяем, существует ли файл
+if not exist "%EXT_PATH%" (
+    echo Файл не найден: "%EXT_PATH%"
+    echo Введите полный путь к файлу extension.js:
+    set /p EXT_PATH=
+    if not exist "!EXT_PATH!" (
+        echo Файл не найден: "!EXT_PATH!"
+        pause
+        exit /b 1
+    )
+)
+
+:: Делаем бэкап, если его ещё нет
+if not exist "%EXT_PATH%-" (
+    echo Делаю резервную копию...
+    copy "%EXT_PATH%" "%EXT_PATH%-" >nul
+) else (
+    echo Восстанавливаю из резервной копии...
+    copy /Y "%EXT_PATH%-" "%EXT_PATH%" >nul
+)
+
+:: Замена строки в файле
+echo Меняю URL API на http://localhost:3264/api
+powershell -Command "(Get-Content '%EXT_PATH%') -replace 'https://dashscope.aliyuncs.com/compatible-mode/v1',  'http://localhost:3264/api' | Set-Content '%EXT_PATH%'"
+powershell -Command "(Get-Content '%EXT_PATH%') -replace 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1',  'http://localhost:3264/api' | Set-Content '%EXT_PATH%'"
+
+
+:: Определение пути к VS Code
+set VSCODE_PATH=C:\Users\%USERNAME%\AppData\Local\Programs\Microsoft VS Code\Code.exe
+if not exist "%VSCODE_PATH%" (
+    set VSCODE_PATH=C:\Program Files\Microsoft VS Code\Code.exe
+    if not exist "%VSCODE_PATH%" (
+        set VSCODE_PATH=C:\Program Files (x86)\Microsoft VS Code\Code.exe
+        if not exist "%VSCODE_PATH%" (
+            echo VS Code не найден по стандартным путям.
+            echo Введите полный путь к Code.exe:
+            set /p VSCODE_PATH=
+        )
+    )
+)
+
+:: Перезапускаем VSCode
+echo Перезапускаю Visual Studio Code...
+start "" "%VSCODE_PATH%"
+
+echo Готово!
+pause

scripts/addAccount.js

@@ -0,0 +1,8 @@
+// Скрипт interactively добавляет новые аккаунты.
+// Запуск: node scripts/addAccount.js
+
+import { interactiveAccountMenu } from '../src/utils/accountSetup.js';
+
+(async () => {
+    await interactiveAccountMenu();
+})(); 

scripts/auth.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+import readline from 'readline';
+
+import { loadTokens } from '../src/api/tokenManager.js';
+import { addAccountInteractive, reloginAccountInteractive, removeAccountInteractive } from '../src/utils/accountSetup.js';
+
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => rl.question(question, answer => { rl.close(); resolve(answer.trim()); }));
+}
+
+function printDivider() {
+    console.log('======================================================');
+}
+
+const STATUS_CODES = {
+    INVALID: 0,
+    WAIT: 1,
+    OK: 2
+};
+
+function formatStatus(token) {
+    const now = Date.now();
+    if (token.invalid) {
+        return { code: STATUS_CODES.INVALID, label: '❌ Недействителен' };
+    }
+    if (token.resetAt && new Date(token.resetAt).getTime() > now) {
+        return { code: STATUS_CODES.WAIT, label: '⏳ Ожидание сброса' };
+    }
+    return { code: STATUS_CODES.OK, label: '✅ OK' };
+}
+
+function printAccounts(tokens) {
+    console.log('\nСписок аккаунтов:');
+    if (!tokens.length) {
+        console.log('  (пусто)');
+        return;
+    }
+
+    tokens.forEach((token, index) => {
+        const status = formatStatus(token);
+        console.log(`${String(index + 1).padStart(2, ' ')} | ${token.id} | ${status.label} (${status.code})`);
+    });
+}
+
+function handleList(tokens) {
+    printAccounts(tokens);
+    const active = tokens.filter(t => formatStatus(t).code === STATUS_CODES.OK);
+    console.log(`\nАктивных аккаунтов: ${active.length} из ${tokens.length}`);
+}
+
+function parseArgs(argv) {
+    const args = new Set(argv.slice(2));
+    if (args.has('--help') || args.has('-h')) return 'help';
+    if (args.has('--list')) return 'list';
+    if (args.has('--add')) return 'add';
+    if (args.has('--relogin')) return 'relogin';
+    if (args.has('--remove')) return 'remove';
+    return null;
+}
+
+function printHelp() {
+    printDivider();
+    console.log('Скрипт управления аккаунтами Qwen');
+    printDivider();
+    console.log('Опции:');
+    console.log('  --list      Показать список аккаунтов и статусы');
+    console.log('  --add       Добавить новый аккаунт');
+    console.log('  --relogin   Перелогинить аккаунт с истекшим токеном');
+    console.log('  --remove    Удалить аккаунт');
+    console.log('Без опций запускается интерактивное меню.');
+    printDivider();
+}
+
+async function runCliAction(action) {
+    if (action === 'help') {
+        printHelp();
+        return;
+    }
+
+    if (action === 'list') {
+        const tokens = loadTokens();
+        handleList(tokens);
+        return;
+    }
+
+    if (action === 'add') {
+        await addAccountInteractive();
+        return;
+    }
+
+    if (action === 'relogin') {
+        await reloginAccountInteractive();
+        return;
+    }
+
+    if (action === 'remove') {
+        await removeAccountInteractive();
+        return;
+    }
+}
+
+async function runInteractiveMenu() {
+    while (true) {
+        const tokens = loadTokens();
+        printDivider();
+        printAccounts(tokens);
+        printDivider();
+        console.log('Меню:');
+        console.log('1 - Добавить новый аккаунт');
+        console.log('2 - Перелогинить аккаунт с истекшим токеном');
+        console.log('3 - Удалить аккаунт');
+        console.log('4 - Показать список и статусы');
+        console.log('5 - Выход');
+        const choice = await prompt('Ваш выбор (Enter = 5): ');
+        const normalized = choice || '5';
+
+        if (normalized === '1') {
+            await addAccountInteractive();
+        } else if (normalized === '2') {
+            await reloginAccountInteractive();
+        } else if (normalized === '3') {
+            await removeAccountInteractive();
+        } else if (normalized === '4') {
+            handleList(tokens);
+            await prompt('\nНажмите Enter, чтобы вернуться в меню...');
+        } else if (normalized === '5') {
+            console.log('Выход из скрипта.');
+            break;
+        }
+    }
+}
+
+(async () => {
+    const action = parseArgs(process.argv);
+    if (action) {
+        await runCliAction(action);
+        return;
+    }
+
+    await runInteractiveMenu();
+})();

src/AvaibleModels.txt

@@ -0,0 +1,18 @@
+qwen3-max
+qwen3-vl-plus
+qwen3-coder-plus
+qwen3-omni-flash
+qwen-plus-2025-09-11
+qwen3-235b-a22b
+qwen3-30b-a3b
+qwen3-coder-30b-a3b-instruct
+qwen-max-latest
+qwen-plus-2025-01-25
+qwq-32b
+qwen-turbo-2025-02-11
+qwen2.5-omni-7b
+qvq-72b-preview-0310
+qwen2.5-vl-32b-instruct
+qwen2.5-14b-instruct-1m
+qwen2.5-coder-32b-instruct
+qwen2.5-72b-instruct

src/api/chat.js

@@ -0,0 +1,753 @@
+import { getBrowserContext, getAuthenticationStatus, setAuthenticationStatus } from '../browser/browser.js';
+import { checkAuthentication } from '../browser/auth.js';
+import { checkVerification } from '../browser/auth.js';
+import { shutdownBrowser, initBrowser } from '../browser/browser.js';
+import { saveAuthToken } from '../browser/session.js';
+import { getAvailableToken, markRateLimited, removeInvalidToken } from './tokenManager.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logRaw } from '../logger/index.js';
+import crypto from 'crypto';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const CHAT_API_URL_V2 = 'https://chat.qwen.ai/api/v2/chat/completions';
+const CREATE_CHAT_URL = 'https://chat.qwen.ai/api/v2/chats/new';
+const CHAT_PAGE_URL = 'https://chat.qwen.ai/';
+
+const MODELS_FILE = path.join(__dirname, '..', 'AvaibleModels.txt');
+const AUTH_KEYS_FILE = path.join(__dirname, '..', 'Authorization.txt');
+
+let authToken = null;
+let availableModels = null;
+let authKeys = null;
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+async function getPage(context) {
+    if (context && typeof context.goto === 'function') {
+        return context;
+    } else if (context && typeof context.newPage === 'function') {
+        const page = await context.newPage();
+        return page;
+    } else {
+        throw new Error('Неверный контекст: не страница Puppeteer, не контекст Playwright');
+    }
+}
+
+export const pagePool = {
+    pages: [],
+    maxSize: 3,
+
+    async getPage(context) {
+        if (this.pages.length > 0) {
+            return this.pages.pop();
+        }
+
+        const newPage = await getPage(context);
+        await newPage.goto(CHAT_PAGE_URL, { waitUntil: 'domcontentloaded', timeout: 120000 });
+
+        if (!authToken) {
+            try {
+                authToken = await newPage.evaluate(() => localStorage.getItem('token'));
+                console.log('Токен авторизации получен из браузера');
+
+                if (authToken) {
+                    saveAuthToken(authToken);
+                }
+            } catch (e) {
+                console.error('Ошибка при получении токена авторизации:', e);
+            }
+        }
+
+        return newPage;
+    },
+
+    releasePage(page) {
+        if (this.pages.length < this.maxSize) {
+            this.pages.push(page);
+        } else {
+            page.close().catch(e => console.error('Ошибка при закрытии страницы:', e));
+        }
+    },
+
+    async clear() {
+        for (const page of this.pages) {
+            try {
+                await page.close();
+            } catch (e) {
+                console.error('Ошибка при закрытии страницы в пуле:', e);
+            }
+        }
+        this.pages = [];
+    }
+};
+
+export async function extractAuthToken(context, forceRefresh = false) {
+    if (authToken && !forceRefresh) {
+        return authToken;
+    }
+
+    try {
+        const page = await getPage(context);
+        
+        try {
+            await page.goto(CHAT_PAGE_URL, { waitUntil: 'domcontentloaded', timeout: 120000 });
+            await delay(2000);
+
+            const newToken = await page.evaluate(() => localStorage.getItem('token'));
+
+            if (typeof context.newPage === 'function') {
+                await page.close();
+            }
+
+            if (newToken) {
+                authToken = newToken;
+                console.log('Токен авторизации успешно извлечен');
+                saveAuthToken(authToken);
+                return authToken;
+            } else {
+                console.error('Токен авторизации не найден в браузере');
+                return null;
+            }
+        } catch (error) {
+            if (typeof context.newPage === 'function') {
+                await page.close().catch(() => {});
+            }
+            throw error;
+        }
+    } catch (error) {
+        console.error('Ошибка при извлечении токена авторизации:', error);
+        return null;
+    }
+}
+
+export function getAvailableModelsFromFile() {
+    try {
+        if (!fs.existsSync(MODELS_FILE)) {
+            console.error(`Файл с моделями не найден: ${MODELS_FILE}`);
+            return ['qwen-max-latest'];
+        }
+
+        const fileContent = fs.readFileSync(MODELS_FILE, 'utf8');
+        const models = fileContent.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+
+        console.log('===== ДОСТУПНЫЕ МОДЕЛИ =====');
+        models.forEach(model => console.log(`- ${model}`));
+        console.log('============================');
+
+        return models;
+    } catch (error) {
+        console.error('Ошибка при чтении файла с моделями:', error);
+        return ['qwen-max-latest'];
+    }
+}
+
+function getAuthKeysFromFile() {
+    try {
+        if (!fs.existsSync(AUTH_KEYS_FILE)) {
+            const template = `# Файл API-ключей для прокси\n# --------------------------------------------\n# В этом файле перечислены токены, которые\n# прокси будет считать «действительными».\n# Один ключ — одна строка без пробелов.\n#\n# 1) Хотите ОТКЛЮЧИТЬ авторизацию целиком?\n#    Оставьте файл пустым — сервер перестанет\n#    проверять заголовок Authorization.\n#\n# 2) Хотите разрешить доступ нескольким людям?\n#    Впишите каждый ключ в отдельной строке:\n#      d35ab3e1-a6f9-4d...\n#      f2b1cd9c-1b2e-4a...\n#\n# Пустые строки и строки, начинающиеся с «#»,\n# игнорируются.`;
+            try {
+                fs.writeFileSync(AUTH_KEYS_FILE, template, { encoding: 'utf8', flag: 'wx' });
+                console.log(`Создан шаблон файла ключей: ${AUTH_KEYS_FILE}`);
+            } catch (e) {
+                console.error('Не удалось создать шаблон Authorization.txt:', e);
+            }
+            return [];
+        }
+
+        const fileContent = fs.readFileSync(AUTH_KEYS_FILE, 'utf8');
+        const keys = fileContent.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+
+        return keys;
+    } catch (error) {
+        console.error('Ошибка при чтении файла с ключами авторизации:', error);
+        return [];
+    }
+}
+
+export function isValidModel(modelName) {
+    if (!availableModels) {
+        availableModels = getAvailableModelsFromFile();
+    }
+
+    return availableModels.includes(modelName);
+}
+
+export function getAllModels() {
+    if (!availableModels) {
+        availableModels = getAvailableModelsFromFile();
+    }
+
+    return {
+        models: availableModels.map(model => ({
+            id: model,
+            name: model,
+            description: `Модель ${model}`
+        }))
+    };
+}
+
+export function getApiKeys() {
+    if (!authKeys) {
+        authKeys = getAuthKeysFromFile();
+    }
+
+    return authKeys;
+}
+
+export async function sendMessage(message, model = "qwen-max-latest", chatId = null, parentId = null, files = null, tools = null, toolChoice = null, systemMessage = null) {
+
+    if (!availableModels) {
+        availableModels = getAvailableModelsFromFile();
+    }
+
+    // Создаём новый чат, если не передан
+    if (!chatId) {
+        const newChatResult = await createChatV2(model);
+        if (newChatResult.error) {
+            return { error: 'Не удалось создать чат: ' + newChatResult.error };
+        }
+        chatId = newChatResult.chatId;
+        console.log(`Создан новый чат v2 с ID: ${chatId}`);
+    }
+
+    // Валидация сообщения
+    let messageContent = message;
+    try {
+        if (message === null || message === undefined) {
+            console.error('Сообщение пустое');
+            return { error: 'Сообщение не может быть пустым', chatId };
+        } else if (typeof message === 'string') {
+            messageContent = message;
+        } else if (Array.isArray(message)) {
+            const isValid = message.every(item =>
+                (item.type === 'text' && typeof item.text === 'string') ||
+                (item.type === 'image' && typeof item.image === 'string') ||
+                (item.type === 'file' && typeof item.file === 'string')
+            );
+
+            if (!isValid) {
+                console.error('Некорректная структура составного сообщения');
+                return { error: 'Некорректная структура составного сообщения', chatId };
+            }
+
+            messageContent = message;
+        } else {
+            console.error('Неподдерживаемый формат сообщения:', message);
+            return { error: 'Неподдерживаемый формат сообщения', chatId };
+        }
+    } catch (error) {
+        console.error('Ошибка при обработке сообщения:', error);
+        return { error: 'Ошибка при обработке сообщения: ' + error.message, chatId };
+    }
+
+    if (!model || model.trim() === "") {
+        model = "qwen-max-latest";
+    } else {
+        if (!isValidModel(model)) {
+            console.warn(`Предупреждение: Указанная модель "${model}" не найдена в списке доступных моделей. Используется модель по умолчанию.`);
+            model = "qwen-max-latest";
+        }
+    }
+
+    console.log(`Используемая модель: "${model}"`);
+
+    let tokenObj = await getAvailableToken();
+    if (tokenObj && tokenObj.token) {
+        authToken = tokenObj.token;
+        console.log(`Используется аккаунт: ${tokenObj.id}`);
+    }
+
+    const browserContext = getBrowserContext();
+    if (!browserContext) {
+        return { error: 'Браузер не инициализирован', chatId };
+    }
+
+    if (!getAuthenticationStatus()) {
+        console.log('Проверка авторизации...');
+        const authCheck = await checkAuthentication(browserContext);
+        if (!authCheck) {
+            return { error: 'Требуется авторизация. Пожалуйста, авторизуйтесь в открытом браузере.', chatId };
+        }
+    }
+
+    if (!authToken) {
+        console.log('Получение токена авторизации...');
+        authToken = await extractAuthToken(browserContext);
+        if (!authToken) {
+            console.error('Не удалось получить токен авторизации');
+            return { error: 'Ошибка авторизации: не удалось получить токен', chatId };
+        }
+    }
+
+    let page = null;
+    try {
+        page = await pagePool.getPage(browserContext);
+
+        const verificationNeeded = await checkVerification(page);
+        if (verificationNeeded) {
+            await page.reload({ waitUntil: 'domcontentloaded', timeout: 120000 });
+        }
+
+        if (!authToken) {
+            console.error('Токен отсутствует перед отправкой запроса');
+            authToken = await page.evaluate(() => localStorage.getItem('token'));
+            if (!authToken) {
+                return { error: 'Токен авторизации не найден. Требуется перезапуск в ручном режиме.', chatId };
+            } else {
+                saveAuthToken(authToken);
+            }
+        }
+
+        console.log('Отправка запроса к API v2...');
+
+        // Формируем новое сообщение для v2 API
+        const userMessageId = crypto.randomUUID();
+        const assistantChildId = crypto.randomUUID();
+        
+        const newMessage = {
+            fid: userMessageId,
+            parentId: parentId,
+            parent_id: parentId,
+            role: "user",
+            content: messageContent,
+            chat_type: "t2t",
+            sub_chat_type: "t2t",
+            timestamp: Math.floor(Date.now() / 1000),
+            user_action: "chat",
+            models: [model],
+            files: files || [],
+            childrenIds: [assistantChildId],
+            extra: {
+                meta: {
+                    subChatType: "t2t"
+                }
+            },
+            feature_config: {
+                thinking_enabled: false,
+                output_schema: "phase"
+            }
+        };
+
+        // Формируем payload для v2 API
+        const payload = {
+            stream: true,
+            incremental_output: true,
+            chat_id: chatId,
+            chat_mode: "normal",
+            messages: [newMessage],
+            model: model,
+            parent_id: parentId,
+            timestamp: Math.floor(Date.now() / 1000)
+        };
+
+        // Добавляем system message если есть
+        if (systemMessage) {
+            payload.system_message = systemMessage;
+            console.log(`System message: ${systemMessage.substring(0, 100)}${systemMessage.length > 100 ? '...' : ''}`);
+        }
+
+        // Добавляем tools если есть
+        if (tools && Array.isArray(tools) && tools.length > 0) {
+            payload.tools = tools;
+            payload.tool_choice = toolChoice || "auto";
+        }
+
+        console.log('=== PAYLOAD V2 ===\n' + JSON.stringify(payload, null, 2));
+        console.log(`Отправка сообщения в чат ${chatId} с parent_id: ${parentId || 'null'}`);
+
+        const apiUrl = `${CHAT_API_URL_V2}?chat_id=${chatId}`;
+        const evalData = {
+            apiUrl: apiUrl,
+            payload: payload,
+            token: authToken
+        };
+
+        console.log(`Используем токен: ${authToken ? 'Токен существует' : 'Токен отсутствует'}`);
+        console.log(`API URL: ${apiUrl}`);
+
+        // Выполняем запрос через браузер и парсим SSE
+        let response = await page.evaluate(async (data) => {
+            try {
+                const token = data.token;
+                if (!token) {
+                    return { success: false, error: 'Токен авторизации не найден' };
+                }
+
+                const response = await fetch(data.apiUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${token}`,
+                        'Accept': '*/*'
+                    },
+                    body: JSON.stringify(data.payload)
+                });
+
+                if (response.ok) {
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = '';
+                    let fullContent = '';
+                    let responseId = null;
+                    let usage = null;
+                    let finished = false;
+
+                    while (!finished) {
+                        const { done, value } = await reader.read();
+                        if (done) break;
+
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || '';
+
+                        for (const line of lines) {
+                            if (!line.trim() || !line.startsWith('data: ')) continue;
+                            
+                            const jsonStr = line.substring(6).trim();
+                            if (!jsonStr) continue;
+
+                            try {
+                                const chunk = JSON.parse(jsonStr);
+                                
+                                // Первый чанк с метаданными
+                                if (chunk['response.created']) {
+                                    responseId = chunk['response.created'].response_id;
+                                }
+                                
+                                // Чанки с контентом
+                                if (chunk.choices && chunk.choices[0]) {
+                                    const delta = chunk.choices[0].delta;
+                                    if (delta && delta.content) {
+                                        fullContent += delta.content;
+                                    }
+                                    if (delta && delta.status === 'finished') {
+                                        finished = true;
+                                    }
+                                }
+                                
+                                // Обновляем usage
+                                if (chunk.usage) {
+                                    usage = chunk.usage;
+                                }
+                            } catch (e) {
+                                // Игнорируем ошибки парсинга отдельных чанков
+                            }
+                        }
+                    }
+
+                    return {
+                        success: true,
+                        data: {
+                            id: responseId || 'chatcmpl-' + Date.now(),
+                            object: 'chat.completion',
+                            created: Math.floor(Date.now() / 1000),
+                            model: data.payload.model,
+                            choices: [{
+                                index: 0,
+                                message: {
+                                    role: 'assistant',
+                                    content: fullContent
+                                },
+                                finish_reason: 'stop'
+                            }],
+                            usage: usage || {
+                                prompt_tokens: 0,
+                                completion_tokens: 0,
+                                total_tokens: 0
+                            },
+                            response_id: responseId
+                        }
+                    };
+                } else {
+                    const errorBody = await response.text();
+                    return {
+                        success: false,
+                        status: response.status,
+                        statusText: response.statusText,
+                        errorBody: errorBody
+                    };
+                }
+            } catch (error) {
+                return { success: false, error: error.toString() };
+            }
+        }, evalData);
+
+        // --- TEST: симуляция ответа RateLimited ---
+        if (global.simulateRateLimit && !global.__rateLimitedTested) {
+            global.__rateLimitedTested = true;
+            response = {
+                success: false,
+                status: 429,
+                errorBody: JSON.stringify({
+                    code: 'RateLimited',
+                    detail: "You've reached the upper limit for today's usage.",
+                    template: 'You have reached the daily usage limit. Please wait {{num}} hours before trying again.',
+                    num: 4
+                })
+            };
+            console.log('*** Симуляция ответа RateLimited активирована ***');
+        }
+
+        pagePool.releasePage(page);
+        page = null;
+
+        if (response.success) {
+            // Логируем сырой ответ от модели
+            logRaw(JSON.stringify(response.data));
+            console.log('Ответ получен успешно');
+
+            // Добавляем метаданные для клиента
+            response.data.chatId = chatId;
+            response.data.parentId = response.data.response_id; // Для следующего сообщения
+            response.data.id = response.data.id || "chatcmpl-" + Date.now();
+
+            return response.data;
+        } else {
+            // Логируем ошибочный сырой ответ
+            logRaw(JSON.stringify(response));
+            console.error('Ошибка при получении ответа:', response.error || response.statusText);
+
+            if (response.errorBody) {
+                console.error('Тело ответа с ошибкой:', response.errorBody);
+            }
+
+            if (response.html && response.html.includes('Verification')) {
+                setAuthenticationStatus(false);
+                console.log('Обнаружена необходимость верификации, перезапуск браузера в видимом режиме...');
+
+                await pagePool.clear();
+
+                authToken = null;
+
+                await shutdownBrowser();
+                await initBrowser(true);
+
+                return { error: 'Требуется верификация. Браузер запущен в видимом режиме.', verification: true, chatId };
+            }
+
+            // ----- Новая обработка истекшего токена / 401 Unauthorized -----
+            if ((response.status === 401) || (response.errorBody && (response.errorBody.includes('Unauthorized') || response.errorBody.includes('Token has expired')))) {
+                console.log('Токен', tokenObj?.id, 'недействителен (401). Удаляем и пробуем другой.');
+
+                // Удаляем токен из пула
+                authToken = null;
+                if (tokenObj && tokenObj.id) {
+                    const { markInvalid } = await import('./tokenManager.js');
+                    markInvalid(tokenObj.id);
+                }
+
+                // Есть ли ещё токены?
+                const { hasValidTokens } = await import('./tokenManager.js');
+                if (hasValidTokens()) {
+                    return await sendMessage(message, model, chatId, files); // повторяем с новым токеном
+                }
+
+                console.error('Не осталось валидных токенов. Останавливаю прокси.');
+                await pagePool.clear();
+                await shutdownBrowser();
+                process.exit(1);
+            }
+
+            if (response.errorBody && response.errorBody.includes('RateLimited')) {
+                try {
+                    const rateInfo = JSON.parse(response.errorBody);
+                    const hours = Number(rateInfo.num) || 24;
+                    if (tokenObj && tokenObj.id) {
+                        markRateLimited(tokenObj.id, hours);
+                        console.log(`Токен ${tokenObj.id} достиг лимита. Помечаем на ${hours}ч и пробуем другой токен...`);
+                    }
+                } catch (e) {
+                    console.error('Не удалось распарсить тело ошибки RateLimited:', e);
+                }
+                authToken = null;
+                return await sendMessage(message, model, chatId, files);
+            }
+
+            return { error: response.error || response.statusText, details: response.errorBody || 'Нет дополнительных деталей', chatId };
+        }
+    } catch (error) {
+        console.error('Ошибка при отправке сообщения:', error);
+        return { error: error.toString(), chatId };
+    } finally {
+        if (page) {
+            try {
+                if (typeof getBrowserContext().newPage === 'function') {
+                    await page.close();
+                }
+            } catch (e) {
+                console.error('Ошибка при закрытии страницы:', e);
+            }
+        }
+    }
+}
+
+export async function clearPagePool() {
+    await pagePool.clear();
+}
+
+export function getAuthToken() {
+    return authToken;
+}
+
+export async function listModels(browserContext) {
+    return await getAvailableModels(browserContext);
+}
+
+// Создание нового чата через v2 API
+export async function createChatV2(model = "qwen-max-latest", title = "Новый чат") {
+    const browserContext = getBrowserContext();
+    if (!browserContext) {
+        return { error: 'Браузер не инициализирован' };
+    }
+
+    // Получаем токен из tokenManager
+    let tokenObj = await getAvailableToken();
+    if (tokenObj && tokenObj.token) {
+        authToken = tokenObj.token;
+        console.log(`Используется аккаунт для создания чата: ${tokenObj.id}`);
+    }
+
+    if (!authToken) {
+        console.log('Получение токена авторизации для создания чата...');
+        authToken = await extractAuthToken(browserContext);
+        if (!authToken) {
+            return { error: 'Не удалось получить токен авторизации' };
+        }
+    }
+
+    let page = null;
+    try {
+        page = await pagePool.getPage(browserContext);
+
+        const payload = {
+            title: title,
+            models: [model],
+            chat_mode: "normal",
+            chat_type: "t2t",
+            timestamp: Date.now()
+        };
+
+        const evalData = {
+            apiUrl: CREATE_CHAT_URL,
+            payload: payload,
+            token: authToken
+        };
+
+        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}`
+                    },
+                    body: JSON.stringify(data.payload)
+                });
+
+                if (response.ok) {
+                    const result = await response.json();
+                    return { success: true, data: result };
+                } else {
+                    const errorBody = await response.text();
+                    return {
+                        success: false,
+                        status: response.status,
+                        errorBody: errorBody
+                    };
+                }
+            } catch (error) {
+                return { success: false, error: error.toString() };
+            }
+        }, evalData);
+
+        pagePool.releasePage(page);
+        page = null;
+
+        if (result.success && result.data.success) {
+            console.log(`Чат создан: ${result.data.data.id}`);
+            return { 
+                success: true, 
+                chatId: result.data.data.id,
+                requestId: result.data.request_id
+            };
+        } else {
+            console.error('Ошибка при создании чата:', result);
+            return { error: result.errorBody || result.error || 'Неизвестная ошибка' };
+        }
+    } catch (error) {
+        console.error('Ошибка при создании чата:', error);
+        return { error: error.toString() };
+    } finally {
+        if (page) {
+            try {
+                if (typeof getBrowserContext().newPage === 'function') {
+                    await page.close();
+                }
+            } catch (e) {
+                console.error('Ошибка при закрытии страницы:', e);
+            }
+        }
+    }
+}
+
+export async function testToken(token) {
+    const browserContext = getBrowserContext();
+    if (!browserContext) return 'ERROR';
+
+    let page;
+    try {
+        page = await getPage(browserContext);
+        await page.goto(CHAT_PAGE_URL, { waitUntil: 'domcontentloaded' });
+
+        const evalData = {
+            apiUrl: CHAT_API_URL_V2,
+            token,
+            payload: {
+                chat_type: 't2t',
+                messages: [{ role: 'user', content: 'ping', chat_type: 't2t' }],
+                model: 'qwen-max-latest',
+                stream: false
+            }
+        };
+
+        const result = await page.evaluate(async (data) => {
+            try {
+                const res = await fetch(data.apiUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${data.token}`
+                    },
+                    body: JSON.stringify(data.payload)
+                });
+                return { ok: res.ok, status: res.status };
+            } catch (e) {
+                return { ok: false, status: 0, error: e.toString() };
+            }
+        }, evalData);
+
+        if (result.ok || result.status === 400) return 'OK';
+        if (result.status === 401 || result.status === 403) return 'UNAUTHORIZED';
+        if (result.status === 429) return 'RATELIMIT';
+        return 'ERROR';
+    } catch (e) {
+        console.error('testToken error:', e);
+        return 'ERROR';
+    } finally {
+        if (page) {
+            try {
+                if (typeof browserContext.newPage === 'function') {
+                    await page.close();
+                }
+            } catch { }
+        }
+    }
+}

src/api/chatHistory.js

@@ -0,0 +1,346 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+import { logInfo, logError, logDebug } from '../logger/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const HISTORY_DIR = path.join(__dirname, '..', '..', 'session', 'history');
+
+const MAX_HISTORY_LENGTH = 100;
+
+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
+        };
+    }
+} 

src/api/fileUpload.js

@@ -0,0 +1,284 @@
+// FileUpload.js - Модуль для загрузки файлов в чат Qwen.ai
+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 { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UPLOAD_DIR = path.join(__dirname, '../../uploads');
+
+const STS_TOKEN_API_URL = 'https://chat.qwen.ai/api/v1/files/getstsToken';
+const OSS_SDK_URL = 'https://gosspublic.alicdn.com/aliyun-oss-sdk-6.20.0.min.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';
+
+// Убедимся, что директория для загрузок существует
+if (!fs.existsSync(UPLOAD_DIR)) {
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true });
+}
+
+/**
+ * Получает и валидирует browser context
+ * @returns {Object} - Browser context
+ * @throws {Error} - Если браузер не инициализирован
+ */
+function validateBrowserContext() {
+    const browserContext = getBrowserContext();
+    if (!browserContext) {
+        throw new Error('Браузер не инициализирован');
+    }
+    return browserContext;
+}
+
+/**
+ * Получает токен авторизации, извлекая из браузера при необходимости
+ * @param {Object} browserContext - Browser context
+ * @returns {Promise<string>} - Токен авторизации
+ * @throws {Error} - Если не удалось получить токен
+ */
+async function validateAuthToken(browserContext) {
+    let tokenObj = await getAvailableToken();
+    let token = null;
+    
+    if (tokenObj && tokenObj.token) {
+        token = tokenObj.token;
+        logInfo(`Используется токен из tokenManager: ${tokenObj.id}`);
+    }
+    
+    if (!token) {
+        token = getAuthToken();
+    }
+    
+    if (!token) {
+        logInfo('Токен авторизации не найден в памяти, пытаемся извлечь из браузера');
+        token = await extractAuthToken(browserContext);
+        if (!token) {
+            throw new Error('Не удалось получить токен авторизации');
+        }
+    }
+    
+    return token;
+}
+
+/**
+ * Получает STS токен доступа для загрузки файлов
+ * @param {Object} fileInfo - Информация о файле (имя, размер, тип)
+ * @returns {Promise<Object>} - Объект с данными токена доступа
+ */
+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()};
+                } else {
+                    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;
+        } else {
+            logError(`Ошибка при получении STS токена: status=${result.status}, error=${result.errorBody || result.error}`);
+            throw new Error(`Ошибка получения STS токена: ${result.statusText || result.error}`);
+        }
+    } catch (error) {
+        logError(`Ошибка при получении STS токена: ${error.message}`, error);
+        throw error;
+    } finally {
+        if (page) {
+            try {
+                pagePool.releasePage(page);
+            } catch (e) {
+                logError('Ошибка при возврате страницы в пул:', e);
+            }
+        }
+    }
+}
+
+/**
+ * Загружает файл на URL, полученный с STS токеном
+ * @param {string} filePath - Путь к файлу для загрузки
+ * @param {Object} stsData - Данные STS токена
+ * @returns {Promise<Object>} - Результат загрузки файла
+ */
+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}`);
+    }
+    
+    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') {
+                    await new Promise((resolve, reject) => {
+                        const script = document.createElement('script');
+                        script.src = data.ossSdkUrl;
+                        script.onload = resolve;
+                        script.onerror = reject;
+                        document.head.appendChild(script);
+                    });
+                }
+                const blob = new Blob([Uint8Array.from(atob(data.fileBase64), c => c.charCodeAt(0))])
+                
+                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
+                });
+                
+                await client.put(data.stsData.file_path, blob);
+                return { success: true };
+            } catch (error) {
+                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) {
+            return {
+                success: true,
+                fileName: path.basename(filePath),
+                url: stsData.file_url,
+                fileId: stsData.file_id,
+                filePath: stsData.file_path
+            };
+        } else {
+            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);
+            }
+        }
+    }
+}
+
+/**
+ * Полный процесс загрузки файла: получение токена и загрузка
+ * @param {string} filePath - Путь к файлу для загрузки
+ * @returns {Promise<Object>} - Результат загрузки файла
+ */
+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;
+        }
+        
+        // Запрашиваем STS токен
+        const fileInfo = {
+            filename: fileName,
+            filesize: fileSize,
+            filetype: fileType
+        };
+        
+        const stsData = await getStsToken(fileInfo);
+        
+        const uploadResult = await uploadFile(filePath, stsData);
+        
+        return {
+            ...uploadResult,
+            fileInfo,
+            stsData
+        };
+    } catch (error) {
+        logError(`Ошибка в процессе загрузки файла: ${error.message}`, error);
+        return {
+            success: false,
+            error: error.message
+        };
+    }
+}
+
+export default {
+    getStsToken,
+    uploadFile,
+    uploadFileToQwen
+};

src/api/modelMapping.js

@@ -0,0 +1,181 @@
+const CANONICAL_MODELS = Object.freeze([
+    "qwen3-max",
+    "qwen3-vl-plus",
+    "qwen3-coder-plus",
+    "qwen3-omni-flash",
+    "qwen-plus-2025-09-11",
+    "qwen3-235b-a22b",
+    "qwen3-30b-a3b",
+    "qwen3-coder-30b-a3b-instruct",
+    "qwen-max-latest",
+    "qwen-plus-2025-01-25",
+    "qwq-32b",
+    "qwen-turbo-2025-02-11",
+    "qwen2.5-omni-7b",
+    "qvq-72b-preview-0310",
+    "qwen2.5-vl-32b-instruct",
+    "qwen2.5-14b-instruct-1m",
+    "qwen2.5-coder-32b-instruct",
+    "qwen2.5-72b-instruct"
+]);
+
+const CANONICAL_MODEL_SET = new Set(CANONICAL_MODELS);
+
+const ALIAS_GROUPS = Object.freeze({
+    "qwen3-max": [
+        "qwen-max",
+        "Qwen3-Max",
+        "Qwen3-Maximum",
+        "qwen3-max-preview",
+        "Qwen3-Max-Preview"
+    ],
+    "qwen3-vl-plus": [
+        "qwen-vl",
+        "qwen-vl-plus",
+        "qwen-vl-plus-latest",
+        "qwen-vl-max",
+        "qwen-vl-max-latest",
+        "Qwen3-VL-235B-A22B",
+        "qwen3-vl-235b-a22b"
+    ],
+    "qwen3-coder-plus": [
+        "qwen3-coder",
+        "qwen-coder-plus",
+        "qwen-coder-plus-latest",
+        "Qwen3-Coder-Plus",
+        "qwen2.5-coder-3b-instruct",
+        "qwen2.5-coder-1.5b-instruct",
+        "qwen2.5-coder-0.5b-instruct",
+        "Qwen3-Coder"
+    ],
+    "qwen3-omni-flash": [
+        "qwen3-omni",
+        "qwen3-omni-latest",
+        "Qwen3-omni-flash",
+        "Qwen3-Omni-Flash",
+        "Qwen3-Omni"
+    ],
+    "qwen-plus-2025-09-11": [
+        "qwen-plus",
+        "qwen-plus-latest",
+        "Qwen3-Next",
+        "Qwen3-Next-80B-A3B",
+        "Qwen3-Next-80B-A3Bб",
+        "qwen3-next",
+        "qwen3-next-80b-a3b"
+    ],
+    "qwen3-235b-a22b": [
+        "qwen3",
+        "qwen-3",
+        "qwen3-235b",
+        "Qwen3-235B-A22B",
+        "Qwen3-235B-A22B-2507",
+        "qwen3-235b-a22b-2507"
+    ],
+    "qwen3-30b-a3b": [
+        "qwen3-plus",
+        "qwen3-30b",
+        "Qwen3-30B-A3B",
+        "Qwen3-30B-A3B-2507",
+        "qwen3-30b-a3b-2507"
+    ],
+    "qwen3-coder-30b-a3b-instruct": [
+        "qwen3-coder-flash",
+        "Qwen3-Coder-Flash",
+        "qwen3-coder-30b",
+        "Qwen3-Coder-30B-A3B-Instruct"
+    ],
+    "qwen-max-latest": [
+        "Qwen2.5-Max",
+        "qwen2.5-max"
+    ],
+    "qwen-plus-2025-01-25": [
+        "Qwen2.5-Plus",
+        "qwen2.5-plus"
+    ],
+    "qwq-32b": [
+        "qwq",
+        "QwQ-32B",
+        "qwq-32b-preview"
+    ],
+    "qwen-turbo-2025-02-11": [
+        "qwen-turbo",
+        "qwen-turbo-latest",
+        "Qwen2.5-Turbo"
+    ],
+    "qwen2.5-omni-7b": [
+        "qwen2.5-omni",
+        "Qwen2.5-Omni-7B",
+        "qwen-omni-7b"
+    ],
+    "qvq-72b-preview-0310": [
+        "qvq",
+        "QVQ-Max",
+        "qvq-72b"
+    ],
+    "qwen2.5-vl-32b-instruct": [
+        "qwen2.5-vl",
+        "Qwen2.5-VL-32B-Instruct"
+    ],
+    "qwen2.5-14b-instruct-1m": [
+        "qwen2.5-14b",
+        "qwen2.5-coder-14b-instruct",
+        "Qwen2.5-14B-Instruct-1M"
+    ],
+    "qwen2.5-coder-32b-instruct": [
+        "qwen2.5-coder",
+        "qwen2.5-coder-plus",
+        "Qwen2.5-Coder-32B-Instruct"
+    ],
+    "qwen2.5-72b-instruct": [
+        "qwen2.5-72b",
+        "Qwen2.5-72B-Instruct"
+    ]
+});
+
+const buildModelMapping = () => {
+    const mapping = Object.create(null);
+
+    for (const model of CANONICAL_MODELS) {
+        mapping[model] = model;
+    }
+
+    for (const [target, aliases] of Object.entries(ALIAS_GROUPS)) {
+        if (!CANONICAL_MODEL_SET.has(target)) {
+            continue;
+        }
+
+        for (const alias of aliases) {
+            if (!alias) continue;
+            mapping[alias] = target;
+        }
+    }
+
+    return Object.freeze(mapping);
+};
+
+export const MODEL_MAPPING = buildModelMapping();
+
+/**
+ * Получить соответствующую доступную модель
+ * @param {string} requestedModel - Запрошенная модель
+ * @param {string} defaultModel - Модель по умолчанию
+ * @returns {string} - Доступная модель
+ */
+export function getMappedModel(requestedModel, defaultModel = "qwen-max-latest") {
+    if (!requestedModel) return defaultModel;
+
+    // Проверяем точное соответствие в словаре
+    if (MODEL_MAPPING[requestedModel]) {
+        return MODEL_MAPPING[requestedModel];
+    }
+
+    // Проверяем, является ли запрошенная модель уже доступной
+    const availableModels = Object.values(MODEL_MAPPING);
+    if (availableModels.includes(requestedModel)) {
+        return requestedModel;
+    }
+
+    // Возвращаем модель по умолчанию, если соответствие не найдено
+    return defaultModel;
+} 

src/api/routes.js

@@ -0,0 +1,470 @@
+// routes.js - Модуль с маршрутами для API
+import express from 'express';
+import { sendMessage, getAllModels, getApiKeys, createChatV2 } from './chat.js';
+import { getAuthenticationStatus } from '../browser/browser.js';
+import { checkAuthentication } from '../browser/auth.js';
+import { getBrowserContext } from '../browser/browser.js';
+import { logInfo, logError, logDebug } from '../logger/index.js';
+import { getMappedModel } from './modelMapping.js';
+import { getStsToken, uploadFileToQwen } from './fileUpload.js';
+import multer from 'multer';
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { listTokens, markInvalid, markRateLimited, markValid } from './tokenManager.js';
+import { testToken } from './chat.js';
+
+const router = express.Router();
+
+// Настройка multer для загрузки файлов
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        const uploadDir = path.join(process.cwd(), 'uploads');
+        if (!fs.existsSync(uploadDir)) {
+            fs.mkdirSync(uploadDir, { recursive: true });
+        }
+        cb(null, uploadDir);
+    },
+    filename: function (req, file, cb) {
+        const uniqueSuffix = Date.now() + '-' + crypto.randomBytes(8).toString('hex');
+        cb(null, uniqueSuffix + '-' + file.originalname);
+    }
+});
+
+const upload = multer({
+    storage: storage,
+    limits: { fileSize: 10 * 1024 * 1024 } // 10MB макс. размер
+});
+
+function authMiddleware(req, res, next) {
+    const apiKeys = getApiKeys();
+
+    if (apiKeys.length === 0) {
+        return next();
+    }
+
+    const authHeader = req.headers.authorization;
+    const apiKeyHeaderPrefix = 'Bearer ';
+
+    if (!authHeader || !authHeader.startsWith(apiKeyHeaderPrefix)) {
+        logError('Отсутствует или некорректный заголовок авторизации');
+        return res.status(401).json({ error: 'Требуется авторизация' });
+    }
+
+    const token = authHeader.substring(apiKeyHeaderPrefix.length).trim();
+
+    if (!apiKeys.includes(token)) {
+        logError('Предоставлен недействительный API ключ');
+        return res.status(401).json({ error: 'Недействительный токен' });
+    }
+
+    next();
+}
+
+router.use(authMiddleware);
+router.use((req, res, next) => {
+    req.url = req.url
+        .replace(/\/v[12](?=\/|$)/g, '')
+        .replace(/\/+/g, '/');
+    next();
+});
+
+router.post('/chat', async (req, res) => {
+    try {
+        const { message, messages, model, chatId, parentId } = req.body;
+
+        // Поддержка как message, так и messages для совместимости
+        let messageContent = message;
+        let systemMessage = null;
+
+        // Если указан параметр messages (множественное число), используем его в приоритете
+        if (messages && Array.isArray(messages)) {
+            // Извлекаем system message если есть
+            const systemMsg = messages.find(msg => msg.role === 'system');
+            if (systemMsg) {
+                systemMessage = systemMsg.content;
+            }
+
+            // Преобразуем формат messages в формат сообщения, понятный нашему прокси
+            if (messages.length > 0) {
+                const lastUserMessage = messages.filter(msg => msg.role === 'user').pop();
+                if (lastUserMessage) {
+                    if (Array.isArray(lastUserMessage.content)) {
+                        messageContent = lastUserMessage.content;
+                    } else {
+                        messageContent = lastUserMessage.content;
+                    }
+                }
+            }
+        }
+
+        if (!messageContent) {
+            logError('Запрос без сообщения');
+            return res.status(400).json({ error: 'Сообщение не указано' });
+        }
+
+        logInfo(`Получен запрос: ${typeof messageContent === 'string' ? messageContent.substring(0, 50) + (messageContent.length > 50 ? '...' : '') : 'Составное сообщение'}`);
+        if (systemMessage) {
+            logInfo(`System message: ${systemMessage.substring(0, 50)}${systemMessage.length > 50 ? '...' : ''}`);
+        }
+        if (chatId) {
+            logInfo(`Используется chatId: ${chatId}, parentId: ${parentId || 'null'}`);
+        }
+
+        let mappedModel = model || "qwen-max-latest";
+        if (model) {
+            mappedModel = getMappedModel(model);
+            if (mappedModel !== model) {
+                logInfo(`Модель "${model}" заменена на "${mappedModel}"`);
+            }
+        }
+        logInfo(`Используется модель: ${mappedModel}`);
+
+        const result = await sendMessage(messageContent, mappedModel, chatId, parentId, null, null, null, systemMessage);
+
+        if (result.choices && result.choices[0] && result.choices[0].message) {
+            const responseLength = result.choices[0].message.content ? result.choices[0].message.content.length : 0;
+            logInfo(`Ответ успешно сформирован для запроса, длина ответа: ${responseLength}`);
+        } else if (result.error) {
+            logInfo(`Получена ошибка в ответе: ${result.error}`);
+        }
+
+        res.json(result);
+    } catch (error) {
+        logError('Ошибка при обработке запроса', error);
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+});
+
+router.get('/models', async (req, res) => {
+    try {
+        logInfo('Запрос на получение списка моделей');
+        const modelsRaw = getAllModels();
+
+
+        const openAiModels = {
+            object: 'list',
+            data: modelsRaw.models.map(m => ({
+                id: m.id || m.name || m,
+                object: 'model',
+                created: 0,
+                owned_by: 'openai',
+                permission: []
+            }))
+        };
+
+        logInfo(`Возвращено ${openAiModels.data.length} моделей (OpenAI формат)`);
+        res.json(openAiModels);
+    } catch (error) {
+        logError('Ошибка при получении списка моделей', error);
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+});
+
+
+router.get('/status', async (req, res) => {
+    try {
+        logInfo('Запрос статуса авторизации');
+
+
+        const tokens = listTokens();
+        const accounts = await Promise.all(tokens.map(async t => {
+            const accInfo = { id: t.id, status: 'UNKNOWN', resetAt: t.resetAt || null };
+
+            if (t.resetAt) {
+                const resetTime = new Date(t.resetAt).getTime();
+                if (resetTime > Date.now()) {
+                    accInfo.status = 'WAIT';
+                    return accInfo;
+                }
+            }
+
+            const testResult = await testToken(t.token);
+            if (testResult === 'OK') {
+                accInfo.status = 'OK';
+                if (t.invalid || t.resetAt) markValid(t.id);
+            } else if (testResult === 'RATELIMIT') {
+                accInfo.status = 'WAIT';
+                markRateLimited(t.id, 24);
+            } else if (testResult === 'UNAUTHORIZED') {
+                accInfo.status = 'INVALID';
+                if (!t.invalid) markInvalid(t.id);
+            } else {
+                accInfo.status = 'ERROR';
+            }
+            return accInfo;
+        }));
+
+        const browserContext = getBrowserContext();
+        if (!browserContext) {
+            logError('Браузер не инициализирован');
+            return res.json({ authenticated: false, message: 'Браузер не инициализирован', accounts });
+        }
+
+        if (getAuthenticationStatus()) {
+            return res.json({
+                accounts
+            });
+        }
+
+        await checkAuthentication(browserContext);
+        const isAuthenticated = getAuthenticationStatus();
+        logInfo(`Статус авторизации: ${isAuthenticated ? 'активна' : 'требуется авторизация'}`);
+
+        res.json({
+            authenticated: isAuthenticated,
+            message: isAuthenticated ? 'Авторизация активна' : 'Требуется авторизация',
+            accounts
+        });
+    } catch (error) {
+        logError('Ошибка при проверке статуса авторизации', error);
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+});
+
+router.post('/chats', async (req, res) => {
+    try {
+        const { name, model } = req.body;
+        const chatModel = model ? getMappedModel(model) : 'qwen-max-latest';
+        logInfo(`Создание нового чата${name ? ` с именем: ${name}` : ''}, модель: ${chatModel}`);
+        
+        const result = await createChatV2(chatModel, name || "Новый чат");
+        
+        if (result.error) {
+            logError(`Ошибка создания чата: ${result.error}`);
+            return res.status(500).json({ error: result.error });
+        }
+        
+        logInfo(`Создан новый чат v2 с ID: ${result.chatId}`);
+        res.json({ chatId: result.chatId, success: true });
+    } catch (error) {
+        logError('Ошибка при создании чата', error);
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+});
+
+router.post('/analyze/network', (req, res) => {
+    try {
+        return res.json({ success: true });
+    } catch (error) {
+        logError('Ошибка при анализе с��ти', error);
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+})
+
+router.post('/chat/completions', async (req, res) => {
+    try {
+        const { messages, model, stream, tools, functions, tool_choice, chatId, parentId } = req.body;
+
+        logInfo(`Получен OpenAI-совместимый запрос${stream ? ' (stream)' : ''}`);
+
+        if (!messages || !Array.isArray(messages) || messages.length === 0) {
+            logError('Запрос без сообщений');
+            return res.status(400).json({ error: 'Сообщения не указаны' });
+        }
+
+        // Извлекаем system message если есть
+        const systemMsg = messages.find(msg => msg.role === 'system');
+        const systemMessage = systemMsg ? systemMsg.content : null;
+
+        const lastUserMessage = messages.filter(msg => msg.role === 'user').pop();
+        if (!lastUserMessage) {
+            logError('В запросе нет сообщений от пользователя');
+            return res.status(400).json({ error: 'В запросе нет сообщений от пользователя' });
+        }
+
+        const messageContent = lastUserMessage.content;
+
+        let mappedModel = model ? getMappedModel(model) : "qwen-max-latest";
+        if (model && mappedModel !== model) {
+            logInfo(`Модель "${model}" заменена на "${mappedModel}"`);
+        }
+        logInfo(`Используется модель: ${mappedModel}`);
+
+        if (systemMessage) {
+            logInfo(`System message: ${systemMessage.substring(0, 50)}${systemMessage.length > 50 ? '...' : ''}`);
+        }
+
+        if (stream) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+
+            const writeSse = (payload) => {
+                res.write('data: ' + JSON.stringify(payload) + '\n\n');
+            };
+
+            writeSse({
+                id: 'chatcmpl-stream',
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: mappedModel || 'qwen-max-latest',
+                choices: [
+                    { index: 0, delta: { role: 'assistant' }, finish_reason: null }
+                ]
+            });
+
+            try {
+                const combinedTools = tools || (functions ? functions.map(fn => ({ type: 'function', function: fn })) : null);
+                const result = await sendMessage(messageContent, mappedModel, chatId, parentId, null, combinedTools, tool_choice, systemMessage);
+
+                if (result.error) {
+                    writeSse({
+                        id: 'chatcmpl-stream',
+                        object: 'chat.completion.chunk',
+                        created: Math.floor(Date.now() / 1000),
+                        model: mappedModel || 'qwen-max-latest',
+                        choices: [
+                            { index: 0, delta: { content: `Error: ${result.error}` }, finish_reason: null }
+                        ]
+                    });
+                } else if (result.choices && result.choices[0] && result.choices[0].message) {
+                    const content = String(result.choices[0].message.content || '');
+
+                    const codePoints = Array.from(content);
+                    const chunkSize = 16;
+                    for (let i = 0; i < codePoints.length; i += chunkSize) {
+                        const chunk = codePoints.slice(i, i + chunkSize).join('');
+                        writeSse({
+                            id: 'chatcmpl-stream',
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: mappedModel || 'qwen-max-latest',
+                            choices: [
+                                { index: 0, delta: { content: chunk }, finish_reason: null }
+                            ]
+                        });
+
+                        await new Promise(resolve => setTimeout(resolve, 20));
+                    }
+                }
+
+                writeSse({
+                    id: 'chatcmpl-stream',
+                    object: 'chat.completion.chunk',
+                    created: Math.floor(Date.now() / 1000),
+                    model: mappedModel || 'qwen-max-latest',
+                    choices: [
+                        { index: 0, delta: {}, finish_reason: 'stop' }
+                    ]
+                });
+                res.write('data: [DONE]\n\n');
+                res.end();
+
+            } catch (error) {
+                logError('Ошибка при обработке потокового запроса', error);
+                writeSse({
+                    id: 'chatcmpl-stream',
+                    object: 'chat.completion.chunk',
+                    created: Math.floor(Date.now() / 1000),
+                    model: mappedModel || 'qwen-max-latest',
+                    choices: [
+                        { index: 0, delta: { content: 'Internal server error' }, finish_reason: 'stop' }
+                    ]
+                });
+                res.write('data: [DONE]\n\n');
+                res.end();
+            }
+        } else {
+            const combinedTools = tools || (functions ? functions.map(fn => ({ type: 'function', function: fn })) : null);
+            const result = await sendMessage(messageContent, mappedModel, chatId, parentId, null, combinedTools, tool_choice, systemMessage);
+
+            if (result.error) {
+                return res.status(500).json({
+                    error: { message: result.error, type: "server_error" }
+                });
+            }
+
+            const openaiResponse = {
+                id: result.id || "chatcmpl-" + Date.now(),
+                object: "chat.completion",
+                created: Math.floor(Date.now() / 1000),
+                model: result.model || mappedModel || "qwen-max-latest",
+                choices: result.choices || [{
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content: result.choices?.[0]?.message?.content || ""
+                    },
+                    finish_reason: "stop"
+                }],
+                usage: result.usage || {
+                    prompt_tokens: 0,
+                    completion_tokens: 0,
+                    total_tokens: 0
+                },
+                chatId: result.chatId,
+                parentId: result.parentId
+            };
+
+            res.json(openaiResponse);
+        }
+    } catch (error) {
+        logError('Ошибка при обработке запроса', error);
+        res.status(500).json({ error: { message: 'Внутренняя ошибка сервера', type: "server_error" } });
+    }
+});
+
+// Новый маршрут для получения STS токена
+router.post('/files/getstsToken', async (req, res) => {
+    try {
+        logInfo(`Запрос на получение STS токена: ${JSON.stringify(req.body)}`);
+
+        const fileInfo = req.body;
+        if (!fileInfo || !fileInfo.filename || !fileInfo.filesize || !fileInfo.filetype) {
+            logError('Некорректные данные о файле');
+            return res.status(400).json({ error: 'Некорректные данные о файле' });
+        }
+
+        const stsToken = await getStsToken(fileInfo);
+        res.json(stsToken);
+    } catch (error) {
+        logError('Ошибка при получении STS токена', error);
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+});
+
+// Маршрут для загрузки файла - работает
+router.post('/files/upload', upload.single('file'), async (req, res) => {
+    try {
+        if (!req.file) {
+            logError('Файл не был загружен');
+            return res.status(400).json({ error: 'Файл не был загружен' });
+        }
+
+        logInfo(`Файл загружен на сервер: ${req.file.originalname} (${req.file.size} байт)`);
+
+        // Загружаем файл в Qwen OSS хранилище
+        const result = await uploadFileToQwen(req.file.path);
+
+        // Удаляем временный файл после успешной загрузки
+        fs.unlinkSync(req.file.path);
+
+        if (result.success) {
+            logInfo(`Файл успешно загружен в OSS: ${result.fileName}`);
+            res.json({
+                success: true,
+                file: {
+                    name: result.fileName,
+                    url: result.url,
+                    size: req.file.size,
+                    type: req.file.mimetype
+                }
+            });
+        } else {
+            logError(`Ошибка при загрузке файла в OSS: ${result.error}`);
+            res.status(500).json({ error: 'Ошибка при загрузке файла' });
+        }
+    } catch (error) {
+        logError('Ошибка при загрузке файла', error);
+
+        // Удаляем временный файл в случае ошибки
+        if (req.file && req.file.path && fs.existsSync(req.file.path)) {
+            fs.unlinkSync(req.file.path);
+        }
+
+        res.status(500).json({ error: 'Внутренняя ошибка сервера' });
+    }
+});
+
+export default router;

src/api/tokenManager.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let pointer = 0;
+
+// Директория для хранения сессий и данных аккаунтов
+const SESSION_DIR = path.join(__dirname, '..', '..', 'session');
+const ACCOUNTS_DIR = path.join(SESSION_DIR, 'accounts');
+const TOKENS_FILE = path.join(SESSION_DIR, 'tokens.json');
+
+function ensureSessionDir() {
+    if (!fs.existsSync(SESSION_DIR)) {
+        fs.mkdirSync(SESSION_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(ACCOUNTS_DIR)) {
+        fs.mkdirSync(ACCOUNTS_DIR, { recursive: true });
+    }
+}
+
+export function loadTokens() {
+    ensureSessionDir();
+    if (!fs.existsSync(TOKENS_FILE)) {
+        return [];
+    }
+    try {
+        const data = fs.readFileSync(TOKENS_FILE, 'utf8');
+        return JSON.parse(data);
+    } catch (e) {
+        console.error('TokenManager: ошибка чтения tokens.json:', e);
+        return [];
+    }
+}
+
+export function saveTokens(tokens) {
+    ensureSessionDir();
+    try {
+        fs.writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2), 'utf8');
+    } catch (e) {
+        console.error('TokenManager: ошибка сохранения tokens.json:', e);
+    }
+}
+
+export async function getAvailableToken() {
+    const tokens = loadTokens();
+    const now = Date.now();
+    const valid = tokens.filter(t => (!t.resetAt || new Date(t.resetAt).getTime() <= now) && !t.invalid);
+    if (!valid.length) return null;
+    const token = valid[pointer % valid.length];
+    pointer = (pointer + 1) % valid.length;
+    return token;
+}
+
+export function hasValidTokens() {
+    const tokens = loadTokens();
+    const now = Date.now();
+    return tokens.some(t => (!t.resetAt || new Date(t.resetAt).getTime() <= now) && !t.invalid);
+}
+
+export function markRateLimited(id, hours = 24) {
+    const tokens = loadTokens();
+    const idx = tokens.findIndex(t => t.id === id);
+    if (idx !== -1) {
+        const until = new Date(Date.now() + hours * 3600 * 1000).toISOString();
+        tokens[idx].resetAt = until;
+        saveTokens(tokens);
+    }
+}
+
+export function removeToken(id) {
+    const tokens = loadTokens();
+    const filtered = tokens.filter(t => t.id !== id);
+    saveTokens(filtered);
+}
+
+export { removeToken as removeInvalidToken };
+
+export function markInvalid(id) {
+    const tokens = loadTokens();
+    const idx = tokens.findIndex(t => t.id === id);
+    if (idx !== -1) {
+        tokens[idx].invalid = true;
+        saveTokens(tokens);
+    }
+}
+
+export function markValid(id, newToken) {
+    const tokens = loadTokens();
+    const idx = tokens.findIndex(t => t.id === id);
+    if (idx !== -1) {
+        tokens[idx].invalid = false;
+        tokens[idx].resetAt = null;
+        if (newToken) tokens[idx].token = newToken;
+        saveTokens(tokens);
+    }
+}
+
+export function listTokens() {
+    return loadTokens();
+} 

src/browser/auth.js

@@ -0,0 +1,234 @@
+// auth.js - Модуль для авторизации и проверки авторизации
+import { saveSession } from './session.js';
+import { setAuthenticationStatus, getAuthenticationStatus, restartBrowserInHeadlessMode } from './browser.js';
+import { extractAuthToken } from '../api/chat.js';
+
+const AUTH_URL = 'https://chat.qwen.ai/';
+const AUTH_SIGNIN_URL = 'https://chat.qwen.ai/auth?action=signin';
+
+const VERIFICATION_TIMEOUT = 300000;
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+async function getPage(context) {
+    if (context && typeof context.goto === 'function') {
+        return context;
+    } else if (context && typeof context.newPage === 'function') {
+        return await context.newPage();
+    } else {
+        throw new Error('Неверный контекст: не страница Puppeteer, не контекст Playwright');
+    }
+}
+
+function isPlaywright(context) {
+    return context && typeof context.newPage === 'function';
+}
+
+async function promptUser(question) {
+    return new Promise(resolve => {
+        process.stdout.write(question);
+
+        const onData = (data) => {
+            const input = data.toString().trim();
+            process.stdin.removeListener('data', onData);
+            process.stdin.pause();
+            resolve(input);
+        };
+
+        process.stdin.resume();
+        process.stdin.once('data', onData);
+    });
+}
+
+export async function checkAuthentication(context) {
+    try {
+        if (getAuthenticationStatus()) {
+            return true;
+        }
+
+        const page = await getPage(context);
+        const isPW = isPlaywright(context);
+
+        console.log('Проверка авторизации...');
+        
+        try {
+            await page.goto(AUTH_URL, { waitUntil: 'domcontentloaded', timeout: 120000 });
+            
+            if (isPW) {
+                await page.waitForLoadState('domcontentloaded');
+            }
+            
+            await delay(2000);
+
+            const pageTitle = await page.title();
+            const hasVerification = pageTitle.includes('Verification');
+
+            if (hasVerification) {
+                console.log('Обнаружена страница верификации. Пожалуйста, пройдите верификацию вручную.');
+                await promptUser('После прохождения верификации нажмите ENTER для продолжения...');
+                console.log('Верификация подтверждена пользователем.');
+            }
+
+            let loginContainerCount = 0;
+            if (isPW) {
+                loginContainerCount = await page.locator('.login-container').count();
+            } else {
+                const loginElements = await page.$$('.login-container');
+                loginContainerCount = loginElements.length;
+            }
+
+            if (loginContainerCount === 0) {
+                console.log('======================================================');
+                console.log('               АВТОРИЗАЦИЯ ОБНАРУЖЕНА                 ');
+                console.log('======================================================');
+
+                setAuthenticationStatus(true);
+                
+                try {
+                    await extractAuthToken(context, true);
+                    await saveSession(context);
+                    console.log('Сессия обновлена');
+                } catch (e) {
+                    console.error('Не удалось обновить сессию:', e);
+                }
+
+                if (isPW) {
+                    await page.close();
+                }
+
+                return true;
+            } else {
+                console.log('------------------------------------------------------');
+                console.log('               НЕОБХОДИМА АВТОРИЗАЦИЯ                 ');
+                console.log('------------------------------------------------------');
+                console.log('Пожалуйста, выполните следующие действия:');
+                console.log('1. Войдите в систему через GitHub или другой способ в открытом браузере');
+                console.log('2. Дождитесь завершения процесса авторизации');
+                console.log('3. Нажмите ENTER в этой консоли');
+                console.log('------------------------------------------------------');
+
+                await promptUser('После успешной авторизации нажмите ENTER для продолжения...');
+                console.log('Пользователь подтвердил завершение авторизации.');
+
+                await page.reload({ waitUntil: 'domcontentloaded', timeout: 120000 });
+                await delay(3000);
+
+                let loginElements = 0;
+                if (isPW) {
+                    loginElements = await page.locator('.login-container').count();
+                } else {
+                    const elements = await page.$$('.login-container');
+                    loginElements = elements.length;
+                }
+
+                if (loginElements === 0) {
+                    console.log('Авторизация подтверждена.');
+                    setAuthenticationStatus(true);
+
+                    await saveSession(context);
+                    await extractAuthToken(context, true);
+
+                    if (isPW) {
+                        await page.close();
+                    }
+                    
+                    return true;
+                } else {
+                    console.log('Предупреждение: Авторизация не обнаружена.');
+                    setAuthenticationStatus(false);
+                    return false;
+                }
+            }
+        } catch (error) {
+            if (isPW) {
+                await page.close().catch(() => {});
+            }
+            throw error;
+        }
+    } catch (error) {
+        console.error('Ошибка при проверке авторизации:', error);
+        setAuthenticationStatus(false);
+        return false;
+    }
+}
+
+export async function startManualAuthentication(context, skipRestart = false) {
+    try {
+        const page = await getPage(context);
+        const isPW = isPlaywright(context);
+
+        console.log('Открытие страницы для ручной авторизации...');
+        
+        try {
+            await page.goto(AUTH_SIGNIN_URL, { waitUntil: 'load', timeout: 120000 });
+
+            console.log('------------------------------------------------------');
+            console.log('               НЕОБХОДИМА АВТОРИЗАЦИЯ                 ');
+            console.log('------------------------------------------------------');
+            console.log('Пожалуйста, выполните следующие действия:');
+            console.log('1. Войдите в систему в открытом браузере');
+            console.log('2. Дождитесь завершения процесса авторизации');
+            console.log('3. Нажмите ENTER в этой консоли');
+            console.log('------------------------------------------------------');
+
+            await promptUser('После успешной авторизации нажмите ENTER для продолжения...');
+            
+            await page.goto(AUTH_URL, { waitUntil: 'domcontentloaded', timeout: 120000 });
+            await delay(2000);
+
+            let loginElements = 0;
+            if (isPW) {
+                loginElements = await page.locator('.login-container').count();
+            } else {
+                const elements = await page.$$('.login-container');
+                loginElements = elements.length;
+            }
+
+            if (loginElements === 0) {
+                console.log('Авторизация подтверждена.');
+                setAuthenticationStatus(true);
+
+                await saveSession(context);
+                await extractAuthToken(context, true);
+
+                console.log('Сессия сохранена успешно!');
+
+                if (isPW) {
+                    await page.close();
+                }
+                
+                if (!skipRestart) {
+                    await restartBrowserInHeadlessMode();
+                }
+                return true;
+            } else {
+                console.log('Авторизация не удалась.');
+                setAuthenticationStatus(false);
+                return false;
+            }
+        } catch (error) {
+            if (isPW) {
+                await page.close().catch(() => {});
+            }
+            throw error;
+        }
+    } catch (error) {
+        console.error('Ошибка при ручной авторизации:', error);
+        setAuthenticationStatus(false);
+        return false;
+    }
+}
+
+export async function checkVerification(page) {
+    try {
+        const pageTitle = await page.title();
+        if (pageTitle.includes('Verification')) {
+            console.log('Обнаружена страница верификации');
+            await promptUser('Пройдите верификацию и нажмите ENTER...');
+            return true;
+        }
+        return false;
+    } catch (error) {
+        return false;
+    }
+}

src/browser/browser.js

@@ -0,0 +1,365 @@
+import puppeteer from 'puppeteer-extra';
+import StealthPlugin from 'puppeteer-extra-plugin-stealth';
+import { saveSession, loadSession, saveAuthToken } from './session.js';
+import { checkAuthentication, startManualAuthentication } from './auth.js';
+import { clearPagePool, getAuthToken } from '../api/chat.js';
+import fs from 'fs';
+import path from 'path';
+
+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) {
+        console.log('Инициализация браузера с 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=1920,1080',
+                    '--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: 1920,
+                    height: 1080
+                },
+                ignoreHTTPSErrors: true
+            });
+
+            const pages = await browserInstance.pages();
+            const page = pages.length > 0 ? pages[0] : await browserInstance.newPage();
+
+            await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36');
+
+            await page.setViewport({
+                width: 1920,
+                height: 1080,
+                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) {
+                            const delay = Math.random() * 3;
+                            setTimeout(() => {
+                                listener.call(this, event);
+                            }, delay);
+                        };
+                        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);
+                };
+
+                console.log('Puppeteer Stealth активирован');
+            });
+
+            browserContext = page;
+
+            console.log('Браузер инициализирован с максимальной защитой от обнаружения');
+
+            if (visibleMode) {
+                await startManualAuthenticationPuppeteer(page, skipManualRestart);
+            } else {
+                const sessionLoaded = await loadSessionPuppeteer(page);
+                if (sessionLoaded) {
+                    setAuthenticationStatus(true);
+                    console.log('Сессия успешно загружена');
+                }
+            }
+
+            return true;
+        } catch (error) {
+            console.error('Ошибка при инициализации браузера:', error);
+            return false;
+        }
+    }
+    return true;
+}
+
+async function saveSessionPuppeteer(page) {
+    try {
+        const cookies = await page.cookies();
+        
+        const sessionDir = path.join(process.cwd(), 'session', 'accounts');
+        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)
+        );
+        
+        console.log(`Cookies сохранены для аккаунта ${accountId}`);
+        return accountId;
+        
+    } catch (error) {
+        console.error('Ошибка при сохранении сессии:', error);
+        return null;
+    }
+}
+
+async function startManualAuthenticationPuppeteer(page, skipManualRestart) {
+    try {
+        console.log('Открытие страницы для ручной авторизации...');
+        
+        await page.goto('https://chat.qwen.ai/', {
+            waitUntil: 'networkidle2',
+            timeout: 60000
+        });
+
+        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);
+                    console.log('\nПолучено подтверждение, продолжаем...');
+                    resolve();
+                }
+            };
+
+            process.stdin.on('data', onData);
+        });
+
+        const cookies = await page.cookies();
+        console.log(`Сохранено ${cookies.length} cookies`);
+
+        const token = await page.evaluate(() => {
+            return localStorage.getItem('token') || 
+                   localStorage.getItem('auth_token') ||
+                   localStorage.getItem('access_token') ||
+                   sessionStorage.getItem('token') ||
+                   sessionStorage.getItem('auth_token') ||
+                   null;
+        });
+
+        if (token) {
+            console.log('Токен найден и будет сохранен');
+            saveAuthToken(token);
+        } else {
+            console.log('Токен не найден в localStorage/sessionStorage');
+            console.log('Попытка извлечь токен из cookies...');
+            
+            const tokenCookie = cookies.find(c => 
+                c.name.toLowerCase().includes('token') || 
+                c.name.toLowerCase().includes('auth')
+            );
+            
+            if (tokenCookie) {
+                console.log(`Токен найден в cookie: ${tokenCookie.name}`);
+                saveAuthToken(tokenCookie.value);
+            }
+        }
+
+        const accountId = await saveSessionPuppeteer(page);
+        if (accountId) {
+            console.log(`Сессия сохранена с ID: ${accountId}`);
+        }
+
+        setAuthenticationStatus(true);
+        console.log('Авторизация завершена успешно');
+
+        if (!skipManualRestart) {
+            await restartBrowserInHeadlessMode();
+        }
+
+    } catch (error) {
+        console.error('Ошибка при ручной авторизации:', error);
+        throw error;
+    }
+}
+
+async function loadSessionPuppeteer(page) {
+    try {
+        return false;
+    } catch (error) {
+        console.error('Ошибка при загрузке сессии:', error);
+        return false;
+    }
+}
+
+export async function restartBrowserInHeadlessMode() {
+    console.log('Перезапуск браузера в фоновом режиме...');
+
+    const token = getAuthToken();
+    if (token) {
+        console.log('Сохранение токена...');
+        saveAuthToken(token);
+        await delay(1000);
+    }
+
+    await shutdownBrowser();
+    await delay(2000);
+
+    const success = await initBrowser(false);
+    
+    if (success) {
+        console.log('Браузер перезапущен в фоновом режиме');
+    } else {
+        console.error('Ошибка при перезапуске браузера');
+    }
+}
+
+export async function shutdownBrowser() {
+    try {
+        // Сначала очищаем пул страниц
+        try {
+            await clearPagePool();
+        } catch (e) {
+            console.error('Ошибка при очистке пула страниц:', e);
+        }
+        
+        // Закрываем контекст браузера
+        if (browserInstance) {
+            try {
+                const pages = await browserInstance.pages();
+                for (const page of pages) {
+                    await page.close().catch(() => {});
+                }
+                await browserInstance.close();
+            } catch (e) {
+                // Игнорируем ошибку, если контекст уже закрыт
+                console.error('Ошибка при закрытии браузера:', e);
+            }
+        }
+
+        // Сбрасываем переменные
+        browserContext = null;
+        browserInstance = null;
+
+        console.log('Браузер закрыт');
+    } catch (error) {
+        console.error('Ошибка при завершении работы браузера:', error);
+    }
+}
+
+export function getBrowserContext() {
+    return browserContext;
+}
+
+// Установить статус авторизации
+export function setAuthenticationStatus(status) {
+    isAuthenticated = status;
+}
+
+// Получить статус авторизации
+export function getAuthenticationStatus() {
+    return isAuthenticated;
+}

src/browser/session.js

@@ -0,0 +1,166 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const SESSION_DIR = path.join(__dirname, '..', '..', 'session');
+const TOKEN_FILE = path.join(SESSION_DIR, 'auth_token.txt');
+
+export function initSessionDirectory() {
+    if (!fs.existsSync(SESSION_DIR)) {
+        fs.mkdirSync(SESSION_DIR, { recursive: true });
+        console.log(`Создана директория для сессий: ${SESSION_DIR}`);
+    }
+}
+
+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 = accountId 
+                ? path.join(SESSION_DIR, 'accounts', accountId, 'cookies.json')
+                : path.join(SESSION_DIR, 'cookies.json');
+            
+            const sessionDir = path.dirname(sessionPath);
+            if (!fs.existsSync(sessionDir)) {
+                fs.mkdirSync(sessionDir, { recursive: true });
+            }
+            
+            fs.writeFileSync(sessionPath, JSON.stringify(cookies, null, 2));
+            
+            console.log('Сессия Puppeteer сохранена');
+            return true;
+            
+        } else if (isPlaywright && context.browser()) {
+            const sessionPath = accountId 
+                ? path.join(SESSION_DIR, 'accounts', accountId, 'state.json')
+                : path.join(SESSION_DIR, 'state.json');
+            
+            const sessionDir = path.dirname(sessionPath);
+            if (!fs.existsSync(sessionDir)) {
+                fs.mkdirSync(sessionDir, { recursive: true });
+            }
+            
+            await context.storageState({ path: sessionPath });
+            console.log('Сессия Playwright сохранена');
+            return true;
+        } else {
+            console.error('Неизвестный тип контекста браузера');
+            return false;
+        }
+    } catch (error) {
+        console.error('Ошибка при сохранении сессии:', 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 = accountId 
+                ? path.join(SESSION_DIR, 'accounts', accountId, 'cookies.json')
+                : path.join(SESSION_DIR, 'cookies.json');
+            
+            if (fs.existsSync(sessionPath)) {
+                const cookies = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+                await context.setCookie(...cookies);
+                console.log('Сессия Puppeteer загружена');
+                return true;
+            }
+        } else if (isPlaywright) {
+            const sessionPath = accountId 
+                ? path.join(SESSION_DIR, 'accounts', accountId, 'state.json')
+                : path.join(SESSION_DIR, 'state.json');
+            
+            if (fs.existsSync(sessionPath)) {
+                await context.storageState({ path: sessionPath });
+                console.log('Сессия Playwright загружена');
+                return true;
+            }
+        }
+    } catch (error) {
+        console.error('Ошибка при загрузке сессии:', error);
+    }
+    return false;
+}
+
+export function clearSession(accountId = null) {
+    try {
+        const sessionPaths = [
+            accountId 
+                ? path.join(SESSION_DIR, 'accounts', accountId, 'state.json')
+                : path.join(SESSION_DIR, 'state.json'),
+            accountId 
+                ? path.join(SESSION_DIR, 'accounts', accountId, 'cookies.json')
+                : path.join(SESSION_DIR, 'cookies.json')
+        ];
+
+        let cleared = false;
+        for (const sessionPath of sessionPaths) {
+            if (fs.existsSync(sessionPath)) {
+                fs.unlinkSync(sessionPath);
+                cleared = true;
+            }
+        }
+
+        if (cleared) {
+            console.log('Сессия очищена');
+            return true;
+        }
+    } catch (error) {
+        console.error('Ошибка при очистке сессии:', error);
+    }
+    return false;
+}
+
+export function hasSession(accountId = null) {
+    const sessionPaths = [
+        accountId 
+            ? path.join(SESSION_DIR, 'accounts', accountId, 'state.json')
+            : path.join(SESSION_DIR, 'state.json'),
+        accountId 
+            ? path.join(SESSION_DIR, 'accounts', accountId, 'cookies.json')
+            : path.join(SESSION_DIR, 'cookies.json')
+    ];
+
+    return sessionPaths.some(path => fs.existsSync(path));
+}
+
+export function saveAuthToken(token) {
+    try {
+        initSessionDirectory();
+
+        if (token) {
+            fs.writeFileSync(TOKEN_FILE, token, 'utf8');
+            console.log('Токен авторизации сохранен');
+            return true;
+        }
+    } catch (error) {
+        console.error('Ошибка при сохранении токена авторизации:', error);
+    }
+    return false;
+}
+
+export function loadAuthToken() {
+    try {
+        if (fs.existsSync(TOKEN_FILE)) {
+            const token = fs.readFileSync(TOKEN_FILE, 'utf8');
+            console.log('Токен авторизации загружен');
+            return token;
+        }
+    } catch (error) {
+        console.error('Ошибка при загрузке токена авторизации:', error);
+    }
+    return null;
+}

src/logger/index.js

@@ -0,0 +1,142 @@
+import winston from 'winston';
+import morgan from 'morgan';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Создаем директорию для логов, если она не существует
+const LOG_DIR = path.join(__dirname, '..', '..', 'logs');
+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 }) => {
+        return `${timestamp} [${level}]: ${message}`;
+    })
+);
+
+// Формат для файла (без цветов)
+const fileFormat = combine(
+    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    printf(({ level, message, timestamp }) => {
+        return `${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 level = 'raw';
+
+// Создаем инстанс логгера
+const logger = winston.createLogger({
+    levels: customLevels.levels,
+    level,
+    format: fileFormat,
+    transports: [
+        // Лог всех сообщений уровня info и выше в combined.log
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'combined.log'),
+            maxsize: 5242880, // 5MB
+            maxFiles: 5
+        }),
+        // Отдельный файл для HTTP-запросов
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'http.log'),
+            level: 'http',
+            maxsize: 5242880, // 5MB
+            maxFiles: 5
+        }),
+        // Лог всех ошибок в error.log
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'error.log'),
+            level: 'error',
+            maxsize: 5242880, // 5MB
+            maxFiles: 5
+        }),
+        // Файл для сырых ответов нейросети
+        new winston.transports.File({
+            filename: path.join(LOG_DIR, 'raw-responses.log'),
+            level: 'raw',
+            maxsize: 5242880, // 5MB
+            maxFiles: 5
+        }),
+        // Вывод в консоль
+        new winston.transports.Console({
+            format: consoleFormat
+        })
+    ]
+});
+
+// Добавляем цвета для уровней логирования
+winston.addColors(customLevels.colors);
+
+// Создаем stream для morgan, который будет писать в winston
+const morganStream = {
+    write: (message) => {
+        // Убираем символ новой строки и отправляем в http-логи
+        logger.http(message.trim());
+    }
+};
+
+// Настраиваем формат morgan с дополнительной информацией
+const morganFormat = ':remote-addr :method :url :status :res[content-length] - :response-time ms';
+
+// Создаем middleware для express с использованием morgan
+const httpLogger = morgan(morganFormat, { stream: morganStream });
+
+// Отдельная функция для логирования HTTP-запросов (используется morgan)
+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
+}; 

src/utils/accountSetup.js

@@ -0,0 +1,164 @@
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { initBrowser, shutdownBrowser, getBrowserContext } from '../browser/browser.js';
+import { extractAuthToken } from '../api/chat.js';
+import { loadTokens, saveTokens, markValid, removeToken } from '../api/tokenManager.js';
+import { loadAuthToken } from '../browser/session.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+function ensureAccountDir(id) {
+    const accountDir = path.join(__dirname, '..', '..', 'session', 'accounts', id);
+    if (!fs.existsSync(accountDir)) {
+        fs.mkdirSync(accountDir, { recursive: true });
+    }
+    return accountDir;
+}
+
+export async function addAccountInteractive() {
+    console.log('======================================================');
+    console.log('Добавление нового аккаунта Qwen');
+    console.log('Браузер откроется, войдите в систему, затем вернитесь к консоли.');
+    console.log('======================================================');
+
+    const ok = await initBrowser(true, true);
+    if (!ok) {
+        console.error('Не удалось запустить браузер.');
+        return null;
+    }
+
+
+
+    const ctx = getBrowserContext();
+    let token = await extractAuthToken(ctx, true);
+
+    if (!token) {
+        token = loadAuthToken();
+        if (token) {
+            console.log('Токен получен из сохранённого файла.');
+        }
+    }
+
+    if (!token) {
+        console.error('Токен не был получен. Аккаунт не добавлен.');
+        await shutdownBrowser();
+        return null;
+    }
+
+    await shutdownBrowser();
+    // ---
+
+    const id = 'acc_' + Date.now();
+
+
+    ensureAccountDir(id);
+    fs.writeFileSync(path.join(__dirname, '..', '..', 'session', 'accounts', id, 'token.txt'), token, 'utf8');
+
+    const list = loadTokens();
+    list.push({ id, token, resetAt: null });
+    saveTokens(list);
+
+    console.log(`Аккаунт '${id}' добавлен. Всего аккаунтов: ${list.length}`);
+    console.log('======================================================');
+    return id;
+}
+
+export async function interactiveAccountMenu() {
+    while (true) {
+        console.log('\n=== Меню управления аккаунтами ===');
+        console.log('1 - Добавить новый аккаунт');
+        console.log('2 - Завершить');
+        const choice = await prompt('Ваш выбор (1/2): ');
+        if (choice === '1') {
+            await addAccountInteractive();
+        } else if (choice === '2') {
+            break;
+        } else {
+            console.log('Неверный выбор.');
+        }
+    }
+}
+
+export async function reloginAccountInteractive() {
+    const tokens = loadTokens();
+    const invalids = tokens.filter(t => t.invalid);
+    if (!invalids.length) {
+        console.log('Нет аккаунтов, требующих повторного входа.');
+        await prompt('Нажмите ENTER чтобы вернуться в меню...');
+        return;
+    }
+
+    console.log('\nАккаунты с истекшим токеном:');
+    invalids.forEach((t, idx) => console.log(`${idx + 1} - ${t.id}`));
+    const choice = await prompt('Выберите номер аккаунта для повторного входа: ');
+    const num = parseInt(choice, 10);
+    if (isNaN(num) || num < 1 || num > invalids.length) {
+        console.log('Неверный выбор.');
+        return;
+    }
+    const account = invalids[num - 1];
+
+    console.log(`\nПовторная авторизация для ${account.id}`);
+    const ok = await initBrowser(true, true);
+    if (!ok) {
+        console.error('Не удалось запустить браузер.');
+        return;
+    }
+
+    const token = await extractAuthToken(getBrowserContext(), true);
+    await shutdownBrowser();
+
+    if (!token) {
+        console.error('Не удалось извлечь токен.');
+        return;
+    }
+
+    // сохраняем новый токен и снимаем invalid
+    markValid(account.id, token);
+    fs.writeFileSync(path.join(__dirname, '..', '..', 'session', 'accounts', account.id, 'token.txt'), token, 'utf8');
+
+    console.log(`Токен обновлён для ${account.id}`);
+}
+
+export async function removeAccountInteractive() {
+    const tokens = loadTokens();
+    if (!tokens.length) {
+        console.log('Нет сохранённых аккаунтов.');
+        await prompt('ENTER чтобы вернуться...');
+        return;
+    }
+
+    console.log('\nДоступные аккаунты:');
+    tokens.forEach((t, idx) => console.log(`${idx + 1} - ${t.id}`));
+    const choice = await prompt('Номер аккаунта, который нужно удалить (или ENTER для отмены): ');
+    if (!choice) return;
+    const num = parseInt(choice, 10);
+    if (isNaN(num) || num < 1 || num > tokens.length) {
+        console.log('Неверный выбор.');
+        await prompt('ENTER чтобы вернуться...');
+        return;
+    }
+    const acc = tokens[num - 1];
+    const confirm = await prompt(`Точно удалить ${acc.id}? (y/N): `);
+    if (confirm.toLowerCase() !== 'y') return;
+
+    removeToken(acc.id);
+
+    // удалить директорию аккаунта
+    const dir = path.join(__dirname, '..', '..', 'session', 'accounts', acc.id);
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+
+    console.log(`Аккаунт ${acc.id} удалён.`);
+    await prompt('ENTER чтобы вернуться...');
+} 

start.bat

@@ -0,0 +1,39 @@
+@echo off
+chcp 65001 >nul
+title Запуск Qwen API сервера
+
+echo Проверка наличия Node.js...
+where node >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo [ОШИБКА] Node.js не установлен!
+    echo Пожалуйста, установите Node.js с сайта https://nodejs.org/
+    pause
+    exit /b 1
+)
+
+echo Проверка наличия npm...
+where npm >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo [ОШИБКА] npm не установлен!
+    echo Пожалуйста, переустановите Node.js с сайта https://nodejs.org/
+    pause
+    exit /b 1
+)
+
+echo Установка зависимостей...
+call npm install
+
+if %ERRORLEVEL% neq 0 (
+    echo [ОШИБКА] Не удалось установить зависимости!
+    pause
+    exit /b 1
+)
+
+echo.
+echo Запуск приложения...
+echo.
+
+:: Запуск Node.js приложения
+node index.js
+
+pause