cli-anything-cliproxyapi 1.0.0__py3-none-any.whl

cli_anything/cliproxyapi/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules for CLIProxyAPI CLI harness."""

cli_anything/cliproxyapi/core/api_keys.py

@@ -0,0 +1,144 @@
+"""API 密钥管理模块。"""
+
+from typing import Any, Optional
+
+from .client import ManagementClient
+
+
+class APIKeyManager:
+    """管理 CLIProxyAPI 的各类 API 密钥。"""
+
+    def __init__(self, client: ManagementClient):
+        self.client = client
+
+    # ---- 全局 API 密钥 ----
+
+    def list_api_keys(self) -> list:
+        resp = self.client.get("/api-keys")
+        resp.raise_for_status()
+        return resp.json().get("value", [])
+
+    def set_api_keys(self, keys: list) -> dict:
+        resp = self.client.put("/api-keys", json_data={"value": keys})
+        resp.raise_for_status()
+        return resp.json()
+
+    def add_api_key(self, key: str) -> dict:
+        resp = self.client.patch("/api-keys", json_data={"value": key})
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_api_key(self, key: str) -> dict:
+        resp = self.client.delete("/api-keys", json_data={"value": key})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- Gemini API 密钥 ----
+
+    def list_gemini_keys(self) -> list:
+        resp = self.client.get("/gemini-api-key")
+        resp.raise_for_status()
+        return resp.json().get("value", [])
+
+    def set_gemini_keys(self, keys: list) -> dict:
+        resp = self.client.put("/gemini-api-key", json_data={"value": keys})
+        resp.raise_for_status()
+        return resp.json()
+
+    def add_gemini_key(self, key_data: dict) -> dict:
+        resp = self.client.patch("/gemini-api-key", json_data=key_data)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_gemini_key(self, api_key: str) -> dict:
+        resp = self.client.delete("/gemini-api-key", json_data={"api_key": api_key})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- Claude API 密钥 ----
+
+    def list_claude_keys(self) -> list:
+        resp = self.client.get("/claude-api-key")
+        resp.raise_for_status()
+        return resp.json().get("value", [])
+
+    def set_claude_keys(self, keys: list) -> dict:
+        resp = self.client.put("/claude-api-key", json_data={"value": keys})
+        resp.raise_for_status()
+        return resp.json()
+
+    def add_claude_key(self, key_data: dict) -> dict:
+        resp = self.client.patch("/claude-api-key", json_data=key_data)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_claude_key(self, api_key: str) -> dict:
+        resp = self.client.delete("/claude-api-key", json_data={"api_key": api_key})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- Codex API 密钥 ----
+
+    def list_codex_keys(self) -> list:
+        resp = self.client.get("/codex-api-key")
+        resp.raise_for_status()
+        return resp.json().get("value", [])
+
+    def set_codex_keys(self, keys: list) -> dict:
+        resp = self.client.put("/codex-api-key", json_data={"value": keys})
+        resp.raise_for_status()
+        return resp.json()
+
+    def add_codex_key(self, key_data: dict) -> dict:
+        resp = self.client.patch("/codex-api-key", json_data=key_data)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_codex_key(self, api_key: str) -> dict:
+        resp = self.client.delete("/codex-api-key", json_data={"api_key": api_key})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- OpenAI 兼容提供商 ----
+
+    def list_openai_compat(self) -> list:
+        resp = self.client.get("/openai-compatibility")
+        resp.raise_for_status()
+        return resp.json().get("value", [])
+
+    def set_openai_compat(self, providers: list) -> dict:
+        resp = self.client.put("/openai-compatibility", json_data={"value": providers})
+        resp.raise_for_status()
+        return resp.json()
+
+    def add_openai_compat(self, provider: dict) -> dict:
+        resp = self.client.patch("/openai-compatibility", json_data=provider)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_openai_compat(self, name: str) -> dict:
+        resp = self.client.delete("/openai-compatibility", json_data={"name": name})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- Vertex API 密钥 ----
+
+    def list_vertex_keys(self) -> list:
+        resp = self.client.get("/vertex-api-key")
+        resp.raise_for_status()
+        return resp.json().get("value", [])
+
+    def set_vertex_keys(self, keys: list) -> dict:
+        resp = self.client.put("/vertex-api-key", json_data={"value": keys})
+        resp.raise_for_status()
+        return resp.json()
+
+    def add_vertex_key(self, key_data: dict) -> dict:
+        resp = self.client.patch("/vertex-api-key", json_data=key_data)
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_vertex_key(self, api_key: str) -> dict:
+        resp = self.client.delete("/vertex-api-key", json_data={"api_key": api_key})
+        resp.raise_for_status()
+        return resp.json()

cli_anything/cliproxyapi/core/auth.py

@@ -0,0 +1,176 @@
+"""认证文件管理模块。"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any, Optional
+
+from .client import ManagementClient
+
+CODEX_QUOTA_URL = "https://chatgpt.com/backend-api/wham/usage"
+CODEX_QUOTA_USER_AGENT = "codex_cli_rs/0.76.0 (Debian 13.0.0; x86_64) WindowsTerminal"
+
+
+class AuthManager:
+    """管理 CLIProxyAPI 的认证文件。"""
+
+    def __init__(self, client: ManagementClient):
+        self.client = client
+
+    def list_auth_files(self, disabled: Optional[bool] = None) -> dict:
+        resp = self.client.get("/auth-files", params=None)
+        resp.raise_for_status()
+        data = resp.json()
+        files = data.get("files", [])
+        if disabled is None:
+            return data
+        filtered = [item for item in files if bool(item.get("disabled", False)) is disabled]
+        return {**data, "files": filtered}
+
+    def get_codex_quotas(self) -> dict:
+        payload = self.list_auth_files(disabled=False)
+        files = payload.get("files", [])
+        codex_files = [item for item in files if str(item.get("provider") or item.get("type") or "").strip().lower() == "codex"]
+        quotas = []
+        success = 0
+        failed = 0
+
+        for item in codex_files:
+            auth_index = str(item.get("auth_index") or "").strip()
+            name = str(item.get("name") or item.get("id") or auth_index or "codex")
+            email = str(item.get("email") or "").strip()
+            id_token = item.get("id_token") if isinstance(item.get("id_token"), dict) else {}
+            account_id = str(id_token.get("chatgpt_account_id") or "").strip()
+            plan_type = str(id_token.get("plan_type") or "").strip()
+            quota = {
+                "auth_index": auth_index,
+                "name": name,
+                "email": email,
+                "plan_type": plan_type,
+            }
+
+            if not auth_index:
+                quota["error"] = "missing auth_index"
+                quotas.append(quota)
+                failed += 1
+                continue
+            if not account_id:
+                quota["error"] = "missing chatgpt_account_id"
+                quotas.append(quota)
+                failed += 1
+                continue
+
+            request_body = {
+                "auth_index": auth_index,
+                "method": "GET",
+                "url": CODEX_QUOTA_URL,
+                "header": {
+                    "Authorization": "Bearer $TOKEN$",
+                    "Content-Type": "application/json",
+                    "User-Agent": CODEX_QUOTA_USER_AGENT,
+                    "Chatgpt-Account-Id": account_id,
+                },
+            }
+
+            try:
+                resp = self.client.post("/api-call", json_data=request_body)
+                resp.raise_for_status()
+                api_result = resp.json()
+                body = api_result.get("body") or "{}"
+                payload_json = json.loads(body)
+                rate_limit = payload_json.get("rate_limit") or {}
+                primary = self._build_window(rate_limit.get("primary_window") or {})
+                secondary = self._build_window(rate_limit.get("secondary_window") or {})
+                quota.update({
+                    "status_code": api_result.get("status_code"),
+                    "email": str(payload_json.get("email") or email).strip(),
+                    "plan_type": str(payload_json.get("plan_type") or plan_type).strip(),
+                    "primary_window": primary,
+                    "secondary_window": secondary,
+                })
+                quotas.append(quota)
+                success += 1
+            except Exception as exc:
+                quota["error"] = str(exc)
+                quotas.append(quota)
+                failed += 1
+
+        return {
+            "total": len(quotas),
+            "success": success,
+            "failed": failed,
+            "quotas": quotas,
+        }
+
+    @staticmethod
+    def _build_window(window: dict) -> dict:
+        used_percent = int(window.get("used_percent") or 0)
+        reset_at = int(window.get("reset_at") or 0)
+        return {
+            "used_percent": used_percent,
+            "remaining_percent": max(0, 100 - used_percent),
+            "limit_window_seconds": int(window.get("limit_window_seconds") or 0),
+            "reset_after_seconds": int(window.get("reset_after_seconds") or 0),
+            "reset_at": reset_at,
+            "reset_at_local": datetime.fromtimestamp(reset_at).strftime("%m/%d %H:%M") if reset_at else "",
+        }
+
+    def get_auth_file_models(self) -> dict:
+        resp = self.client.get("/auth-files/models")
+        resp.raise_for_status()
+        return resp.json()
+
+    def upload_auth_file(self, filename: str, content: str) -> dict:
+        import requests
+
+        url = f"{self.client.conn.base_url}/v0/management/auth-files"
+        files = {"file": (filename, content, "application/json")}
+        headers = {"Authorization": f"Bearer {self.client.conn.management_key}"}
+        resp = requests.post(url, files=files, headers=headers, timeout=30)
+        resp.raise_for_status()
+        return resp.json()
+
+    def download_auth_file(self, filename: str) -> str:
+        resp = self.client.get("/auth-files/download", params={"filename": filename})
+        resp.raise_for_status()
+        return resp.text
+
+    def delete_auth_file(self, filename: str) -> dict:
+        resp = self.client.delete("/auth-files", json_data={"filename": filename})
+        resp.raise_for_status()
+        return resp.json()
+
+    def patch_auth_file_status(self, filename: str, disabled: bool) -> dict:
+        resp = self.client.patch("/auth-files/status", json_data={
+            "filename": filename,
+            "disabled": disabled,
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    def patch_auth_file_fields(self, filename: str, fields: dict) -> dict:
+        resp = self.client.patch("/auth-files/fields", json_data={
+            "filename": filename,
+            **fields,
+        })
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_model_definitions(self, channel: str) -> dict:
+        resp = self.client.get(f"/model-definitions/{channel}")
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_auth_status(self, session_id: str) -> dict:
+        resp = self.client.get("/get-auth-status", params={"session_id": session_id})
+        resp.raise_for_status()
+        return resp.json()
+
+    def import_vertex(self, key_json: str, prefix: str = "") -> dict:
+        data: dict[str, Any] = {"key": key_json}
+        if prefix:
+            data["prefix"] = prefix
+        resp = self.client.post("/vertex/import", json_data=data)
+        resp.raise_for_status()
+        return resp.json()

cli_anything/cliproxyapi/core/client.py

@@ -0,0 +1,101 @@
+"""HTTP 客户端，封装与 CLIProxyAPI 管理 API 的所有通信。"""
+
+import json
+import os
+from typing import Any, Optional
+from pathlib import Path
+
+import requests
+
+
+# 默认配置文件路径
+DEFAULT_CONFIG_PATH = Path.home() / ".cliproxyapi-cli.yaml"
+
+
+class ConnectionConfig:
+    """从 CLI 参数 / 环境变量 / 配置文件解析连接参数。"""
+
+    def __init__(
+        self,
+        url: Optional[str] = None,
+        key: Optional[str] = None,
+    ):
+        self.base_url = (url or os.getenv("CPA_URL") or self._load_from_config("url") or "").rstrip("/")
+        self.management_key = key or os.getenv("CPA_KEY") or self._load_from_config("key") or ""
+
+    @staticmethod
+    def _load_from_config(field: str) -> Optional[str]:
+        if not DEFAULT_CONFIG_PATH.exists():
+            return None
+        try:
+            import yaml
+
+            data = yaml.safe_load(DEFAULT_CONFIG_PATH.read_text())
+            if isinstance(data, dict):
+                return data.get(field)
+        except Exception:
+            pass
+        return None
+
+    def save(self, url: str, key: str) -> None:
+        import yaml
+
+        data = {}
+        if DEFAULT_CONFIG_PATH.exists():
+            try:
+                data = yaml.safe_load(DEFAULT_CONFIG_PATH.read_text()) or {}
+            except Exception:
+                data = {}
+        data["url"] = url.rstrip("/")
+        data["key"] = key
+        DEFAULT_CONFIG_PATH.write_text(yaml.dump(data, default_flow_style=False))
+
+    @property
+    def is_configured(self) -> bool:
+        return bool(self.base_url and self.management_key)
+
+
+class ManagementClient:
+    """CLIProxyAPI 管理 API 的 HTTP 客户端。"""
+
+    def __init__(self, conn: ConnectionConfig):
+        self.conn = conn
+        self._session = requests.Session()
+
+    @property
+    def _headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.conn.management_key}",
+            "Content-Type": "application/json",
+        }
+
+    def _url(self, path: str) -> str:
+        return f"{self.conn.base_url}/v0/management{path}"
+
+    def get(self, path: str, params: Optional[dict] = None) -> requests.Response:
+        return self._session.get(self._url(path), headers=self._headers, params=params, timeout=30)
+
+    def post(self, path: str, json_data: Any = None, **kwargs) -> requests.Response:
+        return self._session.post(self._url(path), headers=self._headers, json=json_data, timeout=30, **kwargs)
+
+    def put(self, path: str, json_data: Any = None) -> requests.Response:
+        return self._session.put(self._url(path), headers=self._headers, json=json_data, timeout=30)
+
+    def patch(self, path: str, json_data: Any = None) -> requests.Response:
+        return self._session.patch(self._url(path), headers=self._headers, json=json_data, timeout=30)
+
+    def delete(self, path: str, json_data: Any = None) -> requests.Response:
+        return self._session.delete(self._url(path), headers=self._headers, json=json_data, timeout=30)
+
+    # ---- 代理 API（非管理端点） ----
+
+    def health_check(self) -> requests.Response:
+        return self._session.get(f"{self.conn.base_url}/healthz", timeout=10)
+
+    def proxy_get(self, path: str, api_key: str, params: Optional[dict] = None) -> requests.Response:
+        headers = {"Authorization": f"Bearer {api_key}"}
+        return self._session.get(f"{self.conn.base_url}{path}", headers=headers, params=params, timeout=30)
+
+    def proxy_post(self, path: str, api_key: str, json_data: Any = None) -> requests.Response:
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        return self._session.post(f"{self.conn.base_url}{path}", headers=headers, json=json_data, timeout=60)

