rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/_runtime/core/browser/manager.py

@@ -0,0 +1,247 @@
+import asyncio
+import hashlib
+import json
+import platform
+from contextlib import asynccontextmanager
+from typing import Optional, AsyncGenerator, Union, Callable, Awaitable, Dict
+
+from loguru import logger
+from playwright.async_api import (
+    async_playwright,
+    Browser,
+    BrowserContext,
+    Page,
+    Playwright,
+    Response,
+)
+
+from rednote_cli._runtime.common.app_utils import get_system_chrome_path
+from rednote_cli._runtime.common.config import (
+    BROWSER_LOCALE,
+    BROWSER_TIMEZONE,
+    resolve_browser_headless,
+)
+
+# Handle playwright-stealth version differences
+try:
+    from playwright_stealth import stealth_async
+except ImportError:
+    try:
+        from playwright_stealth import Stealth
+
+
+        async def stealth_async(page):
+            await Stealth().apply_stealth_async(page)
+    except ImportError:
+        async def stealth_async(page):
+            logger.warning("Stealth module not found, proceeding without stealth.")
+            pass
+
+class BrowserManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(BrowserManager, cls).__new__(cls)
+            cls._instance.is_running = False
+            cls._instance._local_playwrights: Dict[int, Playwright] = {}
+            cls._instance._local_browsers: Dict[int, Browser] = {}
+            cls._instance._loop_semaphores: Dict[int, asyncio.Semaphore] = {}
+            cls._instance._loop_start_locks: Dict[int, asyncio.Lock] = {}
+            cls._instance._profile_cache: Dict[str, dict] = {}
+
+        return cls._instance
+
+    @staticmethod
+    def _pick_by_hash(digest: str, start: int, end: int, offset: int) -> int:
+        span = end - start + 1
+        return start + (int(digest[offset: offset + 8], 16) % span)
+
+    def _resolve_profile(self, account_key: Optional[str]) -> dict:
+        key = account_key or "default"
+        cached = self._profile_cache.get(key)
+        if cached:
+            return cached
+
+        digest = hashlib.sha256(key.encode("utf-8")).hexdigest()
+        system = platform.system()
+
+        if system == "Darwin":
+            user_agent = (
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/131.0.0.0 Safari/537.36"
+            )
+            device_scale_factor = 2.0
+        else:
+            user_agent = (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/131.0.0.0 Safari/537.36"
+            )
+            device_scale_factor = 1.0
+
+        profile = {
+            "user_agent": user_agent,
+            "viewport": {
+                "width": self._pick_by_hash(digest, 1366, 1920, 0),
+                "height": self._pick_by_hash(digest, 768, 1080, 8),
+            },
+            "device_scale_factor": device_scale_factor,
+        }
+        self._profile_cache[key] = profile
+        return profile
+
+    @staticmethod
+    def _normalize_storage_state(storage_state: Optional[Union[dict, str]]) -> Optional[dict]:
+        if isinstance(storage_state, str) and storage_state:
+            try:
+                return json.loads(storage_state)
+            except Exception:
+                return None
+        return storage_state if isinstance(storage_state, dict) else None
+
+    @staticmethod
+    def _get_loop_id() -> int:
+        return id(asyncio.get_running_loop())
+
+    def _get_loop_semaphore(self) -> asyncio.Semaphore:
+        loop_id = id(asyncio.get_running_loop())
+        if loop_id not in self._loop_semaphores:
+            self._loop_semaphores[loop_id] = asyncio.Semaphore(10)
+        return self._loop_semaphores[loop_id]
+
+    def _get_loop_start_lock(self, loop_id: int) -> asyncio.Lock:
+        if loop_id not in self._loop_start_locks:
+            self._loop_start_locks[loop_id] = asyncio.Lock()
+        return self._loop_start_locks[loop_id]
+
+    async def _ensure_loop_browser(self, headless: bool | None = None) -> int:
+        headless = resolve_browser_headless(headless)
+        loop_id = self._get_loop_id()
+        if loop_id in self._local_browsers:
+            return loop_id
+
+        async with self._get_loop_start_lock(loop_id):
+            if loop_id in self._local_browsers:
+                return loop_id
+
+            logger.info(f"DEBUG: [BrowserManager] loop={loop_id} 正在以直连模式启动浏览器...")
+            launch_args = [
+                "--disable-blink-features=AutomationControlled",
+                "--no-sandbox",
+                "--disable-dev-shm-usage",
+            ]
+
+            launch_kwargs = {
+                "headless": headless,
+                "args": launch_args,
+            }
+            browser_bin = get_system_chrome_path()
+            if browser_bin:
+                launch_kwargs["executable_path"] = browser_bin
+
+            playwright = await async_playwright().start()
+            browser = await playwright.chromium.launch(**launch_kwargs)
+            self._local_playwrights[loop_id] = playwright
+            self._local_browsers[loop_id] = browser
+            self._loop_semaphores.setdefault(loop_id, asyncio.Semaphore(10))
+            self.is_running = True
+            logger.info(f"DEBUG: [BrowserManager] loop={loop_id} 浏览器直连模式启动完成")
+            return loop_id
+
+    async def start(self, headless: bool | None = None):
+        """为当前事件循环启动浏览器管理服务。"""
+        await self._ensure_loop_browser(headless=headless)
+
+    async def stop(self):
+        """停止所有事件循环持有的浏览器资源。"""
+        if not self.is_running:
+            return
+
+        for loop_id, browser in list(self._local_browsers.items()):
+            try:
+                await browser.close()
+            except Exception as e:
+                logger.warning(f"DEBUG: [BrowserManager] loop={loop_id} 关闭浏览器失败: {e}")
+        self._local_browsers.clear()
+
+        for loop_id, playwright in list(self._local_playwrights.items()):
+            try:
+                await playwright.stop()
+            except Exception as e:
+                logger.warning(f"DEBUG: [BrowserManager] loop={loop_id} 停止 playwright 失败: {e}")
+        self._local_playwrights.clear()
+        self._loop_semaphores.clear()
+        self._loop_start_locks.clear()
+
+        self.is_running = False
+        logger.info("DEBUG: [BrowserManager] 浏览器已停止")
+
+    @asynccontextmanager
+    async def get_context(
+            self,
+            storage_state: Optional[Union[dict, str]] = None,
+            headless: bool | None = None,
+            account_key: Optional[str] = None,
+            timezone_id: Optional[str] = None,
+            locale: Optional[str] = None,
+    ) -> AsyncGenerator[BrowserContext, None]:
+        """获取浏览器上下文，确保账号画像稳定。"""
+        headless = resolve_browser_headless(headless)
+        loop_id = await self._ensure_loop_browser(headless=headless)
+        browser = self._local_browsers.get(loop_id)
+        if not browser:
+            raise RuntimeError(f"Browser not initialized for loop={loop_id}")
+
+        semaphore = self._get_loop_semaphore()
+        profile = self._resolve_profile(account_key)
+        normalized_state = self._normalize_storage_state(storage_state)
+
+        async with semaphore:
+            context = await browser.new_context(
+                permissions=["geolocation"],
+                user_agent=profile["user_agent"],
+                viewport=profile["viewport"],
+                device_scale_factor=profile["device_scale_factor"],
+                storage_state=normalized_state,
+                ignore_https_errors=True,
+                locale=locale or BROWSER_LOCALE,
+                timezone_id=timezone_id or BROWSER_TIMEZONE,
+            )
+            try:
+                yield context
+            finally:
+                await context.close()
+
+    @asynccontextmanager
+    async def get_page(
+            self,
+            storage_state: Optional[Union[dict, str]] = None,
+            headless: bool | None = None,
+            account_key: Optional[str] = None,
+            timezone_id: Optional[str] = None,
+            locale: Optional[str] = None,
+    ) -> AsyncGenerator[Page, None]:
+        """获取页面上下文。"""
+        async with self.get_context(
+                storage_state=storage_state,
+                headless=headless,
+                account_key=account_key,
+                timezone_id=timezone_id,
+                locale=locale,
+        ) as context:
+            page = await context.new_page()
+            await stealth_async(page)
+            yield page
+
+    @asynccontextmanager
+    async def observe_responses(self, page: Page, handler: Callable[[Response], Awaitable[None]]):
+        page.on("response", handler)
+        try:
+            yield
+        finally:
+            page.remove_listener("response", handler)
+
+
+browser_manager = BrowserManager()

