@jackwener/opencli 1.7.11 → 1.7.13

package/clis/youtube/feed.test.js

@@ -0,0 +1,131 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './feed.js';
+
+function makePage({ initialData, continuationData, fetchImpl } = {}) {
+    const fetchMock = fetchImpl || vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => continuationData,
+    });
+
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(async (script) => {
+            const previousWindow = globalThis.window;
+            const previousFetch = globalThis.fetch;
+
+            globalThis.window = {
+                ytInitialData: initialData,
+                ytcfg: {
+                    data_: {
+                        INNERTUBE_API_KEY: 'test-key',
+                        INNERTUBE_CONTEXT: { client: { clientName: 'WEB', clientVersion: '1.0' } },
+                    },
+                },
+            };
+            globalThis.fetch = fetchMock;
+
+            try {
+                return await eval(script);
+            }
+            finally {
+                globalThis.window = previousWindow;
+                globalThis.fetch = previousFetch;
+            }
+        }),
+        __fetchMock: fetchMock,
+    };
+}
+
+const initialData = {
+    contents: {
+        twoColumnBrowseResultsRenderer: {
+            tabs: [{
+                tabRenderer: {
+                    content: {
+                        richGridRenderer: {
+                            contents: [
+                                {
+                                    richItemRenderer: {
+                                        content: {
+                                            videoRenderer: {
+                                                videoId: 'first-video',
+                                                title: { runs: [{ text: 'First video' }] },
+                                                ownerText: { runs: [{ text: 'First channel' }] },
+                                                viewCountText: { simpleText: '1K views' },
+                                                lengthText: { simpleText: '10:00' },
+                                                publishedTimeText: { simpleText: '1 day ago' },
+                                            },
+                                        },
+                                    },
+                                },
+                                {
+                                    continuationItemRenderer: {
+                                        continuationEndpoint: {
+                                            continuationCommand: {
+                                                token: 'next-token',
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            }],
+        },
+    },
+};
+
+const continuationData = {
+    onResponseReceivedActions: [{
+        appendContinuationItemsAction: {
+            continuationItems: [{
+                richItemRenderer: {
+                    content: {
+                        videoRenderer: {
+                            videoId: 'second-video',
+                            title: { runs: [{ text: 'Second video' }] },
+                            ownerText: { runs: [{ text: 'Second channel' }] },
+                            viewCountText: { simpleText: '2K views' },
+                            lengthText: { simpleText: '11:00' },
+                            publishedTimeText: { simpleText: '2 days ago' },
+                        },
+                    },
+                },
+            }],
+        },
+    }],
+};
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+describe('youtube feed', () => {
+    it('uses continuation results when the first page is below limit', async () => {
+        const page = makePage({ initialData, continuationData });
+        const cmd = getRegistry().get('youtube/feed');
+
+        const rows = await cmd.func(page, { limit: 2 });
+
+        expect(page.goto).toHaveBeenCalledWith('https://www.youtube.com');
+        expect(page.wait).toHaveBeenCalledWith(3);
+        expect(page.__fetchMock).toHaveBeenCalledTimes(1);
+        expect(rows).toEqual([
+            expect.objectContaining({
+                rank: 1,
+                title: 'First video',
+                video_id: 'first-video',
+                url: 'https://www.youtube.com/watch?v=first-video',
+            }),
+            expect.objectContaining({
+                rank: 2,
+                title: 'Second video',
+                video_id: 'second-video',
+                url: 'https://www.youtube.com/watch?v=second-video',
+            }),
+        ]);
+    });
+});

package/clis/youtube/history.js

@@ -7,6 +7,7 @@ import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/erro
 cli({
     site: 'youtube',
     name: 'history',
+    access: 'read',
     description: 'Get YouTube watch history',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/like.js

@@ -8,6 +8,7 @@ import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/err
 cli({
     site: 'youtube',
     name: 'like',
+    access: 'write',
     description: 'Like a YouTube video',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/playlist.js

@@ -23,6 +23,7 @@ function parsePlaylistId(input) {
 cli({
     site: 'youtube',
     name: 'playlist',
+    access: 'read',
     description: 'Get YouTube playlist info and video list',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/search.js

@@ -5,6 +5,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'youtube',
     name: 'search',
+    access: 'read',
     description: 'Search YouTube videos',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/subscribe.js

@@ -8,6 +8,7 @@ import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/err
 cli({
     site: 'youtube',
     name: 'subscribe',
+    access: 'write',
     description: 'Subscribe to a YouTube channel',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/subscriptions.js

@@ -8,6 +8,7 @@ import { extractSubscriptionChannel } from './utils.js';
 cli({
     site: 'youtube',
     name: 'subscriptions',
+    access: 'read',
     description: 'List subscribed YouTube channels',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/transcript.js

@@ -1,21 +1,22 @@
 /**
- * YouTube transcript — uses InnerTube player API with Android client context.
+ * YouTube transcript — extracts caption tracks from watch page bootstrap data.
  *
- * The Web client's caption URLs require a PoToken (proof of origin) generated
- * by BotGuard at runtime. The Android client returns caption URLs that work
- * without PoToken — same approach used by youtube-transcript-api (Python).
+ * The old Android InnerTube client path stopped reliably returning captions.
+ * We now match youtube/video.js: fetch watch HTML with the browser session and
+ * parse ytInitialPlayerResponse.captions.playerCaptionsTracklistRenderer.
  *
  * Modes:
  *   --mode grouped (default): sentences merged, speaker detection, chapters
  *   --mode raw: every caption segment as-is with precise timestamps
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { parseVideoId, prepareYoutubeApiPage } from './utils.js';
+import { extractJsonAssignmentFromHtml, parseVideoId, prepareYoutubeApiPage } from './utils.js';
 import { groupTranscriptSegments, formatGroupedTranscript, } from './transcript-group.js';
 import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 cli({
     site: 'youtube',
     name: 'transcript',
+    access: 'read',
     description: 'Get YouTube video transcript/subtitles',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,
@@ -31,27 +32,21 @@ cli({
         await prepareYoutubeApiPage(page);
         const lang = kwargs.lang || '';
         const mode = kwargs.mode || 'grouped';
-        // Step 1: Get caption track URL via Android InnerTube API
+        // Step 1: Get caption track URL from watch page HTML
         const captionData = await page.evaluate(`
       (async () => {
-        const cfg = window.ytcfg?.data_ || {};
-        const apiKey = cfg.INNERTUBE_API_KEY;
-        if (!apiKey) return { error: 'INNERTUBE_API_KEY not found on page' };
+        const extractJsonAssignmentFromHtml = ${extractJsonAssignmentFromHtml.toString()};
 
-        const resp = await fetch('/youtubei/v1/player?key=' + apiKey + '&prettyPrint=false', {
-          method: 'POST',
+        const watchResp = await fetch('/watch?v=' + encodeURIComponent(${JSON.stringify(videoId)}), {
           credentials: 'include',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            context: { client: { clientName: 'ANDROID', clientVersion: '20.10.38' } },
-            videoId: ${JSON.stringify(videoId)}
-          })
         });
+        if (!watchResp.ok) return { error: 'Watch HTML returned HTTP ' + watchResp.status };
 
-        if (!resp.ok) return { error: 'InnerTube player API returned HTTP ' + resp.status };
-        const data = await resp.json();
+        const html = await watchResp.text();
+        const player = extractJsonAssignmentFromHtml(html, 'ytInitialPlayerResponse');
+        if (!player) return { error: 'ytInitialPlayerResponse not found in watch HTML' };
 
-        const renderer = data.captions?.playerCaptionsTracklistRenderer;
+        const renderer = player.captions?.playerCaptionsTracklistRenderer;
         if (!renderer?.captionTracks?.length) {
           return { error: 'No captions available for this video' };
         }

package/clis/youtube/transcript.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const transcriptSource = readFileSync(resolve(__dirname, 'transcript.js'), 'utf8');
+
+describe('youtube transcript source contract', () => {
+    it('gets caption tracks from watch page bootstrap data, not Android InnerTube', () => {
+        expect(transcriptSource).toContain("fetch('/watch?v='");
+        expect(transcriptSource).toContain("extractJsonAssignmentFromHtml(html, 'ytInitialPlayerResponse')");
+        expect(transcriptSource).toContain('playerCaptionsTracklistRenderer');
+        expect(transcriptSource).not.toContain('/youtubei/v1/player');
+        expect(transcriptSource).not.toContain("clientName: 'ANDROID'");
+    });
+});

package/clis/youtube/unlike.js

@@ -8,6 +8,7 @@ import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/err
 cli({
     site: 'youtube',
     name: 'unlike',
+    access: 'write',
     description: 'Remove like from a YouTube video',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/unsubscribe.js

@@ -8,6 +8,7 @@ import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/err
 cli({
     site: 'youtube',
     name: 'unsubscribe',
+    access: 'write',
     description: 'Unsubscribe from a YouTube channel',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/video.js

@@ -7,6 +7,7 @@ import { CommandExecutionError } from '@jackwener/opencli/errors';
 cli({
     site: 'youtube',
     name: 'video',
+    access: 'read',
     description: 'Get YouTube video metadata (title, views, description, etc.)',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/youtube/watch-later.js

@@ -9,6 +9,7 @@ import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/erro
 cli({
     site: 'youtube',
     name: 'watch-later',
+    access: 'read',
     description: 'Get your YouTube Watch Later queue',
     domain: 'www.youtube.com',
     strategy: Strategy.COOKIE,

package/clis/yuanbao/ask.js

@@ -1,7 +1,16 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { htmlToMarkdown } from '@jackwener/opencli/utils';
-import { CommandExecutionError, TimeoutError } from '@jackwener/opencli/errors';
-import { YUANBAO_DOMAIN, IS_VISIBLE_JS, authRequired, isOnYuanbao, ensureYuanbaoPage, hasLoginGate } from './shared.js';
+import { ArgumentError, CommandExecutionError, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    YUANBAO_DOMAIN,
+    IS_VISIBLE_JS,
+    authRequired,
+    isOnYuanbao,
+    ensureYuanbaoPage,
+    hasLoginGate,
+    normalizeBooleanFlag,
+    sendYuanbaoMessage,
+} from './shared.js';
 const YUANBAO_RESPONSE_POLL_INTERVAL_SECONDS = 2;
 const YUANBAO_MIN_WAIT_MS = 8_000;
 const YUANBAO_STABLE_POLLS_REQUIRED = 3;
@@ -12,14 +21,6 @@ function sendFailure(reason, detail) {
 function normalizeText(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
-function normalizeBooleanFlag(value, fallback) {
-    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 convertYuanbaoHtmlToMarkdown(value) {
     return htmlToMarkdown(value, (td) => {
         td.addRule('table', {
@@ -272,59 +273,6 @@ async function setYuanbaoDeepThink(page, enabled) {
   })()`);
     await page.wait(0.5);
 }
-async function sendYuanbaoMessage(page, prompt) {
-    return await page.evaluate(`(async () => {
-    const waitFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-    ${IS_VISIBLE_JS}
-
-    const composer = Array.from(document.querySelectorAll('.ql-editor[contenteditable="true"], .ql-editor, [contenteditable="true"]'))
-      .find(isVisible);
-
-    if (!(composer instanceof HTMLElement)) {
-      return {
-        ok: false,
-        reason: 'Yuanbao composer was not found.',
-      };
-    }
-
-    try {
-      composer.focus();
-      const selection = window.getSelection();
-      const range = document.createRange();
-      range.selectNodeContents(composer);
-      range.collapse(false);
-      selection?.removeAllRanges();
-      selection?.addRange(range);
-      composer.textContent = '';
-      document.execCommand('insertText', false, ${JSON.stringify(prompt)});
-      composer.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(prompt)}, inputType: 'insertText' }));
-      await waitFor(200);
-    } catch (error) {
-      return {
-        ok: false,
-        reason: 'Failed to insert the prompt into the Yuanbao composer.',
-        detail: error instanceof Error ? error.message : String(error),
-      };
-    }
-
-    const submit = Array.from(document.querySelectorAll('a[class*="send-btn"], button[class*="send-btn"]'))
-      .find((node) => {
-        if (!(node instanceof HTMLElement) || !isVisible(node)) return false;
-        const className = node.className || '';
-        if (typeof className === 'string' && className.includes('disabled')) return false;
-        return true;
-      });
-
-    if (submit instanceof HTMLElement) {
-      submit.click();
-      return { ok: true, action: 'click' };
-    }
-
-    composer.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
-    composer.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
-    return { ok: true, action: 'enter' };
-  })()`);
-}
 async function waitForYuanbaoResponse(page, baselineAssistantCount, beforeLines, prompt, timeoutSeconds) {
     const startTime = Date.now();
     let previousText = '';
@@ -352,23 +300,27 @@ async function waitForYuanbaoResponse(page, baselineAssistantCount, beforeLines,
 export const askCommand = cli({
     site: 'yuanbao',
     name: 'ask',
+    access: 'write',
     description: 'Send a prompt to Yuanbao web chat and wait for the assistant response',
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     defaultFormat: 'plain',
-    timeoutSeconds: 180,
     args: [
         { name: 'prompt', required: true, positional: true, help: 'Prompt to send' },
-        { name: 'timeout', required: false, help: 'Max seconds to wait (default: 60)', default: '60' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait (default: 60)', default: 60 },
         { name: 'search', type: 'boolean', required: false, help: 'Enable Yuanbao internet search (default: true)', default: true },
         { name: 'think', type: 'boolean', required: false, help: 'Enable Yuanbao deep thinking (default: false)', default: false },
     ],
     columns: ['Role', 'Text'],
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
-        const timeout = parseInt(kwargs.timeout, 10) || 60;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
         const useSearch = normalizeBooleanFlag(kwargs.search, true);
         const useThink = normalizeBooleanFlag(kwargs.think, false);
         await ensureYuanbaoPage(page);

package/clis/yuanbao/ask.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, CommandExecutionError, TimeoutError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { __test__ } from './ask.js';
 import { askCommand } from './ask.js';
 describe('yuanbao ask helpers', () => {
@@ -101,7 +101,7 @@ function createAskPageMock(overrides = {}) {
 describe('yuanbao ask command', () => {
     it('throws AuthRequiredError when Yuanbao shows a login gate before sending', async () => {
         const page = createAskPageMock({ hasLoginGate: true });
-        await expect(askCommand.func(page, { prompt: '你好', timeout: '60', search: true, think: false }))
+        await expect(askCommand.func(page, { prompt: '你好', timeout: 60, search: true, think: false }))
             .rejects.toBeInstanceOf(AuthRequiredError);
     });
     it('throws CommandExecutionError when the prompt cannot be sent', async () => {
@@ -111,14 +111,14 @@ describe('yuanbao ask command', () => {
                 reason: 'Yuanbao composer was not found.',
             },
         });
-        await expect(askCommand.func(page, { prompt: '你好', timeout: '60', search: true, think: false }))
+        await expect(askCommand.func(page, { prompt: '你好', timeout: 60, search: true, think: false }))
             .rejects.toBeInstanceOf(CommandExecutionError);
     });
     it('throws TimeoutError when no response arrives before timeout', async () => {
         const page = createAskPageMock({
             sendResult: { ok: true, action: 'click' },
         });
-        await expect(askCommand.func(page, { prompt: '你好', timeout: '-1', search: true, think: false }))
-            .rejects.toBeInstanceOf(TimeoutError);
+        await expect(askCommand.func(page, { prompt: '你好', timeout: -1, search: true, think: false }))
+            .rejects.toBeInstanceOf(ArgumentError);
     });
 });

package/clis/yuanbao/detail.js

@@ -0,0 +1,65 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    YUANBAO_DOMAIN,
+    YUANBAO_URL,
+    getYuanbaoMessageBubbles,
+    parseYuanbaoSessionId,
+    hasLoginGate,
+    authRequired,
+} from './shared.js';
+import { convertYuanbaoHtmlToMarkdown } from './ask.js';
+
+cli({
+    site: 'yuanbao',
+    name: 'detail',
+    access: 'read',
+    description: 'Open a Yuanbao conversation by ID and read its messages',
+    domain: YUANBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        {
+            name: 'id',
+            positional: true,
+            required: true,
+            help: 'Full https://yuanbao.tencent.com/chat/<agentId>/<convId> URL or "<agentId>/<convId>" pair (a UUID alone is not enough — Yuanbao requires the agent slug)',
+        },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const { agentId, convId } = parseYuanbaoSessionId(kwargs.id);
+        await page.goto(`${YUANBAO_URL}chat/${agentId}/${convId}`, { waitUntil: 'load', settleMs: 2500 });
+        await page.wait(2);
+        if (await hasLoginGate(page)) {
+            throw authRequired('Yuanbao opened a login gate when navigating to the conversation.');
+        }
+
+        // Poll up to ~20s for the transcript to render. The page shell loads
+        // before history is fetched, so a fixed wait races the empty render.
+        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 getYuanbaoMessageBubbles(page);
+            if (bubbles.length > 0) break;
+            await page.wait(POLL_INTERVAL_S);
+        }
+
+        if (!bubbles.length) {
+            throw new EmptyResultError(
+                'yuanbao detail',
+                `No visible messages found for conversation ${agentId}/${convId}. Verify the IDs are correct and that the session belongs to the current login.`,
+            );
+        }
+        return bubbles.map((b) => ({
+            Role: b.role,
+            Text: b.role === 'Assistant' && b.html
+                ? (convertYuanbaoHtmlToMarkdown(b.html).trim() || b.text)
+                : b.text,
+        }));
+    },
+});

package/clis/yuanbao/history.js

@@ -0,0 +1,51 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    YUANBAO_DOMAIN,
+    YUANBAO_URL,
+    ensureYuanbaoPage,
+    getYuanbaoSessionList,
+    hasLoginGate,
+    authRequired,
+} from './shared.js';
+
+cli({
+    site: 'yuanbao',
+    name: 'history',
+    access: 'read',
+    description: 'List recent Yuanbao conversations from the sidebar (requires login)',
+    domain: YUANBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max conversations to list (sidebar virtual scroll caps actual count)' },
+    ],
+    columns: ['Index', 'Title', 'AgentId', 'SessionId', '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');
+        }
+        await ensureYuanbaoPage(page);
+        if (await hasLoginGate(page)) {
+            throw authRequired('Yuanbao opened a login gate when reading the sidebar.');
+        }
+        await page.wait(1.5);
+        const sessions = await getYuanbaoSessionList(page, limit);
+        if (!sessions.length) {
+            throw new EmptyResultError(
+                'yuanbao history',
+                'No Yuanbao conversations found in the sidebar. Either the account is logged out, the sidebar is collapsed, or the user truly has no chat history yet.',
+            );
+        }
+        return sessions.map((s, i) => ({
+            Index: i + 1,
+            Title: s.title || '(untitled)',
+            AgentId: s.agentId,
+            SessionId: s.cid,
+            Url: `${YUANBAO_URL}chat/${s.agentId}/${s.cid}`,
+        }));
+    },
+});

package/clis/yuanbao/new.js

@@ -50,10 +50,12 @@ async function startNewYuanbaoChat(page) {
 export const newCommand = cli({
     site: 'yuanbao',
     name: 'new',
+    access: 'read',
     description: 'Start a new conversation in Yuanbao web chat',
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Action'],

package/clis/yuanbao/read.js

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    YUANBAO_DOMAIN,
+    ensureYuanbaoPage,
+    getYuanbaoMessageBubbles,
+} from './shared.js';
+import { convertYuanbaoHtmlToMarkdown } from './ask.js';
+
+cli({
+    site: 'yuanbao',
+    name: 'read',
+    access: 'read',
+    description: 'Read messages in the current Yuanbao conversation',
+    domain: YUANBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [],
+    columns: ['Role', 'Text'],
+    func: async (page) => {
+        await ensureYuanbaoPage(page);
+        await page.wait(1.5);
+        const bubbles = await getYuanbaoMessageBubbles(page);
+        if (!bubbles.length) {
+            return [{ Role: 'system', Text: 'No visible messages in the current Yuanbao conversation.' }];
+        }
+        return bubbles.map((b) => ({
+            Role: b.role,
+            // Assistant turns render markdown HTML; convert to markdown so the
+            // text column carries usable structure (lists, code, tables) rather
+            // than collapsed innerText.
+            Text: b.role === 'Assistant' && b.html
+                ? (convertYuanbaoHtmlToMarkdown(b.html).trim() || b.text)
+                : b.text,
+        }));
+    },
+});