Add heuristics settings for editor and send button; implement UI toggles and state management

MaxITService · MaxITService · commit be18f1586818 · 2025-11-25T19:22:56.000+02:00
diff --git a/code-notes.md b/code-notes.md
@@ -45,7 +45,8 @@ Current architectural reference for the OneClickPrompts Chrome extension (Manife
 - **`modules/selector-auto-detector/selector-guard.js`** ("The Guard"): Adapter that replaces direct `document.querySelector` calls. Tries configured selectors, skips disabled/custom buttons, reports success/failure to the Brain.
 - **`modules/selector-auto-detector/base-heuristics.js`**: Generic heuristics (textarea + any `[contenteditable]`, shadow-root walk; buttons/role=button scoring). Also hosts `OneClickPromptsSiteHeuristics` registry and resolver.
 - **Site heuristics modules**: e.g., `modules/selector-auto-detector/heuristics-deepseek.js` registers DeepSeek-specific editor/button scoring (ignores OCP UI). If present, the Brain picks the site module by `InjectionTargetsOnWebsite.activeSite`; otherwise it falls back to the base heuristics.
-- **Integration**: Site scripts call `SelectorGuard.findEditor()/findSendButton()`; on repeated failures the Brain runs heuristics, shows toasts on success/error, and returns the guessed element to the caller.
+- **Integration**: Site scripts call `SelectorGuard.findEditor()/findSendButton()`; on repeated failures the Brain runs heuristics, shows toasts on success/error, and returns the guessed element to the caller. When both editor and send-button selectors are missing, the Guard now surfaces the editor failure toast first to match dependency order.
+- **Auto-detect toggles**: If heuristics are disabled in the popup toggles, the Brain still shows a "not found; auto-detect off" toast so the user sees which element is missing even without running scans.
 
 ## 3. UI Surfaces
 
diff --git a/modules/selector-auto-detector/index.js b/modules/selector-auto-detector/index.js
@@ -27,6 +27,11 @@ window.OneClickPromptsSelectorAutoDetector = {
         failureThreshold: 1, // Number of failures before triggering recovery (can be >1 to debounce)
         cooldownMs: 2000,    // Time to wait before re-alerting or re-trying
     },
+    settings: {
+        enableEditorHeuristics: true,
+        enableSendButtonHeuristics: true,
+        loaded: false
+    },
 
     /**
      * Reports a failure to find a specific element type.
@@ -81,9 +86,23 @@ window.OneClickPromptsSelectorAutoDetector = {
         const s = this.state[type];
         s.recovering = true;
 
+        const heuristicsAllowed = type === 'editor'
+            ? this.settings.enableEditorHeuristics !== false
+            : this.settings.enableSendButtonHeuristics !== false;
+
         // Readable name for the type
         const typeName = type === 'editor' ? 'Text input area' : 'send button';
 
+        // If heuristics are disabled, still notify the user but skip the scan.
+        if (!heuristicsAllowed) {
+            logConCgp(`[SelectorAutoDetector] Heuristics disabled for ${type}; skipping recovery.`);
+            if (window.showToast) {
+                window.showToast(`OneClickPrompts: ${typeName} not found. Auto-detect is off.`, 'error');
+            }
+            s.recovering = false;
+            return null;
+        }
+
         // Notify user
         if (window.showToast) {
             window.showToast(`OneClickPrompts: ${typeName} not found. Trying to find it...`, 'info');
@@ -119,5 +138,38 @@ window.OneClickPromptsSelectorAutoDetector = {
 
         s.recovering = false;
         return result;
+    },
+
+    loadSettings: async function () {
+        if (!chrome?.runtime?.sendMessage) {
+            return;
+        }
+        try {
+            const response = await chrome.runtime.sendMessage({ type: 'getSelectorAutoDetectorSettings' });
+            if (response && response.settings) {
+                this.settings = {
+                    enableEditorHeuristics: response.settings.enableEditorHeuristics !== false,
+                    enableSendButtonHeuristics: response.settings.enableSendButtonHeuristics !== false,
+                    loaded: true
+                };
+            }
+        } catch (error) {
+            logConCgp('[SelectorAutoDetector] Failed to load settings, falling back to defaults.', error);
+        }
     }
 };
+
+// Initial settings sync and live updates
+window.OneClickPromptsSelectorAutoDetector.loadSettings();
+
+if (chrome?.runtime?.onMessage?.addListener) {
+    chrome.runtime.onMessage.addListener((message) => {
+        if (message?.type === 'selectorAutoDetectorSettingsChanged' && message.settings) {
+            window.OneClickPromptsSelectorAutoDetector.settings = {
+                enableEditorHeuristics: message.settings.enableEditorHeuristics !== false,
+                enableSendButtonHeuristics: message.settings.enableSendButtonHeuristics !== false,
+                loaded: true
+            };
+        }
+    });
+}
diff --git a/modules/selector-auto-detector/selector-guard.js b/modules/selector-auto-detector/selector-guard.js
@@ -37,6 +37,7 @@ window.OneClickPromptsSelectorGuard = {
      */
     findSendButton: async function () {
         const selectors = window.InjectionTargetsOnWebsite?.selectors?.sendButtons || [];
+        const editorSelectors = window.InjectionTargetsOnWebsite?.selectors?.editors || [];
 
         // 1. Try standard selectors
         let element = this._querySelectors(selectors, { requireEnabled: true });
@@ -46,6 +47,11 @@ window.OneClickPromptsSelectorGuard = {
             window.OneClickPromptsSelectorAutoDetector.reportRecovery('sendButton');
             return element;
         } else {
+            // If editor is also missing, surface that failure first to guide the user.
+            const editorElement = this._querySelectors(editorSelectors);
+            if (!editorElement && window.OneClickPromptsSelectorAutoDetector) {
+                await window.OneClickPromptsSelectorAutoDetector.reportFailure('editor', { selectors: editorSelectors });
+            }
             // Try to recover
             return await window.OneClickPromptsSelectorAutoDetector.reportFailure('sendButton', { selectors });
         }
diff --git a/modules/service-worker-auxiliary-state-store.js b/modules/service-worker-auxiliary-state-store.js
@@ -50,6 +50,7 @@ const KEYS = {
     crossChat: 'modules.crossChat', // object { settings: {...}, storedPrompt: string }
     inlineProfileSelector: 'modules.inlineProfileSelector', // object { enabled:boolean, placement:'before'|'after' }
     tokenApproximator: 'modules.tokenApproximator', // object { enabled:boolean, calibration:number, threadMode:string, showEditorCounter:boolean, placement:'before'|'after' }
+    selectorAutoDetector: 'modules.selectorAutoDetector', // object { enableEditorHeuristics:boolean, enableSendButtonHeuristics:boolean }
   },
   floatingPanel: 'floatingPanel', // object map { [hostname]: settings }
   global: {
@@ -79,6 +80,11 @@ const CROSS_CHAT_DEFAULT_SETTINGS = {
   hideStandardButtons: false,
 };
 
+const SELECTOR_AUTO_DETECTOR_DEFAULTS = {
+  enableEditorHeuristics: true,
+  enableSendButtonHeuristics: true,
+};
+
 // Utilities to get/set nested key paths by flattening as separate storage entries
 // We store each top-level namespace as a whole object where applicable to limit storage ops:
 async function getValue(path) {
@@ -193,6 +199,17 @@ async function getValue(path) {
       }
     };
   }
+  if (path === KEYS.modules.selectorAutoDetector) {
+    const r = await lsGet([KEYS.modules.selectorAutoDetector]);
+    const obj = r[KEYS.modules.selectorAutoDetector];
+    if (obj && typeof obj === 'object') {
+      return {
+        enableEditorHeuristics: !!obj.enableEditorHeuristics,
+        enableSendButtonHeuristics: !!obj.enableSendButtonHeuristics,
+      };
+    }
+    return { ...SELECTOR_AUTO_DETECTOR_DEFAULTS };
+  }
   if (path === KEYS.floatingPanel) {
     // Build map from structured store if exists, else from legacy scattered keys
     const all = await lsGet(null);
@@ -306,6 +323,15 @@ async function setValue(path, value) {
     await lsSet({ [KEYS.modules.tokenApproximator]: normalized });
     return;
   }
+  if (path === KEYS.modules.selectorAutoDetector) {
+    const settings = value && typeof value === 'object' ? value : {};
+    const normalized = {
+      enableEditorHeuristics: settings.enableEditorHeuristics !== false,
+      enableSendButtonHeuristics: settings.enableSendButtonHeuristics !== false,
+    };
+    await lsSet({ [KEYS.modules.selectorAutoDetector]: normalized });
+    return;
+  }
   if (path.startsWith(KEYS.floatingPanel)) {
     // We maintain a structured map and legacy per-host keys
     if (path === KEYS.floatingPanel) {
@@ -487,6 +513,15 @@ export const StateStore = {
     this.broadcast({ type: 'tokenApproximatorSettingsChanged', settings });
   },
 
+  // ===== Selector Auto-Detector (Global Module) =====
+  async getSelectorAutoDetectorSettings() {
+    return await getValue(KEYS.modules.selectorAutoDetector);
+  },
+  async saveSelectorAutoDetectorSettings(settings) {
+    await setValue(KEYS.modules.selectorAutoDetector, settings);
+    this.broadcast({ type: 'selectorAutoDetectorSettingsChanged', settings });
+  },
+
   // Broadcast utility
   async broadcast(payload) {
     try {
diff --git a/modules/service-worker-message-router.js b/modules/service-worker-message-router.js
@@ -494,6 +494,34 @@ export function handleMessage(request, sender, sendResponse) {
             return true;
         // ===== End Token Approximator Cases =====
 
+        // ===== Selector Auto-Detector Cases =====
+        case 'getSelectorAutoDetectorSettings':
+            (async () => {
+                try {
+                    const settings = await StateStore.getSelectorAutoDetectorSettings();
+                    logConfigurationRelatedStuff('Retrieved Selector Auto-Detector settings:', settings);
+                    sendResponse({ settings });
+                } catch (error) {
+                    handleStorageError(error);
+                    sendResponse({ error: error.message });
+                }
+            })();
+            return true;
+
+        case 'saveSelectorAutoDetectorSettings':
+            (async () => {
+                try {
+                    await StateStore.saveSelectorAutoDetectorSettings(request.settings);
+                    logConfigurationRelatedStuff('Saved Selector Auto-Detector settings:', request.settings);
+                    sendResponse({ success: true });
+                } catch (error) {
+                    handleStorageError(error);
+                    sendResponse({ error: error.message });
+                }
+            })();
+            return true;
+        // ===== End Selector Auto-Detector Cases =====
+
         case 'openSettingsPage':
             (async () => {
                 try {
@@ -514,4 +542,4 @@ export function handleMessage(request, sender, sendResponse) {
             sendResponse({ error: 'Unknown message type' });
             return false;
     }
-}
+}
diff --git a/popup-page-scripts/popup-page-advanced.js b/popup-page-scripts/popup-page-advanced.js
@@ -42,6 +42,43 @@ document.addEventListener('DOMContentLoaded', () => {
     const selectorConfig = document.getElementById('selectorConfig');
     const saveButton = document.getElementById('saveSelectors');
     const resetButton = document.getElementById('resetSelectors');
+    const editorHeuristicsToggle = document.getElementById('editorHeuristicsToggle');
+    const sendButtonHeuristicsToggle = document.getElementById('sendButtonHeuristicsToggle');
+
+    const heuristicsDefaults = {
+        enableEditorHeuristics: true,
+        enableSendButtonHeuristics: true,
+    };
+    let heuristicsSettings = { ...heuristicsDefaults };
+
+    async function loadHeuristicsSettings() {
+        if (!editorHeuristicsToggle || !sendButtonHeuristicsToggle) return;
+        try {
+            const response = await chrome.runtime.sendMessage({ type: 'getSelectorAutoDetectorSettings' });
+            if (response && response.settings) {
+                heuristicsSettings = {
+                    ...heuristicsDefaults,
+                    ...response.settings,
+                };
+            }
+        } catch (error) {
+            console.error('[advanced selectors] Failed to load heuristics settings:', error);
+            heuristicsSettings = { ...heuristicsDefaults };
+        }
+        editorHeuristicsToggle.checked = !!heuristicsSettings.enableEditorHeuristics;
+        sendButtonHeuristicsToggle.checked = !!heuristicsSettings.enableSendButtonHeuristics;
+    }
+
+    async function saveHeuristicsSettings() {
+        try {
+            await chrome.runtime.sendMessage({
+                type: 'saveSelectorAutoDetectorSettings',
+                settings: heuristicsSettings,
+            });
+        } catch (error) {
+            console.error('[advanced selectors] Failed to save heuristics settings:', error);
+        }
+    }
 
     // Load selectors for the selected website
     async function loadSelectors() {
@@ -163,9 +200,22 @@ document.addEventListener('DOMContentLoaded', () => {
     websiteSelect.addEventListener('change', loadSelectors);
     saveButton.addEventListener('click', saveSelectors);
     resetButton.addEventListener('click', resetSelectors);
+    if (editorHeuristicsToggle) {
+        editorHeuristicsToggle.addEventListener('change', () => {
+            heuristicsSettings.enableEditorHeuristics = editorHeuristicsToggle.checked;
+            saveHeuristicsSettings();
+        });
+    }
+    if (sendButtonHeuristicsToggle) {
+        sendButtonHeuristicsToggle.addEventListener('change', () => {
+            heuristicsSettings.enableSendButtonHeuristics = sendButtonHeuristicsToggle.checked;
+            saveHeuristicsSettings();
+        });
+    }
 
     // Initial load
     loadSelectors();
+    loadHeuristicsSettings();
 
     // Make the selectorConfig textarea auto-resizable by reusing the global function
     if (typeof textareaInputAreaResizerFun === 'function') {
@@ -208,4 +258,4 @@ document.addEventListener('DOMContentLoaded', () => {
     if (selectorConfig && typeof resizeVerticalTextarea === 'function') {
         selectorConfig.addEventListener('input', () => resizeVerticalTextarea(selectorConfig));
     }
-});
+});
diff --git a/popup.html b/popup.html
@@ -1,3 +1,4 @@
+<!-- popup.html -->
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
@@ -1370,7 +1371,31 @@ <h2>
               Reset to Defaults
             </button>
           </div>
-
+          <br />
+          <div class="switch-container">
+            <label class="switch">
+              <input
+                type="checkbox"
+                id="editorHeuristicsToggle"
+                aria-label="Enable heuristics when the text editor is not found"
+              />
+              <span class="slider"></span>
+            </label>
+            <span class="switch-label">Use heuristics when editor is not found</span>
+          </div>
+           <br />
+          <div class="switch-container">
+            <label class="switch">
+              <input
+                type="checkbox"
+                id="sendButtonHeuristicsToggle"
+                aria-label="Enable heuristics when the send button is not found"
+              />
+              <span class="slider"></span>
+            </label>
+            <span class="switch-label">Use heuristics when send button is not found</span>
+          </div>
+           <br />
           <!-- Collapsible Help Section -->
           <div class="collapsible" id="advancedHelpSection">
             <div class="section-header subsection-header">
@@ -1414,6 +1439,29 @@ <h3>Help <span class="expand-text">(click to expand)</span></h3>
                   Format: JSON array for containers/sendButtons/editors, string
                   for buttonsContainerId
                 </p>
+                <br />
+                <p><strong>Auto-Detection (Heuristics)</strong></p>
+                <p>
+                  If the configured selectors fail (e.g., after a website update),
+                  the extension attempts to "guess" the correct elements using
+                  smart heuristics.
+                </p>
+                <ul>
+                  <li>
+                    <strong>Editor Heuristics:</strong> Scans for visible text
+                    areas and content-editable fields, usually picking the
+                    largest one near the bottom.
+                  </li>
+                  <li>
+                    <strong>Send Button Heuristics:</strong> Looks for buttons
+                    with "Send" icons or text, especially those positioned near
+                    the found editor.
+                  </li>
+                </ul>
+                <p>
+                  Use the toggles above to disable this behavior if it
+                  incorrectly identifies elements.
+                </p>
               </div>
             </div>
           </div>