rednote_cli/_runtime/core/database/manager.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from urllib.parse import quote
+
+from loguru import logger
+
+import rednote_cli._runtime.common.config as runtime_config
+
+
+def _data_root() -> Path:
+    root = Path(runtime_config.APP_DATA_DIR)
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def _accounts_root() -> Path:
+    root = _data_root() / "accounts"
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def _settings_file() -> Path:
+    return _data_root() / "settings.json"
+
+
+def _task_schedules_file() -> Path:
+    return _data_root() / "task_schedules.json"
+
+
+def _meta_file() -> Path:
+    return _accounts_root() / ".meta.json"
+
+
+def _safe_user_no(user_no: str) -> str:
+    return quote(str(user_no), safe="")
+
+
+def _account_file(platform: str, user_no: str) -> Path:
+    platform_dir = _accounts_root() / str(platform)
+    platform_dir.mkdir(parents=True, exist_ok=True)
+    return platform_dir / f"{_safe_user_no(user_no)}.json"
+
+
+def _load_json(path: Path, default):
+    if not path.exists():
+        return default
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def _write_json_atomic(path: Path, payload) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def _iter_account_files() -> list[Path]:
+    root = _accounts_root()
+    return [p for p in root.rglob("*.json") if p.name != ".meta.json"]
+
+
+def _next_account_id() -> int:
+    meta_path = _meta_file()
+    meta = _load_json(meta_path, {"next_id": 1})
+    next_id = int(meta.get("next_id", 1))
+    meta["next_id"] = next_id + 1
+    _write_json_atomic(meta_path, meta)
+    return next_id
+
+
+def _normalize_storage_state(value):
+    if isinstance(value, str) and value:
+        try:
+            return json.loads(value)
+        except Exception:
+            return None
+    if isinstance(value, dict):
+        return value
+    return None
+
+
+def _normalize_account_record(raw: dict) -> dict:
+    record = dict(raw)
+    record["storage_state"] = _normalize_storage_state(record.get("storage_state"))
+    if "is_logged_in" in record:
+        record["is_logged_in"] = bool(record.get("is_logged_in"))
+    return record
+
+
+def _ensure_file_store_layout() -> None:
+    _accounts_root()
+    for file_path, default in [
+        (_settings_file(), {}),
+        (_task_schedules_file(), {}),
+        (_meta_file(), {"next_id": 1}),
+    ]:
+        if not file_path.exists():
+            _write_json_atomic(file_path, default)
+
+
+def _has_existing_file_data() -> bool:
+    if _iter_account_files():
+        return True
+    if _load_json(_settings_file(), {}):
+        return True
+    return False
+
+
+def _migrate_from_legacy_sqlite_once() -> None:
+    marker = _data_root() / ".migrated_from_sqlite"
+    if marker.exists():
+        return
+
+    if _has_existing_file_data():
+        marker.write_text(str(int(time.time())), encoding="utf-8")
+        return
+
+    db_file = Path(runtime_config.DB_FILE)
+    if not db_file.exists():
+        marker.write_text(str(int(time.time())), encoding="utf-8")
+        return
+
+    try:
+        import sqlite3
+
+        conn = sqlite3.connect(db_file)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='accounts'")
+        has_accounts = cursor.fetchone() is not None
+        accounts_count = 0
+        if has_accounts:
+            cursor.execute("SELECT * FROM accounts")
+            rows = cursor.fetchall()
+            for row in rows:
+                account = _normalize_account_record(dict(row))
+                platform = account.get("platform")
+                user_no = account.get("user_no")
+                if not platform or not user_no:
+                    continue
+                target = _account_file(platform, user_no)
+                _write_json_atomic(target, account)
+                accounts_count += 1
+
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='settings'")
+        has_settings = cursor.fetchone() is not None
+        settings_count = 0
+        if has_settings:
+            cursor.execute("SELECT key, value FROM settings")
+            settings_rows = cursor.fetchall()
+            settings = {str(r["key"]): r["value"] for r in settings_rows}
+            _write_json_atomic(_settings_file(), settings)
+            settings_count = len(settings)
+
+        conn.close()
+        marker.write_text(
+            json.dumps(
+                {
+                    "migrated_at": int(time.time()),
+                    "accounts_count": accounts_count,
+                    "settings_count": settings_count,
+                },
+                ensure_ascii=False,
+            ),
+            encoding="utf-8",
+        )
+        logger.info(
+            "Migrated legacy sqlite data to file store: accounts={} settings={}",
+            accounts_count,
+            settings_count,
+        )
+    except Exception as exc:
+        logger.warning("Skipped sqlite migration: {}", exc)
+        marker.write_text(str(int(time.time())), encoding="utf-8")
+
+
+def init_db():
+    """Initialize file-based store and migrate legacy sqlite once if needed."""
+    _ensure_file_store_layout()
+    _migrate_from_legacy_sqlite_once()
+
+
+class DatabaseManager:
+    """File-backed storage manager (source of truth)."""
+
+    @staticmethod
+    def upsert_account(account_data: dict):
+        now = int(time.time())
+        platform = str(account_data.get("platform") or "").strip()
+        user_no = str(account_data.get("user_no") or "").strip()
+        if not platform or not user_no:
+            raise ValueError("platform and user_no are required")
+
+        path = _account_file(platform, user_no)
+        existing = _load_json(path, {}) if path.exists() else {}
+
+        payload = {
+            "id": int(existing.get("id") or _next_account_id()),
+            "platform": platform,
+            "user_no": user_no,
+            "nickname": account_data.get("nickname"),
+            "is_logged_in": bool(account_data.get("is_logged_in")),
+            "check_time": account_data.get("check_time"),
+            "usage_time": account_data.get("usage_time", existing.get("usage_time")),
+            "storage_state": _normalize_storage_state(account_data.get("storage_state")),
+            "creater": existing.get("creater", "admin"),
+            "created": int(existing.get("created") or now),
+            "modifier": "admin",
+            "modified": now,
+        }
+        _write_json_atomic(path, payload)
+
+    @staticmethod
+    def get_all_accounts(only_active=False):
+        records = []
+        for path in _iter_account_files():
+            data = _load_json(path, {})
+            if not data:
+                continue
+            record = _normalize_account_record(data)
+            if only_active and not bool(record.get("is_logged_in")):
+                continue
+            records.append(record)
+        records.sort(key=lambda x: int(x.get("modified") or 0), reverse=True)
+        return records
+
+    @staticmethod
+    def delete_account(platform, user_no):
+        path = _account_file(str(platform), str(user_no))
+        if path.exists():
+            path.unlink()
+
+    @staticmethod
+    def get_setting(key: str, default=None):
+        settings = _load_json(_settings_file(), {})
+        return settings.get(key, default)
+
+    @staticmethod
+    def set_setting(key: str, value: str):
+        settings = _load_json(_settings_file(), {})
+        settings[str(key)] = value
+        _write_json_atomic(_settings_file(), settings)
+
+    @staticmethod
+    def get_task_schedule(platform: str) -> dict:
+        schedules = _load_json(_task_schedules_file(), {})
+        schedule = schedules.get(platform)
+        if schedule:
+            return schedule
+        return {
+            "platform": platform,
+            "task_type": "login_check",
+            "cron_expression": "",
+            "jitter_seconds": 0,
+            "alert_enabled": 0,
+            "alert_email": "",
+            "is_active": 0,
+        }
+
+    @staticmethod
+    def upsert_task_schedule(data: dict):
+        schedules = _load_json(_task_schedules_file(), {})
+        platform = str(data.get("platform") or "").strip()
+        if not platform:
+            raise ValueError("platform is required")
+        now = int(time.time())
+        existing = schedules.get(platform, {})
+        schedules[platform] = {
+            "platform": platform,
+            "task_type": data.get("task_type", "login_check"),
+            "cron_expression": data.get("cron_expression"),
+            "jitter_seconds": data.get("jitter_seconds", 0),
+            "next_run_time": data.get("next_run_time"),
+            "alert_enabled": data.get("alert_enabled", 0),
+            "alert_email": data.get("alert_email", ""),
+            "is_active": data.get("is_active", 1),
+            "created": int(existing.get("created") or now),
+            "modified": now,
+        }
+        _write_json_atomic(_task_schedules_file(), schedules)
+
+    @staticmethod
+    def get_all_task_schedules():
+        schedules = _load_json(_task_schedules_file(), {})
+        return list(schedules.values())
+
+    @staticmethod
+    def delete_task_schedule(platform: str):
+        schedules = _load_json(_task_schedules_file(), {})
+        schedules.pop(platform, None)
+        _write_json_atomic(_task_schedules_file(), schedules)
+
+    @staticmethod
+    def update_next_run_time(platform: str, next_run: int):
+        schedules = _load_json(_task_schedules_file(), {})
+        item = schedules.get(platform)
+        if not item:
+            return
+        item["next_run_time"] = next_run
+        item["modified"] = int(time.time())
+        schedules[platform] = item
+        _write_json_atomic(_task_schedules_file(), schedules)
+
+    @staticmethod
+    def set_account_login_status(platform: str, user_no: str, is_logged_in: bool) -> bool:
+        path = _account_file(platform, user_no)
+        data = _load_json(path, {})
+        if not data:
+            return False
+        data["is_logged_in"] = bool(is_logged_in)
+        data["modified"] = int(time.time())
+        _write_json_atomic(path, data)
+        return True
+
+    @staticmethod
+    def update_account_status(account_id: int, is_logged_in: bool, check_time: int, storage_state: dict = None):
+        for path in _iter_account_files():
+            data = _load_json(path, {})
+            if int(data.get("id") or 0) != int(account_id):
+                continue
+            data["is_logged_in"] = bool(is_logged_in)
+            data["check_time"] = check_time
+            if storage_state is not None:
+                data["storage_state"] = _normalize_storage_state(storage_state)
+            data["modified"] = int(time.time())
+            _write_json_atomic(path, data)
+            return

