Add files via upload

static/js/db.js

@@ -0,0 +1,153 @@
+// static/js/db.js
+
+const DB_NAME = 'AlphaChatFileStore';
+const STORE_NAME = 'files';
+// *** قدم 1: نسخه دیتابیس را افزایش می‌دهیم تا فرآیند ارتقا فعال شود ***
+const DB_VERSION = 2;
+
+let db;
+
+// 1. مقداردهی اولیه و باز کردن دیتابیس
+export function initDB() {
+    return new Promise((resolve, reject) => {
+        console.log(`در حال تلاش برای باز کردن دیتابیس ${DB_NAME} با نسخه ${DB_VERSION}...`);
+        const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+        request.onerror = (event) => {
+            console.error("خطای حیاتی در باز کردن IndexedDB:", event.target.error);
+            reject("خطای دیتابیس. لطفا از فعال بودن کوکی‌ها و فضای ذخیره‌سازی مرورگر اطمینان حاصل کنید.");
+        };
+
+        request.onsuccess = (event) => {
+            db = event.target.result;
+            console.log("IndexedDB با موفقیت باز و آماده استفاده است.");
+            resolve(db);
+        };
+
+        // این تابع فقط زمانی اجرا می‌شود که دیتابیس برای اولین بار ساخته شود یا نسخه آن (DB_VERSION) افزایش یابد.
+        request.onupgradeneeded = (event) => {
+            console.log("رویداد onupgradeneeded فعال شد. در حال ارتقا ساختار دیتابیس...");
+            const db = event.target.result;
+            
+            // *** قدم 2: منطق ارتقا را هوشمند می‌کنیم ***
+            // ابتدا بررسی می‌کنیم که آیا ساختار قدیمی (و اشتباه) وجود دارد یا نه
+            if (db.objectStoreNames.contains(STORE_NAME)) {
+                // اگر وجود داشت، آن را حذف می‌کنیم تا راه برای ساختار جدید باز شود.
+                db.deleteObjectStore(STORE_NAME);
+                console.log("Object store قدیمی 'files' پیدا و برای ارتقا حذف شد.");
+            }
+            
+            // حالا ساختار جدید و صحیح را ایجاد می‌کنیم.
+            // با حذف keyPath، به IndexedDB اجازه می‌دهیم کلید را به صورت خودکار و خارج از آبجکت مدیریت کند.
+            // این کار مشکل اصلی شما را به طور قطعی حل می‌کند.
+            const store = db.createObjectStore(STORE_NAME, { autoIncrement: true });
+            
+            // یک ایندکس برای جستجوی فایل‌ها بر اساس زمان ایجاد می‌کنیم.
+            store.createIndex('timestamp', 'timestamp', { unique: false });
+            console.log("Object store جدید و صحیح 'files' با موفقیت ساخته شد.");
+        };
+    });
+}
+
+// 2. ذخیره کردن یک فایل در دیتابیس
+export function storeFile(file) {
+    return new Promise((resolve, reject) => {
+        if (!db) {
+            // این حالت نباید رخ دهد چون main.js منتظر اتمام initDB می‌ماند.
+            reject("دیتابیس هنوز مقداردهی اولیه نشده است.");
+            return;
+        }
+        const transaction = db.transaction([STORE_NAME], 'readwrite');
+        const store = transaction.objectStore(STORE_NAME);
+        const fileRecord = {
+            file: file,
+            name: file.name,
+            type: file.type,
+            timestamp: Date.now()
+        };
+        
+        const request = store.add(fileRecord);
+
+        request.onsuccess = (event) => {
+            // event.target.result حاوی کلید (ID) اختصاص داده شده به رکورد جدید است.
+            resolve(event.target.result); 
+        };
+
+        request.onerror = (event) => {
+            console.error("خطا در ذخیره فایل در IndexedDB:", event.target.error);
+            reject("ذخیره فایل در دیتابیس محلی ناموفق بود.");
+        };
+    });
+}
+
+// 3. بازیابی یک فایل از دیتابیس با استفاده از ID
+export function getFile(id) {
+    return new Promise((resolve, reject) => {
+        if (!db) {
+            reject("دیتابیس مقداردهی اولیه نشده است.");
+            return;
+        }
+        
+        // کلیدهای تولید شده توسط autoIncrement همیشه عددی هستند.
+        // این تبدیل، اطمینان می‌دهد که حتی اگر ID به صورت رشته ذخیره شده باشد، به درستی بازیابی شود.
+        const numericId = typeof id === 'string' ? parseInt(id, 10) : id;
+        if (isNaN(numericId)) {
+            reject("ID فایل برای بازیابی نامعتبر است.");
+            return;
+        }
+        
+        const transaction = db.transaction([STORE_NAME], 'readonly');
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(numericId);
+
+        request.onsuccess = (event) => {
+            if (event.target.result) {
+                // خود فایل که یک Blob است را باز می‌گردانیم.
+                resolve(event.target.result.file); 
+            } else {
+                reject("فایلی با این ID در دیتابیس محلی یافت نشد.");
+            }
+        };
+
+        request.onerror = (event) => {
+            console.error("خطا در بازیابی فایل:", event.target.error);
+            reject("بازیابی فایل ناموفق بود.");
+        };
+    });
+}
+
+// 4. پاک کردن فایل‌های قدیمی‌تر از یک هفته
+export function cleanupOldFiles() {
+    return new Promise((resolve, reject) => {
+        if (!db) {
+            reject("دیتابیس مقداردهی اولیه نشده است.");
+            return;
+        }
+        const transaction = db.transaction([STORE_NAME], 'readwrite');
+        const store = transaction.objectStore(STORE_NAME);
+        const index = store.index('timestamp');
+        
+        const oneWeekAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+        const range = IDBKeyRange.upperBound(oneWeekAgo);
+        
+        const request = index.openCursor(range);
+        let deletedCount = 0;
+
+        request.onsuccess = (event) => {
+            const cursor = event.target.result;
+            if (cursor) {
+                cursor.delete();
+                deletedCount++;
+                cursor.continue();
+            } else {
+                if(deletedCount > 0) console.log(`${deletedCount} فایل قدیمی و منقضی شده از IndexedDB پاک شد.`);
+                resolve();
+            }
+        };
+
+        request.onerror = (event) => {
+            console.error("خطا در پاکسازی فایل‌های قدیمی:", event.target.error);
+            reject("پاکسازی فایل‌های قدیمی ناموفق بود.");
+        };
+    });
+}

