sing-box-cli 0.0.18__tar.gz → 0.0.21__tar.gz

{sing_box_cli-0.0.18 → sing_box_cli-0.0.21}/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.0.21 - 2025-03-18
+
+### 🐛 Bug Fixes
+
+- Replace None of host with destination ip
+
+## 0.0.20 - 2025-03-18
+
+### 🚀 Features
+
+- Add stats command to visualize traffic, memory and connections
+- Add cnns command to manage connections
+- Add proxy command to select policy
+
+### 🚜 Refactor
+
+- Replace requests with httpx
+- Check url using httpx
+
+## 0.0.19 - 2025-03-15
+
+### 🚀 Features
+
+- Add simple run command
+
+### ⚙️ Miscellaneous Tasks
+
+- Add type annotationfor __init__
+
 ## 0.0.18 - 2025-03-15
 
 ### ⚙️ Miscellaneous Tasks

{sing_box_cli-0.0.18 → sing_box_cli-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sing-box-cli
-Version: 0.0.18
+Version: 0.0.21
 Summary: cross-platform sing-box-service manager.
 Project-URL: Homepage, https://github.com/aittcuszz/sing-box-service
 Project-URL: Issues, https://github.com/atticuszz/sing-box-service/issues
@@ -38,8 +38,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: psutil>=6.1.1
-Requires-Dist: requests>=2.32.3
 Requires-Dist: typer>=0.15.1
 Description-Content-Type: text/markdown
 

{sing_box_cli-0.0.18 → sing_box_cli-0.0.21}/pyproject.toml

@@ -24,8 +24,9 @@ maintainers = [{ name = "A.J.Zeller", email = "zhouge1831@gmail.com" }]
 
 dynamic = ["version"] # https://hatch.pypa.io/latest/config/metadata/#version
 dependencies = [
+    "httpx>=0.28.1",
+    "prompt-toolkit>=3.0.50",
     "psutil>=6.1.1",
-    "requests>=2.32.3",
     "typer>=0.15.1",
 ]
 
@@ -57,7 +58,6 @@ dev = [
     "bump-my-version>=0.28.0",
     "typos>=1.26.8",
     "types-psutil>=6.1.0.20241221",
-    "types-requests>=2.32.0.20241016",
     "pytest>=8.3.5",
 ]
 
@@ -210,7 +210,7 @@ sort_commits = "oldest"
 
 
 [tool.bumpversion]
-current_version = "0.0.18"
+current_version = "0.0.21"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{sing_box_cli-0.0.18 → sing_box_cli-0.0.21}/src/sing_box_service/__init__.py

@@ -2,4 +2,4 @@ from .main import main
 
 __all__ = ["main"]
 
-__version__ = "0.0.18"
+__version__ = "0.0.21"

sing_box_cli-0.0.21/src/sing_box_service/client.py

@@ -0,0 +1,245 @@
+"""
+Sing-Box API Client module.
+Provides an async client for interacting with Sing-Box HTTP API.
+"""
+
+import json
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import httpx
+
+
+class SingBoxAPIClient:
+    """Async client for interacting with Sing-Box API.
+
+    Args:
+        base_url: The base URL of the Sing-Box API
+        token: The API authentication token
+        timeout: Request timeout in seconds
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://127.0.0.1:9090",
+        token: str | None = None,
+        timeout: float = 10.0,
+    ) -> None:
+        self.base_url = base_url
+        self.headers = {"Authorization": f"Bearer {token}"} if token else {}
+        self.timeout = timeout
+        if not self._health_check():
+            raise ValueError(f"Invalid to initialize client: {self.base_url}")
+
+    def _health_check(self) -> bool:
+        """Check if the API is reachable.
+
+        Returns:
+            True if the API is reachable, False otherwise
+        """
+        try:
+            response = httpx.get(
+                f"{self.base_url}", timeout=self.timeout, headers=self.headers
+            )
+            return response.status_code == 200
+        except httpx.HTTPError:
+            return False
+
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Make a request to the API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint
+            params: URL parameters
+            data: Request body data
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            httpx.HTTPError: If the request fails
+        """
+        url = f"{self.base_url}{endpoint}"
+        async with httpx.AsyncClient() as client:
+            response = await client.request(
+                method=method,
+                url=url,
+                params=params,
+                json=data,
+                headers=self.headers,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            if response.content:
+                return dict(response.json())
+            return {}
+
+    async def traffic_stream(self) -> AsyncGenerator[dict[str, Any], None]:
+        """
+        Get traffic statistics as a stream of updates.
+
+        Yields:
+            Dictionary containing traffic data (up/down in B/s)
+        """
+        url = f"{self.base_url}/traffic"
+
+        async with httpx.AsyncClient() as client:
+            async with client.stream(
+                "GET", url, headers=self.headers, timeout=None
+            ) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.strip():  # Skip empty lines
+                        try:
+                            yield json.loads(line)
+                        except json.JSONDecodeError:
+                            # Skip invalid JSON lines
+                            continue
+
+    async def memory_stream(self) -> AsyncGenerator[dict[str, Any], None]:
+        """
+        Get memory statistics as a stream of updates.
+
+        Yields:
+            Dictionary containing memory data (inuse/total in bytes)
+        """
+        url = f"{self.base_url}/memory"
+
+        async with httpx.AsyncClient() as client:
+            async with client.stream(
+                "GET", url, headers=self.headers, timeout=None
+            ) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.strip():  # Skip empty lines
+                        try:
+                            yield json.loads(line)
+                        except json.JSONDecodeError:
+                            # Skip invalid JSON lines
+                            continue
+
+    async def get_connections(self) -> dict[str, Any]:
+        """
+        Get current connections.
+
+        Returns:
+            Dictionary containing active connections
+        """
+        return await self._make_request("GET", "/connections")
+
+    async def close_connection(self, connection_id: str) -> dict[str, Any]:
+        """
+        Close a specific connection.
+
+        Args:
+            connection_id: ID of the connection to close
+
+        Returns:
+            Response from the API
+        """
+        return await self._make_request("DELETE", f"/connections/{connection_id}")
+
+    async def close_all_connections(self) -> dict[str, Any]:
+        """
+        Close all connections.
+
+        Returns:
+            Response from the API
+        """
+        return await self._make_request("DELETE", "/connections")
+
+    async def get_groups(self) -> dict[str, Any]:
+        """
+        Get all policy groups.
+
+        Returns:
+            Dictionary containing policy groups information
+        """
+        return await self._make_request("GET", "/group")
+
+    async def get_group(self, group_name: str) -> dict[str, Any]:
+        """
+        Get information about a specific policy group.
+
+        Args:
+            group_name: Name of the policy group
+
+        Returns:
+            Dictionary containing the policy group information
+        """
+        return await self._make_request("GET", f"/group/{group_name}")
+
+    async def test_group_delay(
+        self,
+        group_name: str,
+        url: str = "https://cp.cloudflare.com/generate_204",
+        timeout: int = 5000,
+    ) -> dict[str, Any]:
+        """
+        Test delay for all proxies in a policy group.
+
+        Args:
+            group_name: Name of the policy group
+            url: URL to test latency against
+            timeout: Timeout in milliseconds
+
+        Returns:
+            Dictionary containing delay test results
+        """
+        params = {"url": url, "timeout": timeout}
+        return await self._make_request(
+            "GET", f"/group/{group_name}/delay", params=params
+        )
+
+    async def test_proxy_delay(
+        self,
+        proxy_name: str,
+        url: str = "https://cp.cloudflare.com/generate_204",
+        timeout: int = 5000,
+    ) -> dict[str, Any]:
+        """
+        Test delay for a specific proxy.
+
+        Args:
+            proxy_name: Name of the proxy
+            url: URL to test latency against
+            timeout: Timeout in milliseconds
+
+        Returns:
+            Dictionary containing delay test results
+        """
+        params = {"url": url, "timeout": timeout}
+        return await self._make_request(
+            "GET", f"/proxies/{proxy_name}/delay", params=params
+        )
+
+    async def select_proxy(self, proxy_name: str, selected: str) -> dict[str, Any]:
+        """
+        Select a proxy for a selector proxy group.
+
+        Args:
+            proxy_name: Name of the proxy selector
+            selected: Name of the proxy to select
+
+        Returns:
+            Response from the API
+        """
+        data = {"name": selected}
+        return await self._make_request("PUT", f"/proxies/{proxy_name}", data=data)
+
+    async def get_version(self) -> dict[str, Any]:
+        """
+        Get Sing-Box version.
+
+        Returns:
+            Dictionary containing version information
+        """
+        return await self._make_request("GET", "/version")

{sing_box_cli-0.0.18 → sing_box_cli-0.0.21}/src/sing_box_service/config.py

@@ -1,9 +1,11 @@
+import json
 import os
 import platform
 import shutil
 from pathlib import Path
+from typing import Any
 
-import requests
+import httpx
 from rich import print
 
 
@@ -64,6 +66,28 @@ class Config:
             return ""
         return self.subscription_file.read_text().strip()
 
+    @property
+    def api_base_url(self) -> str:
+        config = load_json_config(self.config_file)
+        url = (
+            config.get("experimental", {})
+            .get("clash_api", {})
+            .get("external_controller", "")
+        )
+        if isinstance(url, str) and url:
+            if not url.startswith("http"):
+                url = f"http://{url}"
+            return url
+        return ""
+
+    @property
+    def api_secret(self) -> str:
+        config = load_json_config(self.config_file)
+        token = config.get("experimental", {}).get("clash_api", {}).get("secret", "")
+        if isinstance(token, str) and token:
+            return token
+        return ""
+
     def update_config(self) -> bool:
         """download configuration from subscription URL and show differences"""
         if not self.sub_url:
@@ -77,7 +101,7 @@ class Config:
         )
         print(f"⌛ Updating configuration from {self.sub_url}")
         try:
-            response = requests.get(self.sub_url)
+            response = httpx.get(self.sub_url)
             response.raise_for_status()
             new_config = response.text
             self.config_file.write_text(new_config, encoding="utf-8")
@@ -95,8 +119,7 @@ class Config:
             return False
 
     def add_subscription(self, url: str) -> bool:
-        if not url.startswith(("http://", "https://")):
-            print("❌ Invalid URL format.")
+        if not check_url(url):
             return False
         self.subscription_file.write_text(url.strip())
         print("📁 Subscription added successfully.")
@@ -154,3 +177,21 @@ def show_diff_config(current_config: str, new_config: str) -> None:
             print(f"[dim]{line}[/dim]")
         else:
             print(f"[white]{line}[/white]")
+
+
+def check_url(url: str) -> bool:
+    try:
+        response = httpx.head(url)
+        response.raise_for_status()
+        return True
+    except Exception as e:
+        print(f"❌ Invalid URL: {e}")
+        return False
+
+
+def load_json_config(config_file: Path) -> dict[str, Any]:
+    try:
+        return dict(json.loads(config_file.read_text(encoding="utf-8")))
+    except Exception as e:
+        print(f"❌ Failed to load configuration: {e}")
+        return {}