rednote-cli 0.1.3__tar.gz → 0.1.5__tar.gz

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rednote-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: Rednote platform CLI
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -61,10 +61,12 @@ rednote-cli search note --keyword 旅行 --size 10 --sort-by latest --note-type
 rednote-cli search note --keyword <kw> [--size N] [--sort-by <comprehensive|latest|most_liked|most_commented|most_favorited>] [--note-type <all|video|image_text>] [--publish-time <all|day|week|half_year>] [--search-scope <all|viewed|unviewed|following>] [--location <all|local|nearby>] [--account <user_id>] [--input <file|->]
 
 rednote-cli note --note-id <id> [--xsec-token t] [--xsec-source src] [--comment-size N] [--sub-comment-size N] [--account <user_id>] [--input <file|->]
+  # 如上游已拿到 xsec_token，默认优先携带；发现页里的笔记=pc_feed，搜索页里的笔记=pc_search，达人收藏页里的笔记=pc_collect，达人点赞页里的笔记=pc_like，达人笔记页里的笔记=pc_user
 
 rednote-cli search user --keyword <kw> [--size N] [--account <user_id>] [--input <file|->]
 
 rednote-cli user --user-id <id> [--xsec-token t] [--xsec-source src] [--account <user_id>] [--input <file|->]
+  # 如上游已拿到 xsec_token，默认优先携带；发现页里的达人=pc_feed，搜索页里的达人=pc_search，达人收藏页里的达人=pc_collect，达人点赞页里的达人=pc_like，笔记页里的达人=pc_note
 
 rednote-cli user self --account <user_id>
 
