rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/application/use_cases/auth_login.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from rednote_cli._runtime.common.enums import Platform
+from rednote_cli._runtime.core.account_manager import AccountManager
+from rednote_cli.domain.errors import CliTimeoutError, InternalError, InvalidArgsError
+from rednote_cli.infra.platforms import REDNOTE_PLATFORM
+
+
+async def execute_auth_login(
+    *,
+    mode: str = "local",
+    login_timeout_seconds: int = 240,
+    screenshot_path: str = "",
+    account_uid: str = "",
+    progress_callback: Callable[[dict], None] | None = None,
+) -> dict:
+    normalized_mode = mode.strip().lower()
+    if normalized_mode not in {"local", "remote"}:
+        raise InvalidArgsError("`--mode` 仅支持 local 或 remote")
+
+    platform_enum = Platform(REDNOTE_PLATFORM)
+    result = await AccountManager.login_and_add_account(
+        platform_enum,
+        mode=normalized_mode,
+        timeout_seconds=login_timeout_seconds,
+        screenshot_path=screenshot_path,
+        account_uid=account_uid,
+        progress_callback=progress_callback,
+    )
+    if result.get("success"):
+        return {"platform": platform_enum.value, **result}
+
+    reason = result.get("reason")
+    message = result.get("message") or "登录失败"
+    if reason == "login_timeout":
+        raise CliTimeoutError(
+            message=message,
+            details={
+                "mode": normalized_mode,
+                "account_uid": account_uid or None,
+                "timeout_seconds": login_timeout_seconds,
+                "screenshot_path": result.get("screenshot_path"),
+            },
+        )
+    if reason in {"account_not_found", "account_mismatch"}:
+        raise InvalidArgsError(
+            message=message,
+            details={
+                "mode": normalized_mode,
+                "account_uid": account_uid or None,
+                "reason": reason,
+            },
+        )
+    raise InternalError(
+        message=message,
+        details={
+            "mode": normalized_mode,
+            "account_uid": account_uid or None,
+            "reason": reason,
+            "screenshot_path": result.get("screenshot_path"),
+        },
+    )

