@jackwener/opencli 1.7.12 → 1.7.13

package/clis/xianyu/publish.test.js

@@ -0,0 +1,220 @@
+import { JSDOM } from 'jsdom';
+import { describe, it, expect, vi } from 'vitest';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+vi.mock('node:fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        statSync: vi.fn((input) => {
+            const value = String(input);
+            if (value.includes('missing')) return undefined;
+            return { isFile: () => !value.includes('directory') };
+        }),
+    };
+});
+
+vi.mock('node:path', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        resolve: vi.fn((input) => `/abs/${input}`),
+        extname: vi.fn((input) => {
+            const match = String(input).match(/\.[^.]+$/);
+            return match ? match[0] : '';
+        }),
+    };
+});
+
+import { __test__, publishCommand } from './publish.js';
+
+function makePage({ evaluateResults = [], overrides = {} } = {}) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    evaluate.mockResolvedValue({ ok: false, reason: 'unknown-state' });
+
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        getCurrentUrl: vi.fn().mockResolvedValue('https://www.goofish.com/publish'),
+        ...overrides,
+    };
+}
+
+async function runBrowserScript(html, script, { url = 'https://www.goofish.com/publish' } = {}) {
+    const dom = new JSDOM(html, { url, runScripts: 'outside-only' });
+    return dom.window.eval(script);
+}
+
+const validArgs = {
+    title: 'MacBook Pro',
+    description: '成色很好，功能正常',
+    price: '5999.99',
+    condition: '轻微使用',
+    category: '笔记本',
+};
+
+describe('xianyu/publish', () => {
+    it('builds the goofish publish URL', () => {
+        expect(__test__.buildPublishUrl()).toBe('https://www.goofish.com/publish');
+    });
+
+    it('validates publish arguments before navigation', async () => {
+        const page = makePage();
+
+        await expect(publishCommand.func(page, { ...validArgs, title: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(publishCommand.func(page, { ...validArgs, price: '0' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(publishCommand.func(page, { ...validArgs, price: '12.345' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(publishCommand.func(page, { ...validArgs, condition: '八成新' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(publishCommand.func(page, { ...validArgs, images: 'a.bmp' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(publishCommand.func(page, { ...validArgs, images: 'missing.png' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(publishCommand.func(page, { ...validArgs, 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('publishes when every UI step has positive proof', async () => {
+        const page = makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: true },
+                { ok: true, filled: ['title', 'description', 'price', 'condition'], missing: [] },
+                { ok: true },
+                { status: 'published', item_id: '123456789012', url: 'https://www.goofish.com/item?id=123456789012' },
+            ],
+        });
+
+        const rows = await publishCommand.func(page, validArgs);
+
+        expect(rows).toEqual([{
+            status: 'published',
+            item_id: '123456789012',
+            title: 'MacBook Pro',
+            price: '¥5999.99',
+            condition: '轻微使用',
+            url: 'https://www.goofish.com/item?id=123456789012',
+            message: '发布成功',
+        }]);
+    });
+
+    it('uses IPage getCurrentUrl instead of a non-existent page.url method', async () => {
+        const page = makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: true },
+                { ok: true, filled: ['title', 'description', 'price', 'condition'], missing: [] },
+                { ok: true },
+                { status: 'published', item_id: '123456789012' },
+            ],
+            overrides: {
+                getCurrentUrl: vi.fn().mockResolvedValue('https://www.goofish.com/item?id=123456789012'),
+            },
+        });
+
+        expect(page.url).toBeUndefined();
+
+        const rows = await publishCommand.func(page, validArgs);
+
+        expect(page.getCurrentUrl).toHaveBeenCalled();
+        expect(rows[0].url).toBe('https://www.goofish.com/item?id=123456789012');
+    });
+
+    it('maps login walls to AuthRequiredError', async () => {
+        const page = makePage({
+            evaluateResults: [
+                { requiresAuth: true },
+            ],
+        });
+
+        await expect(publishCommand.func(page, validArgs)).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('fails fast when category selection or form filling is not proven', async () => {
+        await expect(publishCommand.func(makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: false, reason: 'category-not-found' },
+            ],
+        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
+
+        await expect(publishCommand.func(makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: true },
+                { ok: false, missing: ['price'] },
+            ],
+        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('uploads validated local images through the discovered file input', async () => {
+        const page = makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: true },
+                { ok: true, missing: [] },
+                { ok: true, selector: '[id="upload"]' },
+                { ok: true },
+                { status: 'published', item_id: '123456789012', url: 'https://www.goofish.com/item?id=123456789012' },
+            ],
+        });
+
+        await publishCommand.func(page, { ...validArgs, images: 'a.png,b.webp' });
+
+        expect(page.setFileInput).toHaveBeenCalledWith(['/abs/a.png', '/abs/b.webp'], '[id="upload"]');
+    });
+
+    it('does not return a success row for failed or unconfirmed publish states', async () => {
+        await expect(publishCommand.func(makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: true },
+                { ok: true, missing: [] },
+                { ok: true },
+                { status: 'failed', message: '内容违规' },
+            ],
+        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
+
+        await expect(publishCommand.func(makePage({
+            evaluateResults: [
+                { hasPublishForm: true },
+                { ok: true },
+                { ok: true, missing: [] },
+                { ok: true },
+            ],
+        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('browser category script is async and returns typed failure reasons', async () => {
+        const result = await runBrowserScript('<main><button>其他</button></main>', __test__.buildSelectCategoryEvaluate('笔记本'));
+
+        expect(result).toEqual({ ok: false, reason: 'category-trigger-not-found' });
+    });
+
+    it('browser fill script reports missing required fields', async () => {
+        const result = await runBrowserScript(`
+            <main>
+              <input placeholder="标题" />
+              <textarea id="desc"></textarea>
+              <button>轻微使用</button>
+            </main>
+        `, __test__.buildFillFormEvaluate(validArgs));
+
+        expect(result.ok).toBe(false);
+        expect(result.missing).toContain('price');
+    });
+
+    it('browser success detector distinguishes success from failure and unknown states', async () => {
+        await expect(runBrowserScript('<body>发布成功</body>', __test__.buildDetectSuccessEvaluate(), {
+            url: 'https://www.goofish.com/item?id=123456789012',
+        })).resolves.toMatchObject({ status: 'published', item_id: '123456789012' });
+
+        await expect(runBrowserScript('<body><div class="error">内容违规</div></body>', __test__.buildDetectSuccessEvaluate()))
+            .resolves.toMatchObject({ status: 'failed', message: '内容违规' });
+
+        await expect(runBrowserScript('<body>处理中</body>', __test__.buildDetectSuccessEvaluate()))
+            .resolves.toEqual({ ok: false, reason: 'unknown-state' });
+    });
+});

package/clis/xiaoe/catalog.js

@@ -1,19 +1,58 @@
+// Xiaoe (小鹅通) catalog — list chapters + sections of a course / column
+// page (`h5.xet.citv.cn`).
+//
+// Replaces the legacy `pipeline:[]` form. The in-browser extraction logic
+// (Vue store walking + auto-scroll-to-load + Vue child traversal) is kept
+// byte-for-byte — Xiaoe's pages are SPA-rendered and Vue's private API
+// (`__vue__`, `$store`, `$children`, `chapter_box.__vue__`) is the only
+// stable hook we have. JSDOM cannot reproduce the Vue runtime tree, so
+// reorganising the IIFE without live verify would be silent-failure risk.
+//
+// What changes:
+//   - `func` form + `Strategy.COOKIE` + `browser:true`.
+//   - Typed errors: `ArgumentError` on missing url; `EmptyResultError`
+//     when the IIFE yields zero rows (almost always means the cookie
+//     expired or the URL is not a course page); `CommandExecutionError`
+//     when `page.evaluate` rejects.
+//   - Three pure helpers (`typeLabel`, `buildItemUrl`, `chapterUrlPath`)
+//     are module-level exports and are embedded into the in-page IIFE
+//     via `${fn.toString()}` so the live and the test path share one
+//     source of truth.
+
 import { cli, Strategy } from '@jackwener/opencli/registry';
-cli({
-    site: 'xiaoe',
-    name: 'catalog',
-    access: 'read',
-    description: '小鹅通课程目录（支持普通课程、专栏、大专栏）',
-    domain: 'h5.xet.citv.cn',
-    strategy: Strategy.COOKIE,
-    args: [
-        { name: 'url', required: true, positional: true, help: '课程页面 URL' },
-    ],
-    columns: ['ch', 'chapter', 'no', 'title', 'type', 'resource_id', 'url', 'status'],
-    pipeline: [
-        { navigate: '${{ args.url }}' },
-        { wait: 8 },
-        { evaluate: `(async () => {
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { requireXiaoePageUrl } from './content.js';
+
+// resource_type → human label. 1=图文 2=直播 3=音频 4=视频 6=专栏 8=大专栏.
+// Returns the raw `String(t)` when the type is unknown (e.g. xiaoe rolls
+// out a new resource type) — never silently swallows it.
+export function typeLabel(t) {
+    const map = { 1: '图文', 2: '直播', 3: '音频', 4: '视频', 6: '专栏', 8: '大专栏' };
+    return map[Number(t)] || String(t || '');
+}
+
+// Resolve a relative `jump_url` / `h5_url` / `url` against the page's
+// origin. Returns '' when the item has no URL field at all.
+export function buildItemUrl(item, origin) {
+    const u = item.jump_url || item.h5_url || item.url || '';
+    if (!u) return '';
+    return u.startsWith('http') ? u : (origin + u);
+}
+
+// chapter_type → URL path for the section reader. Xiaoe routes chapter
+// types to different player paths; returning `undefined` for unknown
+// types lets the caller decide whether to emit `''` instead of guessing
+// a bad URL.
+export function chapterUrlPath(chType) {
+    const map = { 1: '/v1/course/text/', 2: '/v2/course/alive/', 3: '/v1/course/audio/', 4: '/v1/course/video/' };
+    return map[Number(chType)];
+}
+
+export function buildCatalogScript() {
+    return `(async () => {
+  ${typeLabel.toString()}
+  ${buildItemUrl.toString()}
+  ${chapterUrlPath.toString()}
   var el = document.querySelector('#app');
   var store = (el && el.__vue__) ? el.__vue__.$store : null;
   if (!store) return [];
@@ -22,13 +61,6 @@ cli({
   var origin = window.location.origin;
   var courseName = coreInfo.resource_name || '';
 
-  function typeLabel(t) {
-    return {1:'图文',2:'直播',3:'音频',4:'视频',6:'专栏',8:'大专栏'}[Number(t)] || String(t||'');
-  }
-  function buildUrl(item) {
-    var u = item.jump_url || item.h5_url || item.url || '';
-    return (u && !u.startsWith('http')) ? origin + u : u;
-  }
   function clickTab(name) {
     var tabs = document.querySelectorAll('span, div');
     for (var i = 0; i < tabs.length; i++) {
@@ -61,7 +93,7 @@ cli({
       if(scrollers[si].scrollHeight > scrollers[si].clientHeight) scrollers[si].scrollTop = scrollers[si].scrollHeight;
     }
     await new Promise(function(r) { setTimeout(r, 800); });
-    
+
     // 点击可能存在的下拉/加载更多
     var moreTabs = document.querySelectorAll('span, div, p');
     for (var bi = 0; bi < moreTabs.length; bi++) {
@@ -70,7 +102,7 @@ cli({
         try { moreTabs[bi].click(); } catch(e){}
       }
     }
-    
+
     var maxScrollHeight = getMaxScrollHeight(getScrollTargets());
     if (sc > 3 && maxScrollHeight === prevMaxScrollHeight) break;
     prevMaxScrollHeight = maxScrollHeight;
@@ -92,11 +124,13 @@ cli({
             var item = arr[j];
             if (!item.resource_id || !/^[pvlai]_/.test(item.resource_id)) continue;
             listData.push({
-              ch: 1, chapter: courseName, no: j + 1,
+              ch: 1,
+              chapter: courseName,
+              no: j + 1,
               title: item.resource_title || item.title || item.chapter_title || '',
               type: typeLabel(item.resource_type || item.chapter_type),
               resource_id: item.resource_id,
-              url: buildUrl(item),
+              url: buildItemUrl(item, origin),
               status: item.finished_state === 1 ? '已完成' : (item.resource_count ? item.resource_count + '节' : ''),
             });
           }
@@ -134,9 +168,11 @@ cli({
       var child = children[ck];
       var resId = child.resource_id || child.chapter_id || '';
       var chType = child.chapter_type || child.resource_type || 0;
-      var urlPath = {1:'/v1/course/text/',2:'/v2/course/alive/',3:'/v1/course/audio/',4:'/v1/course/video/'}[Number(chType)];
+      var urlPath = chapterUrlPath(chType);
       result.push({
-        ch: cj + 1, chapter: chTitle, no: ck + 1,
+        ch: cj + 1,
+        chapter: chTitle,
+        no: ck + 1,
         title: child.chapter_title || child.resource_title || '',
         type: typeLabel(chType),
         resource_id: resId,
@@ -146,17 +182,46 @@ cli({
     }
   }
   return result;
-})()
-` },
-        { map: {
-                ch: '${{ item.ch }}',
-                chapter: '${{ item.chapter }}',
-                no: '${{ item.no }}',
-                title: '${{ item.title }}',
-                type: '${{ item.type }}',
-                resource_id: '${{ item.resource_id }}',
-                url: '${{ item.url }}',
-                status: '${{ item.status }}',
-            } },
+})()`;
+}
+
+async function getXiaoeCatalog(page, args) {
+    const url = requireXiaoePageUrl(args.url, 'catalog');
+    let rows;
+    try {
+        await page.goto(url, { waitUntil: 'load', settleMs: 8000 });
+        rows = await page.evaluate(buildCatalogScript());
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CommandExecutionError(
+            `Failed to read xiaoe catalog: ${message}`,
+            'page may not have rendered or auth may be required',
+        );
+    }
+    if (!Array.isArray(rows) || rows.length === 0) {
+        throw new EmptyResultError(
+            'xiaoe/catalog',
+            'No catalog rows extracted — the URL may not be a course page or the login session has expired',
+        );
+    }
+    return rows;
+}
+
+export const catalogCommand = cli({
+    site: 'xiaoe',
+    name: 'catalog',
+    access: 'read',
+    description: '小鹅通课程目录（支持普通课程、专栏、大专栏）',
+    domain: 'h5.xet.citv.cn',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'url', required: true, positional: true, help: '课程页面 URL' },
     ],
+    columns: ['ch', 'chapter', 'no', 'title', 'type', 'resource_id', 'url', 'status'],
+    func: getXiaoeCatalog,
 });
+
+export const __test__ = {
+    buildCatalogScript,
+};

package/clis/xiaoe/content.js

@@ -1,40 +1,175 @@
+// Xiaoe (小鹅通) content extractor — pulls rendered article text from a
+// rich-text page (h5.xet.citv.cn).
+//
+// Replaces the legacy `pipeline:[]` form. Two real bugs in the legacy
+// adapter, both silent:
+//   1. The IIFE returned `{title, content, content_length, image_count,
+//      images}` but `columns` declared `[title, content_length,
+//      image_count]` — `content` (the text the adapter exists to
+//      extract!) and `images` were silently dropped before reaching the
+//      caller. The user got "this article has 1234 chars" with no way
+//      to read those chars.
+//   2. `JSON.stringify(images.slice(0, 20))` silently truncated to the
+//      first 20 image URLs and never told the caller the slice
+//      happened.
+//
+// New behavior:
+//   - `func` form + `Strategy.COOKIE` + `browser:true` (the page is
+//     gated behind a logged-in xiaoe session).
+//   - Pure helpers `pickContentText` / `countXiaoeImages` are
+//     module-level exports; the in-page IIFE embeds them via
+//     `${fn.toString()}` while JSDOM tests call the same exports
+//     directly against a hand-crafted fixture (same pattern as
+//     dianping #1313 / hupu #1387).
+//   - `content` is now a real column (the bug fix). `image_count` is
+//     metadata that helps callers decide whether to re-render the
+//     page for a JSON-image dump in a follow-up adapter.
+//   - Empty-content extraction → `EmptyResultError` with a
+//     login-likely hint (xiaoe routinely renders an empty shell when
+//     the cookie has expired). No silent `return [{ content: '' }]`.
+
 import { cli, Strategy } from '@jackwener/opencli/registry';
-cli({
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const CONTENT_SELECTORS = [
+    '.rich-text-wrap',
+    '.content-wrap',
+    '.article-content',
+    '.text-content',
+    '.course-detail',
+    '.detail-content',
+    '[class*="richtext"]',
+    '[class*="rich-text"]',
+    '.ql-editor',
+];
+export const CONTENT_MIN_LENGTH = 50;
+
+// Pure: walk `selectors` in order, return the trimmed text of the first
+// element whose `.innerText` (with `.textContent` fallback for JSDOM)
+// has more than `minLength` characters. Falls back to `<main>`, then
+// `#app`, then `<body>` — same chain the legacy IIFE used.
+export function pickContentText(doc, selectors, minLength = CONTENT_MIN_LENGTH) {
+    for (const sel of selectors) {
+        const el = doc.querySelector(sel);
+        if (!el) continue;
+        const text = ((el.innerText || el.textContent) || '').trim();
+        if (text.length > minLength) return text;
+    }
+    const fallback = doc.querySelector('main')
+        || doc.querySelector('#app')
+        || doc.body;
+    if (!fallback) return '';
+    return ((fallback.innerText || fallback.textContent) || '').trim();
+}
+
+// Pure: count `<img>` elements whose src looks like a real xiaoe-hosted
+// asset. `data:` URIs and non-xiaoe CDNs (avatars, ads) are excluded.
+export function countXiaoeImages(doc) {
+    let count = 0;
+    const imgs = doc.querySelectorAll('img');
+    for (let i = 0; i < imgs.length; i += 1) {
+        const src = imgs[i].getAttribute('src') || imgs[i].src || '';
+        if (!src) continue;
+        if (src.startsWith('data:')) continue;
+        if (!src.includes('xiaoe')) continue;
+        count += 1;
+    }
+    return count;
+}
+
+export function requireXiaoePageUrl(value, commandName) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (!raw) {
+        throw new ArgumentError('url is required (positional)');
+    }
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    } catch {
+        throw new ArgumentError(
+            `invalid xiaoe URL: ${raw}`,
+            `Example: opencli xiaoe ${commandName} https://appxxxx.h5.xet.citv.cn/p/course/ecourse/v_xxxxx`,
+        );
+    }
+    if (parsed.protocol !== 'https:') {
+        throw new ArgumentError(
+            `xiaoe URL must use https (got ${parsed.protocol.replace(':', '')})`,
+            `Example: opencli xiaoe ${commandName} https://appxxxx.h5.xet.citv.cn/p/course/ecourse/v_xxxxx`,
+        );
+    }
+    const host = parsed.hostname.toLowerCase();
+    if (host !== 'h5.xet.citv.cn' && !host.endsWith('.h5.xet.citv.cn')) {
+        throw new ArgumentError(
+            `url must be on h5.xet.citv.cn or a shop subdomain (got ${parsed.hostname})`,
+            `Example: opencli xiaoe ${commandName} https://appxxxx.h5.xet.citv.cn/p/course/ecourse/v_xxxxx`,
+        );
+    }
+    return parsed.toString();
+}
+
+export function buildContentScript() {
+    return `
+(() => {
+  ${pickContentText.toString()}
+  ${countXiaoeImages.toString()}
+  const selectors = ${JSON.stringify(CONTENT_SELECTORS)};
+  const title = document.title || '';
+  const content = pickContentText(document, selectors, ${JSON.stringify(CONTENT_MIN_LENGTH)});
+  const imageCount = countXiaoeImages(document);
+  return [{
+    title,
+    content,
+    content_length: content.length,
+    image_count: imageCount,
+  }];
+})()
+`;
+}
+
+async function getXiaoeContent(page, args) {
+    const url = requireXiaoePageUrl(args.url, 'content');
+    let rows;
+    try {
+        await page.goto(url, { waitUntil: 'load', settleMs: 6000 });
+        rows = await page.evaluate(buildContentScript());
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CommandExecutionError(
+            `Failed to extract xiaoe content: ${message}`,
+            'page may not have rendered or auth may be required',
+        );
+    }
+    if (!Array.isArray(rows) || rows.length === 0) {
+        throw new EmptyResultError(
+            'xiaoe/content',
+            'No rows returned from page evaluator (page structure may have changed)',
+        );
+    }
+    const row = rows[0];
+    if (!row || typeof row.content !== 'string' || row.content.length === 0) {
+        throw new EmptyResultError(
+            'xiaoe/content',
+            'No article content extracted — login session may have expired or the page renders an empty shell',
+        );
+    }
+    return rows;
+}
+
+export const contentCommand = cli({
     site: 'xiaoe',
     name: 'content',
     access: 'read',
     description: '提取小鹅通图文页面内容为文本',
     domain: 'h5.xet.citv.cn',
     strategy: Strategy.COOKIE,
+    browser: true,
     args: [
         { name: 'url', required: true, positional: true, help: '页面 URL' },
     ],
-    columns: ['title', 'content_length', 'image_count'],
-    pipeline: [
-        { navigate: '${{ args.url }}' },
-        { wait: 6 },
-        { evaluate: `(() => {
-  var selectors = ['.rich-text-wrap','.content-wrap','.article-content','.text-content',
-    '.course-detail','.detail-content','[class*="richtext"]','[class*="rich-text"]','.ql-editor'];
-  var content = '';
-  for (var i = 0; i < selectors.length; i++) {
-    var el = document.querySelector(selectors[i]);
-    if (el && el.innerText.trim().length > 50) { content = el.innerText.trim(); break; }
-  }
-  if (!content) content = (document.querySelector('main') || document.querySelector('#app') || document.body).innerText.trim();
-
-  var images = [];
-  document.querySelectorAll('img').forEach(function(img) {
-    if (img.src && !img.src.startsWith('data:') && img.src.includes('xiaoe')) images.push(img.src);
-  });
-  return [{
-    title: document.title,
-    content: content,
-    content_length: content.length,
-    image_count: images.length,
-    images: JSON.stringify(images.slice(0, 20)),
-  }];
-})()
-` },
-    ],
+    columns: ['title', 'content', 'content_length', 'image_count'],
+    func: getXiaoeContent,
 });
+
+export const __test__ = {
+    buildContentScript,
+};