@jackwener/opencli 1.7.12 → 1.7.13

package/clis/tvmaze/tvmaze.test.js

@@ -0,0 +1,93 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './show.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('tvmaze search adapter', () => {
+    const cmd = getRegistry().get('tvmaze/search');
+
+    it('rejects empty query and bad limit before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ query: '', limit: 5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 100 })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        await expect(cmd.func({ query: 'foo', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when no shows match', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('[]', { status: 200 })));
+        await expect(cmd.func({ query: 'asdfghjkl', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('strips HTML from summary and ids round-trip into tvmaze show <id>', async () => {
+        const list = [{
+            score: 1.2,
+            show: {
+                id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English',
+                genres: ['Drama'], status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11',
+                network: { name: 'AMC' }, rating: { average: 9.2 },
+                summary: '<p><b>Breaking Bad</b> is a show with &amp; entities &#39;here&#39;, &#x27;hex&#x27;, and &hellip;.</p>',
+                url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+            },
+        }];
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(list), { status: 200 })));
+
+        const rows = await cmd.func({ query: 'breaking bad', limit: 5 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, id: 169, name: 'Breaking Bad', network: 'AMC', rating: 9.2, matchScore: 1.2,
+        });
+        expect(rows[0].summary).toBe("Breaking Bad is a show with & entities 'here', 'hex', and ….");
+        // id round-trip
+        expect(typeof rows[0].id).toBe('number');
+    });
+});
+
+describe('tvmaze show adapter', () => {
+    const cmd = getRegistry().get('tvmaze/show');
+
+    it('rejects non-positive id before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: -5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'abc' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 404 to EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
+        await expect(cmd.func({ id: 99999999 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('returns full show detail with externals + schedule', async () => {
+        const show = {
+            id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English', genres: ['Drama'],
+            status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11', runtime: 60, averageRuntime: 60,
+            network: { name: 'AMC', country: { name: 'United States' } }, schedule: { time: '22:00', days: ['Sunday'] },
+            rating: { average: 9.2 }, externals: { imdb: 'tt0903747', thetvdb: 81189 },
+            officialSite: 'http://www.amc.com/shows/breaking-bad',
+            summary: '<p>Plain.</p>', url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(show), { status: 200 })));
+
+        const rows = await cmd.func({ id: 169 });
+        expect(rows[0]).toMatchObject({
+            id: 169, name: 'Breaking Bad', country: 'United States', schedule: 'Sunday 22:00',
+            imdb: 'tt0903747', thetvdb: 81189, rating: 9.2, summary: 'Plain.',
+        });
+    });
+});

package/clis/tvmaze/utils.js

@@ -0,0 +1,110 @@
+// Shared helpers for the TVmaze adapters.
+//
+// TVmaze publishes a free, unauthenticated REST API at https://api.tvmaze.com.
+// Docs: https://www.tvmaze.com/api
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const TVMAZE_BASE = 'https://api.tvmaze.com';
+const UA = 'opencli-tvmaze-adapter (+https://github.com/jackwener/opencli)';
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`tvmaze ${label} cannot be empty`);
+    return s;
+}
+
+export function requireShowId(value) {
+    const raw = value;
+    const n = typeof raw === 'number' ? raw : Number(String(raw ?? '').trim());
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(
+            'tvmaze show id is required and must be a positive integer',
+            'TVmaze show ids appear in the URL: https://www.tvmaze.com/shows/<id>/<slug>.',
+        );
+    }
+    return n;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`tvmaze ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`tvmaze ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function tvmazeFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.tvmaze.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `TVmaze returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'TVmaze caps unauthenticated traffic at ~20 req/10s; wait a few seconds and retry.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+const HTML_ENTITY_MAP = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+    rsquo: '’',
+    lsquo: '‘',
+    rdquo: '”',
+    ldquo: '“',
+    hellip: '…',
+    ndash: '–',
+    mdash: '—',
+};
+
+// TVmaze ships HTML in `summary` ("<p><b>...</b> ...</p>"). Strip tags + decode
+// named and numeric entities so output is plain text.
+export function stripHtml(html) {
+    if (html == null) return '';
+    let s = String(html);
+    s = s.replace(/<[^>]+>/g, '');
+    s = s
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => {
+            const code = parseInt(hex, 16);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&#(\d+);/g, (_, dec) => {
+            const code = parseInt(dec, 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&([a-zA-Z]+);/g, (match, name) => HTML_ENTITY_MAP[name] ?? match);
+    return s.replace(/\s+/g, ' ').trim();
+}
+
+export function joinList(value) {
+    return Array.isArray(value) ? value.filter(Boolean).join(', ') : '';
+}

package/clis/twitter/accept.js

@@ -8,10 +8,10 @@ cli({
     domain: 'x.com',
     strategy: Strategy.UI,
     browser: true,
-    timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
     args: [
         { name: 'query', type: 'string', required: true, positional: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
         { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+        { name: 'timeout', type: 'int', required: false, default: 600, help: 'Max seconds for the overall command (default: 600 — batch op)' },
     ],
     columns: ['index', 'status', 'user', 'message'],
     func: async (page, kwargs) => {

package/clis/twitter/followers.js

@@ -1,103 +1,168 @@
-import { AuthRequiredError, selectorError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, selectorError, EmptyResultError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
+
+/**
+ * Extract follower rows from Twitter/X follower-list SPA cells.
+ *
+ * Verified DOM shape on x.com followers list (confirmed live 2026-05-05):
+ *   - `[data-testid="UserCell"]` per follower
+ *     - `[data-testid="UserAvatar-Container-<handle>"]` — stable handle source
+ *     - `[data-testid="<userId>-follow"]` — follow button (i18n-independent)
+ *     - `[data-testid="userFollowIndicator"]` — "Follows you" badge when present
+ *     - the bio (when present) is rendered into `cell.innerText` but has NO
+ *       dedicated testid in the list view (`UserDescription` only appears on
+ *       the standalone profile page, NOT inside follower-list cells).
+ *
+ * Strategy: subtract the i18n-variable button / badge texts from the lines of
+ * `cell.innerText`, treat the first remaining `@…` line as the handle, the
+ * first non-handle line as display name, and the rest as bio. We avoid
+ * locale-coupled string matching (`"Follow"` / `"关注"` / `"Folgen"`).
+ *
+ * Note: Twitter does NOT render follower COUNTS in the list view, so the
+ * `followers` column is omitted from the output schema. Use
+ * `opencli twitter profile <user>` to read a per-user follower count.
+ */
+async function extractFollowersFromDOM(page) {
+    const script = `() => {
+        const cells = document.querySelectorAll('[data-testid="UserCell"]');
+        const out = [];
+        for (const cell of cells) {
+            // Collect i18n-variable UI strings to strip from the cell text.
+            const stripTexts = new Set();
+            const buttons = cell.querySelectorAll(
+                '[data-testid$="-follow"],[data-testid$="-unfollow"],[data-testid="userFollowIndicator"]'
+            );
+            for (const el of buttons) {
+                const t = (el.innerText || '').trim();
+                if (t) stripTexts.add(t);
+            }
+            const lines = (cell.innerText || '')
+                .split('\\n')
+                .map(s => s.trim())
+                .filter(Boolean)
+                .filter(l => !stripTexts.has(l));
+            // Pull the @handle line; fall back to UserAvatar-Container-<handle>.
+            let screen_name = '';
+            const remaining = [];
+            for (const l of lines) {
+                if (!screen_name && l.startsWith('@')) {
+                    screen_name = l.slice(1).split(/\\s/)[0];
+                } else {
+                    remaining.push(l);
+                }
+            }
+            if (!screen_name) {
+                const av = cell.querySelector('[data-testid^="UserAvatar-Container-"]');
+                const tid = av ? av.getAttribute('data-testid') || '' : '';
+                if (tid.startsWith('UserAvatar-Container-')) {
+                    screen_name = tid.slice('UserAvatar-Container-'.length);
+                }
+            }
+            // First non-handle line is display name (may equal handle when the user hasn't set one).
+            const name = remaining[0] || screen_name;
+            // Lines past the display name form the bio.
+            const bio = remaining.slice(1).join(' ').replace(/\\s+/g, ' ').trim();
+            if (screen_name) {
+                out.push({ screen_name, name, bio });
+            }
+        }
+        return out;
+    }`;
+    return page.evaluate(script);
+}
+
+function normalizeScreenName(value) {
+    return String(value ?? '').trim().replace(/^\/+/, '').replace(/^@+/, '');
+}
+
 cli({
     site: 'twitter',
     name: 'followers',
     access: 'read',
     description: 'Get accounts following a Twitter/X user',
     domain: 'x.com',
-    strategy: Strategy.INTERCEPT,
+    strategy: Strategy.UI,
     browser: true,
     args: [
         { name: 'user', positional: true, type: 'string', required: false },
         { name: 'limit', type: 'int', default: 50 },
     ],
-    columns: ['screen_name', 'name', 'bio', 'followers'],
+    // `followers` (count) is NOT exposed: the SPA followers-list view does not
+    // render it. Use `twitter profile <user>` for per-user follower counts.
+    columns: ['screen_name', 'name', 'bio'],
     func: async (page, kwargs) => {
-        let targetUser = kwargs.user;
-        // If no user is specified, figure out the logged-in user's handle
+        const limit = kwargs.limit;
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new ArgumentError('limit must be a positive integer');
+        }
+
+        let targetUser = normalizeScreenName(kwargs.user);
         if (!targetUser) {
             await page.goto('https://x.com/home');
             await page.wait({ selector: '[data-testid="primaryColumn"]' });
             const href = await page.evaluate(`() => {
-            const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
-            return link ? link.getAttribute('href') : null;
-        }`);
+                const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
+                return link ? link.getAttribute('href') : null;
+            }`);
             if (!href) {
                 throw new AuthRequiredError('x.com', 'Could not find logged-in user profile link. Are you logged in?');
             }