rednote_cli/application/use_cases/auth_status.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import time
+
+from loguru import logger
+
+from rednote_cli._runtime.common.enums import Platform
+from rednote_cli._runtime.core.account_manager import AccountManager
+from rednote_cli._runtime.core.browser.manager import browser_manager, stealth_async
+from rednote_cli._runtime.core.database.manager import DatabaseManager
+from rednote_cli._runtime.platforms.factory import PlatformFactory
+from rednote_cli.application.use_cases.account_list import execute_account_list
+from rednote_cli.domain.errors import InvalidArgsError
+from rednote_cli.infra.platforms import REDNOTE_PLATFORM
+
+
+async def _refresh_account_status(account: dict, *, platform_enum: Platform) -> None:
+    user_no = str(account.get("user_no") or "").strip()
+    if not user_no:
+        return
+
+    is_logged_in = False
+    nickname = account.get("nickname")
+    refreshed_state = account.get("storage_state")
+    check_time = int(time.time())
+    profile = AccountManager.get_login_profile(platform_enum)
+
+    try:
+        async with browser_manager.get_context(
+            storage_state=account.get("storage_state"),
+            account_key=user_no,
+        ) as context:
+            page = await context.new_page()
+            await stealth_async(page)
+            extractor = PlatformFactory.get_extractor(platform_enum, page)
+
+            await page.goto(profile.login_url, wait_until="domcontentloaded")
+            await page.wait_for_timeout(500)
+            has_logged_in_selector = await page.locator(profile.login_selector).count() > 0
+            is_logged_in = has_logged_in_selector
+
+            if has_logged_in_selector:
+                try:
+                    info = await extractor.get_self_info()
+                    if isinstance(info, dict):
+                        info_nickname = str(info.get(profile.nickname_field) or "").strip()
+                        if info_nickname:
+                            nickname = info_nickname
+                        self_uid = str(info.get(profile.account_id_field) or "").strip()
+                        if self_uid and self_uid != user_no:
+                            # Cookie 已漂移到其他账号，当前账号视为失效。
+                            is_logged_in = False
+                        elif profile.guest_field in info:
+                            is_logged_in = not bool(info.get(profile.guest_field))
+                except Exception as exc:
+                    logger.warning(f"Self info check failed for account {user_no}: {exc}")
+
+            refreshed_state = await context.storage_state()
+    except Exception as exc:
+        logger.warning(f"Account status probe failed for account {user_no}: {exc}")
+
+    DatabaseManager.upsert_account(
+        {
+            "platform": account.get("platform"),
+            "user_no": user_no,
+            "nickname": nickname,
+            "is_logged_in": bool(is_logged_in),
+            "check_time": check_time,
+            "usage_time": account.get("usage_time"),
+            "storage_state": refreshed_state,
+        }
+    )
+
+
+def _load_platform_accounts() -> list[dict]:
+    accounts = DatabaseManager.get_all_accounts(only_active=False)
+    return [acc for acc in accounts if acc.get("platform") == REDNOTE_PLATFORM]
+
+
+async def execute_auth_status(account_uid: str | None = None) -> list[dict]:
+    platform_enum = Platform(REDNOTE_PLATFORM)
+    platform_accounts = _load_platform_accounts()
+
+    if account_uid:
+        target = str(account_uid).strip()
+        account = next((acc for acc in platform_accounts if str(acc.get("user_no") or "").strip() == target), None)
+        if not account:
+            raise InvalidArgsError(f"账号不存在: {target}")
+        accounts_to_probe = [account]
+    else:
+        accounts_to_probe = [acc for acc in platform_accounts if bool(acc.get("is_logged_in"))]
+
+    for account in accounts_to_probe:
+        await _refresh_account_status(account, platform_enum=platform_enum)
+
+    return execute_account_list(only_active=False)

rednote_cli/application/use_cases/doctor.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import importlib.util
+import platform
+import shutil
+
+from rednote_cli._runtime.common.app_utils import get_system_chrome_path
+from rednote_cli._runtime.core.database.manager import init_db
+from rednote_cli.infra.paths import APP_HOME, LOG_DIR, OUTPUT_DIR, configure_legacy_data_paths, ensure_runtime_dirs
+
+
+
+def execute_doctor() -> dict:
+    ensure_runtime_dirs()
+    configure_legacy_data_paths()
+    init_db()
+    checks = {
+        "python": {
+            "ok": True,
+            "version": platform.python_version(),
+        },
+        "playwright": {
+            "ok": importlib.util.find_spec("playwright") is not None,
+            "installed": importlib.util.find_spec("playwright") is not None,
+        },
+        "chrome": {
+            "ok": bool(get_system_chrome_path()),
+            "path": get_system_chrome_path() or "",
+        },
+        "uv": {
+            "ok": shutil.which("uv") is not None,
+            "path": shutil.which("uv") or "",
+        },
+        "runtime_dirs": {
+            "ok": True,
+            "app_home": str(APP_HOME),
+            "log_dir": str(LOG_DIR),
+            "output_dir": str(OUTPUT_DIR),
+        },
+        "storage": {
+            "ok": True,
+            "mode": "file_primary",
+            "accounts_dir": str(APP_HOME / "accounts"),
+            "settings_file": str(APP_HOME / "settings.json"),
+            "task_schedules_file": str(APP_HOME / "task_schedules.json"),
+        },
+    }
+    checks["overall_ok"] = all(item.get("ok", False) for item in checks.values() if isinstance(item, dict))
+    return checks

