1887 lines
91 KiB
JavaScript
1887 lines
91 KiB
JavaScript
/*
|
|
* 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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
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,
|
|
contextMenuID_AddTags,
|
|
contextMenuID_Spamfilter,
|
|
contextMenuID_Summarize,
|
|
contextMenuID_Translate,
|
|
contextMenuIconsPath,
|
|
sanitizeChatGPTModelData,
|
|
sanitizeChatGPTWebCustomData,
|
|
stripHtmlKeepLines,
|
|
htmlBodyToPlainText,
|
|
convertNewlinesToParagraphs,
|
|
getConnectionType,
|
|
checkAPIIntegration,
|
|
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
|
|
} 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-addtags-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),
|
|
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});
|
|
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,
|
|
is_chatgpt_web: (prefs_reload.connection_type === "chatgpt_web")
|
|
});
|
|
menus.reload(special_prompts_ids);
|
|
taLog.log("Reloading menus");
|
|
return true;
|
|
}
|
|
|
|
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, summarize_strip_formatting: prefs_default.summarize_strip_formatting });
|
|
|
|
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, stripFormatting: prefs.summarize_strip_formatting } });
|
|
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,
|
|
summarize_strip_formatting: prefs_default.summarize_strip_formatting
|
|
});
|
|
try {
|
|
browser.tabs.sendMessage(msg.tabId, {
|
|
command: "showSummary",
|
|
data: { ...summaryData, maxDisplayLength: prefs_summary.summarize_max_display_length, stripFormatting: prefs_summary.summarize_strip_formatting }
|
|
});
|
|
} 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 'shortcut_do_prompt':
|
|
taLog.log("Executing shortcut, promptId: " + message.promptId);
|
|
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,
|
|
summarize_strip_formatting: prefs_default.summarize_strip_formatting,
|
|
...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, stripFormatting: prefs.summarize_strip_formatting } });
|
|
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, stripFormatting: prefs.summarize_strip_formatting } });
|
|
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();
|
|
}
|
|
}
|
|
|
|
// Extract sender email for skip checks
|
|
let senderEmail = (message.author.match(/[\w.-]+@[\w.-]+\.\w+/) || [''])[0].toLowerCase();
|
|
|
|
// Check if sender is in the skip addresses list
|
|
let skip_addresses = options.skip_addresses || (await browser.storage.sync.get({spamfilter_skip_addresses: prefs_default.spamfilter_skip_addresses})).spamfilter_skip_addresses;
|
|
if (skip_addresses.length > 0) {
|
|
if (senderEmail && skip_addresses.includes(senderEmail)) {
|
|
taLog.log("Sender " + senderEmail + " is in the skip addresses list, skipping spam filter.");
|
|
let report_data = {};
|
|
report_data.report_date = new Date();
|
|
report_data.headerMessageId = headerMessageId;
|
|
report_data.spamValue = 0;
|
|
report_data.explanation = browser.i18n.getMessage('spamfilter_skip_addresses_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;
|
|
spamReport.saveReportData(report_data, headerMessageId);
|
|
await updateSpamPanel(headerMessageId, "showSpamReport", report_data);
|
|
return { success: true };
|
|
}
|
|
}
|
|
|
|
// Check if sender is in any address book
|
|
let skip_addressbook = options.skip_addressbook !== undefined
|
|
? options.skip_addressbook
|
|
: (await browser.storage.sync.get({spamfilter_skip_addressbook: prefs_default.spamfilter_skip_addressbook})).spamfilter_skip_addressbook;
|
|
if (skip_addressbook && senderEmail) {
|
|
try {
|
|
let hasPermission = await browser.permissions.contains({ permissions: ["addressBooks"] });
|
|
if (hasPermission) {
|
|
let matchingContacts = await browser.contacts.quickSearch({ searchString: senderEmail });
|
|
let isInAddressBook = matchingContacts.some(contact => {
|
|
let props = contact.properties;
|
|
return (props.PrimaryEmail && props.PrimaryEmail.toLowerCase() === senderEmail) ||
|
|
(props.SecondEmail && props.SecondEmail.toLowerCase() === senderEmail);
|
|
});
|
|
if (isInAddressBook) {
|
|
taLog.log("Sender " + senderEmail + " is in the address book, skipping spam filter.");
|
|
let report_data = {};
|
|
report_data.report_date = new Date();
|
|
report_data.headerMessageId = headerMessageId;
|
|
report_data.spamValue = 0;
|
|
report_data.explanation = browser.i18n.getMessage('spamfilter_skip_addressbook_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;
|
|
spamReport.saveReportData(report_data, headerMessageId);
|
|
await updateSpamPanel(headerMessageId, "showSpamReport", report_data);
|
|
return { success: true };
|
|
}
|
|
}
|
|
} catch (err) {
|
|
taLog.error("Error checking address book for sender: " + err);
|
|
// Fail open — continue with normal spam check
|
|
}
|
|
}
|
|
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
is_chatgpt_web: (newConnectionType === "chatgpt_web")
|
|
});
|
|
menus.reload(special_prompts_ids);
|
|
}
|
|
|
|
reload_pref_init().then(() => {
|
|
addContextMenuItems();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// 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
|
|
const menus = new mzta_Menus(openChatGPT, prefs_init.do_debug);
|
|
menus.loadMenus(special_prompts_ids);
|
|
|
|
// Context Menus
|
|
function addContextMenu(menu_id) {
|
|
browser.menus.remove(menu_id);
|
|
browser.menus.create({
|
|
id: menu_id,
|
|
title: browser.i18n.getMessage("context_menu_" + menu_id),
|
|
contexts: ["message_list"],
|
|
icons: contextMenuIconsPath[menu_id],
|
|
});
|
|
taLog.log("Context menu added: " + menu_id);
|
|
// console.log(">>>>>>> contextMenuIconsPath[menu_id]: " + contextMenuIconsPath[menu_id]);
|
|
}
|
|
|
|
function removeContextMenu(menu_id) {
|
|
browser.menus.remove(menu_id);
|
|
taLog.log("Context menu removed: " + menu_id);
|
|
}
|
|
|
|
function addContextMenuItems() {
|
|
let itemsToAdd = [];
|
|
|
|
// Add Context menu: Add tags
|
|
if(prefs_init.add_tags && checkAPIIntegration(prefs_init.connection_type, prefs_init.add_tags_use_specific_integration,prefs_init.add_tags_connection_type)){
|
|
itemsToAdd.push(contextMenuID_AddTags);
|
|
} else {
|
|
removeContextMenu(contextMenuID_AddTags);
|
|
}
|
|
|
|
// Add Context menu: Spamfilter
|
|
if(prefs_init.spamfilter && checkAPIIntegration(prefs_init.connection_type, prefs_init.spamfilter_use_specific_integration,prefs_init.spamfilter_connection_type)){
|
|
itemsToAdd.push(contextMenuID_Spamfilter);
|
|
} else {
|
|
removeContextMenu(contextMenuID_Spamfilter);
|
|
}
|
|
|
|
// Add Context menu: Summarize
|
|
if(prefs_init.summarize && checkAPIIntegration(prefs_init.connection_type, prefs_init.summarize_use_specific_integration, prefs_init.summarize_connection_type)) {
|
|
itemsToAdd.push(contextMenuID_Summarize);
|
|
} else {
|
|
removeContextMenu(contextMenuID_Summarize);
|
|
}
|
|
|
|
// Add Context menu: Translate
|
|
if(prefs_init.translate && checkAPIIntegration(prefs_init.connection_type, prefs_init.translate_use_specific_integration, prefs_init.translate_connection_type)){
|
|
itemsToAdd.push(contextMenuID_Translate);
|
|
} else {
|
|
removeContextMenu(contextMenuID_Translate);
|
|
}
|
|
|
|
itemsToAdd.sort((a, b) => {
|
|
let titleA = browser.i18n.getMessage("context_menu_" + a);
|
|
let titleB = browser.i18n.getMessage("context_menu_" + b);
|
|
return titleA.localeCompare(titleB);
|
|
});
|
|
|
|
itemsToAdd.forEach(menu_id => {
|
|
addContextMenu(menu_id);
|
|
});
|
|
}
|
|
|
|
addContextMenuItems();
|
|
|
|
// Listen for context menu item clicks
|
|
browser.menus.onClicked.addListener( (info, tab) => {
|
|
let _add_tags = false
|
|
let _spamfilter = false
|
|
let _summarize = false;
|
|
let _translate = false;
|
|
if(info.menuItemId === contextMenuID_AddTags){
|
|
_add_tags = true;
|
|
}
|
|
if(info.menuItemId === contextMenuID_Spamfilter){
|
|
_spamfilter = true;
|
|
}
|
|
if(info.menuItemId === contextMenuID_Summarize) {
|
|
_summarize = true;
|
|
}
|
|
if(info.menuItemId === contextMenuID_Translate) {
|
|
_translate = true;
|
|
}
|
|
if(_add_tags || _spamfilter || _summarize || _translate){
|
|
processEmails({
|
|
messages: getMessages(info.selectedMessages),
|
|
addTagsAuto: _add_tags,
|
|
spamFilter: _spamfilter,
|
|
summarize: _summarize,
|
|
translate: _translate
|
|
});
|
|
}
|
|
});
|
|
|
|
|
|
// 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,
|
|
isAutoMode: true,
|
|
});
|
|
|
|
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,
|
|
isAutoMode = 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,
|
|
spamfilter_skip_addresses: prefs_default.spamfilter_skip_addresses,
|
|
spamfilter_skip_addressbook: prefs_default.spamfilter_skip_addressbook,
|
|
...getDynamicSettingsDefaults(['use_specific_integration', 'connection_type']),
|
|
do_debug: prefs_default.do_debug,
|
|
});
|
|
// console.log(">>>>>>>>>>>>>>>> prefs_aats: " + JSON.stringify(prefs_aats));
|
|
let spamfilter_skip_addresses = prefs_aats.spamfilter_skip_addresses;
|
|
let spamfilter_skip_addressbook = prefs_aats.spamfilter_skip_addressbook;
|
|
|
|
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) {
|
|
let skipAddTags = false;
|
|
if(isAutoMode && 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...");
|
|
skipAddTags = true;
|
|
}
|
|
}
|
|
if (!skipAddTags) {
|
|
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) {
|
|
let skipSpamFilter = false;
|
|
if(isAutoMode && 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...");
|
|
skipSpamFilter = true;
|
|
}
|
|
}
|
|
if (!skipSpamFilter) {
|
|
await _generateSpamReportForMessage(
|
|
message.headerMessageId,
|
|
{
|
|
messageData: { message, fullMessage: curr_fullMessage, body_text, msg_text },
|
|
prefs: prefs_aats,
|
|
autoMove: true,
|
|
skip_addresses: spamfilter_skip_addresses,
|
|
skip_addressbook: spamfilter_skip_addressbook
|
|
});
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|