qwen-api-proxy 1.0.10

package/src/utils/accountSetup.js

@@ -0,0 +1,153 @@
+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';
+import { logInfo, logError, logWarn } from '../logger/index.js';
+import { prompt } from './prompt.js';
+import { SESSION_DIR, ACCOUNTS_DIR } from '../config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function ensureAccountDir(id) {
+    const accountDir = path.resolve(__dirname, '..', '..', SESSION_DIR, ACCOUNTS_DIR, id);
+    if (!fs.existsSync(accountDir)) fs.mkdirSync(accountDir, { recursive: true });
+    return accountDir;
+}
+
+export async function addAccountInteractive() {
+    logInfo('======================================================');
+    logInfo('Добавление нового аккаунта Qwen');
+    logInfo('Браузер откроется, войдите в систему, затем вернитесь к консоли.');
+    logInfo('======================================================');
+
+    const ok = await initBrowser(true, true);
+    if (!ok) {
+        logError('Не удалось запустить браузер.');
+        return null;
+    }
+
+    const ctx = getBrowserContext();
+    let token = await extractAuthToken(ctx, true);
+
+    if (!token) {
+        token = loadAuthToken();
+        if (token) logInfo('Токен получен из сохранённого файла.');
+    }
+
+    if (!token) {
+        logError('Токен не был получен. Аккаунт не добавлен.');
+        await shutdownBrowser();
+        return null;
+    }
+
+    await shutdownBrowser();
+
+    const id = 'acc_' + Date.now();
+    ensureAccountDir(id);
+    fs.writeFileSync(path.resolve(__dirname, '..', '..', SESSION_DIR, ACCOUNTS_DIR, id, 'token.txt'), token, 'utf8');
+
+    const list = loadTokens();
+    list.push({ id, token, resetAt: null });
+    saveTokens(list);
+
+    logInfo(`Аккаунт '${id}' добавлен. Всего аккаунтов: ${list.length}`);
+    logInfo('======================================================');
+    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];
+
+    logInfo(`Повторная авторизация для ${account.id}`);
+    const ok = await initBrowser(true, true);
+    if (!ok) { logError('Не удалось запустить браузер.'); return; }
+
+    const token = await extractAuthToken(getBrowserContext(), true);
+    await shutdownBrowser();
+
+    if (!token) { logError('Не удалось извлечь токен.'); return; }
+
+    markValid(account.id, token);
+    fs.writeFileSync(path.resolve(__dirname, '..', '..', SESSION_DIR, ACCOUNTS_DIR, account.id, 'token.txt'), token, 'utf8');
+    logInfo(`Токен обновлён для ${account.id}`);
+}
+
+export async function removeAccountInteractive() {
+    const tokens = loadTokens();
+    if (!tokens.length) {
+        console.log('Нет сохранённых аккаунтов.');
+        await prompt('ENTER чтобы вернуться...');
+        return;
+    }
+
+    const now = Date.now();
+    const validTokens = tokens.filter(t => {
+        if (t.invalid) return false;
+        if (t.resetAt && new Date(t.resetAt).getTime() > now) return false;
+        if (t.expiryTime && t.expiryTime <= now) return false;
+        // Проверяем наличие cookies.json
+        const cookiesPath = path.resolve(__dirname, '..', '..', SESSION_DIR, ACCOUNTS_DIR, t.id, 'cookies.json');
+        if (!fs.existsSync(cookiesPath)) return false;
+        return true;
+    });
+
+    if (validTokens.length === 0) {
+        console.log('Нет действительных аккаунтов.');
+        await prompt('ENTER чтобы вернуться...');
+        return;
+    }
+
+    console.log('\nДоступные аккаунты:');
+    validTokens.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 > validTokens.length) {
+        console.log('Неверный выбор.');
+        await prompt('ENTER чтобы вернуться...');
+        return;
+    }
+
+    const acc = validTokens[num - 1];
+    const confirm = await prompt(`Точно удалить ${acc.id}? (y/N): `);
+    if (confirm.toLowerCase() !== 'y') return;
+
+    removeToken(acc.id);
+    const dir = path.resolve(__dirname, '..', '..', SESSION_DIR, ACCOUNTS_DIR, acc.id);
+    if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
+
+    logInfo(`Аккаунт ${acc.id} удалён.`);
+    await prompt('ENTER чтобы вернуться...');
+}

package/src/utils/botSettings.js