cli_anything/cliproxyapi/core/config.py

@@ -0,0 +1,194 @@
+"""配置管理模块。"""
+
+from typing import Any, Optional
+
+from .client import ManagementClient
+
+
+class ConfigManager:
+    """管理 CLIProxyAPI 的配置项。"""
+
+    def __init__(self, client: ManagementClient):
+        self.client = client
+
+    def get_config(self) -> dict:
+        resp = self.client.get("/config")
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_config_yaml(self) -> str:
+        resp = self.client.get("/config.yaml")
+        resp.raise_for_status()
+        return resp.text
+
+    def put_config_yaml(self, yaml_content: str) -> dict:
+        resp = self.client.put(
+            "/config.yaml",
+            json_data=yaml_content,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 调试模式 ----
+
+    def get_debug(self) -> bool:
+        resp = self.client.get("/debug")
+        resp.raise_for_status()
+        return resp.json().get("value", False)
+
+    def set_debug(self, enabled: bool) -> dict:
+        resp = self.client.put("/debug", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 日志写文件 ----
+
+    def get_logging_to_file(self) -> bool:
+        resp = self.client.get("/logging-to-file")
+        resp.raise_for_status()
+        return resp.json().get("value", False)
+
+    def set_logging_to_file(self, enabled: bool) -> dict:
+        resp = self.client.put("/logging-to-file", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 日志大小限制 ----
+
+    def get_logs_max_total_size_mb(self) -> int:
+        resp = self.client.get("/logs-max-total-size-mb")
+        resp.raise_for_status()
+        return resp.json().get("value", 0)
+
+    def set_logs_max_total_size_mb(self, value: int) -> dict:
+        resp = self.client.put("/logs-max-total-size-mb", json_data={"value": value})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 错误日志文件数限制 ----
+
+    def get_error_logs_max_files(self) -> int:
+        resp = self.client.get("/error-logs-max-files")
+        resp.raise_for_status()
+        return resp.json().get("value", 10)
+
+    def set_error_logs_max_files(self, value: int) -> dict:
+        resp = self.client.put("/error-logs-max-files", json_data={"value": value})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 使用统计 ----
+
+    def get_usage_statistics_enabled(self) -> bool:
+        resp = self.client.get("/usage-statistics-enabled")
+        resp.raise_for_status()
+        return resp.json().get("value", False)
+
+    def set_usage_statistics_enabled(self, enabled: bool) -> dict:
+        resp = self.client.put("/usage-statistics-enabled", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 代理 URL ----
+
+    def get_proxy_url(self) -> Optional[str]:
+        resp = self.client.get("/proxy-url")
+        resp.raise_for_status()
+        return resp.json().get("value")
+
+    def set_proxy_url(self, url: str) -> dict:
+        resp = self.client.put("/proxy-url", json_data={"value": url})
+        resp.raise_for_status()
+        return resp.json()
+
+    def delete_proxy_url(self) -> dict:
+        resp = self.client.delete("/proxy-url")
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 请求重试 ----
+
+    def get_request_retry(self) -> int:
+        resp = self.client.get("/request-retry")
+        resp.raise_for_status()
+        return resp.json().get("value", 3)
+
+    def set_request_retry(self, value: int) -> dict:
+        resp = self.client.put("/request-retry", json_data={"value": value})
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_max_retry_interval(self) -> int:
+        resp = self.client.get("/max-retry-interval")
+        resp.raise_for_status()
+        return resp.json().get("value", 30)
+
+    def set_max_retry_interval(self, value: int) -> dict:
+        resp = self.client.put("/max-retry-interval", json_data={"value": value})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 模型前缀 ----
+
+    def get_force_model_prefix(self) -> bool:
+        resp = self.client.get("/force-model-prefix")
+        resp.raise_for_status()
+        return resp.json().get("value", False)
+
+    def set_force_model_prefix(self, enabled: bool) -> dict:
+        resp = self.client.put("/force-model-prefix", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 路由策略 ----
+
+    def get_routing_strategy(self) -> str:
+        resp = self.client.get("/routing/strategy")
+        resp.raise_for_status()
+        return resp.json().get("value", "round-robin")
+
+    def set_routing_strategy(self, strategy: str) -> dict:
+        resp = self.client.put("/routing/strategy", json_data={"value": strategy})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 配额超限行为 ----
+
+    def get_switch_project(self) -> bool:
+        resp = self.client.get("/quota-exceeded/switch-project")
+        resp.raise_for_status()
+        return resp.json().get("value", True)
+
+    def set_switch_project(self, enabled: bool) -> dict:
+        resp = self.client.put("/quota-exceeded/switch-project", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_switch_preview_model(self) -> bool:
+        resp = self.client.get("/quota-exceeded/switch-preview-model")
+        resp.raise_for_status()
+        return resp.json().get("value", True)
+
+    def set_switch_preview_model(self, enabled: bool) -> dict:
+        resp = self.client.put("/quota-exceeded/switch-preview-model", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- WebSocket 认证 ----
+
+    def get_ws_auth(self) -> bool:
+        resp = self.client.get("/ws-auth")
+        resp.raise_for_status()
+        return resp.json().get("value", False)
+
+    def set_ws_auth(self, enabled: bool) -> dict:
+        resp = self.client.put("/ws-auth", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    # ---- 最新版本 ----
+
+    def get_latest_version(self) -> dict:
+        resp = self.client.get("/latest-version")
+        resp.raise_for_status()
+        return resp.json()

cli_anything/cliproxyapi/core/logs.py

@@ -0,0 +1,47 @@
+"""日志管理模块。"""
+
+from typing import Optional
+
+from .client import ManagementClient
+
+
+class LogManager:
+    """管理 CLIProxyAPI 的日志。"""
+
+    def __init__(self, client: ManagementClient):
+        self.client = client
+
+    def get_logs(self, lines: int = 100) -> str:
+        resp = self.client.get("/logs", params={"lines": lines})
+        resp.raise_for_status()
+        return resp.text
+
+    def delete_logs(self) -> dict:
+        resp = self.client.delete("/logs")
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_request_log(self) -> dict:
+        resp = self.client.get("/request-log")
+        resp.raise_for_status()
+        return resp.json()
+
+    def set_request_log(self, enabled: bool) -> dict:
+        resp = self.client.put("/request-log", json_data={"value": enabled})
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_request_error_logs(self) -> dict:
+        resp = self.client.get("/request-error-logs")
+        resp.raise_for_status()
+        return resp.json()
+
+    def download_request_error_log(self, name: str) -> str:
+        resp = self.client.get(f"/request-error-logs/{name}")
+        resp.raise_for_status()
+        return resp.text
+
+    def get_request_log_by_id(self, log_id: str) -> dict:
+        resp = self.client.get(f"/request-log-by-id/{log_id}")
+        resp.raise_for_status()
+        return resp.json()