blockmine 1.23.4 → 1.25.0

package/backend/src/api/routes/aiAssistant.js

@@ -13,6 +13,122 @@ const { botManager } = require('../../core/services');
 // Хранилище истории чатов в памяти: Map<"botId_pluginName", messages[]>
 const chatHistoryStore = new Map();
 
+const MAX_HISTORY_MESSAGES = 300;
+
+/**
+ * Обрезает историю сообщений до MAX_HISTORY_MESSAGES (защита от memory leak)
+ * @param {Array} history - Массив сообщений
+ * @param {string} chatKey - Ключ чата для логирования
+ */
+function trimHistory(history, chatKey) {
+    if (history.length > MAX_HISTORY_MESSAGES) {
+        history.splice(0, history.length - MAX_HISTORY_MESSAGES);
+        console.log(`[AI Chat] History trimmed to ${MAX_HISTORY_MESSAGES} messages for ${chatKey}`);
+    }
+}
+
+const rateLimitStore = new Map();
+const RATE_LIMIT_MAX_REQUESTS = 30;
+const RATE_LIMIT_WINDOW_MS = 60 * 1000;
+
+// Очистка устаревших записей каждые 5 минут (защита от утечки памяти)
+setInterval(() => {
+    const now = Date.now();
+    for (const [key, record] of rateLimitStore.entries()) {
+        if (now > record.resetTime) {
+            rateLimitStore.delete(key);
+        }
+    }
+}, 5 * 60 * 1000);
+
+/**
+ * Проверка rate limit для AI запросов
+ * @param {string} key - Ключ (например, "botId_pluginName")
+ * @returns {boolean} - true если запрос разрешен, false если превышен лимит
+ */
+function checkRateLimit(key) {
+    const now = Date.now();
+    const record = rateLimitStore.get(key);
+
+    if (!record || now > record.resetTime) {
+        rateLimitStore.set(key, {
+            count: 1,
+            resetTime: now + RATE_LIMIT_WINDOW_MS
+        });
+        return true;
+    }
+
+    if (record.count >= RATE_LIMIT_MAX_REQUESTS) {
+        return false;
+    }
+
+    record.count += 1;
+    return true;
+}
+
+/**
+ * Получить оставшееся время до сброса rate limit (в секундах)
+ */
+function getRateLimitResetTime(key) {
+    const record = rateLimitStore.get(key);
+    if (!record) return 0;
+
+    const now = Date.now();
+    const remaining = Math.max(0, record.resetTime - now);
+    return Math.ceil(remaining / 1000);
+}
+
+/**
+ * Валидация и нормализация AI параметров (temperature, maxTokens)
+ */
+function validateAIParams(temperature, maxTokens, maxTokenLimit = 4096) {
+    let effectiveTemperature = 0.7;
+    if (temperature !== undefined) {
+        const temp = Number(temperature);
+        if (!isFinite(temp) || temp < 0 || temp > 2) {
+            return { error: 'Temperature must be a number between 0 and 2.' };
+        }
+        effectiveTemperature = temp;
+    }
+    let effectiveMaxTokens = 4096;
+    if (maxTokens !== undefined) {
+        const tokens = Number(maxTokens);
+        if (!isFinite(tokens) || tokens < 256) {
+            return { error: 'maxTokens must be a number >= 256.' };
+        }
+        effectiveMaxTokens = Math.min(tokens, maxTokenLimit);
+    }
+
+    return { effectiveTemperature, effectiveMaxTokens };
+}
+
+/**
+ * Простое форматирование JS кода
+ * - Нормализует line endings (CRLF -> LF)
+ * - Убирает trailing whitespace
+ * - Обеспечивает newline в конце файла
+ * - Убирает множественные пустые строки (оставляет максимум 2)
+ */
+function simpleFormatCode(content, filePath) {
+    // Только для JS файлов
+    if (!filePath.endsWith('.js') && !filePath.endsWith('.mjs') && !filePath.endsWith('.cjs')) {
+        return content;
+    }
+
+    let formatted = content;
+    formatted = formatted.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+    formatted = formatted.split('\n').map(line => line.trimEnd()).join('\n');
+
+    formatted = formatted.replace(/\n{4,}/g, '\n\n\n');
+
+    if (!formatted.endsWith('\n')) {
+        formatted += '\n';
+    }
+
+    return formatted;
+}
+
 /**
  * Конвертирует JSON Schema параметры в формат Gemini
  */
@@ -96,7 +212,7 @@ function parseProxyString(proxyString) {
 
         return {
             host: host,
-            port: parseInt(port),
+            port: parseInt(port, 10),
             user: user,
             pass: pass
         };
@@ -106,7 +222,6 @@ function parseProxyString(proxyString) {
     }
 }
 
