From 732ec7cf8721de62f44fc349f746b07139ed8b1b Mon Sep 17 00:00:00 2001
From: Sergei Arutiunian <sergeiarutiunian@Sergei-sin-MacBook-Air.local>
Date: Tue, 12 May 2026 18:53:16 +0200
Subject: [PATCH] fix(comet-ai): use matched input selector, tighten
 finalCheck, doc stability semantics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### `findInputElement` return value was ignored

`sendPrompt` called `findInputElement()` (which iterates a list of
candidate selectors and returns the first one that matches), then
discarded the result and hardcoded `[contenteditable="true"]` for the
typing logic. On pages where the real input is a `<textarea>` AND a
different unrelated `contenteditable` exists somewhere on the page
(e.g. a hidden search box), focus / typing landed on the wrong
element. Now we route through the selector that the discovery loop
actually matched, and branch on `el.isContentEditable` / `'value' in el`
so contenteditable elements get `execCommand('insertText', ...)` and
form controls get `.value =` + `input` event.

### `finalCheck` matched `[class*="animate"]` — too broad

Perplexity's brand mark uses `animate-pulse` permanently. The
"submission succeeded?" probe used `[class*="animate"]`, which
matches that brand mark, so `hasLoading` was effectively always
`true` on any Perplexity page. The `form.submit()` last-resort
branch — meant to fire when neither key dispatch nor button click
worked — therefore never fired. Tightened to specific progress
indicators: `animate-spin`, `loading`, `thinking`.

### `isResponseStable` semantics were off-by-one in the doc

The constant was named `STABILITY_THRESHOLD` with the comment
"Response must be same for 2 checks". The actual behaviour: counter
increments only AFTER the first matching call, so the function
returns `true` on the 3rd consecutive identical poll (which is what
the existing unit test asserts). Renamed to `STABLE_REPEATS_REQUIRED`
and rewrote the comment to describe the true semantics — "unchanged
for `STABLE_REPEATS_REQUIRED + 1` consecutive polls". The constant
value (2) is unchanged; the test still passes; no behavioural
change, just an accurate name + comment.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/comet-ai.ts | 60 +++++++++++++++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 17 deletions(-)

diff --git a/src/comet-ai.ts b/src/comet-ai.ts
index 557a442..8f82852 100644
--- a/src/comet-ai.ts
+++ b/src/comet-ai.ts
@@ -53,22 +53,30 @@ export class CometAI {
       throw new Error("Could not find input element. Navigate to Perplexity first.");
     }
 
-    // Use execCommand for contenteditable elements (works with React/Vue)
+    // Use the actually-matched selector. The previous implementation
+    // discarded `inputSelector` and tried `[contenteditable="true"]`
+    // unconditionally, so on pages where the real input was a
+    // `<textarea>` *and* a different unrelated `contenteditable` (e.g.
+    // a hidden search box) was also present, focus / typing landed on
+    // the wrong element. Routing through the selector that the
+    // discovery loop actually matched fixes that.
+    const safeSelector = JSON.stringify(inputSelector);
+    const safePrompt = JSON.stringify(prompt);
     const result = await cometClient.evaluate(`
       (() => {
-        const el = document.querySelector('[contenteditable="true"]');
-        if (el) {
-          el.focus();
+        const el = document.querySelector(${safeSelector});
+        if (!el) return { success: false };
+        el.focus();
+        // contenteditable path: execCommand keeps React's input bindings happy.
+        if (el.isContentEditable) {
           document.execCommand('selectAll', false, null);
-          document.execCommand('insertText', false, ${JSON.stringify(prompt)});
+          document.execCommand('insertText', false, ${safePrompt});
           return { success: true };
         }
-        // Fallback for textarea
-        const textarea = document.querySelector('textarea');
-        if (textarea) {
-          textarea.focus();
-          textarea.value = ${JSON.stringify(prompt)};
-          textarea.dispatchEvent(new Event('input', { bubbles: true }));
+        // Form-control path: set value + fire input event.
+        if ('value' in el) {
+          el.value = ${safePrompt};
+          el.dispatchEvent(new Event('input', { bubbles: true }));
           return { success: true };
         }
         return { success: false };
@@ -226,12 +234,20 @@ export class CometAI {
 
     await new Promise(resolve => setTimeout(resolve, 500));
 
-    // Final verification and last resort
+    // Final verification and last resort.
+    // The previous check used `[class*="animate"]` which matches
+    // Perplexity's permanently-animated logo (`animate-pulse` on the
+    // brand mark) — so `hasLoading` was effectively always true on
+    // every Perplexity page, and the `form.submit()` last-resort
+    // branch below never fired. Tighten to genuine progress
+    // indicators (`animate-spin`, `loading`, `thinking`).
     const finalCheck = await cometClient.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el && el.innerText.trim().length < 5) return true;
-        const hasLoading = document.querySelector('[class*="animate"]') !== null;
+        const hasLoading = document.querySelector(
+          '[class*="animate-spin"], [class*="loading"], [class*="thinking"]'
+        ) !== null;
         const hasThinking = document.body.innerText.includes('Thinking');
         return hasLoading || hasThinking;
       })()
@@ -250,13 +266,23 @@ export class CometAI {
     }
   }
 
-  // Track response stability for completion detection
+  // Track response stability for completion detection.
+  // Semantics: returns `true` once the same response has been observed
+  // for `STABLE_REPEATS_REQUIRED` consecutive polls AFTER the first
+  // sighting. So with the default 2: call 1 records the value (false),
+  // call 2 matches (count=1, false), call 3 matches (count=2, true).
+  // Effectively "the response has not changed across the last 3 polls".
+  // The previous comment claimed "same for 2 checks" which was off by
+  // one; renaming the constant to match what the code actually does.
   private lastResponseText: string = '';
   private stableResponseCount: number = 0;
-  private readonly STABILITY_THRESHOLD: number = 2; // Response must be same for 2 checks
+  private readonly STABLE_REPEATS_REQUIRED: number = 2;
 
   /**
-   * Check if response has stabilized (same content for multiple polls)
+   * Check if response has stabilized.
+   *
+   * Returns `true` once the response text has been observed unchanged
+   * for `STABLE_REPEATS_REQUIRED + 1` consecutive polls.
    */
   isResponseStable(currentResponse: string): boolean {
     if (currentResponse && currentResponse.length > 50) {
@@ -266,7 +292,7 @@ export class CometAI {
         this.stableResponseCount = 0;
         this.lastResponseText = currentResponse;
       }
-      return this.stableResponseCount >= this.STABILITY_THRESHOLD;
+      return this.stableResponseCount >= this.STABLE_REPEATS_REQUIRED;
     }
     return false;
   }