@@ -0,0 +1,231 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logInfo, logError, logWarn } from '../logger/index.js';
+import { SESSION_DIR, DEFAULT_MODEL } from '../config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Пути к файлам настроек
+const SETTINGS_FILE = path.join(process.cwd(), SESSION_DIR, 'bot_settings.json');
+
+// Кэш настроек
+let settingsCache = null;
+let settingsCacheMTime = null; // Время последнего изменения файла
+
+/**
+ * Проверяет изменился ли файл с момента последнего чтения
+ */
+function hasFileChanged() {
+    try {
+        if (!fs.existsSync(SETTINGS_FILE)) {
+            return true; // Файл не существует, нужно перечитать
+        }
+        
+        const stats = fs.statSync(SETTINGS_FILE);
+        const currentMTime = stats.mtimeMs;
+        
+        // Если кэш пуст или время изменения отличается - файл изменился
+        return !settingsCacheMTime || currentMTime !== settingsCacheMTime;
+    } catch (error) {
+        return true; // При ошибке перечитываем
+    }
+}
+
+/**
+ * Загружает настройки бота из файла (с кэшированием)
+ */
+export function loadBotSettings() {
+    try {
+        // Проверяем есть ли файл
+        if (!fs.existsSync(SETTINGS_FILE)) {
+            if (!settingsCache) {
+                logInfo('📝 Файл настроек бота не найден, используем значения по умолчанию');
+            }
+            const defaultSettings = {
+                activeModel: null,
+                llmChatEnabled: false,
+                lastUpdated: null
+            };
+            settingsCache = defaultSettings;
+            settingsCacheMTime = null;
+            return defaultSettings;
+        }
+        
+        // Проверяем изменился ли файл
+        if (!hasFileChanged() && settingsCache) {
+            // Файл не изменился, возвращаем кэш
+            return settingsCache;
+        }
+        
+        // Файл изменился или кэш пуст - читаем файл
+        const stats = fs.statSync(SETTINGS_FILE);
+        settingsCacheMTime = stats.mtimeMs;
+        
+        const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+        settingsCache = settings;
+        
+        logInfo(`✅ Настройки бота загружены из файла: модель=${settings.activeModel || 'default'}, LLM=${settings.llmChatEnabled}`);
+        return settings;
+    } catch (error) {
+        logError('❌ Ошибка загрузки настроек бота', error);
+        // Возвращаем кэш если есть, иначе defaults
+        if (settingsCache) {
+            logWarn('⚠️ Используется кэш настроек из-за ошибки чтения');
+            return settingsCache;
+        }
+        return {
+            activeModel: null,
+            llmChatEnabled: false,
+            lastUpdated: null
+        };
+    }
+}
+
+/**
+ * Сохраняет настройки бота в файл и обновляет кэш
+ */
+export function saveBotSettings(settings) {
+    try {
+        // Создаем директорию session если не существует
+        const sessionPath = path.join(process.cwd(), SESSION_DIR);
+        if (!fs.existsSync(sessionPath)) {
+            fs.mkdirSync(sessionPath, { recursive: true });
+        }
+
+        settings.lastUpdated = new Date().toISOString();
+        
+        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf8');
+        
+        // Обновляем кэш
+        settingsCache = settings;
+        // Обновляем время модификации
+        const stats = fs.statSync(SETTINGS_FILE);
+        settingsCacheMTime = stats.mtimeMs;
+        
+        logInfo(`💾 Настройки бота сохранены: модель=${settings.activeModel || 'default'}, LLM=${settings.llmChatEnabled}`);
+        return true;
+    } catch (error) {
+        logError('❌ Ошибка сохранения настроек бота', error);
+        return false;
+    }
+}
+
+/**
+ * Загружает модели для конкретных чатов (не используется, все используют activeModel)
+ */
+export function loadChatModels() {
+    return {};
+}
+
+/**
+ * Сохраняет модели для конкретных чатов (не используется, все используют activeModel)
+ */
+export function saveChatModels(chatModels) {
+    return true;
+}
+
+/**
+ * Принудительно очищает кэш настроек
+ * Используйте если файл был изменен вручную
+ */
+export function clearSettingsCache() {
+    settingsCache = null;
+    settingsCacheMTime = null;
+    logInfo('🗑️ Кэш настроек очищен');
+}
+
+/**
+ * Получает активную модель из настроек бота
+ * Приоритет: activeModel из bot_settings.json > DEFAULT_MODEL из .env > первая модель из AvailableModels.txt
+ * @returns {string} название модели
+ */
+export function getActiveModel() {
+    try {
+        const settings = loadBotSettings();
+        
+        // Если есть activeModel в настройках бота - используем его
+        if (settings && settings.activeModel) {
+            return settings.activeModel;
+        }
+        
+        // Иначе используем DEFAULT_MODEL из .env
+        if (DEFAULT_MODEL) {
+            return DEFAULT_MODEL;
+        }
+        
+        // Fallback: первая модель из списка доступных
+        try {
+            const modelsFile = path.join(process.cwd(), 'src', 'AvailableModels.txt');
+            if (fs.existsSync(modelsFile)) {
+                const modelsContent = fs.readFileSync(modelsFile, 'utf8');
+                const models = modelsContent.split('\n').map(m => m.trim()).filter(m => m && !m.startsWith('#'));
+                if (models.length > 0) {
+                    return models[0];
+                }
+            }
+        } catch (e) {
+            // Если не удалось загрузить список моделей
+        }
+        
+        // Последний fallback
+        return 'qwen3.5-plus';
+    } catch (error) {
+        logError('❌ Ошибка получения активной модели', error);
+        return 'qwen3.5-plus';
+    }
+}
+
+/**
+ * Получает текущий статус кэша (для отладки)
+ */
+export function getCacheStatus() {
+    return {
+        hasCache: settingsCache !== null,
+        cacheMTime: settingsCacheMTime,
+        cachedModel: settingsCache?.activeModel || null,
+        cachedLLM: settingsCache?.llmChatEnabled || false
+    };
+}
+
+/**
+ * Устанавливает модель для конкретного чата
+ */
+export function setChatModel(chatId, modelName) {
+    try {
+        const chatModels = loadChatModels();
+        chatModels[String(chatId)] = modelName;
+        return saveChatModels(chatModels);
+    } catch (error) {
+        logError(`❌ Ошибка установки модели для чата ${chatId}`, error);
+        return false;
+    }
+}
+
+/**
+ * Получает модель для конкретного чата
+ */
+export function getChatModel(chatId) {
+    try {
+        const chatModels = loadChatModels();
+        return chatModels[String(chatId)] || null;
+    } catch (error) {
+        logError(`❌ Ошибка получения модели для чата ${chatId}`, error);
+        return null;
+    }
+}
+
+/**
+ * Удаляет модель для конкретного чата
+ */
+export function removeChatModel(chatId) {
+    try {
+        const chatModels = loadChatModels();
+        delete chatModels[String(chatId)];
+        return saveChatModels(chatModels);
+    } catch (error) {
+        logError(`❌ Ошибка удаления модели для чата ${chatId}`, error);
+        return false;
+    }
+}

