@jackwener/opencli 1.6.1 → 1.6.2

package/src/browser/page.ts

@@ -58,25 +58,17 @@ export class Page extends BasePage {
       this._tabId = result.tabId;
     }
     this._lastUrl = url;
-    // Inject stealth anti-detection patches (guard flag prevents double-injection).
-    try {
-      await sendCommand('exec', {
-        code: generateStealthJs(),
-        ...this._cmdOpts(),
-      });
-    } catch {
-      // Non-fatal: stealth is best-effort
-    }
-    // Smart settle: use DOM stability detection instead of fixed sleep.
-    // settleMs is now a timeout cap (default 1000ms), not a fixed wait.
+    // Inject stealth + settle in a single round-trip instead of two sequential exec calls.
+    // The stealth guard flag prevents double-injection; settle uses DOM stability detection.
     if (options?.waitUntil !== 'none') {
       const maxMs = options?.settleMs ?? 1000;
-      const settleOpts = {
-        code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
+      const combinedCode = `${generateStealthJs()};\n${waitForDomStableJs(maxMs, Math.min(500, maxMs))}`;
+      const combinedOpts = {
+        code: combinedCode,
         ...this._cmdOpts(),
       };
       try {
-        await sendCommand('exec', settleOpts);
+        await sendCommand('exec', combinedOpts);
       } catch (err) {
         if (!isRetryableSettleError(err)) throw err;
         // SPA client-side redirects can invalidate the CDP target after
@@ -84,14 +76,21 @@ export class Page extends BasePage {
         // to load, then retry the settle probe once.
         try {
           await new Promise((r) => setTimeout(r, 200));
-          await sendCommand('exec', settleOpts);
+          await sendCommand('exec', combinedOpts);
         } catch (retryErr) {
           if (!isRetryableSettleError(retryErr)) throw retryErr;
-          // Retry also failed — give up silently. Settle is best-effort
-          // after successful navigation; the next real command will surface
-          // any persistent target error immediately.
         }
       }
+    } else {
+      // Even with waitUntil='none', still inject stealth (best-effort)
+      try {
+        await sendCommand('exec', {
+          code: generateStealthJs(),
+          ...this._cmdOpts(),
+        });
+      } catch {
+        // Non-fatal: stealth is best-effort
+      }
     }
   }
 
@@ -121,6 +120,9 @@ export class Page extends BasePage {
       await sendCommand('close-window', { ...this._wsOpt() });
     } catch {
       // Window may already be closed or daemon may be down
+    } finally {
+      this._tabId = undefined;
+      this._lastUrl = null;
     }
   }
 
@@ -129,18 +131,6 @@ export class Page extends BasePage {
     return Array.isArray(result) ? result : [];
   }
 