-            targetUser = href.replace('/', '');
+            targetUser = normalizeScreenName(href);
         }
+        if (!targetUser) {
+            throw new ArgumentError('twitter followers user cannot be empty', 'Example: opencli twitter followers @elonmusk --limit 100');
+        }
+
         // 1. Navigate to profile page
         await page.goto(`https://x.com/${targetUser}`);
         await page.wait(3);
-        // 2. Install interceptor BEFORE SPA navigation.
-        //    goto() resets JS context, but SPA click preserves it.
-        await page.installInterceptor('Followers');
-        // 3. Click the followers link via SPA navigation (preserves interceptor).
-        //    Twitter uses /verified_followers instead of /followers now.
+
+        // 2. Click the followers tab via SPA navigation (preserves session/state).
+        //    Twitter sometimes only renders /verified_followers on profiles with
+        //    badge filtering enabled; try the canonical link first, fall back.
         const safeUser = JSON.stringify(targetUser);
         const clicked = await page.evaluate(`() => {
-        const target = ${safeUser};
-        const selectors = [
-            'a[href="/' + target + '/verified_followers"]',
-            'a[href="/' + target + '/followers"]',
-        ];
-        for (const sel of selectors) {
-            const link = document.querySelector(sel);
-            if (link) { link.click(); return true; }
-        }
-        return false;
-    }`);
+            const target = ${safeUser};
+            const selectors = [
+                'a[href="/' + target + '/followers"]',
+                'a[href="/' + target + '/verified_followers"]',
+            ];
+            for (const sel of selectors) {
+                const link = document.querySelector(sel);
+                if (link) { link.click(); return true; }
+            }
+            return false;
+        }`);
         if (!clicked) {
             throw selectorError('Twitter followers link', 'Twitter may have changed the layout.');
         }
-        await page.waitForCapture(5);
-        // 4. Scroll to trigger pagination API calls
-        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
-        // 5. Retrieve intercepted data
-        const requests = await page.getInterceptedRequests();
-        const requestList = Array.isArray(requests) ? requests : [];
-        if (requestList.length === 0) {
-            return [];
-        }
-        let results = [];
-        for (const req of requestList) {
-            try {
-                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
-                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
-                if (!instructions)
-                    continue;
-                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
-                if (!addEntries) {
-                    addEntries = instructions.find((i) => i.entries && Array.isArray(i.entries));
-                }
-                if (!addEntries)
-                    continue;
-                for (const entry of addEntries.entries) {
-                    if (!entry.entryId.startsWith('user-'))
-                        continue;
-                    const item = entry.content?.itemContent?.user_results?.result;
-                    if (!item || item.__typename !== 'User')
-                        continue;
-                    const core = item.core || {};
-                    const legacy = item.legacy || {};
-                    results.push({
-                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
-                        name: core.name || legacy.name || 'unknown',
-                        bio: legacy.description || item.profile_bio?.description || '',
-                        followers: legacy.followers_count || legacy.normal_followers_count || 0
-                    });
-                }
+
+        // 3. Wait for follower cells to appear
+        await page.wait({ selector: '[data-testid="UserCell"]', timeout: 10000 });
+
+        // 4. Extract from DOM, scroll to load more, dedupe by screen_name
+        const allFollowers = [];
+        const seen = new Set();
+        let sameCount = 0;
+        while (allFollowers.length < limit && sameCount < 3) {
+            const followers = await extractFollowersFromDOM(page);
+            const newFollowers = followers.filter(f => !seen.has(f.screen_name));
+            for (const f of newFollowers) {
+                seen.add(f.screen_name);
+                allFollowers.push(f);
             }
-            catch (e) {
-                // ignore parsing errors for individual payloads
+            if (newFollowers.length === 0) {
+                sameCount++;
+            } else {
+                sameCount = 0;
             }
+            if (allFollowers.length >= limit) break;
+            await page.autoScroll({ times: 1, delayMs: 500 });
+            await page.wait(2);
+        }
+        if (allFollowers.length === 0) {
+            throw new EmptyResultError('twitter followers', `No followers found for @${targetUser}`);
         }
-        // Deduplicate by screen_name
-        const unique = new Map();
-        results.forEach(r => unique.set(r.screen_name, r));
-        const deduplicatedResults = Array.from(unique.values());
-        return deduplicatedResults.slice(0, kwargs.limit);
+        return allFollowers.slice(0, limit);
     }
 });

package/clis/twitter/reply-dm.js

@@ -8,11 +8,11 @@ cli({
     domain: 'x.com',
     strategy: Strategy.UI,
     browser: true,
-    timeoutSeconds: 600, // 10 min — batch operation
     args: [
         { name: 'text', type: 'string', required: true, positional: true, help: 'Message text to send (e.g. "我的微信 wxkabi")' },
         { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of conversations to reply to (default: 20)' },
         { name: 'skip-replied', type: 'boolean', required: false, default: true, help: 'Skip conversations where you already sent the same text (default: true)' },
+        { name: 'timeout', type: 'int', required: false, default: 600, help: 'Max seconds for the overall command (default: 600 — batch op)' },
     ],
     columns: ['index', 'status', 'user', 'message'],
     func: async (page, kwargs) => {

package/clis/twitter/reply.test.js

@@ -4,35 +4,7 @@ import * as path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { __test__ } from './reply.js';
-function createPageMock(evaluateResults, overrides = {}) {
-    const evaluate = vi.fn();
-    for (const result of evaluateResults) {
-        evaluate.mockResolvedValueOnce(result);
-    }
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate,
-        snapshot: vi.fn().mockResolvedValue(undefined),
-        click: vi.fn().mockResolvedValue(undefined),
-        typeText: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-        scrollTo: vi.fn().mockResolvedValue(undefined),
-        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
-        wait: vi.fn().mockResolvedValue(undefined),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn().mockResolvedValue(undefined),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue([]),
-        scroll: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        installInterceptor: vi.fn().mockResolvedValue(undefined),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        getCookies: vi.fn().mockResolvedValue([]),
-        screenshot: vi.fn().mockResolvedValue(''),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        ...overrides,
-    };
-}
+import { createPageMock } from '../test-utils.js';
 describe('twitter reply command', () => {
     it('uses the dedicated reply composer for text-only replies too', async () => {
         const cmd = getRegistry().get('twitter/reply');

package/clis/uisdc/news.js

@@ -0,0 +1,105 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError, getErrorMessage } from '@jackwener/opencli/errors';
+
+const UISDC_NEWS_URL = 'https://www.uisdc.com/news';
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 50;
+
+function normalizeLimit(value) {
+    const raw = value ?? DEFAULT_LIMIT;
+    const limit = Number(raw);
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new ArgumentError('limit must be a positive integer', `Example: opencli uisdc news --limit ${DEFAULT_LIMIT}`);
+    }
+    if (limit > MAX_LIMIT) {
+        throw new ArgumentError(`limit must be <= ${MAX_LIMIT}`, `Example: opencli uisdc news --limit ${MAX_LIMIT}`);
+    }
+    return limit;
+}
+
+function normalizeText(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function buildExtractUisdcNewsJs() {
+    return `
+      (() => {
+        const cards = Array.from(document.querySelectorAll(
+          '.news-list > .news-item:first-child > .item-content > .dubao-items > .dubao-item'
+        ));
+        if (cards.length === 0) {
+          return {
+            ok: false,
+            reason: 'selector-missing',
+            title: document.title || '',
+            bodyText: (document.body?.innerText || document.body?.textContent || '').slice(0, 500),
+          };
+        }
+        const rows = cards.map((el, index) => {
+          const anchor = el.querySelector('a[href]');
+          return {
+            rank: index + 1,
+            title: el.querySelector('.dubao-title')?.textContent || '',
+            summary: el.querySelector('.dubao-content')?.textContent || '',
+            url: anchor ? new URL(anchor.getAttribute('href'), location.href).href : '',
+          };
+        });
+        return { ok: true, rows };
+      })()
+    `;
+}
+
+function toRows(payload, limit) {
+    if (!payload || typeof payload !== 'object') {
+        throw new CommandExecutionError('UISDC news page returned an unreadable payload');
+    }
+    if (!payload.ok) {
+        const reason = typeof payload.reason === 'string' && payload.reason.trim() ? payload.reason.trim() : 'selector-drift';
+        throw new CommandExecutionError(
+            `UISDC news selector drift: ${reason}`,
+            payload.title ? `Page title: ${payload.title}` : undefined,
+        );
+    }
+    const rows = (Array.isArray(payload.rows) ? payload.rows : [])
+        .map((row, index) => ({
+            rank: index + 1,
+            title: normalizeText(row.title),
+            summary: normalizeText(row.summary),
+            url: normalizeText(row.url),
+        }))
+        .filter((row) => row.title && row.url);
+    if (rows.length === 0) {
+        throw new EmptyResultError('uisdc news', 'UISDC news page loaded, but no news rows with title and URL were extracted.');
+    }
+    return rows.slice(0, limit).map((row, index) => ({ ...row, rank: index + 1 }));
+}
+
+async function loadUisdcNews(page, args) {
+    const limit = normalizeLimit(args.limit);
+    await page.goto(UISDC_NEWS_URL, { waitUntil: 'load', settleMs: 3000 });
+    const payload = await page.evaluate(buildExtractUisdcNewsJs()).catch((error) => {
+        throw new CommandExecutionError(`Failed to extract UISDC news: ${getErrorMessage(error)}`);
+    });
+    return toRows(payload, limit);
+}
+
+export const uisdcNewsCommand = cli({
+    site: 'uisdc',
+    name: 'news',
+    access: 'read',
+    description: '优设读报 - 最新 AI/设计行业新闻',
+    domain: 'www.uisdc.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: DEFAULT_LIMIT, help: `Number of news items to return (max ${MAX_LIMIT})` },
+    ],
+    columns: ['rank', 'title', 'summary', 'url'],
+    func: loadUisdcNews,
+});
+
+export const __test__ = {
+    buildExtractUisdcNewsJs,
+    normalizeLimit,
+    toRows,
+};