agentengine-sdk-python 0.6.2__py3-none-any.whl → 0.6.9__py3-none-any.whl

ksadk/cli/cmd_web.py

@@ -0,0 +1,288 @@
+"""ksadk web - 启动统一本地 Web UI。"""
+
+import click
+import webbrowser
+from pathlib import Path
+import os
+import yaml
+from ksadk.cli.error_utils import ensure_json_output_supported, print_exception
+from ksadk.cli.local_runtime import reexec_with_project_venv_if_needed
+from ksadk.cli.ui import (
+    print_error,
+    print_info,
+    print_kv,
+    print_success,
+    print_title,
+)
+from ksadk.configs import setup_environment
+from ksadk.detection import FrameworkDetector
+from ksadk.runners.factory import create_runner
+
+
+_PERSISTENT_STM_FRAMEWORKS = {"adk", "langgraph", "langchain", "deepagents"}
+_STM_ENV_NAMES = (
+    "KSADK_STM_BACKEND",
+    "KSADK_STM_PATH",
+    "KSADK_STM_URL",
+    "KSADK_STM_DB_PATH",
+    "KSADK_STM_DB_URL",
+)
+_SESSION_ENV_NAMES = (
+    "KSADK_SESSION_BACKEND",
+    "AGENTENGINE_SESSION_BACKEND",
+    "KSADK_SESSION_PATH",
+    "KSADK_SESSION_DSN",
+)
+_CHECKPOINT_ENV_NAMES = (
+    "KSADK_CHECKPOINT_BACKEND",
+    "KSADK_CHECKPOINT_PATH",
+    "KSADK_LANGGRAPH_CHECKPOINT_DSN",
+)
+_LOCAL_UI_ENV_NAMES = ("AGENTENGINE_UI_DIR",)
+
+
+def _normalize_ui_path(path: str | None) -> str:
+    value = str(path or "/").strip() or "/"
+    if not value.startswith("/"):
+        value = "/" + value
+    return value.rstrip("/") or "/"
+
+
+def _load_agentengine_config(agent_path: Path) -> dict:
+    for file_name in ("agentengine.yaml", "ksadk.yaml", "ksadk.yml"):
+        config_path = agent_path / file_name
+        if not config_path.exists():
+            continue
+        try:
+            payload = yaml.safe_load(config_path.read_text(encoding="utf-8-sig")) or {}
+            return payload if isinstance(payload, dict) else {}
+        except Exception:
+            return {}
+    return {}
+
+
+def _project_dotenv_values(agent_path: Path) -> dict[str, str]:
+    env_path = agent_path / ".env"
+    if not env_path.exists():
+        return {}
+    try:
+        from dotenv import dotenv_values
+    except ImportError:
+        return {}
+    values: dict[str, str] = {}
+    for key, value in dotenv_values(env_path, encoding="utf-8-sig").items():
+        if key and value is not None:
+            values[str(key)] = str(value)
+    return values
+
+
+def _explicit_env_names_excluding_project_dotenv(
+    names: tuple[str, ...],
+    project_dotenv: dict[str, str],
+) -> set[str]:
+    explicit: set[str] = set()
+    for name in names:
+        current = os.environ.get(name)
+        if current is None:
+            continue
+        if project_dotenv.get(name) == current:
+            continue
+        explicit.add(name)
+    return explicit
+
+
+def _configure_custom_ui_env(agent_path: Path) -> str:
+    config = _load_agentengine_config(agent_path)
+    if str(config.get("ui_profile") or "").strip().lower() != "custom":
+        return "/"
+
+    bundle_path = str(config.get("ui_bundle_path") or "").strip()
+    if not bundle_path:
+        return "/"
+    bundle_dir = agent_path / bundle_path
+    if not (bundle_dir / "index.html").is_file():
+        return "/"
+
+    ui_path = _normalize_ui_path(str(config.get("ui_path") or "/"))
+    os.environ["KSADK_UI_PROFILE"] = "custom"
+    os.environ["KSADK_UI_PATH"] = ui_path
+    os.environ["KSADK_UI_BUNDLE_PATH"] = bundle_path
+    return ui_path
+
+
+def _ensure_langgraph_sqlite_checkpoint_available() -> None:
+    try:
+        import langgraph.checkpoint.sqlite.aio  # noqa: F401
+    except ImportError:
+        print_error(
+            "本地 LangGraph checkpoint 需要安装 langgraph-checkpoint-sqlite：\n"
+            "  pip install langgraph-checkpoint-sqlite\n"
+            "或显式设置 KSADK_CHECKPOINT_BACKEND=memory/postgres。"
+        )
+        raise SystemExit(1)
+
+
+def _configure_langgraph_checkpoint_env(
+    agent_path: Path,
+    *,
+    explicit_checkpoint_env_names: set[str],
+) -> None:
+    checkpoint_backend = str(os.environ.get("KSADK_CHECKPOINT_BACKEND") or "").strip().lower()
+    if checkpoint_backend == "local":
+        checkpoint_backend = "sqlite"
+        os.environ["KSADK_CHECKPOINT_BACKEND"] = "sqlite"
+
+    if checkpoint_backend == "sqlite":
+        _ensure_langgraph_sqlite_checkpoint_available()
+        os.environ.setdefault(
+            "KSADK_CHECKPOINT_PATH",
+            str(agent_path / ".agentengine" / "ui" / "checkpoints.sqlite"),
+        )
+        os.environ.pop("KSADK_LANGGRAPH_CHECKPOINT_DSN", None)
+        return
+
+    if explicit_checkpoint_env_names.intersection(_CHECKPOINT_ENV_NAMES):
+        return
+
+    _ensure_langgraph_sqlite_checkpoint_available()
+    os.environ["KSADK_CHECKPOINT_BACKEND"] = "sqlite"
+    os.environ["KSADK_CHECKPOINT_PATH"] = str(
+        agent_path / ".agentengine" / "ui" / "checkpoints.sqlite"
+    )
+    os.environ.pop("KSADK_LANGGRAPH_CHECKPOINT_DSN", None)
+
+
+def _default_project_stm_if_unset(
+    framework: str,
+    agent_path: Path,
+    *,
+    explicit_session_env_names: set[str] | None = None,
+    explicit_checkpoint_env_names: set[str] | None = None,
+) -> None:
+    if framework not in _PERSISTENT_STM_FRAMEWORKS:
+        return
+    explicit_session_env_names = explicit_session_env_names or set()
+    explicit_checkpoint_env_names = explicit_checkpoint_env_names or set()
+    session_db_path = str(agent_path / ".agentengine" / "ui" / "sessions.sqlite")
+    if not any(name in os.environ for name in _STM_ENV_NAMES):
+        os.environ["KSADK_STM_BACKEND"] = "sqlite"
+        os.environ["KSADK_STM_PATH"] = session_db_path
+    if not explicit_session_env_names.intersection(_SESSION_ENV_NAMES):
+        os.environ["KSADK_SESSION_BACKEND"] = "local"
+        os.environ["KSADK_SESSION_PATH"] = session_db_path
+        os.environ.pop("KSADK_SESSION_DSN", None)
+        os.environ.pop("AGENTENGINE_SESSION_BACKEND", None)
+    if framework == "langgraph":
+        _configure_langgraph_checkpoint_env(
+            agent_path,
+            explicit_checkpoint_env_names=explicit_checkpoint_env_names,
+        )
+
+
+@click.command(context_settings=dict(help_option_names=["-h", "--help"]))
+@click.argument("agent_dir", default=".", type=click.Path(exists=True))
+@click.option("--port", "-p", default=8080, help="Web UI 端口")
+@click.option("--model", help="指定模型名称 (覆盖 .env 配置)")
+@click.option("--no-open", is_flag=True, help="仅打印 URL，不自动打开浏览器")
+def web(agent_dir: str, port: int, model: str, no_open: bool):
+    """启动本地统一 Web UI（Invoke UI）
+
+    \b
+    AGENT_DIR: Agent 项目目录 (默认: 当前目录)
+
+    \b
+    用途说明:
+      本地调试 Agent Invoke UI（非云端 Dashboard）
+      所有受支持框架统一使用 ksadk 内建 Web UI
+    """
+    ensure_json_output_supported(
+        "agentengine web",
+        suggestion="请改用 `agentengine dashboard open` 或 `agentengine agent status --output json`。",
+    )
+
+    agent_path = Path(agent_dir).resolve()
+    command_args = ["web", str(agent_path), "--port", str(port)]
+    if model:
+        command_args.extend(["--model", model])
+    reexec_with_project_venv_if_needed(agent_path, command_args)
+    project_dotenv = _project_dotenv_values(agent_path)
+    explicit_session_env_names = _explicit_env_names_excluding_project_dotenv(
+        (*_STM_ENV_NAMES, *_SESSION_ENV_NAMES),
+        project_dotenv,
+    )
+    explicit_checkpoint_env_names = _explicit_env_names_excluding_project_dotenv(
+        _CHECKPOINT_ENV_NAMES,
+        project_dotenv,
+    )
+    explicit_local_ui_env_names = _explicit_env_names_excluding_project_dotenv(
+        _LOCAL_UI_ENV_NAMES,
+        project_dotenv,
+    )
+
+    print_title("启动本地调试 Web UI")
+    print_kv("项目目录", str(agent_path))
+
+    # 设置模型名称 (CLI 参数优先级最高)
+    if model:
+        os.environ["MODEL_NAME"] = model
+        os.environ["OPENAI_MODEL_NAME"] = model
+        print_kv("指定模型", model, value_style="#58a6ff")
+
+    setup_environment(agent_path)
+
+    # 检测框架
+    detector = FrameworkDetector(str(agent_path))
+    result = detector.detect()
+
+    if result.type.value == "unknown":
+        print_error("未检测到支持的框架")
+        raise SystemExit(1)
+
+    # Map framework types to display names
+    framework_map = {
+        "adk": "ADK",
+        "langchain": "LangChain",
+        "langgraph": "LangGraph",
+        "deepagents": "DeepAgents",
+    }
+    display_name = framework_map.get(result.type.value, result.name)
+    print_kv("框架", display_name, value_style="#2da44e")
+
+    # 本地 UI 的持久化目录与项目根绑定
+    os.environ["KSADK_PROJECT_DIR"] = str(agent_path)
+    local_ui_dir = str(agent_path / ".agentengine" / "ui")
+    if "AGENTENGINE_UI_DIR" not in explicit_local_ui_env_names:
+        os.environ["AGENTENGINE_UI_DIR"] = local_ui_dir
+    else:
+        os.environ.setdefault("AGENTENGINE_UI_DIR", local_ui_dir)
+    _default_project_stm_if_unset(
+        result.type.value,
+        agent_path,
+        explicit_session_env_names=explicit_session_env_names,
+        explicit_checkpoint_env_names=explicit_checkpoint_env_names,
+    )
+    launch_path = _configure_custom_ui_env(agent_path)
+
+    try:
+        print_info("初始化 Runner...")
+        runner = create_runner(result, str(agent_path))
+    except Exception as e:
+        print_exception("Runner 初始化失败", e)
+        raise SystemExit(1)
+
+    print_success("启动统一 Web UI")
+    launch_url = f"http://localhost:{port}{launch_path if launch_path != '/' else ''}"
+    print_kv("Web UI", launch_url, value_style="#58a6ff")
+    print_kv("Agent", result.name)
+    print_info("按 Ctrl+C 停止")
+
+    if not no_open:
+        webbrowser.open(launch_url)
+
+    try:
+        runner.run_server(port=port)
+    except KeyboardInterrupt:
+        raise SystemExit(0)
+    except Exception as e:
+        print_exception("统一 Web UI 启动失败", e)
+        raise SystemExit(1)