-  async closeTab(index?: number): Promise<void> {
-    await sendCommand('tabs', { op: 'close', ...this._wsOpt(), ...(index !== undefined ? { index } : {}) });
-    // Invalidate cached tabId — the closed tab might have been our active one.
-    // We can't know for sure (close-by-index doesn't return tabId), so reset.
-    this._tabId = undefined;
-  }
-
-  async newTab(): Promise<void> {
-    const result = await sendCommand('tabs', { op: 'new', ...this._wsOpt() }) as { tabId?: number };
-    if (result?.tabId) this._tabId = result.tabId;
-  }
-
   async selectTab(index: number): Promise<void> {
     const result = await sendCommand('tabs', { op: 'select', index, ...this._wsOpt() }) as { selected?: number };
     if (result?.selected) this._tabId = result.selected;
@@ -164,6 +154,19 @@ export class Page extends BasePage {
     return base64;
   }
 
+  async startNetworkCapture(pattern: string = ''): Promise<void> {
+    await sendCommand('network-capture-start', {
+      pattern,
+      ...this._cmdOpts(),
+    });
+  }
+
+  async readNetworkCapture(): Promise<unknown[]> {
+    const result = await sendCommand('network-capture-read', {
+      ...this._cmdOpts(),
+    });
+    return Array.isArray(result) ? result : [];
+  }
   /**
    * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
    * Chrome reads the files directly from the local filesystem, avoiding the
@@ -180,6 +183,16 @@ export class Page extends BasePage {
     }
   }
 
+  async insertText(text: string): Promise<void> {
+    const result = await sendCommand('insert-text', {
+      text,
+      ...this._cmdOpts(),
+    }) as { inserted?: boolean };
+    if (!result?.inserted) {
+      throw new Error('insertText returned no inserted flag — command may not be supported by the extension');
+    }
+  }
+
   async cdp(method: string, params: Record<string, unknown> = {}): Promise<unknown> {
     return sendCommand('cdp', {
       cdpMethod: method,
@@ -188,6 +201,78 @@ export class Page extends BasePage {
     });
   }
 
+  /** CDP native click fallback — called when JS el.click() fails */
+  protected override async tryNativeClick(x: number, y: number): Promise<boolean> {
+    try {
+      await this.nativeClick(x, y);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Precise click using DOM.getContentQuads/getBoxModel for inline elements */
+  async clickWithQuads(ref: string): Promise<void> {
+    const safeRef = JSON.stringify(ref);
+    const cssSelector = `[data-opencli-ref="${ref.replace(/"/g, '\\"')}"]`;
+
+    // Scroll element into view first
+    await this.evaluate(`
+      (() => {
+        const el = document.querySelector('[data-opencli-ref="' + ${safeRef} + '"]');
+        if (el) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+        return !!el;
+      })()
+    `);
+
+    try {
+      // Find DOM node via CDP
+      const doc = await this.cdp('DOM.getDocument', {}) as { root: { nodeId: number } };
+      const result = await this.cdp('DOM.querySelectorAll', {
+        nodeId: doc.root.nodeId,
+        selector: cssSelector,
+      }) as { nodeIds: number[] };
+
+      if (!result.nodeIds?.length) throw new Error('DOM node not found');
+
+      const nodeId = result.nodeIds[0];
+
+      // Try getContentQuads first (precise for inline elements)
+      try {
+        const quads = await this.cdp('DOM.getContentQuads', { nodeId }) as { quads: number[][] };
+        if (quads.quads?.length) {
+          const q = quads.quads[0];
+          const cx = (q[0] + q[2] + q[4] + q[6]) / 4;
+          const cy = (q[1] + q[3] + q[5] + q[7]) / 4;
+          await this.nativeClick(Math.round(cx), Math.round(cy));
+          return;
+        }
+      } catch { /* fallthrough */ }
+
+      // Try getBoxModel
+      try {
+        const box = await this.cdp('DOM.getBoxModel', { nodeId }) as { model: { content: number[] } };
+        if (box.model?.content) {
+          const c = box.model.content;
+          const cx = (c[0] + c[2] + c[4] + c[6]) / 4;
+          const cy = (c[1] + c[3] + c[5] + c[7]) / 4;
+          await this.nativeClick(Math.round(cx), Math.round(cy));
+          return;
+        }
+      } catch { /* fallthrough */ }
+    } catch { /* fallthrough */ }
+
+    // Final fallback: regular click
+    await this.evaluate(`
+      (() => {
+        const el = document.querySelector('[data-opencli-ref="' + ${safeRef} + '"]');
+        if (!el) throw new Error('Element not found: ' + ${safeRef});
+        el.click();
+        return 'clicked';
+      })()
+    `);
+  }
+
   async nativeClick(x: number, y: number): Promise<void> {
     await this.cdp('Input.dispatchMouseEvent', {
       type: 'mousePressed',
@@ -228,4 +313,3 @@ export class Page extends BasePage {
     });
   }
 }
-

package/src/browser.test.ts

@@ -136,7 +136,7 @@ describe('BrowserBridge state', () => {
 
   it('fails fast when daemon is running but extension is disconnected', async () => {
     vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
-    vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
+    vi.spyOn(daemonClient, 'fetchDaemonStatus').mockResolvedValue({ extensionConnected: false } as any);
 
     const bridge = new BrowserBridge();
 

package/src/build-manifest.ts

@@ -33,6 +33,7 @@ export interface ManifestEntry {
     type?: string;
     default?: unknown;
     required?: boolean;
+    valueRequired?: boolean;
     positional?: boolean;
     help?: string;
     choices?: string[];
@@ -62,6 +63,7 @@ function toManifestArgs(args: CliCommand['args']): ManifestEntry['args'] {
     type: arg.type ?? 'str',
     default: arg.default,
     required: !!arg.required,
+    valueRequired: !!arg.valueRequired || undefined,
     positional: arg.positional || undefined,
     help: arg.help ?? '',
     choices: arg.choices,

package/src/cli.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IPage } from './types.js';
+
+const {
+  mockExploreUrl,
+  mockRenderExploreSummary,
+  mockGenerateCliFromUrl,
+  mockRenderGenerateSummary,
+  mockRecordSession,
+  mockRenderRecordSummary,
+  mockCascadeProbe,
+  mockRenderCascadeResult,
+  mockGetBrowserFactory,
+  mockBrowserSession,
+} = vi.hoisted(() => ({
+  mockExploreUrl: vi.fn(),
+  mockRenderExploreSummary: vi.fn(),
+  mockGenerateCliFromUrl: vi.fn(),
+  mockRenderGenerateSummary: vi.fn(),
+  mockRecordSession: vi.fn(),
+  mockRenderRecordSummary: vi.fn(),
+  mockCascadeProbe: vi.fn(),
+  mockRenderCascadeResult: vi.fn(),
+  mockGetBrowserFactory: vi.fn(() => ({ name: 'BrowserFactory' })),
+  mockBrowserSession: vi.fn(),
+}));
+
+vi.mock('./explore.js', () => ({
+  exploreUrl: mockExploreUrl,
+  renderExploreSummary: mockRenderExploreSummary,
+}));
+
+vi.mock('./generate.js', () => ({
+  generateCliFromUrl: mockGenerateCliFromUrl,
+  renderGenerateSummary: mockRenderGenerateSummary,
+}));
+
+vi.mock('./record.js', () => ({
+  recordSession: mockRecordSession,
+  renderRecordSummary: mockRenderRecordSummary,
+}));
+
+vi.mock('./cascade.js', () => ({
+  cascadeProbe: mockCascadeProbe,
+  renderCascadeResult: mockRenderCascadeResult,
+}));
+
+vi.mock('./runtime.js', () => ({
+  getBrowserFactory: mockGetBrowserFactory,
+  browserSession: mockBrowserSession,
+}));
+
+import { createProgram } from './cli.js';
+
+describe('built-in browser commands verbose wiring', () => {
+  const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+  beforeEach(() => {
+    delete process.env.OPENCLI_VERBOSE;
+    process.exitCode = undefined;
+
+    mockExploreUrl.mockReset().mockResolvedValue({ ok: true });
+    mockRenderExploreSummary.mockReset().mockReturnValue('explore-summary');
+    mockGenerateCliFromUrl.mockReset().mockResolvedValue({ ok: true });
+    mockRenderGenerateSummary.mockReset().mockReturnValue('generate-summary');
+    mockRecordSession.mockReset().mockResolvedValue({ candidateCount: 1 });
+    mockRenderRecordSummary.mockReset().mockReturnValue('record-summary');
+    mockCascadeProbe.mockReset().mockResolvedValue({ ok: true });
+    mockRenderCascadeResult.mockReset().mockReturnValue('cascade-summary');
+    mockGetBrowserFactory.mockClear();
+    mockBrowserSession.mockReset().mockImplementation(async (_factory, fn) => {
+      const page = {
+        goto: vi.fn(),
+        wait: vi.fn(),
+      } as unknown as IPage;
+      return fn(page);
+    });
+  });
+
+  it('enables OPENCLI_VERBOSE for explore via the real CLI command', async () => {
+    const program = createProgram('', '');
+
+    await program.parseAsync(['node', 'opencli', 'explore', 'https://example.com', '-v']);
+
+    expect(process.env.OPENCLI_VERBOSE).toBe('1');
+    expect(mockExploreUrl).toHaveBeenCalledWith(
+      'https://example.com',
+      expect.objectContaining({ workspace: 'explore:example.com' }),
+    );
+  });
+
+  it('enables OPENCLI_VERBOSE for generate via the real CLI command', async () => {
+    const program = createProgram('', '');
+
+    await program.parseAsync(['node', 'opencli', 'generate', 'https://example.com', '-v']);
+
+    expect(process.env.OPENCLI_VERBOSE).toBe('1');
+    expect(mockGenerateCliFromUrl).toHaveBeenCalledWith(
+      expect.objectContaining({ url: 'https://example.com', workspace: 'generate:example.com' }),
+    );
+  });
+
+  it('enables OPENCLI_VERBOSE for record via the real CLI command', async () => {
+    const program = createProgram('', '');
+
+    await program.parseAsync(['node', 'opencli', 'record', 'https://example.com', '-v']);
+
+    expect(process.env.OPENCLI_VERBOSE).toBe('1');
+    expect(mockRecordSession).toHaveBeenCalledWith(
+      expect.objectContaining({ url: 'https://example.com' }),
+    );
+  });
+
+  it('enables OPENCLI_VERBOSE for cascade via the real CLI command', async () => {
+    const program = createProgram('', '');
+
+    await program.parseAsync(['node', 'opencli', 'cascade', 'https://example.com', '-v']);
+
+    expect(process.env.OPENCLI_VERBOSE).toBe('1');
+    expect(mockBrowserSession).toHaveBeenCalled();
+    expect(mockCascadeProbe).toHaveBeenCalledWith(expect.any(Object), 'https://example.com');
+  });
+
+  it('leaves OPENCLI_VERBOSE unset when verbose is omitted', async () => {
+    const program = createProgram('', '');
+
+    await program.parseAsync(['node', 'opencli', 'explore', 'https://example.com']);
+
+    expect(process.env.OPENCLI_VERBOSE).toBeUndefined();
+  });
+
+  consoleLogSpy.mockClear();
+});

package/src/cli.ts

@@ -25,7 +25,11 @@ async function getOperatePage(): Promise<import('./types.js').IPage> {
   return bridge.connect({ timeout: 30, workspace: 'operate:default' });
 }
 
-export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
+function applyVerbose(opts: { verbose?: boolean }): void {
+  if (opts.verbose) process.env.OPENCLI_VERBOSE = '1';
+}
+
+export function createProgram(BUILTIN_CLIS: string, USER_CLIS: string): Command {
   const program = new Command();
   // enablePositionalOptions: prevents parent from consuming flags meant for subcommands;
   // prerequisite for passThroughOptions to forward --help/--version to external binaries
@@ -145,7 +149,16 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .option('--wait <s>', '', '3')
     .option('--auto', 'Enable interactive fuzzing')
     .option('--click <labels>', 'Comma-separated labels to click before fuzzing')
-    .action(async (url, opts) => {
+    .option('-v, --verbose', 'Debug output')
+    .action(async (url: string, opts: {
+      site?: string;
+      goal?: string;
+      wait: string;
+      auto?: boolean;
+      click?: string;
+      verbose?: boolean;
+    }) => {
+      applyVerbose(opts);
       const { exploreUrl, renderExploreSummary } = await import('./explore.js');
       const clickLabels = opts.click
         ? opts.click.split(',').map((s: string) => s.trim())
@@ -168,7 +181,9 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .description('Synthesize CLIs from explore')
     .argument('<target>')
     .option('--top <n>', '', '3')
+    .option('-v, --verbose', 'Debug output')
     .action(async (target, opts) => {
+      applyVerbose(opts);
       const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js');
       console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) })));
     });
@@ -179,7 +194,13 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .argument('<url>')
     .option('--goal <text>')
     .option('--site <name>')
-    .action(async (url, opts) => {
+    .option('-v, --verbose', 'Debug output')
+    .action(async (url: string, opts: {
+      goal?: string;
+      site?: string;
+      verbose?: boolean;
+    }) => {
+      applyVerbose(opts);
       const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js');
       const workspace = `generate:${inferHost(url, opts.site)}`;
       const r = await generateCliFromUrl({
@@ -203,7 +224,15 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .option('--out <dir>', 'Output directory for candidates')
     .option('--poll <ms>', 'Poll interval in milliseconds', '2000')
     .option('--timeout <ms>', 'Auto-stop after N milliseconds (default: 60000)', '60000')
-    .action(async (url, opts) => {
+    .option('-v, --verbose', 'Debug output')
+    .action(async (url: string, opts: {
+      site?: string;
+      out?: string;
+      poll: string;
+      timeout: string;
+      verbose?: boolean;
+    }) => {
+      applyVerbose(opts);
       const { recordSession, renderRecordSummary } = await import('./record.js');
       const result = await recordSession({
         BrowserFactory: getBrowserFactory(),
@@ -222,7 +251,12 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .description('Strategy cascade: find simplest working strategy')
     .argument('<url>')
     .option('--site <name>')
-    .action(async (url, opts) => {
+    .option('-v, --verbose', 'Debug output')
+    .action(async (url: string, opts: {
+      site?: string;
+      verbose?: boolean;
+    }) => {
+      applyVerbose(opts);
       const { cascadeProbe, renderCascadeResult } = await import('./cascade.js');
       const workspace = `cascade:${inferHost(url, opts.site)}`;
       const result = await browserSession(getBrowserFactory(), async (page) => {
@@ -302,7 +336,7 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
 
   operate.command('state').description('Page state: URL, title, interactive elements with [N] indices')
     .action(operateAction(async (page) => {
-      const snapshot = await page.snapshot({ viewportExpand: 800 });
+      const snapshot = await page.snapshot({ viewportExpand: 2000 });
       const url = await page.getCurrentUrl?.() ?? '';
       console.log(`URL: ${url}\n`);
       console.log(typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot, null, 2));
@@ -372,7 +406,23 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       await page.click(index);
       await page.wait(0.3);
       await page.typeText(index, text);
-      console.log(`Typed "${text}" into element [${index}]`);
+      // Detect autocomplete/combobox fields and wait for dropdown suggestions
+      const isAutocomplete = await page.evaluate(`
+        (() => {
+          const el = document.querySelector('[data-opencli-ref="${index}"]');
+          if (!el) return false;
+          const role = el.getAttribute('role');
+          const ac = el.getAttribute('aria-autocomplete');
+          const list = el.getAttribute('list');
+          return role === 'combobox' || ac === 'list' || ac === 'both' || !!list;
+        })()
+      `);
+      if (isAutocomplete) {
+        await page.wait(0.4);
+        console.log(`Typed "${text}" into autocomplete [${index}] — use state to see suggestions`);
+      } else {
+        console.log(`Typed "${text}" into element [${index}]`);
+      }
     }));
 
   operate.command('select').argument('<index>', 'Element index of <select>').argument('<option>', 'Option text')
@@ -589,19 +639,25 @@ cli({
         console.log(`🔍 Verifying ${name}...\n`);
         console.log(`  Loading: ${filePath}`);
 
+        // Read adapter to check if it defines a 'limit' arg
+        const adapterSrc = fs.readFileSync(filePath, 'utf-8');
+        const hasLimitArg = /['"]limit['"]/.test(adapterSrc);
+        const limitFlag = hasLimitArg ? ' --limit 3' : '';
+        const verifyCmd = `node dist/main.js ${site} ${command}${limitFlag}`;
+
         try {
-          const output = execSync(`node dist/main.js ${site} ${command} --limit 3`, {
+          const output = execSync(verifyCmd, {
             cwd: path.join(path.dirname(import.meta.url.replace('file://', '')), '..'),
             timeout: 30000,
             encoding: 'utf-8',
             env: process.env,
             stdio: ['pipe', 'pipe', 'pipe'],
           });
-          console.log(`  Executing: opencli ${site} ${command} --limit 3\n`);
+          console.log(`  Executing: opencli ${site} ${command}${limitFlag}\n`);
           console.log(output);
           console.log(`\n  ✓ Adapter works!`);
         } catch (err: any) {
-          console.log(`  Executing: opencli ${site} ${command} --limit 3\n`);
+          console.log(`  Executing: opencli ${site} ${command}${limitFlag}\n`);
           if (err.stdout) console.log(err.stdout);
           if (err.stderr) console.error(err.stderr.slice(0, 500));
           console.log(`\n  ✗ Adapter failed. Fix the code and try again.`);
@@ -628,7 +684,9 @@ cli({
     .description('Diagnose opencli browser bridge connectivity')
     .option('--no-live', 'Skip live browser connectivity test')
     .option('--sessions', 'Show active automation sessions', false)
+    .option('-v, --verbose', 'Debug output')
     .action(async (opts) => {
+      applyVerbose(opts);
       const { runBrowserDoctor, renderBrowserDoctorReport } = await import('./doctor.js');
       const report = await runBrowserDoctor({ live: opts.live, sessions: opts.sessions, cliVersion: PKG_VERSION });
       console.log(renderBrowserDoctorReport(report));
@@ -938,7 +996,11 @@ cli({
     process.exitCode = EXIT_CODES.USAGE_ERROR;
   });
 
-  program.parse();
+  return program;
+}
+
+export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
+  createProgram(BUILTIN_CLIS, USER_CLIS).parse();
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────────────

package/src/clis/1688/item.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './item.js';
+
+describe('1688 item normalization', () => {
+  it('normalizes public item payload into contract fields', () => {
+    const result = __test__.normalizeItemPayload({
+      href: 'https://detail.1688.com/offer/887904326744.html',
+      title: '法式春季长袖开衫连衣裙女新款大码女装碎花吊带裙套装142077 - 阿里巴巴',
+      bodyText: `
+        青岛沁澜衣品服装有限公司
+        入驻13年
+        主营：大码女装
+        店铺回头率
+        87%
+        山东青岛
+        3套起批
+        已售1600+套
+        支持定制logo
+      `,
+      offerTitle: '法式春季长袖开衫连衣裙女新款大码女装碎花吊带裙套装142077',
+      offerId: 887904326744,
+      seller: {
+        companyName: '青岛沁澜衣品服装有限公司',
+        memberId: 'b2b-1641351767',
+        winportUrl: 'https://yinuoweierfushi.1688.com/page/index.html?spm=a1',
+      },
+      trade: {
+        beginAmount: 3,
+        priceDisplay: '96.00-98.00',
+        unit: '套',
+        saleCount: 1655,
+        offerIDatacenterSellInfo: {
+          面料名称: '莫代尔',
+          主面料成分: '莫代尔纤维',
+          sellPointModel: '{"ignore":true}',
+        },
+        offerPriceModel: {
+          currentPrices: [
+            { beginAmount: 3, price: '98.00' },
+            { beginAmount: 50, price: '97.00' },
+          ],
+        },
+      },
+      gallery: {
+        mainImage: ['https://example.com/1.jpg'],
+        offerImgList: ['https://example.com/2.jpg'],
+        wlImageInfos: [{ fullPathImageURI: 'https://example.com/3.jpg' }],
+      },
+      services: [
+        { serviceName: '延期必赔', agreeDeliveryHours: 360 },
+        { serviceName: '品质保障' },
+      ],
+    });
+
+    expect(result.offer_id).toBe('887904326744');
+    expect(result.member_id).toBe('b2b-1641351767');
+    expect(result.shop_id).toBe('yinuoweierfushi');
+    expect(result.seller_url).toBe('https://yinuoweierfushi.1688.com');
+    expect(result.price_text).toBe('¥96.00-98.00');
+    expect(result.moq_text).toBe('3套起批');
+    expect(result.origin_place).toBe('山东青岛');
+    expect(result.delivery_days_text).toBe('360小时内发货');
+    expect(result.private_label_text).toBe('支持定制logo');
+    expect(result.visible_attributes).toEqual([
+      { key: '面料名称', value: '莫代尔' },
+      { key: '主面料成分', value: '莫代尔纤维' },
+    ]);
+  });
+});