-// Список игнорируемых файлов/папок для сканирования проекта
 const IGNORE_LIST = [
     'node_modules/',
     'package-lock.json',
@@ -121,9 +236,41 @@ const IGNORE_LIST = [
     '.claude/'
 ];
 
-// Вспомогательная функция для проверки игнорирования
+/**
+ * Строгая проверка безопасности пути (защита от path traversal)
+ * @param {string} basePath - Базовая директория (например, pluginPath)
+ * @param {string} userPath - Путь от пользователя
+ * @returns {string|null} - Безопасный абсолютный путь или null если небезопасно
+ */
+function validateSafePath(basePath, userPath) {
+    // Проверяем что userPath не пустой
+    if (!userPath || typeof userPath !== 'string') {
+        return null;
+    }
+
+    // Проверяем на опасные символы
+    if (userPath.includes('\0') || userPath.includes('\x00')) {
+        return null;
+    }
+
+    // Нормализуем пути
+    const normalizedBase = path.normalize(basePath);
+    const resolvedPath = path.resolve(basePath, userPath);
+    const normalizedResolved = path.normalize(resolvedPath);
+
+    // Проверяем что путь начинается с базового пути
+    // Используем path.relative чтобы проверить что файл внутри базовой директории
+    const relativePath = path.relative(normalizedBase, normalizedResolved);
+
+    // Если relative path начинается с '..' или является абсолютным, значит файл вне базовой директории
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        return null;
+    }
+
+    return normalizedResolved;
+}
+
 function shouldIgnore(filePath, ignoreList) {
-    // Нормализуем путь к forward slashes для кроссплатформенности
     const normalizedPath = filePath.replace(/\\/g, '/');
 
     return ignoreList.some(pattern => {
@@ -143,7 +290,6 @@ function shouldIgnore(filePath, ignoreList) {
     });
 }
 
-// Получить все файлы рекурсивно
 function getAllFilesRecursive(dir, basePath = dir, fileList = [], ignoreList = []) {
     const files = fse.readdirSync(dir);
 
@@ -165,7 +311,6 @@ function getAllFilesRecursive(dir, basePath = dir, fileList = [], ignoreList = [
     return fileList;
 }
 
-// Получить древовидную структуру
 function getTreeStructure(dir, basePath = dir, prefix = '', ignoreList = []) {
     const files = fse.readdirSync(dir);
     let result = '';
@@ -192,7 +337,6 @@ function getTreeStructure(dir, basePath = dir, prefix = '', ignoreList = []) {
     return result;
 }
 
-// Debug middleware
 router.use((req, res, next) => {
     console.log('[AI Assistant Router] Request:', req.method, req.path, 'Params:', req.params);
     next();
@@ -206,13 +350,24 @@ async function resolvePluginPath(req, res, next) {
         console.log('resolvePluginPath - botId:', req.params.botId, 'pluginName:', req.params.pluginName);
         const { botId, pluginName } = req.params;
 
+        // Валидация botId (защита от SQL Injection)
+        const botIdNum = parseInt(botId, 10);
+        if (isNaN(botIdNum) || botIdNum <= 0 || botIdNum.toString() !== botId) {
+            return res.status(400).json({ error: 'Invalid bot ID.' });
+        }
+
         if (!pluginName) {
             return res.status(400).json({ error: 'Имя плагина обязательно в пути.' });
         }
 
+        // Валидация pluginName (защита от path traversal в имени)
+        if (pluginName.includes('..') || pluginName.includes('/') || pluginName.includes('\\')) {
+            return res.status(400).json({ error: 'Invalid plugin name.' });
+        }
+
         const plugin = await prisma.installedPlugin.findFirst({
             where: {
-                botId: parseInt(botId),
+                botId: botIdNum,
                 name: pluginName
             }
         });
@@ -232,6 +387,7 @@ async function resolvePluginPath(req, res, next) {
 
         console.log('Plugin path found, proceeding to route handler');
         req.pluginPath = pluginPath;
+        req.botIdNum = botIdNum; // Сохраняем валидированный botId
         next();
     } catch (error) {
         console.error('Error in resolvePluginPath:', error);
@@ -239,10 +395,8 @@ async function resolvePluginPath(req, res, next) {
     }
 }
 
-// Создаем tools для AI ассистента
-function createPluginTools(pluginPath, res, botId) {
-    return [
-        // Tool 1: Получить древовидную структуру проекта
+function createPluginTools(pluginPath, res, botId, applyMode = 'immediate', autoFormat = false) {
+    const baseTools = [
         {
             type: 'function',
             function: {
@@ -271,7 +425,6 @@ function createPluginTools(pluginPath, res, botId) {
             }
         },
 
-        // Tool 2: Получить полный контекст проекта
         {
             type: 'function',
             function: {
@@ -294,9 +447,27 @@ function createPluginTools(pluginPath, res, botId) {
                     result += `Всего файлов: ${allFiles.length}\n\n`;
                     result += `Содержимое файлов:\n\n`;
 
+                    // Ограничения для защиты от переполнения памяти
+                    const MAX_FILE_SIZE = 100 * 1024; // 100KB на файл
+                    const MAX_TOTAL_SIZE = 1024 * 1024; // 1MB общий размер
+                    let totalSize = 0;
+
                     for (const file of allFiles) {
                         const fullPath = path.join(pluginPath, file);
+
+                        const stats = await fse.stat(fullPath);
+                        if (stats.size > MAX_FILE_SIZE) {
+                            result += `=== Файл: ${file} === (пропущен: размер ${stats.size} байт превышает лимит ${MAX_FILE_SIZE})\n\n`;
+                            continue;
+                        }
+
+                        if (totalSize + stats.size > MAX_TOTAL_SIZE) {
+                            result += `\n(достигнут лимит размера ответа ${MAX_TOTAL_SIZE} байт, остальные файлы пропущены)\n`;
+                            break;
+                        }
+
                         const fileContent = await fse.readFile(fullPath, 'utf8');
+                        totalSize += fileContent.length;
                         result += `=== Файл: ${file} ===\n${fileContent}\n\n`;
                     }
 
@@ -307,7 +478,6 @@ function createPluginTools(pluginPath, res, botId) {
             }
         },
 
-        // Tool 2: Прочитать конкретный файл
         {
             type: 'function',
             function: {
@@ -327,12 +497,10 @@ function createPluginTools(pluginPath, res, botId) {
             execute: async (args) => {
                 console.log('readFile called with:', args.filePath);
                 try {
-                    const safePath = path.resolve(pluginPath, args.filePath);
-
-                    // Проверка безопасности - файл должен быть внутри pluginPath
-                    const normalizedPluginPath = pluginPath.endsWith(path.sep) ? pluginPath : pluginPath + path.sep;
-                    if (!safePath.startsWith(normalizedPluginPath) && safePath !== pluginPath) {
-                        return `Ошибка: Доступ запрещен. Файл находится за пределами плагина.`;
+                    // Используем строгую проверку безопасности (защита от path traversal)
+                    const safePath = validateSafePath(pluginPath, args.filePath);
+                    if (!safePath) {
+                        return `Ошибка: Доступ запрещен. Недопустимый путь к файлу.`;
                     }
 
                     if (!await fse.pathExists(safePath)) {
@@ -347,7 +515,6 @@ function createPluginTools(pluginPath, res, botId) {
             }
         },
 
-        // Tool 3: Обновить содержимое файла
         {
             type: 'function',
             function: {
@@ -369,14 +536,19 @@ function createPluginTools(pluginPath, res, botId) {
                 }
             },
             execute: async (args, context) => {
-                console.log('updateFile called for:', args.filePath);
-                try {
-                    const safePath = path.resolve(pluginPath, args.filePath);
+                console.log('updateFile called for:', args.filePath, 'applyMode:', applyMode, 'autoFormat:', autoFormat);
+
+                let content = args.content;
+                if (autoFormat) {
+                    content = simpleFormatCode(content, args.filePath);
+                    console.log('Auto-formatted content for:', args.filePath);
+                }
 
-                    // Проверка безопасности - файл должен быть внутри pluginPath
-                    const normalizedPluginPath = pluginPath.endsWith(path.sep) ? pluginPath : pluginPath + path.sep;
-                    if (!safePath.startsWith(normalizedPluginPath) && safePath !== pluginPath) {
-                        return `Ошибка: Доступ запрещен. Файл находится за пределами плагина.`;
+                try {
+                    // Используем строгую проверку безопасности (защита от path traversal)
+                    const safePath = validateSafePath(pluginPath, args.filePath);
+                    if (!safePath) {
+                        return `Ошибка: Доступ запрещен. Недопустимый путь к файлу.`;
                     }
 
                     // Читаем старое содержимое для подсчёта diff
@@ -390,34 +562,24 @@ function createPluginTools(pluginPath, res, botId) {
                     } else {
                         isNewFile = true;
                     }
-
-                    // Создаем директорию если не существует
-                    await fse.ensureDir(path.dirname(safePath));
-
-                    // Записываем новое содержимое
-                    await fse.writeFile(safePath, args.content, 'utf8');
-
-                    // Вычисляем реальные изменённые строки используя diff
-                    const newLines = args.content.split('\n');
+                    
+                    const newLines = content.split('\n');
                     let linesAdded = 0;
                     let linesRemoved = 0;
                     let changedLineRanges = []; // Массив объектов { start: number, end: number }
 
                     if (isNewFile) {
                         linesAdded = newLines.length;
-                        // Все строки нового файла - это добавленные строки
                         changedLineRanges = [{ start: 1, end: newLines.length }];
                     } else {
-                        // Используем библиотеку diff для вычисления изменений
-                        const diffResult = Diff.diffLines(oldContent, args.content);
+                        const diffResult = Diff.diffLines(oldContent, content);
 
-                        let currentLine = 1; // Текущая строка в новом файле
+                        let currentLine = 1;
 
                         diffResult.forEach(part => {
                             const lineCount = part.count || 0;
 
                             if (part.added) {
-                                // Добавленные строки
                                 linesAdded += lineCount;
                                 changedLineRanges.push({
                                     start: currentLine,
@@ -425,29 +587,58 @@ function createPluginTools(pluginPath, res, botId) {
                                 });
                                 currentLine += lineCount;
                             } else if (part.removed) {
-                                // Удалённые строки (не увеличиваем currentLine)
                                 linesRemoved += lineCount;
                             } else {
-                                // Неизменённые строки
                                 currentLine += lineCount;
                             }
                         });
                     }
 
-                    // Отправляем событие на фронтенд для обновления редактора
+                    if (applyMode === 'preview') {
+                        const sseEvent = {
+                            type: 'file_preview',
+                            filePath: args.filePath,
+                            newContent: content,
+                            oldContent: oldContent,
+                            linesAdded,
+                            linesRemoved,
+                            isNewFile,
+                            changedLineRanges
+                        };
+                        console.log('Sending SSE event file_preview:', {
+                            filePath: args.filePath,
+                            contentLength: content.length,
+                            linesAdded,
+                            linesRemoved,
+                            isNewFile
+                        });
+                        res.write(`data: ${JSON.stringify(sseEvent)}\n\n`);
+
+                        if (isNewFile) {
+                            return `[ОЖИДАЕТ ПОДТВЕРЖДЕНИЯ] Предложено создание файла "${args.filePath}" (${newLines.length} строк). Файл ЕЩЁ НЕ создан - пользователь должен нажать "Применить" чтобы подтвердить. В своём ответе пользователю скажи что ты ПРЕДЛАГАЕШЬ создать файл и жди его решения. НЕ говори что файл создан.`;
+                        } else {
+                            return `[ОЖИДАЕТ ПОДТВЕРЖДЕНИЯ] Предложено обновление файла "${args.filePath}" (+${linesAdded} -${linesRemoved} строк). Файл ЕЩЁ НЕ изменён - пользователь должен нажать "Применить" чтобы подтвердить. В своём ответе пользователю скажи что ты ПРЕДЛАГАЕШЬ изменения и жди его решения. НЕ говори что изменения применены.`;
+                        }
+                    }
+
+                    // Immediate mode - записываем файл сразу
+                    await fse.ensureDir(path.dirname(safePath));
+
+                    await fse.writeFile(safePath, content, 'utf8');
+
                     const sseEvent = {
                         type: 'file_updated',
                         filePath: args.filePath,
-                        newContent: args.content,
+                        newContent: content,
                         oldContent: oldContent,
                         linesAdded,
                         linesRemoved,
                         isNewFile,
-                        changedLineRanges // Добавляем точные диапазоны изменённых строк
+                        changedLineRanges
                     };
                     console.log('Sending SSE event file_updated:', {
                         filePath: args.filePath,
-                        contentLength: args.content.length,
+                        contentLength: content.length,
                         linesAdded,
                         linesRemoved,
                         isNewFile,
@@ -457,7 +648,7 @@ function createPluginTools(pluginPath, res, botId) {
                     console.log('SSE event sent successfully');
 
                     if (isNewFile) {
-                        return `Создан новый файл "${args.filePath}". Размер: ${args.content.length} символов (${newLines.length} строк).`;
+                        return `Создан новый файл "${args.filePath}". Размер: ${content.length} символов (${newLines.length} строк).`;
                     } else {
                         return `Успешно обновлен файл "${args.filePath}". +${linesAdded} -${linesRemoved} строк.`;
                     }
@@ -468,7 +659,6 @@ function createPluginTools(pluginPath, res, botId) {
             }
         },
 
-        // Tool 4: Прочитать логи бота (чат из игры и console.log)
         {
             type: 'function',
             function: {
@@ -499,10 +689,8 @@ function createPluginTools(pluginPath, res, botId) {
                         return 'Логи бота пусты. Возможно бот ещё не запущен или не было активности.';
                     }
 
-                    // Берём последние N записей
                     let filteredLogs = logs.slice(-limit);
 
-                    // Применяем фильтр если указан
                     if (args.filter) {
                         const filterLower = args.filter.toLowerCase();
                         filteredLogs = filteredLogs.filter(log => {
@@ -515,7 +703,6 @@ function createPluginTools(pluginPath, res, botId) {
                         return `Логи не найдены${args.filter ? ` по фильтру "${args.filter}"` : ''}.`;
                     }
 
-                    // Форматируем логи
                     const formattedLogs = filteredLogs.map(log => {
                         if (typeof log === 'string') {
                             return log;
@@ -536,7 +723,6 @@ function createPluginTools(pluginPath, res, botId) {
             }
         },
 
-        // Tool 5: Удалить файл
         {
             type: 'function',
             function: {
@@ -556,12 +742,10 @@ function createPluginTools(pluginPath, res, botId) {
             execute: async (args) => {
                 console.log('deleteFile called for:', args.filePath);
                 try {
-                    const safePath = path.resolve(pluginPath, args.filePath);
-
-                    // Проверка безопасности - файл должен быть внутри pluginPath
-                    const normalizedPluginPath = pluginPath.endsWith(path.sep) ? pluginPath : pluginPath + path.sep;
-                    if (!safePath.startsWith(normalizedPluginPath) && safePath !== pluginPath) {
-                        return `Ошибка: Доступ запрещен. Файл находится за пределами плагина.`;
+                    // Используем строгую проверку безопасности (защита от path traversal)
+                    const safePath = validateSafePath(pluginPath, args.filePath);
+                    if (!safePath) {
+                        return `Ошибка: Доступ запрещен. Недопустимый путь к файлу.`;
                     }
 
                     // Проверяем что путь существует
@@ -593,7 +777,122 @@ function createPluginTools(pluginPath, res, botId) {
             }
         },
 
-        // Tool 6: Удалить папку
+        {
+            type: 'function',
+            function: {
+                name: 'searchCode',
+                description: 'Ищет текст или регулярное выражение в файлах плагина. Полезно для поиска функций, переменных, использований и паттернов в коде.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Текст или регулярное выражение для поиска'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['text', 'regex'],
+                            description: 'Тип поиска: text (точное совпадение) или regex (регулярное выражение). По умолчанию text.'
+                        },
+                        filePattern: {
+                            type: 'string',
+                            description: 'Паттерн файлов для поиска, например "*.js" или "*.json". По умолчанию ищет во всех файлах.'
+                        },
+                        maxResults: {
+                            type: 'number',
+                            description: 'Максимальное количество результатов (по умолчанию 20, максимум 50)'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            execute: async (args) => {
+                console.log('searchCode called:', args.query, 'type:', args.type || 'text');
+                try {
+                    const searchType = args.type || 'text';
+                    const maxResults = Math.min(args.maxResults || 20, 50);
+                    const filePattern = args.filePattern || '*';
+
+                    const allFiles = getAllFilesRecursive(pluginPath, pluginPath, [], IGNORE_LIST);
+
+                    let filesToSearch = allFiles;
+                    if (filePattern !== '*') {
+                        // Полное экранирование спецсимволов regex, затем конвертация glob '*' в '.*'
+                        const escaped = filePattern
+                            .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+                            .replace(/\*/g, '.*');
+                        const patternRegex = new RegExp('^' + escaped + '$');
+                        filesToSearch = allFiles.filter(f => patternRegex.test(path.basename(f)));
+                    }
+
+                    let searchRegex;
+                    try {
+                        // Защита от ReDoS: ограничение длины regex паттерна
+                        const MAX_REGEX_LENGTH = 100;
+                        if (searchType === 'regex') {
+                            if (args.query.length > MAX_REGEX_LENGTH) {
+                                return `Ошибка: регулярное выражение слишком длинное (максимум ${MAX_REGEX_LENGTH} символов)`;
+                            }
+                            searchRegex = new RegExp(args.query, 'gi');
+                        } else {
+                            const escaped = args.query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                            searchRegex = new RegExp(escaped, 'gi');
+                        }
+                    } catch (regexError) {
+                        return `Ошибка в регулярном выражении: ${regexError.message}`;
+                    }
+
+                    const results = [];
+
+                    for (const file of filesToSearch) {
+                        if (results.length >= maxResults) break;
+
+                        const fullPath = path.join(pluginPath, file);
+
+                        try {
+                            const content = await fse.readFile(fullPath, 'utf8');
+                            const lines = content.split('\n');
+
+                            lines.forEach((line, index) => {
+                                if (results.length >= maxResults) return;
+
+                                if (searchRegex.test(line)) {
+                                    searchRegex.lastIndex = 0;
+
+                                    results.push({
+                                        file: file,
+                                        line: index + 1,
+                                        content: line.trim().substring(0, 200)
+                                    });
+                                }
+                            });
+                        } catch (readError) {
+                            continue;
+                        }
+                    }
+
+                    if (results.length === 0) {
+                        return `Поиск "${args.query}" не дал результатов в ${filesToSearch.length} файлах.`;
+                    }
+
+                    let response = `Найдено ${results.length} совпадений для "${args.query}":\n\n`;
+
+                    results.forEach((r, i) => {
+                        response += `${i + 1}. ${r.file}:${r.line}\n   ${r.content}\n\n`;
+                    });
+
+                    if (results.length === maxResults) {
+                        response += `\n(показаны первые ${maxResults} результатов)`;
+                    }
+
+                    return response;
+                } catch (error) {
+                    console.error('Error in searchCode:', error);
+                    return `Ошибка при поиске: ${error.message}`;
+                }
+            }
+        },
+
         {
             type: 'function',
             function: {
@@ -613,38 +912,30 @@ function createPluginTools(pluginPath, res, botId) {
             execute: async (args) => {
                 console.log('deleteFolder called for:', args.folderPath);
                 try {
-                    const safePath = path.resolve(pluginPath, args.folderPath);
-
-                    // Проверка безопасности - папка должна быть внутри pluginPath
-                    const normalizedPluginPath = pluginPath.endsWith(path.sep) ? pluginPath : pluginPath + path.sep;
-                    if (!safePath.startsWith(normalizedPluginPath) && safePath !== pluginPath) {
-                        return `Ошибка: Доступ запрещен. Папка находится за пределами плагина.`;
+                    // Используем строгую проверку безопасности (защита от path traversal)
+                    const safePath = validateSafePath(pluginPath, args.folderPath);
+                    if (!safePath) {
+                        return `Ошибка: Доступ запрещен. Недопустимый путь к папке.`;
                     }
 
-                    // Защита от удаления корневой директории плагина
-                    if (safePath === pluginPath) {
+                    if (safePath === path.normalize(pluginPath)) {
                         return `Ошибка: Нельзя удалить корневую директорию плагина.`;
                     }
 
-                    // Проверяем что путь существует
                     if (!await fse.pathExists(safePath)) {
                         return `Ошибка: Папка "${args.folderPath}" не найдена.`;
                     }
 
-                    // Проверяем что это директория
                     const stats = await fse.stat(safePath);
                     if (!stats.isDirectory()) {
                         return `Ошибка: "${args.folderPath}" является файлом. Используйте deleteFile для удаления файлов.`;
                     }
 
-                    // Подсчитываем количество файлов и папок внутри
                     const items = await fse.readdir(safePath);
                     const itemCount = items.length;
 
-                    // Удаляем папку рекурсивно
                     await fse.remove(safePath);
 
-                    // Отправляем событие на фронтенд
                     const sseEvent = {
                         type: 'folder_deleted',
                         folderPath: args.folderPath
@@ -659,6 +950,8 @@ function createPluginTools(pluginPath, res, botId) {
             }
         }
     ];
+
+    return baseTools;
 }
 
 /**
@@ -668,9 +961,32 @@ function createPluginTools(pluginPath, res, botId) {
 router.post('/chat', resolvePluginPath, async (req, res) => {
     console.log('Route hit! botId:', req.params.botId, 'pluginName:', req.params.pluginName);
     try {
-        const { message, provider, apiKey, apiEndpoint, model, history, includeFiles, proxy } = req.body;
+        const { message, provider, apiKey, apiEndpoint, model, history, includeFiles, proxy, applyMode, temperature, maxTokens, customSystemPrompt, aiMode, autoFormat } = req.body;
         const { botId, pluginName } = req.params;
 
+        // Проверка rate limit (защита от злоупотребления)
+        const rateLimitKey = `${botId}_${pluginName}`;
+        if (!checkRateLimit(rateLimitKey)) {
+            const resetTime = getRateLimitResetTime(rateLimitKey);
+            console.warn(`[AI Chat] Rate limit exceeded for ${rateLimitKey}. Reset in ${resetTime}s`);
+            return res.status(429).json({
+                error: 'Превышен лимит запросов к AI. Попробуйте позже.',
+                retryAfter: resetTime
+            });
+        }
+
+        const effectiveApplyMode = applyMode || 'immediate';
+
+        const effectiveAutoFormat = autoFormat === true;
+
+        const validation = validateAIParams(temperature, maxTokens, 4096);
+        if (validation.error) {
+            return res.status(400).json({ error: validation.error });
+        }
+        const { effectiveTemperature, effectiveMaxTokens } = validation;
+
+        console.log('Apply mode:', effectiveApplyMode);
+
         const aiProvider = provider || 'openrouter';
         console.log('AI Provider:', aiProvider);
         console.log('Proxy config:', proxy);
@@ -690,6 +1006,10 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
             systemPrompt = await fse.readFile(systemPromptPath, 'utf8');
         }
 
+        if (customSystemPrompt && customSystemPrompt.trim()) {
+            systemPrompt += `\n\n## Дополнительные инструкции пользователя:\n${customSystemPrompt.trim()}`;
+        }
+
         let context = '';
 
         const packageJsonPath = path.join(req.pluginPath, 'package.json');
@@ -698,12 +1018,15 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
             context += `\n\n## Package.json плагина:\n\`\`\`json\n${JSON.stringify(packageJson, null, 2)}\n\`\`\`\n`;
         }
 
-        // Добавляем файлы если запрошено
         if (includeFiles && Array.isArray(includeFiles)) {
             for (const fileName of includeFiles) {
-                const filePath = path.join(req.pluginPath, fileName);
-                if (await fse.pathExists(filePath)) {
-                    const fileContent = await fse.readFile(filePath, 'utf8');
+                const safePath = validateSafePath(req.pluginPath, fileName);
+                if (!safePath) {
+                    console.warn(`[AI Chat] Skipping unsafe path: ${fileName}`);
+                    continue;
+                }
+                if (await fse.pathExists(safePath)) {
+                    const fileContent = await fse.readFile(safePath, 'utf8');
                     context += `\n\n## Файл ${fileName}:\n\`\`\`javascript\n${fileContent}\n\`\`\`\n`;
                 }
             }
@@ -729,35 +1052,34 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
             console.log('Created Google Gemini client');
         } else {
             // OpenRouter
+            const maxToolIterations = 30;
+
             const clientConfig = {
                 apiKey: apiKey,
                 model: model,
                 historyAdapter: new MemoryHistoryStorage(),
-                debug: true
+                maxToolCalls: maxToolIterations, 
+                debug: false
             };
 
-            // Добавляем кастомный endpoint если указан
             if (apiEndpoint && apiEndpoint !== 'https://openrouter.ai/api/v1') {
                 clientConfig.apiEndpoint = apiEndpoint;
             }
 
-            // Добавляем прокси если указан
             if (proxyConfig) {
                 clientConfig.proxy = proxyConfig;
             }
 
             client = new OpenRouterClient(clientConfig);
-            console.log('Created OpenRouter client');
+            console.log('Created OpenRouter client with maxToolCalls:', maxToolIterations);
         }
 
-        // Получаем или создаем историю для этого бота и плагина
         const chatKey = `${botId}_${pluginName}`;
         if (!chatHistoryStore.has(chatKey)) {
             chatHistoryStore.set(chatKey, []);
         }
         const storedHistory = chatHistoryStore.get(chatKey);
 
-        // Формируем customMessages
         const customMessages = [
             {
                 role: 'system',
@@ -765,35 +1087,38 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
             }
         ];
 
-        // Добавляем сохранённую историю
         customMessages.push(...storedHistory);
 
-        // Добавляем текущее сообщение
         const userMessage = {
             role: 'user',
             content: message
         };
         customMessages.push(userMessage);
 
-        // Сохраняем сообщение пользователя в историю
         storedHistory.push(userMessage);
 
-        // Создаем tools для этого плагина (только для OpenRouter пока)
-        const pluginTools = createPluginTools(req.pluginPath, res, botId);
+        // Ограничиваем размер истории (защита от memory leak)
+        trimHistory(storedHistory, chatKey);
+
+        const pluginTools = createPluginTools(
+            req.pluginPath,
+            res,
+            botId,
+            effectiveApplyMode,
+            effectiveAutoFormat
+        );
+        console.log('AutoFormat:', effectiveAutoFormat, 'Tools count:', pluginTools.length);
 
         let fullResponse = '';
         let assistantMessage = { role: 'assistant', content: '' };
 
-        // Google Gemini использует другой API
         if (aiProvider === 'google') {
-            // Устанавливаем SSE заголовки
             res.setHeader('Content-Type', 'text/event-stream');
             res.setHeader('Cache-Control', 'no-cache');
             res.setHeader('Connection', 'keep-alive');
 
             try {
                 console.log('[Google] Converting history...');
-                // Конвертируем историю в формат Gemini
                 const geminiHistory = [];
                 storedHistory.forEach(msg => {
                     if (msg.role === 'user') {
@@ -804,7 +1129,6 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
                 });
                 console.log('[Google] History length:', geminiHistory.length);
 
-                // Конвертируем tools в формат Gemini с wrapper для SSE событий
                 console.log('[Google] Converting tools...');
                 const geminiTools = [{
                     functionDeclarations: pluginTools.map(tool => ({
@@ -812,7 +1136,6 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
                         description: tool.function.description,
                         parameters: convertToGeminiParameters(tool.function.parameters),
                         execute: async (args) => {
-                            // Отправляем событие начала выполнения tool
                             if (!res.writableEnded) {
                                 res.write(`data: ${JSON.stringify({
                                     type: 'tool_call',
@@ -837,12 +1160,13 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
                 }];
                 console.log('[Google] Converted', geminiTools[0].functionDeclarations.length, 'tools');
 
-                console.log('[Google] Creating chat...');
+                const maxToolIterations = 30;
+                console.log('[Google] Creating chat... maxToolCalls:', maxToolIterations);
                 const chat = client.chats.create({
                     systemInstruction: systemPrompt + context,
                     history: geminiHistory,
                     tools: geminiTools,
-                    maxToolCalls: 10
+                    maxToolCalls: maxToolIterations
                 });
 
                 console.log('[Google] Sending message...');
@@ -859,6 +1183,9 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
                 assistantMessage.content = content;
                 storedHistory.push(assistantMessage);
 
+                // Ограничиваем размер истории (защита от memory leak)
+                trimHistory(storedHistory, chatKey);
+
                 console.log('[Google] Closing SSE stream');
                 res.end();
                 return;
@@ -877,10 +1204,11 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
         res.setHeader('Connection', 'keep-alive');
 
         try {
+            console.log(`Using temperature: ${effectiveTemperature}, maxTokens: ${effectiveMaxTokens}`);
             await client.chatStream({
                 customMessages: customMessages,
-                temperature: 0.7,
-                maxTokens: 4096,
+                temperature: effectiveTemperature,
+                maxTokens: effectiveMaxTokens,
                 tools: pluginTools,
                 includeToolResultInReport: true,
                 streamCallbacks: {
@@ -911,6 +1239,9 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
 
             if (assistantMessage.content) {
                 storedHistory.push(assistantMessage);
+
+                trimHistory(storedHistory, chatKey);
+
                 console.log(`Saved to history. Total messages: ${storedHistory.length}`);
             }
 
@@ -930,22 +1261,151 @@ router.post('/chat', resolvePluginPath, async (req, res) => {
     } catch (error) {
         console.error('[AI Assistant Error]:', error);
 
-        // Если заголовки еще не отправлены, отправляем JSON ошибку
         if (!res.headersSent) {
             res.status(500).json({
                 error: error.message || 'Failed to process AI request.'
             });
         } else {
-            // Если стриминг уже начался, отправляем ошибку через SSE
             res.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\n\n`);
             res.end();
         }
     }
 });
 
+/**
+ * POST /api/bots/:botId/plugins/ide/:pluginName/ai/inline
+ * Inline AI запрос (для командной палитры в редакторе)
+ */
+router.post('/inline', resolvePluginPath, async (req, res) => {
+    try {
+        const { prompt, systemInstruction, action, context, provider, apiKey, apiEndpoint, model, proxy, temperature, maxTokens } = req.body;
+        const { botId, pluginName } = req.params;
+
+        const rateLimitKey = `${botId}_${pluginName}_inline`;
+        if (!checkRateLimit(rateLimitKey)) {
+            const resetTime = getRateLimitResetTime(rateLimitKey);
+            console.warn(`[AI Inline] Rate limit exceeded for ${rateLimitKey}. Reset in ${resetTime}s`);
+            return res.status(429).json({
+                error: 'Превышен лимит запросов к AI. Попробуйте позже.',
+                retryAfter: resetTime
+            });
+        }
+
+        if (!prompt) {
+            return res.status(400).json({ error: 'Prompt is required' });
+        }
+
+        if (!apiKey) {
+            return res.status(400).json({ error: 'API key is required' });
+        }
+
+        const aiProvider = provider || 'openrouter';
+        const proxyConfig = parseProxyString(proxy);
+
+        const validation = validateAIParams(temperature, maxTokens, 4096);
+        if (validation.error) {
+            return res.status(400).json({ error: validation.error });
+        }
+        const { effectiveTemperature, effectiveMaxTokens } = validation;
+
+        let client;
+        if (aiProvider === 'google') {
+            const googleConfig = {
+                apiKeys: [apiKey],
+                defaultModel: model
+            };
+            if (proxyConfig) {
+                googleConfig.proxy = proxyConfig;
+            }
+            client = new GeminiClient(googleConfig);
+        } else {
+            const clientConfig = {
+                apiKey: apiKey,
+                model: model,
+                historyAdapter: new MemoryHistoryStorage()
+            };
+            if (apiEndpoint && apiEndpoint !== 'https://openrouter.ai/api/v1') {
+                clientConfig.apiEndpoint = apiEndpoint;
+            }
+            if (proxyConfig) {
+                clientConfig.proxy = proxyConfig;
+            }
+            client = new OpenRouterClient(clientConfig);
+        }
+
+        let result;
+
+        if (aiProvider === 'google') {
+            const chat = client.chats.create({
+                systemInstruction: systemInstruction || 'Ты - AI помощник для разработчиков. Отвечай кратко и по делу.'
+            });
+            const response = await chat.sendMessage(prompt);
+            result = response.text();
+        } else {
+            const response = await client.chat({
+                customMessages: [
+                    { role: 'system', content: systemInstruction || 'Ты - AI помощник для разработчиков. Отвечай кратко и по делу.' },
+                    { role: 'user', content: prompt }
+                ],
+                temperature: effectiveTemperature,
+                maxTokens: effectiveMaxTokens
+            });
+            result = response;
+        }
+
+        console.log('[AI Inline] Response generated for action:', action);
+        res.json({ result, action });
+
+    } catch (error) {
+        console.error('[AI Inline Error]:', error);
+        res.status(500).json({ error: error.message || 'Failed to process inline AI request' });
+    }
+});
+
+/**
+ * POST /api/bots/:botId/plugins/ide/:pluginName/ai/apply-change
+ * Применяет preview изменение (записывает файл на диск)
+ */
+router.post('/apply-change', resolvePluginPath, async (req, res) => {
+    try {
+        const { filePath, content } = req.body;
+        const { botId, pluginName } = req.params;
+
+        const rateLimitKey = `${botId}_${pluginName}_apply`;
+        if (!checkRateLimit(rateLimitKey)) {
+            const resetTime = getRateLimitResetTime(rateLimitKey);
+            console.warn(`[AI Apply] Rate limit exceeded for ${rateLimitKey}. Reset in ${resetTime}s`);
+            return res.status(429).json({
+                error: 'Превышен лимит запросов к AI. Попробуйте позже.',
+                retryAfter: resetTime
+            });
+        }
+
+        if (!filePath || content === undefined) {
+            return res.status(400).json({ error: 'filePath and content are required' });
+        }
+
+        // Используем строгую проверку безопасности (защита от path traversal)
+        const safePath = validateSafePath(req.pluginPath, filePath);
+        if (!safePath) {
+            return res.status(403).json({ error: 'Access denied. Invalid file path.' });
+        }
+
+        await fse.ensureDir(path.dirname(safePath));
+
+        await fse.writeFile(safePath, content, 'utf8');
+
+        console.log('[AI] Applied preview change:', filePath);
+
+        res.json({ success: true, filePath });
+    } catch (error) {
+        console.error('[AI] Error applying change:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
 /**
  * GET /api/bots/:botId/plugins/ide/:pluginName/ai/chat
- * Получает историю чата для конкретного бота и плагина
  */
 router.get('/chat', resolvePluginPath, async (req, res) => {
     try {
@@ -967,7 +1427,6 @@ router.get('/chat', resolvePluginPath, async (req, res) => {
 
 /**
  * DELETE /api/bots/:botId/plugins/ide/:pluginName/ai/chat
- * Очищает историю чата для конкретного бота и плагина
  */
 router.delete('/chat', resolvePluginPath, async (req, res) => {
     try {