@jackwener/opencli 1.4.1 → 1.5.0

package/src/clis/xiaohongshu/comments.ts

@@ -0,0 +1,81 @@
+/**
+ * Xiaohongshu comments — DOM extraction from note detail page.
+ * XHS API requires signed requests, so we scrape the rendered DOM instead.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+
+cli({
+  site: 'xiaohongshu',
+  name: 'comments',
+  description: '获取小红书笔记评论（仅主评论，不含楼中楼）',
+  domain: 'www.xiaohongshu.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'note-id', required: true, positional: true, help: 'Note ID or full /explore/<id> URL' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of comments (max 50)' },
+  ],
+  columns: ['rank', 'author', 'text', 'likes', 'time'],
+  func: async (page, kwargs) => {
+    const limit = Math.min(Number(kwargs.limit) || 20, 50);
+    let noteId = String(kwargs['note-id']).trim();
+
+    // Accept full URLs: /explore/<id> or /note/<id>
+    const urlMatch = noteId.match(/\/explore\/([a-f0-9]+)/) || noteId.match(/\/note\/([a-f0-9]+)/);
+    if (urlMatch) noteId = urlMatch[1];
+
+    await page.goto(`https://www.xiaohongshu.com/explore/${noteId}`);
+    await page.wait(3);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const wait = (ms) => new Promise(r => setTimeout(r, ms))
+
+        // Check login state
+        const loginWall = /登录后查看|请登录/.test(document.body.innerText || '')
+
+        // Scroll the note container to trigger comment loading
+        const scroller = document.querySelector('.note-scroller') || document.querySelector('.container')
+        if (scroller) {
+          for (let i = 0; i < 3; i++) {
+            scroller.scrollTo(0, scroller.scrollHeight)
+            await wait(1000)
+          }
+        }
+
+        const clean = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim()
+
+        const results = []
+        const parents = document.querySelectorAll('.parent-comment')
+        for (const p of parents) {
+          const item = p.querySelector('.comment-item')
+          if (!item) continue
+
+          const author = clean(item.querySelector('.author-wrapper .name, .user-name'))
+          const text = clean(item.querySelector('.content, .note-text'))
+          // XHS shows text "赞" when likes = 0; only shows a number when > 0
+          const likesRaw = clean(item.querySelector('.count'))
+          const likes = /^\\d+$/.test(likesRaw) ? Number(likesRaw) : 0
+          const time = clean(item.querySelector('.date, .time'))
+
+          if (!text) continue
+          results.push({ author, text, likes, time })
+        }
+
+        return { loginWall, results }
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') {
+      throw new EmptyResultError('xiaohongshu/comments', 'Unexpected evaluate response');
+    }
+
+    if ((data as any).loginWall) {
+      throw new AuthRequiredError('www.xiaohongshu.com', 'Note comments require login');
+    }
+
+    const results: any[] = (data as any).results ?? [];
+    return results.slice(0, limit).map((c: any, i: number) => ({ rank: i + 1, ...c }));
+  },
+});

package/src/clis/xiaohongshu/publish.test.ts

@@ -0,0 +1,137 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { getRegistry } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import './publish.js';
+
+function createPageMock(evaluateResults: any[]): IPage {
+  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([]),
+    closeTab: vi.fn().mockResolvedValue(undefined),
+    newTab: vi.fn().mockResolvedValue(undefined),
+    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(''),
+  };
+}
+
+describe('xiaohongshu publish', () => {
+  it('selects the image-text tab and publishes successfully', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-xhs-publish-'));
+    const imagePath = path.join(tempDir, 'demo.jpg');
+    fs.writeFileSync(imagePath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: true, target: '上传图文', text: '上传图文' },
+      { hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+      { ok: true, count: 1 },
+      false,
+      { ok: true, sel: 'input[maxlength="20"]' },
+      { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+      true,
+      'https://creator.xiaohongshu.com/publish/success',
+      '发布成功',
+    ]);
+
+    const result = await cmd!.func!(page, {
+      title: 'DeepSeek别乱问',
+      content: '一篇真实一点的小红书正文',
+      images: imagePath,
+      topics: '',
+      draft: false,
+    });
+
+    const evaluateCalls = (page.evaluate as any).mock.calls.map((args: any[]) => String(args[0]));
+    expect(evaluateCalls.some((code: string) => code.includes("const targets = ['上传图文', '图文', '图片']"))).toBe(true);
+    expect(evaluateCalls.some((code: string) => code.includes("No image file input found on page"))).toBe(true);
+    expect(result).toEqual([
+      {
+        status: '✅ 发布成功',
+        detail: '"DeepSeek别乱问" · 1张图片 · 发布成功',
+      },
+    ]);
+  });
+
+  it('fails early with a clear error when still on the video page', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: false, visibleTexts: ['上传视频', '上传图文'] },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+    ]);
+
+    await expect(cmd!.func!(page, {
+      title: 'DeepSeek别乱问',
+      content: '一篇真实一点的小红书正文',
+      topics: '',
+      draft: false,
+    })).rejects.toThrow('Still on the video publish page after trying to select 图文');
+
+    expect(page.screenshot).toHaveBeenCalledWith({ path: '/tmp/xhs_publish_tab_debug.png' });
+  });
+
+  it('waits for the image-text surface to appear after clicking the tab', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: true, target: '上传图文', text: '上传图文' },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+      { ok: true, sel: 'input[maxlength="20"]' },
+      { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+      true,
+      'https://creator.xiaohongshu.com/publish/success',
+      '发布成功',
+    ]);
+
+    const result = await cmd!.func!(page, {
+      title: '延迟切换也能过',
+      content: '图文页切换慢一点也继续等',
+      topics: '',
+      draft: false,
+    });
+
+    expect((page.wait as any).mock.calls).toContainEqual([{ time: 0.5 }]);
+    expect(result).toEqual([
+      {
+        status: '✅ 发布成功',
+        detail: '"延迟切换也能过" · 无图 · 发布成功',
+      },
+    ]);
+  });
+});

package/src/clis/xiaohongshu/publish.ts

@@ -63,14 +63,22 @@ async function injectImages(page: IPage, images: ImagePayload[]): Promise<{ ok:
     (async () => {
       const images = ${payload};
 
-      // Prefer image/* file inputs; fall back to the first available input.
+      // Only use image-capable file inputs. Do not fall back to a generic uploader,
+      // otherwise we can accidentally feed images into the video upload flow.
       const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
       const input = inputs.find(el => {
         const accept = el.getAttribute('accept') || '';
-        return accept.includes('image') || accept.includes('.jpg') || accept.includes('.png');
-      }) || inputs[0];
+        return (
+          accept.includes('image') ||
+          accept.includes('.jpg') ||
+          accept.includes('.jpeg') ||
+          accept.includes('.png') ||
+          accept.includes('.gif') ||
+          accept.includes('.webp')
+        );
+      });
 
-      if (!input) return { ok: false, count: 0, error: 'No file input found on page' };
+      if (!input) return { ok: false, count: 0, error: 'No image file input found on page' };
 
       const dt = new DataTransfer();
       for (const img of images) {
@@ -151,6 +159,111 @@ async function fillField(page: IPage, selectors: string[], text: string, fieldNa
   }
 }
 
+async function selectImageTextTab(
+  page: IPage,
+): Promise<{ ok: boolean; target?: string; text?: string; visibleTexts?: string[] }> {
+  const result = await page.evaluate(`
+    () => {
+      const isVisible = (el) => {
+        if (!el || el.offsetParent === null) return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const selector = 'button, [role="tab"], [role="button"], a, label, div, span, li';
+      const nodes = Array.from(document.querySelectorAll(selector));
+      const targets = ['上传图文', '图文', '图片'];
+
+      for (const target of targets) {
+        for (const node of nodes) {
+          if (!isVisible(node)) continue;
+          const text = normalize(node.innerText || node.textContent || '');
+          if (!text || text.includes('视频')) continue;
+          if (text === target || text.startsWith(target) || text.includes(target)) {
+            const clickable = node.closest('button, [role="tab"], [role="button"], a, label') || node;
+            clickable.click();
+            return { ok: true, target, text };
+          }
+        }
+      }
+
+      const visibleTexts = [];
+      for (const node of nodes) {
+        if (!isVisible(node)) continue;
+        const text = normalize(node.innerText || node.textContent || '');
+        if (!text || text.length > 20) continue;
+        visibleTexts.push(text);
+        if (visibleTexts.length >= 20) break;
+      }
+      return { ok: false, visibleTexts };
+    }
+  `);
+  if (result?.ok) {
+    await page.wait({ time: 1 });
+  }
+  return result;
+}
+
+async function inspectPublishSurface(
+  page: IPage,
+): Promise<{ hasTitleInput: boolean; hasImageInput: boolean; hasVideoSurface: boolean }> {
+  return page.evaluate(`
+    () => {
+      const text = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim();
+      const hasTitleInput = !!Array.from(document.querySelectorAll('input, textarea')).find((el) => {
+        if (!el || el.offsetParent === null) return false;
+        const placeholder = (el.getAttribute('placeholder') || '').trim();
+        const cls = el.className ? String(el.className) : '';
+        const maxLength = Number(el.getAttribute('maxlength') || 0);
+        return (
+          placeholder.includes('标题') ||
+          /title/i.test(placeholder) ||
+          /title/i.test(cls) ||
+          maxLength === 20
+        );
+      });
+      const hasImageInput = !!Array.from(document.querySelectorAll('input[type="file"]')).find((el) => {
+        const accept = el.getAttribute('accept') || '';
+        return (
+          accept.includes('image') ||
+          accept.includes('.jpg') ||
+          accept.includes('.jpeg') ||
+          accept.includes('.png') ||
+          accept.includes('.gif') ||
+          accept.includes('.webp')
+        );
+      });
+      return {
+        hasTitleInput,
+        hasImageInput,
+        hasVideoSurface: text.includes('拖拽视频到此处点击上传') || text.includes('上传视频'),
+      };
+    }
+  `);
+}
+
+async function waitForImageTextSurface(
+  page: IPage,
+  maxWaitMs = 5_000,
+): Promise<{ hasTitleInput: boolean; hasImageInput: boolean; hasVideoSurface: boolean }> {
+  const pollMs = 500;
+  const maxAttempts = Math.max(1, Math.ceil(maxWaitMs / pollMs));
+  let surface = await inspectPublishSurface(page);
+
+  for (let i = 0; i < maxAttempts; i++) {
+    if (surface.hasTitleInput || surface.hasImageInput || !surface.hasVideoSurface) {
+      return surface;
+    }
+    if (i < maxAttempts - 1) {
+      await page.wait({ time: pollMs / 1_000 });
+      surface = await inspectPublishSurface(page);
+    }
+  }
+
+  return surface;
+}
+
 cli({
   site: 'xiaohongshu',
   name: 'publish',
@@ -204,20 +317,18 @@ cli({
     }
 
     // ── Step 2: Select 图文 (image+text) note type if tabs are present ─────────
-    const tabClicked: boolean = await page.evaluate(`
-      () => {
-        const allEls = document.querySelectorAll('[class*="tab"], [class*="note-type"], [class*="type-item"]');
-        for (const el of allEls) {
-          const text = el.innerText || el.textContent || '';
-          if ((text.includes('图文') || text.includes('图片')) && el.offsetParent !== null) {
-            el.click();
-            return true;
-          }
-        }
-        return false;
-      }
-    `);
-    if (tabClicked) await page.wait({ time: 1 });
+    const tabResult = await selectImageTextTab(page);
+    const surface = await waitForImageTextSurface(page, tabResult?.ok ? 5_000 : 2_000);
+    if (!surface.hasTitleInput && !surface.hasImageInput && surface.hasVideoSurface) {
+      await page.screenshot({ path: '/tmp/xhs_publish_tab_debug.png' });
+      const detail = tabResult?.ok
+        ? `clicked "${tabResult.text}"`
+        : `visible candidates: ${(tabResult?.visibleTexts || []).join(' | ') || 'none'}`;
+      throw new Error(
+        'Still on the video publish page after trying to select 图文. ' +
+        `Details: ${detail}. Debug screenshot: /tmp/xhs_publish_tab_debug.png`
+      );
+    }
 
     // ── Step 3: Upload images ──────────────────────────────────────────────────
     if (imageData.length > 0) {

package/src/commanderAdapter.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import type { CliCommand } from './registry.js';
+
+const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
+  mockExecuteCommand: vi.fn(),
+  mockRenderOutput: vi.fn(),
+}));
+
+vi.mock('./execution.js', () => ({
+  executeCommand: mockExecuteCommand,
+}));
+
+vi.mock('./output.js', () => ({
+  render: mockRenderOutput,
+}));
+
+import { registerCommandToProgram } from './commanderAdapter.js';
+
+describe('commanderAdapter arg passing', () => {
+  const cmd: CliCommand = {
+    site: 'paperreview',
+    name: 'submit',
+    description: 'Submit a PDF',
+    browser: false,
+    args: [
+      { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
+      { name: 'dry-run', type: 'bool', default: false, help: 'Validate only' },
+      { name: 'prepare-only', type: 'bool', default: false, help: 'Prepare only' },
+    ],
+    func: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockExecuteCommand.mockReset();
+    mockExecuteCommand.mockResolvedValue([]);
+    mockRenderOutput.mockReset();
+    delete process.env.OPENCLI_VERBOSE;
+    process.exitCode = undefined;
+  });
+
+  it('passes bool flag values through to executeCommand for coercion', async () => {
+    const program = new Command();
+    const siteCmd = program.command('paperreview');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'false']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs.pdf).toBe('./paper.pdf');
+    expect(kwargs).toHaveProperty('dry-run');
+  });
+
+  it('passes valueless bool flags as true to executeCommand', async () => {
+    const program = new Command();
+    const siteCmd = program.command('paperreview');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs.pdf).toBe('./paper.pdf');
+    expect(kwargs['prepare-only']).toBe(true);
+  });
+
+  it('rejects invalid bool values before calling executeCommand', async () => {
+    const program = new Command();
+    const siteCmd = program.command('paperreview');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
+
+    // normalizeArgValue validates bools eagerly; executeCommand should not be reached
+    expect(mockExecuteCommand).not.toHaveBeenCalled();
+  });
+});