rednote-cli 0.1.0__py3-none-any.whl

rednote_cli/cli/main.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import sys
+
+import typer
+from loguru import logger
+
+from rednote_cli._runtime.common.config import is_browser_headful_forced
+from rednote_cli._runtime.core.database.manager import init_db
+from rednote_cli.adapters.platform.rednote.runtime_registration import register_rednote_runtime
+from rednote_cli.cli.commands import account, doctor, init, note, publish, search, user
+from rednote_cli.cli.options import CliContext
+from rednote_cli.infra.logger import setup_cli_logger
+from rednote_cli.infra.paths import configure_legacy_data_paths, ensure_runtime_dirs
+from rednote_cli.infra.platforms import REDNOTE_PLATFORM
+
+APP_HELP = """
+Rednote CLI（非驻留，一次命令一次进程）。
+
+推荐给 AI/Agent 的调用约定：
+- 输出固定使用 `--format json`
+- 每次调用传 `--trace-id`
+- 需要批量参数时使用 `--input <json-file|->`
+
+输入优先级：
+- 显式 CLI 参数 > `--input` JSON 同名字段 > 默认值
+
+输出契约与错误码：
+- 成功/失败 JSON 结构见 `schemas/*.json`
+- 退出码：0 成功，2 参数错，3 认证错，4 风控，5 内部错，6 超时，7 依赖缺失/未实现
+
+快速开始：
+- `rednote-cli init runtime`
+- `rednote-cli doctor run --format json`
+- `rednote-cli search note --keyword 旅行 --size 10 --sort-by latest --note-type image_text --format json`
+- `rednote-cli note --note-id <id> --format json`
+""".strip()
+
+app = typer.Typer(help=APP_HELP, add_completion=False, no_args_is_help=True)
+
+app.add_typer(init.app, name="init")
+app.add_typer(doctor.app, name="doctor")
+app.add_typer(account.app, name="account")
+app.add_typer(note.app, name="note")
+app.add_typer(user.app, name="user")
+app.add_typer(search.app, name="search")
+app.add_typer(publish.app, name="publish")
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    format: str = typer.Option("table", "--format", help="输出格式：json(推荐给 Agent) | jsonl(流式) | table(人工查看)"),
+    out: str | None = typer.Option(None, "--out", help="将最终输出写入文件；stderr 日志不受影响"),
+    quiet: bool = typer.Option(False, "--quiet", help="静默日志，仅输出结果"),
+    trace_id: str | None = typer.Option(None, "--trace-id", help="请求链路 ID，方便排查和关联日志/结果；建议外部系统全程透传"),
+    timeout: int = typer.Option(120, "--timeout", help="命令超时（秒）"),
+):
+    if format not in {"json", "jsonl", "table"}:
+        raise typer.BadParameter("--format 仅支持 json|jsonl|table")
+
+    register_rednote_runtime()
+    ensure_runtime_dirs()
+    configure_legacy_data_paths()
+    init_db()
+    setup_cli_logger(quiet=quiet)
+    if is_browser_headful_forced():
+        logger.warning("Browser headful mode forced by env (REDNOTE_CLI_HEADFUL/BROWSER_HEADFUL).")
+
+    ctx.obj = CliContext(
+        platform_name=REDNOTE_PLATFORM,
+        output_format=format,
+        out_file=out,
+        quiet=quiet,
+        trace_id=trace_id,
+        timeout=timeout,
+    )
+
+
+def _normalize_global_options_position() -> None:
+    """Allow global options to appear after subcommands.
+
+    Click/Typer requires group options to appear before subcommands by default.
+    This shim rewrites argv so both forms work:
+    - rednote-cli --format json doctor run
+    - rednote-cli doctor run --format json
+    """
+    if len(sys.argv) <= 1:
+        return
+
+    command_names = {"init", "doctor", "account", "note", "user", "search", "publish"}
+    value_options = {"--format", "--out", "--trace-id", "--timeout"}
+    flag_options = {"--quiet"}
+    all_options = value_options | flag_options
+
+    raw_args = sys.argv[1:]
+    moved: list[str] = []
+    kept: list[str] = []
+
+    def _die_missing_value(option: str) -> None:
+        option_examples = {
+            "--format": "rednote-cli doctor run --format json",
+            "--out": "rednote-cli doctor run --out result.json",
+            "--trace-id": "rednote-cli doctor run --trace-id req-001",
+            "--timeout": "rednote-cli doctor run --timeout 120",
+        }
+        example = option_examples.get(option, f"rednote-cli doctor run {option} <value>")
+        typer.echo(
+            f"Error: `{option}` 需要一个值。例如：`{example}`",
+            err=True,
+        )
+        raise SystemExit(2)
+
+    i = 0
+    while i < len(raw_args):
+        token = raw_args[i]
+        if token == "--":
+            kept.extend(raw_args[i:])
+            break
+
+        if token in flag_options:
+            moved.append(token)
+            i += 1
+            continue
+
+        if token in value_options:
+            if i + 1 >= len(raw_args):
+                _die_missing_value(token)
+            next_token = raw_args[i + 1]
+            if next_token == "--":
+                _die_missing_value(token)
+            if token == "--out" and next_token in command_names:
+                _die_missing_value(token)
+            moved.append(token)
+            moved.append(next_token)
+            i += 2
+            continue
+
+        matched_inline = False
+        for opt in all_options:
+            prefix = f"{opt}="
+            if token.startswith(prefix):
+                moved.append(token)
+                matched_inline = True
+                break
+        if matched_inline:
+            i += 1
+            continue
+
+        kept.append(token)
+        i += 1
+
+    if moved:
+        sys.argv = [sys.argv[0], *moved, *kept]
+
+
+def run() -> None:
+    _normalize_global_options_position()
+    app()
+
+
+if __name__ == "__main__":
+    run()

