tinet-cticloud-cli 0.0.5__tar.gz

tinet_cticloud_cli-0.0.5/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: tinet-cticloud-cli
+Version: 0.0.5
+Summary: CLI harness for CTICloud predictive outbound task APIs
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-httpx>=0.30; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/__init__.py

@@ -0,0 +1,3 @@
+"""CTICloud CLI harness for predictive outbound tasks."""
+
+__version__ = "0.0.5"

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/__main__.py

@@ -0,0 +1,4 @@
+from cli_anything.cticloud.cticloud_cli import main
+
+if __name__ == "__main__":
+    main()

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/core/auth.py

@@ -0,0 +1,54 @@
+"""MD5 sign and auth query parameter helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from typing import Any, Dict, Optional
+
+from cli_anything.cticloud.core.config import CtiConfig
+
+
+def build_sign(
+    *,
+    validate_type: int,
+    enterprise_id: Optional[str],
+    department_id: Optional[str],
+    timestamp: int,
+    token: str,
+) -> str:
+    """Compute platform sign: MD5(id + timestamp + token), 32-char lowercase hex."""
+    if validate_type == 1:
+        if not department_id:
+            raise ValueError("validateType=1 需要 departmentId")
+        raw = f"{department_id}{timestamp}{token}"
+    elif validate_type == 2:
+        if not enterprise_id:
+            raise ValueError("validateType=2 需要 enterpriseId")
+        raw = f"{enterprise_id}{timestamp}{token}"
+    else:
+        raise ValueError(f"不支持的 validateType: {validate_type}")
+    return hashlib.md5(raw.encode("utf-8")).hexdigest()
+
+
+def auth_query_params(config: CtiConfig, timestamp: Optional[int] = None) -> Dict[str, Any]:
+    """Build validateType, ids, timestamp, and sign query parameters."""
+    config.validate_ready()
+    ts = timestamp if timestamp is not None else int(time.time())
+    sign = build_sign(
+        validate_type=config.validate_type,
+        enterprise_id=config.enterprise_id,
+        department_id=config.department_id,
+        timestamp=ts,
+        token=config.token or "",
+    )
+    params: Dict[str, Any] = {
+        "validateType": str(config.validate_type),
+        "timestamp": str(ts),
+        "sign": sign,
+    }
+    if config.validate_type == 1:
+        params["departmentId"] = config.department_id
+    else:
+        params["enterpriseId"] = config.enterprise_id
+    return params

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/core/cdr.py

@@ -0,0 +1,112 @@
+"""CDR list-auto-task operations."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import Any, Dict, List
+
+from cli_anything.cticloud.core.client import CcClient
+from cli_anything.cticloud.core.config import CtiConfig
+from cli_anything.cticloud.core.cdr_query import (
+    ListCdrAutoTaskQuery,
+    build_list_cdr_auto_task_params,
+    validate_list_cdr_auto_task_query,
+    validate_time_range,
+)
+
+__all__ = [
+    "ListCdrAutoTaskQuery",
+    "build_list_cdr_auto_task_params",
+    "list_cdr_auto_task",
+    "validate_list_cdr_auto_task_query",
+    "validate_time_range",
+]
+
+
+def list_cdr_auto_task(
+    config: CtiConfig,
+    query: ListCdrAutoTaskQuery,
+    *,
+    fetch_all: bool = False,
+    verbose: bool = False,
+) -> Dict[str, Any]:
+    """Query task call records via /cc/list_cdr_auto_task."""
+    validate_list_cdr_auto_task_query(query)
+    client = CcClient(config)
+
+    def _fetch(current: ListCdrAutoTaskQuery) -> dict:
+        params = build_list_cdr_auto_task_params(current)
+        return client.get("list_cdr_auto_task", params, verbose=verbose)
+
+    if not fetch_all:
+        return _fetch(query)
+
+    if query.scroll_search:
+        return _fetch_all_scroll(query, _fetch)
+
+    return _fetch_all_offset(query, _fetch)
+
+
+def _fetch_all_offset(
+    query: ListCdrAutoTaskQuery,
+    fetch_page,
+) -> Dict[str, Any]:
+    """Paginate with offset/limit until all records are retrieved."""
+    responses: List[dict] = []
+    all_records: List[dict] = []
+    off = query.offset
+    page_limit = max(10, min(query.limit, 100))
+    platform_total = None
+
+    while True:
+        page_query = replace(query, offset=off, limit=page_limit)
+        page = fetch_page(page_query)
+        responses.append(page)
+        batch = page.get("cdrAutoTask") or []
+        all_records.extend(batch)
+        if platform_total is None:
+            platform_total = int(page.get("totalCount") or 0)
+        if not batch or len(all_records) >= platform_total:
+            break
+        off += page_limit
+
+    return {
+        "responses": responses,
+        "summary": {
+            "totalCount": platform_total if platform_total is not None else len(all_records),
+            "cdrAutoTask": all_records,
+            "pages": len(responses),
+        },
+    }
+
+
+def _fetch_all_scroll(
+    query: ListCdrAutoTaskQuery,
+    fetch_page,
+) -> Dict[str, Any]:
+    """Paginate with scrollId until scroll ends."""
+    responses: List[dict] = []
+    all_records: List[dict] = []
+    scroll_id = query.scroll_id
+    platform_total = None
+
+    while True:
+        page_query = replace(query, scroll_id=scroll_id, scroll_search=True)
+        page = fetch_page(page_query)
+        responses.append(page)
+        batch = page.get("cdrAutoTask") or []
+        all_records.extend(batch)
+        if platform_total is None:
+            platform_total = int(page.get("totalCount") or 0)
+        scroll_id = page.get("scrollId")
+        if not scroll_id or not batch:
+            break
+
+    return {
+        "responses": responses,
+        "summary": {
+            "totalCount": platform_total if platform_total is not None else len(all_records),
+            "cdrAutoTask": all_records,
+            "pages": len(responses),
+        },
+    }

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/core/cdr_query.py