ksadk/cli/deploy_utils.py

@@ -0,0 +1,87 @@
+import os
+import click
+from ksadk.api import AgentEngineClient
+
+async def auto_release_version(agent_id: str, region: str, deploy_name: str):
+    """部署成功后自动创建版本快照"""
+    from datetime import datetime
+    
+    access_key = os.getenv("KSYUN_ACCESS_KEY") or os.getenv("KS3_ACCESS_KEY")
+    secret_key = os.getenv("KSYUN_SECRET_KEY") or os.getenv("KS3_SECRET_KEY")
+    
+    client = AgentEngineClient(
+        access_key=access_key,
+        secret_key=secret_key,
+        region=region,
+    )
+    
+    try:
+        description = "部署后自动发布"
+        result = await client.release_version(
+            agent_id=agent_id,
+            tag=None,  # 自动生成
+            description=description
+        )
+        
+        click.echo("")
+        click.secho(f"✓ 版本快照已创建: {result.get('tag')}", fg="green")
+    except Exception as e:
+        # 版本创建失败不阻断部署流程
+        click.secho(f"⚠ 版本快照创建失败: {e}", fg="yellow")
+    finally:
+        await client.close()
+
+
+async def auto_rollback_to_previous(agent_id: str, region: str):
+    """部署失败时自动回滚到上一版本"""
+    
+    access_key = os.getenv("KSYUN_ACCESS_KEY") or os.getenv("KS3_ACCESS_KEY")
+    secret_key = os.getenv("KSYUN_SECRET_KEY") or os.getenv("KS3_SECRET_KEY")
+    
+    client = AgentEngineClient(
+        access_key=access_key,
+        secret_key=secret_key,
+        region=region,
+    )
+    
+    try:
+        # 获取版本列表，找到最近的历史版本
+        versions_result = await client.list_versions(agent_id, page=1, size=5)
+        versions = versions_result.get("versions", [])
+        
+        # 找到需要回滚的目标版本 (统一 snake_case)
+        target_version = None
+        for v in versions:
+            if (v.get("status") or "").lower() == "current":
+                target_version = v
+                break
+        
+        # 如果没有 Current，则找最新的 Historical
+        if not target_version:
+            for v in versions:
+                if (v.get("status") or "").lower() == "historical":
+                    target_version = v
+                    break
+        
+        if not target_version:
+            click.secho("⚠ 无可用稳定版本，跳过自动回滚", fg="yellow")
+            return
+        
+        target_tag = target_version.get("tag")
+        click.echo("")
+        click.secho(f"⏪ 正在自动回滚到版本: {target_tag}...", fg="yellow")
+        
+        # 执行回滚
+        result = await client.rollback_version(
+            agent_id=agent_id,
+            target_tag=target_tag,
+            ks3_access_key=access_key,
+            ks3_secret_key=secret_key
+        )
+        
+        click.secho(f"✓ 已回滚到版本: {target_tag}", fg="green")
+        
+    except Exception as e:
+        click.secho(f"⚠ 自动回滚失败: {e}", fg="red")
+    finally:
+        await client.close()

