openboost-cli 0.1.0__py3-none-any.whl

proboost_cli/cli/main.py

@@ -0,0 +1,566 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from proboost_cli import MCP_LABELS, MCP_NAMES, __version__
+from proboost_cli.cli import interactive
+from proboost_cli.coerce_args import merge_tool_arguments_json
+from proboost_cli.config import (
+    effective_secret_and_base,
+    load_config,
+    mask_secret,
+    normalize_mcp_name,
+    update_config,
+)
+from proboost_cli.mcp_client import extract_result_text, invoke_tool_async
+from proboost_cli.parse_result import decode_embedded_payload
+from proboost_cli.registry import DOMAIN_LABELS, DOMAIN_TOOLS, TOOLS
+from proboost_cli.schemas_loader import load_tool_definitions, tool_schema_properties, tool_schema_required
+
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+console = Console()
+
+app = typer.Typer(
+    name="proboost",
+    help="Proboost CLI — 统一调用 TikTok / Patent / Amazon MCP",
+    no_args_is_help=False,
+    add_completion=False,
+)
+config_app = typer.Typer(help="配置 secret-key 和 MCP URL")
+tiktok_app = typer.Typer(help="TikTok MCP")
+tiktok_statistics_app = typer.Typer(help="TikTok 大盘统计")
+tiktok_commodity_app = typer.Typer(help="TikTok 商品选品")
+tiktok_expert_app = typer.Typer(help="TikTok 达人分析")
+tiktok_video_app = typer.Typer(help="TikTok 视频分析")
+tiktok_shop_app = typer.Typer(help="TikTok 店铺分析")
+patent_app = typer.Typer(help="Patent MCP")
+patent_search_app = typer.Typer(help="专利检索")
+patent_detail_app = typer.Typer(help="专利详情")
+patent_image_app = typer.Typer(help="专利图像检索")
+amazon_app = typer.Typer(help="Amazon MCP")
+amazon_product_app = typer.Typer(help="Amazon 商品与市场")
+amazon_hot_app = typer.Typer(help="Amazon 榜单")
+
+app.add_typer(config_app, name="config")
+app.add_typer(tiktok_app, name="tiktok")
+app.add_typer(patent_app, name="patent")
+app.add_typer(amazon_app, name="amazon")
+tiktok_app.add_typer(tiktok_statistics_app, name="statistics")
+tiktok_app.add_typer(tiktok_commodity_app, name="commodity")
+tiktok_app.add_typer(tiktok_expert_app, name="expert")
+tiktok_app.add_typer(tiktok_video_app, name="video")
+tiktok_app.add_typer(tiktok_shop_app, name="shop")
+patent_app.add_typer(patent_search_app, name="search")
+patent_app.add_typer(patent_detail_app, name="detail")
+patent_app.add_typer(patent_image_app, name="image-search")
+amazon_app.add_typer(amazon_product_app, name="product")
+amazon_app.add_typer(amazon_hot_app, name="hot")
+
+_state: dict[str, str | None] = {"secret_key": None, "base_url": None}
+
+KeyOpt = Annotated[Optional[str], typer.Option("--key", "-k", help="secret-key")]
+BaseUrlOpt = Annotated[Optional[str], typer.Option("--base-url", "-u", help="MCP Streamable HTTP URL")]
+McpArg = Annotated[str, typer.Argument(help="MCP 名称: tiktok / patent / amazon")]
+CountryOpt = Annotated[str, typer.Option("--country-region", "--country", help="国家/地区，如 美国")]
+CurrentOpt = Annotated[Optional[int], typer.Option("--current", help="当前页码")]
+SizeOpt = Annotated[Optional[int], typer.Option("--size", help="每页条数")]
+DataPeriodOpt = Annotated[Optional[str], typer.Option("--data-period", help="数据周期，如 last7d / last30d")]
+DateOpt = Annotated[Optional[str], typer.Option("--date", help="数据日期")]
+OrderTypeOpt = Annotated[Optional[str], typer.Option("--order-type", help="排序类型")]
+ExtraArg = Annotated[Optional[list[str]], typer.Argument(help="额外参数 key=value ...")]
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context, key: KeyOpt = None, base_url: BaseUrlOpt = None) -> None:
+    _state["secret_key"] = key
+    _state["base_url"] = base_url
+    if ctx.invoked_subcommand is None:
+        interactive.run_interactive(secret_key=key, base_url=base_url)
+
+
+def _print_json(data: Any) -> None:
+    if isinstance(data, (dict, list)):
+        console.print_json(json.dumps(data, ensure_ascii=False))
+    else:
+        console.print(str(data))
+
+
+def _props(mcp: str, tool_name: str) -> dict[str, Any]:
+    return tool_schema_properties(load_tool_definitions(mcp)[tool_name])
+
+
+def _parse_extra(mcp: str, tool_name: str, extra: list[str] | None) -> dict[str, Any]:
+    return merge_tool_arguments_json({}, tuple(extra or []), props=_props(mcp, tool_name))
+
+
+def _compact(kwargs: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in kwargs.items() if v is not None}
+
+
+def _with_extra(mcp: str, tool_name: str, base: dict[str, Any], extra: list[str] | None) -> dict[str, Any]:
+    merged = _parse_extra(mcp, tool_name, extra)
+    merged.update(_compact(base))
+    return merged
+
+
+def _page_args(current: int | None, size: int | None) -> dict[str, Any]:
+    return {"current": current, "size": size}
+
+
+def _run_tool(mcp: str, tool_name: str, arguments: dict[str, Any], *, verbatim: bool = False) -> None:
+    mcp = normalize_mcp_name(mcp)
+    secret, base = effective_secret_and_base(
+        mcp,
+        secret_key=_state.get("secret_key"),
+        base_url=_state.get("base_url"),
+    )
+    if not secret:
+        console.print(
+            f"[red]缺少 {MCP_LABELS[mcp]} secret-key。[/red]请设置 PROBOOST_SECRET_KEY 或运行 proboost config set --secret-key ..."
+        )
+        raise typer.Exit(1)
+    try:
+        result = asyncio.run(invoke_tool_async(base, secret, tool_name, _compact(arguments)))
+    except Exception as exc:
+        console.print(str(exc), style="red")
+        raise typer.Exit(2) from exc
+
+    text = extract_result_text(result)
+    if verbatim:
+        console.print(text)
+        raise typer.Exit(3 if result.isError else 0)
+    if result.isError:
+        console.print(text or "(tool error)", style="red")
+        raise typer.Exit(3)
+    structured = getattr(result, "structuredContent", None)
+    if isinstance(structured, (dict, list)):
+        _print_json(structured)
+        return
+    try:
+        _print_json(decode_embedded_payload(text))
+    except ValueError:
+        console.print(text)
+
+
+@app.command("version")
+def version_cmd() -> None:
+    """显示版本号"""
+    console.print(__version__)
+
+
+@app.command("tui")
+def tui_cmd() -> None:
+    """进入交互式菜单"""
+    interactive.run_interactive(secret_key=_state.get("secret_key"), base_url=_state.get("base_url"))
+
+
+@config_app.command("set")
+def config_set_cmd(
+    secret_key: Annotated[Optional[str], typer.Option("--secret-key", "-k", help="secret-key")] = None,
+    mcp: Annotated[Optional[str], typer.Option("--mcp", help="仅配置某个 MCP: tiktok / patent / amazon")] = None,
+    base_url: BaseUrlOpt = None,
+) -> None:
+    """保存通用或单 MCP 配置"""
+    if secret_key is None and base_url is None:
+        console.print("[red]请至少提供 --secret-key 或 --base-url[/red]")
+        raise typer.Exit(2)
+    update_config(mcp=mcp, secret_key=secret_key, base_url=base_url)
+    console.print("[green]配置已保存。[/green]")
+
+
+@config_app.command("show")
+def config_show_cmd() -> None:
+    """查看当前生效配置（密钥脱敏）"""
+    cfg = load_config()
+    console.print(f"config file: {Path.home() / '.config/proboost/config.json'}")
+    if cfg.get("secret_key"):
+        console.print(f"global secret_key: {mask_secret(str(cfg['secret_key']))}")
+    for mcp in MCP_NAMES:
+        secret, base = effective_secret_and_base(mcp)
+        console.print(f"{mcp:7} base_url   : {base}")
+        console.print(f"{mcp:7} secret_key : {mask_secret(secret)}")
+    if os.environ.get("PROBOOST_SECRET_KEY"):
+        console.print("env PROBOOST_SECRET_KEY is set")
+
+
+@app.command("list")
+def list_tools_cmd() -> None:
+    """列出全部 MCP 工具"""
+    for mcp in MCP_NAMES:
+        console.print(f"[bold]{MCP_LABELS[mcp]} MCP[/bold]")
+        for domain, tool_names in DOMAIN_TOOLS[mcp].items():
+            table = Table(title=DOMAIN_LABELS[mcp].get(domain, domain), show_header=True, header_style="bold cyan")
+            table.add_column("工具", style="green")
+            table.add_column("说明")
+            table.add_column("必填参数")
+            for tool_name in tool_names:
+                meta = TOOLS[mcp][tool_name]
+                table.add_row(tool_name, meta.label, ", ".join(meta.required) or "-")
+            console.print(table)
+        console.print()
+    total = sum(len(TOOLS[mcp]) for mcp in MCP_NAMES)
+    console.print(f"[bold]共 {total} 个工具[/bold]")
+
+
+@app.command("docs")
+def docs_cmd(mcp: McpArg, tool_name: str = typer.Argument(..., help="工具名")) -> None:
+    """查看工具描述和参数"""
+    mcp = normalize_mcp_name(mcp)
+    defs = load_tool_definitions(mcp)
+    if tool_name not in defs:
+        console.print(f"[red]未知工具: {mcp}.{tool_name}[/red]")
+        raise typer.Exit(2)
+    tool = defs[tool_name]
+    console.print(f"[bold]{mcp}.{tool_name}[/bold]")
+    console.print(str(tool.get("description", "")))
+    props = tool_schema_properties(tool)
+    required = set(tool_schema_required(tool))
+    table = Table(title="参数", show_header=True, header_style="bold cyan")
+    table.add_column("参数")
+    table.add_column("类型")
+    table.add_column("必填")
+    table.add_column("说明")
+    for name, schema in props.items():
+        if isinstance(schema, dict):
+            table.add_row(name, str(schema.get("type", "")), "是" if name in required else "否", str(schema.get("description", ""))[:100])
+    console.print(table)
+
+
+@app.command("call")
+def call_tool_cmd(
+    mcp: McpArg,
+    tool_name: str = typer.Argument(..., help="MCP 工具名"),
+    verbatim: Annotated[bool, typer.Option("--verbatim", "-v", help="输出原始 MCP 文本")] = False,
+    payload_file: Annotated[Optional[Path], typer.Option("--payload", "-p", exists=True, dir_okay=False, readable=True, help="JSON 参数文件")] = None,
+    payload_stdin: Annotated[bool, typer.Option("--stdin", "-i", help="从 stdin 读取 JSON 参数")] = False,
+    set_kv: Annotated[list[str], typer.Option("--set", "-s", help="参数 key=value，可重复")] = [],
+) -> None:
+    """通用 MCP 工具调用"""
+    mcp = normalize_mcp_name(mcp)
+    defs = load_tool_definitions(mcp)
+    if tool_name not in defs:
+        console.print(f"[red]未知工具: {mcp}.{tool_name}[/red]")
+        raise typer.Exit(2)
+    if payload_stdin and payload_file is not None:
+        console.print("[red]--stdin 和 --payload 只能使用一个。[/red]")
+        raise typer.Exit(2)
+
+    base_obj: dict[str, Any] = {}
+    raw_text: str | None = None
+    if payload_stdin:
+        raw_text = sys.stdin.read()
+    elif payload_file is not None:
+        raw_text = payload_file.read_text(encoding="utf-8")
+    if raw_text and raw_text.strip():
+        decoded = json.loads(raw_text)
+        if not isinstance(decoded, dict):
+            console.print("[red]payload JSON 必须是对象。[/red]")
+            raise typer.Exit(2)
+        base_obj = decoded
+
+    args = merge_tool_arguments_json(base_obj, tuple(set_kv), props=tool_schema_properties(defs[tool_name]))
+    _run_tool(mcp, tool_name, args, verbatim=verbatim)
+
+
+# TikTok shortcuts
+@tiktok_statistics_app.command("total")
+def tiktok_statistics_total(country_region: CountryOpt = "美国", data_period: DataPeriodOpt = "last7d", date: DateOpt = None, extra: ExtraArg = None) -> None:
+    _run_tool("tiktok", "tt_commodity_statistics_get_total_statistics", _with_extra("tiktok", "tt_commodity_statistics_get_total_statistics", {"countryRegion": country_region, "dataPeriod": data_period, "date": date}, extra))
+
+
+@tiktok_statistics_app.command("category")
+def tiktok_statistics_category(country_region: CountryOpt = "美国", data_period: DataPeriodOpt = "last7d", order_type: OrderTypeOpt = None, extra: ExtraArg = None) -> None:
+    _run_tool("tiktok", "tt_commodity_statistics_get_category_statistics", _with_extra("tiktok", "tt_commodity_statistics_get_category_statistics", {"countryRegion": country_region, "dataPeriod": data_period, "orderType": order_type}, extra))
+
+
+@tiktok_statistics_app.command("expert")
+def tiktok_statistics_expert(country_region: CountryOpt = "美国", data_period: DataPeriodOpt = "last7d", extra: ExtraArg = None) -> None:
+    _run_tool("tiktok", "tt_commodity_statistics_get_expert_statistics", _with_extra("tiktok", "tt_commodity_statistics_get_expert_statistics", {"countryRegion": country_region, "dataPeriod": data_period}, extra))
+
+
+@tiktok_statistics_app.command("price")
+def tiktok_statistics_price(country_region: CountryOpt = "美国", data_period: DataPeriodOpt = "last7d", extra: ExtraArg = None) -> None:
+    _run_tool("tiktok", "tt_commodity_statistics_get_price_statistics", _with_extra("tiktok", "tt_commodity_statistics_get_price_statistics", {"countryRegion": country_region, "dataPeriod": data_period}, extra))
+
+
+@tiktok_commodity_app.command("category-tree")
+def tiktok_commodity_category_tree() -> None:
+    _run_tool("tiktok", "tt_commodity_get_commodity_cat_tree", {})
+
+
+@tiktok_commodity_app.command("list")
+def tiktok_commodity_list(country_region: CountryOpt = "美国", current: CurrentOpt = 1, size: SizeOpt = 10, data_period: DataPeriodOpt = None, date: DateOpt = None, commodity_name: Annotated[Optional[str], typer.Option("--commodity-name")] = None, order_type: OrderTypeOpt = None, extra: ExtraArg = None) -> None:
+    args = {"countryRegion": country_region, "dataPeriod": data_period, "date": date, "commodityName": commodity_name, "orderType": order_type, **_page_args(current, size)}
+    _run_tool("tiktok", "tt_commodity_info_list", _with_extra("tiktok", "tt_commodity_info_list", args, extra))
+
+
+@tiktok_commodity_app.command("detail")
+def tiktok_commodity_detail(commodity_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_commodity_detail", {"countryRegion": country_region, "commodityId": commodity_id})
+
+
+@tiktok_commodity_app.command("trend")
+def tiktok_commodity_trend(commodity_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国", past_days: Annotated[int, typer.Option("--past-days")] = 30) -> None:
+    _run_tool("tiktok", "tt_commodity_sales_trend", {"countryRegion": country_region, "commodityId": commodity_id, "pastDays": past_days})
+
+
+@tiktok_commodity_app.command("voice")
+def tiktok_commodity_voice(commodity_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国", size: SizeOpt = 10) -> None:
+    _run_tool("tiktok", "tt_commodity_voice_analyze", {"countryRegion": country_region, "commodityId": commodity_id, "size": size})
+
+
+@tiktok_commodity_app.command("channel")
+def tiktok_commodity_channel(product_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国", sale_type: Annotated[int, typer.Option("--sale-type")] = 1) -> None:
+    _run_tool("tiktok", "tt_sale_channel_sale_channel", {"countryRegion": country_region, "productId": product_id, "saleType": sale_type})
+
+
+@tiktok_commodity_app.command("expert-trend")
+def tiktok_commodity_expert_trend(commodity_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_commodity_expert_draw_expert_trend", {"countryRegion": country_region, "commodityId": commodity_id})
+
+
+@tiktok_expert_app.command("list")
+def tiktok_expert_list(country_region: CountryOpt = "美国", current: CurrentOpt = 1, size: SizeOpt = 10, data_period: DataPeriodOpt = None, date: DateOpt = None, expert_name: Annotated[Optional[str], typer.Option("--expert-name")] = None, order_type: OrderTypeOpt = None, extra: ExtraArg = None) -> None:
+    args = {"countryRegion": country_region, "dataPeriod": data_period, "date": date, "expertName": expert_name, "orderType": order_type, **_page_args(current, size)}
+    _run_tool("tiktok", "tt_expert_info_list", _with_extra("tiktok", "tt_expert_info_list", args, extra))
+
+
+@tiktok_expert_app.command("detail")
+def tiktok_expert_detail(expert_id: Annotated[str, typer.Argument(help="达人 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_expert_detail", {"countryRegion": country_region, "expertId": expert_id})
+
+
+@tiktok_expert_app.command("fans-portrait")
+def tiktok_expert_fans_portrait(expert_id: Annotated[str, typer.Argument(help="达人 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_expert_fans_portrait", {"countryRegion": country_region, "expertId": expert_id})
+
+
+@tiktok_expert_app.command("sale-show")
+def tiktok_expert_sale_show(expert_id: Annotated[str, typer.Argument(help="达人 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tk_expert_sale_show", {"countryRegion": country_region, "expertId": expert_id})
+
+
+@tiktok_expert_app.command("basic")
+def tiktok_expert_basic(expert_id: Annotated[str, typer.Argument(help="达人 ID")], country_region: CountryOpt = "美国", extra: ExtraArg = None) -> None:
+    _run_tool("tiktok", "tt_expert_basic_analyze", _with_extra("tiktok", "tt_expert_basic_analyze", {"countryRegion": country_region, "expertId": expert_id}, extra))
+
+
+@tiktok_expert_app.command("category")
+def tiktok_expert_category(commodity_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国", category_level: Annotated[int, typer.Option("--category-level")] = 1) -> None:
+    _run_tool("tiktok", "tt_expert_category_analyze", {"countryRegion": country_region, "commodityId": commodity_id, "categoryLevel": category_level})
+
+
+@tiktok_expert_app.command("fans")
+def tiktok_expert_fans(commodity_id: Annotated[str, typer.Argument(help="商品 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_expert_fans_analyze", {"countryRegion": country_region, "commodityId": commodity_id})
+
+
+@tiktok_video_app.command("list")
+def tiktok_video_list(country_region: CountryOpt = "美国", current: CurrentOpt = 1, size: SizeOpt = 10, data_period: DataPeriodOpt = None, date: DateOpt = None, order_type: OrderTypeOpt = None, extra: ExtraArg = None) -> None:
+    args = {"countryRegion": country_region, "dataPeriod": data_period, "date": date, "orderType": order_type, **_page_args(current, size)}
+    _run_tool("tiktok", "tt_video_info_list", _with_extra("tiktok", "tt_video_info_list", args, extra))
+
+
+@tiktok_video_app.command("detail")
+def tiktok_video_detail(video_id: Annotated[str, typer.Argument(help="视频 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_video_detail", {"countryRegion": country_region, "videoId": video_id})
+
+
+@tiktok_video_app.command("content")
+def tiktok_video_content(video_id: Annotated[str, typer.Argument(help="视频 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_video_content", {"countryRegion": country_region, "videoId": video_id})
+
+
+@tiktok_video_app.command("comments")
+def tiktok_video_comments(video_id: Annotated[str, typer.Argument(help="视频 ID")], country_region: CountryOpt = "美国", current: CurrentOpt = 1, size: SizeOpt = 10) -> None:
+    _run_tool("tiktok", "tt_video_voice_read", {"countryRegion": country_region, "videoId": video_id, **_page_args(current, size)})
+
+
+@tiktok_video_app.command("summary")
+def tiktok_video_summary(video_id: Annotated[str, typer.Argument(help="视频 ID")], country_region: CountryOpt = "美国", size: SizeOpt = 10) -> None:
+    _run_tool("tiktok", "tt_video_voice_summary", {"countryRegion": country_region, "videoId": video_id, "size": size})
+
+
+@tiktok_video_app.command("new-summary")
+def tiktok_video_new_summary(video_id: Annotated[str, typer.Argument(help="视频 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_video_new_video_summary", {"countryRegion": country_region, "videoId": video_id})
+
+
+@tiktok_video_app.command("script")
+def tiktok_video_script(video_id: Annotated[str, typer.Argument(help="视频 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_video_script_diy_query", {"countryRegion": country_region, "videoId": video_id})
+
+
+@tiktok_shop_app.command("list")
+def tiktok_shop_list(data_period: Annotated[str, typer.Option("--data-period", help="数据周期")], country_region: CountryOpt = "美国", current: CurrentOpt = 1, size: SizeOpt = 10, date: DateOpt = None, shop_name: Annotated[Optional[str], typer.Option("--shop-name")] = None, order_type: OrderTypeOpt = None, extra: ExtraArg = None) -> None:
+    args = {"countryRegion": country_region, "dataPeriod": data_period, "date": date, "shopName": shop_name, "orderType": order_type, **_page_args(current, size)}
+    _run_tool("tiktok", "tt_shop_info_list", _with_extra("tiktok", "tt_shop_info_list", args, extra))
+
+
+@tiktok_shop_app.command("detail")
+def tiktok_shop_detail(shop_id: Annotated[str, typer.Argument(help="店铺 ID")], country_region: CountryOpt = "美国", data_period: DataPeriodOpt = "last30d", date: DateOpt = None) -> None:
+    _run_tool("tiktok", "tt_shop_detail", {"countryRegion": country_region, "dataPeriod": data_period, "date": date, "shopId": shop_id})
+
+
+@tiktok_shop_app.command("market")
+def tiktok_shop_market(shop_id: Annotated[str, typer.Argument(help="店铺 ID")], country_region: CountryOpt = "美国", data_period: DataPeriodOpt = "last30d", date: DateOpt = None) -> None:
+    _run_tool("tiktok", "tt_shop_market_info", {"countryRegion": country_region, "dataPeriod": data_period, "date": date, "shopId": shop_id})
+
+
+@tiktok_shop_app.command("trend")
+def tiktok_shop_trend(shop_id: Annotated[str, typer.Argument(help="店铺 ID")], country_region: CountryOpt = "美国", past_days: Annotated[int, typer.Option("--past-days")] = 30) -> None:
+    _run_tool("tiktok", "tt_shop_sales_trend", {"countryRegion": country_region, "shopId": shop_id, "pastDays": past_days})
+
+
+@tiktok_shop_app.command("commodity-account")
+def tiktok_shop_commodity_account(shop_id: Annotated[str, typer.Argument(help="店铺 ID")], country_region: CountryOpt = "美国") -> None:
+    _run_tool("tiktok", "tt_shop_commodity_account_list", {"countryRegion": country_region, "shopId": shop_id})
+
+
+# Patent shortcuts
+@patent_search_app.command("query")
+def patent_search_query(query_text: Annotated[str, typer.Argument(help="Analytics 检索式")], limit: Annotated[int, typer.Option("--limit")] = 10, offset: Annotated[int, typer.Option("--offset")] = 0, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_query_search", _with_extra("patent", "patent_query_search", {"query_text": query_text, "limit": limit, "offset": offset}, extra))
+
+
+@patent_search_app.command("semantic")
+def patent_search_semantic(text: Annotated[str, typer.Argument(help="技术描述文本")], limit: Annotated[int, typer.Option("--limit")] = 10, offset: Annotated[int, typer.Option("--offset")] = 0, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_semantic_search", _with_extra("patent", "patent_semantic_search", {"text": text, "limit": limit, "offset": offset}, extra))
+
+
+@patent_search_app.command("count")
+def patent_search_count(query_text: Annotated[str, typer.Argument(help="Analytics 检索式")], extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_query_count", _with_extra("patent", "patent_query_count", {"query_text": query_text}, extra))
+
+
+@patent_search_app.command("agg")
+def patent_search_agg(query: Annotated[str, typer.Argument(help="Analytics 检索式")], field: Annotated[str, typer.Argument(help="聚合维度，如 ASSIGNEE,IPC")], limit: Annotated[int, typer.Option("--limit")] = 50, offset: Annotated[int, typer.Option("--offset")] = 0, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_query_search_with_agg", _with_extra("patent", "patent_query_search_with_agg", {"query": query, "field": field, "limit": limit, "offset": offset}, extra))
+
+
+def _patent_id_args(patent_id: str | None, patent_number: str | None, extra: list[str] | None, tool_name: str) -> dict[str, Any]:
+    return _with_extra("patent", tool_name, {"patent_id": patent_id, "patent_number": patent_number}, extra)
+
+
+@patent_detail_app.command("bibliography")
+def patent_detail_bibliography(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_bibliography", _patent_id_args(patent_id, patent_number, extra, "patent_bibliography"))
+
+
+@patent_detail_app.command("abstract")
+def patent_detail_abstract(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, lang: Annotated[Optional[str], typer.Option("--lang")] = None, translated: Annotated[bool, typer.Option("--translated")] = False, extra: ExtraArg = None) -> None:
+    tool = "patent_abstract_translated" if translated or lang else "patent_abstract_image"
+    args = _patent_id_args(patent_id, patent_number, extra, tool)
+    if lang:
+        args["lang"] = lang
+    _run_tool("patent", tool, args)
+
+
+@patent_detail_app.command("claim")
+def patent_detail_claim(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, lang: Annotated[Optional[str], typer.Option("--lang")] = None, translated: Annotated[bool, typer.Option("--translated")] = False, extra: ExtraArg = None) -> None:
+    tool = "patent_claim_translated" if translated or lang else "patent_claim_data"
+    args = _patent_id_args(patent_id, patent_number, extra, tool)
+    if lang:
+        args["lang"] = lang
+    _run_tool("patent", tool, args)
+
+
+@patent_detail_app.command("description")
+def patent_detail_description(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, lang: Annotated[Optional[str], typer.Option("--lang")] = None, translated: Annotated[bool, typer.Option("--translated")] = False, extra: ExtraArg = None) -> None:
+    tool = "patent_description_translated" if translated or lang else "patent_description"
+    args = _patent_id_args(patent_id, patent_number, extra, tool)
+    if lang:
+        args["lang"] = lang
+    _run_tool("patent", tool, args)
+
+
+@patent_detail_app.command("legal-status")
+def patent_detail_legal_status(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_legal_status", _patent_id_args(patent_id, patent_number, extra, "patent_legal_status"))
+
+
+@patent_detail_app.command("family")
+def patent_detail_family(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_family", _patent_id_args(patent_id, patent_number, extra, "patent_family"))
+
+
+@patent_detail_app.command("pdf")
+def patent_detail_pdf(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_pdf", _patent_id_args(patent_id, patent_number, extra, "patent_pdf"))
+
+
+@patent_detail_app.command("images")
+def patent_detail_images(patent_id: Annotated[Optional[str], typer.Option("--patent-id")] = None, patent_number: Annotated[Optional[str], typer.Option("--patent-number")] = None, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_fulltext_image", _patent_id_args(patent_id, patent_number, extra, "patent_fulltext_image"))
+
+
+@patent_image_app.command("single")
+def patent_image_single(url: Annotated[str, typer.Argument(help="图片公网 URL")], model: Annotated[int, typer.Option("--model")], patent_type: Annotated[str, typer.Option("--patent-type")], limit: Annotated[int, typer.Option("--limit")] = 10, offset: Annotated[int, typer.Option("--offset")] = 0, extra: ExtraArg = None) -> None:
+    _run_tool("patent", "patent_image_search_single", _with_extra("patent", "patent_image_search_single", {"url": url, "model": model, "patent_type": patent_type, "limit": limit, "offset": offset}, extra))
+
+
+@patent_image_app.command("multiple")
+def patent_image_multiple(urls: Annotated[str, typer.Argument(help="逗号分隔 URL 或 JSON 数组")], model: Annotated[int, typer.Option("--model")], patent_type: Annotated[str, typer.Option("--patent-type")], limit: Annotated[int, typer.Option("--limit")] = 10, offset: Annotated[int, typer.Option("--offset")] = 0, extra: ExtraArg = None) -> None:
+    parsed_urls: Any = json.loads(urls) if urls.strip().startswith("[") else [u.strip() for u in urls.split(",") if u.strip()]
+    _run_tool("patent", "patent_image_search_multiple", _with_extra("patent", "patent_image_search_multiple", {"urls": parsed_urls, "model": model, "patent_type": patent_type, "limit": limit, "offset": offset}, extra))
+
+
+# Amazon shortcuts
+@amazon_product_app.command("selection")
+def amazon_product_selection(web_site_id: Annotated[str, typer.Option("--web-site-id", "--site")], pages: Annotated[int, typer.Option("--pages")] = 1, pages_size: Annotated[int, typer.Option("--pages-size")] = 10, cat_id: Annotated[Optional[str], typer.Option("--cat-id")] = None, sku_id: Annotated[Optional[str], typer.Option("--sku-id")] = None, extra: ExtraArg = None) -> None:
+    args = {"webSiteId": web_site_id, "pages": pages, "pagesSize": pages_size, "catId": cat_id, "skuId": sku_id}
+    _run_tool("amazon", "amz_product_selection", _with_extra("amazon", "amz_product_selection", args, extra))
+
+
+@amazon_product_app.command("sku")
+def amazon_product_sku(sku_id: Annotated[str, typer.Argument(help="SKU ID")], web_site_id: Annotated[Optional[str], typer.Option("--web-site-id", "--site")] = None) -> None:
+    _run_tool("amazon", "amz_sku_query", {"skuId": sku_id, "webSiteId": web_site_id})
+
+
+@amazon_product_app.command("category")
+def amazon_product_category(cat_id: Annotated[str, typer.Argument(help="类目 ID")], web_site_id: Annotated[Optional[str], typer.Option("--web-site-id", "--site")] = None) -> None:
+    _run_tool("amazon", "amz_category_query", {"catId": cat_id, "webSiteId": web_site_id})
+
+
+@amazon_product_app.command("sales")
+def amazon_product_sales(sku_id: Annotated[str, typer.Argument(help="SKU ID")], web_site_id: Annotated[Optional[str], typer.Option("--web-site-id", "--site")] = None) -> None:
+    _run_tool("amazon", "amz_sales_query", {"skuId": sku_id, "webSiteId": web_site_id})
+
+
+@amazon_product_app.command("review")
+def amazon_product_review(sku_id: Annotated[str, typer.Argument(help="SKU ID")], web_site_id: Annotated[Optional[str], typer.Option("--web-site-id", "--site")] = None, current: CurrentOpt = 1, size: SizeOpt = 100) -> None:
+    _run_tool("amazon", "amz_review_query", {"skuId": sku_id, "webSiteId": web_site_id, "current": current, "size": size})
+
+
+@amazon_product_app.command("price")
+def amazon_product_price(node_id: Annotated[str, typer.Argument(help="类目节点 ID")], web_site_id: Annotated[Optional[str], typer.Option("--web-site-id", "--site")] = None, top_n: Annotated[int, typer.Option("--top-n")] = 10, ds: DateOpt = None) -> None:
+    _run_tool("amazon", "amz_market_price", {"nodeId": node_id, "webSiteId": web_site_id, "topN": top_n, "ds": ds})
+
+
+@amazon_hot_app.command("list")
+def amazon_hot_list(web_site_id: Annotated[str, typer.Option("--web-site-id", "--site")], rank_type: Annotated[str, typer.Option("--rank-type")], cat_id: Annotated[Optional[str], typer.Option("--cat-id")] = None, current_page: Annotated[int, typer.Option("--current-page")] = 1, page_size: Annotated[int, typer.Option("--page-size")] = 10) -> None:
+    _run_tool("amazon", "amz_hot_amz_hot_list", {"webSiteId": web_site_id, "rankType": rank_type, "catId": cat_id, "currentPage": current_page, "pageSize": page_size})
+
+
+@amazon_hot_app.command("cat-tree")
+def amazon_hot_cat_tree(web_site_id: Annotated[str, typer.Option("--web-site-id", "--site")], rank_type: Annotated[str, typer.Option("--rank-type")], keyword: Annotated[Optional[str], typer.Option("--keyword")] = None) -> None:
+    _run_tool("amazon", "amz_hot_amz_hot_cat_tree", {"webSiteId": web_site_id, "rankType": rank_type, "keyword": keyword})
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

proboost_cli/client.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any
+
+from proboost_cli.mcp_client import McpClient
+
+
+class Proboost:
+    """Unified Python client for Proboost MCP servers.
+
+    Usage:
+
+        from proboost_cli import Proboost
+
+        pb = Proboost()
+        pb.tiktok.tt_video_content(countryRegion="美国", videoId="...")
+        pb.patent.patent_query_search(query_text="TACD: virtual reality")
+        pb.amazon.amz_product_selection(webSiteId="1")
+    """
+
+    def __init__(
+        self,
+        *,
+        secret_key: str | None = None,
+        tiktok_secret_key: str | None = None,
+        patent_secret_key: str | None = None,
+        amazon_secret_key: str | None = None,
+        tiktok_base_url: str | None = None,
+        patent_base_url: str | None = None,
+        amazon_base_url: str | None = None,
+        connect_timeout_sec: float = 30,
+        read_timeout_sec: float = 300,
+    ) -> None:
+        shared: dict[str, Any] = {
+            "connect_timeout_sec": connect_timeout_sec,
+            "read_timeout_sec": read_timeout_sec,
+        }
+        self.tiktok = McpClient(
+            "tiktok",
+            secret_key=tiktok_secret_key or secret_key,
+            base_url=tiktok_base_url,
+            **shared,
+        )
+        self.patent = McpClient(
+            "patent",
+            secret_key=patent_secret_key or secret_key,
+            base_url=patent_base_url,
+            **shared,
+        )
+        self.amazon = McpClient(
+            "amazon",
+            secret_key=amazon_secret_key or secret_key,
+            base_url=amazon_base_url,
+            **shared,
+        )
+
+    def client(self, mcp: str) -> McpClient:
+        return getattr(self, mcp)