rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Rednote Operator CLI package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

rednote_cli/_runtime/common/app_utils.py

@@ -0,0 +1,77 @@
+import os
+import platform
+import sys
+from datetime import datetime
+
+
+def get_app_path(relative_path):
+    """
+    获取资源绝对路径（兼容 Dev 和 Frozen 环境）
+    
+    在 PyInstaller --onedir 模式下，macOS .app 的结构通常是：
+    OperatorRuntime.app/
+        Contents/
+            MacOS/
+                OperatorRuntime (可执行文件)
+                assets/       (如果 spec 中配置在同级)
+            Resources/        (标准 Mac 资源目录)
+            
+    我们现在的 spec 配置是将 assets 放在可执行文件同级目录。
+    """
+    if getattr(sys, 'frozen', False):
+        # 打包后的环境
+        bundle_dir = os.path.dirname(sys.executable)
+        return os.path.join(bundle_dir, relative_path)
+    else:
+        # 开发环境
+        return os.path.join(os.path.abspath("."), relative_path)
+
+
+def get_system_chrome_path():
+    """
+    获取系统已安装的 Chrome/Edge 路径，避免打包几百兆的浏览器。
+    优先查找 Chrome，其次 Edge。
+    """
+    system = platform.system()
+    paths = []
+
+    if system == "Darwin":  # macOS
+        paths = [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            # 用户可能安装在用户目录下
+            os.path.expanduser("~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+        ]
+    elif system == "Windows":
+        paths = [
+            r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+            r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+            r"C:\Program Files\Microsoft\Edge\Application\msedge.exe",
+            r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
+        ]
+
+    for p in paths:
+        if os.path.exists(p):
+            return p
+
+    return None
+
+
+def timestamp_to_str(ts, fmt='%Y-%m-%d %H:%M:%S', tz=None):
+    """
+    自动识别10位或13位时间戳并转为日期字符串
+    """
+    if not ts: return ts
+
+    # 如果是字符串类型的输入，先转为数字
+    try:
+        ts = int(ts)
+    except Exception:
+        return ts
+
+    # 核心逻辑：如果数值大于 1e11 (即 100,000,000,000)，通常被认为是毫秒级
+    # 10位时间戳最大到 2286年 (9999999999)
+    if ts > 10000000000:
+        ts = ts / 1000
+
+    return datetime.fromtimestamp(ts, tz=tz).strftime(fmt)

rednote_cli/_runtime/common/config.py

@@ -0,0 +1,83 @@
+import os
+import platform
+from pathlib import Path
+
+
+def _read_bool_env(name: str, default: bool) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    text = str(raw).strip().lower()
+    if text in {"1", "true", "yes", "on"}:
+        return True
+    if text in {"0", "false", "no", "off"}:
+        return False
+    return default
+
+
+def get_app_data_dir(app_name="OperatorRuntime"):
+    """
+    Get the platform-specific user data directory.
+    """
+    system = platform.system()
+    if system == "Windows":
+        return Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming")) / app_name
+    elif system == "Darwin":
+        return Path.home() / "Library" / "Application Support" / app_name
+    else:
+        # Linux / Unix
+        return Path.home() / ".local" / "share" / app_name
+
+
+# Initialize paths
+APP_DATA_DIR = get_app_data_dir()
+try:
+    APP_DATA_DIR.mkdir(parents=True, exist_ok=True)
+except PermissionError:
+    # Sandbox-friendly fallback for restricted environments (tests/CI).
+    APP_DATA_DIR = Path.cwd() / ".operator_runtime_data"
+    APP_DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+# Database path
+DB_FILE = APP_DATA_DIR / "operator_runtime.db"
+
+# Log path
+LOG_DIR = APP_DATA_DIR / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / "app.log"
+
+# --- 调试配置 ---
+# 默认行为：无头（生产）
+# 开发调试可通过环境变量强制有头：
+# - REDNOTE_CLI_HEADFUL=1
+# - BROWSER_HEADFUL=1
+BROWSER_HEADLESS = _read_bool_env("BROWSER_HEADLESS", True)
+_BROWSER_HEADFUL_FORCED = _read_bool_env("REDNOTE_CLI_HEADFUL", False) or _read_bool_env("BROWSER_HEADFUL", False)
+
+
+def is_browser_headful_forced() -> bool:
+    return _BROWSER_HEADFUL_FORCED
+
+
+def resolve_browser_headless(requested: bool | None = None) -> bool:
+    if _BROWSER_HEADFUL_FORCED:
+        return False
+    if requested is None:
+        return BROWSER_HEADLESS
+    return bool(requested)
+
+
+def resolve_login_mode_headless(mode: str) -> bool:
+    normalized_mode = str(mode or "").strip().lower()
+    if normalized_mode == "local":
+        # Local login is interactive by design.
+        return resolve_browser_headless(False)
+    if normalized_mode == "remote":
+        # Remote login defaults to headless, but follows BROWSER_HEADLESS env.
+        return resolve_browser_headless(None)
+    return resolve_browser_headless()
+
+# --- 浏览器环境配置 ---
+# 建议与账号真实访问地区保持一致，减少环境指纹漂移。
+BROWSER_LOCALE = os.getenv("BROWSER_LOCALE", "zh-CN")
+BROWSER_TIMEZONE = os.getenv("BROWSER_TIMEZONE", "Asia/Shanghai")

rednote_cli/_runtime/common/enums.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class Platform(Enum):
+    REDNOTE = "Rednote"
+    DOUYIN = "Douyin"
+    TIKTOK = "TikTok"
+
+
+class XsecSource(Enum):
+    PC_FEED = "pc_feed"  # 发现页 → 笔记；发现页 → 达人
+    PC_SEARCH = "pc_search"  # 搜索页 → 笔记；搜索页 → 达人
+    PC_COLLECT = "pc_collect"  # 达人-收藏页 → 笔记；达人-收藏页 → 达人
+    PC_LIKE = "pc_like"  # 达人-点赞页 → 笔记；达人-点赞页 → 达人
+    PC_USER = "pc_user"  # 达人-笔记页 → 笔记
+    PC_NOTE = "pc_note"  # 笔记页 → 达人
+

rednote_cli/_runtime/common/errors.py

@@ -0,0 +1,22 @@
+class PublishNoteException(Exception):
+    """Base exception for publish-note workflow."""
+
+
+class InvalidPublishParameterError(PublishNoteException, ValueError):
+    """Raised when publish-note inputs are invalid."""
+
+
+class UnsupportedPublishTargetError(PublishNoteException):
+    """Raised when publish target is unsupported."""
+
+
+class PublishWorkflowNotReadyError(PublishNoteException):
+    """Raised when target exists but workflow is not implemented yet."""
+
+
+class PublishMediaPreparationError(PublishNoteException):
+    """Raised when media validation/download fails."""
+
+
+class PublishExecutionError(PublishNoteException):
+    """Raised when publish execution fails unexpectedly."""

rednote_cli/_runtime/core/account_manager.py

@@ -0,0 +1,349 @@
+import asyncio
+import random
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Callable, Optional, Set
+
+from loguru import logger
+
+import rednote_cli._runtime.common.config as runtime_config
+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
+
+
+class AccountLeaseManager:
+    """Manages account locking and leasing for multi-tenant isolation."""
+    _locked_accounts: Set[str] = set()  # format: "platform:user_no"
+    _lock = asyncio.Lock()
+
+    @classmethod
+    def build_account_key(cls, platform: Platform, user_no: str) -> str:
+        return f"{platform.value}:{user_no}"
+
+    @classmethod
+    def _match_account_identifier(cls, account: dict, identifier: str) -> bool:
+        target = str(identifier or "").strip()
+        if not target:
+            return False
+        user_no = str(account.get("user_no") or "").strip()
+        return target == user_no
+
+    @classmethod
+    async def try_acquire_account_lock(cls, platform: Platform, user_no: str) -> bool:
+        if not user_no:
+            return False
+        accounts = DatabaseManager.get_all_accounts(only_active=True)
+        valid_accounts = [acc for acc in accounts if acc['platform'] == platform.value]
+        target = next((acc for acc in valid_accounts if cls._match_account_identifier(acc, user_no)), None)
+        if not target:
+            return False
+        key = cls.build_account_key(platform, target["user_no"])
+        async with cls._lock:
+            if key in cls._locked_accounts:
+                return False
+            cls._locked_accounts.add(key)
+            logger.info(f"Leased account: {key}")
+            return True
+
+    @classmethod
+    async def release_account_lock(cls, platform: Platform, user_no: str) -> None:
+        if not user_no:
+            return
+        accounts = DatabaseManager.get_all_accounts(only_active=False)
+        valid_accounts = [acc for acc in accounts if acc['platform'] == platform.value]
+        target = next((acc for acc in valid_accounts if cls._match_account_identifier(acc, user_no)), None)
+        if not target:
+            return
+        key = cls.build_account_key(platform, target["user_no"])
+        async with cls._lock:
+            if key in cls._locked_accounts:
+                cls._locked_accounts.remove(key)
+                logger.info(f"Released account: {key}")
+
+    @classmethod
+    @asynccontextmanager
+    async def lease_account(cls, platform: Platform, user_no: Optional[str] = None):
+        """Lease an account for a request. If user_no is None, pick a random active one."""
+        account = None
+        account_key = None
+
+        async with cls._lock:
+            accounts = DatabaseManager.get_all_accounts(only_active=True)
+            valid_accounts = [acc for acc in accounts if acc['platform'] == platform.value]
+
+            if user_no:
+                target = next((acc for acc in valid_accounts if cls._match_account_identifier(acc, user_no)), None)
+                if target:
+                    key = cls.build_account_key(platform, target['user_no'])
+                    if key not in cls._locked_accounts:
+                        account = target
+                        account_key = key
+            else:
+                # Pick a random one that is not locked
+                available = [
+                    acc for acc in valid_accounts
+                    if cls.build_account_key(platform, acc['user_no']) not in cls._locked_accounts
+                ]
+                if available:
+                    account = random.choice(available)
+                    account_key = cls.build_account_key(platform, account['user_no'])
+
+            if not account:
+                raise Exception(f"No available {platform.value} accounts to lease.")
+
+            cls._locked_accounts.add(account_key)
+            logger.info(f"Leased account: {account_key}")
+
+        try:
+            yield account
+        finally:
+            async with cls._lock:
+                if account_key in cls._locked_accounts:
+                    cls._locked_accounts.remove(account_key)
+                    logger.info(f"Released account: {account_key}")
+
+
+class AccountManager:
+    """Business logic for managing accounts across platforms."""
+    DEFAULT_REMOTE_SCREENSHOT_NAME = "login_viewport.png"
+
+    @staticmethod
+    def list_accounts(only_active=False):
+        accounts = DatabaseManager.get_all_accounts(only_active=only_active)
+        for acc in accounts:
+            acc["uid"] = acc["user_no"]
+            acc["status"] = "Active" if acc["is_logged_in"] else "Inactive"
+            if acc.get("check_time"):
+                acc["last_active"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(acc["check_time"]))
+            else:
+                acc["last_active"] = "N/A"
+        return accounts
+
+    @staticmethod
+    def add_or_update_account(account_data: dict):
+        DatabaseManager.upsert_account(account_data)
+        logger.info(f"Account {account_data.get('nickname')} ({account_data.get('platform')}) updated.")
+
+    @staticmethod
+    def delete_account(platform, user_no):
+        DatabaseManager.delete_account(platform, user_no)
+        logger.info(f"Account {user_no} deleted from {platform}.")
+
+    @staticmethod
+    def _resolve_screenshot_path(raw_path: str) -> Path:
+        default_name = AccountManager.DEFAULT_REMOTE_SCREENSHOT_NAME
+        if not raw_path:
+            return Path(runtime_config.APP_DATA_DIR) / "outputs" / default_name
+
+        path = Path(raw_path).expanduser()
+        if (path.exists() and path.is_dir()) or raw_path.endswith(("/", "\\")):
+            return path / default_name
+        if path.suffix.lower() in {".png", ".jpg", ".jpeg"}:
+            return path
+        return path.with_suffix(".png")
+
+    @staticmethod
+    def _find_account(platform_enum: Platform, account_uid: str) -> Optional[dict]:
+        account_uid = str(account_uid or "").strip()
+        if not account_uid:
+            return None
+        accounts = DatabaseManager.get_all_accounts(only_active=False)
+        for item in accounts:
+            if item.get("platform") != platform_enum.value:
+                continue
+            if str(item.get("user_no") or "").strip() == account_uid:
+                return item
+        return None
+
+    @staticmethod
+    def get_login_profile(platform_enum: Platform):
+        return PlatformFactory.get_login_profile(platform_enum)
+
+    @staticmethod
+    async def login_and_add_account(
+        platform_enum: Platform,
+        *,
+        mode: str = "local",
+        timeout_seconds: int = 240,
+        screenshot_path: str = "",
+        account_uid: str = "",
+        progress_callback: Callable[[dict], None] | None = None,
+    ) -> dict:
+        """Interactive login process via browser."""
+        logger.info(f"Starting browser for {platform_enum.value} login, mode={mode}...")
+
+        def _emit_progress(event: str, **payload) -> None:
+            if progress_callback is None:
+                return
+            try:
+                progress_callback({"event": event, **payload})
+            except Exception as emit_err:
+                logger.debug(f"Ignored progress callback error: {emit_err}")
+
+        from playwright.async_api import TimeoutError as PlaywrightTimeoutError, async_playwright
+        from rednote_cli._runtime.common.app_utils import get_system_chrome_path
+
+        if mode not in {"local", "remote"}:
+            return {
+                "success": False,
+                "reason": "invalid_mode",
+                "message": f"Unsupported login mode: {mode}",
+                "mode": mode,
+            }
+
+        result = {
+            "success": False,
+            "mode": mode,
+            "timeout_seconds": timeout_seconds,
+            "login_url": "",
+            "screenshot_path": None,
+            "account_uid": None,
+            "user_no": None,
+            "nickname": None,
+            "reused_session": False,
+        }
+        profile = AccountManager.get_login_profile(platform_enum)
+        result["login_url"] = profile.login_url
+        target_account_uid = str(account_uid or "").strip()
+        target_account = None
+        if target_account_uid:
+            target_account = AccountManager._find_account(platform_enum, target_account_uid)
+            if not target_account:
+                result["reason"] = "account_not_found"
+                result["message"] = f"账号不存在: {target_account_uid}"
+                result["account_uid"] = target_account_uid
+                return result
+            result["account_uid"] = target_account_uid
+
+        headless = runtime_config.resolve_login_mode_headless(mode)
+        close_timeout_seconds = 1
+        browser = None
+        context = None
+        p = None
+
+        p = await async_playwright().start()
+        try:
+            executable_path = get_system_chrome_path()
+            browser = await p.chromium.launch(
+                headless=headless,
+                executable_path=executable_path,
+                args=["--disable-blink-features=AutomationControlled"]
+            )
+            context_kwargs = {"viewport": {'width': 1280, 'height': 800}}
+            if target_account and target_account.get("storage_state"):
+                context_kwargs["storage_state"] = target_account.get("storage_state")
+                logger.info(f"Loaded stored session for account: {target_account_uid}")
+            context = await browser.new_context(**context_kwargs)
+            page = await context.new_page()
+            await stealth_async(page)
+
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+
+            try:
+                logger.info(f"Opening login page: {profile.login_url}")
+                await page.goto(profile.login_url, wait_until="domcontentloaded")
+                await page.wait_for_timeout(500)
+
+                is_logged_in = await page.locator(profile.login_selector).count() > 0
+                result["reused_session"] = bool(target_account and is_logged_in)
+                if not is_logged_in:
+                    if target_account:
+                        logger.info(f"Stored session expired for account {target_account_uid}, fallback to QR login.")
+                    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,
+                            login_url=profile.login_url,
+                            screenshot_path=result["screenshot_path"],
+                            timeout_seconds=timeout_seconds,
+                            account_uid=result["account_uid"],
+                        )
+
+                    logger.info("Please complete login in the browser...")
+                    try:
+                        await page.wait_for_selector(profile.login_selector, timeout=timeout_seconds * 1000)
+                    except PlaywrightTimeoutError:
+                        logger.error(f"Login timed out after {timeout_seconds}s")
+                        result["reason"] = "login_timeout"
+                        result["message"] = f"扫码登录超时（{timeout_seconds} 秒）"
+                        return result
+                elif target_account:
+                    logger.info(f"Session still valid for account {target_account_uid}, skip QR login.")
+
+                logger.info("Login detected!")
+
+                storage_state = await context.storage_state()
+                info = await extractor.get_self_info()
+                user_no = str((info or {}).get(profile.account_id_field) or "").strip()
+                if info and user_no:
+                    if target_account_uid and target_account:
+                        expected = str(target_account.get("user_no") or "").strip()
+                        if expected and user_no != expected:
+                            result["reason"] = "account_mismatch"
+                            result["message"] = (
+                                f"指定账号 {target_account_uid} 与当前登录账号 {user_no} 不一致，"
+                                "请确认扫码账号或去掉 --account 参数"
+                            )
+                            return result
+                    elif target_account_uid and user_no != target_account_uid:
+                        result["reason"] = "account_mismatch"
+                        result["message"] = (
+                            f"指定账号 {target_account_uid} 与当前登录账号 {user_no} 不一致，"
+                            "请确认扫码账号或去掉 --account 参数"
+                        )
+                        return result
+
+                    account_data = {
+                        "platform": platform_enum.value,
+                        "user_no": user_no,
+                        "nickname": info.get(profile.nickname_field),
+                        "is_logged_in": not bool(info.get(profile.guest_field)),
+                        "check_time": int(time.time()),
+                        "storage_state": storage_state
+                    }
+                    DatabaseManager.upsert_account(account_data)
+                    logger.info(f"Account {info.get(profile.nickname_field)} added successfully!")
+                    result["success"] = True
+                    result["account_uid"] = user_no
+                    result["user_no"] = user_no
+                    result["nickname"] = info.get(profile.nickname_field)
+                    return result
+
+                logger.info("Failed to fetch user info after login.")
+                result["reason"] = "self_info_unavailable"
+                result["message"] = "登录成功但未获取到用户信息"
+                return result
+            except Exception as e:
+                logger.error(f"Login failed or timed out: {e}")
+                result["reason"] = "login_failed"
+                result["message"] = str(e)
+                return result
+            finally:
+                if context is not None:
+                    try:
+                        await asyncio.wait_for(context.close(), timeout=close_timeout_seconds)
+                    except Exception as close_err:
+                        logger.warning(f"Context close timeout/error ignored: {close_err}")
+                if browser is not None:
+                    try:
+                        await asyncio.wait_for(browser.close(), timeout=close_timeout_seconds)
+                    except Exception as close_err:
+                        logger.warning(f"Browser close timeout/error ignored: {close_err}")
+        finally:
+            if p is not None:
+                try:
+                    await asyncio.wait_for(p.stop(), timeout=close_timeout_seconds)
+                except Exception as close_err:
+                    logger.warning(f"Playwright stop timeout/error ignored: {close_err}")