rednote_cli/cli/options.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CliContext:
+    platform_name: str = "Rednote"
+    output_format: str = "table"
+    out_file: str | None = None
+    quiet: bool = False
+    trace_id: str | None = None
+    timeout: int = 120

rednote_cli/cli/runtime.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from typing import Any, Awaitable, Callable
+
+import typer
+from pydantic import ValidationError
+
+from rednote_cli._runtime.common.errors import InvalidPublishParameterError, PublishNoteException
+from rednote_cli._runtime.platforms.base import RiskControlException
+from rednote_cli.adapters.output.formatter_json import format_json, format_jsonl
+from rednote_cli.adapters.output.formatter_table import format_table
+from rednote_cli.adapters.output.writer import write_output
+from rednote_cli.application.dto.output_models import build_error_output, build_success_output
+from rednote_cli.cli.options import CliContext
+from rednote_cli.domain.errors import CliError, InternalError
+from rednote_cli.infra.exit_codes import ExitCode, map_error_code_to_exit_code
+
+
+async def _with_timeout(coro: Awaitable[Any], timeout: int) -> Any:
+    return await asyncio.wait_for(coro, timeout=timeout)
+
+
+def _render_payload(payload: Any, output_format: str) -> str:
+    if output_format == "json":
+        return format_json(payload)
+    if output_format == "jsonl":
+        if isinstance(payload, list):
+            return format_jsonl(payload)
+        return format_jsonl([payload])
+    if hasattr(payload, "model_dump"):
+        payload = payload.model_dump(mode="json")
+    if isinstance(payload, dict) and "data" in payload:
+        return format_table(payload["data"])
+    return format_table(payload)
+
+
+def _normalize_error(exc: Exception) -> CliError:
+    if isinstance(exc, CliError):
+        return exc
+    if isinstance(exc, ValidationError):
+        try:
+            normalized_errors = exc.errors(include_context=False, include_input=False)
+        except TypeError:
+            normalized_errors = exc.errors()
+        return CliError(code="INVALID_ARGS", message="参数校验失败", details={"errors": normalized_errors})
+    if isinstance(exc, InvalidPublishParameterError):
+        return CliError(code="INVALID_ARGS", message=str(exc))
+    if isinstance(exc, RiskControlException):
+        return CliError(code="RISK_CONTROL_TRIGGERED", message=str(exc))
+    if isinstance(exc, asyncio.TimeoutError):
+        return CliError(code="TIMEOUT", message="命令执行超时")
+    if isinstance(exc, PublishNoteException):
+        return CliError(code="INTERNAL_ERROR", message=str(exc))
+    if "No available" in str(exc):
+        return CliError(code="ACCOUNT_UNAVAILABLE", message=str(exc))
+    internal = InternalError(message=f"未处理异常: {exc}")
+    return CliError(code=internal.code, message=internal.message)
+
+
+def run_sync_command(
+    *,
+    ctx: CliContext,
+    command: str,
+    func: Callable[[], Any],
+    platform: str | None = None,
+    account_uid: str | None = None,
+) -> None:
+    effective_platform = platform or ctx.platform_name
+    trace_id = ctx.trace_id or uuid.uuid4().hex
+    start = time.time()
+    try:
+        data = func()
+        duration_ms = int((time.time() - start) * 1000)
+        payload = build_success_output(
+            command=command,
+            data=data,
+            trace_id=trace_id,
+            duration_ms=duration_ms,
+            platform=effective_platform,
+            account_uid=account_uid,
+        )
+        write_output(_render_payload(payload, ctx.output_format), out_file=ctx.out_file)
+        raise typer.Exit(code=ExitCode.SUCCESS.value)
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        err = _normalize_error(exc)
+        duration_ms = int((time.time() - start) * 1000)
+        payload = build_error_output(
+            command=command,
+            code=err.code,
+            message=err.message,
+            details=err.details,
+            trace_id=trace_id,
+            duration_ms=duration_ms,
+        )
+        write_output(format_json(payload), out_file=ctx.out_file)
+        raise typer.Exit(code=map_error_code_to_exit_code(err.code).value)
+
+
+def run_async_command(
+    *,
+    ctx: CliContext,
+    command: str,
+    func: Callable[[], Awaitable[Any]],
+    platform: str | None = None,
+    account_uid: str | None = None,
+) -> None:
+    effective_platform = platform or ctx.platform_name
+    trace_id = ctx.trace_id or uuid.uuid4().hex
+    start = time.time()
+    try:
+        data = asyncio.run(_with_timeout(func(), timeout=ctx.timeout))
+        duration_ms = int((time.time() - start) * 1000)
+        payload = build_success_output(
+            command=command,
+            data=data,
+            trace_id=trace_id,
+            duration_ms=duration_ms,
+            platform=effective_platform,
+            account_uid=account_uid,
+        )
+        write_output(_render_payload(payload, ctx.output_format), out_file=ctx.out_file)
+        raise typer.Exit(code=ExitCode.SUCCESS.value)
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        err = _normalize_error(exc)
+        duration_ms = int((time.time() - start) * 1000)
+        payload = build_error_output(
+            command=command,
+            code=err.code,
+            message=err.message,
+            details=err.details,
+            trace_id=trace_id,
+            duration_ms=duration_ms,
+        )
+        write_output(format_json(payload), out_file=ctx.out_file)
+        raise typer.Exit(code=map_error_code_to_exit_code(err.code).value)