rednote_cli/application/use_cases/init_runtime.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from rednote_cli._runtime.core.database.manager import init_db
+from rednote_cli.infra.paths import APP_HOME, LOG_DIR, OUTPUT_DIR, configure_legacy_data_paths, ensure_runtime_dirs
+
+
+def execute_runtime_init() -> dict:
+    ensure_runtime_dirs()
+    configure_legacy_data_paths()
+    init_db()
+    return {
+        "app_home": str(APP_HOME),
+        "log_dir": str(LOG_DIR),
+        "output_dir": str(OUTPUT_DIR),
+        "accounts_dir": str(APP_HOME / "accounts"),
+        "settings_file": str(APP_HOME / "settings.json"),
+        "task_schedules_file": str(APP_HOME / "task_schedules.json"),
+        "storage_mode": "file_primary",
+        "store_initialized": True,
+    }

rednote_cli/application/use_cases/note_get.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.platform.rednote.extractor import RednoteExtractorAdapter
+
+
+async def execute_note_get(
+    note_id: str,
+    xsec_token: str | None = None,
+    xsec_source: str | None = "pc_feed",
+    comment_size: int = 10,
+    sub_comment_size: int = 5,
+    account_uid: str | None = None,
+) -> dict:
+    adapter = RednoteExtractorAdapter()
+    return await adapter.get_note_info(
+        note_id=note_id,
+        xsec_token=xsec_token,
+        xsec_source=xsec_source,
+        comment_size=comment_size,
+        sub_comment_size=sub_comment_size,
+        account_uid=account_uid,
+    )

rednote_cli/application/use_cases/note_search.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.platform.rednote.extractor import RednoteExtractorAdapter
+
+
+async def execute_note_search(
+    keyword: str,
+    size: int = 20,
+    sort_by: str | None = None,
+    note_type: str | None = None,
+    publish_time: str | None = None,
+    search_scope: str | None = None,
+    location: str | None = None,
+    account_uid: str | None = None,
+) -> list[dict]:
+    adapter = RednoteExtractorAdapter()
+    return await adapter.search_notes(
+        keyword=keyword,
+        size=size,
+        sort_by=sort_by,
+        note_type=note_type,
+        publish_time=publish_time,
+        search_scope=search_scope,
+        location=location,
+        account_uid=account_uid,
+    )

rednote_cli/application/use_cases/publish_note.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.platform.rednote.publisher import RednotePublisherAdapter
+
+
+async def execute_publish_note(
+    *,
+    target: str,
+    image_list: list[str],
+    title: str = "",
+    content: str = "",
+    tags: list[str] | None = None,
+    schedule_at: str | None = None,
+    account_uid: str | None = None,
+) -> dict:
+    adapter = RednotePublisherAdapter()
+    return await adapter.publish_note(
+        target=target,
+        image_list=image_list,
+        title=title,
+        content=content,
+        tags=tags,
+        schedule_at=schedule_at,
+        account_uid=account_uid,
+    )

rednote_cli/application/use_cases/user_get.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.platform.rednote.extractor import RednoteExtractorAdapter
+
+
+async def execute_user_get(
+    user_id: str,
+    xsec_token: str | None = None,
+    xsec_source: str | None = "pc_feed",
+    account_uid: str | None = None,
+) -> dict:
+    adapter = RednoteExtractorAdapter()
+    return await adapter.get_user_info(
+        user_id=user_id,
+        xsec_token=xsec_token,
+        xsec_source=xsec_source,
+        account_uid=account_uid,
+    )

rednote_cli/application/use_cases/user_search.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.platform.rednote.extractor import RednoteExtractorAdapter
+
+
+async def execute_user_search(keyword: str, size: int = 20, account_uid: str | None = None) -> list[dict]:
+    adapter = RednoteExtractorAdapter()
+    return await adapter.search_users(keyword=keyword, size=size, account_uid=account_uid)

rednote_cli/application/use_cases/user_self.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from rednote_cli.adapters.platform.rednote.extractor import RednoteExtractorAdapter
+
+
+async def execute_user_self(account_uid: str | None = None) -> dict:
+    adapter = RednoteExtractorAdapter()
+    return await adapter.get_self_info(account_uid=account_uid)

