@skills-store/rednote 0.1.2 → 0.1.5

package/dist/rednote/index.js

@@ -95,11 +95,8 @@ export async function runRednoteCli(argv = process.argv.slice(2)) {
         return;
     }
     if (command === 'publish') {
-        const { runPublishCommand } = await import('./publish.js');
-        await runPublishCommand({
-            instance: basicValues.instance,
-            help: basicValues.help
-        });
+        const { parsePublishCliArgs, runPublishCommand } = await import('./publish.js');
+        await runPublishCommand(parsePublishCliArgs(commandArgv));
         return;
     }
     if (command === 'home') {

package/dist/rednote/login.js

@@ -2,7 +2,7 @@
 import { parseArgs } from 'node:util';
 import { printJson, runCli } from '../utils/browser-cli.js';
 import { resolveStatusTarget } from './status.js';
-import { createRednoteSession, disconnectRednoteSession } from './checkLogin.js';
+import { checkRednoteLogin, createRednoteSession, disconnectRednoteSession } from './checkLogin.js';
 function printLoginHelp() {
     process.stdout.write(`rednote login
 
@@ -28,21 +28,24 @@ async function getOrCreateXiaohongshuPage(session) {
     };
 }
 export async function openRednoteLogin(target, session) {
+    const rednoteStatus = await checkRednoteLogin(target, session);
+    if (!rednoteStatus.needLogin) {
+        return {
+            ok: true,
+            rednote: {
+                loginClicked: false,
+                pageUrl: session.page.url(),
+                waitingForPhoneLogin: false,
+                message: '当前实例已登录，无需重复执行登录操作。'
+            }
+        };
+    }
     const { page } = await getOrCreateXiaohongshuPage(session);
-    await page.waitForTimeout(2_000);
     const loginButton = page.locator('#login-btn');
     const hasLoginButton = await loginButton.count() > 0;
     if (!hasLoginButton) {
         return {
             ok: true,
-            instance: {
-                scope: target.scope,
-                name: target.instanceName,
-                browser: target.browser,
-                userDataDir: target.userDataDir,
-                source: target.source,
-                lastConnect: target.lastConnect
-            },
             rednote: {
                 loginClicked: false,
                 pageUrl: page.url(),
@@ -51,18 +54,12 @@ export async function openRednoteLogin(target, session) {
             }
         };
     }
-    await loginButton.first().click();
+    await loginButton.first().click({
+        timeout: 2000
+    });
     await page.waitForTimeout(500);
     return {
         ok: true,
-        instance: {
-            scope: target.scope,
-            name: target.instanceName,
-            browser: target.browser,
-            userDataDir: target.userDataDir,
-            source: target.source,
-            lastConnect: target.lastConnect
-        },
         rednote: {
             loginClicked: true,
             pageUrl: page.url(),

package/dist/rednote/publish.js

@@ -8,6 +8,27 @@ import { createRednoteSession, disconnectRednoteSession, ensureRednoteLoggedIn }
 const REDNOTE_EXPLORE_URL = 'https://www.xiaohongshu.com/explore';
 const CREATOR_HOME_URL = 'https://creator.xiaohongshu.com/new/home';
 const CREATOR_SERVICE_SELECTOR = 'a.link[href="//creator.xiaohongshu.com/?source=official"]';
+const CREATOR_CENTER_TRIGGER_SELECTOR = 'span.reds-button-new-text';
+const CREATOR_CENTER_TRIGGER_TEXT = '创作中心';
+const PUBLISH_NOTE_BUTTON_SELECTOR = 'span.btn-text';
+const PUBLISH_NOTE_BUTTON_TEXT = '发布笔记';
+const PUBLISH_TYPE_TAB_SELECTOR = '.header-tabs .creator-tab .title';
+const VIDEO_UPLOAD_BUTTON_SELECTOR = 'button.upload-button';
+const VIDEO_UPLOAD_BUTTON_TEXT = '上传视频';
+const IMAGE_UPLOAD_BUTTON_SELECTOR = 'button.upload-button';
+const IMAGE_UPLOAD_BUTTON_TEXT = '上传图片';
+const IMAGE_PUBLISH_PAGE_SELECTOR = '.publish-page-content';
+const IMAGE_TITLE_INPUT_SELECTOR = '.publish-page-content input.d-text[placeholder="填写标题会有更多赞哦"]';
+const IMAGE_CONTENT_EDITOR_SELECTOR = '.editor-content .tiptap.ProseMirror[contenteditable="true"]';
+const ARTICLE_NEW_BUTTON_SELECTOR = 'button.new-btn';
+const ARTICLE_NEW_BUTTON_TEXT = '新的创作';
+const ARTICLE_TITLE_INPUT_SELECTOR = '.edit-page textarea.d-text[placeholder="输入标题"]';
+const ARTICLE_CONTENT_EDITOR_SELECTOR = '.rich-editor-content .tiptap.ProseMirror[contenteditable="true"]';
+const PUBLISH_ACTION_BUTTON_SELECTOR = '.publish-page-publish-btn button';
+const SAVE_DRAFT_BUTTON_TEXT = '暂存离开';
+const PUBLISH_BUTTON_TEXT = '发布';
+const VIDEO_FILE_INPUT_SELECTOR = 'input[type="file"]';
+const IMAGE_FILE_INPUT_SELECTOR = 'input[type="file"]';
 const MAX_IMAGE_COUNT = 15;
 function printPublishHelp() {
     process.stdout.write(`rednote publish
@@ -191,62 +212,6 @@ export function resolvePublishPayload(values) {
         content
     };
 }
-function summarizePayload(payload) {
-    if (payload.type === 'video') {
-        return {
-            type: payload.type,
-            title: payload.title,
-            content: payload.content,
-            tags: payload.tags,
-            draft: payload.draft,
-            assetCount: 1,
-            coverImagePath: null,
-            videoPath: payload.videoPath,
-            imagePaths: [],
-            contentLength: payload.content.length
-        };
-    }
-    if (payload.type === 'image') {
-        return {
-            type: payload.type,
-            title: payload.title,
-            content: payload.content,
-            tags: payload.tags,
-            draft: payload.draft,
-            assetCount: payload.imagePaths.length,
-            coverImagePath: payload.coverImagePath,
-            videoPath: null,
-            imagePaths: payload.imagePaths,
-            contentLength: payload.content.length
-        };
-    }
-    return {
-        type: payload.type,
-        title: payload.title,
-        content: payload.content,
-        tags: [],
-        draft: payload.draft,
-        assetCount: 0,
-        coverImagePath: null,
-        videoPath: null,
-        imagePaths: [],
-        contentLength: payload.content.length
-    };
-}
-function toPublishResult(target, publish) {
-    return {
-        ok: true,
-        instance: {
-            scope: target.scope,
-            name: target.instanceName,
-            browser: target.browser,
-            userDataDir: target.userDataDir,
-            source: target.source,
-            lastConnect: target.lastConnect
-        },
-        publish
-    };
-}
 function getSessionPages(session) {
     const pages = [
         session.page,
@@ -303,51 +268,207 @@ async function waitForCreatorHome(page) {
     });
     await page.waitForLoadState('domcontentloaded');
 }
-export async function openRednotePublish(target, session, payload) {
-    const resolved = await resolvePublishPage(session);
-    const payloadSummary = summarizePayload(payload);
-    if (resolved.reusedCreatorHome || isCreatorHomeUrl(resolved.page.url())) {
-        return toPublishResult(target, {
-            pageUrl: resolved.page.url(),
-            creatorHomeUrl: CREATOR_HOME_URL,
-            clickedCreatorService: false,
-            reusedCreatorHome: true,
-            openedInNewPage: false,
-            payload: payloadSummary,
-            message: '当前页面已经是创作服务首页，发布参数已校验。'
-        });
+async function findVisibleLocator(locator, timeoutMs = 3_000) {
+    const deadline = Date.now() + timeoutMs;
+    while(Date.now() < deadline){
+        const count = await locator.count();
+        for(let index = 0; index < count; index += 1){
+            const candidate = locator.nth(index);
+            if (await candidate.isVisible().catch(()=>false)) {
+                return candidate;
+            }
+        }
+        await new Promise((resolve)=>setTimeout(resolve, 100));
     }
-    const creatorServiceLink = resolved.page.locator(CREATOR_SERVICE_SELECTOR).filter({
-        hasText: '创作服务'
+    return null;
+}
+async function requireVisibleLocator(locator, errorMessage, timeoutMs = 3_000) {
+    const visibleLocator = await findVisibleLocator(locator, timeoutMs);
+    if (!visibleLocator) {
+        throw new Error(errorMessage);
+    }
+    return visibleLocator;
+}
+function resolvePublishTypeTabText(type) {
+    if (type === 'video') {
+        return '上传视频';
+    }
+    if (type === 'image') {
+        return '上传图文';
+    }
+    return '写长文';
+}
+async function hoverCreatorCenter(page) {
+    const creatorCenterTrigger = page.locator(CREATOR_CENTER_TRIGGER_SELECTOR).filter({
+        hasText: CREATOR_CENTER_TRIGGER_TEXT
     });
-    if (await creatorServiceLink.count() === 0) {
-        throw new Error('未找到“创作服务”入口，请先打开小红书首页并确认账号已登录。');
+    const visibleCreatorCenterTrigger = await findVisibleLocator(creatorCenterTrigger);
+    if (!visibleCreatorCenterTrigger) {
+        return;
     }
-    const popupPromise = session.browserContext.waitForEvent('page', {
+    await visibleCreatorCenterTrigger.hover();
+    await page.waitForTimeout(300);
+}
+async function openPublishComposer(page, type) {
+    const publishNoteButton = page.locator(PUBLISH_NOTE_BUTTON_SELECTOR).filter({
+        hasText: PUBLISH_NOTE_BUTTON_TEXT
+    });
+    const visiblePublishNoteButton = await requireVisibleLocator(publishNoteButton, '未找到“发布笔记”按钮，请确认已进入创作服务首页。', 15_000);
+    await visiblePublishNoteButton.click();
+    const publishTypeTabText = resolvePublishTypeTabText(type);
+    const publishTypeTab = page.locator(PUBLISH_TYPE_TAB_SELECTOR).filter({
+        hasText: publishTypeTabText
+    }).last();
+    const visiblePublishTypeTab = await requireVisibleLocator(publishTypeTab, `未找到“${publishTypeTabText}”入口，请确认创作服务页面已正确加载。`, 15_000);
+    await visiblePublishTypeTab.click();
+    await page.waitForTimeout(300);
+}
+async function uploadVideoFile(page, videoPath) {
+    const uploadVideoButton = page.locator(VIDEO_UPLOAD_BUTTON_SELECTOR).filter({
+        hasText: VIDEO_UPLOAD_BUTTON_TEXT
+    });
+    const visibleUploadVideoButton = await requireVisibleLocator(uploadVideoButton, '未找到“上传视频”按钮，请确认已进入视频发布页。', 15_000);
+    const fileChooserPromise = page.waitForEvent('filechooser', {
         timeout: 3_000
     }).catch(()=>null);
-    await creatorServiceLink.first().click();
-    let targetPage = await popupPromise ?? resolved.page;
-    let openedInNewPage = targetPage !== resolved.page;
-    try {
-        await waitForCreatorHome(targetPage);
-    } catch  {
-        const existingCreatorHomePage = getSessionPages(session).find((page)=>isCreatorHomeUrl(page.url()));
-        if (!existingCreatorHomePage) {
-            throw new Error(`点击“创作服务”后，未跳转到 ${CREATOR_HOME_URL}`);
-        }
-        targetPage = existingCreatorHomePage;
-        openedInNewPage = targetPage !== resolved.page;
+    await visibleUploadVideoButton.click();
+    const fileChooser = await fileChooserPromise;
+    if (fileChooser) {
+        await fileChooser.setFiles(videoPath);
+        return;
+    }
+    const videoFileInput = page.locator(`${VIDEO_FILE_INPUT_SELECTOR}[accept*="video"], ${VIDEO_FILE_INPUT_SELECTOR}`);
+    if (await videoFileInput.count() === 0) {
+        throw new Error('未找到视频文件输入框，请确认上传组件已正确加载。');
+    }
+    await videoFileInput.first().setInputFiles(videoPath);
+}
+async function uploadImageFiles(page, imagePaths) {
+    const uploadImageButton = page.locator(IMAGE_UPLOAD_BUTTON_SELECTOR).filter({
+        hasText: IMAGE_UPLOAD_BUTTON_TEXT
+    });
+    const visibleUploadImageButton = await requireVisibleLocator(uploadImageButton, '未找到“上传图片”按钮，请确认已进入图文发布页。', 15_000);
+    const fileChooserPromise = page.waitForEvent('filechooser', {
+        timeout: 3_000
+    }).catch(()=>null);
+    await visibleUploadImageButton.click();
+    const fileChooser = await fileChooserPromise;
+    if (fileChooser) {
+        await fileChooser.setFiles(imagePaths);
+        return;
+    }
+    const imageFileInput = page.locator(`${IMAGE_FILE_INPUT_SELECTOR}[accept*="image"], ${IMAGE_FILE_INPUT_SELECTOR}`);
+    if (await imageFileInput.count() === 0) {
+        throw new Error('未找到图片文件输入框，请确认上传组件已正确加载。');
+    }
+    await imageFileInput.first().setInputFiles(imagePaths);
+}
+async function waitForImagePublishPage(page) {
+    const imagePublishPage = page.locator(IMAGE_PUBLISH_PAGE_SELECTOR);
+    const visibleImagePublishPage = await requireVisibleLocator(imagePublishPage, '未等待到图文发布页，请确认图片上传成功。', 30_000);
+    await visibleImagePublishPage.waitFor({
+        state: 'visible',
+        timeout: 30_000
+    });
+}
+async function fillImageTitle(page, title) {
+    const imageTitleInput = page.locator(IMAGE_TITLE_INPUT_SELECTOR);
+    const visibleImageTitleInput = await requireVisibleLocator(imageTitleInput, '未找到图文标题输入框，请确认图文发布页已正确加载。', 15_000);
+    await visibleImageTitleInput.fill(title);
+    await page.waitForTimeout(200);
+}
+async function fillImageContent(page, content) {
+    const imageContentEditor = page.locator(IMAGE_CONTENT_EDITOR_SELECTOR);
+    const visibleImageContentEditor = await requireVisibleLocator(imageContentEditor, '未找到图文正文编辑器，请确认图文发布页已正确加载。', 15_000);
+    await visibleImageContentEditor.fill(content);
+    await page.waitForTimeout(200);
+}
+async function openArticleEditor(page) {
+    const articleNewButton = page.locator(ARTICLE_NEW_BUTTON_SELECTOR).filter({
+        hasText: ARTICLE_NEW_BUTTON_TEXT
+    });
+    const visibleArticleNewButton = await requireVisibleLocator(articleNewButton, '未找到“新的创作”按钮，请确认已进入长文发布页。', 15_000);
+    await visibleArticleNewButton.click();
+    await page.waitForTimeout(300);
+}
+async function fillArticleTitle(page, title) {
+    const articleTitleInput = page.locator(ARTICLE_TITLE_INPUT_SELECTOR);
+    const visibleArticleTitleInput = await requireVisibleLocator(articleTitleInput, '未找到长文标题输入框，请确认已进入长文编辑页。', 15_000);
+    await visibleArticleTitleInput.fill(title);
+    await page.waitForTimeout(200);
+}
+async function fillArticleContent(page, content) {
+    const articleContentEditor = page.locator(ARTICLE_CONTENT_EDITOR_SELECTOR);
+    const visibleArticleContentEditor = await requireVisibleLocator(articleContentEditor, '未找到长文正文编辑器，请确认已进入长文编辑页。', 15_000);
+    await visibleArticleContentEditor.fill(content);
+    await page.waitForTimeout(200);
+}
+async function preparePublishAssets(page, payload) {
+    if (payload.type === 'video') {
+        await uploadVideoFile(page, payload.videoPath);
+        await waitForImagePublishPage(page);
+        await fillImageTitle(page, payload.title);
+        await fillImageContent(page, payload.content);
+        return;
     }
-    return toPublishResult(target, {
-        pageUrl: targetPage.url(),
-        creatorHomeUrl: CREATOR_HOME_URL,
-        clickedCreatorService: true,
-        reusedCreatorHome: false,
-        openedInNewPage,
-        payload: payloadSummary,
-        message: '已进入创作服务首页，发布参数已校验。'
+    if (payload.type === 'image') {
+        await uploadImageFiles(page, payload.imagePaths);
+        await waitForImagePublishPage(page);
+        await fillImageTitle(page, payload.title);
+        await fillImageContent(page, payload.content);
+        return;
+    }
+    await openArticleEditor(page);
+    await fillArticleTitle(page, payload.title);
+    await fillArticleContent(page, payload.content);
+}
+async function finalizePublish(page, draft) {
+    const buttonText = draft ? SAVE_DRAFT_BUTTON_TEXT : PUBLISH_BUTTON_TEXT;
+    const publishActionButton = page.locator(PUBLISH_ACTION_BUTTON_SELECTOR).filter({
+        hasText: buttonText
     });
+    const visiblePublishActionButton = await requireVisibleLocator(publishActionButton, `未找到“${buttonText}”按钮，请确认发布页已正确加载。`, 15_000);
+    await visiblePublishActionButton.click();
+    await page.waitForTimeout(500);
+}
+export async function openRednotePublish(session, payload) {
+    const resolved = await resolvePublishPage(session);
+    let targetPage = resolved.page;
+    let clickedCreatorService = false;
+    let reusedCreatorHome = resolved.reusedCreatorHome || isCreatorHomeUrl(resolved.page.url());
+    let openedInNewPage = false;
+    if (!reusedCreatorHome) {
+        await hoverCreatorCenter(resolved.page);
+        const creatorServiceLink = resolved.page.locator(CREATOR_SERVICE_SELECTOR).filter({
+            hasText: '创作服务'
+        });
+        const visibleCreatorServiceLink = await requireVisibleLocator(creatorServiceLink, '未找到“创作服务”入口，请先打开小红书首页并确认账号已登录。');
+        const popupPromise = session.browserContext.waitForEvent('page', {
+            timeout: 3_000
+        }).catch(()=>null);
+        await visibleCreatorServiceLink.click();
+        targetPage = await popupPromise ?? resolved.page;
+        openedInNewPage = targetPage !== resolved.page;
+        try {
+            await waitForCreatorHome(targetPage);
+        } catch  {
+            const existingCreatorHomePage = getSessionPages(session).find((page)=>isCreatorHomeUrl(page.url()));
+            if (!existingCreatorHomePage) {
+                throw new Error(`点击“创作服务”后，未跳转到 ${CREATOR_HOME_URL}`);
+            }
+            targetPage = existingCreatorHomePage;
+            openedInNewPage = targetPage !== resolved.page;
+        }
+        clickedCreatorService = true;
+        reusedCreatorHome = false;
+    }
+    await openPublishComposer(targetPage, payload.type);
+    await preparePublishAssets(targetPage, payload);
+    await finalizePublish(targetPage, payload.draft);
+    return {
+        ok: true,
+        message: payload.draft ? '已完成发布页操作并点击“暂存离开”，内容已保存到草稿。' : '已完成发布页操作并点击“发布”。'
+    };
 }
 export async function runPublishCommand(values) {
     if (values.help || !hasPublishInputs(values)) {
@@ -359,7 +480,7 @@ export async function runPublishCommand(values) {
     const session = await createRednoteSession(target);
     try {
         await ensureRednoteLoggedIn(target, 'publishing content', session);
-        const result = await openRednotePublish(target, session, payload);
+        const result = await openRednotePublish(session, payload);
         printJson(result);
     } finally{
         disconnectRednoteSession(session);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skills-store/rednote",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "private": false,
   "type": "module",
   "bin": {
@@ -45,6 +45,15 @@
     "bun": ">=1.0.0"
   },
   "description": "Xiaohongshu automation CLI for Skills Router",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skills-router/skills-store.git",
+    "directory": "packages/rednote"
+  },
+  "homepage": "https://github.com/skills-router/skills-store/tree/main/packages/rednote",
+  "bugs": {
+    "url": "https://github.com/skills-router/skills-store/issues"
+  },
   "publishConfig": {
     "access": "public"
   },

package/README.md

@@ -1,35 +0,0 @@
-# rednote
-
-A Xiaohongshu (RED) automation CLI.
-
-## Run with npx
-
-```bash
-npx -y @skills-store/rednote browser list
-npx -y @skills-store/rednote browser create --name seller-main --browser chrome
-npx -y @skills-store/rednote browser connect --instance seller-main
-npx -y @skills-store/rednote login --instance seller-main
-npx -y @skills-store/rednote search --instance seller-main --keyword 护肤
-npx -y @skills-store/rednote get-feed-detail --instance seller-main --url "https://www.xiaohongshu.com/explore/<id>?xsec_token=<token>"
-npx -y @skills-store/rednote get-profile --instance seller-main --id USER_ID
-```
-
-## Install globally
-
-```bash
-npm install -g @skills-store/rednote
-```
-
-## Storage
-
-The CLI stores custom browser instances and metadata under:
-
-```text
-~/.skills-router/rednote/instances
-```
-
-Run this to inspect the current environment and exact resolved paths:
-
-```bash
-npx -y @skills-store/rednote env
-```

package/bin/rednote.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-import { runRootCli } from '../dist/index.js';
-import { stringifyError } from '../dist/utils/browser-cli.js';
-
-try {
-  await runRootCli(process.argv.slice(2));
-} catch (error) {
-  process.stderr.write(
-    `${JSON.stringify(
-      {
-        ok: false,
-        error: stringifyError(error),
-      },
-      null,
-      2,
-    )}\n`,
-  );
-  process.exit(1);
-}