rednote_cli/cli/utils.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from click import Option
+from click.core import ParameterSource
+
+
+def parse_csv(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [item.strip() for item in value.split(",") if item and item.strip()]
+
+
+def load_json_input(path_or_dash: str | None) -> dict[str, Any]:
+    if not path_or_dash:
+        return {}
+    if path_or_dash == "-":
+        import sys
+
+        raw = sys.stdin.read()
+        return json.loads(raw) if raw.strip() else {}
+    path = Path(path_or_dash).expanduser().resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"input 文件不存在: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def pick_value(value: Any, fallback_dict: dict[str, Any], key: str) -> Any:
+    if value is not None:
+        return value
+    return fallback_dict.get(key)
+
+
+def pick_cli_or_input(
+    *,
+    ctx: Any,
+    param_name: str,
+    cli_value: Any,
+    payload: dict[str, Any],
+    payload_key: str,
+) -> Any:
+    """Resolve value precedence: explicit CLI option > --input JSON > CLI default."""
+    try:
+        source = ctx.get_parameter_source(param_name)
+    except Exception:
+        source = None
+
+    if source == ParameterSource.DEFAULT and payload_key in payload:
+        return payload[payload_key]
+    if cli_value is not None:
+        return cli_value
+    return payload.get(payload_key)
+
+
+def all_option_params_are_default(*, ctx: Any) -> bool:
+    """Return True when all option params are from default source (no CLI override)."""
+    command = getattr(ctx, "command", None)
+    params = getattr(command, "params", None) or []
+    for param in params:
+        if not isinstance(param, Option):
+            continue
+        name = getattr(param, "name", None)
+        if not name:
+            continue
+        try:
+            source = ctx.get_parameter_source(name)
+        except Exception:
+            return False
+        if source != ParameterSource.DEFAULT:
+            return False
+    return True

rednote_cli/domain/__init__.py

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

rednote_cli/domain/errors.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CliError(Exception):
+    """Base CLI error carrying protocol-level codes."""
+
+    code: str
+    message: str
+    details: dict | None = None
+
+    def __str__(self) -> str:  # pragma: no cover - trivial
+        return self.message
+
+
+class InvalidArgsError(CliError):
+    def __init__(self, message: str, details: dict | None = None):
+        super().__init__("INVALID_ARGS", message, details)
+
+
+class AuthRequiredError(CliError):
+    def __init__(self, message: str = "登录失效或未登录", details: dict | None = None):
+        super().__init__("AUTH_REQUIRED", message, details)
+
+
+class AccountUnavailableError(CliError):
+    def __init__(self, message: str = "无可用账号", details: dict | None = None):
+        super().__init__("ACCOUNT_UNAVAILABLE", message, details)
+
+
+class RiskControlError(CliError):
+    def __init__(self, message: str = "命中风控", details: dict | None = None):
+        super().__init__("RISK_CONTROL_TRIGGERED", message, details)
+
+
+class DependencyMissingError(CliError):
+    def __init__(self, message: str = "运行依赖缺失", details: dict | None = None):
+        super().__init__("DEPENDENCY_MISSING", message, details)
+
+
+class CliTimeoutError(CliError):
+    def __init__(self, message: str = "执行超时", details: dict | None = None):
+        super().__init__("TIMEOUT", message, details)
+
+
+class InternalError(CliError):
+    def __init__(self, message: str = "内部异常", details: dict | None = None):
+        super().__init__("INTERNAL_ERROR", message, details)

rednote_cli/domain/note_search_filters.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+FILTER_FIELD_ORDER = ("sort_by", "note_type", "publish_time", "search_scope", "location")
+
+_FILTER_CONFIG = {
+    "sort_by": {
+        "aliases": {
+            "comprehensive": "comprehensive",
+            "综合": "comprehensive",
+            "latest": "latest",
+            "最新": "latest",
+            "most_liked": "most_liked",
+            "最多点赞": "most_liked",
+            "most_commented": "most_commented",
+            "最多评论": "most_commented",
+            "most_favorited": "most_favorited",
+            "最多收藏": "most_favorited",
+        },
+        "selectors": {
+            "comprehensive": (1, 1, "综合"),
+            "latest": (1, 2, "最新"),
+            "most_liked": (1, 3, "最多点赞"),
+            "most_commented": (1, 4, "最多评论"),
+            "most_favorited": (1, 5, "最多收藏"),
+        },
+    },
+    "note_type": {
+        "aliases": {
+            "all": "all",
+            "不限": "all",
+            "video": "video",
+            "视频": "video",
+            "image_text": "image_text",
+            "图文": "image_text",
+        },
+        "selectors": {
+            "all": (2, 1, "不限"),
+            "video": (2, 2, "视频"),
+            "image_text": (2, 3, "图文"),
+        },
+    },
+    "publish_time": {
+        "aliases": {
+            "all": "all",
+            "不限": "all",
+            "day": "day",
+            "一天内": "day",
+            "week": "week",
+            "一周内": "week",
+            "half_year": "half_year",
+            "半年内": "half_year",
+        },
+        "selectors": {
+            "all": (3, 1, "不限"),
+            "day": (3, 2, "一天内"),
+            "week": (3, 3, "一周内"),
+            "half_year": (3, 4, "半年内"),
+        },
+    },
+    "search_scope": {
+        "aliases": {
+            "all": "all",
+            "不限": "all",
+            "viewed": "viewed",
+            "已看过": "viewed",
+            "unviewed": "unviewed",
+            "未看过": "unviewed",
+            "following": "following",
+            "已关注": "following",
+        },
+        "selectors": {
+            "all": (4, 1, "不限"),
+            "viewed": (4, 2, "已看过"),
+            "unviewed": (4, 3, "未看过"),
+            "following": (4, 4, "已关注"),
+        },
+    },
+    "location": {
+        "aliases": {
+            "all": "all",
+            "不限": "all",
+            "local": "local",
+            "同城": "local",
+            "nearby": "nearby",
+            "附近": "nearby",
+        },
+        "selectors": {
+            "all": (5, 1, "不限"),
+            "local": (5, 2, "同城"),
+            "nearby": (5, 3, "附近"),
+        },
+    },
+}
+
+
+@dataclass(frozen=True)
+class SearchFilterSelection:
+    field: str
+    value: str
+    filters_index: int
+    tags_index: int
+    label: str
+
+
+def normalize_filter_value(field: str, value: str | None) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    config = _FILTER_CONFIG.get(field)
+    if config is None:
+        raise ValueError(f"未知筛选字段: {field}")
+    aliases = config["aliases"]
+    normalized = aliases.get(text) or aliases.get(text.lower())
+    if normalized:
+        return normalized
+    canonical = sorted(config["selectors"].keys())
+    raise ValueError(f"{field} 不支持 '{text}'，可选值: {', '.join(canonical)}")
+
+
+def build_search_filter_selections(
+    *,
+    sort_by: str | None = None,
+    note_type: str | None = None,
+    publish_time: str | None = None,
+    search_scope: str | None = None,
+    location: str | None = None,
+) -> list[SearchFilterSelection]:
+    values = {
+        "sort_by": sort_by,
+        "note_type": note_type,
+        "publish_time": publish_time,
+        "search_scope": search_scope,
+        "location": location,
+    }
+    selections: list[SearchFilterSelection] = []
+    for field in FILTER_FIELD_ORDER:
+        value = values[field]
+        if not value:
+            continue
+        selectors = _FILTER_CONFIG[field]["selectors"]
+        filters_index, tags_index, label = selectors[value]
+        selections.append(
+            SearchFilterSelection(
+                field=field,
+                value=value,
+                filters_index=filters_index,
+                tags_index=tags_index,
+                label=label,
+            )
+        )
+    return selections

rednote_cli/infra/__init__.py

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

rednote_cli/infra/exit_codes.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class ExitCode(IntEnum):
+    SUCCESS = 0
+    INVALID_ARGS = 2
+    AUTH_REQUIRED = 3
+    RISK_CONTROL = 4
+    INTERNAL_ERROR = 5
+    TIMEOUT = 6
+    DEPENDENCY_MISSING = 7
+
+
+ERROR_CODE_TO_EXIT_CODE: dict[str, ExitCode] = {
+    "INVALID_ARGS": ExitCode.INVALID_ARGS,
+    "AUTH_REQUIRED": ExitCode.AUTH_REQUIRED,
+    "ACCOUNT_UNAVAILABLE": ExitCode.INVALID_ARGS,
+    "RISK_CONTROL_TRIGGERED": ExitCode.RISK_CONTROL,
+    "RATE_LIMITED": ExitCode.RISK_CONTROL,
+    "UPSTREAM_CHANGED": ExitCode.INTERNAL_ERROR,
+    "TIMEOUT": ExitCode.TIMEOUT,
+    "DEPENDENCY_MISSING": ExitCode.DEPENDENCY_MISSING,
+    "INTERNAL_ERROR": ExitCode.INTERNAL_ERROR,
+}
+
+
+def map_error_code_to_exit_code(code: str) -> ExitCode:
+    return ERROR_CODE_TO_EXIT_CODE.get(code, ExitCode.INTERNAL_ERROR)

rednote_cli/infra/logger.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import sys
+
+from loguru import logger
+
+
+def setup_cli_logger(quiet: bool = False) -> None:
+    logger.remove()
+    level = "ERROR" if quiet else "INFO"
+    logger.add(sys.stderr, level=level, colorize=True, backtrace=False, diagnose=False)

rednote_cli/infra/paths.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+APP_HOME = Path(os.getenv("REDNOTE_OPERATOR_HOME", str(Path.cwd() / ".rednote_cli"))).expanduser().resolve()
+SCHEMA_DIR = APP_HOME / "schemas"
+LOG_DIR = APP_HOME / "logs"
+OUTPUT_DIR = APP_HOME / "outputs"
+DB_FILE = APP_HOME / "rednote_cli.db"
+
+
+def ensure_runtime_dirs() -> None:
+    APP_HOME.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def configure_legacy_data_paths() -> None:
+    """Force legacy modules to use CLI runtime paths.
+
+    Existing modules import DB path at module level, so both origins must be patched.
+    """
+    import rednote_cli._runtime.common.config as common_config
+    import rednote_cli._runtime.core.database.manager as db_manager
+
+    common_config.APP_DATA_DIR = APP_HOME
+    common_config.LOG_DIR = LOG_DIR
+    common_config.LOG_FILE = LOG_DIR / "app.log"
+    common_config.DB_FILE = DB_FILE
+    db_manager.DB_FILE = DB_FILE

rednote_cli/infra/platforms.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+REDNOTE_PLATFORM = "Rednote"
+TIKTOK_PLATFORM = "TikTok"