static/js/main.js

@@ -0,0 +1,703 @@
+// static/js/main.js
+
+import * as state from './state.js';
+import * as api from './api.js';
+import * as db from './db.js';
+
+// New UI module imports
+import { dom } from './ui/dom.js';
+import * as chatUI from './ui/chat.js';
+import * as modalUI from './ui/modals.js';
+import * as toolUI from './ui/tools.js';
+import * as ttsUI from './ui/tts.js';
+
+
+let currentUserStatus = {
+    isPremium: false,
+    hasBeenChecked: false,
+    fingerprint: null
+};
+
+const MAX_CHAT_SESSIONS = 150;
+
+function checkUserPremiumStatus() {
+    return currentUserStatus.isPremium;
+}
+
+async function handleFileSelection(event) {
+    const file = event.target.files[0];
+    if (!file) return;
+    
+    chatUI.showFileUploading(file.name);
+    dom.submitButton.disabled = true;
+
+    try {
+        const uploadedFileData = await api.processAndUploadFile(file);
+        state.setAttachedFile(uploadedFileData);
+        chatUI.showFileReady(file.name, file.type, uploadedFileData.blobUrl);
+    } catch (error) {
+        console.error("خطا در پردازش فایل:", error);
+        chatUI.showFileError(error.message);
+    } finally {
+        event.target.value = '';
+        toolUI.toggleFilePopupMenu(false);
+        dom.submitButton.disabled = false;
+        dom.messageInput.dispatchEvent(new Event('input'));
+    }
+}
+
+function handleNewChat() {
+    if (state.chatSessions.length >= MAX_CHAT_SESSIONS) {
+        state.chatSessions.pop();
+    }
+
+    const newSession = { id: Date.now().toString(), title: 'چت جدید', messages: [], showThoughts: false };
+    state.chatSessions.unshift(newSession);
+    state.setActiveChatId(newSession.id);
+    chatUI.renderActiveChat();
+    chatUI.renderHistoryList();
+    toolUI.updateToolsButton(null);
+    state.setActiveToolPrefix(null);
+    state.setActiveTool(null);
+    state.saveSessions();
+    ttsUI.clearAllCache();
+    ttsUI.stopAudio(); 
+}
+
+function getFullChatText(session) {
+    if (!session || !session.messages) return "";
+    return session.messages
+        .map(msg => {
+            const prefix = msg.role === 'user' ? 'کاربر' : 'مدل';
+            const textContent = msg.parts?.find(p => p.text)?.text || '[محتوای غیر متنی]';
+            return `${prefix}:\n${textContent}`;
+        })
+        .join('\n\n---\n\n');
+}
+
+function handlePremiumFeatureClick(element) {
+    if (checkUserPremiumStatus()) {
+        return true;
+    }
+    
+    const parentContainer = element.closest('.premium-locked-item');
+    if (parentContainer) {
+        parentContainer.classList.add('animate-premium-lock');
+        setTimeout(() => {
+            parentContainer.classList.remove('animate-premium-lock');
+        }, 800);
+    }
+    
+    modalUI.togglePremiumFeatureModal(true);
+    
+    return false;
+}
+
+document.addEventListener('DOMContentLoaded', async () => {
+    await db.initDB();
+    await db.cleanupOldFiles();
+
+    chatUI.initTheme();
+    ttsUI.initTtsPlayer();
+    state.loadSessions();
+
+    currentUserStatus.fingerprint = await api.getBrowserFingerprint();
+
+    if (state.chatSessions.length > MAX_CHAT_SESSIONS) {
+        state.chatSessions.length = MAX_CHAT_SESSIONS;
+        state.saveSessions();
+    }
+
+    if (state.chatSessions.length === 0 || !state.getActiveChat()) {
+        handleNewChat();
+    } else {
+        state.setActiveChatId(state.activeChatId || state.chatSessions[0].id);
+        chatUI.renderActiveChat();
+        chatUI.renderHistoryList();
+    }
+    
+    chatUI.setupMobileKeyboardFix();
+    
+    dom.newChatButton.addEventListener('click', handleNewChat);
+    dom.menuButton.addEventListener('click', () => modalUI.toggleSidebar(true));
+    dom.sidebarOverlay.addEventListener('click', () => modalUI.toggleSidebar(false));
+
+    dom.deleteAllChatsButton.addEventListener('click', () => {
+        modalUI.showConfirmModal('آیا از حذف تمام چت‌ها مطمئن هستید؟', () => {
+            state.setChatSessions([]);
+            state.setActiveChatId(null);
+            state.saveSessions();
+            handleNewChat();
+            modalUI.toggleSidebar(false);
+        });
+    });
+
+    dom.settingsButton.addEventListener('click', () => {
+        modalUI.updateSettingsUI(checkUserPremiumStatus());
+        modalUI.toggleSettingsModal(true);
+    });
+    dom.settingsModal.addEventListener('click', (e) => {
+        if (e.target === dom.settingsModal) modalUI.toggleSettingsModal(false);
+    });
+    dom.themeToggle.addEventListener('change', (e) => {
+        const newTheme = e.target.checked ? 'dark' : 'light';
+        localStorage.setItem('theme', newTheme);
+        chatUI.applyTheme(newTheme);
+    });
+
+    dom.toolsButton.addEventListener('click', (e) => {
+        if (dom.toolsButton.classList.contains('tool-selected')) return;
+        e.stopPropagation();
+        const activeChat = state.getActiveChat();
+        const toggleSwitch = dom.toolsMenu.querySelector('.toggle-switch');
+        if (activeChat && toggleSwitch) {
+            toggleSwitch.classList.toggle('active', activeChat.showThoughts);
+        }
+        toolUI.toggleToolsMenu(!dom.toolsMenu.classList.contains('active'));
+    });
+    dom.attachFileButton.addEventListener('click', (e) => {
+        e.stopPropagation();
+        toolUI.toggleFilePopupMenu(!dom.filePopupMenu.classList.contains('active'));
+    });
+
+    dom.toolsMenu.addEventListener('click', (e) => {
+        const toggleSwitch = e.target.closest('.toggle-switch');
+        if (toggleSwitch) {
+            e.stopPropagation(); 
+            if (!handlePremiumFeatureClick(toggleSwitch)) return; 
+            toggleSwitch.classList.toggle('active');
+            const activeChat = state.getActiveChat();
+            if (activeChat) {
+                activeChat.showThoughts = toggleSwitch.classList.contains('active');
+                state.saveSessions();
+            }
+            return;
+        }
+        
+        const toolItem = e.target.closest('.tool-item');
+        if (!toolItem) return;
+        if (toolItem.parentElement.classList.contains('premium-locked-item') && !handlePremiumFeatureClick(toolItem)) {
+            toolUI.toggleToolsMenu(false);
+            return;
+        }
+
+        const tool = toolItem.dataset.tool;
+        const toolName = toolItem.dataset.toolName;
+        
+        toolUI.toggleToolsMenu(false);
+        toolUI.updateToolsButton(toolName);
+        state.setActiveTool(tool);
+        
+        if (tool === 'deep-think') {
+            state.setActiveToolPrefix("شما یک محقق حرفه‌ای هستید. با بررسی عمیق و جامع، به سوال زیر یک پاسخ کامل، ساختاریافته و دقیق بدهید: ");
+            dom.messageInput.placeholder = "موضوع برای تفکر عمیق...";
+        } else if (tool === 'reasoning') {
+            state.setActiveToolPrefix("شما یک استدلال‌گر منطقی هستید. با تحلیل گام به گام و ارائه دلایل روشن، به سوال زیر پاسخ دهید: ");
+            dom.messageInput.placeholder = "موضوع برای استدلال...";
+        } else {
+            state.setActiveToolPrefix(null);
+            state.setActiveTool(null);
+        }
+        dom.messageInput.focus();
+    });
+
+    dom.clearToolSelection.addEventListener('click', (e) => {
+        e.stopPropagation();
+        state.setActiveToolPrefix(null);
+        state.setActiveTool(null);
+        toolUI.updateToolsButton(null);
+        dom.messageInput.focus();
+    });
+
+    window.addEventListener('click', (e) => {
+        if (dom.toolsMenu.classList.contains('active') && !dom.toolsMenu.contains(e.target) && !dom.toolsButton.contains(e.target)) {
+            toolUI.toggleToolsMenu(false);
+        }
+        if (dom.filePopupMenu.classList.contains('active') && !dom.filePopupMenu.contains(e.target) && !dom.attachFileButton.contains(e.target)) {
+            toolUI.toggleFilePopupMenu(false);
+        }
+    });
+    
+    dom.selectImageOption.addEventListener('click', (e) => {
+        toolUI.toggleFilePopupMenu(false);
+        if (handlePremiumFeatureClick(e.currentTarget)) dom.imageFileInput.click();
+    });
+    
+    dom.selectFileOption.addEventListener('click', (e) => {
+        toolUI.toggleFilePopupMenu(false);
+        if (handlePremiumFeatureClick(e.currentTarget)) dom.generalFileInput.click();
+    });
+    
+    dom.premiumModalCloseBtn.addEventListener('click', () => modalUI.togglePremiumFeatureModal(false));
+    dom.premiumFeatureModal.addEventListener('click', (e) => {
+        if(e.target === dom.premiumFeatureModal) modalUI.togglePremiumFeatureModal(false);
+    });
+    dom.premiumModalUpgradeBtn.addEventListener('click', () => {
+        parent.postMessage({ type: 'NAVIGATE_TO_PREMIUM', payload: { url: chatUI.PREMIUM_URL } }, '*');
+        modalUI.togglePremiumFeatureModal(false);
+    });
+
+    dom.plusModalCloseBtn.addEventListener('click', () => modalUI.togglePlusRequiredModal(false));
+    dom.plusRequiredModal.addEventListener('click', (e) => {
+        if(e.target === dom.plusRequiredModal) modalUI.togglePlusRequiredModal(false);
+    });
+
+    dom.imageFileInput.addEventListener('change', handleFileSelection);
+    dom.generalFileInput.addEventListener('change', handleFileSelection);
+
+    dom.removeImageButton.addEventListener('click', () => {
+        state.setAttachedFile(null);
+        chatUI.hideFilePreview();
+        dom.messageInput.dispatchEvent(new Event('input'));
+    });
+
+    dom.htmlPreviewCloseBtn.addEventListener('click', () => modalUI.toggleHtmlPreviewModal(false));
+    dom.htmlPreviewOverlay.addEventListener('click', () => modalUI.toggleHtmlPreviewModal(false));
+    
+    dom.messageForm.addEventListener('submit', async (e) => {
+        e.preventDefault();
+        
+        if (state.isGenerating) {
+            if (state.globalAbortController) state.globalAbortController.abort();
+            return;
+        }
+
+        // *** START: ADDED MESSAGE LIMIT CHECK ***
+        if (state.isMessageLimitReached(checkUserPremiumStatus())) {
+            chatUI.showLimitReachedUpgrade();
+            return;
+        }
+        // *** END: ADDED MESSAGE LIMIT CHECK ***
+
+        const activeChat = state.getActiveChat();
+        if (!activeChat) return;
+        
+        const userMessageText = dom.messageInput.value.trim();
+        if (!userMessageText && !state.attachedFile) return;
+
+        chatUI.setGeneratingState(true);
+        let modelBubbleOuterDiv;
+
+        try {
+            const isFirstMessageOfChat = activeChat.messages.length === 0;
+            if (isFirstMessageOfChat && dom.chatWindow.querySelector('.welcome-screen')) {
+                dom.chatWindow.querySelector('.welcome-screen').remove();
+            }
+
+            const userParts = [];
+            let fileAttachedInThisTurn = null;
+            if (state.attachedFile) {
+                fileAttachedInThisTurn = { ...state.attachedFile };
+                userParts.push({ 
+                    id: fileAttachedInThisTurn.id, blobUrl: fileAttachedInThisTurn.blobUrl,
+                    mimeType: fileAttachedInThisTurn.mimeType, name: fileAttachedInThisTurn.name, 
+                    base64Data: fileAttachedInThisTurn.base64Data 
+                });
+                chatUI.hideFilePreview();
+                state.setAttachedFile(null);
+            }
+            if (userMessageText) userParts.push({ text: userMessageText });
+            
+            const newUserMessage = { role: 'user', parts: userParts, tool: state.getActiveTool() };
+            activeChat.messages.push(newUserMessage);
+
+            // *** START: ADDED MESSAGE COUNT INCREMENT ***
+            // Increment count immediately after adding the message to the state,
+            // before making the API call.
+            state.incrementMessageCount(checkUserPremiumStatus());
+            // *** END: ADDED MESSAGE COUNT INCREMENT ***
+            
+            await chatUI.addMessageToUI(newUserMessage, activeChat.messages.length - 1, {isLastUser: true, animate: true});
+            
+            const modelPlaceholderMessage = { role: 'assistant', isTemporary: true, parts: [] };
+            activeChat.messages.push(modelPlaceholderMessage);
+            modelBubbleOuterDiv = await chatUI.addMessageToUI(modelPlaceholderMessage, activeChat.messages.length - 1, {animate: true});
+            
+            // *** START: MODIFIED - منطق پاکسازی تاریخچه اینجا اضافه شده است ***
+            const historyForApi = activeChat.messages.map((msg, index) => {
+                const isLastMessage = index === activeChat.messages.length - 1; // این پیام placeholder مدل است
+                const isUserMessageJustSent = index === activeChat.messages.length - 2; // این پیام کاربر است
+
+                // برای پیام کاربر که همین الان ارسال شده، تمام اطلاعات را نگه دار
+                if (isUserMessageJustSent) {
+                    return JSON.parse(JSON.stringify(msg));
+                }
+                // برای پیام placeholder مدل نیز کاری انجام نده
+                if (isLastMessage) {
+                    return msg;
+                }
+
+                // برای تمام پیام‌های قدیمی‌تر در تاریخچه...
+                const cleanMsg = { role: msg.role, parts: [] };
+                if (msg.parts) {
+                    msg.parts.forEach(part => {
+                        // ... فقط و فقط بخش متنی را نگه دار.
+                        if (part.text) {
+                            cleanMsg.parts.push({ text: part.text });
+                        }
+                    });
+                }
+                return cleanMsg;
+            });
+            // *** END: MODIFIED ***
+
+            const toolPrefix = state.getActiveToolPrefix();
+            const lastUserMsgInHistory = historyForApi.findLast(m => m.role === 'user');
+            const textPartInHistory = lastUserMsgInHistory.parts.find(p => p.text);
+            if (textPartInHistory) {
+                 textPartInHistory.text = (toolPrefix ? toolPrefix : '') + (textPartInHistory.text || '');
+            } else if (toolPrefix) {
+                 lastUserMsgInHistory.parts.push({ text: toolPrefix });
+            }
+
+            if (isFirstMessageOfChat && userMessageText) {
+                activeChat.title = userMessageText.substring(0, 30);
+                chatUI.renderHistoryList();
+            }
+            
+            dom.messageInput.value = '';
+            dom.messageInput.dispatchEvent(new Event('input'));
+
+            const activeTool = state.getActiveTool();
+            if (activeTool === 'deep-think' || activeTool === 'reasoning') {
+                if (activeTool === 'deep-think') toolUI.updateDeepThinkPanel({ topic: userMessageText || 'فایل ضمیمه شده' }, modelBubbleOuterDiv);
+                else if (activeTool === 'reasoning') toolUI.updateReasoningPanel({ topic: userMessageText || 'فایل ضمیمه شده' }, modelBubbleOuterDiv);
+                
+                const progressBar = modelBubbleOuterDiv.querySelector('.bar');
+
+                if (progressBar) {
+                    requestAnimationFrame(() => {
+                        progressBar.style.transition = 'width 30s ease-out';
+                        progressBar.style.width = '100%';
+                    });
+                }
+                
+                const response = await api.getChatStream(historyForApi, state.globalAbortController.signal);
+                await api.readStreamAndDisplay(response, modelBubbleOuterDiv);
+
+            } else {
+                const MAX_RETRIES = 2;
+                for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+                    if (state.globalAbortController.signal.aborted) throw new DOMException('Aborted by user', 'AbortError');
+                    
+                    const attemptController = new AbortController();
+                    const onGlobalAbort = () => attemptController.abort();
+                    state.globalAbortController.signal.addEventListener('abort', onGlobalAbort);
+
+                    try {
+                        const timeoutDuration = fileAttachedInThisTurn ? 8000 : 3000;
+                        if (attempt > 0) console.warn(`تلاش ${attempt + 1}/${MAX_RETRIES + 1}: سرور پاسخ نداد. تلاش مجدد...`);
+                        
+                        const timeoutPromise = new Promise((_, reject) => {
+                           const id = setTimeout(() => {
+                                clearTimeout(id);
+                                reject(new Error('ClientTimeout'));
+                           }, timeoutDuration);
+                        });
+
+                        const responsePromise = api.getChatStream(historyForApi, attemptController.signal);
+                        
+                        const response = await Promise.race([responsePromise, timeoutPromise]);
+                        
+                        await api.readStreamAndDisplay(response, modelBubbleOuterDiv);
+                        
+                        break;
+                    } catch (error) {
+                        attemptController.abort();
+                        if (error.name === 'AbortError') {
+                            throw error;
+                        }
+                        if (error.message === 'ClientTimeout') {
+                            if (attempt === MAX_RETRIES) {
+                                throw new Error('سرور پس از چندین تلاش پاسخگو نبود.');
+                            }
+                        } else {
+                            throw error;
+                        }
+                    } finally {
+                        state.globalAbortController.signal.removeEventListener('abort', onGlobalAbort);
+                    }
+                }
+            }
+
+        } catch (error) {
+            if (error.name !== 'AbortError') {
+                console.error("خطا در هنگام تولید پیام:", error);
+                if (modelBubbleOuterDiv) {
+                    chatUI.displayError(modelBubbleOuterDiv, error.message || 'یک خطای ناشناخته رخ داد.');
+                }
+            } else {
+                 if (modelBubbleOuterDiv && !modelBubbleOuterDiv.querySelector('.message-content')?.innerText.includes('متوقف شد')) {
+                     const contentArea = modelBubbleOuterDiv.querySelector('.message-content') || modelBubbleOuterDiv;
+                     contentArea.innerHTML += '<p class="text-xs text-slate-500 mt-2 text-center p-4">-- عملیات متوقف شد --</p>';
+                 }
+            }
+        } finally {
+            chatUI.resetState();
+            state.saveSessions();
+            state.setActiveToolPrefix(null);
+            state.setActiveTool(null);
+            toolUI.updateToolsButton(null);
+        }
+    });
+    
+    dom.chatWindow.addEventListener('click', async (e) => {
+        const button = e.target.closest('.action-button');
+        if (!button) return;
+        const action = button.dataset.action;
+        const messageEntry = button.closest('.message-entry');
+        if (!messageEntry) return;
+        const messageIndex = parseInt(messageEntry.dataset.index, 10);
+        const activeChat = state.getActiveChat();
+        if (!activeChat || isNaN(messageIndex)) return;
+        const message = activeChat.messages[messageIndex];
+        if (action === 'copy') {
+            const textToCopy = message.parts?.find(p => p.text)?.text || '';
+            if (textToCopy) navigator.clipboard.writeText(textToCopy).then(() => chatUI.showCopyFeedback(button));
+        } else if (action === 'like' || action === 'dislike') {
+            chatUI.handleLikeDislike(button, messageEntry);
+        } else if (action === 'speak') {
+            const audioState = ttsUI.getAudioState();
+            if (audioState.messageIndex === messageIndex && (audioState.status === 'running' || audioState.status === 'suspended')) {
+                ttsUI.stopAudio();
+                return;
+            }
+            if (ttsUI.hasCacheForMessage(messageIndex)) {
+                ttsUI.playFromCache(messageIndex, button);
+                return;
+            }
+            const fullText = message.parts?.find(p => p.text)?.text;
+            if (!fullText) return;
+            const codeBlockRegex = /```[\s\S]*?```/g;
+            const textToSpeak = fullText.replace(codeBlockRegex, '').trim();
+            if (!textToSpeak) {
+                alert("محتوای متنی برای خواندن وجود ندارد (فقط کد شناسایی شد).");
+                return;
+            }
+            ttsUI.stream(messageIndex, textToSpeak, button);
+        } else if (action === 'regenerate') {
+            if (state.isGenerating) return;
+            chatUI.setGeneratingState(true);
+            const lastModelMessageIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'assistant');
+            if (messageIndex === lastModelMessageIndex) {
+                ttsUI.clearCacheForMessage(messageIndex);
+                activeChat.messages.length = messageIndex;
+                messageEntry.remove();
+                const lastUserMessageIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'user');
+                if (lastUserMessageIndex !== -1) {
+                    const lastUserMessageElement = dom.chatWindow.querySelector(`.message-entry[data-index="${lastUserMessageIndex}"]`);
+                    if (lastUserMessageElement) chatUI.updateMessageActions(lastUserMessageElement, activeChat.messages[lastUserMessageIndex], true, false);
+                }
+                const modelPlaceholderMessage = { role: 'assistant', isTemporary: true, parts: [] };
+                activeChat.messages.push(modelPlaceholderMessage);
+                const newModelBubble = await chatUI.addMessageToUI(modelPlaceholderMessage, activeChat.messages.length - 1, { animate: true });
+                try {
+                    const lastUserMessage = activeChat.messages.findLast(m => m.role === 'user');
+                    const lastTool = lastUserMessage?.tool;
+
+                    // *** START: MODIFIED - اعمال منطق پاکسازی به بازسازی ***
+                    const historyForApi = activeChat.messages.map((msg, index) => {
+                        if (index === activeChat.messages.length - 1) return msg; // placeholder
+                        if (index === activeChat.messages.length - 2) return JSON.parse(JSON.stringify(msg)); // user message
+                        const cleanMsg = { role: msg.role, parts: [] };
+                        if (msg.parts) msg.parts.forEach(part => { if (part.text) cleanMsg.parts.push({ text: part.text }); });
+                        return cleanMsg;
+                    });
+                    // *** END: MODIFIED ***
+                    
+                    if (lastTool === 'deep-think' || lastTool === 'reasoning') {
+                        if (lastTool === 'deep-think') toolUI.updateDeepThinkPanel({ topic: lastUserMessage.parts.find(p=>p.text)?.text || 'فایل ضمیمه شده' }, newModelBubble);
+                        if (lastTool === 'reasoning') toolUI.updateReasoningPanel({ topic: lastUserMessage.parts.find(p=>p.text)?.text || 'فایل ضمیمه شده' }, newModelBubble);
+                        const progressBar = newModelBubble.querySelector('.bar');
+                        if (progressBar) {
+                            requestAnimationFrame(() => {
+                                progressBar.style.transition = 'width 30s ease-out';
+                                progressBar.style.width = '100%';
+                            });
+                        }
+                        const response = await api.getChatStream(historyForApi, state.globalAbortController.signal);
+                        await api.readStreamAndDisplay(response, newModelBubble);
+                    } else {
+                        const response = await api.getChatStream(historyForApi, state.globalAbortController.signal);
+                        await api.readStreamAndDisplay(response, newModelBubble);
+                    }
+                } catch(error) {
+                    if (error.name !== 'AbortError') console.error("Regeneration failed:", error);
+                } finally {
+                    chatUI.resetState();
+                    state.saveSessions();
+                }
+            } else {
+                chatUI.resetState();
+            }
+        } else if (action === 'edit') {
+            if (state.isGenerating) return;
+            const lastUserMessageIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'user');
+            if (messageIndex === lastUserMessageIndex) {
+                const textPart = message.parts.find(p => p.text);
+                const filePart = message.parts.find(p => p.id);
+                if (textPart || filePart) {
+                    modalUI.showEditModal(textPart ? textPart.text : '', async (newText) => {
+                        chatUI.setGeneratingState(true);
+                        try {
+                            const allMessagesInDOM = dom.chatWindow.querySelectorAll('.message-entry');
+                            allMessagesInDOM.forEach(msgEl => {
+                                const idx = parseInt(msgEl.dataset.index, 10);
+                                if (idx >= messageIndex) {
+                                    ttsUI.clearCacheForMessage(idx);
+                                    msgEl.remove();
+                                }
+                            });
+                            activeChat.messages.length = messageIndex;
+                            const newParts = [];
+                            if (filePart) {
+                                const file = await db.getFile(filePart.id);
+                                const blobUrl = URL.createObjectURL(file);
+                                const base64 = await api.processAndUploadFile(file).then(d => d.base64Data);
+                                newParts.push({ ...filePart, blobUrl, base64Data: base64 });
+                            }
+                            if (newText.trim()) newParts.push({ text: newText });
+                            if (newParts.length > 0) {
+                                const editedUserMessage = { role: 'user', parts: newParts };
+                                activeChat.messages.push(editedUserMessage);
+                                await chatUI.addMessageToUI(editedUserMessage, activeChat.messages.length - 1, { isLastUser: true, animate: true });
+                            }
+                            const modelPlaceholderMessage = { role: 'assistant', isTemporary: true, parts: [] };
+                            activeChat.messages.push(modelPlaceholderMessage);
+                            const newModelBubble = await chatUI.addMessageToUI(modelPlaceholderMessage, activeChat.messages.length - 1, { animate: true });
+                            
+                            // *** START: MODIFIED - اعمال منطق پاکسازی به ویرایش ***
+                            const historyForApi = activeChat.messages.map((msg, index) => {
+                                if (index >= activeChat.messages.length - 2) return JSON.parse(JSON.stringify(msg));
+                                const cleanMsg = { role: msg.role, parts: [] };
+                                if (msg.parts) msg.parts.forEach(part => { if (part.text) cleanMsg.parts.push({ text: part.text }); });
+                                return cleanMsg;
+                            });
+                            // *** END: MODIFIED ***
+
+                            const response = await api.getChatStream(historyForApi, state.globalAbortController.signal);
+                            await api.readStreamAndDisplay(response, newModelBubble);
+                        } catch (error) {
+                             if (error.name !== 'AbortError') console.error("Edit failed:", error);
+                        } finally {
+                            chatUI.resetState();
+                            state.saveSessions();
+                        }
+                    });
+                }
+            }
+        }
+        else if (action === 'show-message-menu') {
+            modalUI.showMessageMenu(e, messageIndex, activeChat, chatUI.escapeHTML);
+        }
+    });
+
+    dom.historyItemMenu.addEventListener('click', (e) => {
+        const button = e.target.closest('.menu-item');
+        if (!button) return;
+        const action = button.dataset.action;
+        const format = button.dataset.format;
+        const sessionId = dom.historyItemMenu.dataset.sessionId;
+        const session = state.chatSessions.find(s => s.id === sessionId);
+        if (!session) return;
+        if (action === 'rename') {
+            modalUI.showRenameModal(session.title, (newTitle) => {
+                session.title = newTitle;
+                state.saveSessions();
+                chatUI.renderHistoryList();
+            });
+        } else if (action === 'delete') {
+            modalUI.showConfirmModal(`آیا از حذف گفتگوی "${session.title}" مطمئن هستید؟`, () => {
+                state.setChatSessions(state.chatSessions.filter(s => s.id !== sessionId));
+                state.saveSessions();
+                if (state.activeChatId === sessionId) {
+                    if (state.chatSessions.length > 0) {
+                        state.setActiveChatId(state.chatSessions[0].id);
+                        chatUI.renderActiveChat();
+                    } else {
+                        handleNewChat();
+                    }
+                }
+                chatUI.renderHistoryList();
+            });
+        } else if (action === 'convert-chat') {
+            const fullText = getFullChatText(session);
+            api.convertTextToFile(fullText, format, button);
+        }
+        dom.historyItemMenu.classList.remove('visible');
+    });
+
+    dom.messageItemMenu.addEventListener('click', (e) => {
+        const menu = dom.messageItemMenu;
+        const closeMenu = () => {
+            menu.classList.remove('visible');
+            setTimeout(() => { menu.classList.add('hidden'); }, 300);
+        };
+        if (e.target === dom.messageItemMenuOverlay) {
+            closeMenu();
+            return;
+        }
+        const button = e.target.closest('.menu-item');
+        if (!button) return;
+        const action = button.dataset.action;
+        const format = button.dataset.format;
+        const messageIndex = parseInt(menu.dataset.messageIndex, 10);
+        const activeChat = state.getActiveChat();
+        if (!activeChat || isNaN(messageIndex)) {
+            closeMenu();
+            return;
+        }
+        const message = activeChat.messages[messageIndex];
+        if (action === 'delete-message') {
+            modalUI.showConfirmModal('آیا از حذف این پیام مطمئن هستید؟', () => {
+                state.deleteMessage(activeChat.id, messageIndex);
+                ttsUI.clearCacheForMessage(messageIndex);
+                chatUI.renderActiveChat();
+            });
+        } else if (action === 'convert-message') {
+            const textContent = message.parts?.find(p => p.text)?.text || '';
+            if (textContent) api.convertTextToFile(textContent, format, button);
+            else alert('محتوای متنی برای تبدیل وجود ندارد.');
+        }
+        closeMenu();
+    });
+    
+    dom.messageInput.addEventListener('input', () => {
+        chatUI.adjustTextareaHeight(dom.messageInput);
+        if (dom.messageInput.value.trim().length > 0 || state.attachedFile) {
+            dom.submitButton.classList.add('active');
+        } else {
+            dom.submitButton.classList.remove('active');
+        }
+    });
+
+    dom.editInput.addEventListener('input', () => {
+        chatUI.adjustTextareaHeight(dom.editInput);
+    });
+    
+    window.addEventListener('message', (event) => {
+        if (event.data && event.data.type === 'USER_DATA_RESPONSE_SIMPLE_CHECK') {
+            const PREMIUM_PAGE_ID = '1149636';
+            let isUserPremium = false;
+            if (event.data.payload) {
+                try {
+                    const userObject = JSON.parse(event.data.payload);
+                    if (userObject && userObject.isLogin && userObject.accessible_pages) {
+                        if (userObject.accessible_pages.includes(PREMIUM_PAGE_ID) || userObject.accessible_pages.includes(parseInt(PREMIUM_PAGE_ID))) {
+                            isUserPremium = true;
+                        }
+                    }
+                } catch (e) { console.error("Error parsing user data from parent:", e); }
+            }
+            currentUserStatus.isPremium = isUserPremium;
+            currentUserStatus.hasBeenChecked = true;
+            if (!dom.settingsModal.classList.contains('hidden')) {
+                modalUI.updateSettingsUI(isUserPremium);
+            }
+        }
+    });
+
+    parent.postMessage({ type: 'REQUEST_USER_DATA_SIMPLE_CHECK' }, '*');
+});
+
+window.handleSuggestionClick = chatUI.handleSuggestionClick;

