sing-box-cli 0.0.26__tar.gz → 0.0.27__tar.gz

{sing_box_cli-0.0.26 → sing_box_cli-0.0.27}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.0.27 - 2025-03-21
+
+### 🐛 Bug Fixes
+
+- Catch `asyncio.exceptions.CancelledError` while canceling stats display
+- Logic of load groups, when to update delay and load delay history
+
+### 🚜 Refactor
+
+- Replace SingBoxCli class with typer context and modularize commands files
+- Make_stream_request
+- Display logs from api_client
+- Simplify config_dir
+
+### ⚙️ Miscellaneous Tasks
+
+- Remove EmptyResponse
+- Simplify api commands in top level
+
 ## 0.0.26 - 2025-03-20
 
 ### 🚜 Refactor

{sing_box_cli-0.0.26 → sing_box_cli-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sing-box-cli
-Version: 0.0.26
+Version: 0.0.27
 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

{sing_box_cli-0.0.26 → sing_box_cli-0.0.27}/pyproject.toml

@@ -213,7 +213,7 @@ sort_commits = "oldest"
 
 
 [tool.bumpversion]
-current_version = "0.0.26"
+current_version = "0.0.27"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{sing_box_cli-0.0.26 → sing_box_cli-0.0.27}/src/sing_box_service/__init__.py

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

sing_box_cli-0.0.27/src/sing_box_service/api/__init__.py

@@ -0,0 +1,99 @@
+import asyncio
+from functools import lru_cache
+from typing import Annotated
+
+import typer
+
+from ..common import LogLevel, StrOrNone
+from ..config import SingBoxConfig
+from .client import SingBoxAPIClient
+from .connections import ConnectionsManager
+from .logs import get_logs
+from .monitor import ResourceMonitor, ResourceVisualizer
+from .policy import PolicyGroupManager
+
+ApiUrlOption = Annotated[
+    StrOrNone,
+    typer.Option(
+        "--base-url",
+        "-u",
+        help="Base URL of the sing-box API, read from configuration file if not provided",
+    ),
+]
+ApiTokenOption = Annotated[
+    StrOrNone,
+    typer.Option(
+        "--token",
+        "-t",
+        help="Authentication token for the sing-box API, read from configuration file if not provided",
+    ),
+]
+
+LogLevelOption = Annotated[
+    LogLevel,
+    typer.Option(
+        "--log-level",
+        "-l",
+        help="Log level of trace, debug, info, warning, error, fatal, panic",
+        case_sensitive=False,
+    ),
+]
+
+api = typer.Typer(help="sing-box manager.")
+
+
+@lru_cache
+def create_client(
+    config: SingBoxConfig, base_url: StrOrNone = None, token: StrOrNone = None
+) -> SingBoxAPIClient:
+    # read from config if not provided
+    if base_url is None:
+        base_url = config.api_base_url
+    if token is None:
+        token = config.api_secret
+    return SingBoxAPIClient(base_url, token)
+
+
+@api.command()
+def stats(
+    ctx: typer.Context, base_url: ApiUrlOption = None, token: ApiTokenOption = None
+) -> None:
+    """Show sing-box traffic, memory statistics and connections, requires API token(Optional)"""
+
+    api_client = create_client(ctx.obj.config, base_url, token)
+    visualizer = ResourceVisualizer()
+    monitor = ResourceMonitor(api_client, visualizer)
+    asyncio.run(monitor.start())
+
+
+@api.command()
+def conns(
+    ctx: typer.Context, base_url: ApiUrlOption = None, token: ApiTokenOption = None
+) -> None:
+    """Manage sing-box connections, requires API token(Optional)"""
+    api_client = create_client(ctx.obj.config, base_url, token)
+    manager = ConnectionsManager(api_client)
+    asyncio.run(manager.run())
+
+
+@api.command()
+def proxy(
+    ctx: typer.Context, base_url: ApiUrlOption = None, token: ApiTokenOption = None
+) -> None:
+    """Manage sing-box policy groups, requires API token(Optional)"""
+    api_client = create_client(ctx.obj.config, base_url, token)
+    manager = PolicyGroupManager(api_client)
+    asyncio.run(manager.run())
+
+
+@api.command()
+def logs(
+    ctx: typer.Context,
+    log_level: LogLevelOption = LogLevel.info,
+    base_url: ApiUrlOption = None,
+    token: ApiTokenOption = None,
+) -> None:
+    """Show sing-box logs, requires API token(Optional)"""
+    api_client = create_client(ctx.obj.config, base_url, token)
+    print("⌛ Showing real-time logs (Press Ctrl+C to exit)")
+    asyncio.run(get_logs(api_client, log_level))

{sing_box_cli-0.0.26/src/sing_box_service → sing_box_cli-0.0.27/src/sing_box_service/api}/client.py

@@ -75,7 +75,7 @@ class GroupInfo(FrozenBaseModel):
     name: str
     udp: bool = Field(description="UDP support")
     history: list[DelayHistory] = Field(
-        description="History of selected proxies", default=[]
+        description="History delay of selected proxies", default=[]
     )
     now: str = Field(description="Currently selected proxy")
     all: list[str] = Field(description="List of all outbound proxies")
@@ -90,13 +90,13 @@ class GroupsData(FrozenBaseModel):
 class DelayTestResult(FrozenBaseModel):
     """Delay test result model."""
 
+    outbound: str = Field(default="", description="Outbound proxy name")
     delay: int = Field(default=0, description="Outbound delay in milliseconds")
 
 
-class EmptyResponse(FrozenBaseModel):
-    """Empty response model."""
-
-    status_code: int
+class LogEntry(FrozenBaseModel):
+    type: str = Field(description="Logs level")
+    payload: str = Field(description="Log message")
 
 
 # Generic response type for API methods
@@ -187,29 +187,46 @@ class SingBoxAPIClient:
         raw = await self._make_request_raw(method, endpoint, params, data)
         return model_class.model_validate(raw)
 
-    async def traffic_stream(self) -> AsyncGenerator[TrafficData, None]:
+    async def _make_stream_request(
+        self, endpoint: str, model_class: type[T], params: dict[str, str] | None = None
+    ) -> AsyncGenerator[T, None]:
         """
-        Get traffic statistics as a stream of updates.
+        Make a streaming request to the API.
+
+        Args:
+            endpoint: API endpoint
+            model_class: Pydantic model class to validate response data
+            params: Optional query parameters for the request
 
         Yields:
-            TrafficData object containing traffic data (up/down in B/s)
+            Validated model instances from the stream
         """
-        url = f"{self.base_url}/traffic"
+        url = f"{self.base_url}{endpoint}"
 
         async with httpx.AsyncClient() as client:
             async with client.stream(
-                "GET", url, headers=self.headers, timeout=None
+                "GET", url, headers=self.headers, params=params, timeout=None
             ) as response:
                 response.raise_for_status()
                 async for line in response.aiter_lines():
                     if line.strip():  # Skip empty lines
                         try:
                             data = json.loads(line)
-                            yield TrafficData.model_validate(data)
+                            yield model_class.model_validate(data)
                         except json.JSONDecodeError:
                             # Skip invalid JSON lines
                             continue
 
+    async def traffic_stream(self) -> AsyncGenerator[TrafficData, None]:
+        """
+        Get traffic statistics as a stream of updates.
+
+        Yields:
+            TrafficData object containing traffic data (up/down in B/s)
+        """
+        async for data in self._make_stream_request("/traffic", TrafficData):
+            yield data
+
     async def memory_stream(self) -> AsyncGenerator[MemoryData, None]:
         """
         Get memory statistics as a stream of updates.
@@ -217,21 +234,21 @@ class SingBoxAPIClient:
         Yields:
             MemoryData object containing memory data (inuse/total in bytes)
         """
-        url = f"{self.base_url}/memory"
+        async for data in self._make_stream_request("/memory", MemoryData):
+            yield data
 
-        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:
-                            data = json.loads(line)
-                            yield MemoryData.model_validate(data)
-                        except json.JSONDecodeError:
-                            # Skip invalid JSON lines
-                            continue
+    async def log_stream(
+        self, level: str | None = None
+    ) -> AsyncGenerator[LogEntry, None]:
+        """
+        Get log entries as a stream of updates.
+
+        Yields:
+            LogEntry object containing log data (type/payload)
+        """
+        params = {"level": level} if level else None
+        async for data in self._make_stream_request("/logs", LogEntry, params=params):
+            yield data
 
     async def get_connections(self) -> ConnectionData:
         """
@@ -293,7 +310,7 @@ class SingBoxAPIClient:
         group_name: str,
         url: str = "https://cp.cloudflare.com/generate_204",
         timeout: int = 5000,
-    ) -> dict[str, Any]:
+    ) -> list[DelayTestResult]:
         """
         Test delay for all proxies in a policy group.
 
@@ -302,9 +319,12 @@ class SingBoxAPIClient:
             timeout: Timeout in milliseconds
         """
         params = {"url": url, "timeout": timeout}
-        return await self._make_request_raw(
+        reps = await self._make_request_raw(
             "GET", f"/group/{group_name}/delay", params=params
         )
+        return [
+            DelayTestResult(outbound=key, delay=value) for key, value in reps.items()
+        ]
 
     async def test_proxy_delay(
         self,

sing_box_cli-0.0.27/src/sing_box_service/api/logs.py

@@ -0,0 +1,93 @@
+import asyncio
+import re
+from datetime import datetime
+
+from rich import print
+from rich.text import Text
+
+from ..common import LogLevel
+from .client import SingBoxAPIClient
+
+
+async def get_logs(client: SingBoxAPIClient, log_level: LogLevel) -> None:
+    # Define color mapping for log levels with brighter colors
+    # Ref: https://rich.readthedocs.io/en/stable/appendix/colors.html
+    log_level_colors = {
+        "trace": "bright_black",
+        "debug": "grey66",
+        "info": "bright_cyan",
+        "warning": "bright_yellow",
+        "error": "bright_red",
+        "fatal": "bright_magenta",
+        "panic": "bright_magenta",
+    }
+
+    # Bright colors for IDs
+    id_colors = [
+        "bright_red",
+        "bright_green",
+        "bright_yellow",
+        "bright_blue",
+        "bright_magenta",
+        "bright_cyan",
+    ]
+
+    # Dictionary to store ID to color mapping
+    id_color_map = {}
+
+    try:
+        async for entry in client.log_stream(log_level.value.lower()):
+            # Get current timestamp with automatic timezone offset
+            now = datetime.now().astimezone()
+            timestamp = now.strftime("%z %Y-%m-%d %H:%M:%S")
+
+            # Get level color
+            # Start building the output message
+            message = Text()
+            message.append(timestamp, style="bright_black")
+            message.append(" ")
+            message.append(
+                entry.type.upper(),
+                style=log_level_colors.get(entry.type.lower(), "bright_white"),
+            )
+            message.append(" ")
+
+            # Process the payload
+            payload = entry.payload
+
+            # Find all ID patterns in the payload
+            pattern = r"\[(\d+) (\d+ms)\]"
+            last_end = 0
+
+            for match in re.finditer(pattern, payload):
+                # Add text before the match
+                message.append(payload[last_end : match.start()])
+
+                # Extract ID and time part
+                log_id = match.group(1)
+                time_part = match.group(2)
+
+                # Assign a consistent color to this ID
+                if log_id not in id_color_map:
+                    color_index = hash(log_id) % len(id_colors)
+                    id_color_map[log_id] = id_colors[color_index]
+
+                id_color = id_color_map[log_id]
+
+                # Add the ID with coloring
+                message.append("[", style="default")
+                message.append(log_id, style=id_color)
+                message.append(f" {time_part}]", style="default")
+
+                last_end = match.end()
+
+            # Add any remaining text
+            if last_end < len(payload):
+                message.append(payload[last_end:])
+
+            # Print the complete message
+            print(message)
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    except Exception as e:
+        print(f"[red]Error:[/red] {e}")

{sing_box_cli-0.0.26/src/sing_box_service → sing_box_cli-0.0.27/src/sing_box_service/api}/monitor.py

@@ -691,7 +691,7 @@ class ResourceMonitor:
 
                     # Wait for next refresh
                     await asyncio.sleep(self.visualizer.refresh_rate - 0.1)
-                except KeyboardInterrupt:
+                except (asyncio.exceptions.CancelledError, KeyboardInterrupt):
                     self.running = False
                     break
                 except Exception as e:

{sing_box_cli-0.0.26/src/sing_box_service → sing_box_cli-0.0.27/src/sing_box_service/api}/policy.py

@@ -28,9 +28,7 @@ def create_policy_group_table(
     current = group_data.now
     proxies = group_data.all
     # Get delay information, prioritizing the cache
-    # TODO: no sure if this is the best way to handle this
     history = group_data.history
-    history_dict = {item.time: item.delay for item in history} if history else {}
 
     # Create table for proxies
     table = Table(expand=True, show_header=True)
@@ -48,8 +46,9 @@ def create_policy_group_table(
                 latency = f"{delay} ms"
             else:
                 latency = "Timeout"
-        elif proxy in history_dict:
-            delay = history_dict[proxy]
+        elif i == group_data.all.index(current):
+            # [0]->latest delay for the current proxy
+            delay = history[0].delay if history else -1
             if delay > 0:
                 latency = f"{delay} ms"
             else:
@@ -92,7 +91,6 @@ class PolicyGroupManager:
         self.selected_proxy_index = 0
         self.current_group: GroupInfo | None = None
         self.status_message = "Loading policy groups..."
-        self.running = False
 
         # Add a delay cache to store test results
         # Format: {group_name: {proxy_name: delay_value}}
@@ -126,6 +124,9 @@ class PolicyGroupManager:
             """Switch between group list and proxy list."""
             if self.focus_on_groups:
                 self.focus_on_groups = False
+                # initiate a test for the selected group
+                if self.current_group:
+                    asyncio.create_task(self.test_group_delay(self.current_group.name))
             else:
                 self.focus_on_groups = True
 
@@ -298,19 +299,7 @@ class PolicyGroupManager:
             self.status_message = f"Loading group: {group_name}..."
 
             data = await self.api_client.get_group(group_name)
-
-            # Make sure we have the history data
-            # Try to fetch delay data if not present
-            try:
-                await self.api_client.test_group_delay(group_name)
-                # Fetch the group data again to get updated delay information
-                data = await self.api_client.get_group(group_name)
-            except Exception:
-                # If testing fails, continue with existing data
-                pass
-
             self.current_group = data
-            self.selected_proxy_index = 0
 
             # Find the index of the currently selected proxy
             current = data.now
@@ -372,16 +361,9 @@ class PolicyGroupManager:
             if group_name not in self.delay_cache:
                 self.delay_cache[group_name] = {}
 
-            # Test each proxy individually to ensure we get all results
-            # TODO: Consider batching these requests
-            for proxy in proxies:
-                try:
-                    result = await self.api_client.test_proxy_delay(proxy)
-                    delay = result.delay
-                    self.delay_cache[group_name][proxy] = delay
-                except Exception:
-                    # If one proxy test fails, continue with others
-                    pass
+            results = await self.api_client.test_group_delay(group_name)
+            for result in results:
+                self.delay_cache[group_name][result.outbound] = result.delay
 
             self.status_message = f"Tested all proxies in group: {group_name}"
         except Exception as e:
@@ -389,30 +371,11 @@ class PolicyGroupManager:
 
     async def run(self) -> None:
         """Run the policy group manager."""
-        self.running = True
-
-        # Initial load of groups
-        await self.load_groups()
-        # Setup periodic refresh task
-        refresh_task = asyncio.create_task(self.periodic_refresh())
 
         try:
+            # Initial load of groups
+            await self.load_groups()
             await self.app.run_async()
-        finally:
-            self.running = False
-            # Clean up refresh task
-            refresh_task.cancel()
-            try:
-                await refresh_task
-            except asyncio.CancelledError:
-                pass
-
-    async def periodic_refresh(self, interval: float = 5.0) -> None:
-        """Periodically refresh the policy group data."""
-        while self.running:
-            try:
-                await asyncio.sleep(interval)
-                if self.current_group:
-                    await self.load_selected_group()
-            except asyncio.CancelledError:
-                break
+        except Exception as e:
+            self.status_message = f"Error running application: {str(e)}"
+            await asyncio.sleep(5)

sing_box_cli-0.0.27/src/sing_box_service/common.py

@@ -0,0 +1,26 @@
+import os
+from enum import Enum
+
+StrOrNone = str | None
+
+
+class LogLevel(str, Enum):
+    trace = "trace"
+    debug = "debug"
+    info = "info"
+    warning = "warning"
+    error = "error"
+    fatal = "fatal"
+    panic = "panic"
+
+
+def ensure_root() -> None:
+    """https://gist.github.com/RDCH106/fdd419ef7dd803932b16056aab1d2300"""
+    try:
+        if os.geteuid() != 0:  # type: ignore
+            raise SystemError("⚠️ This script must be run as root.")
+    except AttributeError:
+        import ctypes
+
+        if not ctypes.windll.shell32.IsUserAnAdmin():  # type: ignore
+            raise SystemError("⚠️ This script must be run as Administrator.")

sing_box_cli-0.0.27/src/sing_box_service/config/__init__.py

@@ -0,0 +1,46 @@
+from typing import Annotated
+
+import typer
+
+from ..common import ensure_root
+from .config import SingBoxConfig, get_config
+
+__all__ = ["config", "SingBoxConfig", "get_config"]
+
+config = typer.Typer(help="Configuration management commands")
+
+
+@config.command("add-sub")
+def config_add_sub(ctx: typer.Context, url: Annotated[str, typer.Argument()]) -> None:
+    """Add subscription URL"""
+    ensure_root()
+    if ctx.obj.config.add_subscription(url):
+        # restart service if subscription is updated
+        if not ctx.obj.service.check_service():
+            ctx.obj.service.create_service()
+            print("⌛ Service created successfully.")
+        if ctx.obj.config.update_config():
+            ctx.obj.service.restart()
+        else:
+            raise typer.Exit(1)
+    else:
+        print("❌ Failed to add subscription.")
+        raise typer.Exit(1)
+
+
+@config.command("show-sub")
+def config_show_sub(ctx: typer.Context) -> None:
+    """Show subscription URL"""
+    ctx.obj.config.show_subscription()
+
+
+@config.command("show")
+def config_show(ctx: typer.Context) -> None:
+    """Show configuration file"""
+    ctx.obj.config.show_config()
+
+
+@config.command("clean_cache")
+def config_clean_cache(ctx: typer.Context) -> None:
+    """Clean cache database"""
+    ctx.obj.config.clean_cache()