rednote_cli/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI entry package."""

rednote_cli/cli/__main__.py

@@ -0,0 +1,5 @@
+from rednote_cli.cli.main import run
+
+
+if __name__ == "__main__":
+    run()

rednote_cli/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands package."""

rednote_cli/cli/commands/account.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from uuid import uuid4
+
+import typer
+
+from rednote_cli.adapters.output.event_stream import emit_event
+from rednote_cli.application.dto.input_models import AccountListInput
+from rednote_cli.application.use_cases.auth_login import execute_auth_login
+from rednote_cli.application.use_cases.auth_status import execute_auth_status
+from rednote_cli.application.use_cases.account_list import execute_account_list
+from rednote_cli.application.use_cases.account_mutation import (
+    execute_account_activate,
+    execute_account_deactivate,
+    execute_account_delete,
+)
+from rednote_cli.cli.options import CliContext
+from rednote_cli.cli.runtime import run_async_command, run_sync_command
+from rednote_cli.cli.utils import all_option_params_are_default
+from rednote_cli.domain.errors import InvalidArgsError
+
+app = typer.Typer(help="账号管理（登录/状态/激活/停用/删除）", no_args_is_help=True)
+
+
+@app.command("login")
+def account_login(
+    ctx: typer.Context,
+    account: str | None = typer.Option(
+        None,
+        "--account",
+        help="账号唯一标识（user_no）",
+    ),
+    mode: str = typer.Option(
+        "local",
+        "--mode",
+        help="登录模式：local（本机扫码）| remote（远程截图扫码）",
+    ),
+    login_timeout_seconds: int = typer.Option(
+        240,
+        "--login-timeout-seconds",
+        min=30,
+        help="扫码登录超时（秒）",
+    ),
+    screenshot_path: str = typer.Option(
+        "",
+        "--screenshot-path",
+        help="remote 模式屏幕截图路径，可传目录或文件路径，默认为 .rednote_cli/outputs/login_viewport.png",
+    ),
+):
+    """启动登录流程并写入持久登录态。"""
+    cli_ctx: CliContext = ctx.obj
+    effective_trace_id = cli_ctx.trace_id or uuid4().hex
+
+    def _progress_callback(event_payload: dict) -> None:
+        event_name = str(event_payload.get("event") or "").strip()
+        if not event_name:
+            return
+        emit_event(
+            command="account.login",
+            event=event_name,
+            trace_id=effective_trace_id,
+            data={k: v for k, v in event_payload.items() if k != "event"},
+        )
+
+    async def _run():
+        return await execute_auth_login(
+            account_uid=(account or "").strip(),
+            mode=mode,
+            login_timeout_seconds=login_timeout_seconds,
+            screenshot_path=screenshot_path,
+            progress_callback=_progress_callback,
+        )
+
+    effective_ctx = replace(
+        cli_ctx,
+        timeout=max(cli_ctx.timeout, login_timeout_seconds + 30),
+        trace_id=effective_trace_id,
+    )
+    run_async_command(
+        ctx=effective_ctx,
+        command="account.login",
+        func=_run,
+    )
+
+
+@app.command("status")
+def account_status(
+    ctx: typer.Context,
+    account: str | None = typer.Option(None, "--account", help="账号唯一标识；为空时检查所有有效账号"),
+):
+    """实时检查并刷新账号登录状态。"""
+    cli_ctx: CliContext = ctx.obj
+
+    async def _run() -> list[dict]:
+        return await execute_auth_status(account_uid=account)
+
+    run_async_command(
+        ctx=cli_ctx,
+        command="account.status",
+        func=_run,
+        account_uid=account,
+    )
+
+
+@app.command("list")
+def account_list(
+    ctx: typer.Context,
+    only_active: str = typer.Option(
+        "true",
+        "--only-active",
+        help="仅显示当前可用账号，需显式传入 true|false（默认 true）",
+    ),
+):
+    """列出账号池。"""
+    cli_ctx: CliContext = ctx.obj
+
+    def _run() -> list[dict]:
+        validated = AccountListInput(only_active=only_active.strip())
+        return execute_account_list(only_active=validated.only_active)
+
+    run_sync_command(
+        ctx=cli_ctx,
+        command="account.list",
+        func=_run,
+    )
+
+
+@app.command("activate")
+def account_activate(
+    ctx: typer.Context,
+    account: str | None = typer.Option(None, "--account", help="账号唯一标识（user_no）"),
+):
+    """将账号标记为可用。"""
+    if all_option_params_are_default(ctx=ctx):
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+    cli_ctx: CliContext = ctx.obj
+    account_uid = (account or "").strip()
+
+    def _run() -> dict:
+        if not account_uid:
+            raise InvalidArgsError("`--account` 为必填参数")
+        return execute_account_activate(account_uid=account_uid)
+
+    run_sync_command(
+        ctx=cli_ctx,
+        command="account.activate",
+        func=_run,
+        account_uid=account_uid,
+    )
+
+
+@app.command("deactivate")
+def account_deactivate(
+    ctx: typer.Context,
+    account: str | None = typer.Option(None, "--account", help="账号唯一标识（user_no）"),
+):
+    """将账号标记为不可用。"""
+    if all_option_params_are_default(ctx=ctx):
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+    cli_ctx: CliContext = ctx.obj
+    account_uid = (account or "").strip()
+
+    def _run() -> dict:
+        if not account_uid:
+            raise InvalidArgsError("`--account` 为必填参数")
+        return execute_account_deactivate(account_uid=account_uid)
+
+    run_sync_command(
+        ctx=cli_ctx,
+        command="account.deactivate",
+        func=_run,
+        account_uid=account_uid,
+    )
+
+
+@app.command("delete")
+def account_delete(
+    ctx: typer.Context,
+    account: str | None = typer.Option(None, "--account", help="账号唯一标识（user_no）"),
+):
+    """删除账号记录（不会清理业务输出文件）。"""
+    if all_option_params_are_default(ctx=ctx):
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+    cli_ctx: CliContext = ctx.obj
+    account_uid = (account or "").strip()
+
+    def _run() -> dict:
+        if not account_uid:
+            raise InvalidArgsError("`--account` 为必填参数")
+        return execute_account_delete(account_uid=account_uid)
+
+    run_sync_command(
+        ctx=cli_ctx,
+        command="account.delete",
+        func=_run,
+        account_uid=account_uid,
+    )

