/* * ThunderAI [https://micz.it/thunderbird-addon-thunderai/] * Copyright (C) 2024 - 2026 Mic (m@micz.it) * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ import { mzta_script } from './js/mzta-chatgpt.js'; import { prefs_default, getDynamicSettingsDefaults } from './options/mzta-options-default.js'; import { mzta_Menus } from './js/mzta-menus.js'; import { taLogger } from './js/mzta-logger.js'; import { getCurrentIdentity, getOriginalBody, replaceBody, setBody, i18nConditionalGet, generateCallID, migrateCustomPromptsStorage, migrateDefaultPromptsPropStorage, getGPTWebModelString, getTagsList, createTag, assignTagsToMessage, checkIfTagLabelExists, getActiveSpecialPromptsIDs, checkSparksPresence, getMessages, getMailBody, extractJsonObject, sanitizeChatGPTModelData, sanitizeChatGPTWebCustomData, stripHtmlKeepLines, htmlBodyToPlainText, convertNewlinesToParagraphs, getConnectionType, hasSpecificIntegration, } from './js/mzta-utils.js'; import { taPromptUtils } from './js/mzta-utils-prompt.js'; import { mzta_specialCommand } from './js/mzta-special-commands.js'; import { getSpamFilterPrompt, migrateMenuOrderAlphabetic } from './js/mzta-prompts.js'; import { taSpamReport } from './js/mzta-spamreport.js'; import { taSummaryStore } from './js/mzta-summarystore.js'; import { taTranslationStore } from './js/mzta-translationstore.js'; import { taWorkingStatus } from './js/mzta-working-status.js'; import { addTags_getExclusionList, checkExcludedTag } from './js/mzta-addatags-exclusion-list.js'; browser.runtime.onInstalled.addListener(({ reason, previousVersion }) => { // console.log(">>>>>>>>>>> onInstalled: " + JSON.stringify(reason) + ", previousVersion: " + previousVersion); if (reason === "install" || (reason === "update" && (previousVersion.startsWith("2.") || previousVersion.startsWith("1."))) || (reason === "update" && ((previousVersion.startsWith("3.") && parseInt(previousVersion.split(".")[1]) <= 2))) //|| (reason === "update") // only for testing ) { browser.tabs.create({ url: "/pages/onboarding/onboarding.html" }); } }); await migrateCustomPromptsStorage(); await migrateDefaultPromptsPropStorage(); var original_html = ''; var modified_html = ''; let _process_incoming = false; let _sparks_presence = false; let prefs_init = {}; await reload_pref_init(); let taLog = new taLogger("mzta-background",prefs_init.do_debug); taWorkingStatus.taLog = taLog; let spamReport = new taSpamReport(prefs_init.do_debug); let summaryStore = new taSummaryStore(prefs_init.do_debug); let translationStore = new taTranslationStore(prefs_init.do_debug); let special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: doGetSparkFeature(prefs_init.get_calendar_event), get_calendar_event_from_clipboard: doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard), get_task: doGetSparkFeature(prefs_init.get_task), spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); browser.composeScripts.register({ js: [{file: "/js/mzta-compose-script.js"}] }); // Register the message display script for all newly opened message tabs. messenger.messageDisplayScripts.register({ js: [{ file: "js/mzta-compose-script.js" }] }); browser.contentScripts.register({ matches: ["https://*.chatgpt.com/*"], js: [{file: "js/mzta-chatgpt-loader.js"}], runAt: "document_idle" }); // Listen for shortcut command messenger.commands.onCommand.addListener((command, tab) => { if (command === "_thunderai__do_action") { handleShortcut(tab); } }); async function handleShortcut(tab) { taLog.log("Shortcut triggered!"); if(!["mail", "messageCompose","messageDisplay"].includes(tab.type)){ return; } switch (tab.type) { case "mail": case "messageDisplay": browser.messageDisplayAction.openPopup(); break; case "messageCompose": browser.composeAction.openPopup(); break; default: break; } } function preparePopupMenu(tab) { let output = {}; output.lastShortcutTabId = tab.id; output.lastShortcutTabType = tab.type; output.lastShortcutPromptsData = menus.shortcutMenu; output.lastShortcutFiltering = 0; switch (tab.type) { case "mail": case "messageDisplay": output.lastShortcutFiltering = 1; break; case "messageCompose": output.lastShortcutFiltering = 2; break; default: break; } return output; } async function _reload_menus() { let prefs_reload = await browser.storage.sync.get({add_tags: prefs_default.add_tags, get_calendar_event: prefs_default.get_calendar_event, get_calendar_event_from_clipboard: prefs_default.get_calendar_event_from_clipboard, get_task: prefs_default.get_task, connection_type: prefs_default.connection_type, spamfilter: prefs_default.spamfilter, summarize: prefs_default.summarize, translate: prefs_default.translate}); let getCalendarEvent = doGetSparkFeature(prefs_reload.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_reload.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_reload.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_reload.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_reload.spamfilter, summarize: prefs_reload.summarize, translate: prefs_reload.translate, is_chatgpt_web: (prefs_reload.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); taLog.log("Reloading menus"); return true; } async function _getActiveSpecialIds() { let prefs_reload = await browser.storage.sync.get({add_tags: prefs_default.add_tags, get_calendar_event: prefs_default.get_calendar_event, get_calendar_event_from_clipboard: prefs_default.get_calendar_event_from_clipboard, get_task: prefs_default.get_task, connection_type: prefs_default.connection_type, spamfilter: prefs_default.spamfilter, summarize: prefs_default.summarize, translate: prefs_default.translate}); let getCalendarEvent = doGetSparkFeature(prefs_reload.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_reload.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_reload.get_task); return getActiveSpecialPromptsIDs({ addtags: prefs_reload.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_reload.spamfilter, summarize: prefs_reload.summarize, translate: prefs_reload.translate, is_chatgpt_web: (prefs_reload.connection_type === "chatgpt_web") }); } async function _assign_tags(_data, create_new_tags = true, exclusions_exact_match = false) { let all_tags_list = await getTagsList(); all_tags_list = all_tags_list[1]; // console.log(">>>>>>>>>>>>>>> all_tags_list: " + JSON.stringify(all_tags_list)); taLog.log("assign_tags data: " + JSON.stringify(_data)); let new_tags = []; let add_tags_exclusions_list = await addTags_getExclusionList(); taLog.log("add_tags_exclusions_list: " + JSON.stringify(add_tags_exclusions_list)); const tags_final = _data.tags.filter(tag => !add_tags_exclusions_list.some(exclusion => checkExcludedTag(tag, exclusion, exclusions_exact_match) ) ); if(!create_new_tags){ taLog.log("Not creating new tags, only assigning existing ones..."); } for (const tag of tags_final) { // console.log(">>>>>>>>>>>>>>> tag: " + JSON.stringify(tag)); if (create_new_tags && !checkIfTagLabelExists(tag, all_tags_list)) { taLog.log("Creating tag: " + tag); await createTag(tag); } new_tags.push(tag); } let added_tags = await assignTagsToMessage(_data.messageId, new_tags); taLog.log("Assigned tags: " + JSON.stringify(added_tags)); } messenger.runtime.onMessage.addListener((message, sender, sendResponse) => { // Check what type of message we have received and invoke the appropriate // handler function. if (message && message.hasOwnProperty("command")){ switch (message.command) { case 'initSummary': async function _initSummary() { try { let tabId = sender.tab.id; let prefs = await browser.storage.sync.get({ summarize: prefs_default.summarize, summarize_auto: prefs_default.summarize_auto, summarize_display_mode: prefs_default.summarize_display_mode, summarize_max_display_length: prefs_default.summarize_max_display_length }); if (!prefs.summarize) return; let message = await browser.messageDisplay.getDisplayedMessage(tabId); if (!message) return; // Always show cached summary if available, regardless of summarize_auto let cachedSummary = await summaryStore.loadSummary(message.headerMessageId); if (cachedSummary && !cachedSummary.error) { browser.tabs.sendMessage(tabId, { command: "showSummary", data: { ...cachedSummary, maxDisplayLength: prefs.summarize_max_display_length } }); return; } if (await summaryStore.isProcessing(message.headerMessageId)) { browser.tabs.sendMessage(tabId, { command: "showSummaryGenerating" }); return; } // If summarize_auto is disabled, don't show button or auto-generate if (prefs.summarize_auto === 0) return; // Auto mode (summarize_auto === 2) always generates inline if (prefs.summarize_auto === 2) { _generateSummaryForMessage(message.headerMessageId, tabId); return; } // Manual button mode (summarize_auto === 1) if (prefs.summarize_display_mode === 'inline') { browser.tabs.sendMessage(tabId, { command: "showSummaryButton", headerMessageId: message.headerMessageId }); } else { browser.tabs.sendMessage(tabId, { command: "showSummaryButton", headerMessageId: message.headerMessageId, webchat: true }); } } catch (e) { taLog.error("Error in initSummary: " + e); } } _initSummary(); break; case 'triggerSummaryGeneration': async function _triggerSummaryGeneration(message) { let tabId = sender.tab.id; await _generateSummaryForMessage(message.headerMessageId, tabId); } _triggerSummaryGeneration(message); break; case 'triggerSummaryWebchat': async function _triggerSummaryWebchat(message) { let tabId = sender.tab.id; await _openSummaryWebchat(message.headerMessageId, tabId); } _triggerSummaryWebchat(message); break; case 'generate_summary': async function _generate_summary(message) { await _generateSummaryForMessage(message.headerMessageId, message.tabId); } _generate_summary(message); break; case 'refreshSummary': async function _refreshSummary(message) { let tabId = sender.tab.id; await summaryStore.removeSummary(message.headerMessageId); let prefs_refresh = await browser.storage.sync.get({ summarize_display_mode: prefs_default.summarize_display_mode }); if (prefs_refresh.summarize_display_mode === 'webchat') { await _openSummaryWebchat(message.headerMessageId, tabId); } else { await _generateSummaryForMessage(message.headerMessageId, tabId); } } _refreshSummary(message); break; case 'removeSummary': summaryStore.removeSummary(message.headerMessageId); break; case 'chatgpt_saveSummary': async function _saveSummaryFromWebchat(msg) { try { let summaryHtml = msg.text.trim(); let cleanedSummary = cleanSummaryText(msg.text); const summaryData = { summary: cleanedSummary, summary_html: summaryHtml, summary_date: new Date(), headerMessageId: msg.headerMessageId }; await summaryStore.saveSummary(summaryData, msg.headerMessageId); let prefs_summary = await browser.storage.sync.get({ summarize_max_display_length: prefs_default.summarize_max_display_length }); try { browser.tabs.sendMessage(msg.tabId, { command: "showSummary", data: { ...summaryData, maxDisplayLength: prefs_summary.summarize_max_display_length } }); } catch (e) { taLog.error("Error sending showSummary to tab: " + e); } } catch (error) { console.error("[ThunderAI] Error saving summary from webchat:", error); } } _saveSummaryFromWebchat(message); break; // case 'chatgpt_open': // openChatGPT(message.prompt,message.action,message.tabId); // return true; case 'initTranslation': async function _initTranslation() { try { let tabId = sender.tab.id; let prefs = await browser.storage.sync.get({ translate: prefs_default.translate, translate_auto: prefs_default.translate_auto, translate_max_display_length: prefs_default.translate_max_display_length }); if (!prefs.translate) return; let message = await browser.messageDisplay.getDisplayedMessage(tabId); if (!message) return; // Always show cached translation if available, regardless of translate_auto let cachedTranslation = await translationStore.loadTranslation(message.headerMessageId); if (cachedTranslation && !cachedTranslation.error) { browser.tabs.sendMessage(tabId, { command: "showTranslation", data: { ...cachedTranslation, maxDisplayLength: prefs.translate_max_display_length } }); return; } if (await translationStore.isProcessing(message.headerMessageId)) { browser.tabs.sendMessage(tabId, { command: "showTranslationGenerating" }); return; } // If translate_auto is disabled, don't show button or auto-generate if (prefs.translate_auto === 0) return; // Auto mode (translate_auto === 2) always generates inline if (prefs.translate_auto === 2) { _generateTranslationForMessage(message.headerMessageId, tabId); return; } // Manual button mode (translate_auto === 1) browser.tabs.sendMessage(tabId, { command: "showTranslationButton", headerMessageId: message.headerMessageId }); } catch (e) { taLog.error("Error in initTranslation: " + e); } } _initTranslation(); break; case 'triggerTranslationGeneration': async function _triggerTranslationGeneration(message) { let tabId = sender.tab.id; let prefs_tl = await browser.storage.sync.get({ translate_lang: prefs_default.translate_lang, default_chatgpt_lang: prefs_default.default_chatgpt_lang }); const lang_tl = prefs_tl.translate_lang || prefs_tl.default_chatgpt_lang || ''; if (!lang_tl) { let tabs = await browser.tabs.query({ active: true, currentWindow: true }); browser.tabs.sendMessage(tabId, { command: "sendAlert", curr_tab_type: tabs[0].type, message: browser.i18n.getMessage('translate_no_language_configured') }); browser.tabs.sendMessage(tabId, { command: "showTranslationButton", headerMessageId: message.headerMessageId }); return; } await _generateTranslationForMessage(message.headerMessageId, tabId); } _triggerTranslationGeneration(message); break; case 'refreshTranslation': async function _refreshTranslation(message) { let tabId = sender.tab.id; await translationStore.removeTranslation(message.headerMessageId); await _generateTranslationForMessage(message.headerMessageId, tabId); } _refreshTranslation(message); break; case 'removeTranslation': translationStore.removeTranslation(message.headerMessageId); break; case 'chatgpt_close': async function _closeChatGptWindow(window_id) { let prefs_close = await browser.storage.sync.get({chatgpt_win_save_position: prefs_default.chatgpt_win_save_position}); if(prefs_close.chatgpt_win_save_position){ try { let winInfo = await browser.windows.get(window_id); await browser.storage.sync.set({chatgpt_win_top: winInfo.top, chatgpt_win_left: winInfo.left}); taLog.log("Window position saved: top=" + winInfo.top + ", left=" + winInfo.left); } catch(e) { taLog.error("Error saving window position: " + e); } } return browser.windows.remove(window_id).then(() => { taLog.log("ChatGPT window closed successfully."); }).catch((error) => { taLog.error("Error closing ChatGPT window:", error); }); } return _closeChatGptWindow(message.window_id); case 'chatgpt_replaceSelectedText': async function _replaceSelectedText(tabId, text) { //console.log('chatgpt_replaceSelectedText: [' + tabId +'] ' + text) taLog.log("chatgpt_replaceSelectedText text: " + text); original_html = await getOriginalBody(tabId); let prefs_repl = await browser.storage.sync.get({composing_plain_text: prefs_default.composing_plain_text}); if(prefs_repl.composing_plain_text){ text = stripHtmlKeepLines(text); } await browser.tabs.sendMessage(tabId, { command: "replaceSelectedText", text: text, tabId: tabId }); return true; } return _replaceSelectedText(message.tabId, message.text); case 'chatgpt_replyMessage': async function _replyMessage(message) { let paragraphsHtmlString = message.text; //console.log(">>>>>>>>>>>> paragraphsHtmlString: " + paragraphsHtmlString); taLog.log("paragraphsHtmlString: " + paragraphsHtmlString); let prefs_reply = await browser.storage.sync.get({reply_type: prefs_default.reply_type, composing_plain_text: prefs_default.composing_plain_text}); if(prefs_reply.composing_plain_text){ paragraphsHtmlString = stripHtmlKeepLines(paragraphsHtmlString); } //console.log('reply_type: ' + prefs_reply.reply_type); let replyType = 'replyToAll'; // console.log(">>>>>>>>>>> chatgpt_replyMessage replyType: " + message.replyType); if (typeof message.replyType === "undefined" || message.replyType === null || message.replyType === "") { message.replyType = prefs_reply.reply_type; } if(message.replyType === 'reply_sender'){ replyType = 'replyToSender'; } taLog.log("Reply type: " + replyType); //console.log('replyType: ' + replyType); // browser.messageDisplay.getDisplayedMessage(message.tabId).then(async (mailMessage) => { // let reply_tab = await browser.compose.beginReply(mailMessage.id, replyType, { // type: "reply", // //body: paragraphsHtmlString, // isPlainText: false, // identityId: await getCurrentIdentity(mailMessage), // }) //console.log(">>>>>>>>>>>> message.mailMessageId: " + message.mailMessageId); let _mailMessage = await browser.messages.get(message.mailMessageId); let curr_idn = await getCurrentIdentity(_mailMessage) let reply_tab = await browser.compose.beginReply(_mailMessage.id, replyType, { type: "reply", //body: paragraphsHtmlString, isPlainText: false, identityId: curr_idn, }) // Wait for tab loaded. await new Promise(resolve => { const tabIsLoaded = tab => { return tab.status == "complete" && tab.url != "about:blank"; }; const listener = (tabId, changeInfo, updatedTab) => { if (tabIsLoaded(updatedTab)) { browser.tabs.onUpdated.removeListener(listener); //console.log(">>>>>>>>>>>> reply_tab: " + tabId); resolve(); } } // Early exit if loaded already if (tabIsLoaded(reply_tab)) { resolve(); } else { browser.tabs.onUpdated.addListener(listener); } }); // we need to wait for the compose windows to load the content script //setTimeout(() => browser.tabs.sendMessage(reply_tab.id, { command: "insertText", text: paragraphsHtmlString, tabId: reply_tab.id }), 500); setTimeout(async () => await replaceBody(reply_tab.id, paragraphsHtmlString), 500); return true; } return _replyMessage(message); break; case 'compose_reloadBody': async function _reloadBody(tabId) { modified_html = await getOriginalBody(tabId); await setBody(tabId, original_html); await setBody(tabId, modified_html); return true; } return _reloadBody(message.tabId); break; case 'reload_menus': return _reload_menus(); break; case 'get_active_special_ids': return _getActiveSpecialIds(); break; case 'shortcut_do_prompt': taLog.log("Executing shortcut, promptId: " + message.promptId); if (message.promptId !== 'prompt_add_tags' && specialContextMenuActions[message.promptId]) { //TODO Add an option here if you want the user to decide to use the autotagging also in the popup menu async function _shortcut_special() { let tabId = message.tabId; if (!tabId) { let tabs = await browser.tabs.query({ active: true, currentWindow: true }); if (tabs.length === 0) return false; tabId = tabs[0].id; } let displayedMessage = await browser.messageDisplay.getDisplayedMessage(tabId); if (!displayedMessage) return false; taLog.log("Displayed message found."); return specialContextMenuActions[message.promptId]([displayedMessage]); } return _shortcut_special(); } return menus.executeMenuAction(message.promptId); break; case 'popup_menu_ready': async function _popup_menu_ready() { let tabs = await browser.tabs.query({ active: true, currentWindow: true }); if(tabs.length == 0){ return false; } return preparePopupMenu(tabs[0]); //return true; } return _popup_menu_ready(); break; case 'assign_tags': async function _do_assign_tags(message) { let prefs_assign_tags = await browser.storage.sync.get({add_tags_exclusions_exact_match: prefs_default.add_tags_exclusions_exact_match}); return _assign_tags(message,true, prefs_assign_tags.add_tags_exclusions_exact_match); } return _do_assign_tags(message); break; case 'api_send_custom_text': browser.tabs.sendMessage(message.tabId, { command: "api_send_custom_text", custom_text: message.custom_text }); break; case 'checkSpamReport': if(!prefs_init.spamfilter_show_msg_panel){ return; } async function _checkSpamReport(tabId) { try { if (sender.tab.type !== 'messageDisplay' && sender.tab.type !== 'mail') return; let message = await browser.messageDisplay.getDisplayedMessage(tabId); if (!message) return; let report = await spamReport.loadReportData(message.headerMessageId); if (report) { browser.tabs.sendMessage(tabId, { command: "showSpamReport", data: report }); } else if (await spamReport.isProcessing(message.headerMessageId)) { browser.tabs.sendMessage(tabId, { command: "showSpamCheckInProgress" }); } } catch (e) { taLog.error("Error in checkSpamReport: " + e); } } _checkSpamReport(sender.tab.id); break; case 'removeSpamReport': spamReport.removeReportData(message.headerMessageId); break; case 'refreshSpamReport': _generateSpamReportForMessage(message.headerMessageId); break; default: break; } } return false; }); // Clean summary text by stripping HTML, markdown, and formatting artifacts. // Used by both inline summary generation and webchat summary save. function cleanSummaryText(text) { let cleaned = text.replace(/<\/?[^>]+(>|$)/g, ''); // strip HTML tags cleaned = cleaned.replace(/```[\s\S]*?```/g, ''); cleaned = cleaned.replace(/[\*#_~`]/g, ''); cleaned = cleaned.replace(/\s+/g, ' ').trim(); cleaned = cleaned.replace(/^Summary:\s*/i, ''); return cleaned; } // tabId is optional — if null, runs silently (background pre-cache, no UI update) // options.messageData: { message, fullMessage } — pass pre-fetched data to avoid re-querying async function _generateSummaryForMessage(headerMessageId, tabId = null, options = {}) { try { let prefs = await browser.storage.sync.get({ connection_type: prefs_default.connection_type, do_debug: prefs_default.do_debug, default_chatgpt_lang: prefs_default.default_chatgpt_lang, summarize_max_display_length: prefs_default.summarize_max_display_length, ...getDynamicSettingsDefaults(['use_specific_integration', 'connection_type']) }); let cachedSummary = await summaryStore.loadSummary(headerMessageId); if (cachedSummary && !cachedSummary.error) { if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummary", data: { ...cachedSummary, maxDisplayLength: prefs.summarize_max_display_length } }); return; } if (await summaryStore.isProcessing(headerMessageId)) { if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummaryGenerating" }); return; } await summaryStore.setProcessing(headerMessageId); taWorkingStatus.startWorking(); if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummaryGenerating" }); let message, fullMessage; if (options.messageData) { message = options.messageData.message; fullMessage = options.messageData.fullMessage; } else { const messageResult = await browser.messages.query({ headerMessageId: headerMessageId }); if (!messageResult || messageResult.messages.length === 0) { await summaryStore.saveError(headerMessageId, "Message not found"); if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummary", data: { error: true, message: "Message not found" } }); taWorkingStatus.stopWorking(); return; } message = messageResult.messages[0]; fullMessage = await browser.messages.getFull(message.id); } const connectionType = getConnectionType(prefs, {}, 'summarize'); if (connectionType === 'chatgpt_web') { const errorMsg = browser.i18n.getMessage('summarize_chatgpt_web_not_supported'); await summaryStore.saveError(headerMessageId, errorMsg); if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummary", data: { error: true, message: errorMsg } }); taWorkingStatus.stopWorking(); return; } const { promptText } = await taPromptUtils.buildSummaryPrompt([{ message, fullMessage }]); const cmd = new mzta_specialCommand({ prompt: promptText, llm: connectionType, do_debug: prefs.do_debug, config: {} }); await cmd.initWorker(); const aiResponse = await cmd.sendPrompt(); let cleanedSummary = cleanSummaryText(aiResponse); const md = window.markdownit(); let summaryHtml = md.render(aiResponse); const summaryData = { summary: cleanedSummary, summary_html: summaryHtml, summary_date: new Date(), headerMessageId: headerMessageId }; await summaryStore.saveSummary(summaryData, headerMessageId); if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummary", data: { ...summaryData, maxDisplayLength: prefs.summarize_max_display_length } }); taWorkingStatus.stopWorking(); } catch (error) { console.error("[ThunderAI] Error generating summary:", error); await summaryStore.saveError(headerMessageId, error.message || String(error)); if (tabId) browser.tabs.sendMessage(tabId, { command: "showSummary", data: { error: true, message: error.message || "Failed to generate summary" } }); taWorkingStatus.stopWorking(); } } // tabId is optional — if null, runs silently (background pre-cache, no UI update) // options.messageData: { fullMessage } — pass pre-fetched data to avoid re-querying async function _generateTranslationForMessage(headerMessageId, tabId = null, options = {}) { try { let prefs = await browser.storage.sync.get({ connection_type: prefs_default.connection_type, do_debug: prefs_default.do_debug, default_chatgpt_lang: prefs_default.default_chatgpt_lang, translate_lang: prefs_default.translate_lang, translate_max_display_length: prefs_default.translate_max_display_length, ...getDynamicSettingsDefaults(['use_specific_integration', 'connection_type']) }); let cachedTranslation = await translationStore.loadTranslation(headerMessageId); if (cachedTranslation && !cachedTranslation.error) { if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslation", data: { ...cachedTranslation, maxDisplayLength: prefs.translate_max_display_length } }); return; } const lang = prefs.translate_lang || prefs.default_chatgpt_lang || ''; if (!lang) { taLog.warn("Translation skipped: no language configured (translate_lang and default_chatgpt_lang are both empty)."); return; } if (await translationStore.isProcessing(headerMessageId)) { if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslationGenerating" }); return; } await translationStore.setProcessing(headerMessageId); taWorkingStatus.startWorking(); if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslationGenerating" }); let fullMessage; if (options.messageData) { fullMessage = options.messageData.fullMessage; } else { const messageResult = await browser.messages.query({ headerMessageId: headerMessageId }); if (!messageResult || messageResult.messages.length === 0) { await translationStore.saveError(headerMessageId, "Message not found"); if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslation", data: { error: true, message: "Message not found" } }); taWorkingStatus.stopWorking(); return; } fullMessage = await browser.messages.getFull(messageResult.messages[0].id); } const connectionType = getConnectionType(prefs, {}, 'translate'); if (connectionType === 'chatgpt_web') { const errorMsg = browser.i18n.getMessage('translate_chatgpt_web_not_supported'); await translationStore.saveError(headerMessageId, errorMsg); if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslation", data: { error: true, message: errorMsg } }); taWorkingStatus.stopWorking(); return; } const { promptText } = await taPromptUtils.buildTranslationPrompt(fullMessage); const cmd = new mzta_specialCommand({ prompt: promptText, llm: connectionType, do_debug: prefs.do_debug, config: {} }); await cmd.initWorker(); const aiResponse = await cmd.sendPrompt(); let translatedBody = ''; let translatedSubject = ''; let translationStatus = ''; try { const parsed = JSON.parse(aiResponse); translatedBody = parsed.body || ''; translatedSubject = parsed.subject || ''; translationStatus = String(parsed.status || ''); } catch (e) { translatedBody = aiResponse; } const translationData = { translated_text: translatedBody, translated_subject: translatedSubject, translation_status: translationStatus, lang: lang, headerMessageId: headerMessageId }; await translationStore.saveTranslation(translationData, headerMessageId); if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslation", data: { ...translationData, maxDisplayLength: prefs.translate_max_display_length } }); taWorkingStatus.stopWorking(); } catch (error) { console.error("[ThunderAI] Error generating translation:", error); await translationStore.saveError(headerMessageId, error.message || String(error)); if (tabId) browser.tabs.sendMessage(tabId, { command: "showTranslation", data: { error: true, message: error.message || "Failed to generate translation" } }); taWorkingStatus.stopWorking(); } } // options.messageData: { message, fullMessage, body_text, msg_text } — pass pre-fetched data to avoid re-querying // options.prefs: pass pre-fetched prefs to avoid re-querying // options.autoMove: if true, move spam messages to junk folder (default: false) async function _generateSpamReportForMessage(headerMessageId, options = {}) { try { let prefs = options.prefs || await browser.storage.sync.get({ connection_type: prefs_default.connection_type, do_debug: prefs_default.do_debug, default_chatgpt_lang: prefs_default.default_chatgpt_lang, spamfilter_threshold: prefs_default.spamfilter_threshold, ...getDynamicSettingsDefaults(['use_specific_integration', 'connection_type']), }); await spamReport.removeReportData(headerMessageId); await spamReport.setProcessing(headerMessageId); await updateSpamPanel(headerMessageId, "showSpamCheckInProgress"); let message, curr_fullMessage, msg_text, body_text; if (options.messageData) { message = options.messageData.message; curr_fullMessage = options.messageData.fullMessage; msg_text = options.messageData.msg_text; body_text = options.messageData.body_text; } else { const messageResult = await browser.messages.query({ headerMessageId: headerMessageId }); if (!messageResult || messageResult.messages.length === 0) { let err_data = await spamReport.saveError(headerMessageId, "Message not found"); await updateSpamPanel(headerMessageId, "showSpamReport", err_data); return { success: false }; } message = messageResult.messages[0]; curr_fullMessage = await browser.messages.getFull(message.id); msg_text = getMailBody(curr_fullMessage); body_text = htmlBodyToPlainText(msg_text.html); if (body_text.length == 0) { body_text = msg_text.text.replace(/\s+/g, ' ').trim(); } } let curr_prompt_spamfilter = await getSpamFilterPrompt(); let chatgpt_lang = await taPromptUtils.getDefaultLang(curr_prompt_spamfilter); let specialFullPrompt_spamfilter = await taPromptUtils.preparePrompt({ curr_prompt: curr_prompt_spamfilter, curr_message: message, chatgpt_lang: chatgpt_lang, body_text: body_text, subject_text: curr_fullMessage.headers.subject, msg_text: msg_text }); taLog.log("Special prompt: " + specialFullPrompt_spamfilter); let cmd_spamfilter = new mzta_specialCommand({ prompt: specialFullPrompt_spamfilter, llm: getConnectionType(prefs, curr_prompt_spamfilter, 'spamfilter'), custom_model: curr_prompt_spamfilter.model ? curr_prompt_spamfilter.model : '', do_debug: prefs.do_debug, config: curr_prompt_spamfilter }); await cmd_spamfilter.initWorker(); let spamfilter_result = ''; taLog.log("Sending the prompt..."); try { spamfilter_result = (await cmd_spamfilter.sendPrompt()).trim(); } catch (err) { console.error("[ThunderAI | SpamFilter] Error getting spamfilter: ", err); let err_data = await spamReport.saveError(headerMessageId, err.message || String(err)); await updateSpamPanel(headerMessageId, "showSpamReport", err_data); return { success: false }; } taLog.log("spamfilter_result: " + spamfilter_result); let jsonObj = {}; taLog.log("Decoding the AI response..."); try { jsonObj = extractJsonObject(spamfilter_result); } catch (e) { console.error("[ThunderAI | SpamFilter] Error extracting JSON from AI response: ", e); let err_data = await spamReport.saveError(headerMessageId, e.message || String(e)); await updateSpamPanel(headerMessageId, "showSpamReport", err_data); return { success: false }; } taLog.log("SpamFilter jsonObj: " + JSON.stringify(jsonObj)); let report_data = {}; report_data.report_date = new Date(); report_data.headerMessageId = headerMessageId; report_data.spamValue = jsonObj.spamValue; report_data.explanation = jsonObj.explanation; report_data.subject = curr_fullMessage.headers.subject; report_data.from = curr_fullMessage.headers.from; report_data.message_date = new Date(message.date); report_data.moved = false; report_data.SpamThreshold = prefs.spamfilter_threshold || prefs_init.spamfilter_threshold; if (options.autoMove && jsonObj.spamValue >= report_data.SpamThreshold) { taLog.log("Marking as spam [" + headerMessageId + "]"); messenger.messages.update(message.id, { junk: true }); let spamFolder = await messenger.folders.query({ accountId: message.folder.accountId, specialUse: ['junk'] }); messenger.messages.move([message.id], spamFolder[0].id); report_data.moved = true; taLog.log("Marked as spam [" + headerMessageId + "]"); } spamReport.saveReportData(report_data, headerMessageId); await updateSpamPanel(headerMessageId, "showSpamReport", report_data); return { success: true }; } catch (error) { console.error("[ThunderAI] Error generating spam report:", error); let err_data = await spamReport.saveError(headerMessageId, error.message || String(error)); await updateSpamPanel(headerMessageId, "showSpamReport", err_data); return { success: false }; } } async function _openSummaryWebchat(headerMessageId, tabId) { try { const messageResult = await browser.messages.query({ headerMessageId: headerMessageId }); if (!messageResult || messageResult.messages.length === 0) { console.error("[ThunderAI] _openSummaryWebchat: Message not found for headerMessageId:", headerMessageId); return; } const curr_message = messageResult.messages[0]; const curr_message_full = await browser.messages.getFull(curr_message.id); const connectionType = getConnectionType(await browser.storage.sync.get(prefs_default), {}, 'summarize'); if (connectionType === 'chatgpt_web') { const errorMsg = browser.i18n.getMessage('summarize_chatgpt_web_not_supported'); await summaryStore.saveError(headerMessageId, errorMsg); browser.tabs.sendMessage(tabId, { command: "showSummary", data: { error: true, message: errorMsg } }); return; } const { promptText, promptInfo } = await taPromptUtils.buildSummaryPrompt([{ message: curr_message, fullMessage: curr_message_full }]); promptInfo.headerMessageId = headerMessageId; promptInfo.summaryTabId = tabId; openChatGPT(promptText, promptInfo.action, tabId, promptInfo.name, promptInfo.need_custom_text, promptInfo); } catch (error) { console.error("[ThunderAI] Error opening summary webchat:", error); } } // Listen for messages from ThunderAI-Sparks browser.runtime.onMessageExternal.addListener((message, sender, sendResponse) => { switch (message.action) { case 'reload_menus': return _reload_menus(); break; } }); async function openChatGPT(promptText, action, curr_tabId, prompt_name = '', do_custom_text = 0, prompt_info = {}) { let prefs = await browser.storage.sync.get(prefs_default); taLog.changeDebug(prefs.do_debug); prefs = checkScreenDimensions(prefs); //console.log(">>>>>>>>>>>>>>>> prefs: " + JSON.stringify(prefs)); // console.log(">>>>>>>>>>>>>>>> prompt_info: " + JSON.stringify(prompt_info)); prefs.connection_type = getConnectionType(prefs, prompt_info); taLog.log("Prompt length: " + promptText.length); let _max_prompt_length = prefs.max_prompt_length; if(prefs.connection_type == 'chatgpt_web'){ _max_prompt_length = prefs_default.max_prompt_length; } if((_max_prompt_length > 0) && (promptText.length > _max_prompt_length)){ // Prompt too long let tabs = await browser.tabs.query({ active: true, currentWindow: true }); browser.tabs.sendMessage(curr_tabId, { command: "sendAlert", curr_tab_type: tabs[0].type, message: browser.i18n.getMessage('msg_prompt_too_long') }); return; } let mailMessage = await browser.messageDisplay.getDisplayedMessage(curr_tabId); switch(prefs.connection_type){ case 'chatgpt_web': { // We are using the ChatGPT web interface let rand_call_id = '_chatgptweb_' + generateCallID(); let call_opt = ''; let _wait_time = prefs.chatgpt_web_load_wait_time; let _base_url = "https://chatgpt.com"; let _webproject_set = false; let _custom_gpt_set = false; let _use_prompt_info_custom_gpt = false; prompt_info.chatgpt_web_model = typeof prompt_info.chatgpt_web_model === 'undefined' ? '' : prompt_info.chatgpt_web_model.trim(); prompt_info.chatgpt_web_project = typeof prompt_info.chatgpt_web_project === 'undefined' ? '' : prompt_info.chatgpt_web_project.trim(); prompt_info.chatgpt_web_custom_gpt = typeof prompt_info.chatgpt_web_custom_gpt === 'undefined' ? '' : prompt_info.chatgpt_web_custom_gpt.trim(); let _custom_model = sanitizeChatGPTModelData(prompt_info.chatgpt_web_model != '' ? prompt_info.chatgpt_web_model : prefs.chatgpt_web_model); let _web_project = sanitizeChatGPTWebCustomData(prompt_info.chatgpt_web_project != '' ? prompt_info.chatgpt_web_project : prefs.chatgpt_web_project) let _custom_gpt = sanitizeChatGPTWebCustomData(prompt_info.chatgpt_web_custom_gpt != '' ? prompt_info.chatgpt_web_custom_gpt : prefs.chatgpt_web_custom_gpt) if(prefs.chatgpt_web_tempchat){ call_opt += '&temporary-chat=true'; } if((prompt_info.chatgpt_web_model != '') || (prefs.chatgpt_web_model != '')){ call_opt += '&model=' + _custom_model; } taLog.log("[chatgpt_web] call_opt: " + call_opt); // If there is a custom gpt on the prompt, but also a web_project on the prefs, we need to use the custom gpt _use_prompt_info_custom_gpt = (prompt_info.chatgpt_web_custom_gpt != '' && prompt_info.chatgpt_web_project == ''); if(!_use_prompt_info_custom_gpt && ((prompt_info.chatgpt_web_project != '') || (prefs.chatgpt_web_project != ''))){ _base_url += _web_project; _webproject_set = true; _wait_time += 1000; } if(!_webproject_set && ((prompt_info.chatgpt_web_custom_gpt != '') || (prefs.chatgpt_web_custom_gpt != ''))){ _base_url += _custom_gpt; _custom_gpt_set = true; } let win_options = { url: _base_url + "?call_id=" + rand_call_id + call_opt, type: "popup", } applyWindowPositionAndSize(win_options, prefs); const listener = (message, sender, sendResponse) => { async function handleChatGptWeb(createdTab) { taLog.log("ChatGPT web interface script started..."); let _gpt_model = getGPTWebModelString(_custom_model); taLog.log("_custom_model: " + _custom_model); taLog.log("_gpt_model: " + _gpt_model); let originalText = prompt_info.selection_text; if((originalText == null) || (originalText == "")) { originalText = prompt_info.body_text; } let reply_type_pref = await browser.storage.sync.get({ reply_type: prefs_default.reply_type }); //console.log(">>>>>>>>>> prompt_info: " + JSON.stringify(prompt_info)); let pre_script = `let mztaWinId = `+ createdTab.windowId +`; let mztaStatusPageDesc="`+ browser.i18n.getMessage("prefs_status_page") +`"; let mztaForceCompletionDesc="`+ browser.i18n.getMessage("chatgpt_force_completion") +`"; let mztaForceCompletionTitle="`+ browser.i18n.getMessage("chatgpt_force_completion_title") +`"; let mztaDoCustomText="`+ do_custom_text +`"; let mztaPromptName="[`+ i18nConditionalGet(prompt_name) +`]"; let mztaPhDefVal="`+(prefs.placeholders_use_default_value?'1':'0')+`"; let mztaGPTModel="`+ (_custom_gpt_set ? '' : _gpt_model) +`"; let mztaDoDebug="`+(prefs.do_debug?'1':'0')+`"; let mztaUseDiffViewer="`+(prompt_info.use_diff_viewer=='1'?'1':'0')+`"; let mztaOriginalText="`+ JSON.stringify(originalText).slice(1, -1) +`"; let mztaReplyType="`+ reply_type_pref.reply_type + `"; `; taLog.log("pre_script: " + pre_script); taLog.log("Waiting " + _wait_time + " millisec"); await new Promise(resolve => setTimeout(resolve, _wait_time)); taLog.log("Waiting " + _wait_time + " millisec done"); await browser.tabs.executeScript(createdTab.id, { code: pre_script + mzta_script, matchAboutBlank: false }); // let mailMessage = await browser.messageDisplay.getDisplayedMessage(curr_tabId); let mailMessageId = -1; if(mailMessage) mailMessageId = mailMessage.id; promptText = convertNewlinesToParagraphs(promptText); browser.tabs.sendMessage(createdTab.id, { command: "chatgpt_send", prompt: promptText, action: action, tabId: curr_tabId, mailMessageId: mailMessageId, prompt_info: prompt_info}); taLog.log('[ChatGPT Web] Connection succeded!'); taLog.log("[ThunderAI] ChatGPT Web script injected successfully"); browser.runtime.onMessage.removeListener(listener); } if (message.command === "chatgpt_web_ready_" + rand_call_id) { return handleChatGptWeb(sender.tab) } return false; } browser.runtime.onMessage.addListener(listener); await browser.windows.create(win_options); } break; // chatgpt_web - END case 'chatgpt_api': { // We are using the ChatGPT API let rand_call_id2 = '_openai_' + generateCallID(); const listener2 = (message, sender, sendResponse) => { function handleChatGptApi(createdTab) { let mailMessageId2 = -1; if(mailMessage) mailMessageId2 = mailMessage.id; // check if the config is present, or give a message error if (prefs.chatgpt_api_key == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('chatgpt_empty_apikey')}); return; } if (prefs.chatgpt_model == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('chatgpt_empty_model')}); return; } //console.log(">>>>>>>>>> sender: " + JSON.stringify(sender)); browser.tabs.sendMessage(createdTab.id, { command: "api_send", prompt: promptText, action: action, tabId: curr_tabId, mailMessageId: mailMessageId2, do_custom_text: do_custom_text, prompt_info: prompt_info}); taLog.log('[OpenAI ChatGPT] Connection succeded!'); browser.runtime.onMessage.removeListener(listener2); } if (message.command === "chatgpt_api_ready_"+rand_call_id2) { return handleChatGptApi(sender.tab); } return false; } browser.runtime.onMessage.addListener(listener2); let win_options2 = { url: browser.runtime.getURL('api_webchat/index.html?llm='+prefs.connection_type+'&call_id='+rand_call_id2+'&ph_def_val='+(prefs.placeholders_use_default_value?'1':'0')+'&prompt_id='+encodeURIComponent(prompt_info.id) + '&prompt_name=' + encodeURIComponent(i18nConditionalGet(prompt_info.name))), type: "popup", } applyWindowPositionAndSize(win_options2, prefs); await browser.windows.create(win_options2); } break; // chatgpt_api - END case 'google_gemini_api': { // We are using the Google Gemini API let rand_call_id5 = '_google_gemini_' + generateCallID(); const listener5 = (message, sender, sendResponse) => { function handleChatGptApi(createdTab) { let mailMessageId5 = -1; if(mailMessage) mailMessageId5 = mailMessage.id; // check if the config is present, or give a message error if (prefs.google_gemini_api_key == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('google_gemini_empty_apikey')}); return; } if (prefs.google_gemini_model == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('google_gemini_empty_model')}); return; } //console.log(">>>>>>>>>> sender: " + JSON.stringify(sender)); browser.tabs.sendMessage(createdTab.id, { command: "api_send", prompt: promptText, action: action, tabId: curr_tabId, mailMessageId: mailMessageId5, do_custom_text: do_custom_text, prompt_info: prompt_info}); taLog.log('[Google Gemini] Connection succeded!'); browser.runtime.onMessage.removeListener(listener5); } if (message.command === "google_gemini_api_ready_"+rand_call_id5) { return handleChatGptApi(sender.tab); } return false; } browser.runtime.onMessage.addListener(listener5); let win_options5 = { url: browser.runtime.getURL('api_webchat/index.html?llm='+prefs.connection_type+'&call_id='+rand_call_id5+'&ph_def_val='+(prefs.placeholders_use_default_value?'1':'0')+'&prompt_id='+encodeURIComponent(prompt_info.id) + '&prompt_name=' + encodeURIComponent(i18nConditionalGet(prompt_info.name))), type: "popup", } applyWindowPositionAndSize(win_options5, prefs); await browser.windows.create(win_options5); } break; // google_gemini_api - END case 'ollama_api': { // We are using the Ollama API taLog.log("Ollama API window opening..."); let rand_call_id3 = '_ollama_' + generateCallID(); const listener3 = (message, sender, sendResponse) => { function handleOllamaApi(createdTab3) { taLog.log("Ollama API window ready."); taLog.log("message.window_id: " + message.window_id) taLog.log("createdTab3.id: " + createdTab3.id) // let mailMessage3 = await browser.messageDisplay.getDisplayedMessage(curr_tabId); let mailMessageId3 = -1; if(mailMessage) mailMessageId3 = mailMessage.id; taLog.log("mailMessageId3: " + mailMessageId3) // check if the config is present, or give a message error if (prefs.ollama_host == '') { browser.tabs.sendMessage(createdTab3.id, { command: "api_error", error: browser.i18n.getMessage('ollama_empty_host')}); return; } if (prefs.ollama_model == '') { browser.tabs.sendMessage(createdTab3.id, { command: "api_error", error: browser.i18n.getMessage('ollama_empty_model')}); return; } browser.tabs.sendMessage(createdTab3.id, { command: "api_send", prompt: promptText, action: action, tabId: curr_tabId, mailMessageId: mailMessageId3, do_custom_text: do_custom_text, prompt_info: prompt_info}); taLog.log('[Ollama API] Connection succeded!'); browser.runtime.onMessage.removeListener(listener3); } if (message.command === "ollama_api_ready_"+rand_call_id3) { return handleOllamaApi(sender.tab); }else{ return false; } } browser.runtime.onMessage.addListener(listener3); let win_options3 = { url: browser.runtime.getURL('api_webchat/index.html?llm='+prefs.connection_type+'&call_id='+rand_call_id3+'&ph_def_val='+(prefs.placeholders_use_default_value?'1':'0')+'&prompt_id='+encodeURIComponent(prompt_info.id) + '&prompt_name=' + encodeURIComponent(i18nConditionalGet(prompt_info.name))), type: "popup", } applyWindowPositionAndSize(win_options3, prefs); await browser.windows.create(win_options3); } break; // ollama_api - END case 'openai_comp_api': { // We are using the OpenAI Comp API let rand_call_id4 = '_openai_comp_api_' + generateCallID(); const listener4 = (message, sender, sendResponse) => { function handleOpenAICompApi(createdTab) { let mailMessageId4 = -1; if(mailMessage) mailMessageId4 = mailMessage.id; // check if the config is present, or give a message error if (prefs.openai_comp_host == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('OpenAIComp_empty_host')}); return; } if (prefs.openai_comp_model == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('OpenAIComp_empty_model')}); return; } browser.tabs.sendMessage(createdTab.id, { command: "api_send", prompt: promptText, action: action, tabId: curr_tabId, mailMessageId: mailMessageId4, do_custom_text: do_custom_text, prompt_info: prompt_info}); taLog.log('[OpenAI Comp API] Connection succeded!'); browser.runtime.onMessage.removeListener(listener4); } if (message.command === "openai_comp_api_ready_"+rand_call_id4) { return handleOpenAICompApi(sender.tab); } return false; } browser.runtime.onMessage.addListener(listener4); let win_options4 = { url: browser.runtime.getURL('api_webchat/index.html?llm='+prefs.connection_type+'&call_id='+rand_call_id4+'&ph_def_val='+(prefs.placeholders_use_default_value?'1':'0')+'&prompt_id='+encodeURIComponent(prompt_info.id) + '&prompt_name=' + encodeURIComponent(i18nConditionalGet(prompt_info.name))), type: "popup", } applyWindowPositionAndSize(win_options4, prefs); await browser.windows.create(win_options4); } break; // openai_comp_api - END case 'anthropic_api': { // We are using the Anthropic API let rand_call_id6 = '_anthropic_' + generateCallID(); const listener6 = (message, sender, sendResponse) => { function handleAnthropicApi(createdTab) { let mailMessageId6 = -1; if(mailMessage) mailMessageId6 = mailMessage.id; // check if the config is present, or give a message error if (prefs.anthropic_api_key == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('anthropic_empty_apikey')}); return; } if (prefs.anthropic_model == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('anthropic_empty_model')}); return; } if (prefs.anthropic_version == '') { browser.tabs.sendMessage(createdTab.id, { command: "api_error", error: browser.i18n.getMessage('anthropic_empty_version')}); return; } //console.log(">>>>>>>>>> sender: " + JSON.stringify(sender)); browser.tabs.sendMessage(createdTab.id, { command: "api_send", prompt: promptText, action: action, tabId: curr_tabId, mailMessageId: mailMessageId6, do_custom_text: do_custom_text, prompt_info: prompt_info}); taLog.log('[OpenAI ChatGPT] Connection succeded!'); browser.runtime.onMessage.removeListener(listener6); } if (message.command === "anthropic_api_ready_"+rand_call_id6) { return handleAnthropicApi(sender.tab); } return false; } browser.runtime.onMessage.addListener(listener6); let win_options6 = { url: browser.runtime.getURL('api_webchat/index.html?llm='+prefs.connection_type+'&call_id='+rand_call_id6+'&ph_def_val='+(prefs.placeholders_use_default_value?'1':'0')+'&prompt_id='+encodeURIComponent(prompt_info.id) + '&prompt_name=' + encodeURIComponent(i18nConditionalGet(prompt_info.name))), type: "popup", } applyWindowPositionAndSize(win_options6, prefs); await browser.windows.create(win_options6); } break; // anthropic_api - END default: taLog.error("Unknown API connection type: " + prefs.connection_type); break; } } function checkScreenDimensions(prefs){ let width = window.screen.width - 50; let height = window.screen.height - 50; if(prefs.chatgpt_win_height > height) prefs.chatgpt_win_height = height - 50; if(prefs.chatgpt_win_width > width) prefs.chatgpt_win_width = width - 50; return prefs; } function applyWindowPositionAndSize(win_options, prefs){ if((prefs.chatgpt_win_width != '') && (prefs.chatgpt_win_height != '') && (prefs.chatgpt_win_width != 0) && (prefs.chatgpt_win_height != 0)){ win_options.width = prefs.chatgpt_win_width; win_options.height = prefs.chatgpt_win_height; taLog.log("Applying saved window dimensions: width=" + prefs.chatgpt_win_width + ", height=" + prefs.chatgpt_win_height); } if((prefs.chatgpt_win_top != '') && (prefs.chatgpt_win_left != '')){ win_options.top = prefs.chatgpt_win_top; win_options.left = prefs.chatgpt_win_left; taLog.log("Applying saved window position: top=" + prefs.chatgpt_win_top + ", left=" + prefs.chatgpt_win_left); } return win_options; } function doGetSparkFeature(spark_feature_active) { if(spark_feature_active) { return (_sparks_presence == 1); } else { return false; } } async function reload_pref_init(){ prefs_init = await browser.storage.sync.get({ do_debug: prefs_default.do_debug, add_tags: prefs_default.add_tags, get_calendar_event: prefs_default.get_calendar_event, get_calendar_event_from_clipboard: prefs_default.get_calendar_event_from_clipboard, get_task: prefs_default.get_task, connection_type: prefs_default.connection_type, add_tags_auto: prefs_default.add_tags_auto, add_tags_auto_force_existing: prefs_default.add_tags_auto_force_existing, add_tags_auto_only_inbox: prefs_default.add_tags_auto_only_inbox, spamfilter: prefs_default.spamfilter, summarize: prefs_default.summarize, summarize_auto: prefs_default.summarize_auto, translate: prefs_default.translate, translate_auto: prefs_default.translate_auto, spamfilter_threshold: prefs_default.spamfilter_threshold, spamfilter_show_msg_panel: prefs_default.spamfilter_show_msg_panel, dynamic_menu_force_enter: prefs_default.dynamic_menu_force_enter, chatgpt_win_save_position: prefs_default.chatgpt_win_save_position, ...getDynamicSettingsDefaults(['use_specific_integration', 'connection_type']) }); _process_incoming = prefs_init.add_tags_auto || prefs_init.spamfilter || (prefs_init.summarize && prefs_init.summarize_auto === 3) || (prefs_init.translate && prefs_init.translate_auto === 3); _sparks_presence = await checkSparksPresence(); } // Register the listener for storage changes function setupStorageChangeListener() { browser.storage.onChanged.addListener((changes, areaName) => { // Check if the change happened in the 'sync' storage area if (areaName === 'sync') { // Process 'add_tags' changes if (changes.add_tags) { const newTags = changes.add_tags.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: newTags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'get_calendar_event' changes if (changes.get_calendar_event) { const newCalendarEvent = changes.get_calendar_event.newValue; let getCalendarEvent = doGetSparkFeature(newCalendarEvent); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'get_calendar_event_from_clipboard' changes if (changes.get_calendar_event_from_clipboard) { const newCalendarEventFromClipboard = changes.get_calendar_event_from_clipboard.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(newCalendarEventFromClipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'get_task' changes if (changes.get_task) { const newTask = changes.get_task.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(newTask); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'spamfilter' changes if (changes.spamfilter) { const newSpamfilter = changes.spamfilter.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: newSpamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'summarize' changes if (changes.summarize) { const newSummarize = changes.summarize.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: newSummarize, translate: prefs_init.translate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'translate' changes if (changes.translate) { const newTranslate = changes.translate.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: newTranslate, is_chatgpt_web: (prefs_init.connection_type === "chatgpt_web") }); menus.reload(special_prompts_ids); } // Process 'connection_type' changes if (changes.connection_type) { const newConnectionType = changes.connection_type.newValue; let getCalendarEvent = doGetSparkFeature(prefs_init.get_calendar_event); let getCalendarEventFromClipboard = doGetSparkFeature(prefs_init.get_calendar_event_from_clipboard); let getTask = doGetSparkFeature(prefs_init.get_task); const special_prompts_ids = getActiveSpecialPromptsIDs({ addtags: prefs_init.add_tags, addtags_api: hasSpecificIntegration(prefs_init.add_tags_use_specific_integration, prefs_init.add_tags_connection_type), get_calendar_event: getCalendarEvent, get_calendar_event_from_clipboard: getCalendarEventFromClipboard, get_task: getTask, spamfilter: prefs_init.spamfilter, summarize: prefs_init.summarize, translate: prefs_init.translate, is_chatgpt_web: (newConnectionType === "chatgpt_web") }); menus.reload(special_prompts_ids); } reload_pref_init(); } }); } // Call the function to set up the listener setupStorageChangeListener(); // Register the listener for removed permissions function setupPermissionsRemovedListener() { browser.permissions.onRemoved.addListener((permissions) => { // console.log(">>>>>>>>>>> Permissions onRemoved permissions: " + JSON.stringify(permissions)); // Process 'tags' permissions removal if (["messagesTags", "messagesUpdate"].some(permission => permissions.permissions.includes(permission))) { // console.log(">>>>>>>>>>> Permissions onRemoved: tags"); browser.storage.sync.set({add_tags: false}); } // Process 'spamfilter' permissions removal if (["messagesMove", "messagesUpdate"].some(permission => permissions.permissions.includes(permission))) { // console.log(">>>>>>>>>>> Permissions onRemoved: spamfilter"); browser.storage.sync.set({spamfilter: false}); } }); } // Call the function to set up the listener setupPermissionsRemovedListener(); // Menus handling await migrateMenuOrderAlphabetic(); const menus = new mzta_Menus(openChatGPT, prefs_init.do_debug); menus.loadMenus(special_prompts_ids); // Context menu click handling // Context menus are now created dynamically by mzta_Menus.loadContextMenus() // based on each prompt's show_in property. The menu item IDs use the format 'mzta-ctx-'. // Special prompts (add_tags, spamfilter, summarize, translate) are routed to processEmails() // for batch processing. Regular prompts are executed via menus.executeMenuAction(). const specialContextMenuActions = { 'prompt_add_tags': (messages) => processEmails({ messages, addTagsAuto: true }), 'prompt_spamfilter': (messages) => processEmails({ messages, spamFilter: true }), 'prompt_summarize': (messages) => processEmails({ messages, summarize: true }), 'prompt_translate_this': (messages) => processEmails({ messages, translate: true }), }; browser.menus.onClicked.addListener((info, tab) => { const menuItemId = info.menuItemId; if (typeof menuItemId !== 'string' || !menuItemId.startsWith('mzta-ctx-')) { return; } const promptId = menuItemId.replace('mzta-ctx-', ''); if (specialContextMenuActions[promptId]) { specialContextMenuActions[promptId](getMessages(info.selectedMessages)); } else { menus.executeMenuAction(promptId); } }); // Listening for new received emails const newEmailListener = (folder, messagesList) => { if(!_process_incoming){ return; } taLog.log("New mail received"); taLog.log(`Folder: ${folder.name}`); async function _newEmailListener(){ let messages = getMessages(messagesList); let add_tags_auto_enabled = prefs_init.add_tags && prefs_init.add_tags_auto; await processEmails({ messages: messages, addTagsAuto: add_tags_auto_enabled, spamFilter: prefs_init.spamfilter, summarizeOnReceive: prefs_init.summarize && prefs_init.summarize_auto === 3, translateOnReceive: prefs_init.translate && prefs_init.translate_auto === 3 }); if(prefs_init.spamfilter){ spamReport.truncReportData(); } } return _newEmailListener(); } async function updateSpamPanel(messageId, command, data = null) { if (prefs_init.spamfilter_show_msg_panel) { let tabs = await browser.tabs.query({ active: true, currentWindow: true }); if (tabs.length > 0) { let activeTab = tabs[0]; let displayedMessage = await browser.messageDisplay.getDisplayedMessage(activeTab.id); if (displayedMessage && displayedMessage.headerMessageId === messageId) { let msg = { command: command }; if (data) { msg.data = data; } browser.tabs.sendMessage(activeTab.id, msg); } } } } async function processEmails(args) { const { messages, addTagsAuto = false, spamFilter = false, summarize = false, summarizeOnReceive = false, translateOnReceive = false, translate = false } = args; taWorkingStatus.startWorking(); // One loop handles addTagsAuto, spamFilter, summarizeOnReceive, and translateOnReceive (on email receive). // The separate summarize block below handles the context menu flow. if (addTagsAuto || spamFilter || summarizeOnReceive || translateOnReceive || translate) { let prefs_aats = await browser.storage.sync.get({ add_tags_maxnum: prefs_default.add_tags_maxnum, connection_type: prefs_default.connection_type, add_tags_force_lang: prefs_default.add_tags_force_lang, default_chatgpt_lang: prefs_default.default_chatgpt_lang, add_tags_auto_force_existing: prefs_default.add_tags_auto_force_existing, add_tags_enabled_accounts: prefs_default.add_tags_enabled_accounts, add_tags_exclusions_exact_match: prefs_default.add_tags_exclusions_exact_match, add_tags_auto_uselist: prefs_default.add_tags_auto_uselist, add_tags_auto_uselist_list: prefs_default.add_tags_auto_uselist_list, spamfilter_enabled_accounts: prefs_default.spamfilter_enabled_accounts, ...getDynamicSettingsDefaults(['use_specific_integration', 'connection_type']), do_debug: prefs_default.do_debug, }); // console.log(">>>>>>>>>>>>>>>> prefs_aats: " + JSON.stringify(prefs_aats)); for await (let message of messages) { let curr_fullMessage = null; let msg_text = null; let body_text = ''; if (addTagsAuto || spamFilter) { curr_fullMessage = await browser.messages.getFull(message.id); msg_text = getMailBody(curr_fullMessage); taLog.log("Starting from the HTML body if present and converting to plain text..."); body_text = htmlBodyToPlainText(msg_text.html); if( body_text.length == 0 ){ taLog.log("No HTML found in the message body, using plain text..."); body_text = msg_text.text.replace(/\s+/g, ' ').trim(); } } if (addTagsAuto) { if(prefs_aats.add_tags_enabled_accounts.length > 0){ let accountId = message.folder.accountId; if(!prefs_aats.add_tags_enabled_accounts.includes(accountId)){ taLog.log("Account " + accountId + " not enabled for add_tags, skipping..."); continue; } } let specialFullPrompt_add_tags = ''; let curr_prompt_add_tags = menus.allPrompts.find(p => p.id === 'prompt_add_tags'); let tags_full_list = await getTagsList(); // console.log(">>>>>>>>>>>>> curr_prompt_add_tags: " + JSON.stringify(curr_prompt_add_tags)); let chatgpt_lang = await taPromptUtils.getDefaultLang(curr_prompt_add_tags); specialFullPrompt_add_tags = await taPromptUtils.preparePrompt({ curr_prompt: curr_prompt_add_tags, curr_message: message, chatgpt_lang: chatgpt_lang, body_text: body_text, subject_text: curr_fullMessage.headers.subject, msg_text: msg_text, tags_full_list: tags_full_list }); specialFullPrompt_add_tags = taPromptUtils.finalizePrompt_add_tags(specialFullPrompt_add_tags, prefs_aats.add_tags_maxnum, prefs_aats.add_tags_force_lang, prefs_aats.default_chatgpt_lang, prefs_aats.add_tags_auto_uselist, prefs_aats.add_tags_auto_uselist_list); taLog.log("Special prompt: " + specialFullPrompt_add_tags); // console.log(">>>>>>>>>> curr_prompt_add_tags.model: " + curr_prompt_add_tags.model); // console.log(">>>>>>>>>>>>>>>>> getConnectionType add_tags:" + JSON.stringify(getConnectionType(prefs_aats, curr_prompt_add_tags, 'add_tags'))); let cmd_addTags = new mzta_specialCommand({ prompt: specialFullPrompt_add_tags, llm: getConnectionType(prefs_aats, curr_prompt_add_tags, 'add_tags'), custom_model: curr_prompt_add_tags.model ? curr_prompt_add_tags.model : '', do_debug: prefs_aats.do_debug, config: curr_prompt_add_tags }); await cmd_addTags.initWorker(); let tags_current_email = []; try { tags_current_email = taPromptUtils.getTagsFromResponse(await cmd_addTags.sendPrompt(), prefs_aats.add_tags_auto_uselist, prefs_aats.add_tags_auto_uselist_list); } catch (err) { console.error("[ThunderAI | Auto add_tags] Error getting tags: ", err); } taLog.log("tags_current_email: " + JSON.stringify(tags_current_email)); let _data = { messageId: message.id, tags: tags_current_email }; _assign_tags(_data, !prefs_aats.add_tags_auto_force_existing, prefs_aats.add_tags_exclusions_exact_match); } if (spamFilter) { if(prefs_aats.spamfilter_enabled_accounts.length > 0){ let accountId = message.folder.accountId; if(!prefs_aats.spamfilter_enabled_accounts.includes(accountId)){ taLog.log("Account " + accountId + " not enabled for spamfilter, skipping..."); continue; } } let result = await _generateSpamReportForMessage( message.headerMessageId, { messageData: { message, fullMessage: curr_fullMessage, body_text, msg_text }, prefs: prefs_aats, autoMove: true }); if (!result.success) continue; } if (summarizeOnReceive) { if (!curr_fullMessage) { curr_fullMessage = await browser.messages.getFull(message.id); } taLog.log("[ThunderAI] Pre-caching summary on receive for: " + message.headerMessageId); await _generateSummaryForMessage(message.headerMessageId, null, { messageData: { message, fullMessage: curr_fullMessage } }); } if (translateOnReceive || translate) { if (!curr_fullMessage) { curr_fullMessage = await browser.messages.getFull(message.id); } let translateTabId = null; if (translate) { const tabs = await browser.tabs.query({ active: true, currentWindow: true }); translateTabId = tabs[0].id; } taLog.log("[ThunderAI] Generating translation for: " + message.headerMessageId); await _generateTranslationForMessage(message.headerMessageId, translateTabId, { messageData: { fullMessage: curr_fullMessage } }); } } } if (summarize) { const tabs = await browser.tabs.query({ active: true, currentWindow: true }); const tabId = tabs[0].id; let summarize_prefs = await browser.storage.sync.get({ summarize_display_mode: prefs_default.summarize_display_mode }); // Collect messages into array to check count const messageArray = []; for await (let msg of messages) { messageArray.push(msg); } // Inline mode for single message: generate inline summary in the message pane if (summarize_prefs.summarize_display_mode === 'inline' && messageArray.length === 1) { await _generateSummaryForMessage(messageArray[0].headerMessageId, tabId); } else { // Webchat mode, or inline with multiple messages (fallback to webchat) const messageDataArray = []; for (let curr_message of messageArray) { const fullMessage = await browser.messages.getFull(curr_message.id); messageDataArray.push({ message: curr_message, fullMessage }); } const { promptText, promptInfo } = await taPromptUtils.buildSummaryPrompt(messageDataArray); openChatGPT(promptText, promptInfo.action, tabId, promptInfo.name, promptInfo.need_custom_text, promptInfo); } } taWorkingStatus.stopWorking(); } browser.messages.onNewMailReceived.addListener(newEmailListener, !prefs_init.add_tags_auto_only_inbox); // Inject script and CSS in all already open message tabs. let openTabs = await messenger.tabs.query(); let messageTabs = openTabs.filter( tab => ["mail", "messageDisplay"].includes(tab.type) ); for (let messageTab of messageTabs) { if((messageTab.url == undefined) || (["start.thunderbird.net","about:blank"].some(blockedUrl => messageTab.url.includes(blockedUrl)))) { continue; } try { await browser.tabs.executeScript(messageTab.id, { file: "js/mzta-compose-script.js" }) } catch (error) { console.error("[ThunderAI] Error injecting message display script:", error); console.error("[ThunderAI] Message tab:", messageTab.url); } }