@jackwener/opencli 1.7.21 → 1.8.0

package/clis/twitter/thread.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { extractMedia } from './shared.js';
+import { extractMedia, extractCard, extractQuotedTweet } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const TWEET_DETAIL_QUERY_ID = 'nBS-WpgA6ZG0CyNHD517JQ';
@@ -46,9 +46,11 @@ function extractTweet(r, seen) {
     const u = tw.core?.user_results?.result;
     const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
     const screenName = u?.legacy?.screen_name || u?.core?.screen_name || 'unknown';
+    const bio = u?.legacy?.description || '';
     return {
         id: tw.rest_id,
         author: screenName,
+        bio,
         text: noteText || l.full_text || '',
         likes: l.favorite_count || 0,
         retweets: l.retweet_count || 0,
@@ -56,6 +58,8 @@ function extractTweet(r, seen) {
         created_at: l.created_at,
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(l),
+        card: extractCard(tw),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 function parseTweetDetail(data, seen) {
@@ -91,6 +95,10 @@ function parseTweetDetail(data, seen) {
     }
     return { tweets, nextCursor };
 }
+
+export const __test__ = {
+    parseTweetDetail,
+};
 // ── CLI definition ────────────────────────────────────────────────────
 cli({
     site: 'twitter',
@@ -105,7 +113,7 @@ cli({
         { name: 'limit', type: 'int', default: 50 },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the thread by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the conversation\'s structural ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         let tweetId = kwargs['tweet-id'];
         const urlMatch = tweetId.match(/\/status\/(\d+)/);

package/clis/twitter/thread.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './thread.js';
+
+describe('twitter thread parser', () => {
+    it('extracts author bio from tweet user entity', () => {
+        const command = getRegistry().get('twitter/thread');
+        expect(command?.columns).toEqual(['id', 'author', 'bio', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet']);
+        const result = __test__.parseTweetDetail({
+            data: {
+                threaded_conversation_with_injections_v2: {
+                    instructions: [
+                        {
+                            entries: [
+                                {
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '1',
+                                                    legacy: {
+                                                        full_text: 'thread tweet',
+                                                        favorite_count: 3,
+                                                        retweet_count: 2,
+                                                    },
+                                                    core: {
+                                                        user_results: {
+                                                            result: {
+                                                                legacy: {
+                                                                    screen_name: 'alice',
+                                                                    description: 'Thread author bio',
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        }, new Set());
+        expect(result.tweets).toHaveLength(1);
+        expect(result.tweets[0]).toMatchObject({
+            id: '1',
+            author: 'alice',
+            bio: 'Thread author bio',
+            text: 'thread tweet',
+            likes: 3,
+            retweets: 2,
+            url: 'https://x.com/alice/status/1',
+        });
+    });
+});

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, extractMedia } from './shared.js';
+import { resolveTwitterQueryId, extractMedia, extractCard, extractQuotedTweet } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
@@ -74,11 +74,13 @@ function extractTweet(result, seen) {
     seen.add(tw.rest_id);
     const u = tw.core?.user_results?.result;
     const screenName = u?.legacy?.screen_name || u?.core?.screen_name || 'unknown';
+    const bio = u?.legacy?.description || '';
     const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
     const views = tw.views?.count ? parseInt(tw.views.count, 10) : 0;
     return {
         id: tw.rest_id,
         author: screenName,
+        bio,
         text: noteText || l.full_text || '',
         likes: l.favorite_count || 0,
         retweets: l.retweet_count || 0,
@@ -87,6 +89,8 @@ function extractTweet(result, seen) {
         created_at: l.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(l),
+        card: extractCard(tw),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 function parseHomeTimeline(data, seen) {
@@ -152,7 +156,7 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Maximum number of tweets to return (default 20).' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the timeline by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps X\'s native ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         const timelineType = kwargs.type === 'following' ? 'following' : 'for-you';

package/clis/twitter/timeline.test.js

@@ -57,6 +57,7 @@ describe('twitter timeline helpers', () => {
                                                                 result: {
                                                                     legacy: {
                                                                         screen_name: 'alice',
+                                                                        description: 'Timeline author bio',
                                                                     },
                                                                 },
                                                             },
@@ -90,6 +91,7 @@ describe('twitter timeline helpers', () => {
         expect(result.tweets[0]).toMatchObject({
             id: '1',
             author: 'alice',
+            bio: 'Timeline author bio',
             text: 'hello',
             likes: 3,
             retweets: 2,

package/clis/twitter/tweets.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { resolveTwitterOperationMetadata, sanitizeQueryId, extractMedia, normalizeTwitterGraphqlPayload, unwrapBrowserResult } from './shared.js';
+import { resolveTwitterOperationMetadata, sanitizeQueryId, extractMedia, extractQuotedTweet, normalizeTwitterGraphqlPayload, unwrapBrowserResult } from './shared.js';
 import { normalizeTwitterScreenName } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
@@ -175,6 +175,7 @@ function extractTweet(result, seen) {
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(legacy),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 
@@ -226,7 +227,7 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Max tweets to return' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the tweets by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the chronological ordering.' },
     ],
-    columns: ['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const limit = Math.max(1, Math.min(200, kwargs.limit || 20));
         const rawUsername = String(kwargs.username ?? '').trim();

package/clis/twitter/tweets.test.js

@@ -6,7 +6,7 @@ import { __test__ } from './tweets.js';
 describe('twitter tweets helpers', () => {
     it('registers id and is_retweet in the default columns', () => {
         const cmd = getRegistry().get('twitter/tweets');
-        expect(cmd?.columns).toEqual(['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls']);
+        expect(cmd?.columns).toEqual(['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls', 'quoted_tweet']);
     });
 
     it('makes the username argument optional so it can default to the logged-in user', () => {

package/clis/weibo/comments.js

@@ -2,6 +2,7 @@
  * Weibo comments — get comments on a post.
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { requireArrayEvaluateResult, unwrapEvaluateResult } from './utils.js';
 cli({
     site: 'weibo',
     name: 'comments',
@@ -19,7 +20,7 @@ cli({
         await page.goto('https://weibo.com');
         await page.wait(2);
         const id = String(kwargs.id);
-        const data = await page.evaluate(`
+        const data = requireArrayEvaluateResult(unwrapEvaluateResult(await page.evaluate(`
       (async () => {
         const id = ${JSON.stringify(id)};
         const count = ${count};
@@ -46,9 +47,7 @@ cli({
           return item;
         });
       })()
-    `);
-        if (!Array.isArray(data))
-            return [];
+    `)), 'weibo comments');
         return data;
     },
 });

package/clis/weibo/delete.js

@@ -0,0 +1,172 @@
+/**
+ * Weibo delete — remove a single post owned by the logged-in user.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { requireObjectEvaluateResult, unwrapEvaluateResult } from './utils.js';
+
+const WEIBO_HOST_RE = /(^|\.)weibo\.(com|cn)$/i;
+const POST_ID_RE = /^[A-Za-z0-9]{4,32}$/;
+
+function normalizePostId(raw) {
+    const input = String(raw ?? '').trim();
+    if (!input) {
+        throw new ArgumentError('weibo delete: id cannot be empty');
+    }
+
+    let candidate = input;
+    try {
+        const url = new URL(input);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            throw new ArgumentError('weibo delete: URL must use http or https');
+        }
+        if (!WEIBO_HOST_RE.test(url.hostname)) {
+            throw new ArgumentError('weibo delete: URL must be a weibo.com or weibo.cn post URL');
+        }
+        const parts = url.pathname.split('/').filter(Boolean);
+        if (url.hostname.toLowerCase().endsWith('weibo.cn') && parts[0] === 'status') {
+            candidate = parts[1] ?? '';
+        } else {
+            candidate = parts.at(-1) ?? '';
+        }
+    } catch (error) {
+        if (error instanceof ArgumentError) throw error;
+    }
+
+    candidate = String(candidate ?? '').trim();
+    if (!POST_ID_RE.test(candidate)) {
+        throw new ArgumentError('weibo delete: id must be a numeric idstr, mblogid, or Weibo post URL');
+    }
+    return candidate;
+}
+
+cli({
+    site: 'weibo',
+    name: 'delete',
+    access: 'write',
+    description: 'Delete one of my Weibo posts by id',
+    domain: 'weibo.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        {
+            name: 'id',
+            required: true,
+            positional: true,
+            help: 'Post ID (numeric idstr or mblogid from URL / weibo me / weibo post output)',
+        },
+    ],
+    columns: ['status', 'id', 'mblogid'],
+    func: async (page, kwargs) => {
+        if (!page) {
+            throw new CommandExecutionError('Browser session required for weibo delete');
+        }
+        const raw = String(kwargs.id ?? '').trim();
+        const id = normalizePostId(raw);
+        await page.goto('https://weibo.com');
+        await page.wait(2);
+        const result = requireObjectEvaluateResult(unwrapEvaluateResult(await page.evaluate(`
+      (async () => {
+        const input = ${JSON.stringify(id)};
+        const readCookie = (name) => {
+          const pair = document.cookie.split(';').map(s => s.trim()).find(s => s.startsWith(name + '='));
+          return pair ? decodeURIComponent(pair.slice(name.length + 1)) : '';
+        };
+        // Step 1: resolve mblogid / idstr to canonical idstr via /show.
+        const showResp = await fetch('/ajax/statuses/show?id=' + encodeURIComponent(input), { credentials: 'include' });
+        if (showResp.status === 401 || showResp.status === 403) {
+          return { ok: false, error: 'auth', status: showResp.status };
+        }
+        // 404 from /show means the post does not exist (deleted, wrong id, or
+        // not owned by the logged-in user); map to the same path as a 2xx
+        // response with no idstr so the caller throws EmptyResultError
+        // instead of a generic CommandExecutionError("HTTP 404").
+        if (showResp.status === 404) {
+          return { ok: false, error: 'not_found', input };
+        }
+        if (!showResp.ok) {
+          return { ok: false, error: 'show_http', status: showResp.status };
+        }
+        const showBody = await showResp.json();
+        if (!showBody || !showBody.idstr) {
+          return { ok: false, error: 'not_found', input };
+        }
+        const idstr = String(showBody.idstr);
+        const mblogid = showBody.mblogid || '';
+        // Step 2: destroy. Weibo requires X-Xsrf-Token (double-submit CSRF token).
+        const token = readCookie('XSRF-TOKEN');
+        const destroyResp = await fetch('/ajax/statuses/destroy', {
+          method: 'POST',
+          credentials: 'include',
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'X-Xsrf-Token': token,
+          },
+          body: 'id=' + encodeURIComponent(idstr),
+        });
+        if (destroyResp.status === 401 || destroyResp.status === 403) {
+          return { ok: false, error: 'auth', status: destroyResp.status };
+        }
+        if (!destroyResp.ok) {
+          return { ok: false, error: 'destroy_http', status: destroyResp.status };
+        }
+        const destroyBody = await destroyResp.json();
+        // Require an explicit success signal from the API: { ok: 1 }. A
+        // missing / falsy body must not be silently treated as success.
+        if (!destroyBody || typeof destroyBody !== 'object') {
+          return { ok: false, error: 'api', msg: 'destroy returned malformed response', id: idstr };
+        }
+        if (destroyBody.ok !== 1) {
+          return { ok: false, error: 'api', msg: destroyBody.msg || destroyBody.message || 'destroy returned non-ok', id: idstr };
+        }
+        // Step 3: postcondition evidence. A write command cannot report success
+        // until the target no longer resolves after the delete API returns ok.
+        const verifyResp = await fetch('/ajax/statuses/show?id=' + encodeURIComponent(idstr), { credentials: 'include' });
+        if (verifyResp.status === 401 || verifyResp.status === 403) {
+          return { ok: false, error: 'auth', status: verifyResp.status };
+        }
+        if (verifyResp.status === 404) {
+          return { ok: true, id: idstr, mblogid };
+        }
+        if (!verifyResp.ok) {
+          return { ok: false, error: 'verify_http', status: verifyResp.status, id: idstr };
+        }
+        let verifyBody = null;
+        try {
+          verifyBody = await verifyResp.json();
+        } catch {
+          return { ok: false, error: 'verify_malformed', msg: 'verify returned non-JSON response', id: idstr };
+        }
+        if (!verifyBody || typeof verifyBody !== 'object') {
+          return { ok: false, error: 'verify_malformed', msg: 'verify returned malformed response', id: idstr };
+        }
+        if (String(verifyBody.idstr || '') === idstr) {
+          return { ok: false, error: 'still_exists', id: idstr, mblogid: verifyBody.mblogid || mblogid };
+        }
+        if (!verifyBody.idstr || verifyBody.ok === 0) {
+          return { ok: true, id: idstr, mblogid };
+        }
+        return { ok: false, error: 'verify_mismatch', msg: 'verify returned a different post id', id: idstr };
+      })()
+    `)), 'weibo delete');
+        if (result.error === 'auth') {
+            throw new AuthRequiredError('weibo.com', 'Cookie 已过期！请在当前 Chrome 浏览器中重新登录 Weibo。');
+        }
+        if (result.error === 'not_found') {
+            throw new EmptyResultError('weibo delete', `Post not found for id "${String(result.input ?? raw)}". Verify the post still exists and belongs to the logged-in account.`);
+        }
+        if (result.error === 'show_http' || result.error === 'destroy_http' || result.error === 'verify_http') {
+            throw new CommandExecutionError(`weibo delete: HTTP ${result.status}`);
+        }
+        if (result.error === 'api' || result.error === 'verify_malformed' || result.error === 'verify_mismatch' || result.error === 'still_exists') {
+            throw new CommandExecutionError(`weibo delete: ${String(result.msg ?? result.error)}`);
+        }
+        if (!result.ok) {
+            throw new CommandExecutionError('weibo delete returned an unexpected response');
+        }
+        return [{ status: 'deleted', id: String(result.id ?? ''), mblogid: String(result.mblogid ?? '') }];
+    },
+});
+
+export const __test__ = {
+    normalizePostId,
+};

package/clis/weibo/delete.test.js

@@ -0,0 +1,94 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+import './delete.js';
+
+function makePage(evaluateResult) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(evaluateResult),
+  };
+}
+
+describe('weibo delete command', () => {
+  const getCommand = () => getRegistry().get('weibo/delete');
+
+  it('returns deleted status when the API reports success', async () => {
+    const page = makePage({ ok: true, id: '5197123456789012', mblogid: 'Px2yQfXYZ' });
+    const result = await getCommand().func(page, { id: 'Px2yQfXYZ' });
+    expect(result).toEqual([
+      { status: 'deleted', id: '5197123456789012', mblogid: 'Px2yQfXYZ' },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith('https://weibo.com');
+    const script = page.evaluate.mock.calls[0][0];
+    expect(script.match(/\/ajax\/statuses\/show/g)).toHaveLength(2);
+    expect(script).toContain('/ajax/statuses/destroy');
+    expect(script).toContain('still_exists');
+  });
+
+  it('normalizes supported Weibo post URLs before evaluating delete flow', async () => {
+    const page = makePage({ ok: true, id: '5197123456789012', mblogid: 'Px2yQfXYZ' });
+    const result = await getCommand().func(page, { id: 'https://weibo.com/1234567890/Px2yQfXYZ?refer_flag=1001030103_' });
+
+    expect(result).toEqual([
+      { status: 'deleted', id: '5197123456789012', mblogid: 'Px2yQfXYZ' },
+    ]);
+    expect(page.evaluate.mock.calls[0][0]).toContain('const input = "Px2yQfXYZ"');
+  });
+
+  it('throws ArgumentError when id is empty or whitespace', async () => {
+    const page = makePage({ ok: true, id: '0' });
+    await expect(getCommand().func(page, { id: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { id: '' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { id: 'https://example.com/123/Px2yQfXYZ' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { id: 'javascript:alert(1)' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { id: '../not-a-post' })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('maps 401 / 403 from the show endpoint to AuthRequiredError', async () => {
+    const page = makePage({ error: 'auth', status: 401 });
+    await expect(getCommand().func(page, { id: 'Px2yQfXYZ' })).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('throws EmptyResultError when the post cannot be resolved', async () => {
+    const page = makePage({ error: 'not_found', input: 'Px2yQfXYZ' });
+    await expect(getCommand().func(page, { id: 'Px2yQfXYZ' })).rejects.toBeInstanceOf(EmptyResultError);
+  });
+
+  it('throws CommandExecutionError on non-2xx show response', async () => {
+    const page = makePage({ error: 'show_http', status: 500 });
+    await expect(getCommand().func(page, { id: '5197123456789012' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError on non-2xx destroy response', async () => {
+    const page = makePage({ error: 'destroy_http', status: 502 });
+    await expect(getCommand().func(page, { id: '5197123456789012' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('surfaces API-level errors from destroy as CommandExecutionError with msg', async () => {
+    const page = makePage({ error: 'api', msg: '无权限删除', id: '5197123456789012' });
+    await expect(getCommand().func(page, { id: '5197123456789012' })).rejects.toThrowError(/无权限删除/);
+  });
+
+  it('throws CommandExecutionError when postcondition verification still sees the target', async () => {
+    const page = makePage({ error: 'still_exists', id: '5197123456789012', mblogid: 'Px2yQfXYZ' });
+    await expect(getCommand().func(page, { id: '5197123456789012' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError when postcondition verification is malformed', async () => {
+    const page = makePage({ error: 'verify_malformed', msg: 'verify returned malformed response', id: '5197123456789012' });
+    await expect(getCommand().func(page, { id: '5197123456789012' })).rejects.toThrowError(/verify returned malformed response/);
+  });
+
+  it('unwraps the browser-bridge { session, data } envelope', async () => {
+    const page = makePage({
+      session: 'site:weibo:abc',
+      data: { ok: true, id: '42', mblogid: 'M420' },
+    });
+    const result = await getCommand().func(page, { id: 'M420' });
+    expect(result).toEqual([{ status: 'deleted', id: '42', mblogid: 'M420' }]);
+  });
+});

package/clis/weibo/envelope.test.js

@@ -0,0 +1,85 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './comments.js';
+import './favorites.js';
+import './feed.js';
+import './hot.js';
+import './me.js';
+import './post.js';
+import './search.js';
+import './user.js';
+
+function envelope(data) {
+  return { session: 'site:weibo:test', data };
+}
+
+function makePage(evaluateResults = []) {
+  const queue = [...evaluateResults];
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(async (script) => {
+      if (String(script).includes('window.scrollBy')) return undefined;
+      return queue.length ? queue.shift() : undefined;
+    }),
+  };
+}
+
+describe('weibo read adapters Browser Bridge envelopes', () => {
+  it('unwraps comments, feed, hot, search, and favorites array payloads', async () => {
+    await expect(getRegistry().get('weibo/comments').func(
+      makePage([envelope([{ rank: 1, author: 'a', text: 't', likes: 0, replies: 0, time: '' }])]),
+      { id: '123', limit: 1 },
+    )).resolves.toHaveLength(1);
+
+    await expect(getRegistry().get('weibo/feed').func(
+      makePage([envelope('123456'), envelope([{ id: 'm1', author: 'a', text: 't', reposts: 0, comments: 0, likes: 0, time: '', url: 'https://weibo.com/1/m1' }])]),
+      { type: 'for-you', limit: 1 },
+    )).resolves.toHaveLength(1);
+
+    await expect(getRegistry().get('weibo/hot').func(
+      makePage([envelope([{ rank: 1, word: 'opencli', hot_value: 1, category: '', label: '', url: 'https://s.weibo.com/weibo?q=opencli' }])]),
+      { limit: 1 },
+    )).resolves.toHaveLength(1);
+
+    await expect(getRegistry().get('weibo/search').func(
+      makePage([envelope([{ id: 'm1', title: 'OpenCLI', author: 'a', time: '', url: 'https://weibo.com/1/m1' }])]),
+      { keyword: 'opencli', limit: 1 },
+    )).resolves.toEqual([{ rank: 1, id: 'm1', title: 'OpenCLI', author: 'a', time: '', url: 'https://weibo.com/1/m1' }]);
+
+    await expect(getRegistry().get('weibo/favorites').func(
+      makePage([envelope('123456'), envelope([{ text: '作者A\n这是一条收藏微博', url: 'https://weibo.com/123/AbCd1' }])]),
+      { limit: 1 },
+    )).resolves.toHaveLength(1);
+  });
+
+  it('unwraps me, post, and user object payloads', async () => {
+    await expect(getRegistry().get('weibo/me').func(
+      makePage([envelope('123456'), envelope({ screen_name: 'me', uid: '123456' })]),
+      {},
+    )).resolves.toMatchObject({ screen_name: 'me', uid: '123456' });
+
+    await expect(getRegistry().get('weibo/post').func(
+      makePage([envelope({ id: '1', text: 'post' })]),
+      { id: '1' },
+    )).resolves.toContainEqual({ field: 'text', value: 'post' });
+
+    await expect(getRegistry().get('weibo/user').func(
+      makePage([envelope({ screen_name: 'alice', uid: '42' })]),
+      { id: '42' },
+    )).resolves.toMatchObject({ screen_name: 'alice', uid: '42' });
+  });
+
+  it('fails typed instead of returning empty rows for malformed post-unwrap payloads', async () => {
+    await expect(getRegistry().get('weibo/hot').func(
+      makePage([envelope({ error: 'API error' })]),
+      { limit: 1 },
+    )).rejects.toBeInstanceOf(CommandExecutionError);
+
+    await expect(getRegistry().get('weibo/user').func(
+      makePage([envelope([{ screen_name: 'wrong shape' }])]),
+      { id: '42' },
+    )).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+});

package/clis/weibo/favorites.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { getSelfUid } from './utils.js';
+import { getSelfUid, requireArrayEvaluateResult, unwrapEvaluateResult } from './utils.js';
 
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 50;
@@ -123,7 +123,7 @@ cli({
       await page.wait(1);
     }
 
-    const rawData = await page.evaluate(`
+    const rawData = requireArrayEvaluateResult(unwrapEvaluateResult(await page.evaluate(`
       (() => {
         const scrollers = document.querySelectorAll('.wbpro-scroller-item, .vue-recycle-scroller__item-view');
         const out = [];
@@ -145,9 +145,9 @@ cli({
         }
         return out;
       })()
-    `);
+    `)), 'weibo favorites');
 
-    if (!Array.isArray(rawData) || rawData.length === 0) {
+    if (rawData.length === 0) {
       throw new EmptyResultError('weibo favorites', 'No favorites were visible on the favorites page');
     }
 

package/clis/weibo/feed.js

@@ -2,7 +2,7 @@
  * Weibo feed — for-you or following timeline.
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { getSelfUid } from './utils.js';
+import { getSelfUid, requireArrayEvaluateResult, unwrapEvaluateResult } from './utils.js';
 const TIMELINE_ENDPOINTS = {
     'for-you': 'unreadfriendstimeline',
     following: 'friendstimeline',
@@ -31,7 +31,7 @@ cli({
         await page.goto('https://weibo.com');
         await page.wait(2);
         const uid = await getSelfUid(page);
-        const data = await page.evaluate(`
+        const data = requireArrayEvaluateResult(unwrapEvaluateResult(await page.evaluate(`
       (async () => {
         const uid = ${JSON.stringify(uid)};
         const count = ${count};
@@ -63,9 +63,7 @@ cli({
           return item;
         });
       })()
-    `);
-        if (!Array.isArray(data))
-            return [];
+    `)), 'weibo feed');
         return data;
     },
 });