@jackwener/opencli 1.7.12 → 1.7.14

package/clis/chatgpt/utils.js

@@ -1,8 +1,11 @@
 /**
- * ChatGPT web browser automation helpers for image generation.
+ * ChatGPT web browser automation helpers.
  * Cross-platform: works on Linux/macOS/Windows via OpenCLI's CDP browser automation.
  */
 
+import { htmlToMarkdown } from '@jackwener/opencli/utils';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, TimeoutError } from '@jackwener/opencli/errors';
+
 export const CHATGPT_DOMAIN = 'chatgpt.com';
 export const CHATGPT_URL = 'https://chatgpt.com';
 
@@ -11,8 +14,14 @@ const COMPOSER_SELECTORS = [
     '[aria-label="Chat with ChatGPT"]',
     '[placeholder="Ask anything"]',
     '#prompt-textarea',
+    '[data-testid="prompt-textarea"]',
+    '[contenteditable="true"][role="textbox"]',
+];
+const SEND_BUTTON_LABELS = [
+    'Send prompt',
+    'Send message',
+    'Send',
 ];
-const SEND_BTN_SELECTOR = 'button[aria-label="Send prompt"]';
 
 function isSameChatGPTConversation(currentUrl, expectedUrl) {
     if (!currentUrl || !expectedUrl) return false;
@@ -58,6 +67,116 @@ function buildComposerLocatorScript() {
     `;
 }
 
+export function normalizeBooleanFlag(value, fallback = false) {
+    if (typeof value === 'boolean') return value;
+    if (value == null || value === '') return fallback;
+    const normalized = String(value).trim().toLowerCase();
+    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+
+export function requireNonEmptyPrompt(prompt, commandName) {
+    const text = String(prompt ?? '').trim();
+    if (!text) {
+        throw new ArgumentError(
+            `${commandName} prompt cannot be empty`,
+            `Example: opencli ${commandName} "hello"`,
+        );
+    }
+    return text;
+}
+
+export function requirePositiveInt(value, flagLabel, hint) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new ArgumentError(`${flagLabel} must be a positive integer`, hint);
+    }
+    return value;
+}
+
+export function parseChatGPTConversationId(value) {
+    const raw = String(value ?? '').trim();
+    const match = raw.match(/(?:^|\/c\/)([A-Za-z0-9_-]{8,})(?:[/?#]|$)/);
+    if (match) return match[1];
+    if (/^[A-Za-z0-9_-]{8,}$/.test(raw)) return raw;
+    throw new ArgumentError(
+        'chatgpt detail requires a conversation id or /c/<id> URL',
+        'Example: opencli chatgpt detail 123e4567-e89b-12d3-a456-426614174000',
+    );
+}
+
+export async function currentChatGPTUrl(page) {
+    const url = await page.evaluate('window.location.href').catch(() => '');
+    return typeof url === 'string' ? url : '';
+}
+
+export async function isOnChatGPT(page) {
+    const url = await currentChatGPTUrl(page);
+    if (!url) return false;
+    try {
+        const host = new URL(url).hostname;
+        return host === CHATGPT_DOMAIN || host.endsWith(`.${CHATGPT_DOMAIN}`);
+    } catch {
+        return false;
+    }
+}
+
+export async function ensureOnChatGPT(page) {
+    if (await isOnChatGPT(page)) return false;
+    await page.goto(CHATGPT_URL, { settleMs: 2000 });
+    await page.wait(2);
+    return true;
+}
+
+export async function startNewChat(page) {
+    await page.goto(`${CHATGPT_URL}/new`, { settleMs: 2000 });
+    await page.wait(2);
+}
+
+export async function getPageState(page) {
+    return await page.evaluate(`(() => {
+        const isVisible = (el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const style = window.getComputedStyle(el);
+            if (style.display === 'none' || style.visibility === 'hidden') return false;
+            const rect = el.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        };
+        const composerSelectors = ${JSON.stringify(COMPOSER_SELECTORS)};
+        const hasComposer = composerSelectors.some((selector) =>
+            Array.from(document.querySelectorAll(selector)).some((node) => isVisible(node))
+        );
+        const text = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim();
+        const loginLink = Array.from(document.querySelectorAll('a, button')).find((node) => {
+            const label = ((node.innerText || node.textContent || '') + ' ' + (node.getAttribute('aria-label') || '')).trim().toLowerCase();
+            return isVisible(node) && /^(log in|login|sign up|sign in)$/.test(label);
+        });
+        const userMenu = document.querySelector('[data-testid="profile-button"], [aria-label*="Profile"], [aria-label*="Account"], button[id*="headlessui-menu-button"]');
+        const hasLoginGate = !!loginLink || /log in to chatgpt|sign up to chatgpt|welcome to chatgpt/i.test(text);
+        return {
+            url: window.location.href,
+            title: document.title,
+            hasComposer,
+            isLoggedIn: hasComposer || !!userMenu || !hasLoginGate,
+            hasLoginGate,
+        };
+    })()`);
+}
+
+export async function ensureChatGPTLogin(page, message = 'ChatGPT requires a logged-in browser session.') {
+    const state = await getPageState(page);
+    if (!state.isLoggedIn || state.hasLoginGate) {
+        throw new AuthRequiredError(CHATGPT_DOMAIN, message);
+    }
+    return state;
+}
+
+export async function ensureChatGPTComposer(page, message = 'ChatGPT composer is not available on the current page.') {
+    const state = await ensureChatGPTLogin(page, message);
+    if (!state.hasComposer) {
+        throw new CommandExecutionError(message);
+    }
+    return state;
+}
+
 /**
  * Send a message to the ChatGPT composer and submit it.
  * Returns true if the message was sent successfully.
@@ -116,7 +235,8 @@ export async function sendChatGPTMessage(page, text) {
     const sent = await page.evaluate(`
         (() => {
             const btns = Array.from(document.querySelectorAll('button'));
-            const sendBtn = btns.find(b => b.getAttribute('aria-label') === 'Send prompt');
+            const labels = ${JSON.stringify(SEND_BUTTON_LABELS)};
+            const sendBtn = btns.find(b => labels.includes(b.getAttribute('aria-label') || '') && !b.disabled);
             return { sendBtnFound: !!sendBtn };
         })()
     `);
@@ -127,13 +247,181 @@ export async function sendChatGPTMessage(page, text) {
     
     await page.evaluate(`
         (() => {
-            const sendBtn = Array.from(document.querySelectorAll('button')).find(b => b.getAttribute('aria-label') === 'Send prompt');
+            const labels = ${JSON.stringify(SEND_BUTTON_LABELS)};
+            const sendBtn = Array.from(document.querySelectorAll('button')).find(b => labels.includes(b.getAttribute('aria-label') || '') && !b.disabled);
             if (sendBtn) sendBtn.click();
         })()
     `);
     return true;
 }
 
+export async function getVisibleMessages(page) {
+    const result = await page.evaluate(`(() => {
+        const isVisible = (el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const style = window.getComputedStyle(el);
+            if (style.display === 'none' || style.visibility === 'hidden') return false;
+            const rect = el.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        };
+        const normalize = (value) => String(value || '').replace(/\\u00a0/g, ' ').replace(/[ \\t]+\\n/g, '\\n').replace(/\\n{3,}/g, '\\n\\n').trim();
+        const roleOf = (node) => {
+            const attr = node.getAttribute('data-message-author-role') || node.getAttribute('data-author') || '';
+            if (/assistant/i.test(attr)) return 'Assistant';
+            if (/user/i.test(attr)) return 'User';
+            const testid = node.getAttribute('data-testid') || '';
+            if (/assistant/i.test(testid)) return 'Assistant';
+            if (/user/i.test(testid)) return 'User';
+            const label = node.getAttribute('aria-label') || '';
+            if (/assistant|chatgpt/i.test(label)) return 'Assistant';
+            if (/you|user/i.test(label)) return 'User';
+            return '';
+        };
+
+        let nodes = Array.from(document.querySelectorAll('[data-message-author-role], article[data-testid*="conversation-turn"]'));
+        nodes = nodes.filter((node) => node instanceof HTMLElement && isVisible(node));
+
+        const rows = [];
+        const seen = new Set();
+        for (const node of nodes) {
+            let role = roleOf(node);
+            const roleNode = node.querySelector('[data-message-author-role], [data-author]');
+            if (!role && roleNode) role = roleOf(roleNode);
+            if (!role) continue;
+
+            const contentNode = node.querySelector('[data-message-author-role] .markdown')
+                || node.querySelector('.markdown')
+                || node.querySelector('[data-message-author-role]')
+                || node;
+            const html = contentNode instanceof HTMLElement ? (contentNode.innerHTML || '') : '';
+            const text = normalize(contentNode instanceof HTMLElement ? (contentNode.innerText || contentNode.textContent || '') : '');
+            if (!text) continue;
+            const key = role + '\\n' + text;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            rows.push({ role, text, html });
+        }
+        return rows;
+    })()`);
+    if (!Array.isArray(result)) return [];
+    return result.map((item, index) => ({
+        Index: index + 1,
+        Role: item?.role === 'Assistant' ? 'Assistant' : 'User',
+        Text: String(item?.text || '').trim(),
+        Html: String(item?.html || ''),
+    })).filter((item) => item.Text);
+}
+
+export function messageHtmlToMarkdown(html) {
+    try {
+        return htmlToMarkdown(html).trim();
+    } catch {
+        return String(html || '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    }
+}
+
+export async function getBubbleCount(page) {
+    const messages = await getVisibleMessages(page);
+    return messages.length;
+}
+
+export async function waitForChatGPTResponse(page, baselineCount, prompt, timeoutSeconds) {
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+
+    while (Date.now() - startTime < timeoutSeconds * 1000) {
+        await page.wait(3);
+        if (await isGenerating(page)) {
+            stableCount = 0;
+            continue;
+        }
+
+        const messages = await getVisibleMessages(page);
+        const newMessages = messages.slice(Math.max(0, baselineCount));
+        const assistant = [...newMessages].reverse().find((m) => m.Role === 'Assistant')
+            || [...messages].reverse().find((m) => m.Role === 'Assistant');
+        const candidate = String(assistant?.Text || '').trim();
+        if (!candidate || candidate === String(prompt || '').trim()) continue;
+
+        if (candidate === lastText) {
+            stableCount += 1;
+            if (stableCount >= 2) return candidate;
+        } else {
+            lastText = candidate;
+            stableCount = 0;
+        }
+    }
+
+    throw new TimeoutError(
+        'chatgpt ask',
+        timeoutSeconds,
+        'No ChatGPT response appeared before timeout. Re-run with a higher --timeout if it is still generating.',
+    );
+}
+
+export async function getConversationList(page) {
+    await ensureOnChatGPT(page);
+    await page.wait(2);
+
+    const openSidebar = await page.evaluate(`(() => {
+        const button = Array.from(document.querySelectorAll('button'))
+            .find((node) => /open sidebar/i.test(node.getAttribute('aria-label') || ''));
+        if (button instanceof HTMLElement) {
+            button.click();
+            return true;
+        }
+        return false;
+    })()`);
+    if (openSidebar) await page.wait(1);
+
+    let items = await extractConversationLinks(page);
+    if (!items.length) {
+        await page.goto(CHATGPT_URL, { settleMs: 2000 });
+        await page.wait(2);
+        items = await extractConversationLinks(page);
+    }
+
+    return items;
+}
+
+async function extractConversationLinks(page) {
+    const items = await page.evaluate(`(() => {
+        const isVisible = (el) => {
+            if (!(el instanceof HTMLElement)) return false;
+            const style = window.getComputedStyle(el);
+            if (style.display === 'none' || style.visibility === 'hidden') return false;
+            const rect = el.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        };
+        const links = Array.from(document.querySelectorAll('a[href*="/c/"]'))
+            .filter((link) => link instanceof HTMLAnchorElement && isVisible(link));
+        const seen = new Set();
+        const rows = [];
+        for (const link of links) {
+            const href = link.getAttribute('href') || '';
+            const match = href.match(/\\/c\\/([^/?#]+)/);
+            if (!match || seen.has(match[1])) continue;
+            seen.add(match[1]);
+            const title = (link.innerText || link.textContent || '').replace(/\\s+/g, ' ').trim() || '(untitled)';
+            rows.push({
+                Id: match[1],
+                Title: title,
+                Url: href.startsWith('http') ? href : ('${CHATGPT_URL}' + href),
+            });
+        }
+        return rows;
+    })()`);
+    return Array.isArray(items)
+        ? items.map((item, index) => ({
+            Index: index + 1,
+            Id: String(item?.Id || ''),
+            Title: String(item?.Title || '(untitled)').trim() || '(untitled)',
+            Url: String(item?.Url || ''),
+        })).filter((item) => item.Id)
+        : [];
+}
+
 /**
  * Check if ChatGPT is still generating a response.
  */
@@ -244,7 +532,9 @@ export async function waitForChatGPTImages(page, beforeUrls, timeoutSeconds, con
 
 export const __test__ = {
     COMPOSER_SELECTORS,
+    SEND_BUTTON_LABELS,
     isSameChatGPTConversation,
+    parseChatGPTConversationId,
 };
 
 /**

package/clis/chatgpt/utils.test.js

@@ -61,3 +61,16 @@ describe('chatgpt image wait contract', () => {
         )).toBe(false);
     });
 });
+
+describe('chatgpt conversation id parsing', () => {
+    it('accepts ids and chatgpt conversation URLs', () => {
+        expect(__test__.parseChatGPTConversationId('abc_123-def')).toBe('abc_123-def');
+        expect(__test__.parseChatGPTConversationId('https://chatgpt.com/c/abc_123-def?model=gpt-5')).toBe('abc_123-def');
+        expect(__test__.parseChatGPTConversationId('/c/abc_123-def')).toBe('abc_123-def');
+    });
+
+    it('rejects invalid detail ids', () => {
+        expect(() => __test__.parseChatGPTConversationId('')).toThrow(/conversation id/);
+        expect(() => __test__.parseChatGPTConversationId('https://chatgpt.com/')).toThrow(/conversation id/);
+    });
+});

package/clis/chatgpt-app/ask.js

@@ -1,6 +1,6 @@
 import { execSync } from 'node:child_process';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { ConfigError } from '@jackwener/opencli/errors';
+import { ArgumentError, ConfigError } from '@jackwener/opencli/errors';
 import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating, sendPrompt } from './ax.js';
 export const askCommand = cli({
     site: 'chatgpt-app',
@@ -13,7 +13,7 @@ export const askCommand = cli({
     args: [
         { name: 'text', required: true, positional: true, help: 'Prompt to send' },
         { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
-        { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for response (default: 30)', default: 30 },
     ],
     columns: ['Role', 'Text'],
     func: async (kwargs) => {
@@ -22,7 +22,10 @@ export const askCommand = cli({
         }
         const text = kwargs.text;
         const model = kwargs.model;
-        const timeout = parseInt(kwargs.timeout, 10) || 30;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
         // Switch model before sending if requested
         if (model) {
             activateChatGPT();

package/clis/chatwise/ask.js

@@ -1,5 +1,11 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { selectorError } from '@jackwener/opencli/errors';
+import { selectorError, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    buildChatwiseInjectTextJs,
+    buildChatwiseMessageCountJs,
+    buildChatwiseResponseAfterJs,
+    requirePositiveTimeout,
+} from './utils.js';
 export const askCommand = cli({
     site: 'chatwise',
     name: 'ask',
@@ -10,39 +16,16 @@ export const askCommand = cli({
     browser: true,
     args: [
         { name: 'text', required: true, positional: true, help: 'Prompt to send' },
-        { name: 'timeout', required: false, help: 'Max seconds to wait (default: 30)', default: '30' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait (default: 30)', default: 30 },
     ],
     columns: ['Role', 'Text'],
     func: async (page, kwargs) => {
         const text = kwargs.text;
-        const timeout = parseInt(kwargs.timeout, 10) || 30;
+        const timeout = requirePositiveTimeout(kwargs.timeout);
         // Snapshot content length
-        const beforeLen = await page.evaluate(`
-      (function() {
-        const msgs = document.querySelectorAll('[data-message-id], [class*="message"], [class*="bubble"]');
-        return msgs.length;
-      })()
-    `);
+        const beforeLen = await page.evaluate(buildChatwiseMessageCountJs());
         // Send message
-        const injected = await page.evaluate(`
-      (function(text) {
-        let composer = document.querySelector('textarea');
-        if (!composer) {
-          const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
-          composer = editables.length > 0 ? editables[editables.length - 1] : null;
-        }
-        if (!composer) return false;
-        composer.focus();
-        if (composer.tagName === 'TEXTAREA') {
-          const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
-          setter.call(composer, text);
-          composer.dispatchEvent(new Event('input', { bubbles: true }));
-        } else {
-          document.execCommand('insertText', false, text);
-        }
-        return true;
-      })(${JSON.stringify(text)})
-    `);
+        const injected = await page.evaluate(buildChatwiseInjectTextJs(text));
         if (!injected)
             throw selectorError('ChatWise input element');
         await page.wait(0.5);
@@ -53,25 +36,15 @@ export const askCommand = cli({
         let response = '';
         for (let i = 0; i < maxPolls; i++) {
             await page.wait(pollInterval);
-            const result = await page.evaluate(`
-        (function(prevLen) {
-          const msgs = document.querySelectorAll('[data-message-id], [class*="message"], [class*="bubble"]');
-          if (msgs.length <= prevLen) return null;
-          const last = msgs[msgs.length - 1];
-          const text = last.innerText || last.textContent;
-          return text ? text.trim() : null;
-        })(${beforeLen})
-      `);
+            const result = await page.evaluate(buildChatwiseResponseAfterJs(beforeLen, text));
             if (result) {
-                response = result;
-                break;
+                const next = String(result).trim();
+                if (next === response) break;
+                response = next;
             }
         }
         if (!response) {
-            return [
-                { Role: 'User', Text: text },
-                { Role: 'System', Text: `No response within ${timeout}s.` },
-            ];
+            throw new TimeoutError('ChatWise response', timeout, 'Confirm ChatWise is done generating, then retry with a larger --timeout if needed.');
         }
         return [
             { Role: 'User', Text: text },

package/clis/chatwise/composer.test.js

@@ -0,0 +1,186 @@
+import { JSDOM } from 'jsdom';
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    buildChatwiseInjectTextJs,
+    buildChatwiseMessageCountJs,
+    buildChatwiseResponseAfterJs,
+    requirePositiveTimeout,
+    scoreChatwiseComposerCandidate,
+    selectBestChatwiseComposer,
+} from './utils.js';
+import { askCommand } from './ask.js';
+
+function candidate(overrides = {}) {
+    return {
+        index: 0,
+        hidden: false,
+        role: 'textbox',
+        classes: 'cm-content cm-lineWrapping',
+        editorClasses: 'cm-editor',
+        ariaLabel: '',
+        placeholder: '',
+        text: '',
+        rect: { y: 0, h: 30 },
+        ...overrides,
+    };
+}
+
+function runBrowserScript(html, script) {
+    const dom = new JSDOM(html, { url: 'app://chatwise.local/', runScripts: 'outside-only' });
+    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetWidth', { configurable: true, get: () => 400 });
+    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetHeight', { configurable: true, get: () => 32 });
+    dom.window.HTMLElement.prototype.getClientRects = () => [{ length: 1 }];
+    dom.window.document.execCommand = () => false;
+    return { dom, result: dom.window.eval(script) };
+}
+
+function makePage(evaluateResults = []) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) evaluate.mockResolvedValueOnce(result);
+    evaluate.mockResolvedValue(null);
+    return {
+        evaluate,
+        wait: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+    };
+}
+
+describe('chatwise composer selection', () => {
+    it('prefers the main composer over auxiliary contenteditable editors', () => {
+        const mainComposer = candidate({
+            index: 0,
+            placeholder: 'placeholder Enter a message here, press ⏎ to send',
+            rect: { y: 860, h: 32 },
+        });
+        const optionalDescription = candidate({
+            index: 1,
+            placeholder: 'placeholder Optional description',
+            editorClasses: 'cm-editor simple-editor',
+            rect: { y: 400, h: 32 },
+        });
+        const userContext = candidate({
+            index: 2,
+            text: '# User Context Document',
+            editorClasses: 'cm-editor simple-editor',
+            rect: { y: 460, h: 1200 },
+        });
+
+        expect(scoreChatwiseComposerCandidate(mainComposer, 900)).toBeGreaterThan(
+            scoreChatwiseComposerCandidate(optionalDescription, 900),
+        );
+        expect(scoreChatwiseComposerCandidate(mainComposer, 900)).toBeGreaterThan(
+            scoreChatwiseComposerCandidate(userContext, 900),
+        );
+
+        expect(selectBestChatwiseComposer([
+            optionalDescription,
+            userContext,
+            mainComposer,
+        ], 900)?.index).toBe(0);
+    });
+
+    it('rejects hidden or low-confidence candidates instead of injecting into the wrong editor', () => {
+        expect(selectBestChatwiseComposer([
+            candidate({
+                index: 0,
+                hidden: true,
+                placeholder: 'Enter a message here, press ⏎ to send',
+                rect: { y: 860, h: 32 },
+            }),
+        ], 900)).toBeNull();
+
+        expect(selectBestChatwiseComposer([
+            candidate({
+                index: 1,
+                placeholder: 'Optional description',
+                editorClasses: 'cm-editor simple-editor',
+                rect: { y: 860, h: 32 },
+            }),
+            candidate({
+                index: 2,
+                text: '# User Context Document',
+                editorClasses: 'cm-editor simple-editor',
+                rect: { y: 870, h: 32 },
+            }),
+        ], 900)).toBeNull();
+    });
+
+    it('injects text into the scored main composer instead of the last contenteditable', () => {
+        const html = `
+          <div class="cm-editor simple-editor">
+            <div class="cm-placeholder">Optional description</div>
+            <div id="optional" contenteditable="true" role="textbox"></div>
+          </div>
+          <div class="cm-editor">
+            <div class="cm-placeholder">Enter a message here, press ⏎ to send</div>
+            <div id="main" class="cm-content" contenteditable="true" role="textbox"></div>
+          </div>
+          <div class="cm-editor simple-editor">
+            <div id="context" contenteditable="true" role="textbox"># User Context Document</div>
+          </div>
+        `;
+
+        const { dom, result } = runBrowserScript(html, buildChatwiseInjectTextJs('hello'));
+
+        expect(result).toBe(true);
+        expect(dom.window.document.querySelector('#main')?.textContent).toBe('hello');
+        expect(dom.window.document.querySelector('#optional')?.textContent).toBe('');
+        expect(dom.window.document.querySelector('#context')?.textContent).toBe('# User Context Document');
+    });
+
+    it('fails injection when only auxiliary editors are present', () => {
+        const html = `
+          <div class="cm-editor simple-editor">
+            <div class="cm-placeholder">Optional description</div>
+            <div id="optional" contenteditable="true" role="textbox"></div>
+          </div>
+          <div class="cm-editor simple-editor">
+            <div id="context" contenteditable="true" role="textbox"># User Context Document</div>
+          </div>
+        `;
+
+        const { dom, result } = runBrowserScript(html, buildChatwiseInjectTextJs('hello'));
+
+        expect(result).toBe(false);
+        expect(dom.window.document.querySelector('#optional')?.textContent).toBe('');
+        expect(dom.window.document.querySelector('#context')?.textContent).toBe('# User Context Document');
+    });
+
+    it('reads only real message wrapper content after the previous count', () => {
+        const html = `
+          <div class="group/message">old message</div>
+          <div class="timestamp">12:00</div>
+          <div class="group/message">new assistant answer</div>
+        `;
+
+        expect(runBrowserScript(html, buildChatwiseMessageCountJs()).result).toBe(2);
+        expect(runBrowserScript(html, buildChatwiseResponseAfterJs(1, 'user prompt')).result).toBe('new assistant answer');
+    });
+
+    it('does not treat the user prompt wrapper as an assistant response', () => {
+        const html = `
+          <div class="group/message">old message</div>
+          <div class="group/message">user prompt</div>
+        `;
+
+        expect(runBrowserScript(html, buildChatwiseResponseAfterJs(1, 'user prompt')).result).toBeNull();
+    });
+
+    it('validates timeout explicitly', () => {
+        expect(requirePositiveTimeout(30)).toBe(30);
+        expect(() => requirePositiveTimeout('30')).toThrow(ArgumentError);
+        expect(() => requirePositiveTimeout(0)).toThrow(ArgumentError);
+    });
+
+    it('fails fast when ask times out instead of returning a System success row', async () => {
+        const page = makePage([
+            1,
+            true,
+            null,
+        ]);
+
+        await expect(askCommand.func(page, { text: 'hello', timeout: 1 }))
+            .rejects.toBeInstanceOf(TimeoutError);
+    });
+});