publishport-opencli 1.8.4-pp.1

package/clis/grok/ask.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './ask.js';
+
+describe('grok ask helpers', () => {
+    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 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 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/auth.js

@@ -0,0 +1,52 @@
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { registerSiteAuthCommands } from '../_shared/site-auth.js';
+
+async function hasGrokSessionCookie(page) {
+  const cookies = await page.getCookies({ url: 'https://grok.com' });
+  return cookies.some(c => c.name === '__Secure-next-auth.session-token' && c.value);
+}
+
+async function verifyGrokIdentity(page) {
+  if (!await hasGrokSessionCookie(page)) {
+    throw new AuthRequiredError('grok.com', 'Grok __Secure-next-auth.session-token cookie missing');
+  }
+  await page.goto('https://grok.com/');
+  await page.wait(2);
+  const result = await page.evaluate(`(async () => {
+    try {
+      const res = await fetch('/api/auth/session', { credentials: 'include', headers: { 'Accept': 'application/json' } });
+      if (res.status === 401 || res.status === 403) {
+        return { kind: 'auth', detail: 'Grok /api/auth/session HTTP ' + res.status };
+      }
+      if (!res.ok) return { kind: 'http', httpStatus: res.status };
+      const d = await res.json();
+      const user = d && d.user;
+      if (!user || !user.id) {
+        return { kind: 'auth', detail: 'Grok /api/auth/session has no user — anonymous' };
+      }
+      return { ok: true, user_id: String(user.id), name: String(user.name || '') };
+    } catch (e) {
+      return { kind: 'exception', detail: String(e && e.message || e) };
+    }
+  })()`);
+  if (result?.kind === 'auth') throw new AuthRequiredError('grok.com', result.detail);
+  if (result?.kind === 'http') throw new CommandExecutionError(`HTTP ${result.httpStatus} from /api/auth/session`);
+  if (result?.kind === 'exception') throw new CommandExecutionError(`Grok whoami failed: ${result.detail}`);
+  if (!result?.ok) throw new CommandExecutionError(`Unexpected Grok probe: ${JSON.stringify(result)}`);
+  return { user_id: result.user_id, name: result.name };
+}
+
+registerSiteAuthCommands({
+  site: 'grok',
+  domain: 'grok.com',
+  loginUrl: 'https://grok.com/auth/sign-in',
+  columns: ['user_id', 'name'],
+  quickCheck: hasGrokSessionCookie,
+  verify: verifyGrokIdentity,
+  poll: async (page) => {
+    if (!await hasGrokSessionCookie(page)) {
+      throw new AuthRequiredError('grok.com', 'Waiting for Grok session cookie');
+    }
+    return verifyGrokIdentity(page);
+  },
+});

package/clis/grok/delete.js

@@ -0,0 +1,54 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    GROK_DOMAIN,
+    ensureOnGrok,
+    authRequired,
+    isLoggedIn,
+    parseGrokSessionId,
+    clickConversationMenuItem,
+    normalizeBooleanFlag,
+    waitForConversationToDisappear,
+} from './utils.js';
+
+const SESSION_HINT = 'Likely login/auth/challenge/session issue in the existing grok.com browser session.';
+
+cli({
+    site: 'grok',
+    name: 'delete',
+    access: 'write',
+    description: 'Delete a Grok conversation by ID. Grok takes effect immediately with no confirmation dialog — require --yes to actually delete.',
+    domain: GROK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    siteSession: 'persistent',
+    args: [
+        { name: 'id', positional: true, type: 'string', required: true, help: 'Conversation UUID or grok.com/c/<uuid> URL' },
+        { name: 'yes', type: 'boolean', default: false, help: 'Actually delete (default is a dry-run preview)' },
+    ],
+    columns: ['status', 'id'],
+    func: async (page, kwargs) => {
+        const id = parseGrokSessionId(kwargs.id);
+        const yes = normalizeBooleanFlag(kwargs.yes);
+
+        await ensureOnGrok(page);
+        if (!(await isLoggedIn(page))) throw authRequired();
+
+        if (!yes) {
+            return [{ status: 'dry-run (pass --yes to actually delete)', id }];
+        }
+
+        const result = await clickConversationMenuItem(page, id, ['删除', 'delete']);
+        if (!result || !result.ok) {
+            const detail = result?.detail ? ` ${result.detail}` : '';
+            throw new CommandExecutionError(`${result?.reason || 'Failed to click delete menu item.'}${detail}`, SESSION_HINT);
+        }
+        if (!(await waitForConversationToDisappear(page, id))) {
+            throw new CommandExecutionError(
+                'Delete menu item was clicked, but the conversation is still visible in the sidebar.',
+                SESSION_HINT,
+            );
+        }
+        return [{ status: 'deleted', id }];
+    },
+});

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,
+    siteSession: 'persistent',
+    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/export-all.js

@@ -0,0 +1,409 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, EmptyResultError, TimeoutError } from '@jackwener/opencli/errors';
+import fs from 'node:fs';
+import {
+  normalizeConversationRows,
+  normalizeManifestRows,
+  requireBooleanEvaluateResult,
+  requireObjectEvaluateResult,
+} from './export-utils.js';
+
+const GROK_DOMAIN = 'grok.com';
+const GROK_URL = 'https://grok.com/';
+
+function normalizeInteger(value, defaultValue, label, { min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
+  const raw = value ?? defaultValue;
+  const n = Number(raw);
+  if (!Number.isInteger(n)) {
+    throw new ArgumentError(label, `must be an integer`);
+  }
+  if (n < min) {
+    throw new ArgumentError(label, `must be >= ${min}`);
+  }
+  if (n > max) {
+    throw new ArgumentError(label, `must be <= ${max}`);
+  }
+  return n;
+}
+
+async function waitRandom(page, minMs, maxMs) {
+  if (maxMs <= 0) return;
+  const span = Math.max(0, maxMs - minMs);
+  const ms = minMs + Math.floor(Math.random() * (span + 1));
+  if (ms > 0) await page.wait(ms / 1000);
+}
+
+function readManifest(manifestPath, { offset, limit }) {
+  const path = String(manifestPath || '').trim();
+  if (!path) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(path, 'utf8'));
+  } catch (error) {
+    throw new ArgumentError('manifestPath', `failed to read JSON manifest: ${error?.message || error}`);
+  }
+  const rows = normalizeManifestRows(parsed);
+  const sliced = limit ? rows.slice(offset, offset + limit) : rows.slice(offset);
+  if (!sliced.length) {
+    throw new EmptyResultError('grok export-all', `No manifest rows after offset=${offset}, limit=${limit}`);
+  }
+  return sliced;
+}
+
+async function collectHistory(page, { offset, limit, maxScrolls }) {
+  await page.goto(GROK_URL);
+  await page.wait(2);
+  const rawResult = await page.evaluate(`(async () => {
+    const targetLimit = ${JSON.stringify(limit > 0 ? offset + limit : 0)};
+    const maxScrolls = ${JSON.stringify(maxScrolls)};
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const isVisible = (node) => {
+      if (!(node instanceof Element)) return false;
+      const style = window.getComputedStyle(node);
+      if (style.visibility === 'hidden' || style.display === 'none') return false;
+      const rect = node.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0;
+    };
+    const hasHistoryEntry = Boolean(document.querySelector('a[href^="/c/"]'));
+    const hasHistoryLauncher = Array.from(document.querySelectorAll('button, [role="button"]'))
+      .some((node) => isVisible(node) && /^(查看全部|show all|view all)$/i.test((node.textContent || '').trim()));
+    const signInCta = Array.from(document.querySelectorAll('button, a'))
+      .some((node) => isVisible(node) && /^(sign in|log in)$/i.test((node.textContent || '').trim()));
+    if (signInCta && !hasHistoryEntry && !hasHistoryLauncher) {
+      return { ok: false, code: 'AUTH' };
+    }
+
+    const clickAllHistory = () => {
+      const buttons = Array.from(document.querySelectorAll('button, [role="button"]'))
+        .filter((node) => node instanceof HTMLElement && isVisible(node));
+      const target = buttons.find((node) => /^(查看全部|show all|view all)$/i.test((node.textContent || '').trim()));
+      if (!target) return false;
+      target.click();
+      return true;
+    };
+
+    if (!document.querySelector('[role="listbox"] a[href^="/c/"]')) {
+      clickAllHistory();
+    }
+
+    let listbox = null;
+    for (let attempt = 0; attempt < 30; attempt += 1) {
+      listbox = document.querySelector('[role="listbox"]');
+      if (listbox && listbox.querySelector('a[href^="/c/"]')) break;
+      await sleep(250);
+    }
+    if (!listbox || !listbox.querySelector('a[href^="/c/"]')) {
+      return { ok: false, code: 'NO_DIALOG' };
+    }
+
+    const scroller = Array.from(listbox.querySelectorAll('*'))
+      .find((node) => node.scrollHeight > node.clientHeight + 20) || listbox;
+    const seen = new Map();
+    const collect = () => {
+      for (const a of Array.from(listbox.querySelectorAll('a[href^="/c/"]'))) {
+        const href = a.getAttribute('href') || '';
+        const match = href.match(/^\\/c\\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
+        if (!match) continue;
+        const id = match[1].toLowerCase();
+        const option = a.closest('[role="option"]') || a.parentElement;
+        const lines = (option?.innerText || option?.textContent || a.textContent || '')
+          .split(/\\n+/)
+          .map((line) => line.trim())
+          .filter(Boolean);
+        seen.set(id, {
+          id,
+          title: lines[0] || '',
+          date: lines.slice(1).find(Boolean) || '',
+          url: 'https://grok.com/c/' + id,
+        });
+      }
+    };
+
+    scroller.scrollTop = 0;
+    scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
+    await sleep(250);
+
+    let lastCount = -1;
+    let lastHeight = -1;
+    let stableRounds = 0;
+    for (let attempt = 0; attempt < maxScrolls; attempt += 1) {
+      collect();
+      if (targetLimit > 0 && seen.size >= targetLimit) break;
+      scroller.scrollTop = scroller.scrollHeight;
+      scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
+      await sleep(350);
+      collect();
+      if (targetLimit > 0 && seen.size >= targetLimit) break;
+      if (seen.size === lastCount && scroller.scrollHeight === lastHeight) {
+        stableRounds += 1;
+      } else {
+        stableRounds = 0;
+        lastCount = seen.size;
+        lastHeight = scroller.scrollHeight;
+      }
+      if (targetLimit === 0 && stableRounds >= 8) break;
+    }
+
+    return { ok: true, rows: Array.from(seen.values()) };
+  })()`);
+
+  const result = requireObjectEvaluateResult(rawResult, 'grok export-all history dialog');
+  if (result.ok !== true) {
+    if (result?.code === 'AUTH') {
+      throw new AuthRequiredError(GROK_DOMAIN, 'Sign in to grok.com in the browser, then retry.');
+    }
+    if (result?.code === 'NO_DIALOG') {
+      throw new TimeoutError('grok export-all history dialog', 8);
+    }
+    throw new EmptyResultError('grok export-all', 'No Grok conversation history was visible.');
+  }
+  const validRows = normalizeConversationRows(result.rows, 'grok export-all history dialog');
+  if (!validRows.length) {
+    throw new EmptyResultError('grok export-all', 'No Grok conversations found in the signed-in account history.');
+  }
+  return limit ? validRows.slice(offset, offset + limit) : validRows.slice(offset);
+}
+
+async function readConversation(page, conversation, { pageTimeoutMs, pageScrolls, delayMinMs, delayMaxMs }) {
+  await page.goto(conversation.url);
+  const startedAt = Date.now();
+  let loaded = false;
+
+  while (Date.now() - startedAt < pageTimeoutMs) {
+    let loadedPayload;
+    try {
+      loadedPayload = await page.evaluate(`(() => {
+        return Boolean(document.querySelector('[data-testid="user-message"], [data-testid="assistant-message"]'));
+      })()`);
+      loaded = requireBooleanEvaluateResult(loadedPayload, 'grok export-all page load check');
+    } catch (error) {
+      return {
+        status: 'failed',
+        error: `Page load check failed: ${error?.message || error}`,
+        messageCount: 0,
+        messagesJson: '[]',
+      };
+    }
+    if (loaded) break;
+    await page.wait(1);
+  }
+  if (!loaded) {
+    return {
+      status: 'empty',
+      error: 'No visible message bubbles after waiting for page load.',
+      messageCount: 0,
+      messagesJson: '[]',
+    };
+  }
+
+  await waitRandom(page, delayMinMs, delayMaxMs);
+
+  let rawResult;
+  let result;
+  try {
+    rawResult = await page.evaluate(`(async () => {
+      const maxScrolls = ${JSON.stringify(pageScrolls)};
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const isVisible = (node) => {
+        if (!(node instanceof Element)) return false;
+        const style = window.getComputedStyle(node);
+        if (style.visibility === 'hidden' || style.display === 'none') return false;
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const messageSelector = '[data-testid="user-message"], [data-testid="assistant-message"]';
+      const findScrollableAncestors = () => {
+        const first = document.querySelector(messageSelector);
+        const out = [document.scrollingElement || document.documentElement];
+        let node = first ? first.parentElement : null;
+        while (node && node !== document.body) {
+          if (node.scrollHeight > node.clientHeight + 20) out.push(node);
+          node = node.parentElement;
+        }
+        return Array.from(new Set(out));
+      };
+      const scrollables = findScrollableAncestors();
+      const countMessages = () => Array.from(document.querySelectorAll(messageSelector)).filter(isVisible).length;
+
+      let lastCount = -1;
+      let lastBottom = -1;
+      let stableRounds = 0;
+      for (let attempt = 0; attempt < maxScrolls && stableRounds < 5; attempt += 1) {
+        for (const scroller of scrollables) {
+          scroller.scrollTop = scroller.scrollHeight;
+          scroller.dispatchEvent(new Event('scroll', { bubbles: true }));
+        }
+        window.scrollTo(0, document.documentElement.scrollHeight || document.body.scrollHeight);
+        await sleep(300);
+        const count = countMessages();
+        const bottom = Math.max(
+          document.documentElement.scrollHeight || 0,
+          document.body.scrollHeight || 0,
+          ...scrollables.map((node) => node.scrollHeight || 0),
+        );
+        if (count === lastCount && bottom === lastBottom) {
+          stableRounds += 1;
+        } else {
+          stableRounds = 0;
+          lastCount = count;
+          lastBottom = bottom;
+        }
+      }
+
+      const findResponseId = (node) => {
+        let parent = node.parentElement;
+        while (parent && parent !== document.body) {
+          const id = parent.getAttribute('id') || '';
+          if (id.startsWith('response-')) return id.slice('response-'.length);
+          parent = parent.parentElement;
+        }
+        return '';
+      };
+      const messages = [];
+      let position = 0;
+      for (const node of Array.from(document.querySelectorAll(messageSelector))) {
+        if (!(node instanceof HTMLElement) || !isVisible(node)) continue;
+        const isAssistant = node.getAttribute('data-testid') === 'assistant-message';
+        const text = (node.innerText || node.textContent || '').replace(/\\s+/g, ' ').trim();
+        const html = node.innerHTML || '';
+        if (!text && !html) continue;
+        messages.push({
+          messageIndex: messages.length + 1,
+          messageId: findResponseId(node) || ('pos-' + position),
+          messageRole: isAssistant ? 'assistant' : 'user',
+          messageText: text,
+        });
+        position += 1;
+      }
+      return { messages };
+    })()`);
+    result = requireObjectEvaluateResult(rawResult, 'grok export-all conversation reader');
+  } catch (error) {
+    return {
+      status: 'failed',
+      error: `Conversation reader failed: ${error?.message || error}`,
+      messageCount: 0,
+      messagesJson: '[]',
+    };
+  }
+  if (!Array.isArray(result.messages)) {
+    return {
+      status: 'failed',
+      error: 'Conversation reader returned malformed message rows.',
+      messageCount: 0,
+      messagesJson: '[]',
+    };
+  }
+  const messages = [];
+  for (let index = 0; index < result.messages.length; index += 1) {
+    const message = result.messages[index];
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+      return {
+        status: 'failed',
+        error: `Conversation reader returned malformed message row ${index + 1}.`,
+        messageCount: 0,
+        messagesJson: '[]',
+      };
+    }
+    const messageId = String(message.messageId || '').trim();
+    const messageText = String(message.messageText || '').trim();
+    if (!messageId || !messageText || (message.messageRole !== 'assistant' && message.messageRole !== 'user')) {
+      return {
+        status: 'failed',
+        error: `Conversation reader returned malformed message row ${index + 1}.`,
+        messageCount: 0,
+        messagesJson: '[]',
+      };
+    }
+    messages.push({
+      messageIndex: Number.isInteger(message.messageIndex) ? message.messageIndex : index + 1,
+      messageId,
+      messageRole: message.messageRole,
+      messageText,
+    });
+  }
+  if (!messages.length) {
+    return {
+      status: 'empty',
+      error: 'Page loaded, but no visible message text was found after scrolling to bottom.',
+      messageCount: 0,
+      messagesJson: '[]',
+    };
+  }
+  return {
+    status: 'ok',
+    error: null,
+    messageCount: messages.length,
+    messagesJson: JSON.stringify(messages),
+  };
+}
+
+export const grokExportAllCommand = cli({
+  site: 'grok',
+  name: 'export-all',
+  description: 'Export Grok conversation history and each conversation transcript',
+  access: 'read',
+  example: 'opencli grok export-all --limit 5 -f json',
+  domain: GROK_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  siteSession: 'persistent',
+  navigateBefore: false,
+  args: [
+    { name: 'limit', type: 'int', default: 0, help: 'Max conversations to export; 0 means all loaded history' },
+    { name: 'offset', type: 'int', default: 0, help: 'Skip this many conversations before exporting' },
+    { name: 'manifestPath', type: 'string', default: '', help: 'Optional grok/export JSON manifest path; skips history dialog and visits listed /c pages directly' },
+    { name: 'maxScrolls', type: 'int', default: 80, help: 'Max history-list scroll rounds when limit is 0 (max 500)' },
+    { name: 'pageScrolls', type: 'int', default: 30, help: 'Max per-conversation scroll-to-bottom rounds (max 200)' },
+    { name: 'pageTimeoutMs', type: 'int', default: 30000, help: 'Max wait for each conversation page to show messages' },
+    { name: 'delayMinMs', type: 'int', default: 0, help: 'Minimum polite delay after a conversation page loads' },
+    { name: 'delayMaxMs', type: 'int', default: 5000, help: 'Maximum polite delay after a conversation page loads' },
+  ],
+  columns: ['index', 'id', 'title', 'date', 'url', 'status', 'messageCount', 'error', 'messagesJson'],
+  func: async (page, kwargs) => {
+    const limit = normalizeInteger(kwargs.limit, 0, 'limit', { min: 0 });
+    const offset = normalizeInteger(kwargs.offset, 0, 'offset', { min: 0 });
+    const maxScrolls = normalizeInteger(kwargs.maxScrolls, 80, 'maxScrolls', { min: 1, max: 500 });
+    const pageScrolls = normalizeInteger(kwargs.pageScrolls, 30, 'pageScrolls', { min: 1, max: 200 });
+    const pageTimeoutMs = normalizeInteger(kwargs.pageTimeoutMs, 30000, 'pageTimeoutMs', { min: 5000, max: 180000 });
+    const delayMinMs = normalizeInteger(kwargs.delayMinMs, 0, 'delayMinMs', { min: 0, max: 60000 });
+    const delayMaxMs = normalizeInteger(kwargs.delayMaxMs, 5000, 'delayMaxMs', { min: 0, max: 60000 });
+    if (delayMaxMs < delayMinMs) {
+      throw new ArgumentError('delayMaxMs', 'must be >= delayMinMs');
+    }
+
+    const conversations = readManifest(kwargs.manifestPath, { offset, limit })
+      || await collectHistory(page, { offset, limit, maxScrolls });
+    const rows = [];
+    for (let i = 0; i < conversations.length; i += 1) {
+      const conversation = conversations[i];
+      const transcript = await readConversation(page, conversation, {
+        pageTimeoutMs,
+        pageScrolls,
+        delayMinMs,
+        delayMaxMs,
+      });
+      rows.push({
+        index: offset + i + 1,
+        id: conversation.id,
+        title: conversation.title || null,
+        date: conversation.date || null,
+        url: conversation.url,
+        status: transcript.status,
+        messageCount: transcript.messageCount,
+        error: transcript.error,
+        messagesJson: transcript.messagesJson,
+      });
+    }
+
+    if (!rows.length) {
+      throw new EmptyResultError('grok export-all', 'No Grok conversations were exported.');
+    }
+    return rows;
+  },
+});
+
+export const __test__ = {
+  normalizeInteger,
+  readManifest,
+};