sing-box-cli 0.1.7__tar.gz → 0.1.8__tar.gz

{sing_box_cli-0.1.7 → sing_box_cli-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sing-box-cli
-Version: 0.1.7
+Version: 0.1.8
 Summary: cross-platform sing-box 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.1.7 → sing_box_cli-0.1.8}/pyproject.toml

@@ -215,7 +215,7 @@ topo_order = false
 sort_commits = "oldest"
 
 [tool.bumpversion]
-current_version        = "0.1.7"
+current_version        = "0.1.8"
 parse                  = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize              = ["{major}.{minor}.{patch}"]
 search                 = "{current_version}"

{sing_box_cli-0.1.7 → sing_box_cli-0.1.8}/src/sing_box_cli/__init__.py

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

{sing_box_cli-0.1.7 → sing_box_cli-0.1.8}/src/sing_box_cli/api/__init__.py

@@ -2,12 +2,13 @@ import asyncio
 from collections.abc import Callable, Coroutine
 from typing import Annotated, Any
 
+import httpx
 import typer
 
 from ..common import LogLevel, StrOrNone
 from ..config.config import ConfigHandler
 from ..service import get_context_obj
-from .client import SingBoxAPIClient
+from .client import SingBoxAPIClient, SingBoxAPIError
 from .connections import ConnectionsManager
 from .logs import get_logs
 from .monitor import ResourceMonitor, ResourceVisualizer
@@ -67,6 +68,12 @@ def _run_tui(
         asyncio.run(command(api_client))
     except (KeyboardInterrupt, EOFError):
         pass
+    except SingBoxAPIError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1)
+    except httpx.HTTPError as e:
+        typer.echo(f"Error: sing-box API request failed: {e}", err=True)
+        raise typer.Exit(1)
     print("Exited.")
 
 

{sing_box_cli-0.1.7 → sing_box_cli-0.1.8}/src/sing_box_cli/api/client.py

@@ -104,6 +104,10 @@ class LogEntry(FrozenBaseModel):
 T = TypeVar("T", bound=FrozenBaseModel)
 
 
+class SingBoxAPIError(Exception):
+    """The sing-box API is unreachable or rejected the client."""
+
+
 class SingBoxAPIClient:
     """Async client for interacting with Sing-Box API.
 
@@ -123,7 +127,10 @@ class SingBoxAPIClient:
         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}")
+            raise SingBoxAPIError(
+                f"sing-box API is not reachable at {self.base_url}, "
+                "check that sing-box is running and the API URL and token are correct"
+            )
 
     def _health_check(self) -> bool:
         """Check if the API is reachable.