@@ -84,6 +86,10 @@ rednote-cli publish --target video --account <account_uid> [--video <path-or-url
 - `user`
 - `publish`
 
+`note` 的 `--input` 里如果带 `xsec_source`，它表示笔记来源：发现页笔记=`pc_feed`，搜索页笔记=`pc_search`，达人收藏页笔记=`pc_collect`，达人点赞页笔记=`pc_like`，达人笔记页笔记=`pc_user`。
+
+`user` 的 `--input` 里如果带 `xsec_source`，它表示达人来源：发现页达人=`pc_feed`，搜索页达人=`pc_search`，达人收藏页达人=`pc_collect`，达人点赞页达人=`pc_like`，笔记页达人=`pc_note`。
+
 不支持 `--input` 的命令：
 - `init runtime`
 - `doctor run`

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/README.md

@@ -54,10 +54,12 @@ rednote-cli search note --keyword 旅行 --size 10 --sort-by latest --note-type
 rednote-cli search note --keyword <kw> [--size N] [--sort-by <comprehensive|latest|most_liked|most_commented|most_favorited>] [--note-type <all|video|image_text>] [--publish-time <all|day|week|half_year>] [--search-scope <all|viewed|unviewed|following>] [--location <all|local|nearby>] [--account <user_id>] [--input <file|->]
 
 rednote-cli note --note-id <id> [--xsec-token t] [--xsec-source src] [--comment-size N] [--sub-comment-size N] [--account <user_id>] [--input <file|->]
+  # 如上游已拿到 xsec_token，默认优先携带；发现页里的笔记=pc_feed，搜索页里的笔记=pc_search，达人收藏页里的笔记=pc_collect，达人点赞页里的笔记=pc_like，达人笔记页里的笔记=pc_user
 
 rednote-cli search user --keyword <kw> [--size N] [--account <user_id>] [--input <file|->]
 
 rednote-cli user --user-id <id> [--xsec-token t] [--xsec-source src] [--account <user_id>] [--input <file|->]
+  # 如上游已拿到 xsec_token，默认优先携带；发现页里的达人=pc_feed，搜索页里的达人=pc_search，达人收藏页里的达人=pc_collect，达人点赞页里的达人=pc_like，笔记页里的达人=pc_note
 
 rednote-cli user self --account <user_id>
 
@@ -77,6 +79,10 @@ rednote-cli publish --target video --account <account_uid> [--video <path-or-url
 - `user`
 - `publish`
 
+`note` 的 `--input` 里如果带 `xsec_source`，它表示笔记来源：发现页笔记=`pc_feed`，搜索页笔记=`pc_search`，达人收藏页笔记=`pc_collect`，达人点赞页笔记=`pc_like`，达人笔记页笔记=`pc_user`。
+
+`user` 的 `--input` 里如果带 `xsec_source`，它表示达人来源：发现页达人=`pc_feed`，搜索页达人=`pc_search`，达人收藏页达人=`pc_collect`，达人点赞页达人=`pc_like`，笔记页达人=`pc_note`。
+
 不支持 `--input` 的命令：
 - `init runtime`
 - `doctor run`

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rednote-cli"
-version = "0.1.3"
+version = "0.1.5"
 description = "Rednote platform CLI"
 readme = "README.md"
 requires-python = ">=3.12"

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/src/rednote_cli/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.3"
+__version__ = "0.1.5"

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/src/rednote_cli/_runtime/common/errors.py

@@ -1,6 +1,10 @@
 class PublishNoteException(Exception):
     """Base exception for publish-note workflow."""
 
+    def __init__(self, message: str = "", details: dict | None = None):
+        super().__init__(message)
+        self.details = details
+
 
 class InvalidPublishParameterError(PublishNoteException, ValueError):
     """Raised when publish-note inputs are invalid."""

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/src/rednote_cli/_runtime/core/account_manager.py

@@ -12,6 +12,7 @@ from rednote_cli._runtime.common.enums import Platform
 from rednote_cli._runtime.core.browser.manager import stealth_async
 from rednote_cli._runtime.core.database.manager import DatabaseManager
 from rednote_cli._runtime.platforms.factory import PlatformFactory
+from rednote_cli._runtime.platforms.rednote import build_unknown_issue, detect_issue_from_page
 
 
 class AccountLeaseManager:
@@ -162,6 +163,83 @@ class AccountManager:
     def get_login_profile(platform_enum: Platform):
         return PlatformFactory.get_login_profile(platform_enum)
 
+    @staticmethod
+    async def _prepare_remote_login_screenshot(
+        page,
+        *,
+        login_url: str,
+        qr_selector: str,
+        screenshot_file: Path,
+        mode: str,
+        timeout_seconds: int,
+        account_uid: str | None,
+        emit_progress: Callable[[str], None],
+    ) -> dict:
+        from playwright.async_api import TimeoutError as PlaywrightTimeoutError
+
+        max_attempts = 2
+        last_issue = None
+
+        for attempt in range(1, max_attempts + 1):
+            qr = page.locator(qr_selector).first
+            try:
+                await qr.wait_for(state="visible", timeout=15_000)
+                await page.screenshot(path=str(screenshot_file), full_page=False)
+                screenshot_path = str(screenshot_file.resolve())
+                logger.info(f"Remote login screenshot saved: {screenshot_path}")
+                emit_progress(
+                    "login.qr_ready",
+                    mode=mode,
+                    login_url=login_url,
+                    screenshot_path=screenshot_path,
+                    timeout_seconds=timeout_seconds,
+                    account_uid=account_uid,
+                )
+                return {
+                    "ready": True,
+                    "screenshot_path": screenshot_path,
+                    "issue": None,
+                }
+            except PlaywrightTimeoutError:
+                logger.warning("QR element not found before screenshot, analyzing page state.")
+
+            issue = await detect_issue_from_page(page, include_body=True)
+            if issue is None:
+                issue = build_unknown_issue(
+                    source="page",
+                    failure_reason="登录二维码未就绪",
+                    next_action="请刷新页面后重试登录",
+                )
+            last_issue = issue
+            logger.warning(
+                "Remote login issue detected: "
+                f"{issue.reason_code} source={issue.source} retry={issue.retry_recommended}"
+            )
+            if issue.retry_recommended and attempt < max_attempts:
+                await page.reload(wait_until="domcontentloaded")
+                await page.wait_for_timeout(1500)
+                continue
+            break
+
+        await page.screenshot(path=str(screenshot_file), full_page=False)
+        screenshot_path = str(screenshot_file.resolve())
+        issue_details = last_issue.to_details() if last_issue is not None else build_unknown_issue().to_details()
+        logger.info(f"Remote login screenshot saved: {screenshot_path}")
+        emit_progress(
+            "login.issue_detected",
+            mode=mode,
+            login_url=login_url,
+            screenshot_path=screenshot_path,
+            timeout_seconds=timeout_seconds,
+            account_uid=account_uid,
+            issue=issue_details,
+        )
+        return {
+            "ready": False,
+            "screenshot_path": screenshot_path,
+            "issue": last_issue,
+        }
+
     @staticmethod
     async def login_and_add_account(
         platform_enum: Platform,
@@ -255,21 +333,25 @@ class AccountManager:
                     if mode == "remote":
                         screenshot_file = AccountManager._resolve_screenshot_path(screenshot_path)
                         screenshot_file.parent.mkdir(parents=True, exist_ok=True)
-                        try:
-                            await page.wait_for_selector(profile.qr_selector, timeout=15_000)
-                        except PlaywrightTimeoutError:
-                            logger.warning("QR element not found before screenshot, continue anyway.")
-                        await page.screenshot(path=str(screenshot_file), full_page=False)
-                        result["screenshot_path"] = str(screenshot_file.resolve())
-                        logger.info(f"Remote login screenshot saved: {result['screenshot_path']}")
-                        _emit_progress(
-                            "login.qr_ready",
-                            mode=mode,
+                        remote_state = await AccountManager._prepare_remote_login_screenshot(
+                            page,
                             login_url=profile.login_url,
-                            screenshot_path=result["screenshot_path"],
+                            qr_selector=profile.qr_selector,
+                            screenshot_file=screenshot_file,
+                            mode=mode,
                             timeout_seconds=timeout_seconds,
                             account_uid=result["account_uid"],
+                            emit_progress=_emit_progress,
                         )
+                        result["screenshot_path"] = remote_state["screenshot_path"]
+                        if not remote_state["ready"]:
+                            issue = remote_state.get("issue") or build_unknown_issue()
+                            result["reason"] = "login_issue"
+                            result["message"] = (
+                                f"登录失败: {issue.failure_reason}，{issue.next_action}"
+                            )
+                            result["details"] = issue.to_details()
+                            return result
 
                     logger.info("Please complete login in the browser...")
                     try:

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/src/rednote_cli/_runtime/platforms/base.py

@@ -9,9 +9,20 @@ from yt_dlp import YoutubeDL
 from yt_dlp.extractor.common import InfoExtractor
 
 
-class RiskControlException(Exception):
+class PlatformActionableError(Exception):
+    """Exception carrying structured details for upstream/platform issues."""
+
+    def __init__(self, message: str = "", *, details: dict | None = None, code: str = "INTERNAL_ERROR"):
+        super().__init__(message)
+        self.details = details
+        self.code = code
+
+
+class RiskControlException(PlatformActionableError):
     """Exception raised when platform risk control is detected."""
-    pass
+
+    def __init__(self, message: str = "命中风控", *, details: dict | None = None):
+        super().__init__(message, details=details, code="RISK_CONTROL_TRIGGERED")
 
 
 class RobustnessMixin:

rednote-cli-0.1.5/src/rednote_cli/_runtime/platforms/rednote/__init__.py

@@ -0,0 +1,17 @@
+from rednote_cli._runtime.platforms.rednote.issues import (
+    RednoteIssue,
+    build_unknown_issue,
+    classify_issue_from_text,
+    collect_visible_feedback_texts,
+    detect_issue_from_page,
+    detect_issue_from_texts,
+)
+
+__all__ = [
+    "RednoteIssue",
+    "build_unknown_issue",
+    "classify_issue_from_text",
+    "collect_visible_feedback_texts",
+    "detect_issue_from_page",
+    "detect_issue_from_texts",
+]

rednote-cli-0.1.5/src/rednote_cli/_runtime/platforms/rednote/issues.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from playwright.async_api import Page
+
+
+VISIBLE_FEEDBACK_SELECTORS = (
+    "[role='alert']",
+    ".d-message-notice",
+    ".d-message-notice-content",
+    ".d-message__content",
+    ".d-modal",
+    ".d-dialog",
+    ".toast",
+)
+
+
+@dataclass(frozen=True)
+class RednoteIssue:
+    failure_type: str
+    reason_code: str
+    failure_reason: str
+    next_action: str
+    agent_action: str
+    source: str
+    retry_recommended: bool = False
+    cli_code: str = "INTERNAL_ERROR"
+    observed_text: str = ""
+
+    def to_details(self) -> dict:
+        return {
+            "failure_type": self.failure_type,
+            "failure_reason": self.failure_reason,
+            "next_action": self.next_action,
+            "retry_recommended": self.retry_recommended,
+            "agent_action": self.agent_action,
+        }
+
+
+_ISSUE_RULES: tuple[dict, ...] = (
+    {
+        "markers": ("未绑定手机号",),
+        "failure_type": "PHONE_NOT_BOUND",
+        "reason_code": "PHONE_NOT_BOUND",
+        "next_action": "请给账号绑定手机号",
+        "agent_action": "REQUEST_USER_ACTION",
+        "retry_recommended": False,
+        "cli_code": "INTERNAL_ERROR",
+    },
+    {
+        "markers": ("请扫码通过验证", "请通过验证", "验证码"),
+        "failure_type": "VERIFICATION_REQUIRED",
+        "reason_code": "VERIFICATION_REQUIRED",
+        "next_action": "请使用已登录小红书 APP 扫码完成验证",
+        "agent_action": "REQUEST_USER_ACTION",
+        "retry_recommended": False,
+        "cli_code": "RISK_CONTROL_TRIGGERED",
+    },
+    {
+        "markers": ("薯队长遇到了点小麻烦",),
+        "failure_type": "RISK_CONTROL",
+        "reason_code": "CAPTAIN_POTATO",
+        "next_action": "请暂停当前操作，稍后重试或联系开发者",
+        "agent_action": "STOP",
+        "retry_recommended": False,
+        "cli_code": "RISK_CONTROL_TRIGGERED",
+    },
+    {
+        "markers": ("IP存在风险", "安全限制"),
+        "failure_type": "NETWORK_ENV_RISK",
+        "reason_code": "IP_RISK",
+        "next_action": "请切换可靠网络环境后重试",
+        "agent_action": "STOP",
+        "retry_recommended": False,
+        "cli_code": "RISK_CONTROL_TRIGGERED",
+    },
+    {
+        "markers": ("未连接到服务器，刷新一下试试",),
+        "failure_type": "TRANSIENT_NETWORK",
+        "reason_code": "SERVER_DISCONNECTED",
+        "next_action": "请刷新页面后重试当前步骤",
+        "agent_action": "RETRY_LATER",
+        "retry_recommended": True,
+        "cli_code": "INTERNAL_ERROR",
+    },
+    {
+        "markers": ("当前笔记暂时无法浏览",),
+        "failure_type": "CONTENT_UNAVAILABLE",
+        "reason_code": "CONTENT_UNAVAILABLE",
+        "next_action": "请跳过该内容或联系开发者确认可见性限制",
+        "agent_action": "STOP",
+        "retry_recommended": False,
+        "cli_code": "INTERNAL_ERROR",
+    },
+    {
+        "markers": ("你访问的页面不见了",),
+        "failure_type": "PAGE_UNAVAILABLE",
+        "reason_code": "PAGE_NOT_FOUND",
+        "next_action": "请检查链接参数或联系开发者确认页面访问路径",
+        "agent_action": "STOP",
+        "retry_recommended": False,
+        "cli_code": "INTERNAL_ERROR",
+    },
+    {
+        "markers": ("Cannot read properties of undefined (reading 'status')",),
+        "failure_type": "LOGIN_PAGE_BROKEN",
+        "reason_code": "QR_WIDGET_SCRIPT_ERROR",
+        "next_action": "请刷新页面后重试登录；若仍失败请联系开发者",
+        "agent_action": "RETRY_LATER",
+        "retry_recommended": True,
+        "cli_code": "INTERNAL_ERROR",
+    },
+)
+
+
+def _normalize_text(text: str) -> str:
+    return (text or "").strip()
+
+
+def _candidate_lines(text: str) -> list[str]:
+    normalized = _normalize_text(text)
+    if not normalized:
+        return []
+    return [line.strip() for line in normalized.splitlines() if line.strip()] or [normalized]
+
+
+def _match_rule(text: str, source: str) -> RednoteIssue | None:
+    lines = _candidate_lines(text)
+    for rule in _ISSUE_RULES:
+        for marker in rule["markers"]:
+            for line in lines:
+                if marker in line:
+                    return RednoteIssue(
+                        failure_type=rule["failure_type"],
+                        reason_code=rule["reason_code"],
+                        failure_reason=line,
+                        next_action=rule["next_action"],
+                        agent_action=rule["agent_action"],
+                        source=source,
+                        retry_recommended=rule["retry_recommended"],
+                        cli_code=rule["cli_code"],
+                        observed_text=line,
+                    )
+    return None
+
+
+def classify_issue_from_text(text: str, *, source: str = "page") -> RednoteIssue | None:
+    return _match_rule(text, source)
+
+
+def detect_issue_from_texts(texts: Iterable[str], *, source: str = "page") -> RednoteIssue | None:
+    for text in texts:
+        issue = classify_issue_from_text(text, source=source)
+        if issue is not None:
+            return issue
+    return None
+
+
+def build_unknown_issue(
+    *,
+    source: str = "unknown",
+    observed_text: str = "",
+    failure_reason: str = "未知原因",
+    next_action: str = "请联系开发者",
+    agent_action: str = "STOP",
+) -> RednoteIssue:
+    return RednoteIssue(
+        failure_type="UNKNOWN",
+        reason_code="UNKNOWN",
+        failure_reason=failure_reason,
+        next_action=next_action,
+        agent_action=agent_action,
+        source=source,
+        retry_recommended=False,
+        cli_code="INTERNAL_ERROR",
+        observed_text=_normalize_text(observed_text),
+    )
+
+
+async def collect_visible_feedback_texts(page: Page) -> list[str]:
+    texts = await page.evaluate(
+        """
+        (selectors) => {
+          const isVisible = (el) => {
+            if (!el) return false;
+            const style = window.getComputedStyle(el);
+            if (!style || style.visibility === 'hidden' || style.display === 'none') return false;
+            const rect = el.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+          };
+
+          const nodes = [];
+          for (const selector of selectors) {
+            for (const el of document.querySelectorAll(selector)) {
+              if (isVisible(el)) nodes.push(el);
+            }
+          }
+
+          for (const el of document.querySelectorAll('[class*="message"], [class*="toast"], [class*="modal"], [class*="dialog"]')) {
+            if (isVisible(el)) nodes.push(el);
+          }
+
+          const uniqueTexts = [];
+          const seen = new Set();
+          for (const el of nodes) {
+            const text = (el.innerText || el.textContent || '').trim();
+            if (!text || seen.has(text)) continue;
+            seen.add(text);
+            uniqueTexts.push(text);
+          }
+          return uniqueTexts;
+        }
+        """,
+        list(VISIBLE_FEEDBACK_SELECTORS),
+    )
+    return texts if isinstance(texts, list) else []
+
+
+async def detect_issue_from_page(
+    page: Page,
+    *,
+    body_text: str = "",
+    include_body: bool = True,
+) -> RednoteIssue | None:
+    visible_texts = await collect_visible_feedback_texts(page)
+    issue = detect_issue_from_texts(visible_texts, source="toast")
+    if issue is not None:
+        return issue
+
+    if not include_body:
+        return None
+
+    effective_body_text = _normalize_text(body_text)
+    if not effective_body_text:
+        body = page.locator("body").first
+        if await body.count() == 0:
+            return None
+        effective_body_text = _normalize_text(await body.inner_text() or "")
+    if not effective_body_text:
+        return None
+    return classify_issue_from_text(effective_body_text, source="page")

{rednote-cli-0.1.3 → rednote-cli-0.1.5}/src/rednote_cli/_runtime/services/scraper_service.py

@@ -44,22 +44,36 @@ def _build_publish_result_from_raw(raw_result) -> PublishResult:
     if isinstance(raw_result, dict):
         uploaded_count = int(raw_result.get("uploaded_count", 0) or 0)
         status = str(raw_result.get("status", "")).strip().lower()
-        if status in {"uploaded", "submitted", "success", "verified"}:
-            if status == "uploaded":
-                stage = PublishStage.UPLOAD_DONE
-            elif status == "verified":
-                stage = PublishStage.VERIFIED
-            else:
-                stage = PublishStage.SUBMITTED
+        if status in {"success", "verified"}:
             return PublishResult(
                 success=True,
-                stage=stage,
+                stage=PublishStage.VERIFIED,
                 uploaded_count=uploaded_count,
                 publish_url=str(raw_result.get("publish_url") or ""),
                 publish_id=str(raw_result.get("publish_id") or ""),
                 message=str(raw_result.get("message") or ""),
                 data=raw_result,
             )
+        if status == "uploaded":
+            return PublishResult(
+                success=False,
+                stage=PublishStage.UPLOAD_DONE,
+                uploaded_count=uploaded_count,
+                publish_url=str(raw_result.get("publish_url") or ""),
+                publish_id=str(raw_result.get("publish_id") or ""),
+                message=str(raw_result.get("message") or "素材已上传，但未完成发布"),
+                data=raw_result,
+            )
+        if status == "submitted":
+            return PublishResult(
+                success=False,
+                stage=PublishStage.SUBMITTED,
+                uploaded_count=uploaded_count,
+                publish_url=str(raw_result.get("publish_url") or ""),
+                publish_id=str(raw_result.get("publish_id") or ""),
+                message=str(raw_result.get("message") or "发布动作已提交，但未验证是否真正发布成功"),
+                data=raw_result,
+            )
         return PublishResult(
             success=False,
             stage=PublishStage.FAILED,
@@ -215,6 +229,8 @@ async def publish_note(
                         schedule_at=request.schedule_at,
                     )
                     result = _build_publish_result_from_raw(raw_result)
+                    if not result.success:
+                        raise PublishExecutionError(result.message or f"发布未完成(stage={result.stage.value})")
                     if result.stage == PublishStage.UPLOAD_DONE:
                         result.data["pipeline_stage"] = PublishStage.UPLOAD_DONE.value
                     return result.to_dict()