rednote_cli/_runtime/platforms/base.py

@@ -0,0 +1,62 @@
+import asyncio
+import random
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from loguru import logger
+from playwright.async_api import Page
+from yt_dlp import YoutubeDL
+from yt_dlp.extractor.common import InfoExtractor
+
+
+class RiskControlException(Exception):
+    """Exception raised when platform risk control is detected."""
+    pass
+
+
+class RobustnessMixin:
+    """Mixin providing human-like interaction and risk detection."""
+    page: Page
+
+    async def human_scroll(self, container_locator=None, distance_range=(800, 1500), delay_range=(1.0, 2.5)):
+        """Simulate human-like scrolling with random distance and delays."""
+        distance = random.randint(*distance_range)
+        logger.info(f"Human scroll: {distance}px")
+        if container_locator:
+            await container_locator.evaluate(f"el => el.scrollBy(0, {distance})")
+        else:
+            await self.page.mouse.wheel(0, distance)
+        await asyncio.sleep(random.uniform(*delay_range))
+
+    async def human_click(self, selector: str):
+        """Simulate human-like click using ghost-cursor (pseudo-implementation)."""
+        # Note: Actual ghost-cursor requires more complex setup, using a simplified version here
+        # that moves the mouse before clicking.
+        element = self.page.locator(selector).first
+        if await element.is_visible():
+            box = await element.bounding_box()
+            if box:
+                x = box['x'] + box['width'] / 2
+                y = box['y'] + box['height'] / 2
+                await self.page.mouse.move(x + random.uniform(-5, 5), y + random.uniform(-5, 5), steps=10)
+                await asyncio.sleep(random.uniform(0.2, 0.5))
+                await element.click()
+
+
+class BaseExtractor(InfoExtractor, RobustnessMixin):
+    """Base class for platform-specific data extraction."""
+
+    def __init__(self, page: Page):
+        super().__init__()
+        self.page = page
+        self.set_downloader(YoutubeDL({'quiet': True}))
+
+    @abstractmethod
+    async def get_self_info(self):
+        """Extract information about the currently logged-in user."""
+        pass
+
+    @abstractmethod
+    async def get_user_info(self, user_id: str):
+        """Extract information about a specific user."""
+        pass

