@jackwener/opencli 1.7.22 → 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/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/publish.js

@@ -30,8 +30,15 @@ const SUBMIT_POLL_MS = 500;
 const SUBMIT_TIMEOUT_MS = 20_000;
 const SUPPORTED_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
 
-// Weibo PC UI selectors
-const TEXTAREA_SELECTOR = 'textarea._input_13iqr_8';
+// Weibo PC UI selectors. The CSS-module hash drifts on every frontend
+// rebuild (#1602), so match on the stable placeholder text and keep the
+// legacy hash as a last-resort fallback. Callers pick the LAST visible
+// match because the compose modal renders on top of the home-feed strip.
+const TEXTAREA_SELECTORS = [
+    'textarea[placeholder*="有什么新鲜事"]',
+    'textarea[placeholder*="新鲜事"]',
+    'textarea._input_13iqr_8',
+];
 const FILE_INPUT_SELECTOR = 'input[type="file"][class*="_file_"]';
 
 function validateText(text) {
@@ -125,12 +132,19 @@ cli({
         let editorFound = false;
         for (let i = 0; i < Math.ceil(COMPOSE_TIMEOUT_MS / COMPOSE_POLL_MS); i++) {
             const result = await page.evaluate(`
-                () => {
-                    const ta = document.querySelector('textarea._input_13iqr_8');
-                    if (!ta) return { found: false };
-                    const visible = ta.offsetParent !== null;
-                    return { found: true, visible, rectTop: visible ? ta.getBoundingClientRect().top : -1 };
-                }
+                (selectors => {
+                    // Pick the LAST visible match across all selectors so
+                    // the modal (rendered on top of the home-feed strip)
+                    // wins over earlier matches. See TEXTAREA_SELECTORS.
+                    let last = null;
+                    for (const sel of selectors) {
+                        for (const t of document.querySelectorAll(sel)) {
+                            if (t.offsetParent !== null) last = t;
+                        }
+                    }
+                    if (!last) return { found: false };
+                    return { found: true, visible: true, rectTop: last.getBoundingClientRect().top };
+                })(${JSON.stringify(TEXTAREA_SELECTORS)})
             `);
             if (result?.found && result.visible && result.rectTop >= 0) {
                 editorFound = true;
@@ -187,9 +201,14 @@ cli({
         // IMPORTANT: Using nativeSetter preserves the textarea's reactive/internal state.
         // Direct ta.value= assignment bypasses Weibo's Vue reactivity and causes "undefined" content.
         const insertResult = await page.evaluateWithArgs(`
-            (() => {
-                const ta = document.querySelector('textarea._input_13iqr_8');
-                if (!ta || ta.offsetParent === null) return { ok: false, message: 'textarea not visible' };
+            ((selectors) => {
+                let ta = null;
+                for (const sel of selectors) {
+                    for (const t of document.querySelectorAll(sel)) {
+                        if (t.offsetParent !== null) ta = t;
+                    }
+                }
+                if (!ta) return { ok: false, message: 'textarea not visible' };
                 ta.focus();
                 const nativeSetter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
                 if (nativeSetter) {
@@ -200,7 +219,7 @@ cli({
                 ta.dispatchEvent(new Event('input', { bubbles: true }));
                 ta.dispatchEvent(new Event('change', { bubbles: true }));
                 return { ok: true, valueLength: ta.value.length };
-            })()
+            })(${JSON.stringify(TEXTAREA_SELECTORS)})
         `, { textContent: text });
 
         if (!insertResult?.ok) {
@@ -233,10 +252,14 @@ cli({
         }
 
         // Step 8: Wait for success/failure result
+        // Use page.evaluate (not evaluateWithArgs): the IIFE doesn't reference
+        // any outer args, and evaluateWithArgs would re-declare its const
+        // bindings each loop iteration in the same page context, throwing
+        // "Identifier already declared" after the first iteration.
         let finalResult = null;
         for (let i = 0; i < Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS); i++) {
             await page.wait({ time: SUBMIT_POLL_MS / 1000 });
-            finalResult = await page.evaluateWithArgs(`
+            finalResult = await page.evaluate(`
                 (() => {
                     const successMarkers = ['发布成功', '已发布', '发送成功'];
                     const errorMarkers = ['发布失败', '发送失败', '内容违规', '请稍后再试', '频繁'];
@@ -257,7 +280,7 @@ cli({
                     }
                     return null;
                 })()
-            `, { maxIterations: Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS), currentIndex: i });
+            `);
             if (finalResult !== null) break;
         }
 

package/clis/weibo/publish.test.js

@@ -61,10 +61,10 @@ describe('weibo publish command', () => {
         { ok: true },
         { found: true, visible: true, rectTop: 100 },
         { ok: true, label: '发送' },
+        { ok: true, message: '发送成功' },
       ],
       evaluateWithArgsResults: [
         { ok: true, valueLength: 5 },
-        { ok: true, message: '发送成功' },
       ],
     });
 
@@ -72,6 +72,9 @@ describe('weibo publish command', () => {
 
     expect(result).toEqual([{ status: 'success', message: '发送成功', text: 'hello' }]);
     expect(page.goto).toHaveBeenCalledWith('https://weibo.com', { waitUntil: 'load', settleMs: 2000 });
+    expect(page.evaluate.mock.calls[2][0]).toContain('有什么新鲜事');
+    expect(page.evaluate.mock.calls[2][0]).toContain('textarea._input_13iqr_8');
+    expect(page.evaluateWithArgs.mock.calls[0][0]).toContain('有什么新鲜事');
   });
 
   it('uploads up to nine images before publishing', async () => {
@@ -83,11 +86,11 @@ describe('weibo publish command', () => {
         { found: true, visible: true, rectTop: 100 },
         true,
         { ok: true, label: '发送' },
+        { ok: true, message: '发送成功' },
       ],
       evaluateWithArgsResults: [
         { ok: true, count: 2 },
         { ok: true, valueLength: 11 },
-        { ok: true, message: '发送成功' },
       ],
     });
 
@@ -149,10 +152,10 @@ describe('weibo publish command', () => {
         { ok: true },
         { found: true, visible: true, rectTop: 100 },
         { ok: true, label: '发送' },
+        { ok: false, message: '内容违规' },
       ],
       evaluateWithArgsResults: [
         { ok: true, valueLength: 5 },
-        { ok: false, message: '内容违规' },
       ],
     });
 
@@ -161,22 +164,28 @@ describe('weibo publish command', () => {
 
   it('does not treat editor close as positive publish proof', async () => {
     const command = getCommand();
+    // Step 8 polls up to SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS iterations
+    // (= 20000 / 500 = 40 in upstream). Derive the window programmatically
+    // so the test stays aligned with the implementation if the timeout
+    // changes, and override the makePage default { ok: true } fallback that
+    // would otherwise satisfy the success-marker break.
+    const SUBMIT_POLL_ITERATIONS = Math.ceil(20_000 / 500);
     const page = makePage({
       evaluateResults: [
         '123456',
         { ok: true },
         { found: true, visible: true, rectTop: 100 },
         { ok: true, label: '发送' },
+        ...Array(SUBMIT_POLL_ITERATIONS).fill(null),
       ],
       evaluateWithArgsResults: [
         { ok: true, valueLength: 5 },
-        null,
       ],
     });
 
     await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(CommandExecutionError);
 
-    const submitScript = page.evaluateWithArgs.mock.calls.at(-1)[0];
+    const submitScript = page.evaluate.mock.calls.at(-1)[0];
     expect(submitScript).not.toContain('Editor closed after publish');
     expect(submitScript).toContain('发布成功');
   });