ksadk/cli/dry_run.py

@@ -0,0 +1,214 @@
+"""CLI dry-run utilities."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from typing import Any, Awaitable, Callable, Optional, TypeVar
+
+import click
+from click.core import ParameterSource
+
+from ksadk.api.client import DryRunExit
+from ksadk.cli.resource_common import build_dry_run_envelope
+from ksadk.cli.ui import emit_json, is_json_output
+
+_T = TypeVar("_T")
+_DEFAULT_DONE_MSG = "✅ Dry Run Completed: 请求已打印，未执行实际变更。"
+_GLOBAL_DRY_RUN_ENV = "AGENTENGINE_GLOBAL_DRY_RUN"
+_MASKED_VALUE = "***"
+_SENSITIVE_KEY_TOKENS = (
+    "authorization",
+    "api_key",
+    "apikey",
+    "token",
+    "secret",
+    "password",
+    "signature",
+    "accesskey",
+    "access_key",
+)
+
+
+def is_global_dry_run_enabled() -> bool:
+    return os.getenv(_GLOBAL_DRY_RUN_ENV, "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def effective_dry_run(local_dry_run: bool = False) -> bool:
+    return bool(local_dry_run or is_global_dry_run_enabled())
+
+
+def _set_dry_run_callback(ctx: click.Context, _param: click.Parameter, value: bool):
+    ctx.ensure_object(dict)
+    inherited = False
+    if ctx.parent is not None and isinstance(ctx.parent.obj, dict):
+        inherited = bool(ctx.parent.obj.get("dry_run"))
+
+    source = ctx.get_parameter_source("dry_run")
+    selected = inherited if source == ParameterSource.DEFAULT else bool(value)
+
+    if selected:
+        os.environ[_GLOBAL_DRY_RUN_ENV] = "1"
+    else:
+        os.environ.pop(_GLOBAL_DRY_RUN_ENV, None)
+
+    ctx.obj["dry_run"] = selected
+    return selected
+
+
+def dry_run_option(
+    help_text: str = "只打印 curl 请求，不执行",
+    *,
+    hidden: bool = False,
+    expose_value: bool = True,
+):
+    """Reusable Click option for dry-run support."""
+    return click.option(
+        "--dry-run",
+        "dry_run",
+        is_flag=True,
+        default=False,
+        hidden=hidden,
+        expose_value=expose_value,
+        callback=_set_dry_run_callback,
+        help=help_text,
+    )
+
+
+def build_dry_run_click_option(
+    help_text: str = "只打印 curl 请求，不执行",
+    *,
+    hidden: bool = False,
+    expose_value: bool = True,
+) -> click.Option:
+    """Build a dry-run option for command injection."""
+    return click.Option(
+        ["--dry-run", "dry_run"],
+        is_flag=True,
+        default=False,
+        hidden=hidden,
+        expose_value=expose_value,
+        callback=_set_dry_run_callback,
+        help=help_text,
+    )
+
+
+def _is_sensitive_key(key: Any) -> bool:
+    text = str(key or "").strip().lower().replace("-", "_")
+    if not text:
+        return False
+    return any(token in text for token in _SENSITIVE_KEY_TOKENS)
+
+
+def _mask_if_sensitive(value: Any, *, sensitive: bool) -> Any:
+    if not sensitive:
+        return value
+    if value is None:
+        return None
+    return _MASKED_VALUE
+
+
+def _sanitize_dry_run_value(value: Any, *, parent_key: str | None = None) -> Any:
+    if isinstance(value, dict):
+        env_key = str(value.get("Key") or "")
+        env_sensitive = bool(value.get("IsSensitive")) or _is_sensitive_key(env_key)
+        sanitized: dict[str, Any] = {}
+        for key, item in value.items():
+            key_text = str(key)
+            item_sensitive = env_sensitive and key_text == "Value"
+            if not item_sensitive and _is_sensitive_key(key_text):
+                item_sensitive = True
+            sanitized[key_text] = _mask_if_sensitive(
+                _sanitize_dry_run_value(item, parent_key=key_text),
+                sensitive=item_sensitive,
+            )
+        return sanitized
+    if isinstance(value, list):
+        return [_sanitize_dry_run_value(item, parent_key=parent_key) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_sanitize_dry_run_value(item, parent_key=parent_key) for item in value)
+    return _mask_if_sensitive(value, sensitive=_is_sensitive_key(parent_key))
+
+
+def _shell_quote_single(value: str) -> str:
+    return value.replace("'", "'\"'\"'")
+
+
+def _build_redacted_curl(method: Any, url: Any, headers: Any, body: Any) -> str:
+    method_text = str(method or "REQUEST")
+    url_text = str(url or "")
+    lines = [f'curl -X {method_text} "{url_text}" \\']
+    if isinstance(headers, dict):
+        for key, value in headers.items():
+            lines.append(f'  -H "{key}: {value}" \\')
+    if body is not None:
+        body_text = json.dumps(body, ensure_ascii=False)
+        lines.append(f"  -d '{_shell_quote_single(body_text)}'")
+    elif lines:
+        lines[-1] = lines[-1].rstrip(" \\")
+    return "\n".join(lines)
+
+
+def sanitize_dry_run_request(payload: dict[str, Any] | None) -> dict[str, Any]:
+    """Redact secrets from dry-run request payloads before printing or JSON output."""
+    if not payload:
+        return {}
+    safe_payload = _sanitize_dry_run_value(dict(payload or {}))
+    if not isinstance(safe_payload, dict):
+        return {}
+    safe_payload["curl"] = _build_redacted_curl(
+        safe_payload.get("method"),
+        safe_payload.get("url"),
+        safe_payload.get("headers"),
+        safe_payload.get("body"),
+    )
+    return safe_payload
+
+
+def run_async_with_dry_run(
+    coro: Awaitable[_T],
+    *,
+    dry_run: bool,
+    done_message: str = _DEFAULT_DONE_MSG,
+    on_dry_run: Optional[Callable[[DryRunExit], None]] = None,
+    dry_run_resource: str | None = None,
+    dry_run_action: str | None = None,
+    dry_run_hints: Optional[list[str]] = None,
+) -> Optional[_T]:
+    """Run async coroutine and swallow DryRunExit in dry-run mode."""
+    _ = dry_run
+    try:
+        return asyncio.run(coro)
+    except DryRunExit as exc:
+        safe_payload = sanitize_dry_run_request(exc.payload or {})
+        if on_dry_run:
+            on_dry_run(DryRunExit(str(exc), payload=safe_payload))
+        elif is_json_output() and dry_run_resource and dry_run_action:
+            emit_json(
+                build_dry_run_envelope(
+                    resource=dry_run_resource,
+                    action=dry_run_action,
+                    request=safe_payload,
+                    hints=dry_run_hints or [],
+                )
+            )
+        elif safe_payload:
+            click.echo("=" * 60)
+            click.echo(f"Dry Run Mode: {safe_payload.get('method', 'REQUEST')} {safe_payload.get('url', '')}")
+            click.echo("=" * 60)
+            click.echo(f"Headers: {safe_payload.get('headers')}")
+            if safe_payload.get("body") is not None:
+                click.echo(f"Body: {safe_payload.get('body')}")
+            if safe_payload.get("curl"):
+                click.echo("\nCurl Command:")
+                click.echo(str(safe_payload["curl"]))
+            click.echo("=" * 60)
+        if not is_json_output():
+            click.echo(done_message)
+        return None

ksadk/cli/env_options.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+import click
+
+_ENV_KEY_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def parse_env_pairs(items: tuple[str, ...] | list[str] | None) -> dict[str, str]:
+    """Parse repeated KEY=VALUE CLI env options."""
+    parsed: dict[str, str] = {}
+    for raw_item in items or ():
+        item = str(raw_item or "").strip()
+        if not item or "=" not in item:
+            raise ValueError(f"自定义环境变量格式错误: {raw_item!r}，应为 KEY=VALUE")
+        key, value = item.split("=", 1)
+        key = key.strip()
+        if not _ENV_KEY_PATTERN.fullmatch(key):
+            raise ValueError(f"自定义环境变量名不合法: {key!r}，请使用合法的环境变量名")
+        parsed[key] = value
+    return parsed
+
+
+def load_env_file(env_file: str | None, *, base_dir: Path | None = None) -> dict[str, str]:
+    """Load explicit runtime env variables from a dotenv or JSON object file."""
+    if not env_file:
+        return {}
+
+    path = Path(env_file)
+    if not path.is_absolute() and base_dir is not None:
+        path = base_dir / path
+    if not path.exists():
+        raise ValueError(f"环境变量文件不存在: {path}")
+
+    if path.suffix.lower() == ".json":
+        raw = json.loads(path.read_text(encoding="utf-8-sig"))
+        if not isinstance(raw, dict):
+            raise ValueError(f"环境变量 JSON 文件必须是对象: {path}")
+        items = raw.items()
+    else:
+        from dotenv import dotenv_values
+
+        items = dotenv_values(path, encoding="utf-8-sig").items()
+
+    parsed: dict[str, str] = {}
+    for raw_key, raw_value in items:
+        if not raw_key or raw_value is None:
+            continue
+        key = str(raw_key).lstrip("\ufeff").strip()
+        if not _ENV_KEY_PATTERN.fullmatch(key):
+            raise ValueError(f"环境变量名不合法: {key!r}，文件: {path}")
+        parsed[key] = str(raw_value)
+    return parsed
+
+
+def resolve_explicit_env_vars(
+    *,
+    env_file: str | None,
+    env_pairs: tuple[str, ...] | list[str] | None,
+    base_dir: Path,
+) -> dict[str, str]:
+    env_vars = load_env_file(env_file, base_dir=base_dir)
+    env_vars.update(parse_env_pairs(env_pairs))
+    return env_vars
+
+
+def env_options(func):
+    func = click.option(
+        "--env-file",
+        type=click.Path(exists=False, dir_okay=False),
+        help="额外运行时环境变量文件，支持 .env 或 JSON 对象",
+    )(func)
+    func = click.option(
+        "--env",
+        "extra_env",
+        multiple=True,
+        help="额外透传运行时环境变量，格式 KEY=VALUE，可重复传入",
+    )(func)
+    return func