@jackwener/opencli 1.7.12 → 1.7.14

package/clis/xiaohongshu/publish.test.js

@@ -282,6 +282,48 @@ describe('xiaohongshu publish', () => {
             },
         ]);
     });
+    it('falls back to DataTransfer upload when CDP file injection is blocked by Chrome', async () => {
+        const cmd = getRegistry().get('xiaohongshu/publish');
+        expect(cmd?.func).toBeTypeOf('function');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-xhs-publish-'));
+        const imagePath = path.join(tempDir, 'demo.jpg');
+        fs.writeFileSync(imagePath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+        const setFileInput = vi.fn().mockRejectedValue(new Error('Chrome Not allowed'));
+        const page = createPageMock([
+            'https://creator.xiaohongshu.com/publish/publish?from=menu_left&target=image',
+            { ok: true, target: '上传图文', text: '上传图文' },
+            { state: 'editor_ready', hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+            'input[type="file"][accept*="image"],input[type="file"][accept*=".jpg"],input[type="file"][accept*=".jpeg"],input[type="file"][accept*=".png"],input[type="file"][accept*=".gif"],input[type="file"][accept*=".webp"]',
+            { ok: true, count: 1 },
+            false,
+            true,
+            { ok: true, sel: 'input[maxlength="20"]', kind: 'input' },
+            { ok: true, actual: 'CDP被拒后回退' },
+            { ok: true, sel: '[contenteditable="true"][class*="content"]', kind: 'contenteditable' },
+            { ok: true, actual: 'DataTransfer fallback path' },
+            true,
+            'https://creator.xiaohongshu.com/publish/success',
+            '发布成功',
+        ], {
+            setFileInput,
+        });
+        const result = await cmd.func(page, {
+            title: 'CDP被拒后回退',
+            content: 'DataTransfer fallback path',
+            images: imagePath,
+            topics: '',
+            draft: false,
+        });
+        const evaluateCalls = page.evaluate.mock.calls.map((args) => String(args[0]));
+        expect(setFileInput).toHaveBeenCalledWith([imagePath], expect.stringContaining('input[type="file"][accept*="image"]'));
+        expect(evaluateCalls.some((code) => code.includes('dt.items.add(new File'))).toBe(true);
+        expect(result).toEqual([
+            {
+                status: '✅ 发布成功',
+                detail: '"CDP被拒后回退" · 1张图片 · 发布成功',
+            },
+        ]);
+    });
     it('fails fast when only a generic file input exists on the page', async () => {
         const cmd = getRegistry().get('xiaohongshu/publish');
         expect(cmd?.func).toBeTypeOf('function');
@@ -336,8 +378,11 @@ describe('xiaohongshu publish', () => {
             draft: false,
         });
         const evaluateCalls = page.evaluate.mock.calls.map((args) => String(args[0]));
-        expect(evaluateCalls.some((code) => code.includes("const targets = ['上传图文', '图文', '图片']"))).toBe(true);
+        const tabSelectCode = evaluateCalls.find((code) => code.includes("const targets = ['上传图文', '图文', '图片']"));
+        expect(tabSelectCode).toBeTruthy();
+        expect(tabSelectCode.indexOf('if (text === target)')).toBeLessThan(tabSelectCode.indexOf('text.startsWith(target)'));
         expect(evaluateCalls.some((code) => code.includes("No image file input found on page"))).toBe(true);
+        expect(page.goto).toHaveBeenCalledWith(expect.stringContaining('target=image'));
         expect(result).toEqual([
             {
                 status: '✅ 发布成功',

package/clis/youtube/transcript.js

@@ -1,16 +1,16 @@
 /**
- * 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({
@@ -32,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/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 = '';
@@ -357,19 +305,22 @@ export const askCommand = cli({
     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

@@ -55,6 +55,7 @@ export const newCommand = cli({
     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,
+        }));
+    },
+});

package/clis/yuanbao/send.js

@@ -0,0 +1,57 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    YUANBAO_DOMAIN,
+    authRequired,
+    ensureYuanbaoPage,
+    hasLoginGate,
+    normalizeBooleanFlag,
+    sendYuanbaoMessage,
+    startNewYuanbaoChat,
+} from './shared.js';
+
+cli({
+    site: 'yuanbao',
+    name: 'send',
+    access: 'write',
+    description: 'Fire-and-forget: send a prompt to Yuanbao without waiting for the reply',
+    domain: YUANBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send to Yuanbao' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
+    ],
+    columns: ['Status', 'Prompt'],
+    func: async (page, kwargs) => {
+        const prompt = String(kwargs.prompt || '').trim();
+        if (!prompt) throw new ArgumentError('prompt', 'is required');
+        const startFresh = normalizeBooleanFlag(kwargs.new, false);
+
+        await ensureYuanbaoPage(page);
+        if (await hasLoginGate(page)) {
+            throw authRequired('Yuanbao opened a login gate before sending the prompt.');
+        }
+        if (startFresh) {
+            const action = await startNewYuanbaoChat(page);
+            if (action === 'blocked') {
+                throw authRequired('Yuanbao opened a login gate while starting a new chat.');
+            }
+        }
+        const send = await sendYuanbaoMessage(page, prompt);
+        if (!send?.ok) {
+            if (await hasLoginGate(page)) {
+                throw authRequired('Yuanbao opened a login gate instead of accepting the prompt.');
+            }
+            throw new CommandExecutionError(
+                send?.reason || 'Failed to send Yuanbao prompt',
+                send?.detail
+                    ? `Detail: ${send.detail}`
+                    : 'Make sure the Yuanbao chat composer is visible and not in a disabled state.',
+            );
+        }
+        return [{ Status: 'sent', Prompt: prompt }];
+    },
+});