@jackwener/opencli 1.7.12 → 1.7.13

package/clis/grok/ask.js

@@ -1,263 +1,26 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-const GROK_URL = 'https://grok.com/';
-const RESPONSE_SELECTOR = 'div.message-bubble, [data-testid="message-bubble"]';
-const BLOCKED_PREFIX = '[BLOCKED]';
-const NO_RESPONSE_PREFIX = '[NO RESPONSE]';
+import { CommandExecutionError, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    authRequired,
+    ensureOnGrok,
+    getMessageBubbles,
+    isLoggedIn,
+    normalizeBooleanFlag,
+    sendMessage,
+    startNewChat,
+    waitForAnswer,
+} from './utils.js';
+
 const SESSION_HINT = 'Likely login/auth/challenge/session issue in the existing grok.com browser session.';
-function blocked(message) {
-    return [{ response: `${BLOCKED_PREFIX} ${message} ${SESSION_HINT}` }];
-}
-function normalizeBubbleText(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-function normalizeBooleanFlag(value) {
-    if (typeof value === 'boolean')
-        return value;
-    const normalized = String(value ?? '').trim().toLowerCase();
-    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
-}
-function pickLatestAssistantCandidate(bubbles, baselineCount, prompt) {
-    const normalizedPrompt = prompt.trim();
-    const freshBubbles = bubbles
-        .slice(Math.max(0, baselineCount))
-        .map(normalizeBubbleText)
-        .filter(Boolean);
-    for (let i = freshBubbles.length - 1; i >= 0; i -= 1) {
-        if (freshBubbles[i] !== normalizedPrompt)
-            return freshBubbles[i];
+
+async function getBaselineLastAssistantId(page) {
+    const bubbles = await getMessageBubbles(page);
+    for (let i = bubbles.length - 1; i >= 0; i -= 1) {
+        if (bubbles[i].role === 'Assistant') return bubbles[i].id;
     }
     return '';
 }
-function updateStableState(previousText, stableCount, nextText) {
-    if (!nextText)
-        return { previousText: '', stableCount: 0 };
-    if (nextText === previousText)
-        return { previousText, stableCount: stableCount + 1 };
-    return { previousText: nextText, stableCount: 0 };
-}
-/** Check whether the tab is already on grok.com (any path). */
-async function isOnGrok(page) {
-    // catch handles blank tabs (about:blank) or detached pages
-    const url = await page.evaluate('window.location.href').catch(() => '');
-    if (typeof url !== 'string' || !url)
-        return false;
-    try {
-        const hostname = new URL(url).hostname;
-        return hostname === 'grok.com' || hostname.endsWith('.grok.com');
-    }
-    catch {
-        return false;
-    }
-}
-async function runDefaultAsk(page, prompt, timeoutMs, newChat) {
-    if (newChat) {
-        // Explicitly start a fresh conversation via the homepage
-        await page.goto(GROK_URL);
-        await page.wait(2);
-        await tryStartFreshChat(page);
-        await page.wait(2);
-    }
-    else if (!(await isOnGrok(page))) {
-        // First invocation or tab was recycled — navigate to Grok
-        await page.goto(GROK_URL);
-        await page.wait(3);
-    }
-    const promptJson = JSON.stringify(prompt);
-    const sendResult = await page.evaluate(`(async () => {
-    try {
-      const box = document.querySelector('textarea');
-      if (!box) return { ok: false, msg: 'no textarea' };
-      box.focus(); box.value = '';
-      document.execCommand('selectAll');
-      document.execCommand('insertText', false, ${promptJson});
-      await new Promise(r => setTimeout(r, 1500));
-      const btn = document.querySelector('button[aria-label="\\u63d0\\u4ea4"]');
-      if (btn && !btn.disabled) { btn.click(); return { ok: true, msg: 'clicked' }; }
-      const sub = [...document.querySelectorAll('button[type="submit"]')].find(b => !b.disabled);
-      if (sub) { sub.click(); return { ok: true, msg: 'clicked-submit' }; }
-      box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
-      return { ok: true, msg: 'enter' };
-    } catch (e) { return { ok: false, msg: e.toString() }; }
-  })()`);
-    if (!sendResult || !sendResult.ok) {
-        return [{ response: '[SEND FAILED] ' + JSON.stringify(sendResult) }];
-    }
-    const startTime = Date.now();
-    let lastText = '';
-    let stableCount = 0;
-    while (Date.now() - startTime < timeoutMs) {
-        await page.wait(3);
-        const response = await page.evaluate(`(() => {
-      const bubbles = document.querySelectorAll('div.message-bubble, [data-testid="message-bubble"]');
-      if (bubbles.length < 2) return '';
-      const last = bubbles[bubbles.length - 1];
-      const text = (last.innerText || '').trim();
-      if (!text || text.length < 2) return '';
-      return text;
-    })()`);
-        if (response && response.length > 2) {
-            if (response === lastText) {
-                stableCount++;
-                if (stableCount >= 2)
-                    return [{ response }];
-            }
-            else {
-                stableCount = 0;
-            }
-        }
-        lastText = response || '';
-    }
-    if (lastText)
-        return [{ response: lastText }];
-    return [{ response: NO_RESPONSE_PREFIX }];
-}
-async function getBubbleTexts(page) {
-    const result = await page.evaluate(`(() => {
-    return Array.from(document.querySelectorAll(${JSON.stringify(RESPONSE_SELECTOR)}))
-      .map(node => (node instanceof HTMLElement ? node.innerText : node?.textContent || ''))
-      .map(text => (typeof text === 'string' ? text.trim() : ''))
-      .filter(Boolean);
-  })()`);
-    return Array.isArray(result) ? result.map(normalizeBubbleText).filter(Boolean) : [];
-}
-async function tryStartFreshChat(page) {
-    await page.evaluate(`(() => {
-    const isVisible = (node) => {
-      if (!(node instanceof HTMLElement)) return false;
-      const rect = node.getBoundingClientRect();
-      const style = window.getComputedStyle(node);
-      return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
-    };
-
-    const candidates = Array.from(document.querySelectorAll('a, button')).filter(node => {
-      if (!isVisible(node)) return false;
-      const text = (node.textContent || '').trim().toLowerCase();
-      const aria = (node.getAttribute('aria-label') || '').trim().toLowerCase();
-      const href = node.getAttribute('href') || '';
-      return text.includes('new chat')
-        || text.includes('new conversation')
-        || aria.includes('new chat')
-        || aria.includes('new conversation')
-        || href === '/';
-    });
-
-    const target = candidates[0];
-    if (target instanceof HTMLElement) target.click();
-  })()`);
-}
-async function sendPromptViaExplicitWeb(page, prompt) {
-    return page.evaluate(`(async () => {
-    const waitFor = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-    const composerSelector = '.ProseMirror[contenteditable="true"]';
-    let composer = null;
-
-    for (let attempt = 0; attempt < 12; attempt += 1) {
-      const candidate = document.querySelector(composerSelector);
-      if (candidate instanceof HTMLElement) {
-        composer = candidate;
-        break;
-      }
-
-      await waitFor(1000);
-    }
-
-    if (!(composer instanceof HTMLElement)) {
-      return {
-        ok: false,
-        reason: 'Grok composer was not found on grok.com.',
-      };
-    }
-
-    const editor = composer.editor;
-    if (!editor?.commands?.focus || !editor?.commands?.insertContent) {
-      return {
-        ok: false,
-        reason: 'Grok composer editor API was unavailable.',
-      };
-    }
 
-    const isVisibleEnabledSubmit = (node) => {
-      if (!(node instanceof HTMLButtonElement)) return false;
-      const rect = node.getBoundingClientRect();
-      const style = window.getComputedStyle(node);
-      return !node.disabled
-        && rect.width > 0
-        && rect.height > 0
-        && style.visibility !== 'hidden'
-        && style.display !== 'none';
-    };
-
-    try {
-      if (editor.commands.clearContent) editor.commands.clearContent();
-      editor.commands.focus();
-      editor.commands.insertContent(${JSON.stringify(prompt)});
-    } catch (error) {
-      return {
-        ok: false,
-        reason: 'Failed to insert the prompt into the Grok composer.',
-        detail: error instanceof Error ? error.message : String(error),
-      };
-    }
-
-    let submit = null;
-    for (let attempt = 0; attempt < 6; attempt += 1) {
-      const candidate = Array.from(document.querySelectorAll('button[aria-label="Submit"]'))
-        .find(isVisibleEnabledSubmit);
-
-      if (candidate instanceof HTMLButtonElement) {
-        submit = candidate;
-        break;
-      }
-
-      await waitFor(500);
-    }
-
-    if (!(submit instanceof HTMLButtonElement)) {
-      return {
-        ok: false,
-        reason: 'Grok submit button did not reach a clickable ready state after prompt insertion.',
-      };
-    }
-
-    submit.click();
-    return { ok: true };
-  })()`);
-}
-async function runExplicitWebAsk(page, prompt, timeoutMs, newChat) {
-    if (newChat) {
-        // Navigate to homepage and start a fresh conversation
-        await page.goto(GROK_URL, { settleMs: 2000 });
-        await tryStartFreshChat(page);
-        await page.wait(2);
-    }
-    else if (!(await isOnGrok(page))) {
-        // First invocation or tab was recycled — navigate to Grok
-        await page.goto(GROK_URL, { settleMs: 2000 });
-    }
-    const baselineBubbles = await getBubbleTexts(page);
-    const sendResult = await sendPromptViaExplicitWeb(page, prompt);
-    if (!sendResult?.ok) {
-        const details = sendResult?.detail ? ` ${sendResult.detail}` : '';
-        return blocked(`${sendResult?.reason || 'Unable to send the prompt to Grok.'}${details}`);
-    }
-    const startTime = Date.now();
-    let lastText = '';
-    let stableCount = 0;
-    while (Date.now() - startTime < timeoutMs) {
-        await page.wait(2);
-        const bubbleTexts = await getBubbleTexts(page);
-        const candidate = pickLatestAssistantCandidate(bubbleTexts, baselineBubbles.length, prompt);
-        const nextState = updateStableState(lastText, stableCount, candidate);
-        lastText = nextState.previousText;
-        stableCount = nextState.stableCount;
-        if (candidate && stableCount >= 2) {
-            return [{ response: candidate }];
-        }
-    }
-    if (lastText)
-        return [{ response: lastText }];
-    return [{ response: `${NO_RESPONSE_PREFIX} No new assistant message bubble appeared within ${Math.round(timeoutMs / 1000)}s.` }];
-}
 export const askCommand = cli({
     site: 'grok',
     name: 'ask',
@@ -266,28 +29,49 @@ export const askCommand = cli({
     domain: 'grok.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     args: [
         { name: 'prompt', positional: true, type: 'string', required: true, help: 'Prompt to send to Grok' },
         { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response (default: 120)' },
         { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending (default: false)' },
-        { name: 'web', type: 'boolean', default: false, help: 'Use the explicit grok.com consumer web flow (default: false)' },
     ],
     columns: ['response'],
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
-        const timeoutMs = (kwargs.timeout || 120) * 1000;
+        const timeoutSeconds = kwargs.timeout || 120;
         const newChat = normalizeBooleanFlag(kwargs.new);
-        const useExplicitWeb = normalizeBooleanFlag(kwargs.web);
-        if (useExplicitWeb) {
-            return runExplicitWebAsk(page, prompt, timeoutMs, newChat);
+
+        if (newChat) {
+            await startNewChat(page);
+        } else {
+            await ensureOnGrok(page);
         }
-        return runDefaultAsk(page, prompt, timeoutMs, newChat);
+
+        if (!(await isLoggedIn(page))) {
+            throw authRequired();
+        }
+
+        const baselineLastAssistantId = await getBaselineLastAssistantId(page);
+        const sendResult = await sendMessage(page, prompt);
+        if (!sendResult || !sendResult.ok) {
+            const reason = sendResult?.reason || 'Unable to send the prompt to Grok.';
+            const detail = sendResult?.detail ? ` ${sendResult.detail}` : '';
+            throw new CommandExecutionError(`${reason}${detail}`, SESSION_HINT);
+        }
+
+        const result = await waitForAnswer(page, prompt, timeoutSeconds, baselineLastAssistantId);
+        if (result.status === 'ok') {
+            return [{ response: result.assistant.text }];
+        }
+        // Partial: streaming was seen but did not stabilize; keep the best-effort
+        // text rather than throwing — the caller asked us to wait, not to discard.
+        if (result.status === 'partial' && result.assistant) {
+            return [{ response: result.assistant.text }];
+        }
+        throw new TimeoutError('grok ask response', timeoutSeconds);
     },
 });
+
 export const __test__ = {
-    pickLatestAssistantCandidate,
-    updateStableState,
-    normalizeBooleanFlag,
-    normalizeBubbleText,
-    isOnGrok,
+    getBaselineLastAssistantId,
 };

package/clis/grok/ask.test.js

@@ -1,54 +1,29 @@
 import { describe, expect, it } from 'vitest';
 import { __test__ } from './ask.js';
+
 describe('grok ask helpers', () => {
-    describe('isOnGrok', () => {
-        const fakePage = (url) => ({ evaluate: () => url instanceof Error ? Promise.reject(url) : Promise.resolve(url) });
-        it('returns true for grok.com URLs', async () => {
-            expect(await __test__.isOnGrok(fakePage('https://grok.com/'))).toBe(true);
-            expect(await __test__.isOnGrok(fakePage('https://grok.com/chat/abc123'))).toBe(true);
+    describe('getBaselineLastAssistantId', () => {
+        const fakePage = (bubbles) => ({
+            // getMessageBubbles in utils.js drives a page.evaluate; in tests we
+            // route directly to the in-memory bubble array.
+            evaluate: () => Promise.resolve(bubbles),
         });
-        it('returns true for grok.com subdomains', async () => {
-            expect(await __test__.isOnGrok(fakePage('https://api.grok.com/v1'))).toBe(true);
+
+        it('returns the id of the most recent Assistant bubble, ignoring later User turns', async () => {
+            const bubbles = [
+                { id: 'a1', role: 'Assistant', text: 'first answer', html: '' },
+                { id: 'u1', role: 'User', text: 'follow-up', html: '' },
+                { id: 'a2', role: 'Assistant', text: 'second answer', html: '' },
+                { id: 'u2', role: 'User', text: 'newest user turn', html: '' },
+            ];
+            expect(await __test__.getBaselineLastAssistantId(fakePage(bubbles))).toBe('a2');
         });
-        it('returns false for non-grok domains', async () => {
-            expect(await __test__.isOnGrok(fakePage('https://fakegrok.com/'))).toBe(false);
-            expect(await __test__.isOnGrok(fakePage('https://example.com/?next=grok.com'))).toBe(false);
-            expect(await __test__.isOnGrok(fakePage('about:blank'))).toBe(false);
-        });
-        it('returns false when evaluate throws (detached tab)', async () => {
-            expect(await __test__.isOnGrok(fakePage(new Error('detached')))).toBe(false);
-        });
-    });
-    it('normalizes boolean flags for explicit web routing', () => {
-        expect(__test__.normalizeBooleanFlag(true)).toBe(true);
-        expect(__test__.normalizeBooleanFlag('true')).toBe(true);
-        expect(__test__.normalizeBooleanFlag('1')).toBe(true);
-        expect(__test__.normalizeBooleanFlag('yes')).toBe(true);
-        expect(__test__.normalizeBooleanFlag('on')).toBe(true);
-        expect(__test__.normalizeBooleanFlag(false)).toBe(false);
-        expect(__test__.normalizeBooleanFlag('false')).toBe(false);
-        expect(__test__.normalizeBooleanFlag(undefined)).toBe(false);
-    });
-    it('ignores baseline bubbles and the echoed prompt when choosing the latest assistant candidate', () => {
-        const candidate = __test__.pickLatestAssistantCandidate(['older assistant answer', 'Prompt text', 'Assistant draft', 'Assistant final'], 1, 'Prompt text');
-        expect(candidate).toBe('Assistant final');
-    });
-    it('returns empty when only the echoed prompt appeared after send', () => {
-        const candidate = __test__.pickLatestAssistantCandidate(['older assistant answer', 'Prompt text'], 1, 'Prompt text');
-        expect(candidate).toBe('');
-    });
-    it('tracks stabilization by incrementing repeats and resetting on changes', () => {
-        expect(__test__.updateStableState('', 0, 'First chunk')).toEqual({
-            previousText: 'First chunk',
-            stableCount: 0,
-        });
-        expect(__test__.updateStableState('First chunk', 0, 'First chunk')).toEqual({
-            previousText: 'First chunk',
-            stableCount: 1,
-        });
-        expect(__test__.updateStableState('First chunk', 1, 'Second chunk')).toEqual({
-            previousText: 'Second chunk',
-            stableCount: 0,
+
+        it('returns empty string when no Assistant bubble exists yet (fresh chat)', async () => {
+            expect(await __test__.getBaselineLastAssistantId(fakePage([]))).toBe('');
+            expect(await __test__.getBaselineLastAssistantId(fakePage([
+                { id: 'u1', role: 'User', text: 'hello', html: '' },
+            ]))).toBe('');
         });
     });
 });

package/clis/grok/detail.js

@@ -0,0 +1,60 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    GROK_DOMAIN,
+    bubbleHtmlToMarkdown,
+    getMessageBubbles,
+    normalizeBooleanFlag,
+    parseGrokSessionId,
+} from './utils.js';
+
+cli({
+    site: 'grok',
+    name: 'detail',
+    access: 'read',
+    description: 'Open a Grok conversation by ID and read its messages',
+    domain: GROK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    browserSession: { reuse: 'site' },
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Session ID (UUID) or full https://grok.com/c/<id> URL' },
+        { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant replies as markdown' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const sessionId = parseGrokSessionId(kwargs.id);
+        const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
+
+        await page.goto(`https://grok.com/c/${sessionId}`);
+        await page.wait(2);
+
+        // Poll for the conversation transcript to load. Grok renders the chat
+        // page shell before fetching message history, so a fixed wait can race
+        // the initial empty render. Cap at ~20s so genuinely missing IDs surface
+        // an EmptyResultError rather than hanging.
+        let bubbles = [];
+        const POLL_DEADLINE_MS = 20_000;
+        const POLL_INTERVAL_S = 1;
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < POLL_DEADLINE_MS) {
+            bubbles = await getMessageBubbles(page);
+            if (bubbles.length > 0) break;
+            await page.wait(POLL_INTERVAL_S);
+        }
+
+        if (!bubbles.length) {
+            throw new EmptyResultError(
+                'grok detail',
+                `No visible messages found for conversation ${sessionId}. Verify the ID is correct and that the conversation belongs to the signed-in account.`,
+            );
+        }
+        return bubbles.map((b) => ({
+            Role: b.role,
+            Text: wantMarkdown && b.role === 'Assistant' && b.html
+                ? (bubbleHtmlToMarkdown(b.html) || b.text)
+                : b.text,
+        }));
+    },
+});

package/clis/grok/history.js

@@ -0,0 +1,48 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    GROK_DOMAIN,
+    authRequired,
+    ensureOnGrok,
+    getHistoryFromSidebar,
+    isLoggedIn,
+} from './utils.js';
+
+cli({
+    site: 'grok',
+    name: 'history',
+    access: 'read',
+    description: 'List recent Grok conversations from the sidebar (requires login)',
+    domain: GROK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show (default 20, max 100)' },
+    ],
+    columns: ['Index', 'Title', 'Url'],
+    func: async (page, kwargs) => {
+        const limit = Number(kwargs.limit ?? 20);
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new ArgumentError('limit', 'must be a positive integer');
+        }
+        if (limit > 100) {
+            throw new ArgumentError('limit', 'must be <= 100');
+        }
+        await ensureOnGrok(page);
+        await page.wait(2);
+        if (!(await isLoggedIn(page))) {
+            throw authRequired();
+        }
+        const sessions = await getHistoryFromSidebar(page, limit);
+        if (!sessions.length) {
+            throw new EmptyResultError('grok history', 'No Grok conversations found in the sidebar for the signed-in account.');
+        }
+        return sessions.slice(0, limit).map((s, i) => ({
+            Index: i + 1,
+            Title: s.title || '(untitled)',
+            Url: `https://grok.com/c/${s.id}`,
+        }));
+    },
+});