rednote_cli/_runtime/platforms/factory.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rednote_cli._runtime.common.enums import Platform
+
+
+@dataclass(frozen=True)
+class PlatformLoginProfile:
+    login_url: str
+    login_selector: str
+    qr_selector: str
+    account_id_field: str = "user_no"
+    nickname_field: str = "nickname"
+    guest_field: str = "guest"
+
+
+class PlatformFactory:
+    """Factory for creating platform-specific runtime objects."""
+
+    _extractor_registry: dict[Platform, type] = {}
+    _login_profile_registry: dict[Platform, PlatformLoginProfile] = {}
+
+    @classmethod
+    def register_extractor(cls, platform_enum: Platform, extractor_cls: type) -> None:
+        cls._extractor_registry[platform_enum] = extractor_cls
+
+    @classmethod
+    def register_login_profile(cls, platform_enum: Platform, profile: PlatformLoginProfile) -> None:
+        cls._login_profile_registry[platform_enum] = profile
+
+    @classmethod
+    def register_platform(
+        cls,
+        platform_enum: Platform,
+        *,
+        extractor_cls: type,
+        login_profile: PlatformLoginProfile,
+    ) -> None:
+        cls.register_extractor(platform_enum, extractor_cls)
+        cls.register_login_profile(platform_enum, login_profile)
+
+    @classmethod
+    def get_extractor(cls, platform_enum: Platform, page):
+        extractor_cls = cls._extractor_registry.get(platform_enum)
+        if extractor_cls is None:
+            raise ValueError(f"Unsupported platform: {platform_enum}")
+        return extractor_cls(page)
+
+    @classmethod
+    def get_login_profile(cls, platform_enum: Platform) -> PlatformLoginProfile:
+        profile = cls._login_profile_registry.get(platform_enum)
+        if profile is None:
+            raise ValueError(f"Unsupported platform: {platform_enum}")
+        return profile