@jackwener/opencli 1.7.12 → 1.7.14

package/clis/twitter/unretweet.js

@@ -0,0 +1,99 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseTweetUrl } from './shared.js';
+
+cli({
+    site: 'twitter',
+    name: 'unretweet',
+    access: 'write',
+    description: 'Undo a retweet on a specific tweet',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to unretweet' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter unretweet');
+        const target = parseTweetUrl(kwargs.url);
+        await page.goto(target.url);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        const result = await page.evaluate(`(async () => {
+        try {
+            const tweetId = ${JSON.stringify(target.id)};
+            const findTargetArticle = () => Array.from(document.querySelectorAll('article')).find((article) =>
+                Array.from(article.querySelectorAll('a[href*="/status/"]')).some((link) => {
+                    try {
+                        const match = new URL(link.href, window.location.origin).pathname.match(/^\/(?:[^/]+|i)\/status\/(\d+)\/?$/);
+                        return match?.[1] === tweetId;
+                    } catch {
+                        return false;
+                    }
+                })
+            );
+            // Poll for the tweet to render
+            let attempts = 0;
+            let retweetBtn = null;
+            let unretweetBtn = null;
+            let targetArticle = null;
+
+            while (attempts < 20) {
+                targetArticle = findTargetArticle();
+                retweetBtn = targetArticle?.querySelector('[data-testid="retweet"]') || null;
+                unretweetBtn = targetArticle?.querySelector('[data-testid="unretweet"]') || null;
+
+                if (retweetBtn || unretweetBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            // Already not retweeted: idempotent success
+            if (retweetBtn) {
+                return { ok: true, message: 'Tweet is not retweeted (already removed).' };
+            }
+
+            if (!unretweetBtn) {
+                return { ok: false, message: 'Could not find the Unretweet button on this tweet after waiting 10 seconds. Are you logged in?' };
+            }
+
+            // Step 1: click Unretweet button → opens menu
+            unretweetBtn.click();
+
+            // Step 2: wait for the confirm menu item to appear, then click it
+            let confirmBtn = null;
+            for (let i = 0; i < 20; i++) {
+                await new Promise(r => setTimeout(r, 250));
+                confirmBtn = document.querySelector('[data-testid="unretweetConfirm"]');
+                if (confirmBtn) break;
+            }
+            if (!confirmBtn) {
+                return { ok: false, message: 'Unretweet menu opened but the confirm option did not appear.' };
+            }
+            confirmBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Verify success by checking if the 'retweet' button reappeared
+            const verifyArticle = findTargetArticle() || targetArticle;
+            const verifyBtn = verifyArticle?.querySelector('[data-testid="retweet"]');
+            if (verifyBtn) {
+                return { ok: true, message: 'Tweet successfully unretweeted.' };
+            } else {
+                return { ok: false, message: 'Unretweet action was initiated but UI did not update as expected.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            // Wait for the unretweet network request to be processed
+            await page.wait(2);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});

package/clis/twitter/unretweet.test.js

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './unretweet.js';
+import { createPageMock } from '../test-utils.js';
+
+describe('twitter unretweet command', () => {
+    it('clicks the unretweet button then the confirm menu item and reports success', async () => {
+        const cmd = getRegistry().get('twitter/unretweet');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: true, message: 'Tweet successfully unretweeted.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/alice/status/2040254679301718161');
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="primaryColumn"]' });
+        expect(page.wait).toHaveBeenNthCalledWith(2, 2);
+        const script = page.evaluate.mock.calls[0][0];
+        // Two-step UI flow must be present:
+        //   1) click the unretweet button
+        //   2) wait for and click the confirm menu item (data-testid="unretweetConfirm")
+        expect(script).toContain('unretweetBtn.click()');
+        expect(script).toContain("document.querySelector('[data-testid=\"unretweetConfirm\"]')");
+        expect(script).toContain('confirmBtn.click()');
+        expect(script).toContain("document.querySelectorAll('article')");
+        expect(script).toContain('match?.[1] === tweetId');
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"unretweet\"]')");
+        // Idempotency probe: when already not retweeted ([data-testid="retweet"] present),
+        // the script returns ok:true with an "already removed" message.
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"retweet\"]')");
+        expect(result).toEqual([
+            { status: 'success', message: 'Tweet successfully unretweeted.' },
+        ]);
+    });
+
+    it('returns a failed row when the confirm menu item never appears', async () => {
+        const cmd = getRegistry().get('twitter/unretweet');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: false, message: 'Unretweet menu opened but the confirm option did not appear.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        });
+        expect(result).toEqual([
+            { status: 'failed', message: 'Unretweet menu opened but the confirm option did not appear.' },
+        ]);
+        expect(page.wait).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws CommandExecutionError when no page is provided', async () => {
+        const cmd = getRegistry().get('twitter/unretweet');
+        await expect(cmd.func(undefined, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('rejects invalid tweet URLs before navigation', async () => {
+        const cmd = getRegistry().get('twitter/unretweet');
+        const page = createPageMock([]);
+        await expect(cmd.func(page, {
+            url: 'http://x.com/alice/status/2040254679301718161',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+});

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,
+};

package/clis/uisdc/news.test.js

@@ -0,0 +1,66 @@
+import { JSDOM } from 'jsdom';
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { uisdcNewsCommand, __test__ } from './news.js';
+
+function runBrowserScript(html, script, url = 'https://www.uisdc.com/news') {
+    const dom = new JSDOM(html, { url, runScripts: 'outside-only' });
+    return dom.window.eval(script);
+}
+
+function makePage(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+
+describe('uisdc/news', () => {
+    it('registers stable URL in columns', () => {
+        expect(uisdcNewsCommand.access).toBe('read');
+        expect(uisdcNewsCommand.columns).toEqual(['rank', 'title', 'summary', 'url']);
+    });
+
+    it('validates limit before browser navigation', async () => {
+        const page = makePage({ ok: true, rows: [] });
+        await expect(uisdcNewsCommand.func(page, { limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(uisdcNewsCommand.func(page, { limit: 51 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('extracts rows from the UISDC news DOM', async () => {
+        const html = `
+          <div class="news-list">
+            <div class="news-item">
+              <div class="item-content">
+                <div class="dubao-items">
+                  <div class="dubao-item">
+                    <a href="/article-1"><span class="dubao-title"> AI design news </span></a>
+                    <div class="dubao-content"> summary text </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        `;
+        const payload = runBrowserScript(html, __test__.buildExtractUisdcNewsJs());
+        const page = makePage(payload);
+
+        const rows = await uisdcNewsCommand.func(page, { limit: 10 });
+
+        expect(page.goto).toHaveBeenCalledWith('https://www.uisdc.com/news', { waitUntil: 'load', settleMs: 3000 });
+        expect(rows).toEqual([{
+            rank: 1,
+            title: 'AI design news',
+            summary: 'summary text',
+            url: 'https://www.uisdc.com/article-1',
+        }]);
+    });
+
+    it('maps selector drift and empty rows to typed errors', async () => {
+        await expect(uisdcNewsCommand.func(makePage({ ok: false, reason: 'selector-missing' }), { limit: 1 }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(uisdcNewsCommand.func(makePage({ ok: true, rows: [{ title: '', url: '' }] }), { limit: 1 }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+});

package/clis/wanfang/search.js

@@ -14,7 +14,6 @@ cli({
         { name: 'limit', type: 'int', default: 10, help: '返回结果数量 (max 20)' },
     ],
     columns: ['rank', 'title', 'authors', 'source', 'year', 'type', 'cited', 'url'],
-    navigateBefore: false,
     func: async (page, kwargs) => {
         const limit = clampInt(kwargs.limit, 10, 1, 20);
         const query = requireNonEmptyQuery(kwargs.query);

package/clis/web/read.js

@@ -18,6 +18,7 @@ import { downloadArticle } from '@jackwener/opencli/download/article-download';
 
 const NETWORK_IDLE_QUIET_MS = 1000;
 const NETWORK_IDLE_POLL_MS = 500;
+const MIN_NON_STRUCTURAL_IFRAME_TEXT_CHARS = 50;
 
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -31,7 +32,7 @@ function boolish(value) {
 
 function normalizeFrameMode(value) {
     const mode = String(value || 'same-origin').toLowerCase();
-    if (['same-origin', 'none'].includes(mode)) return mode;
+    if (['same-origin', 'all-same-origin', 'none'].includes(mode)) return mode;
     return 'same-origin';
 }
 
@@ -144,6 +145,7 @@ function buildRenderAwareExtractorJs(options) {
     return `
       (() => {
         const frameMode = ${JSON.stringify(options.frames)};
+        const minNonStructuralIframeTextChars = ${MIN_NON_STRUCTURAL_IFRAME_TEXT_CHARS};
         const result = {
           title: '',
           author: '',
@@ -188,6 +190,7 @@ function buildRenderAwareExtractorJs(options) {
         const collectEmptyContainers = (root, scope, baseUrl) => {
           const likely = 'table, tbody, ul[id], ol[id], div[id], section[id], [class*="grid"], [class*="data"], [class*="list"], [id*="grid"], [id*="data"], [id*="list"]';
           root.querySelectorAll?.(likely).forEach((el) => {
+            if (scope === 'main' && el.closest?.('[data-opencli-iframe-source]')) return;
             const id = el.getAttribute('id') || '';
             const cls = el.getAttribute('class') || '';
             const name = [id, cls].join(' ').toLowerCase();
@@ -202,6 +205,29 @@ function buildRenderAwareExtractorJs(options) {
             });
           });
         };
+        const hasDataContainerSignal = (root) => {
+          const likely = 'table, tbody, ul[id], ol[id], [id*="grid"], [id*="data"], [id*="list"], [id*="content"], [id*="result"], [class*="grid"], [class*="data"], [class*="list"], [class*="content"], [class*="result"]';
+          return !!root.querySelector?.(likely);
+        };
+        const shouldIncludeExternalFrame = (frameBody) => {
+          // Outside-content iframes are less trusted than placeholders inside
+          // contentEl. Long plain text is the fallback for simple same-origin
+          // frames that lack article/table/list structure.
+          if (textLen(frameBody) >= minNonStructuralIframeTextChars) return true;
+          if (frameBody.querySelector?.('article, main, [role="main"], table, tbody, ul li, ol li')) return true;
+          return hasDataContainerSignal(frameBody);
+        };
+        const buildFrameSection = (frameBody, desc, fallbackLabel) => {
+          absolutizeTree(frameBody, desc.src || window.location.href);
+          collectEmptyContainers(frameBody, 'iframe', desc.src);
+          const section = document.createElement('section');
+          section.setAttribute('data-opencli-iframe-source', desc.src);
+          const heading = document.createElement('h2');
+          heading.textContent = '来自 iframe: ' + (desc.src || fallbackLabel);
+          section.appendChild(heading);
+          Array.from(frameBody.childNodes).forEach(node => section.appendChild(node));
+          return section;
+        };
 
         const ogTitle = document.querySelector('meta[property="og:title"]');
         if (ogTitle) result.title = ogTitle.getAttribute('content')?.trim() || '';
@@ -252,28 +278,32 @@ function buildRenderAwareExtractorJs(options) {
 
         const originalFrames = Array.from(contentEl.querySelectorAll('iframe'));
         const clonedFrames = Array.from(clone.querySelectorAll('iframe'));
+        const clonedFrameByOriginal = new Map();
+        originalFrames.forEach((frame, index) => {
+          const cloned = clonedFrames[index];
+          if (cloned) clonedFrameByOriginal.set(frame, cloned);
+        });
         const allFrames = Array.from(document.querySelectorAll('iframe'));
-        result.diagnostics.frames = allFrames.map(describeFrame);
+        const frameDescriptions = new Map();
+        allFrames.forEach((frame, index) => frameDescriptions.set(frame, describeFrame(frame, index)));
+        const getFrameDescription = (frame, fallbackIndex) => frameDescriptions.get(frame) || describeFrame(frame, fallbackIndex);
+        result.diagnostics.frames = allFrames.map(frame => frameDescriptions.get(frame));
 
-        if (frameMode === 'same-origin') {
-          originalFrames.forEach((frame, index) => {
-            const cloned = clonedFrames[index];
-            if (!cloned) return;
-            const desc = describeFrame(frame, index);
+        if (frameMode === 'same-origin' || frameMode === 'all-same-origin') {
+          allFrames.forEach((frame, index) => {
+            const insideContent = contentEl.contains(frame);
+            const cloned = insideContent ? clonedFrameByOriginal.get(frame) : null;
+            if (insideContent && !cloned) return;
+            const desc = getFrameDescription(frame, index);
             if (!desc.sameOrigin || !desc.accessible) return;
             try {
               const doc = frame.contentDocument;
               if (!doc?.body) return;
               const frameBody = doc.body.cloneNode(true);
-              absolutizeTree(frameBody, desc.src || window.location.href);
-              collectEmptyContainers(frameBody, 'iframe', desc.src);
-              const section = document.createElement('section');
-              section.setAttribute('data-opencli-iframe-source', desc.src);
-              const heading = document.createElement('h2');
-              heading.textContent = '来自 iframe: ' + (desc.src || frame.getAttribute('src') || ('#' + index));
-              section.appendChild(heading);
-              Array.from(frameBody.childNodes).forEach(node => section.appendChild(node));
-              cloned.replaceWith(section);
+              if (frameMode !== 'all-same-origin' && !insideContent && !shouldIncludeExternalFrame(frameBody)) return;
+              const section = buildFrameSection(frameBody, desc, frame.getAttribute('src') || ('#' + index));
+              if (insideContent) cloned.replaceWith(section);
+              else clone.appendChild(section);
               result.diagnostics.includedFrameCount += 1;
             } catch {}
           });
@@ -376,7 +406,7 @@ const command = cli({
         { name: 'wait', type: 'int', default: 3, help: 'Seconds to wait after page load' },
         { name: 'wait-for', valueRequired: true, help: 'CSS selector to wait for in the main document or same-origin iframes' },
         { name: 'wait-until', default: 'domstable', choices: ['domstable', 'networkidle'], help: 'Readiness policy after navigation: domstable or networkidle' },
-        { name: 'frames', default: 'same-origin', choices: ['same-origin', 'none'], help: 'Iframe handling mode: same-origin or none' },
+        { name: 'frames', default: 'same-origin', choices: ['same-origin', 'all-same-origin', 'none'], help: 'Iframe handling mode: relevant same-origin, all-same-origin, or none' },
         { name: 'diagnose', type: 'boolean', default: false, help: 'Print render diagnostics (frames, empty containers, XHR/API-like requests) to stderr' },
         { name: 'stdout', type: 'boolean', default: false, help: 'Print markdown to stdout instead of saving to a file' },
     ],

package/clis/web/read.test.js

@@ -165,6 +165,18 @@ describe('web/read stdout behavior', () => {
         expect(page.evaluate.mock.calls[0]?.[0]).toContain('const frameMode = "none"');
     });
 
+    it('passes --frames all-same-origin into the extractor', async () => {
+        await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            frames: 'all-same-origin',
+            stdout: false,
+        });
+
+        expect(page.evaluate.mock.calls[0]?.[0]).toContain('const frameMode = "all-same-origin"');
+    });
+
     it('fails fast when --wait-until networkidle is requested but capture is unavailable', async () => {
         page.startNetworkCapture.mockResolvedValue(false);
 
@@ -217,7 +229,7 @@ describe('web/read render-aware helpers', () => {
         `, { url: 'https://example.com/main.html', runScripts: 'outside-only' });
         const frame = dom.window.document.querySelector('iframe');
         frame.contentDocument.open();
-        frame.contentDocument.write('<body><table id="gridHd"><tr><th>Name</th></tr></table><ul id="gridDatas"><li>Station A 42</li></ul></body>');
+        frame.contentDocument.write('<body><table id="gridHd"><tr><th>Name</th></tr></table><ul id="gridDatas"></ul><p>Station A 42</p></body>');
         frame.contentDocument.close();
 
         const result = dom.window.eval(__test__.buildRenderAwareExtractorJs({ frames: 'same-origin' }));
@@ -226,6 +238,94 @@ describe('web/read render-aware helpers', () => {
         expect(result.contentHtml).toContain('data-opencli-iframe-source="https://example.com/frame.html"');
         expect(result.contentHtml).toContain('来自 iframe: https://example.com/frame.html');
         expect(result.contentHtml).toContain('Station A 42');
+        expect(result.diagnostics.emptyContainers).toEqual(expect.arrayContaining([
+            expect.objectContaining({ scope: 'iframe', id: 'gridDatas', url: 'https://example.com/frame.html' }),
+        ]));
+        expect(result.diagnostics.emptyContainers.every(item => item.scope === 'iframe')).toBe(true);
+    });
+
+    it('merges readable same-origin iframes outside the selected content element', () => {
+        const dom = new JSDOM(`
+          <main>
+            <h1>Main Article</h1>
+            <p>${'Main content '.repeat(30)}</p>
+          </main>
+          <aside>
+            <iframe id="outside" src="/outside.html"></iframe>
+          </aside>
+        `, { url: 'https://example.com/main.html', runScripts: 'outside-only' });
+        const frame = dom.window.document.querySelector('iframe');
+        frame.contentDocument.open();
+        frame.contentDocument.write(`<body><h1>Outside Frame</h1><p>${'Frame data '.repeat(12)}</p></body>`);
+        frame.contentDocument.close();
+
+        const result = dom.window.eval(__test__.buildRenderAwareExtractorJs({ frames: 'same-origin' }));
+
+        expect(result.diagnostics.includedFrameCount).toBe(1);
+        expect(result.contentHtml).toContain('data-opencli-iframe-source="https://example.com/outside.html"');
+        expect(result.contentHtml).toContain('Outside Frame');
+        expect(result.contentHtml).toContain('Frame data');
+    });
+
+    it('keeps short data-like iframes outside the selected content element', () => {
+        const dom = new JSDOM(`
+          <main>
+            <h1>Main Article</h1>
+            <p>${'Main content '.repeat(30)}</p>
+          </main>
+          <iframe id="data-frame" src="/data.html"></iframe>
+        `, { url: 'https://example.com/main.html', runScripts: 'outside-only' });
+        const frame = dom.window.document.querySelector('iframe');
+        frame.contentDocument.open();
+        frame.contentDocument.write('<body><table id="gridHd"><tr><th>水位</th></tr><tr><td>42</td></tr></table><ul id="gridDatas"></ul></body>');
+        frame.contentDocument.close();
+
+        const result = dom.window.eval(__test__.buildRenderAwareExtractorJs({ frames: 'same-origin' }));
+
+        expect(result.diagnostics.includedFrameCount).toBe(1);
+        expect(result.contentHtml).toContain('42');
+        expect(result.diagnostics.emptyContainers).toEqual(expect.arrayContaining([
+            expect.objectContaining({ scope: 'iframe', id: 'gridDatas', url: 'https://example.com/data.html' }),
+        ]));
+        expect(result.diagnostics.emptyContainers.every(item => item.scope === 'iframe')).toBe(true);
+    });
+
+    it('skips short non-structural iframes outside the selected content element', () => {
+        const dom = new JSDOM(`
+          <main>
+            <h1>Main Article</h1>
+            <p>${'Main content '.repeat(30)}</p>
+          </main>
+          <iframe id="tiny-frame" src="/tiny.html"></iframe>
+        `, { url: 'https://example.com/main.html', runScripts: 'outside-only' });
+        const frame = dom.window.document.querySelector('iframe');
+        frame.contentDocument.open();
+        frame.contentDocument.write('<body><p>tiny note</p></body>');
+        frame.contentDocument.close();
+
+        const result = dom.window.eval(__test__.buildRenderAwareExtractorJs({ frames: 'same-origin' }));
+
+        expect(result.diagnostics.includedFrameCount).toBe(0);
+        expect(result.contentHtml).not.toContain('tiny note');
+    });
+
+    it('includes short non-structural iframes in all-same-origin mode', () => {
+        const dom = new JSDOM(`
+          <main>
+            <h1>Main Article</h1>
+            <p>${'Main content '.repeat(30)}</p>
+          </main>
+          <iframe id="status-frame" src="/status.html"></iframe>
+        `, { url: 'https://example.com/main.html', runScripts: 'outside-only' });
+        const frame = dom.window.document.querySelector('iframe');
+        frame.contentDocument.open();
+        frame.contentDocument.write('<body><div>Online: 42°C</div></body>');
+        frame.contentDocument.close();
+
+        const result = dom.window.eval(__test__.buildRenderAwareExtractorJs({ frames: 'all-same-origin' }));
+
+        expect(result.diagnostics.includedFrameCount).toBe(1);
+        expect(result.contentHtml).toContain('Online: 42°C');
     });
 
     it('marks API-like network entries as interesting and ignores static assets', () => {

package/clis/weixin/create-draft.js

@@ -179,13 +179,13 @@ export const createDraftCommand = cli({
     strategy: Strategy.COOKIE,
     browser: true,
     navigateBefore: false,
-    timeoutSeconds: 180,
     args: [
         { name: 'title', required: true, help: '文章标题 (最长64字)' },
         { name: 'content', required: true, positional: true, help: '文章正文' },
         { name: 'author', help: '作者名 (最长8字)' },
         { name: 'cover-image', help: '封面图片路径 (会先上传到正文再设为封面)' },
         { name: 'summary', help: '文章摘要' },
+        { name: 'timeout', type: 'int', required: false, default: 180, help: 'Max seconds for the overall command (default: 180)' },
     ],
     columns: ['status', 'detail'],
 

package/clis/weixin/drafts.js

@@ -12,9 +12,9 @@ export const draftsCommand = cli({
     strategy: Strategy.COOKIE,
     browser: true,
     navigateBefore: false,
-    timeoutSeconds: 60,
     args: [
         { name: 'limit', type: 'int', default: 10, help: '最多显示条数' },
+        { name: 'timeout', type: 'int', required: false, default: 60, help: 'Max seconds for the overall command (default: 60)' },
     ],
     columns: ['Index', 'Title', 'Time'],
 

package/clis/weixin/drafts.test.js

@@ -3,6 +3,7 @@ import { AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
 import { getRegistry } from '@jackwener/opencli/registry';
 import './create-draft.js';
 import './drafts.js';
+import './search.js';
 
 function createPageMock(overrides = {}) {
     return {
@@ -18,7 +19,10 @@ describe('weixin command registration', () => {
         const registry = getRegistry();
         const values = [...registry.values()];
         expect(values.find(c => c.site === 'weixin' && c.name === 'create-draft')).toBeDefined();
-        expect(values.find(c => c.site === 'weixin' && c.name === 'drafts')).toBeDefined();
+        const draftsCommand = values.find(c => c.site === 'weixin' && c.name === 'drafts');
+        expect(draftsCommand).toBeDefined();
+        expect(draftsCommand.args.find((arg) => arg.name === 'timeout')).toMatchObject({ type: 'int', default: 60 });
+        expect(values.find(c => c.site === 'weixin' && c.name === 'search')).toBeDefined();
     });
 });