rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/adapters/platform/rednote/runtime_publisher.py

@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+import os
+import random
+import time
+from datetime import datetime
+from typing import Optional
+
+from loguru import logger
+from playwright.async_api import Page, TimeoutError
+
+from rednote_cli._runtime.common.errors import InvalidPublishParameterError
+
+URL_OF_PUBLISH = "https://creator.xiaohongshu.com/publish/publish?source=official"
+
+
+class RednotePublisher:
+    """
+    图文发布流程实现。
+    业务逻辑严格对齐 publish_note.py 中 PublishAction。
+    """
+
+    def __init__(self, page: Page):
+        self.page = page
+
+    async def _rand_sleep(self, low: float, high: float) -> None:
+        await self.page.wait_for_timeout(int(random.uniform(low, high) * 1000))
+
+    async def open_publish_page(self, tab_name: str = "上传图文") -> None:
+        await self.page.goto(URL_OF_PUBLISH, wait_until="domcontentloaded", timeout=300_000)
+        await self.page.wait_for_timeout(2000)
+        await self.page.locator("div.upload-content").first.wait_for(state="visible", timeout=30_000)
+        await self.must_click_publish_tab(tab_name)
+        await self.page.wait_for_timeout(1000)
+
+    async def remove_pop_cover(self) -> None:
+        pop = self.page.locator("div.d-popover")
+        if await pop.count() > 0:
+            await self.page.evaluate(
+                """
+                () => {
+                  const node = document.querySelector('div.d-popover');
+                  if (node) node.remove();
+                }
+                """
+            )
+        x = 380 + random.randint(0, 100)
+        y = 20 + random.randint(0, 60)
+        await self.page.mouse.click(x, y)
+
+    async def must_click_publish_tab(self, tab_name: str) -> None:
+        deadline = time.time() + 15
+        while time.time() < deadline:
+            tabs = self.page.locator("div.creator-tab")
+            count = await tabs.count()
+            for i in range(count):
+                tab = tabs.nth(i)
+                if not await tab.is_visible():
+                    continue
+
+                text = (await tab.inner_text() or "").strip()
+                if text != tab_name:
+                    continue
+
+                blocked = await tab.evaluate(
+                    """
+                    (el) => {
+                      const rect = el.getBoundingClientRect();
+                      if (rect.width === 0 || rect.height === 0) return true;
+                      const x = rect.left + rect.width / 2;
+                      const y = rect.top + rect.height / 2;
+                      const target = document.elementFromPoint(x, y);
+                      return !(target === el || el.contains(target));
+                    }
+                    """
+                )
+                if blocked:
+                    await self.remove_pop_cover()
+                    await self.page.wait_for_timeout(200)
+                    continue
+
+                await tab.click()
+                return
+
+            await self.page.wait_for_timeout(200)
+
+        raise TimeoutError(f"没有找到发布 TAB: {tab_name}")
+
+    async def upload_images(self, image_paths: list[str]) -> list[str]:
+        if not image_paths:
+            raise InvalidPublishParameterError("没有可上传的本地图片")
+
+        valid_paths: list[str] = []
+        for p in image_paths:
+            if os.path.exists(p):
+                valid_paths.append(p)
+                logger.info(f"有效图片: {p}")
+            else:
+                logger.warning(f"图片文件不存在，跳过: {p}")
+
+        if not valid_paths:
+            raise InvalidPublishParameterError("没有可上传的本地图片")
+
+        for i, path in enumerate(valid_paths):
+            selector = ".upload-input" if i == 0 else "input[type='file']"
+            file_input = self.page.locator(selector).first
+            await file_input.set_input_files(path)
+            logger.info(f"图片已提交上传: index={i + 1}, path={path}")
+            await self.wait_for_upload_complete(i + 1)
+            await self._rand_sleep(0.8, 1.3)
+
+        return valid_paths
+
+    async def wait_for_upload_complete(self, expected_count: int) -> None:
+        start = time.time()
+        last = expected_count - 1
+        while time.time() - start < 60:
+            current = await self.page.locator(".img-preview-area .pr").count()
+            if current != last:
+                logger.info(f"等待图片上传: current={current}, expected={expected_count}")
+                last = current
+            if current >= expected_count:
+                logger.info(f"图片上传完成: count={current}")
+                return
+            await self.page.wait_for_timeout(500)
+        raise TimeoutError(f"第 {expected_count} 张图片上传超时(60s)")
+
+    async def wait_for_publish_button_clickable(self, max_wait_seconds: int = 600):
+        start = time.time()
+        selector = ".publish-page-publish-btn button.bg-red"
+        logger.info("开始等待发布按钮可点击（视频）")
+        while time.time() - start < max_wait_seconds:
+            btn = self.page.locator(selector).first
+            if await btn.count() > 0 and await btn.is_visible():
+                disabled = await btn.get_attribute("disabled")
+                cls = await btn.get_attribute("class") or ""
+                if disabled is None and "disabled" not in cls:
+                    return btn
+                if disabled is None:
+                    return btn
+            await self.page.wait_for_timeout(1000)
+        raise TimeoutError("等待发布按钮可点击超时")
+
+    async def upload_video(self, video_path: str) -> str:
+        if not os.path.exists(video_path):
+            raise InvalidPublishParameterError(f"视频文件不存在: {video_path}")
+
+        file_input = self.page.locator(".upload-input").first
+        if await file_input.count() == 0:
+            file_input = self.page.locator("input[type='file']").first
+        if await file_input.count() == 0:
+            raise InvalidPublishParameterError("未找到视频上传输入框")
+
+        await file_input.set_input_files(video_path)
+        await self.wait_for_publish_button_clickable(max_wait_seconds=600)
+        logger.info(f"视频上传/处理完成，发布按钮可点击: {video_path}")
+        return video_path
+
+    async def get_content_element(self):
+        editor = self.page.locator("div.ql-editor").first
+        if await editor.count() > 0:
+            return editor
+
+        handle = await self.page.evaluate_handle(
+            """
+            () => {
+              const ps = Array.from(document.querySelectorAll('p'));
+              const placeholder = ps.find((p) => (p.getAttribute('data-placeholder') || '').includes('输入正文描述'));
+              if (!placeholder) return null;
+              let cur = placeholder;
+              for (let i = 0; i < 5 && cur; i++) {
+                cur = cur.parentElement;
+                if (!cur) break;
+                if ((cur.getAttribute('role') || '') === 'textbox') return cur;
+              }
+              return null;
+            }
+            """
+        )
+        elem = handle.as_element()
+        if elem is None:
+            raise InvalidPublishParameterError("没有找到正文输入框")
+        return elem
+
+    async def check_title_max_length(self) -> None:
+        suffix = self.page.locator("div.title-container div.max_suffix").first
+        if await suffix.count() == 0:
+            return
+        text = (await suffix.inner_text() or "").strip()
+        if "/" not in text:
+            raise InvalidPublishParameterError(f"标题长度超过限制: {text}")
+        curr, max_len = text.split("/", 1)
+        raise InvalidPublishParameterError(f"当前输入长度为{curr}，最大长度为{max_len}")
+
+    async def check_content_max_length(self) -> None:
+        err = self.page.locator("div.edit-container div.length-error").first
+        if await err.count() == 0:
+            return
+        text = (await err.inner_text() or "").strip()
+        if "/" not in text:
+            raise InvalidPublishParameterError(f"正文长度超过限制: {text}")
+        curr, max_len = text.split("/", 1)
+        raise InvalidPublishParameterError(f"当前输入长度为{curr}，最大长度为{max_len}")
+
+    async def input_tags(self, content_elem, tags: list[str]) -> None:
+        if not tags:
+            return
+
+        await content_elem.click()
+        await self.page.wait_for_timeout(1000)
+        for _ in range(20):
+            await self.page.keyboard.press("ArrowDown")
+            await self.page.wait_for_timeout(10)
+        await self.page.keyboard.press("Enter")
+        await self.page.keyboard.press("Enter")
+        await self.page.wait_for_timeout(1000)
+
+        for tag in tags:
+            clean_tag = tag.lstrip("#")
+            await self.page.keyboard.type("#", delay=80)
+            for ch in clean_tag:
+                await self.page.keyboard.type(ch, delay=50)
+            await self.page.wait_for_timeout(1000)
+            first_item = self.page.locator("#creator-editor-topic-container .item").first
+            if await first_item.count() > 0:
+                await first_item.click()
+                logger.info(f"成功点击标签联想: {clean_tag}")
+            else:
+                await self.page.keyboard.type(" ", delay=50)
+                logger.info(f"未命中标签联想，直接空格收尾: {clean_tag}")
+            await self.page.wait_for_timeout(500)
+
+    async def set_schedule_publish(self, schedule_time: datetime) -> None:
+        switch = self.page.locator(".post-time-wrapper .d-switch").first
+        await switch.click()
+        await self.page.wait_for_timeout(800)
+
+        date_text = schedule_time.strftime("%Y-%m-%d %H:%M")
+        date_input = self.page.locator(".date-picker-container input").first
+        await date_input.click()
+        if os.name == "nt":
+            await self.page.keyboard.press("Control+A")
+        else:
+            await self.page.keyboard.press("Meta+A")
+            await self.page.keyboard.press("Control+A")
+        await self.page.keyboard.type(date_text, delay=40)
+        await self.page.wait_for_timeout(500)
+        logger.info(f"定时发布时间已设置: {date_text}")
+
+    async def submit_publish(
+            self,
+            title: str,
+            content: str,
+            tags: list[str],
+            schedule_time: Optional[datetime],
+    ) -> None:
+        title_input = self.page.locator("div.d-input input").first
+        await title_input.click()
+        await title_input.fill(title)
+        await self.page.wait_for_timeout(500)
+        await self.check_title_max_length()
+        logger.info("标题长度检查通过")
+
+        await self.page.wait_for_timeout(1000)
+        content_elem = await self.get_content_element()
+        await content_elem.click()
+        await self.page.keyboard.type(content, delay=25)
+        await self.input_tags(content_elem, tags)
+
+        await self.page.wait_for_timeout(1000)
+        await self.check_content_max_length()
+        logger.info("正文长度检查通过")
+
+        if schedule_time is not None:
+            await self.set_schedule_publish(schedule_time)
+
+        submit_btn = self.page.locator(".publish-page-publish-btn button.bg-red").first
+        await submit_btn.click()
+        await self.page.wait_for_timeout(3000)
+
+    async def submit_publish_video(
+            self,
+            title: str,
+            content: str,
+            tags: list[str],
+            schedule_time: Optional[datetime],
+    ) -> None:
+        title_input = self.page.locator("div.d-input input").first
+        await title_input.click()
+        await title_input.fill(title)
+        await self.page.wait_for_timeout(500)
+        await self.check_title_max_length()
+        logger.info("标题长度检查通过")
+
+        await self.page.wait_for_timeout(1000)
+        content_elem = await self.get_content_element()
+        await content_elem.click()
+        await self.page.keyboard.type(content, delay=25)
+        await self.input_tags(content_elem, tags)
+
+        await self.page.wait_for_timeout(1000)
+        await self.check_content_max_length()
+        logger.info("正文长度检查通过")
+
+        if schedule_time is not None:
+            await self.set_schedule_publish(schedule_time)
+
+        btn = await self.wait_for_publish_button_clickable(max_wait_seconds=600)
+        await btn.click()
+        await self.page.wait_for_timeout(3000)
+
+    async def publish_image_note(
+            self,
+            image_list: list[str],
+            title: str = "",
+            content: str = "",
+            tags: Optional[list[str]] = None,
+            schedule_at: Optional[datetime] = None,
+    ) -> dict:
+        if not image_list:
+            raise InvalidPublishParameterError("图片不能为空")
+
+        await self.open_publish_page("上传图文")
+        uploaded = await self.upload_images(image_list)
+
+        tags = tags or []
+        normalized_tags = tags[:10] if len(tags) > 10 else tags
+        if len(tags) > 10:
+            logger.warning("标签数量超过 10，仅保留前 10 个")
+
+        await self.submit_publish(
+            title=title,
+            content=content,
+            tags=normalized_tags,
+            schedule_time=schedule_at,
+        )
+        return {
+            "target": "image",
+            "uploaded_count": len(uploaded),
+            "status": "submitted",
+        }
+
+    async def publish_video_note(
+            self,
+            video_path: str,
+            title: str = "",
+            content: str = "",
+            tags: Optional[list[str]] = None,
+            schedule_at: Optional[datetime] = None,
+    ) -> dict:
+        if not video_path:
+            raise InvalidPublishParameterError("视频不能为空")
+
+        await self.open_publish_page("上传视频")
+        uploaded = await self.upload_video(video_path)
+        await self._rand_sleep(0.8, 1.3)
+
+        tags = tags or []
+        normalized_tags = tags[:10] if len(tags) > 10 else tags
+        if len(tags) > 10:
+            logger.warning("标签数量超过 10，仅保留前 10 个")
+
+        await self.submit_publish_video(
+            title=title,
+            content=content,
+            tags=normalized_tags,
+            schedule_time=schedule_at,
+        )
+        return {
+            "target": "video",
+            "uploaded_count": 1 if uploaded else 0,
+            "status": "submitted",
+        }

