@jackwener/opencli 1.5.5 → 1.5.6

package/dist/clis/xiaohongshu/publish.js

@@ -3,7 +3,7 @@
  *
  * Flow:
  *   1. Navigate to creator publish page
- *   2. Upload images via DataTransfer injection into the file input
+ *   2. Upload images via CDP DOM.setFileInputFiles (with base64 fallback)
  *   3. Fill title and body text
  *   4. Add topic hashtags
  *   5. Publish (or save as draft)
@@ -37,43 +37,90 @@ const TITLE_SELECTORS = [
     '.note-title input',
     'input[maxlength]',
 ];
+const SUPPORTED_EXTENSIONS = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
 /**
- * Read a local image and return the name, MIME type, and base64 content.
- * Throws if the file does not exist or the extension is unsupported.
+ * Validate image paths: check existence and extension.
+ * Returns resolved absolute paths.
  */
-function readImageFile(filePath) {
-    const absPath = path.resolve(filePath);
-    if (!fs.existsSync(absPath))
-        throw new Error(`Image file not found: ${absPath}`);
-    const ext = path.extname(absPath).toLowerCase();
-    const mimeMap = {
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.png': 'image/png',
-        '.gif': 'image/gif',
-        '.webp': 'image/webp',
-    };
-    const mimeType = mimeMap[ext];
-    if (!mimeType)
-        throw new Error(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
-    const base64 = fs.readFileSync(absPath).toString('base64');
-    return { name: path.basename(absPath), mimeType, base64 };
+function validateImagePaths(filePaths) {
+    return filePaths.map((filePath) => {
+        const absPath = path.resolve(filePath);
+        if (!fs.existsSync(absPath))
+            throw new Error(`Image file not found: ${absPath}`);
+        const ext = path.extname(absPath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS[ext]) {
+            throw new Error(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
+        }
+        return absPath;
+    });
 }
+/** CSS selector for image-accepting file inputs. */
+const IMAGE_INPUT_SELECTOR = 'input[type="file"][accept*="image"],'
+    + 'input[type="file"][accept*=".jpg"],'
+    + 'input[type="file"][accept*=".jpeg"],'
+    + 'input[type="file"][accept*=".png"],'
+    + 'input[type="file"][accept*=".gif"],'
+    + 'input[type="file"][accept*=".webp"]';
 /**
- * Inject images into the page's file input using DataTransfer.
- * Converts base64 payloads to File objects in the browser context, then dispatches
- * a synthetic 'change' event on the input element.
+ * Upload images via CDP DOM.setFileInputFiles — Chrome reads files directly
+ * from the local filesystem, avoiding base64 payload size limits.
  *
- * Returns { ok, count, error }.
+ * Falls back to the legacy base64 DataTransfer approach if the extension
+ * does not support set-file-input (e.g. older extension version).
  */
-async function injectImages(page, images) {
+async function uploadImages(page, absPaths) {
+    // ── Primary: CDP DOM.setFileInputFiles ──────────────────────────────
+    if (page.setFileInput) {
+        try {
+            // Find image-accepting file input on the page
+            const selector = await page.evaluate(`
+        (() => {
+          const sels = ${JSON.stringify(IMAGE_INPUT_SELECTOR)};
+          const el = document.querySelector(sels);
+          return el ? sels : null;
+        })()
+      `);
+            if (!selector) {
+                return { ok: false, count: 0, error: 'No file input found on page' };
+            }
+            await page.setFileInput(absPaths, selector);
+            return { ok: true, count: absPaths.length };
+        }
+        catch (err) {
+            // If set-file-input action is not supported by extension, fall through to legacy
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('Unknown action') || msg.includes('not supported')) {
+                // Extension too old — fall through to legacy base64 method
+            }
+            else {
+                return { ok: false, count: 0, error: msg };
+            }
+        }
+    }
+    // ── Fallback: legacy base64 DataTransfer injection ─────────────────
+    const images = absPaths.map((absPath) => {
+        const base64 = fs.readFileSync(absPath).toString('base64');
+        const ext = path.extname(absPath).toLowerCase();
+        return { name: path.basename(absPath), mimeType: SUPPORTED_EXTENSIONS[ext], base64 };
+    });
+    // Warn if total payload is large — this may fail with older extensions
+    const totalBytes = images.reduce((sum, img) => sum + img.base64.length, 0);
+    if (totalBytes > 500_000) {
+        console.warn(`[warn] Total image payload is ${(totalBytes / 1024 / 1024).toFixed(1)}MB (base64). ` +
+            'This may fail with the browser bridge. Update the extension to v1.6+ for CDP-based upload, ' +
+            'or compress images before publishing.');
+    }
     const payload = JSON.stringify(images);
     return page.evaluate(`
     (async () => {
       const images = ${payload};
 
-      // 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') || '';
@@ -317,8 +364,8 @@ cli({
             throw new Error('At least one --images path is required. The creator center now requires images before showing the editor.');
         if (imagePaths.length > MAX_IMAGES)
             throw new Error(`Too many images: ${imagePaths.length} (max ${MAX_IMAGES})`);
-        // Read images in Node.js context before navigating (fast-fail on bad paths)
-        const imageData = imagePaths.map(readImageFile);
+        // Validate image paths before navigating (fast-fail on bad paths / unsupported formats)
+        const absImagePaths = validateImagePaths(imagePaths);
         // ── Step 1: Navigate to publish page ──────────────────────────────────────
         await page.goto(PUBLISH_URL);
         await page.wait({ time: 3 });
@@ -340,7 +387,7 @@ cli({
                 `Details: ${detail}. Debug screenshot: /tmp/xhs_publish_tab_debug.png`);
         }
         // ── Step 3: Upload images ──────────────────────────────────────────────────
-        const upload = await injectImages(page, imageData);
+        const upload = await uploadImages(page, absImagePaths);
         if (!upload.ok) {
             await page.screenshot({ path: '/tmp/xhs_publish_upload_debug.png' });
             throw new Error(`Image injection failed: ${upload.error ?? 'unknown'}. ` +
@@ -472,7 +519,7 @@ cli({
                 status: isSuccess ? `✅ ${verb}` : '⚠️ 操作完成，请在浏览器中确认',
                 detail: [
                     `"${title}"`,
-                    `${imageData.length}张图片`,
+                    `${absImagePaths.length}张图片`,
                     topics.length ? `话题: ${topics.join(' ')}` : '',
                     successMsg || finalUrl || '',
                 ]

package/dist/clis/xiaohongshu/publish.test.js

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '../../registry.js';
 import './publish.js';
-function createPageMock(evaluateResults) {
+function createPageMock(evaluateResults, overrides = {}) {
     const evaluate = vi.fn();
     for (const result of evaluateResults) {
         evaluate.mockResolvedValueOnce(result);
@@ -32,9 +32,74 @@ function createPageMock(evaluateResults) {
         getCookies: vi.fn().mockResolvedValue([]),
         screenshot: vi.fn().mockResolvedValue(''),
         waitForCapture: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
     };
 }
 describe('xiaohongshu publish', () => {
+    it('prefers CDP setFileInput upload when the page supports it', 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 setFileInput = vi.fn().mockResolvedValue(undefined);
+        const page = createPageMock([
+            'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+            { ok: true, target: '上传图文', text: '上传图文' },
+            { state: 'editor_ready', hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+            'input[type="file"][accept*="image"],input[type="file"][accept*=".jpg"],input[type="file"][accept*=".jpeg"],input[type="file"][accept*=".png"],input[type="file"][accept*=".gif"],input[type="file"][accept*=".webp"]',
+            false,
+            true,
+            { ok: true, sel: 'input[maxlength="20"]' },
+            { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+            true,
+            'https://creator.xiaohongshu.com/publish/success',
+            '发布成功',
+        ], {
+            setFileInput,
+        });
+        const result = await cmd.func(page, {
+            title: 'CDP上传优先',
+            content: '优先走 setFileInput 主路径',
+            images: imagePath,
+            topics: '',
+            draft: false,
+        });
+        expect(setFileInput).toHaveBeenCalledWith([imagePath], expect.stringContaining('input[type="file"][accept*="image"]'));
+        const evaluateCalls = page.evaluate.mock.calls.map((args) => String(args[0]));
+        expect(evaluateCalls.some((code) => code.includes('atob(img.base64)'))).toBe(false);
+        expect(result).toEqual([
+            {
+                status: '✅ 发布成功',
+                detail: '"CDP上传优先" · 1张图片 · 发布成功',
+            },
+        ]);
+    });
+    it('fails fast when only a generic file input exists on the page', 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 setFileInput = vi.fn().mockResolvedValue(undefined);
+        const page = createPageMock([
+            'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+            { ok: true, target: '上传图文', text: '上传图文' },
+            { state: 'editor_ready', hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+            null,
+        ], {
+            setFileInput,
+        });
+        await expect(cmd.func(page, {
+            title: '不要走泛化上传',
+            content: 'generic file input 应该直接报错',
+            images: imagePath,
+            topics: '',
+            draft: false,
+        })).rejects.toThrow('Image injection failed: No file input found on page');
+        expect(setFileInput).not.toHaveBeenCalled();
+        expect(page.screenshot).toHaveBeenCalledWith({ path: '/tmp/xhs_publish_upload_debug.png' });
+    });
     it('selects the image-text tab and publishes successfully', async () => {
         const cmd = getRegistry().get('xiaohongshu/publish');
         expect(cmd?.func).toBeTypeOf('function');

package/dist/clis/xiaohongshu/user-helpers.d.ts

@@ -7,6 +7,7 @@ export interface XhsUserNoteRow {
     title: string;
     type: string;
     likes: string;
+    cover: string;
     url: string;
 }
 export declare function normalizeXhsUserId(input: string): string;

package/dist/clis/xiaohongshu/user-helpers.js

@@ -55,11 +55,13 @@ export function extractXhsUserNotes(snapshot, fallbackUserId) {
         const userId = toCleanString(noteCard.user?.userId ?? noteCard.user?.user_id ?? fallbackUserId);
         const xsecToken = toCleanString(entry?.xsecToken ?? entry?.xsec_token ?? noteCard.xsecToken ?? noteCard.xsec_token);
         const likes = toCleanString(noteCard.interactInfo?.likedCount ?? noteCard.interact_info?.liked_count ?? 0) || '0';
+        const cover = toCleanString(noteCard.cover?.urlDefault ?? noteCard.cover?.urlPre ?? noteCard.cover?.url ?? '');
         rows.push({
             id: noteId,
             title: toCleanString(noteCard.displayTitle ?? noteCard.display_title ?? noteCard.title),
             type: toCleanString(noteCard.type),
             likes,
+            cover,
             url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken),
         });
     }

package/dist/clis/xiaohongshu/user-helpers.test.js

@@ -55,6 +55,7 @@ describe('extractXhsUserNotes', () => {
                 title: 'First note',
                 type: 'video',
                 likes: '4.6万',
+                cover: '',
                 url: 'https://www.xiaohongshu.com/user/profile/user-1/note-1?xsec_token=abc&xsec_source=pc_user',
             },
             {
@@ -62,10 +63,27 @@ describe('extractXhsUserNotes', () => {
                 title: 'Second note',
                 type: 'normal',
                 likes: '42',
+                cover: '',
                 url: 'https://www.xiaohongshu.com/user/profile/fallback-user/note-2',
             },
         ]);
     });
+    it('extracts cover urls with fallback priority urlDefault -> urlPre -> url', () => {
+        const rows = extractXhsUserNotes({
+            noteGroups: [
+                [
+                    { noteCard: { noteId: 'cover-1', cover: { urlDefault: 'https://img.example/default.jpg', urlPre: 'https://img.example/pre.jpg', url: 'https://img.example/raw.jpg' } } },
+                    { noteCard: { noteId: 'cover-2', cover: { urlPre: 'https://img.example/pre-only.jpg', url: 'https://img.example/raw-only.jpg' } } },
+                    { noteCard: { noteId: 'cover-3', cover: { url: 'https://img.example/raw-fallback.jpg' } } },
+                ],
+            ],
+        }, 'fallback-user');
+        expect(rows.map(row => row.cover)).toEqual([
+            'https://img.example/default.jpg',
+            'https://img.example/pre-only.jpg',
+            'https://img.example/raw-fallback.jpg',
+        ]);
+    });
     it('deduplicates repeated notes by note id', () => {
         const rows = extractXhsUserNotes({
             noteGroups: [

package/dist/clis/xueqiu/comments.d.ts

@@ -0,0 +1,118 @@
+import type { IPage } from '../../types.js';
+/**
+ * Minimal browser-response shape used by the classifier.
+ */
+export interface XueqiuCommentsResponse {
+    status: number;
+    contentType: string;
+    json: unknown;
+    textSnippet: string;
+}
+/**
+ * Minimal normalized row shape used during pagination and deduplication.
+ */
+export interface XueqiuCommentRow {
+    id: string;
+    author: string;
+    text?: string;
+    likes?: number;
+    replies?: number;
+    retweets?: number;
+    created_at?: string | null;
+    url?: string | null;
+}
+/**
+ * Public CLI row shape. This intentionally omits the internal stable ID used
+ * only for deduplication, so machine-readable output matches the command
+ * contract and table columns.
+ */
+export type XueqiuCommentOutputRow = Omit<XueqiuCommentRow, 'id'>;
+/**
+ * Pagination options for collecting enough rows to satisfy `--limit`.
+ */
+export interface CollectCommentRowsOptions {
+    symbol: string;
+    limit: number;
+    pageSize: number;
+    maxRequests: number;
+    fetchPage: (pageNumber: number, pageSize: number) => Promise<XueqiuCommentsResponse>;
+    warn?: (message: string) => void;
+}
+type XueqiuCommentsKind = 'auth' | 'anti-bot' | 'argument' | 'empty' | 'incompatible' | 'unknown';
+/**
+ * Extract the raw item list from one classified JSON payload.
+ *
+ * @param json Raw parsed JSON payload from browser fetch.
+ * @returns Discussion items when the response shape is usable.
+ */
+export declare function getCommentItems(json: unknown): Record<string, any>[];
+/**
+ * Classify one raw browser response before command-level error handling.
+ *
+ * @param response Structured browser response payload.
+ * @returns Tagged result describing the response class.
+ */
+export declare function classifyXueqiuCommentsResponse(response: XueqiuCommentsResponse): {
+    kind: XueqiuCommentsKind;
+};
+/**
+ * Merge one new page of rows while preserving the first occurrence of each ID.
+ *
+ * @param current Rows already collected.
+ * @param incoming Rows from the next page.
+ * @returns Deduplicated merged rows.
+ */
+export declare function mergeUniqueCommentRows(current: XueqiuCommentRow[], incoming: XueqiuCommentRow[]): XueqiuCommentRow[];
+/**
+ * Normalize one raw xueqiu discussion item into the CLI row shape.
+ *
+ * Returned rows represent stock-scoped discussion posts, not replies under
+ * one parent post.
+ *
+ * @param item Raw API item.
+ * @returns Cleaned CLI row.
+ */
+export declare function normalizeCommentItem(item: Record<string, any>): XueqiuCommentRow;
+/**
+ * Remove internal-only fields before returning rows to the CLI renderer.
+ *
+ * @param row Internal row shape used during pagination.
+ * @returns Public output row that matches the documented command contract.
+ */
+export declare function toCommentOutputRow(row: XueqiuCommentRow): XueqiuCommentOutputRow;
+/**
+ * Convert response classification into a compact warning phrase.
+ *
+ * @param kind Classifier result kind.
+ * @returns Human-readable reason fragment for stderr warnings.
+ */
+export declare function describeFailureKind(kind: XueqiuCommentsKind): string;
+/**
+ * Fetch one discussion page from inside the browser context so cookies and
+ * any site-side request state stay attached to the request.
+ *
+ * @param page Active browser page.
+ * @param symbol Normalized stock symbol.
+ * @param pageNumber Internal page counter, starting from 1.
+ * @param pageSize Item count per internal request.
+ * @returns Structured response for command-side classification.
+ */
+export declare function fetchCommentsPage(page: IPage, symbol: string, pageNumber: number, pageSize: number): Promise<XueqiuCommentsResponse>;
+/**
+ * Collect enough stock discussion rows to satisfy the requested limit.
+ *
+ * This helper owns the internal pagination policy so the public command
+ * contract can stay small and expose only `--limit`.
+ *
+ * @param options Pagination inputs and a page-fetch callback.
+ * @returns Deduplicated normalized rows, possibly partial with a warning.
+ */
+export declare function collectCommentRows(options: CollectCommentRowsOptions): Promise<XueqiuCommentRow[]>;
+/**
+ * Convert raw CLI input into a normalized stock symbol.
+ *
+ * @param raw User-provided CLI argument.
+ * @returns Upper-cased symbol string.
+ */
+export declare function normalizeSymbolInput(raw: unknown): string;
+export {};