@jackwener/opencli 1.7.6 → 1.7.8

package/clis/twitter/shared.test.js

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './shared.js';
+
+const { extractMedia } = __test__;
+
+describe('twitter extractMedia', () => {
+    it('returns false + empty list when legacy has no media', () => {
+        expect(extractMedia({})).toEqual({ has_media: false, media_urls: [] });
+        expect(extractMedia(undefined)).toEqual({ has_media: false, media_urls: [] });
+        expect(extractMedia({ extended_entities: { media: [] } })).toEqual({
+            has_media: false,
+            media_urls: [],
+        });
+    });
+
+    it('extracts photo urls from extended_entities', () => {
+        const result = extractMedia({
+            extended_entities: {
+                media: [
+                    { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/a.jpg' },
+                    { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/b.jpg' },
+                ],
+            },
+        });
+        expect(result.has_media).toBe(true);
+        expect(result.media_urls).toEqual([
+            'https://pbs.twimg.com/media/a.jpg',
+            'https://pbs.twimg.com/media/b.jpg',
+        ]);
+    });
+
+    it('prefers mp4 variant for video and animated_gif', () => {
+        const result = extractMedia({
+            extended_entities: {
+                media: [
+                    {
+                        type: 'video',
+                        media_url_https: 'https://pbs.twimg.com/media/thumb.jpg',
+                        video_info: {
+                            variants: [
+                                { content_type: 'application/x-mpegURL', url: 'https://video.twimg.com/x.m3u8' },
+                                { content_type: 'video/mp4', url: 'https://video.twimg.com/x.mp4' },
+                            ],
+                        },
+                    },
+                    {
+                        type: 'animated_gif',
+                        media_url_https: 'https://pbs.twimg.com/tweet_video_thumb/g.jpg',
+                        video_info: {
+                            variants: [
+                                { content_type: 'video/mp4', url: 'https://video.twimg.com/g.mp4' },
+                            ],
+                        },
+                    },
+                ],
+            },
+        });
+        expect(result.has_media).toBe(true);
+        expect(result.media_urls).toEqual([
+            'https://video.twimg.com/x.mp4',
+            'https://video.twimg.com/g.mp4',
+        ]);
+    });
+
+    it('falls back to media_url_https when no mp4 variant is available', () => {
+        const result = extractMedia({
+            extended_entities: {
+                media: [
+                    {
+                        type: 'video',
+                        media_url_https: 'https://pbs.twimg.com/media/thumb.jpg',
+                        video_info: { variants: [] },
+                    },
+                ],
+            },
+        });
+        expect(result).toEqual({
+            has_media: true,
+            media_urls: ['https://pbs.twimg.com/media/thumb.jpg'],
+        });
+    });
+
+    it('falls back to entities.media when extended_entities is missing', () => {
+        const result = extractMedia({
+            entities: {
+                media: [
+                    { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/c.jpg' },
+                ],
+            },
+        });
+        expect(result).toEqual({
+            has_media: true,
+            media_urls: ['https://pbs.twimg.com/media/c.jpg'],
+        });
+    });
+});

package/clis/twitter/thread.js

@@ -1,5 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { extractMedia } from './shared.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const TWEET_DETAIL_QUERY_ID = 'nBS-WpgA6ZG0CyNHD517JQ';
@@ -54,6 +55,7 @@ function extractTweet(r, seen) {
         in_reply_to: l.in_reply_to_status_id_str || undefined,
         created_at: l.created_at,
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(l),
     };
 }
 function parseTweetDetail(data, seen) {
@@ -101,7 +103,7 @@ cli({
         { name: 'tweet-id', positional: true, type: 'string', required: true },
         { name: 'limit', type: 'int', default: 50 },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url'],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         let tweetId = kwargs['tweet-id'];
         const urlMatch = tweetId.match(/\/status\/(\d+)/);

package/clis/twitter/timeline.js

@@ -1,6 +1,6 @@
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { resolveTwitterQueryId } from './shared.js';
+import { resolveTwitterQueryId, extractMedia } from './shared.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
@@ -85,6 +85,7 @@ function extractTweet(result, seen) {
         views,
         created_at: l.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(l),
     };
 }
 function parseHomeTimeline(data, seen) {
@@ -148,7 +149,7 @@ cli({
         },
         { name: 'limit', type: 'int', default: 20 },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url'],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         const timelineType = kwargs.type === 'following' ? 'following' : 'for-you';

package/clis/twitter/tweets.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { resolveTwitterQueryId, sanitizeQueryId } from './shared.js';
+import { resolveTwitterQueryId, sanitizeQueryId, extractMedia } from './shared.js';
 
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const USER_TWEETS_QUERY_ID = '6fWQaBPK51aGyC_VC7t9GQ';
@@ -105,6 +105,7 @@ function extractTweet(result, seen) {
         is_retweet: isRetweet,
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(legacy),
     };
 }
 
@@ -151,7 +152,7 @@ cli({
         { name: 'username', type: 'string', positional: true, required: true, help: 'Twitter screen name (with or without @)' },
         { name: 'limit', type: 'int', default: 20, help: 'Max tweets to return' },
     ],
-    columns: ['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url'],
+    columns: ['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = Math.max(1, Math.min(200, kwargs.limit || 20));
         const username = String(kwargs.username || '').replace(/^@/, '').trim();

package/clis/twitter/tweets.test.js

@@ -5,7 +5,7 @@ import { __test__ } from './tweets.js';
 describe('twitter tweets helpers', () => {
     it('registers is_retweet in the default columns', () => {
         const cmd = getRegistry().get('twitter/tweets');
-        expect(cmd?.columns).toEqual(['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url']);
+        expect(cmd?.columns).toEqual(['author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls']);
     });
 
     it('falls back when queryId contains unsafe characters', () => {

package/clis/web/read.js

@@ -15,7 +15,7 @@
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { downloadArticle } from '@jackwener/opencli/download/article-download';
-cli({
+const command = cli({
     site: 'web',
     name: 'read',
     description: 'Fetch any web page and export as Markdown',
@@ -26,6 +26,7 @@ cli({
         { name: 'output', default: './web-articles', help: 'Output directory' },
         { name: 'download-images', type: 'boolean', default: true, help: 'Download images locally' },
         { name: 'wait', type: 'int', default: 3, help: 'Seconds to wait after page load' },
+        { name: 'stdout', type: 'boolean', default: false, help: 'Print markdown to stdout instead of saving to a file' },
     ],
     columns: ['title', 'author', 'publish_time', 'status', 'size', 'saved'],
     func: async (page, kwargs) => {
@@ -162,14 +163,26 @@ cli({
           if (el.children && el.children.length > 2) dedup(el);
         });
 
+        // --- Lazy-load image src rewrite ---
+        // Many sites render <img src="placeholder.gif" data-src="real.jpg">.
+        // Promote the real URL onto src so both the markdown body and the
+        // image download list reference the same URL.
+        clone.querySelectorAll('img').forEach(img => {
+          const srcset = img.getAttribute('data-srcset') || '';
+          const srcsetFirst = srcset.split(',')[0]?.trim().split(' ')[0] || '';
+          const real = img.getAttribute('data-src')
+            || img.getAttribute('data-original')
+            || img.getAttribute('data-lazy-src')
+            || srcsetFirst;
+          if (real) img.setAttribute('src', real);
+        });
+
         result.contentHtml = clone.innerHTML;
 
         // --- Image extraction ---
         const seen = new Set();
         clone.querySelectorAll('img').forEach(img => {
-          const src = img.getAttribute('data-src')
-            || img.getAttribute('data-original')
-            || img.getAttribute('src');
+          const src = img.getAttribute('src') || '';
           if (src && !src.startsWith('data:') && !seen.has(src)) {
             seen.add(src);
             result.imageUrls.push(src);
@@ -186,7 +199,7 @@ cli({
             referer = parsed.origin + '/';
         }
         catch { /* ignore */ }
-        return downloadArticle({
+        const result = await downloadArticle({
             title: data?.title || 'untitled',
             author: data?.author,
             publishTime: data?.publishTime,
@@ -197,6 +210,13 @@ cli({
             output: kwargs.output,
             downloadImages: kwargs['download-images'],
             imageHeaders: referer ? { Referer: referer } : undefined,
+            stdout: kwargs.stdout,
         });
+        // `--stdout` is a content-streaming mode. The markdown body already went
+        // to process.stdout inside downloadArticle(), so returning rows here
+        // would make Commander append table/JSON output to the same stdout
+        // stream and break piping.
+        return kwargs.stdout ? null : result;
     },
 });
+export const __test__ = { command };

package/clis/web/read.test.js

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockDownloadArticle } = vi.hoisted(() => ({
+    mockDownloadArticle: vi.fn(),
+}));
+
+vi.mock('@jackwener/opencli/download/article-download', () => ({
+    downloadArticle: mockDownloadArticle,
+}));
+
+const { __test__ } = await import('./read.js');
+
+describe('web/read stdout behavior', () => {
+    const read = __test__.command;
+    const page = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue({
+            title: 'Example Article',
+            author: 'Author',
+            publishTime: '2026-04-22',
+            contentHtml: '<p>hello</p>',
+            imageUrls: ['https://example.com/a.jpg'],
+        }),
+    };
+
+    beforeEach(() => {
+        mockDownloadArticle.mockReset();
+        mockDownloadArticle.mockResolvedValue([{
+            title: 'Example Article',
+            author: 'Author',
+            publish_time: '2026-04-22',
+            status: 'success',
+            size: '1 KB',
+            saved: '-',
+        }]);
+        page.goto.mockClear();
+        page.wait.mockClear();
+        page.evaluate.mockClear();
+    });
+
+    it('returns null in --stdout mode so the CLI does not append result rows to stdout', async () => {
+        const result = await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            stdout: true,
+        });
+
+        expect(result).toBeNull();
+        expect(mockDownloadArticle).toHaveBeenCalledWith(
+            expect.objectContaining({
+                title: 'Example Article',
+                sourceUrl: 'https://example.com/article',
+            }),
+            expect.objectContaining({
+                output: '/tmp/out',
+                stdout: true,
+            }),
+        );
+    });
+
+    it('still returns the saved-row payload when writing to disk', async () => {
+        const rows = [{ title: 'Example Article', saved: '/tmp/out/Example Article/example.md' }];
+        mockDownloadArticle.mockResolvedValue(rows);
+
+        const result = await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            stdout: false,
+        });
+
+        expect(result).toBe(rows);
+    });
+});

package/clis/weixin/create-draft.js

@@ -0,0 +1,225 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+const WEIXIN_DOMAIN = 'mp.weixin.qq.com';
+const WEIXIN_HOME = 'https://mp.weixin.qq.com/';
+
+async function getToken(page) {
+    return page.evaluate(`(window.location.href.match(/token=(\\d+)/)||[])[1]`);
+}
+
+async function navigateToEditor(page) {
+    await page.goto(WEIXIN_HOME);
+    await page.wait(3);
+    const token = await getToken(page);
+    if (!token) {
+        throw new CommandExecutionError('Could not extract session token. Please log in to mp.weixin.qq.com');
+    }
+    await page.goto(`https://mp.weixin.qq.com/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=77&token=${token}&lang=zh_CN`);
+    await page.wait(4);
+    const hasTitle = await page.evaluate('!!document.querySelector("textarea#title")');
+    if (!hasTitle) {
+        throw new CommandExecutionError('Article editor did not load. Session may have expired');
+    }
+}
+
+async function fillField(page, selector, value) {
+    return page.evaluate(`(() => {
+        var el = document.querySelector('${selector}');
+        if (!el) return { ok: false, reason: 'not found: ${selector}' };
+        el.focus();
+        var proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+        var setter = Object.getOwnPropertyDescriptor(proto, 'value');
+        if (setter && setter.set) setter.set.call(el, ${JSON.stringify(value)});
+        else el.value = ${JSON.stringify(value)};
+        el.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(value)} }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+        el.blur();
+        return { ok: true };
+    })()`);
+}
+
+async function fillContent(page, text) {
+    return page.evaluate(`(() => {
+        var editors = document.querySelectorAll('div[contenteditable="true"]');
+        var editor = editors[editors.length - 1];
+        if (!editor) return { ok: false, reason: 'content editor not found' };
+        editor.focus();
+        if (editor.querySelector('[contenteditable="false"]')) editor.innerHTML = '';
+        document.execCommand('selectAll', false, null);
+        document.execCommand('insertText', false, ${JSON.stringify(text)});
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true }));
+        return { ok: true };
+    })()`);
+}
+
+async function uploadContentImage(page, imagePath) {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const absPath = path.default.resolve(imagePath);
+    if (!fs.default.existsSync(absPath)) {
+        throw new CommandExecutionError(`Image not found: ${absPath}`);
+    }
+    if (!page.setFileInput) {
+        throw new CommandExecutionError('Image upload requires Browser Bridge with CDP support');
+    }
+
+    await page.evaluate(`(() => {
+        var li = document.querySelector('#js_editor_insertimage');
+        if (li) li.click();
+    })()`);
+    await page.wait(1);
+    await page.evaluate(`(() => {
+        var items = document.querySelectorAll('.js_img_dropdown_menu .tpl_dropdown_menu_item');
+        if (items[0]) items[0].click();
+    })()`);
+    await page.wait(1);
+
+    await page.setFileInput([absPath], 'input[type="file"][name="file"]');
+    await page.wait(8);
+
+    const cdnCount = await page.evaluate(`(() => {
+        var editor = document.querySelector('#ueditor_0');
+        return editor ? editor.querySelectorAll('img[src*="mmbiz"]').length : 0;
+    })()`);
+    if (cdnCount === 0) {
+        throw new CommandExecutionError('Image did not upload to WeChat CDN');
+    }
+}
+
+async function selectCoverFromContent(page) {
+    await page.evaluate('document.querySelector("#js_cover_description_area")?.scrollIntoView()');
+    await page.wait(1);
+
+    await page.evaluate('document.querySelector(".js_cover_btn_area")?.click()');
+    await page.wait(1);
+
+    await page.evaluate(`(() => {
+        var links = document.querySelectorAll('a.pop-opr__button');
+        for (var i = 0; i < links.length; i++) {
+            if (links[i].textContent.trim() === '从正文选择') { links[i].click(); return; }
+        }
+    })()`);
+    await page.wait(2);
+
+    await page.evaluate(`(() => {
+        var img = document.querySelector('.weui-desktop-dialog_img-picker .appmsg_content_img');
+        if (img) img.click();
+    })()`);
+    await page.wait(1);
+
+    await page.evaluate(`(() => {
+        var btns = document.querySelectorAll('.weui-desktop-dialog_img-picker button');
+        for (var i = 0; i < btns.length; i++) {
+            if (btns[i].textContent.trim() === '下一步' && !btns[i].disabled) { btns[i].click(); return; }
+        }
+    })()`);
+
+    // Crop dialog image rendering can be slow
+    for (let attempt = 0; attempt < 8; attempt++) {
+        await page.wait(2);
+        const ready = await page.evaluate(`(() => {
+            var btns = document.querySelectorAll('button');
+            for (var i = 0; i < btns.length; i++) {
+                if (btns[i].textContent.trim() === '确认' && btns[i].offsetHeight > 0 && !btns[i].disabled) return true;
+            }
+            return false;
+        })()`);
+        if (ready) break;
+    }
+
+    await page.evaluate(`(() => {
+        var btns = document.querySelectorAll('button');
+        for (var i = 0; i < btns.length; i++) {
+            if (btns[i].textContent.trim() === '确认' && btns[i].offsetHeight > 0 && !btns[i].disabled) { btns[i].click(); return; }
+        }
+    })()`);
+    await page.wait(2);
+    const hasCover = await page.evaluate(`(() => {
+        var area = document.querySelector('#js_cover_area');
+        if (!area) return false;
+        var found = false;
+        area.querySelectorAll('*').forEach(function(el) {
+            var bg = window.getComputedStyle(el).backgroundImage;
+            if (bg && bg.includes('mmbiz')) found = true;
+        });
+        return found;
+    })()`);
+    return hasCover;
+}
+
+async function clickSaveDraft(page) {
+    const result = await page.evaluate(`(() => {
+        var btns = document.querySelectorAll('span, button, a');
+        for (var i = 0; i < btns.length; i++) {
+            if ((btns[i].textContent || '').trim() === '保存为草稿') { btns[i].click(); return { ok: true }; }
+        }
+        return { ok: false };
+    })()`);
+    if (!result?.ok) throw new CommandExecutionError('Save draft button not found');
+
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await page.wait(2);
+        const saved = await page.evaluate(`(() => {
+            var el = document.querySelector('#js_save_success');
+            if (el && window.getComputedStyle(el).display !== 'none') return true;
+            return document.body.innerText.includes('已保存');
+        })()`);
+        if (saved) return true;
+    }
+    return false;
+}
+
+export const createDraftCommand = cli({
+    site: 'weixin',
+    name: 'create-draft',
+    description: '创建微信公众号图文草稿',
+    domain: WEIXIN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    timeoutSeconds: 180,
+    args: [
+        { name: 'title', required: true, help: '文章标题 (最长64字)' },
+        { name: 'content', required: true, positional: true, help: '文章正文' },
+        { name: 'author', help: '作者名 (最长8字)' },
+        { name: 'cover-image', help: '封面图片路径 (会先上传到正文再设为封面)' },
+        { name: 'summary', help: '文章摘要' },
+    ],
+    columns: ['status', 'detail'],
+
+    func: async (page, kwargs) => {
+        await navigateToEditor(page);
+
+        const titleResult = await fillField(page, 'textarea#title', kwargs.title);
+        if (!titleResult?.ok) throw new CommandExecutionError('Failed to fill title');
+
+        if (kwargs.author) {
+            const authorResult = await fillField(page, 'input#author', kwargs.author);
+            if (!authorResult?.ok) throw new CommandExecutionError('Failed to fill author');
+        }
+
+        const contentResult = await fillContent(page, kwargs.content);
+        if (!contentResult?.ok) throw new CommandExecutionError('Failed to fill content');
+
+        if (kwargs['cover-image']) {
+            await uploadContentImage(page, kwargs['cover-image']);
+            const coverSet = await selectCoverFromContent(page);
+            if (!coverSet) {
+                // Non-fatal: draft can be saved without cover
+            }
+        }
+
+        if (kwargs.summary) {
+            await fillField(page, 'textarea#js_description', kwargs.summary);
+        }
+
+        await page.wait(1);
+        const success = await clickSaveDraft(page);
+
+        return [{
+            status: success ? 'draft saved' : 'save attempted, check browser to confirm',
+            detail: `"${kwargs.title}"${kwargs.author ? ` by ${kwargs.author}` : ''}${kwargs['cover-image'] ? ' (with cover)' : ''}`,
+        }];
+    },
+});

package/clis/weixin/drafts.js

@@ -0,0 +1,65 @@
+import { AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+const WEIXIN_DOMAIN = 'mp.weixin.qq.com';
+
+export const draftsCommand = cli({
+    site: 'weixin',
+    name: 'drafts',
+    description: '列出微信公众号草稿箱',
+    domain: WEIXIN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    timeoutSeconds: 60,
+    args: [
+        { name: 'limit', type: 'int', default: 10, help: '最多显示条数' },
+    ],
+    columns: ['Index', 'Title', 'Time'],
+
+    func: async (page, kwargs) => {
+        await page.goto('https://mp.weixin.qq.com/');
+        await page.wait(3);
+        const token = await page.evaluate(`(window.location.href.match(/token=(\\d+)/)||[])[1]`);
+        if (!token) {
+            throw new AuthRequiredError(WEIXIN_DOMAIN, '微信公众号草稿箱需要已登录的 mp.weixin.qq.com 会话');
+        }
+
+        await page.goto(`https://mp.weixin.qq.com/cgi-bin/appmsg?begin=0&count=${kwargs.limit}&type=77&action=list_card&token=${token}&lang=zh_CN`);
+        await page.wait(4);
+
+        const drafts = await page.evaluate(`(() => {
+            var results = [];
+            var idx = 0;
+
+            var cards = document.querySelectorAll('.weui-desktop-card');
+            for (var i = 0; i < cards.length; i++) {
+                if (cards[i].className.includes('card_new')) continue;
+                var titleEl = cards[i].querySelector('[class*=title]');
+                var timeEl = cards[i].querySelector('[class*=tips]');
+                var title = titleEl ? titleEl.textContent.trim() : '';
+                var time = timeEl ? timeEl.textContent.trim().replace(/\\s+/g, ' ') : '';
+                if (title) results.push({ Index: ++idx, Title: title, Time: time });
+            }
+            if (results.length > 0) return results;
+
+            var rows = document.querySelectorAll('tr, [class*=appmsg_item], [class*=list_item]');
+            rows.forEach(function(row) {
+                var titleEl = row.querySelector('[class*=title] a, [class*=title], h4');
+                var timeEl = row.querySelector('[class*=time], td:nth-child(2)');
+                var title = titleEl ? titleEl.textContent.trim() : '';
+                var time = timeEl ? timeEl.textContent.trim() : '';
+                if (title && title !== '内容' && title.length < 80) {
+                    results.push({ Index: ++idx, Title: title, Time: time });
+                }
+            });
+            return results;
+        })()`);
+
+        if (!drafts || drafts.length === 0) {
+            throw new EmptyResultError('weixin drafts', 'No structured drafts found in the current Weixin Official Account backend');
+        }
+
+        return drafts.slice(0, kwargs.limit);
+    },
+});