rednote_cli/adapters/platform/rednote/runtime_registration.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from rednote_cli._runtime.common.enums import Platform
+from rednote_cli._runtime.platforms.factory import PlatformFactory, PlatformLoginProfile
+from rednote_cli.adapters.platform.rednote.runtime_extractor import RednoteExtractor
+
+
+def register_rednote_runtime() -> None:
+    PlatformFactory.register_platform(
+        Platform.REDNOTE,
+        extractor_cls=RednoteExtractor,
+        login_profile=PlatformLoginProfile(
+            login_url="https://www.xiaohongshu.com/explore",
+            login_selector=".main-container .user .link-wrapper .channel",
+            qr_selector=".login-container .qrcode-img",
+            account_id_field="red_id",
+            nickname_field="nickname",
+            guest_field="guest",
+        ),
+    )

rednote_cli/application/__init__.py

@@ -0,0 +1 @@
+"""Application layer."""

rednote_cli/application/dto/__init__.py

@@ -0,0 +1 @@
+"""DTO models for CLI inputs and outputs."""

rednote_cli/application/dto/input_models.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from rednote_cli.domain.note_search_filters import normalize_filter_value
+
+
+class CommonInput(BaseModel):
+    trace_id: str | None = None
+    account_uid: str | None = None
+
+
+class NoteSearchInput(CommonInput):
+    keyword: str = Field(min_length=1)
+    size: int = Field(default=20, ge=1, le=100)
+    sort_by: str | None = None
+    note_type: str | None = None
+    publish_time: str | None = None
+    search_scope: str | None = None
+    location: str | None = None
+
+    @field_validator("sort_by", mode="before")
+    @classmethod
+    def _normalize_sort_by(cls, value: str | None) -> str | None:
+        return normalize_filter_value("sort_by", value)
+
+    @field_validator("note_type", mode="before")
+    @classmethod
+    def _normalize_note_type(cls, value: str | None) -> str | None:
+        return normalize_filter_value("note_type", value)
+
+    @field_validator("publish_time", mode="before")
+    @classmethod
+    def _normalize_publish_time(cls, value: str | None) -> str | None:
+        return normalize_filter_value("publish_time", value)
+
+    @field_validator("search_scope", mode="before")
+    @classmethod
+    def _normalize_search_scope(cls, value: str | None) -> str | None:
+        return normalize_filter_value("search_scope", value)
+
+    @field_validator("location", mode="before")
+    @classmethod
+    def _normalize_location(cls, value: str | None) -> str | None:
+        return normalize_filter_value("location", value)
+
+
+class UserSearchInput(CommonInput):
+    keyword: str = Field(min_length=1)
+    size: int = Field(default=20, ge=1, le=100)
+
+
+class UserGetInput(CommonInput):
+    user_id: str = Field(min_length=1)
+    xsec_token: str | None = None
+    xsec_source: str | None = "pc_feed"
+
+
+class NoteGetInput(CommonInput):
+    note_id: str = Field(min_length=1)
+    xsec_token: str | None = None
+    xsec_source: str | None = "pc_feed"
+    comment_size: int = Field(default=10, ge=1, le=100)
+    sub_comment_size: int = Field(default=5, ge=1, le=50)
+
+
+class PublishNoteInput(CommonInput):
+    target: str = Field(min_length=1)
+    image_list: list[str] = Field(default_factory=list)
+    video: str | None = None
+    title: str = ""
+    content: str = ""
+    tags: list[str] = Field(default_factory=list)
+    schedule_at: str | None = None
+
+    @field_validator("image_list")
+    @classmethod
+    def _validate_images(cls, value: list[str]) -> list[str]:
+        cleaned = [v.strip() for v in value if isinstance(v, str) and v.strip()]
+        return cleaned
+
+    @field_validator("video", mode="before")
+    @classmethod
+    def _validate_video(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError("video 必须是字符串")
+        text = value.strip()
+        return text or None
+
+    @model_validator(mode="after")
+    def _validate_publish_target_media(self) -> "PublishNoteInput":
+        target_text = self.target.strip().lower()
+        if target_text == "image" and not self.image_list:
+            raise ValueError("image_list 至少包含一个有效项")
+        if target_text == "video" and not self.video:
+            raise ValueError("video 不能为空")
+        return self
+
+
+class AccountListInput(CommonInput):
+    only_active: bool = True
+
+
+class AuthLoginInput(CommonInput):
+    pass
+
+
+class GenericInputEnvelope(BaseModel):
+    command: str
+    params: dict[str, Any]
+    trace_id: str | None = None
+    account_uid: str | None = None
+
+
+class PublishScheduleModel(BaseModel):
+    schedule_at: datetime

rednote_cli/application/dto/output_models.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class OutputMeta(BaseModel):
+    trace_id: str
+    duration_ms: int = Field(ge=0)
+    platform: str | None = None
+    account_uid: str | None = None
+
+
+class SuccessOutput(BaseModel):
+    ok: bool = True
+    command: str
+    timestamp: str
+    data: Any
+    meta: OutputMeta
+
+
+class ErrorDetail(BaseModel):
+    code: str
+    message: str
+    details: dict[str, Any] | None = None
+
+
+class ErrorOutput(BaseModel):
+    ok: bool = False
+    command: str
+    timestamp: str
+    error: ErrorDetail
+    meta: OutputMeta
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def build_success_output(
+    *,
+    command: str,
+    data: Any,
+    trace_id: str,
+    duration_ms: int,
+    platform: str | None = None,
+    account_uid: str | None = None,
+) -> SuccessOutput:
+    return SuccessOutput(
+        command=command,
+        timestamp=_now_iso(),
+        data=data,
+        meta=OutputMeta(
+            trace_id=trace_id,
+            duration_ms=duration_ms,
+            platform=platform,
+            account_uid=account_uid,
+        ),
+    )
+
+
+def build_error_output(
+    *,
+    command: str,
+    code: str,
+    message: str,
+    trace_id: str,
+    duration_ms: int,
+    details: dict[str, Any] | None = None,
+) -> ErrorOutput:
+    return ErrorOutput(
+        command=command,
+        timestamp=_now_iso(),
+        error=ErrorDetail(code=code, message=message, details=details),
+        meta=OutputMeta(trace_id=trace_id, duration_ms=duration_ms),
+    )

rednote_cli/application/use_cases/__init__.py

@@ -0,0 +1 @@
+"""Use cases for CLI commands."""

rednote_cli/application/use_cases/account_list.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.persistence.file_account_repo import FileAccountRepository
+from rednote_cli.infra.platforms import REDNOTE_PLATFORM
+
+
+def execute_account_list(only_active: bool = True) -> list[dict]:
+    repo = FileAccountRepository()
+    return repo.list_accounts(platform=REDNOTE_PLATFORM, only_active=only_active)

rednote_cli/application/use_cases/account_mutation.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.persistence.file_account_repo import FileAccountRepository
+from rednote_cli.infra.platforms import REDNOTE_PLATFORM
+
+
+def execute_account_activate(account_uid: str) -> dict:
+    repo = FileAccountRepository()
+    changed = repo.activate(platform=REDNOTE_PLATFORM, account_uid=account_uid)
+    return {"changed": changed, "platform": REDNOTE_PLATFORM, "account_uid": account_uid, "active": True}
+
+
+def execute_account_deactivate(account_uid: str) -> dict:
+    repo = FileAccountRepository()
+    changed = repo.deactivate(platform=REDNOTE_PLATFORM, account_uid=account_uid)
+    return {"changed": changed, "platform": REDNOTE_PLATFORM, "account_uid": account_uid, "active": False}
+
+
+def execute_account_delete(account_uid: str) -> dict:
+    repo = FileAccountRepository()
+    deleted = repo.delete(platform=REDNOTE_PLATFORM, account_uid=account_uid)
+    return {"deleted": deleted, "platform": REDNOTE_PLATFORM, "account_uid": account_uid}