rednote_cli/cli/commands/doctor.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import typer
+
+from rednote_cli.application.use_cases.doctor import execute_doctor
+from rednote_cli.cli.options import CliContext
+from rednote_cli.cli.runtime import run_sync_command
+
+app = typer.Typer(help="环境诊断与依赖自检", no_args_is_help=True)
+
+
+@app.command("run")
+def doctor_run(ctx: typer.Context):
+    """
+    执行自检并输出可机读诊断结果。
+
+    推荐：`rednote-cli doctor run --format json`。
+    """
+    cli_ctx: CliContext = ctx.obj
+    run_sync_command(ctx=cli_ctx, command="doctor.run", func=execute_doctor)

rednote_cli/cli/commands/init.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import typer
+
+from rednote_cli.application.use_cases.init_runtime import execute_runtime_init
+from rednote_cli.cli.options import CliContext
+from rednote_cli.cli.runtime import run_sync_command
+
+app = typer.Typer(help="初始化运行环境与本地存储", no_args_is_help=True)
+
+
+@app.command("runtime")
+def init_runtime(ctx: typer.Context):
+    """
+    初始化运行时目录与存储文件。
+
+    返回字段包括 `app_home`、`accounts_dir`、`settings_file`、`task_schedules_file`。
+    """
+    cli_ctx: CliContext = ctx.obj
+    run_sync_command(ctx=cli_ctx, command="init.runtime", func=execute_runtime_init)