package/src/utils/permissionChecker.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+/**
+ * Permission Checker
+ * 
+ * Checks write permissions for all project directories and files at startup.
+ * Provides helpful commands to fix any permission issues.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logInfo, logWarn, logError } from '../logger/index.js';
+import { SESSION_DIR, UPLOADS_DIR, LOGS_DIR } from '../config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = path.resolve(__dirname, '../..');
+
+/**
+ * Define all directories and files that need write access
+ */
+const PATHS_TO_CHECK = [
+  // Main directories
+  { path: SESSION_DIR, type: 'directory', recursive: true },
+  { path: path.join(SESSION_DIR, 'accounts'), type: 'directory', recursive: true },
+  { path: path.join(SESSION_DIR, 'history'), type: 'directory', recursive: true },
+  { path: UPLOADS_DIR, type: 'directory', recursive: false },
+  { path: LOGS_DIR, type: 'directory', recursive: false },
+  { path: 'temp', type: 'directory', recursive: false },
+  { path: 'session_backup', type: 'directory', recursive: false },
+  
+  // Important files
+  { path: path.join(SESSION_DIR, 'tokens.json'), type: 'file', optional: true },
+  { path: path.join(SESSION_DIR, 'auth_token.txt'), type: 'file', optional: true },
+  { path: path.join(SESSION_DIR, 'bot_settings.json'), type: 'file', optional: true },
+  { path: '.env', type: 'file', optional: true },
+];
+
+/**
+ * Test if a path is writable
+ */
+function testWritePermission(testPath, type) {
+  try {
+    if (type === 'directory') {
+      // Test directory writability by checking if we can create/delete a temp file
+      const tempFile = path.join(testPath, '.write_test_' + Date.now());
+      fs.writeFileSync(tempFile, 'test');
+      fs.unlinkSync(tempFile);
+      return { writable: true, error: null };
+    } else if (type === 'file') {
+      // For files, test if parent directory is writable
+      const parentDir = path.dirname(testPath);
+      if (!fs.existsSync(parentDir)) {
+        return { writable: false, error: `Parent directory does not exist: ${parentDir}` };
+      }
+      // Try to read if file exists
+      if (fs.existsSync(testPath)) {
+        fs.accessSync(testPath, fs.constants.R_OK | fs.constants.W_OK);
+      }
+      return { writable: true, error: null };
+    }
+  } catch (error) {
+    return { writable: false, error: error.message };
+  }
+}
+
+/**
+ * Generate fix commands for a path
+ */
+function generateFixCommands(testPath, type) {
+  const absolutePath = path.isAbsolute(testPath) ? testPath : path.join(ROOT_DIR, testPath);
+  const commands = [];
+  
+  if (type === 'directory' || (type === 'file' && fs.existsSync(testPath))) {
+    // Fix ownership
+    commands.push(`sudo chown -R $USER:$USER "${absolutePath}"`);
+    // Fix permissions
+    if (type === 'directory') {
+      commands.push(`sudo chmod -R 755 "${absolutePath}"`);
+    } else {
+      commands.push(`sudo chmod 644 "${absolutePath}"`);
+    }
+  } else if (type === 'file' && !fs.existsSync(testPath)) {
+    // File doesn't exist, fix parent directory
+    const parentDir = path.dirname(absolutePath);
+    commands.push(`sudo chown -R $USER:$USER "${parentDir}"`);
+    commands.push(`sudo chmod -R 755 "${parentDir}"`);
+  }
+  
+  return commands;
+}
+
+/**
+ * Check all paths and report issues
+ */
+export async function checkPermissions() {
+  logInfo('🔍 Проверка прав доступа к директориям и файлам...');
+  
+  const issues = [];
+  const allCommands = new Set();
+  
+  for (const { path: relativePath, type, optional, recursive } of PATHS_TO_CHECK) {
+    const absolutePath = path.isAbsolute(relativePath) ? relativePath : path.join(ROOT_DIR, relativePath);
+    
+    // Skip optional paths that don't exist
+    if (optional && !fs.existsSync(absolutePath)) {
+      continue;
+    }
+    
+    // For directories, check if they exist
+    if (type === 'directory' && !fs.existsSync(absolutePath)) {
+      // Try to create it
+      try {
+        fs.mkdirSync(absolutePath, { recursive: true });
+        logInfo(`  ✅ Создана директория: ${relativePath}`);
+      } catch (error) {
+        issues.push({
+          path: relativePath,
+          absolutePath,
+          type,
+          error: `Cannot create directory: ${error.message}`,
+          commands: generateFixCommands(path.dirname(absolutePath), 'directory')
+        });
+      }
+      continue;
+    }
+    
+    // Test write permission
+    const result = testWritePermission(absolutePath, type);
+    
+    if (!result.writable) {
+      issues.push({
+        path: relativePath,
+        absolutePath,
+        type,
+        error: result.error,
+        commands: generateFixCommands(absolutePath, type)
+      });
+    }
+  }
+  
+  // Report results
+  if (issues.length === 0) {
+    logInfo('✅ Все директории и файлы доступны для записи');
+    return true;
+  }
+  
+  // Report issues
+  logError(`❌ Обнаружены проблемы с правами доступа (${issues.length}):`);
+  console.error('');
+  
+  for (const issue of issues) {
+    logError(`  📁 ${issue.path} (${issue.type})`);
+    logError(`     Ошибка: ${issue.error}`);
+    logError(`     Решение:`);
+    for (const cmd of issue.commands) {
+      console.error(`       ${cmd}`);
+      allCommands.add(cmd);
+    }
+    console.error('');
+  }
+  
+  // Show combined fix command
+  if (allCommands.size > 0) {
+    console.error('═'.repeat(70));
+    console.error('🔧 Быстрое решение (скопируйте и выполните в терминале):');
+    console.error('═'.repeat(70));
+    console.error('');
+    console.error('  ⚡ ОДНОЙ СТРОКОЙ (рекомендуется):');
+    console.error('  ' + '─'.repeat(68));
+    
+    // Group by parent directory for cleaner output
+    const dirsToFix = new Set();
+    for (const issue of issues) {
+      if (issue.type === 'directory') {
+        dirsToFix.add(issue.absolutePath);
+      } else {
+        dirsToFix.add(path.dirname(issue.absolutePath));
+      }
+    }
+    
+    const allPaths = Array.from(dirsToFix).join(' ');
+    console.error('');
+    console.error(`  sudo chown -R $USER:$USER ${allPaths}`);
+    console.error(`  sudo chmod -R 755 ${allPaths}`);
+    console.error('');
+    
+    console.error('  📦 ИЛИ исправить все основные директории проекта:');
+    console.error('  ' + '─'.repeat(68));
+    const mainDirs = [
+      path.join(ROOT_DIR, SESSION_DIR),
+      path.join(ROOT_DIR, UPLOADS_DIR),
+      path.join(ROOT_DIR, LOGS_DIR),
+      path.join(ROOT_DIR, 'temp'),
+      path.join(ROOT_DIR, 'session_backup')
+    ].join(' ');
+    console.error(`  sudo chown -R $USER:$USER ${mainDirs}`);
+    console.error(`  sudo chmod -R 755 ${mainDirs}`);
+    console.error('');
+    console.error('═'.repeat(70));
+    console.error('');
+  }
+  
+  return false;
+}

package/src/utils/prompt.js

@@ -0,0 +1,11 @@
+import readline from 'readline';
+
+/**
+ * Интерактивный ввод из stdin.
+ * @param {string} question — текст вопроса
+ * @returns {Promise<string>} — ответ пользователя (trimmed)
+ */
+export 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()); }));
+}