@@ -0,0 +1,232 @@
+"""Wiki-aligned query model for /cc/list_cdr_auto_task."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from typing import Any, Dict, List, Optional, Tuple
+
+MAX_RANGE_SECONDS = 31 * 86400
+MIN_LIMIT = 10
+MAX_LIMIT = 100
+MAX_OFFSET = 99990
+MAX_OFFSET_PLUS_LIMIT = 100_000
+
+# (snake_field, wiki_key, is_array)
+WIKI_QUERY_FIELDS: Tuple[Tuple[str, str, bool], ...] = (
+    ("up_time", "upTime", False),
+    ("up_time_end", "upTimeEnd", False),
+    ("end_time", "endTime", False),
+    ("end_time_end", "endTimeEnd", False),
+    ("hidden_type", "hiddenType", False),
+    ("customer_bridge_duration", "customerBridgeDuration", False),
+    ("customer_bridge_duration_end", "customerBridgeDurationEnd", False),
+    ("total_duration", "totalDuration", False),
+    ("total_duration_end", "totalDurationEnd", False),
+    ("cnos", "cnos", True),
+    ("qnos", "qnos", True),
+    ("client_number", "clientNumber", False),
+    ("customer_number", "customerNumber", False),
+    ("customer_number_match_type", "customerNumberMatchType", False),
+    ("hotlines", "hotlines", True),
+    ("xnumber", "xnumber", True),
+    ("status", "status", True),
+    ("sip_cause_type", "sipCauseType", True),
+    ("sip_cause", "sipCause", True),
+    ("sip_cause_raw", "sipCauseRaw", True),
+    ("on_hook_source", "onHookSource", True),
+    ("investigation_keys", "investigationKeys", False),
+    ("province", "province", False),
+    ("city", "city", False),
+    ("main_unique_id", "mainUniqueId", False),
+    ("request_unique_id", "requestUniqueId", False),
+    ("evaluation", "evaluation", False),
+    ("task_ids", "taskIds", True),
+    ("ivr_ids", "ivrIds", True),
+    ("degrade", "degrade", False),
+    ("tel_retry", "telRetry", False),
+    ("ab_task_group_name", "abTaskGroupName", False),
+    ("finish_retry_flag", "finishRetryFlag", False),
+    ("business_tag_names", "businessTagNames", True),
+    ("user_field", "userField", False),
+    ("user_value", "userValue", False),
+    ("customer_mos", "customerMos", True),
+    ("agent_mos", "agentMos", True),
+    ("intelligent_bridge_time", "intelligentBridgeTime", False),
+    ("intelligent_bridge_time_end", "intelligentBridgeTimeEnd", False),
+    ("intelligent_end_time", "intelligentEndTime", False),
+    ("intelligent_end_time_end", "intelligentEndTimeEnd", False),
+    ("intelligent_bridge_duration", "intelligentBridgeDuration", False),
+    ("intelligent_bridge_duration_end", "intelligentBridgeDurationEnd", False),
+    ("intelligent_bot_ids", "intelligentBotIds", True),
+    ("intelligent_status", "intelligentStatus", True),
+    ("intelligent_status_result", "intelligentStatusResult", True),
+    ("intelligent_round", "intelligentRound", False),
+    ("intelligent_round_end", "intelligentRoundEnd", False),
+    ("intelligent_interrupt_count", "intelligentInterruptCount", False),
+    ("intelligent_interrupt_count_end", "intelligentInterruptCountEnd", False),
+    ("intelligent_transfer", "intelligentTransfer", False),
+    ("intelligent_greeting", "intelligentGreeting", False),
+    ("intelligent_greeting_end", "intelligentGreetingEnd", False),
+    ("intelligent_end_flow", "intelligentEndFlow", False),
+    ("intelligent_intention_tag", "intelligentIntentionTag", False),
+    ("intelligent_info", "intelligentInfo", False),
+    ("scroll_search", "scrollSearch", False),
+    ("scroll_id", "scrollId", False),
+    ("offset", "offset", False),
+    ("limit", "limit", False),
+)
+
+
+@dataclass
+class ListCdrAutoTaskQuery:
+    """All Wiki query parameters for list_cdr_auto_task."""
+
+    start_time: int
+    start_time_end: int
+    up_time: Optional[int] = None
+    up_time_end: Optional[int] = None
+    end_time: Optional[int] = None
+    end_time_end: Optional[int] = None
+    hidden_type: Optional[int] = None
+    customer_bridge_duration: Optional[int] = None
+    customer_bridge_duration_end: Optional[int] = None
+    total_duration: Optional[int] = None
+    total_duration_end: Optional[int] = None
+    cnos: Optional[List[str]] = None
+    qnos: Optional[List[str]] = None
+    client_number: Optional[str] = None
+    customer_number: Optional[str] = None
+    customer_number_match_type: Optional[int] = None
+    hotlines: Optional[List[str]] = None
+    xnumber: Optional[List[str]] = None
+    status: Optional[List[int]] = None
+    sip_cause_type: Optional[List[int]] = None
+    sip_cause: Optional[List[int]] = None
+    sip_cause_raw: Optional[List[int]] = None
+    on_hook_source: Optional[List[int]] = None
+    investigation_keys: Optional[int] = None
+    province: Optional[str] = None
+    city: Optional[str] = None
+    main_unique_id: Optional[str] = None
+    request_unique_id: Optional[str] = None
+    evaluation: Optional[int] = None
+    task_ids: Optional[List[str]] = None
+    ivr_ids: Optional[List[int]] = None
+    degrade: Optional[int] = None
+    tel_retry: Optional[int] = None
+    ab_task_group_name: Optional[str] = None
+    finish_retry_flag: Optional[int] = None
+    business_tag_names: Optional[List[str]] = None
+    user_field: Optional[str] = None
+    user_value: Optional[str] = None
+    customer_mos: Optional[List[int]] = None
+    agent_mos: Optional[List[int]] = None
+    intelligent_bridge_time: Optional[int] = None
+    intelligent_bridge_time_end: Optional[int] = None
+    intelligent_end_time: Optional[int] = None
+    intelligent_end_time_end: Optional[int] = None
+    intelligent_bridge_duration: Optional[int] = None
+    intelligent_bridge_duration_end: Optional[int] = None
+    intelligent_bot_ids: Optional[List[str]] = None
+    intelligent_status: Optional[List[int]] = None
+    intelligent_status_result: Optional[List[int]] = None
+    intelligent_round: Optional[int] = None
+    intelligent_round_end: Optional[int] = None
+    intelligent_interrupt_count: Optional[int] = None
+    intelligent_interrupt_count_end: Optional[int] = None
+    intelligent_transfer: Optional[int] = None
+    intelligent_greeting: Optional[int] = None
+    intelligent_greeting_end: Optional[int] = None
+    intelligent_end_flow: Optional[str] = None
+    intelligent_intention_tag: Optional[str] = None
+    intelligent_info: Optional[str] = None
+    scroll_search: Optional[bool] = None
+    scroll_id: Optional[str] = None
+    offset: int = 0
+    limit: int = 10
+
+
+def validate_time_range(start_time: int, start_time_end: int) -> None:
+    """Reject query windows wider than 31 days."""
+    if start_time_end < start_time:
+        raise ValueError("startTimeEnd 不能早于 startTime")
+    if start_time_end - start_time > MAX_RANGE_SECONDS:
+        raise ValueError("查询时间跨度不能超过 31 天")
+
+
+def _require_pair(a: Optional[int], b: Optional[int], label: str) -> None:
+    if (a is None) != (b is None):
+        raise ValueError(f"{label} 须成对传入")
+
+
+def validate_list_cdr_auto_task_query(query: ListCdrAutoTaskQuery) -> None:
+    """Validate Wiki constraints before HTTP."""
+    validate_time_range(query.start_time, query.start_time_end)
+    _require_pair(query.up_time, query.up_time_end, "upTime/upTimeEnd")
+    _require_pair(query.end_time, query.end_time_end, "endTime/endTimeEnd")
+    _require_pair(
+        query.customer_bridge_duration,
+        query.customer_bridge_duration_end,
+        "customerBridgeDuration/customerBridgeDurationEnd",
+    )
+    _require_pair(query.total_duration, query.total_duration_end, "totalDuration/totalDurationEnd")
+    _require_pair(
+        query.intelligent_bridge_time,
+        query.intelligent_bridge_time_end,
+        "intelligentBridgeTime/intelligentBridgeTimeEnd",
+    )
+    _require_pair(
+        query.intelligent_end_time,
+        query.intelligent_end_time_end,
+        "intelligentEndTime/intelligentEndTimeEnd",
+    )
+    _require_pair(
+        query.intelligent_bridge_duration,
+        query.intelligent_bridge_duration_end,
+        "intelligentBridgeDuration/intelligentBridgeDurationEnd",
+    )
+    _require_pair(query.intelligent_round, query.intelligent_round_end, "intelligentRound/intelligentRoundEnd")
+    _require_pair(
+        query.intelligent_interrupt_count,
+        query.intelligent_interrupt_count_end,
+        "intelligentInterruptCount/intelligentInterruptCountEnd",
+    )
+    _require_pair(
+        query.intelligent_greeting,
+        query.intelligent_greeting_end,
+        "intelligentGreeting/intelligentGreetingEnd",
+    )
+    if query.limit < MIN_LIMIT or query.limit > MAX_LIMIT:
+        raise ValueError(f"limit 须在 {MIN_LIMIT}–{MAX_LIMIT} 之间")
+    if query.offset < 0 or query.offset > MAX_OFFSET:
+        raise ValueError(f"offset 须在 0–{MAX_OFFSET} 之间")
+    if query.offset + query.limit > MAX_OFFSET_PLUS_LIMIT:
+        raise ValueError("limit + offset 不允许超过 100000")
+
+
+def build_list_cdr_auto_task_params(query: ListCdrAutoTaskQuery) -> Dict[str, Any]:
+    """Convert query model to CC API query dict (Wiki camelCase keys)."""
+    params: Dict[str, Any] = {
+        "startTime": str(query.start_time),
+        "startTimeEnd": str(query.start_time_end),
+        "offset": str(query.offset),
+        "limit": str(query.limit),
+    }
+    for snake, wiki_key, is_array in WIKI_QUERY_FIELDS:
+        if snake in ("offset", "limit"):
+            continue
+        value = getattr(query, snake)
+        if value is None:
+            continue
+        if snake == "scroll_search":
+            params[wiki_key] = "true" if value else "false"
+        elif is_array:
+            params[wiki_key] = value
+        else:
+            params[wiki_key] = str(value)
+    return params
+
+
+def list_cdr_query_field_names() -> List[str]:
+    """Return dataclass field names excluding start_time/start_time_end."""
+    return [f.name for f in fields(ListCdrAutoTaskQuery) if f.name not in ("start_time", "start_time_end")]

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/core/client.py

@@ -0,0 +1,112 @@
+"""HTTP clients for CTICloud interface and CC gateways."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional
+from urllib.parse import urlencode
+
+import httpx
+
+from cli_anything.cticloud.core.auth import auth_query_params
+from cli_anything.cticloud.core.config import CtiConfig
+
+logger = logging.getLogger(__name__)
+
+
+class CtiApiError(Exception):
+    """Raised when the platform returns an error response."""
+
+    def __init__(self, message: str, payload: Optional[dict] = None):
+        super().__init__(message)
+        self.payload = payload or {}
+
+
+def _region_host(region: str) -> str:
+    return f"https://api-{region}.cticloud.cn"
+
+
+def log_request(method: str, url: str, verbose: bool = False) -> None:
+    """Log request metadata without secrets."""
+    if verbose:
+        safe_url = url.split("sign=")[0] if "sign=" in url else url
+        logger.info("%s %s", method, safe_url)
+
+
+class InterfaceClient:
+    """Client for /interface/v10 endpoints."""
+
+    def __init__(self, config: CtiConfig, timeout: float = 60.0):
+        self.config = config
+        self.timeout = timeout
+        self.base_url = f"{_region_host(config.region)}/interface/v10"
+
+    def make_url(self, path: str, params: Optional[Dict[str, Any]] = None) -> str:
+        """Build full URL with query string (no auth)."""
+        path = path if path.startswith("/") else f"/{path}"
+        query = urlencode(params or {}, doseq=True)
+        return f"{self.base_url}{path}" + (f"?{query}" if query else "")
+
+    def _merge_params(self, params: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        merged = dict(auth_query_params(self.config))
+        if params:
+            merged.update({k: v for k, v in params.items() if v is not None and v != ""})
+        return merged
+
+    def get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        verbose: bool = False,
+    ) -> dict:
+        """Perform authenticated GET and return parsed JSON."""
+        merged = self._merge_params(params)
+        url = self.make_url(path, merged)
+        log_request("GET", url, verbose=verbose)
+        response = httpx.get(url, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+    def post_json(
+        self,
+        path: str,
+        body: dict,
+        params: Optional[Dict[str, Any]] = None,
+        verbose: bool = False,
+    ) -> dict:
+        """Perform authenticated POST with JSON body."""
+        merged = self._merge_params(params)
+        url = self.make_url(path, merged)
+        log_request("POST", url, verbose=verbose)
+        response = httpx.post(url, json=body, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+
+class CcClient:
+    """Client for /cc endpoints."""
+
+    def __init__(self, config: CtiConfig, timeout: float = 60.0):
+        self.config = config
+        self.timeout = timeout
+        self.base_url = f"{_region_host(config.region)}/cc"
+
+    def make_url(self, path: str, params: Optional[Dict[str, Any]] = None) -> str:
+        path = path.lstrip("/")
+        query = urlencode(params or {}, doseq=True)
+        return f"{self.base_url}/{path}" + (f"?{query}" if query else "")
+
+    def get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        verbose: bool = False,
+    ) -> dict:
+        merged = dict(auth_query_params(self.config))
+        if params:
+            merged.update({k: v for k, v in params.items() if v is not None and v != ""})
+        url = self.make_url(path, merged)
+        log_request("GET", url, verbose=verbose)
+        response = httpx.get(url, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()

tinet_cticloud_cli-0.0.5/cli_anything/cticloud/core/config.py

@@ -0,0 +1,100 @@
+"""CTICloud CLI configuration loading and persistence."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+DEFAULT_CONFIG_PATH = Path.home() / ".cticloud" / "config.json"
+
+ENV_MAP = {
+    "region": "CTICLOUD_REGION",
+    "validate_type": "CTICLOUD_VALIDATE_TYPE",
+    "enterprise_id": "CTICLOUD_ENTERPRISE_ID",
+    "department_id": "CTICLOUD_DEPARTMENT_ID",
+    "token": "CTICLOUD_TOKEN",
+}
+
+
+@dataclass
+class CtiConfig:
+    """Runtime credentials and region settings for CTICloud API calls."""
+
+    region: str = "1"
+    validate_type: int = 2
+    enterprise_id: Optional[str] = None
+    department_id: Optional[str] = None
+    token: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return (
+            f"CtiConfig(region={self.region!r}, validate_type={self.validate_type}, "
+            f"enterprise_id={self.enterprise_id!r}, department_id={self.department_id!r}, "
+            f"token='***')"
+        )
+
+    def validate_ready(self) -> None:
+        """Ensure required auth fields are present before API calls."""
+        if not self.token:
+            raise ValueError("缺少 token，请设置 CTICLOUD_TOKEN 或 config set")
+        if self.validate_type == 1 and not self.department_id:
+            raise ValueError("validateType=1 需要 departmentId")
+        if self.validate_type == 2 and not self.enterprise_id:
+            raise ValueError("validateType=2 需要 enterpriseId")
+
+
+def _parse_int(value: str) -> int:
+    return int(value)
+
+
+def load_config(config_path: Optional[Path] = None) -> CtiConfig:
+    """Load configuration from file, overridden by environment variables."""
+    path = config_path or DEFAULT_CONFIG_PATH
+    data: dict[str, Any] = {}
+    if path.exists():
+        with path.open(encoding="utf-8") as fh:
+            data = json.load(fh)
+
+    cfg = CtiConfig(
+        region=str(data.get("region", "1")),
+        validate_type=int(data.get("validate_type", 2)),
+        enterprise_id=data.get("enterprise_id"),
+        department_id=data.get("department_id"),
+        token=data.get("token"),
+    )
+
+    if os.getenv(ENV_MAP["region"]):
+        cfg.region = os.getenv(ENV_MAP["region"], cfg.region)
+    if os.getenv(ENV_MAP["validate_type"]):
+        cfg.validate_type = _parse_int(os.getenv(ENV_MAP["validate_type"], "2"))
+    if os.getenv(ENV_MAP["enterprise_id"]):
+        cfg.enterprise_id = os.getenv(ENV_MAP["enterprise_id"])
+    if os.getenv(ENV_MAP["department_id"]):
+        cfg.department_id = os.getenv(ENV_MAP["department_id"])
+    if os.getenv(ENV_MAP["token"]):
+        cfg.token = os.getenv(ENV_MAP["token"])
+
+    return cfg
+
+
+def save_config(cfg: CtiConfig, config_path: Optional[Path] = None) -> Path:
+    """Persist configuration to disk with restrictive permissions on Unix."""
+    path = config_path or DEFAULT_CONFIG_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "region": cfg.region,
+        "validate_type": cfg.validate_type,
+        "enterprise_id": cfg.enterprise_id,
+        "department_id": cfg.department_id,
+        "token": cfg.token,
+    }
+    with path.open("w", encoding="utf-8") as fh:
+        json.dump(payload, fh, indent=2)
+    try:
+        path.chmod(0o600)
+    except OSError:
+        pass
+    return path