@jackwener/opencli 1.7.8 → 1.7.10

package/clis/weibo/publish.js

@@ -0,0 +1,282 @@
+/**
+ * Weibo publish — post a new Weibo update via browser UI automation.
+ *
+ * Flow:
+ *   1. Navigate to weibo.com and wait for the feed
+ *   2. Check login state (getSelfUid)
+ *   3. Click "发微博" button to open the inline compose editor
+ *   4. Wait for textarea editor to appear
+ *   5. Fill text content via CDP type
+ *   6. Optionally upload images via CDP setFileInput
+ *   7. Click the publish button
+ *   8. Poll for success/failure feedback
+ *
+ * Usage:
+ *   opencli weibo publish "Hello from OpenCLI! #opencli"  # publishes immediately
+ *   opencli weibo publish "Check this out" --images /path/a.jpg,/path/b.jpg
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { getSelfUid } from './utils.js';
+
+const MAX_IMAGES = 9;
+const UPLOAD_POLL_MS = 1500;
+const UPLOAD_TIMEOUT_MS = 30_000;
+const COMPOSE_POLL_MS = 300;
+const COMPOSE_TIMEOUT_MS = 10_000;
+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';
+const FILE_INPUT_SELECTOR = 'input[type="file"][class*="_file_"]';
+
+function validateText(text) {
+    const t = String(text ?? '').trim();
+    if (!t) throw new ArgumentError('weibo publish text cannot be empty');
+    if (t.length > 2000) throw new ArgumentError('weibo publish text exceeds 2000 characters');
+    return t;
+}
+
+function validateImagePaths(raw) {
+    if (!raw) return [];
+    const paths = raw.split(',').map(s => s.trim()).filter(Boolean);
+    if (paths.length > MAX_IMAGES) {
+        throw new ArgumentError(`Too many images: ${paths.length} (max ${MAX_IMAGES})`);
+    }
+    return paths.map(p => {
+        const absPath = path.resolve(p);
+        const ext = path.extname(absPath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) {
+            throw new ArgumentError(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
+        }
+        const stat = fs.statSync(absPath, { throwIfNoEntry: false });
+        if (!stat || !stat.isFile()) {
+            throw new ArgumentError(`Not a valid file: ${absPath}`);
+        }
+        return absPath;
+    });
+}
+
+cli({
+    site: 'weibo',
+    name: 'publish',
+    description: 'Publish a new Weibo post immediately',
+    domain: 'weibo.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        {
+            name: 'text',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'Weibo text content (max 2000 chars)',
+        },
+        {
+            name: 'images',
+            type: 'string',
+            required: false,
+            help: `Image paths, comma-separated, max ${MAX_IMAGES} (jpg/png/gif/webp)`,
+        },
+    ],
+    columns: ['status', 'message', 'text'],
+    func: async (page, kwargs) => {
+        if (!page) throw new CommandExecutionError('Browser session required for weibo publish');
+
+        const text = validateText(kwargs.text);
+        const absPaths = validateImagePaths(kwargs.images);
+
+        // Step 1: Navigate to weibo.com and wait for feed to load
+        await page.goto('https://weibo.com', { waitUntil: 'load', settleMs: 2000 });
+        await page.wait({ time: 2 });
+
+        // Step 2: Check login
+        try {
+            await getSelfUid(page);
+        } catch (err) {
+            if (err instanceof AuthRequiredError) throw err;
+            throw new CommandExecutionError('Not logged into Weibo. Please login at weibo.com in your Chrome browser.');
+        }
+
+        // Step 3: Click "发微博" button to open inline compose editor
+        const clickResult = await page.evaluate(`
+            () => {
+                const visible = el => !!el && el.offsetParent !== null && !el.disabled;
+                const buttons = document.querySelectorAll('button[title="发微博"], button[title="写微博"]');
+                for (const btn of buttons) {
+                    if (visible(btn)) {
+                        btn.click();
+                        return { ok: true };
+                    }
+                }
+                return { ok: false, message: 'Could not find 发微博 button' };
+            }
+        `);
+        if (!clickResult?.ok) {
+            throw new CommandExecutionError(clickResult?.message ?? 'Could not open compose editor.');
+        }
+
+        // Step 4: Wait for the textarea editor to appear (visible, not just in DOM)
+        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 };
+                }
+            `);
+            if (result?.found && result.visible && result.rectTop >= 0) {
+                editorFound = true;
+                break;
+            }
+            await page.wait({ time: COMPOSE_POLL_MS / 1000 });
+        }
+        if (!editorFound) {
+            throw new CommandExecutionError('Weibo compose editor did not appear');
+        }
+
+        // Step 5: Upload images first (before text to avoid editor reset)
+        if (absPaths.length > 0) {
+            if (!page.setFileInput) {
+                throw new CommandExecutionError('Browser extension does not support file upload. Please update the extension.');
+            }
+
+            // Find the file input
+            const fileInputFound = await page.evaluate(`
+                () => {
+                    const input = document.querySelector('input[type="file"][class*="_file_"]');
+                    return !!input;
+                }
+            `);
+            if (!fileInputFound) {
+                throw new CommandExecutionError('Could not find image file input on Weibo compose page. UI may have changed.');
+            }
+
+            await page.setFileInput(absPaths, FILE_INPUT_SELECTOR);
+
+            // Wait for upload to complete
+            let uploadResult = null;
+            for (let i = 0; i < Math.ceil(UPLOAD_TIMEOUT_MS / UPLOAD_POLL_MS); i++) {
+                await page.wait({ time: UPLOAD_POLL_MS / 1000 });
+                uploadResult = await page.evaluateWithArgs(`
+                    (() => {
+                        const expectedCount = expected;
+                        const uploading = document.querySelector('[class*="upload"], [class*="progress"]');
+                        if (uploading && uploading.offsetParent !== null) return null;
+                        const pics = document.querySelectorAll('img[class*="pic"], [class*="imgItem"], [class*="picture"] img');
+                        if (pics.length >= expectedCount) return { ok: true, count: pics.length };
+                        return null;
+                    })()
+                `, { expected: absPaths.length });
+                if (uploadResult !== null) break;
+            }
+
+            if (!uploadResult?.ok) {
+                throw new CommandExecutionError(uploadResult?.message ?? 'Image upload did not complete before timeout');
+            }
+        }
+
+        // Step 6: Insert text using native DOM setter (preserves Weibo internal state)
+        // 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' };
+                ta.focus();
+                const nativeSetter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
+                if (nativeSetter) {
+                    nativeSetter.call(ta, textContent);
+                } else {
+                    ta.value = textContent;
+                }
+                ta.dispatchEvent(new Event('input', { bubbles: true }));
+                ta.dispatchEvent(new Event('change', { bubbles: true }));
+                return { ok: true, valueLength: ta.value.length };
+            })()
+        `, { textContent: text });
+
+        if (!insertResult?.ok) {
+            throw new CommandExecutionError(insertResult?.message ?? 'Could not insert text.');
+        }
+
+
+        // Step 7: Click the send button inside the compose editor
+        // Try 发送 first (compose editor's submit), then 发布 (fallback)
+        await page.wait({ time: 0.5 });
+        const publishResult = await page.evaluate(`
+            () => {
+                const visible = el => !!el && el.offsetParent !== null && !el.disabled;
+                const labels = ['发送', '发布'];
+                for (const label of labels) {
+                    const allBtns = document.querySelectorAll('button, [role="button"]');
+                    for (const btn of allBtns) {
+                        const t = (btn.innerText || btn.textContent || '').trim();
+                        if (t === label && visible(btn)) {
+                            btn.click();
+                            return { ok: true, label };
+                        }
+                    }
+                }
+                return { ok: false, message: 'Could not find send button' };
+            }
+        `);
+        if (!publishResult?.ok) {
+            throw new CommandExecutionError(publishResult?.message ?? 'Could not click publish.');
+        }
+
+        // Step 8: Wait for success/failure result
+        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(`
+                (() => {
+                    const successMarkers = ['发布成功', '已发布', '发送成功'];
+                    const errorMarkers = ['发布失败', '发送失败', '内容违规', '请稍后再试', '频繁'];
+                    for (const el of document.querySelectorAll('*')) {
+                        if (el.children.length > 3) continue;
+                        const txt = (el.innerText || '').trim();
+                        if (!txt || txt.length > 100) continue;
+                        for (const m of successMarkers) {
+                            if (txt.includes(m) && (txt.includes('成功') || txt.includes('微博'))) {
+                                return { ok: true, message: txt };
+                            }
+                        }
+                        for (const m of errorMarkers) {
+                            if (txt.includes(m)) {
+                                return { ok: false, message: txt };
+                            }
+                        }
+                    }
+                    return null;
+                })()
+            `, { maxIterations: Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS), currentIndex: i });
+            if (finalResult !== null) break;
+        }
+
+        if (!finalResult) {
+            throw new CommandExecutionError('Publish button clicked but result was unclear. Check Weibo manually.');
+        }
+
+        if (!finalResult.ok) {
+            throw new CommandExecutionError(finalResult.message || 'Weibo publish failed');
+        }
+
+        return [{
+            status: 'success',
+            message: finalResult.message || 'Published successfully',
+            text,
+        }];
+    },
+});
+
+export const __test__ = {
+    validateText,
+    validateImagePaths,
+};

package/clis/weibo/publish.test.js

@@ -0,0 +1,183 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    statSync: vi.fn((p) => {
+      if (String(p).includes('missing')) return undefined;
+      return { isFile: () => !String(p).includes('directory') };
+    }),
+  };
+});
+
+vi.mock('node:path', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    resolve: vi.fn((p) => `/abs/${p}`),
+    extname: vi.fn((p) => {
+      const m = String(p).match(/\.[^.]+$/);
+      return m ? m[0] : '';
+    }),
+  };
+});
+
+import './publish.js';
+
+function makePage({ evaluateResults = [], evaluateWithArgsResults = [], overrides = {} } = {}) {
+  const evaluate = vi.fn();
+  for (const result of evaluateResults) {
+    evaluate.mockResolvedValueOnce(result);
+  }
+  evaluate.mockResolvedValue({ ok: true });
+
+  const evaluateWithArgs = vi.fn();
+  for (const result of evaluateWithArgsResults) {
+    evaluateWithArgs.mockResolvedValueOnce(result);
+  }
+  evaluateWithArgs.mockResolvedValue(null);
+
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+    evaluateWithArgs,
+    setFileInput: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
+describe('weibo publish command', () => {
+  const getCommand = () => getRegistry().get('weibo/publish');
+
+  it('publishes a text-only post when the UI reports success', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, valueLength: 5 },
+        { ok: true, message: '发送成功' },
+      ],
+    });
+
+    const result = await command.func(page, { text: 'hello' });
+
+    expect(result).toEqual([{ status: 'success', message: '发送成功', text: 'hello' }]);
+    expect(page.goto).toHaveBeenCalledWith('https://weibo.com', { waitUntil: 'load', settleMs: 2000 });
+  });
+
+  it('uploads up to nine images before publishing', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        true,
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, count: 2 },
+        { ok: true, valueLength: 11 },
+        { ok: true, message: '发送成功' },
+      ],
+    });
+
+    await command.func(page, { text: 'with images', images: 'a.png,b.webp' });
+
+    expect(page.setFileInput).toHaveBeenCalledWith(
+      ['/abs/a.png', '/abs/b.webp'],
+      'input[type="file"][class*="_file_"]',
+    );
+  });
+
+  it('maps auth failures to AuthRequiredError', async () => {
+    const command = getCommand();
+    const page = makePage({ evaluateResults: [null, null] });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('validates text and image arguments before navigation', async () => {
+    const command = getCommand();
+    const page = makePage();
+
+    await expect(command.func(page, { text: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(command.func(page, { text: 'hi', images: 'a.bmp' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(command.func(page, { text: 'hi', images: 'missing.png' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(command.func(page, { text: 'hi', images: '1.png,2.png,3.png,4.png,5.png,6.png,7.png,8.png,9.png,10.png' })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('throws CommandExecutionError when compose cannot be opened', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: ['123456', { ok: false, message: 'Could not find 发微博 button' }],
+    });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError when upload readiness is not proven', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        true,
+      ],
+      evaluateWithArgsResults: [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null],
+    });
+
+    await expect(command.func(page, { text: 'hello', images: 'a.png' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError when publish result is unclear or failed', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, valueLength: 5 },
+        { ok: false, message: '内容违规' },
+      ],
+    });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('does not treat editor close as positive publish proof', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        { ok: true, label: '发送' },
+      ],
+      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];
+    expect(submitScript).not.toContain('Editor closed after publish');
+    expect(submitScript).toContain('发布成功');
+  });
+});

package/clis/weread/ranking.js

@@ -12,7 +12,7 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Max results' },
     ],
     columns: ['rank', 'title', 'author', 'category', 'readingCount', 'bookId'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const cat = encodeURIComponent(args.category ?? 'all');
         const data = await fetchWebApi(`/bookListInCategory/${cat}`, { rank: '1' });
         const books = data?.books ?? [];

package/clis/weread/search-regression.test.js

@@ -35,7 +35,7 @@ describe('weread/search regression', () => {
         `),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        const result = await command.func({ query: 'deep work', limit: 5 });
         expect(fetchMock).toHaveBeenCalledTimes(2);
         expect(String(fetchMock.mock.calls[0][0])).toContain('keyword=deep+work');
         expect(String(fetchMock.mock.calls[1][0])).toContain('/web/search/books?keyword=deep+work');
@@ -72,7 +72,7 @@ describe('weread/search regression', () => {
             text: () => Promise.resolve('<html><body><p>no search cards</p></body></html>'),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        const result = await command.func({ query: 'deep work', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -128,7 +128,7 @@ describe('weread/search regression', () => {
         `),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: 'cal newport', limit: 5 });
+        const result = await command.func({ query: 'cal newport', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -166,7 +166,7 @@ describe('weread/search regression', () => {
         })
             .mockRejectedValueOnce(new Error('network timeout'));
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        const result = await command.func({ query: 'deep work', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -220,7 +220,7 @@ describe('weread/search regression', () => {
         `),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: '文明', limit: 5 });
+        const result = await command.func({ query: '文明', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -279,7 +279,7 @@ describe('weread/search regression', () => {
         `),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: '文明', limit: 5 });
+        const result = await command.func({ query: '文明', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -332,7 +332,7 @@ describe('weread/search regression', () => {
         `),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: '文明', limit: 5 });
+        const result = await command.func({ query: '文明', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -386,7 +386,7 @@ describe('weread/search regression', () => {
         `),
         });
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func(null, { query: '文明', limit: 5 });
+        const result = await command.func({ query: '文明', limit: 5 });
         expect(result).toEqual([
             {
                 rank: 1,

package/clis/weread/search.js

@@ -124,7 +124,7 @@ cli({
         { name: 'limit', type: 'int', default: 10, help: 'Max results' },
     ],
     columns: ['rank', 'title', 'author', 'bookId', 'url'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const [data, htmlEntries] = await Promise.all([
             fetchWebApi('/search/global', { keyword: args.query }),
             loadSearchHtmlEntries(String(args.query ?? '')),

package/clis/wikipedia/random.js

@@ -9,7 +9,7 @@ cli({
     browser: false,
     args: [{ name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' }],
     columns: ['title', 'description', 'extract', 'url'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const lang = args.lang || 'en';
         const data = (await wikiFetch(lang, '/api/rest_v1/page/random/summary'));
         if (!data?.title)

package/clis/wikipedia/search.js

@@ -13,7 +13,7 @@ cli({
         { name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' },
     ],
     columns: ['title', 'snippet', 'url'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const limit = Math.max(1, Math.min(Number(args.limit), 50));
         const lang = args.lang || 'en';
         const q = encodeURIComponent(args.query);

package/clis/wikipedia/summary.js

@@ -12,7 +12,7 @@ cli({
         { name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' },
     ],
     columns: ['title', 'description', 'extract', 'url'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const lang = args.lang || 'en';
         const title = encodeURIComponent(args.title.replace(/ /g, '_'));
         const data = (await wikiFetch(lang, `/api/rest_v1/page/summary/${title}`));

package/clis/wikipedia/trending.js

@@ -12,7 +12,7 @@ cli({
         { name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' },
     ],
     columns: ['rank', 'title', 'description', 'views'],
-    func: async (_page, args) => {
+    func: async (args) => {
         const lang = args.lang || 'en';
         const limit = Math.max(1, Math.min(Number(args.limit), 50));
         // Use yesterday's UTC date — Wikipedia API expects UTC and yesterday

package/clis/xianyu/chat.js

@@ -1,4 +1,4 @@
-import { AuthRequiredError, SelectorError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, selectorError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { normalizeNumericId } from './utils.js';
 function buildChatUrl(itemId, peerUserId) {
@@ -105,7 +105,7 @@ cli({
             throw new AuthRequiredError('www.goofish.com', 'Xianyu chat requires a logged-in browser session');
         }
         if (!state?.can_input) {
-            throw new SelectorError('闲鱼聊天输入框', '未找到可用的聊天输入框，请确认该会话页已正确加载');
+            throw selectorError('闲鱼聊天输入框', '未找到可用的聊天输入框，请确认该会话页已正确加载');
         }
         if (!text) {
             return [{
@@ -123,7 +123,7 @@ cli({
         }
         const sent = await page.evaluate(buildSendMessageEvaluate(text));
         if (!sent?.ok) {
-            throw new SelectorError('闲鱼发送按钮', `消息发送失败：${sent?.reason || 'unknown-reason'}`);
+            throw selectorError('闲鱼发送按钮', `消息发送失败：${sent?.reason || 'unknown-reason'}`);
         }
         await page.wait(1);
         return [{

package/clis/xianyu/item.js

@@ -1,4 +1,4 @@
-import { AuthRequiredError, EmptyResultError, SelectorError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, EmptyResultError, selectorError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { normalizeNumericId } from './utils.js';
 function buildItemUrl(itemId) {
@@ -127,7 +127,7 @@ cli({
             throw new EmptyResultError('xianyu item', 'Xianyu item detail is blocked by verification or risk control');
         }
         if (result?.error === 'mtop-not-ready') {
-            throw new SelectorError('window.lib.mtop', '闲鱼页面未完成初始化，无法调用商品详情接口');
+            throw selectorError('window.lib.mtop', '闲鱼页面未完成初始化，无法调用商品详情接口');
         }
         if (!result || typeof result !== 'object') {
             throw new EmptyResultError('xianyu item', '闲鱼商品详情接口未返回有效数据');

package/clis/xianyu/item.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, EmptyResultError, SelectorError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { __test__ } from './item.js';
 import './item.js';
@@ -49,8 +49,8 @@ describe('xianyu item command', () => {
         const page = createPageMock({ error: 'blocked' });
         await expect(command.func(page, { item_id: '1040754408976' })).rejects.toBeInstanceOf(EmptyResultError);
     });
-    it('keeps SelectorError for true mtop initialization failures', async () => {
+    it('keeps SELECTOR code for true mtop initialization failures', async () => {
         const page = createPageMock({ error: 'mtop-not-ready' });
-        await expect(command.func(page, { item_id: '1040754408976' })).rejects.toBeInstanceOf(SelectorError);
+        await expect(command.func(page, { item_id: '1040754408976' })).rejects.toMatchObject({ code: 'SELECTOR' });
     });
 });