static/js/state.js

@@ -0,0 +1,204 @@
+// static/js/state.js
+
+export let chatSessions = [];
+export let activeChatId = null;
+export let attachedFile = null;
+export let isGenerating = false;
+export let globalAbortController = null;
+export let currentUploadXHR = null; // این متغیر دیگر برای آپلود استفاده نمی‌شود اما برای لغو پردازش فایل نگه داشته می‌شود
+export let activeToolPrefix = null;
+export let activeTool = null;
+
+// *** START: ADDED FOR MESSAGE LIMIT ***
+const DAILY_MESSAGE_LIMIT = 10;
+const MESSAGE_LIMIT_KEY = 'alphaChatDailyLimit';
+
+/**
+ * Gets the current date as a formatted string (YYYY-MM-DD).
+ * @returns {string} The formatted date string.
+ */
+function getTodayDateString() {
+    const today = new Date();
+    const year = today.getFullYear();
+    const month = String(today.getMonth() + 1).padStart(2, '0');
+    const day = String(today.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+
+/**
+ * Retrieves usage data from localStorage.
+ * @returns {{count: number, date: string}} The usage data object.
+ */
+function getUsageData() {
+    try {
+        const saved = localStorage.getItem(MESSAGE_LIMIT_KEY);
+        return saved ? JSON.parse(saved) : { count: 0, date: getTodayDateString() };
+    } catch (e) {
+        console.error("Failed to parse usage data from localStorage:", e);
+        return { count: 0, date: getTodayDateString() };
+    }
+}
+
+/**
+ * Saves usage data to localStorage.
+ * @param {{count: number, date: string}} data The usage data object to save.
+ */
+function saveUsageData(data) {
+    try {
+        localStorage.setItem(MESSAGE_LIMIT_KEY, JSON.stringify(data));
+    } catch (e) {
+        console.error("Failed to save usage data to localStorage:", e);
+    }
+}
+
+/**
+ * Checks if the daily message limit has been reached for a free user.
+ * @param {boolean} isPremium - Whether the current user is premium.
+ * @returns {boolean} - True if the limit is reached, otherwise false.
+ */
+export function isMessageLimitReached(isPremium) {
+    if (isPremium) {
+        return false; // Premium users have no limit.
+    }
+
+    let usageData = getUsageData();
+    const today = getTodayDateString();
+
+    if (usageData.date !== today) {
+        // It's a new day, reset the counter.
+        usageData = { count: 0, date: today };
+        saveUsageData(usageData);
+    }
+
+    return usageData.count >= DAILY_MESSAGE_LIMIT;
+}
+
+/**
+ * Increments the message count for a free user for the current day.
+ * @param {boolean} isPremium - Whether the current user is premium.
+ */
+export function incrementMessageCount(isPremium) {
+    if (isPremium) {
+        return; // Don't track for premium users.
+    }
+
+    let usageData = getUsageData();
+    const today = getTodayDateString();
+
+    if (usageData.date !== today) {
+        // If the day changed between the check and the increment, reset first.
+        usageData = { count: 1, date: today };
+    } else {
+        usageData.count += 1;
+    }
+
+    saveUsageData(usageData);
+}
+// *** END: ADDED FOR MESSAGE LIMIT ***
+
+
+export function setActiveTool(toolName) {
+    activeTool = toolName;
+}
+
+export function getActiveTool() {
+    return activeTool;
+}
+
+export function setActiveToolPrefix(prefix) {
+    activeToolPrefix = prefix;
+}
+
+export function getActiveToolPrefix() {
+    return activeToolPrefix;
+}
+
+export function setChatSessions(newSessions) {
+    chatSessions = newSessions;
+}
+
+export function setActiveChatId(id) {
+    activeChatId = id;
+}
+
+export function setAttachedFile(file) {
+    attachedFile = file;
+}
+
+export function setGenerating(status) {
+    isGenerating = status;
+}
+
+export function setGlobalAbortController(controller) {
+    globalAbortController = controller;
+}
+
+export function setCurrentUploadXHR(xhr) {
+    currentUploadXHR = xhr;
+}
+
+export function getActiveChat() {
+    return chatSessions.find(s => s.id === activeChatId);
+}
+
+export function saveSessions() {
+    try {
+        const sessionsToSave = JSON.parse(JSON.stringify(chatSessions));
+        
+        sessionsToSave.forEach(session => {
+            session.messages.forEach(message => {
+                if (message.parts) {
+                    message.parts.forEach(part => {
+                        if (part.base64Data) {
+                            delete part.base64Data;
+                        }
+                        if (part.blobUrl) {
+                            delete part.blobUrl;
+                        }
+                    });
+                }
+            });
+        });
+
+        localStorage.setItem('alphaChatSessions', JSON.stringify(sessionsToSave));
+    } catch (e) {
+        console.error("Failed to save sessions to localStorage:", e);
+    }
+}
+
+export function loadSessions() {
+    try {
+        const saved = localStorage.getItem('alphaChatSessions');
+        chatSessions = saved ? JSON.parse(saved) : [];
+        chatSessions.forEach(session => {
+            if (session.showThoughts === undefined) {
+                session.showThoughts = false;
+            }
+            // *** START: MODIFIED - افزودن فیلد جدید به پیام‌های قدیمی برای سازگاری ***
+            session.messages.forEach(message => {
+                if (message.role === 'assistant' && message.wasGeneratedWithThoughts === undefined) {
+                    message.wasGeneratedWithThoughts = false; 
+                }
+            });
+            // *** END: MODIFIED ***
+        });
+    } catch (e) {
+        console.error("Failed to load sessions from localStorage:", e);
+        chatSessions = [];
+    }
+}
+
+export function findLastIndex(array, predicate) {
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (predicate(array[i])) { return i; }
+    }
+    return -1;
+}
+
+export function deleteMessage(chatId, messageIndex) {
+    const chat = chatSessions.find(s => s.id === chatId);
+    if (chat && chat.messages[messageIndex]) {
+        chat.messages.splice(messageIndex, 1);
+        saveSessions();
+    }
+}