@@ -204,9 +211,11 @@ class SingBoxAPIClient:
         """
         url = f"{self.base_url}{endpoint}"
 
+        # streams may stay idle for long, so only reads are unbounded
+        timeout = httpx.Timeout(self.timeout, read=None)
         async with httpx.AsyncClient() as client:
             async with client.stream(
-                "GET", url, headers=self.headers, params=params, timeout=None
+                "GET", url, headers=self.headers, params=params, timeout=timeout
             ) as response:
                 response.raise_for_status()
                 async for line in response.aiter_lines():

{sing_box_cli-0.1.7 → sing_box_cli-0.1.8}/src/sing_box_cli/api/connections.py

@@ -440,10 +440,18 @@ class ConnectionsManager:
                     pass
 
     async def periodic_refresh(self, interval: float = 0.5) -> None:
-        """Periodically refresh connections."""
+        """Periodically refresh connections, retrying while the API is unreachable."""
+        failed = False
         while self.running:
             try:
                 await asyncio.sleep(interval)
                 await self.refresh_connections()
             except asyncio.CancelledError:
                 break
+            except Exception:
+                # refresh_connections already shows the error in the status bar
+                failed = True
+                continue
+            if failed:
+                failed = False
+                self.status_message = self.get_filter_state()

sing_box_cli-0.1.8/src/sing_box_cli/api/logs.py

@@ -0,0 +1,89 @@
+import re
+from contextlib import aclosing
+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 = {}
+
+    async with aclosing(client.log_stream(log_level.value.lower())) as stream:
+        async for entry in stream:
+            # 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)

{sing_box_cli-0.1.7 → sing_box_cli-0.1.8}/src/sing_box_cli/api/monitor.py

@@ -2,6 +2,7 @@ import asyncio
 import math
 import statistics
 from collections import deque
+from collections.abc import AsyncGenerator, Callable
 from contextlib import aclosing
 from datetime import datetime
 from enum import Enum
@@ -14,7 +15,13 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from .client import ConnectionInfo, MemoryData, SingBoxAPIClient, TrafficData
+from .client import (
+    ConnectionInfo,
+    FrozenBaseModel,
+    MemoryData,
+    SingBoxAPIClient,
+    TrafficData,
+)
 from .widget import RichPlotMixin, create_header_panel
 
 
@@ -575,7 +582,10 @@ class ResourceVisualizer:
         return table
 
     def create_resources_layout(
-        self, traffic_data: TrafficData, memory_data: MemoryData
+        self,
+        traffic_data: TrafficData,
+        memory_data: MemoryData,
+        api_error: str | None = None,
     ) -> Layout:
         """Create the main layout with all resource components."""
         layout = Layout()
@@ -617,7 +627,17 @@ class ResourceVisualizer:
         )
 
         # Add footer
-        layout["footer"].update(Text("Press Ctrl+C to exit", justify="center"))
+        if api_error:
+            footer = Text(
+                f"{api_error} | Press Ctrl+C to exit",
+                style="bold red",
+                justify="center",
+                no_wrap=True,
+                overflow="ellipsis",
+            )
+        else:
+            footer = Text("Press Ctrl+C to exit", justify="center")
+        layout["footer"].update(footer)
 
         return layout
 
@@ -642,30 +662,44 @@ class ResourceMonitor:
         self.current_memory = MemoryData(inuse=0, total=0)  # in bytes
         # 1.0 fix interval for avoiding repeated data
         self.task_interval = RefreshRate.SLOW.value
+        self.reconnect_interval = RefreshRate.SLOW.value
+        self.api_error: str | None = None
 
     async def monitor_traffic(self) -> None:
         """Monitor traffic stream from the API."""
-        try:
-            async with aclosing(self.api_client.traffic_stream()) as stream:
-                async for traffic_data in stream:
-                    self.current_traffic = traffic_data
-                    if not self.running:
-                        break
-                    await asyncio.sleep(self.task_interval)
-        except Exception as e:
-            self.visualizer.console.print(f"[red]Error monitoring traffic: {str(e)}")
+        await self._follow_stream(
+            self.api_client.traffic_stream, "current_traffic", TrafficData()
+        )
 
     async def monitor_memory(self) -> None:
         """Monitor memory stream from the API."""
-        try:
-            async with aclosing(self.api_client.memory_stream()) as stream:
-                async for memory_data in stream:
-                    self.current_memory = memory_data
-                    if not self.running:
-                        break
-                    await asyncio.sleep(self.task_interval)
-        except Exception as e:
-            self.visualizer.console.print(f"[red]Error monitoring memory: {str(e)}")
+        await self._follow_stream(
+            self.api_client.memory_stream, "current_memory", MemoryData()
+        )
+
+    async def _follow_stream(
+        self,
+        open_stream: Callable[[], AsyncGenerator[FrozenBaseModel, None]],
+        attr: str,
+        empty: FrozenBaseModel,
+    ) -> None:
+        """Keep ``attr`` updated from a stream, reopening it whenever it ends."""
+        while self.running:
+            try:
+                async with aclosing(open_stream()) as stream:
+                    async for data in stream:
+                        setattr(self, attr, data)
+                        self.api_error = None
+                        if not self.running:
+                            return
+                        await asyncio.sleep(self.task_interval)
+                reason = "closed by sing-box"
+            except Exception as e:
+                reason = str(e) or type(e).__name__
+            # don't keep showing stale numbers while sing-box is down
+            setattr(self, attr, empty)
+            self.api_error = f"sing-box API stream lost ({reason}), reconnecting..."
+            await asyncio.sleep(self.reconnect_interval)
 
     async def refresh_display(self) -> None:
         """Main display refresh loop."""
@@ -685,7 +719,7 @@ class ResourceMonitor:
 
                         # Update display
                         layout = self.visualizer.create_resources_layout(
-                            traffic_data, memory_data
+                            traffic_data, memory_data, self.api_error
                         )
                         live.update(layout)
 

sing_box_cli-0.1.7/src/sing_box_cli/api/logs.py

@@ -1,93 +0,0 @@
-import re
-from contextlib import aclosing
-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 with aclosing(client.log_stream(log_level.value.lower())) as stream:
-            async for entry in stream:
-                # 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 Exception as e:
-        print(f"[red]Error:[/red] {e}")
-        raise