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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sing-box-cli
-Version: 0.1.8
+Version: 0.1.9
 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
@@ -39,12 +39,14 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <3.15,>=3.11
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: plotext>=5.3.2
+Requires-Dist: plotext<6,>=5.3.2
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: psutil>=6.1.1
 Requires-Dist: pydantic>=2.10.6
-Requires-Dist: sing-box-bin>=1.12.12
+Requires-Dist: sing-box-bin<1.14,>=1.12.12
 Requires-Dist: typer>=0.15.1
+Provides-Extra: desktop
+Requires-Dist: grpcio>=1.60; extra == 'desktop'
 Description-Content-Type: text/markdown
 
 # Sing-Box CLI
@@ -167,6 +169,7 @@ Preview an update before applying it:
 ```bash
 sbc config update https://sub.example.com/alice.json --dry-run
 sbc config update https://sub.example.com/alice.json --restart
+sbc config update --restart   # no URL: the saved subscription
 ```
 
 `--dry-run` downloads and validates the configuration, then shows its diff without
@@ -187,6 +190,64 @@ sbc config get --subscription  # subscription URL
 
 `config show` and `config show-sub` remain available as hidden compatibility aliases.
 
+### Where it is kept
+
+sbc keeps its configuration the way the official sing-box desktop app does, in one
+place, whether the app is installed or not:
+
+```
+<config dir>/settings.db           profiles and the selected one
+<config dir>/profiles/<id>.json    the selected profile's sing-box configuration
+```
+
+The config directory is `~/.config/sing-box` on Linux. The selected profile is the
+configuration and its subscription URL is the subscription. A subscription token is
+stored inside that URL (`?token=...`), as the app stores it. It is still sent as a
+bearer token and never printed.
+
+Without the app, sbc creates this store itself with the app's schema, so the app
+takes it over unchanged if it is installed later. Files of older versions are
+imported the first time sbc runs anything but `config get` or a `--dry-run`, which
+create nothing:
+
+- `config.json` becomes the profile. It stays as a link to the profile, so a
+  service created before keeps running the same file. The previous file is kept as
+  `config.json.migrated`.
+- The URL and token of `app_config.json` become the subscription. The file is kept
+  as `app_config.json.migrated`.
+- A service created before follows the profile: `service restart` and
+  `config update --restart` point it at the profile when it points elsewhere.
+
+A configuration is written exactly as downloaded. The diff, and whether there is a
+change at all, ignore formatting.
+
+## sing-box desktop app (Linux)
+
+When the official sing-box desktop app is installed, sbc drives its daemon instead
+of a systemd service of its own, and the app's `settings.db` is the store. The app
+counts as installed when its `sing-box-daemon.service` exists.
+
+```bash
+uv tool install 'sing-box-cli[desktop]'   # grpcio is only needed for this
+sbc service restart --update              # sudo works too, it acts as the invoking user
+```
+
+| Command | With the desktop app |
+|---|---|
+| `service status/stop/restart/enable` | start, stop and reload the daemon's core. `restart` reloads in place, without a stop in between |
+| `service disable` | stops the core. Autostart stays with the app's `sing-box-daemon.service` |
+| `config update [URL]`, `--update` | refresh the profile selected in the app and record the refresh there. A new URL is saved to that profile once it downloads fine |
+| `--clear-cache`, `config clear_cache` | clear the daemon's working directory, like "clear data" in the app |
+| `stats/conns/proxy/logs` | unchanged, the default API address comes from the profile |
+| `run` | refused, the daemon runs the core |
+
+The core is started with the start options set in the app (OOM killer, memory
+limit, power report). The app's store is never created or repaired from here: if it
+cannot be read, or the daemon is stopped, sbc says so instead of working around it.
+
+- A local profile of the app has no subscription, `config update URL` is refused for it.
+- The app may show an old subscription URL until its profile list is reloaded.
+
 ## Serve private GitHub configurations
 
 Set `GH_TOKEN` (or `GITHUB_TOKEN`) with **Contents: read** access to your private

{sing_box_cli-0.1.8 → sing_box_cli-0.1.9}/README.md

@@ -118,6 +118,7 @@ Preview an update before applying it:
 ```bash
 sbc config update https://sub.example.com/alice.json --dry-run
 sbc config update https://sub.example.com/alice.json --restart
+sbc config update --restart   # no URL: the saved subscription
 ```
 
 `--dry-run` downloads and validates the configuration, then shows its diff without
@@ -138,6 +139,64 @@ sbc config get --subscription  # subscription URL
 
 `config show` and `config show-sub` remain available as hidden compatibility aliases.
 
+### Where it is kept
+
+sbc keeps its configuration the way the official sing-box desktop app does, in one
+place, whether the app is installed or not:
+
+```
+<config dir>/settings.db           profiles and the selected one
+<config dir>/profiles/<id>.json    the selected profile's sing-box configuration
+```
+
+The config directory is `~/.config/sing-box` on Linux. The selected profile is the
+configuration and its subscription URL is the subscription. A subscription token is
+stored inside that URL (`?token=...`), as the app stores it. It is still sent as a
+bearer token and never printed.
+
+Without the app, sbc creates this store itself with the app's schema, so the app
+takes it over unchanged if it is installed later. Files of older versions are
+imported the first time sbc runs anything but `config get` or a `--dry-run`, which
+create nothing:
+
+- `config.json` becomes the profile. It stays as a link to the profile, so a
+  service created before keeps running the same file. The previous file is kept as
+  `config.json.migrated`.
+- The URL and token of `app_config.json` become the subscription. The file is kept
+  as `app_config.json.migrated`.
+- A service created before follows the profile: `service restart` and
+  `config update --restart` point it at the profile when it points elsewhere.
+
+A configuration is written exactly as downloaded. The diff, and whether there is a
+change at all, ignore formatting.
+
+## sing-box desktop app (Linux)
+
+When the official sing-box desktop app is installed, sbc drives its daemon instead
+of a systemd service of its own, and the app's `settings.db` is the store. The app
+counts as installed when its `sing-box-daemon.service` exists.
+
+```bash
+uv tool install 'sing-box-cli[desktop]'   # grpcio is only needed for this
+sbc service restart --update              # sudo works too, it acts as the invoking user
+```
+
+| Command | With the desktop app |
+|---|---|
+| `service status/stop/restart/enable` | start, stop and reload the daemon's core. `restart` reloads in place, without a stop in between |
+| `service disable` | stops the core. Autostart stays with the app's `sing-box-daemon.service` |
+| `config update [URL]`, `--update` | refresh the profile selected in the app and record the refresh there. A new URL is saved to that profile once it downloads fine |
+| `--clear-cache`, `config clear_cache` | clear the daemon's working directory, like "clear data" in the app |
+| `stats/conns/proxy/logs` | unchanged, the default API address comes from the profile |
+| `run` | refused, the daemon runs the core |
+
+The core is started with the start options set in the app (OOM killer, memory
+limit, power report). The app's store is never created or repaired from here: if it
+cannot be read, or the daemon is stopped, sbc says so instead of working around it.
+
+- A local profile of the app has no subscription, `config update URL` is refused for it.
+- The app may show an old subscription URL until its profile list is reloaded.
+
 ## Serve private GitHub configurations
 
 Set `GH_TOKEN` (or `GITHUB_TOKEN`) with **Contents: read** access to your private

{sing_box_cli-0.1.8 → sing_box_cli-0.1.9}/pyproject.toml

@@ -23,11 +23,11 @@ maintainers = [{ name = "A.J.Zeller", email = "hello@atticux.me" }]
 dynamic = ["version"] # https://hatch.pypa.io/latest/config/metadata/#version
 dependencies = [
     "httpx>=0.28.1",
-    "plotext>=5.3.2",
+    "plotext>=5.3.2,<6",
     "prompt-toolkit>=3.0.50",
     "psutil>=6.1.1",
     "pydantic>=2.10.6",
-    "sing-box-bin>=1.12.12",
+    "sing-box-bin>=1.12.12,<1.14",
     "typer>=0.15.1",
 ]
 
@@ -47,6 +47,7 @@ environments = ["sys_platform == 'win32'", "sys_platform == 'linux'"]
 
 [project.optional-dependencies]
 # optional deps for package installation
+desktop = ["grpcio>=1.60"] # drive the sing-box desktop app's daemon
 
 [dependency-groups]
 dev = [
@@ -61,6 +62,7 @@ dev = [
     "scipy-stubs>=1.15.2.1",
     "coverage>=7.7.1",
     "pytest-sugar>=1.0.0",
+    "grpcio>=1.60", # fake desktop daemon in tests
 ]
 
 [tool.hatch.version]
@@ -121,6 +123,9 @@ ignore = [
 
 isort = { combine-as-imports = true, split-on-trailing-comma = false }
 
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["ARG001"] # pytest fixtures are used by being requested
+
 # Avoid trying to fix flake8-bugbear (`B`) violations.
 unfixable = ["B"]
 
@@ -215,7 +220,7 @@ topo_order = false
 sort_commits = "oldest"
 
 [tool.bumpversion]
-current_version        = "0.1.8"
+current_version        = "0.1.9"
 parse                  = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize              = ["{major}.{minor}.{patch}"]
 search                 = "{current_version}"

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

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

{sing_box_cli-0.1.8 → sing_box_cli-0.1.9}/src/sing_box_cli/config/__init__.py

@@ -8,10 +8,13 @@ from ..service import SharedContext, get_context_obj
 from ..service.manager import create_service
 from .config import get_config
 from .serve import serve
+from .utils import redact_url
 
 __all__ = ["config"]
 
-SubUrlArg = Annotated[str, typer.Argument(help="Subscription URL")]
+SubUrlArg = Annotated[
+    StrOrNone, typer.Argument(help="Subscription URL, the saved one if omitted")
+]
 TokenOption = Annotated[
     StrOrNone,
     typer.Option(
@@ -40,7 +43,7 @@ def config_callback(ctx: typer.Context) -> None:
 
 @config.command("update")
 def config_update(
-    url: SubUrlArg,
+    url: SubUrlArg = None,
     token: TokenOption = None,
     restart: RestartServiceOption = False,
     dry_run: DryRunOption = False,
@@ -51,10 +54,13 @@ def config_update(
         print("❌ Failed to update configuration.")
         raise typer.Exit(1)
     if restart and not dry_run:
-        ensure_root()
         service = create_service(cfg)
+        if service.requires_root:
+            ensure_root()
         # init service
-        if not service.check_service():
+        if service.check_service():
+            service.sync_service()
+        else:
             service.create_service()
             print("⌛ Service created successfully.")
         service.restart()
@@ -71,7 +77,7 @@ def config_get(
     cfg = get_context_obj(ctx).config
     if subscription:
         if cfg.sub_url:
-            print(f"🔗 Current subscription URL: {cfg.sub_url}")
+            print(f"🔗 Current subscription URL: {redact_url(cfg.sub_url)}")
         else:
             print("❌ No subscription URL found.")
     else:
@@ -94,4 +100,4 @@ def config_show(ctx: typer.Context) -> None:
 def config_clear_cache(ctx: typer.Context) -> None:
     """Clean cache database"""
     ctx_obj = get_context_obj(ctx)
-    ctx_obj.config.clear_cache()
+    ctx_obj.service.clear_cache()

{sing_box_cli-0.1.8 → sing_box_cli-0.1.9}/src/sing_box_cli/config/config.py

@@ -1,3 +1,4 @@
+import dataclasses
 import json
 import os
 import platform
@@ -11,7 +12,23 @@ from rich import print
 from sing_box_bin import get_bin_path
 
 from ..common import StrOrNone
-from .utils import request_get, show_diff_config, subscription_credentials
+from .store import (
+    Profile,
+    SettingsError,
+    active_profile,
+    init_store,
+    legacy_profile,
+    settings_path,
+    update_profile_record,
+)
+from .utils import (
+    atomic_write_text,
+    redact_url,
+    request_get,
+    show_diff_config,
+    subscription_credentials,
+    with_token,
+)
 
 
 class ClashApiConfig(BaseModel):
@@ -37,7 +54,7 @@ class ExperimentalConfig(BaseModel):
 
 
 class ConfigModel(BaseModel):
-    """Load and save configuration files."""
+    """Load configuration files."""
 
     @classmethod
     def load(cls, config_path: Path) -> Self:
@@ -52,10 +69,6 @@ class ConfigModel(BaseModel):
                 return cls()
         return cls()
 
-    def save(self, config_path: Path) -> None:
-        """Save configuration to file."""
-        config_path.write_text(self.model_dump_json(indent=2), encoding="utf-8")
-
 
 class SingBoxConfig(ConfigModel):
     """Model representing the sing-box configuration file structure."""
@@ -67,13 +80,6 @@ class SingBoxConfig(ConfigModel):
     model_config = ConfigDict(extra="allow")
 
 
-class SingBoxAppConfig(ConfigModel):
-    """Application-specific configuration for sing-box-cli."""
-
-    subscription_url: str = Field(default="", description="Subscription URL")
-    token: str = Field(default="", description="Authentication token")
-
-
 class ConfigHandler:
     def __init__(self) -> None:
         self._config_dir = (
@@ -81,39 +87,90 @@ class ConfigHandler:
             if self.is_windows
             else Path(f"~{self.user}/.config/sing-box").expanduser()
         )
-        # Configs file path
-        self._config_file = self._config_dir / "config.json"
-        self._app_config_file = self._config_dir / "app_config.json"
+        # Everything lives in the profile store (see config.store): the selected profile
+        # is the configuration and its subscription URL is the subscription. With the
+        # sing-box desktop app installed the store is the app's: it is only read, and an
+        # unusable one is reported, never worked around. Without the app the store is
+        # ours and init_directories() creates it.
+        self._desktop_app = self._detect_desktop_app()
+        self._profile: Profile | None = None
+        self._profile_error: str | None = None
+        # False while showing the files of an older version, before our store exists
+        self._store_ready = False
+        try:
+            self._profile = active_profile(self._config_dir)
+            self._store_ready = True
+        except SettingsError as e:
+            if self._desktop_app:
+                self._profile_error = str(e)
+            else:
+                self._profile = legacy_profile(self._config_dir)
+        self._load_config_file()
+        print(self)
+
+    def _detect_desktop_app(self) -> bool:
+        if self.is_windows:
+            return False
+        # Lazy import: the service package imports this module.
+        from ..service.desktop import desktop_app_installed
+
+        return desktop_app_installed()
 
-        # Load both configurations
+    def _load_config_file(self) -> None:
+        # never read or written without a profile, see _require_profile()
+        self._config_file = (
+            self._profile.path
+            if self._profile
+            else self._config_dir / "profiles" / "unavailable.json"
+        )
         self._sing_box_config = SingBoxConfig.load(self._config_file)
-        self._app_config = SingBoxAppConfig.load(self._app_config_file)
-        print(self)
+
+    def _require_profile(self) -> Profile:
+        """The selected profile, or report why there is none and exit."""
+        if self._profile is None:
+            print(f"❌ {self._profile_error}")
+            raise typer.Exit(1)
+        return self._profile
+
+    def _require_store(self) -> Profile:
+        """The selected profile of a store that may be written."""
+        profile = self._require_profile()
+        if not self._store_ready:
+            raise RuntimeError("The profile store is not initialized.")
+        return profile
+
+    @property
+    def external_config(self) -> bool:
+        """Whether the sing-box desktop app owns the configuration."""
+        return self._desktop_app
+
+    @property
+    def legacy_config(self) -> Path | None:
+        """config.json of an older version that is still a file of its own.
+
+        It normally becomes a link to the profile. Where linking is not allowed a
+        service created before still runs it, until it is pointed at the profile.
+        """
+        path = self._config_dir / "config.json"
+        if self._desktop_app or not self._store_ready:
+            return None
+        return path if path.is_file() and not path.is_symlink() else None
 
     def init_directories(self) -> bool:
-        """Initialize necessary directories and files for sing-box."""
-        try:
-            self.config_dir.mkdir(parents=True, exist_ok=True)
-
-            # Create/save default configs if needed
-            if not self._config_file.exists():
-                self._sing_box_config.save(self._config_file)
-                print(f"📁 Created config file: {self._config_file}")
-
-            if not self._app_config_file.exists():
-                self._app_config.save(self._app_config_file)
-                print(f"📁 Created application config file: {self._app_config_file}")
-
-            # For Linux/Unix systems only - set proper ownership
-            if not self.is_windows:
-                for file in [self._config_file, self._app_config_file]:
-                    if file.exists():
-                        shutil.chown(file, user=self.user, group=self.user)
-                shutil.chown(self.config_dir, user=self.user, group=self.user)
+        """Create the profile store if it is ours to create (no desktop app)."""
+        if self._desktop_app or self._store_ready:
             return True
-        except Exception as e:
+        created = not settings_path(self._config_dir).exists()
+        try:
+            self._profile = init_store(self._config_dir)
+        except SettingsError as e:
             print(f"❌ Failed to initialize directories: {e}")
             return False
+        self._store_ready = True
+        self._load_config_file()
+        if created:
+            print(f"📁 Created profile store: {settings_path(self._config_dir)}")
+        return True
 
     @property
     def user(self) -> str:
@@ -169,6 +226,7 @@ class ConfigHandler:
     @property
     def api_base_url(self) -> str:
         """Get the API base URL from the configuration file."""
+        self._require_profile()
         if (
             self._sing_box_config.experimental
             and self._sing_box_config.experimental.clash_api
@@ -199,6 +257,7 @@ class ConfigHandler:
     @property
     def config_file_content(self) -> str:
         """Get the content of the configuration file."""
+        self._require_profile()
         return (
             self._config_file.read_text(encoding="utf-8")
             if self._config_file.exists()
@@ -207,37 +266,66 @@ class ConfigHandler:
 
     @config_file_content.setter
     def config_file_content(self, value: str) -> None:
-        """Set the content of the configuration file and reload the model."""
-        try:
-            self._sing_box_config = SingBoxConfig.model_validate_json(value)
-            self._sing_box_config.save(self._config_file)
-        except Exception as e:
-            print(f"⚠️ Error parsing new configuration: {e}")
+        """Write the configuration as given and reload the model."""
+        self._require_store()
+        self._sing_box_config = SingBoxConfig.model_validate_json(value)
+        # the bytes as downloaded: the desktop app compares them on its own refresh
+        atomic_write_text(self._config_file, value)
         print("📁 Configuration updated successfully.")
 
+    @staticmethod
+    def _normalized(text: str, *, strict: bool = False) -> str:
+        """One layout to compare configurations in, so formatting is no difference."""
+        try:
+            return SingBoxConfig.model_validate_json(text).model_dump_json(indent=2)
+        except ValueError:
+            if strict:
+                raise
+            return text
+
+    @property
+    def _stored_sub_url(self) -> str:
+        """The subscription as stored: with its token, like the desktop app keeps it."""
+        return self._require_profile().remote_url or ""
+
+    def _subscription(self) -> tuple[str, str]:
+        stored = self._stored_sub_url
+        try:
+            url, token = subscription_credentials(stored)
+        except ValueError:
+            return redact_url(stored), ""
+        return url, token or ""
+
     @property
     def sub_url(self) -> str:
-        """Get the subscription URL from app config."""
-        return self._app_config.subscription_url
-
-    @sub_url.setter
-    def sub_url(self, value: str) -> None:
-        """Set the subscription URL in app config."""
-        self._app_config.subscription_url = value.strip()
-        self._app_config.save(self._app_config_file)
-        print("📁 Subscription updated successfully.")
+        """Get the subscription URL, without its token."""
+        return self._subscription()[0]
 
     @property
     def token_content(self) -> str:
-        """Get the token from app config."""
-        return self._app_config.token
+        """Get the subscription token, which is kept inside the stored URL."""
+        return self._subscription()[1]
+
+    def _save_subscription(self, stored: str) -> None:
+        profile = self._require_store()
+        update_profile_record(
+            self._config_dir,
+            profile.id,
+            remote_url=stored,
+            # a local profile of the app is not ours to turn into a remote one
+            make_remote=not self._desktop_app,
+        )
+        self._profile = dataclasses.replace(profile, remote_url=stored)
+        print("📁 Subscription updated successfully.")
 
-    @token_content.setter
-    def token_content(self, value: str) -> None:
-        """Set the token in app config."""
-        self._app_config.token = value.strip()
-        self._app_config.save(self._app_config_file)
-        print("🔑 Token added successfully.")
+    def _record_refresh(self) -> None:
+        """Show the refresh in the store, the app lists when a profile was updated."""
+        if not (self._profile and self._profile.remote_url):
+            return
+        try:
+            update_profile_record(self._config_dir, self._profile.id)
+        except SettingsError as e:
+            print(f"⚠️ Could not record the refresh: {e}")
 
     def update_config(
         self,
@@ -247,19 +335,25 @@ class ConfigHandler:
         dry_run: bool = False,
     ) -> bool:
         """Download and diff configuration, optionally without saving changes."""
+        profile = self._require_profile()  # exits when the desktop app has none
+        if self._desktop_app and profile.remote_url is None and sub_url is not None:
+            print(
+                "❌ The selected profile in the sing-box app is a local profile, "
+                "it has no subscription to set."
+            )
+            return False
         try:
-            if sub_url is None:
-                # load from file
-                if not self.sub_url:
-                    print("❌ No subscription URL found.")
-                    return False
-                sub_url = self.sub_url
-            sub_url, token = subscription_credentials(sub_url, token)
+            # the saved subscription unless another one is given
+            given = (self._stored_sub_url if sub_url is None else sub_url).strip()
+            if not given:
+                print("❌ No subscription URL found.")
+                return False
+            sub_url, token = subscription_credentials(given, token)
             if token is None:
-                # load from file
+                # the token of the saved subscription
                 token = self.token_content
             action = "Previewing" if dry_run else "Updating"
-            print(f"⌛ {action} configuration from {sub_url}")
+            print(f"⌛ {action} configuration from {redact_url(sub_url)}")
             response = request_get(sub_url, token)
             if response is None:
                 print("❌ Failed to get configuration.")
@@ -268,30 +362,29 @@ class ConfigHandler:
             new_config = response.text
 
             # make sure same order of keys to avoid showing wrong diff
-            new_config = self._sing_box_config.model_validate_json(
-                new_config
-            ).model_dump_json(indent=2)
-            if self.config_file_content == new_config:
+            current = self._normalized(self.config_file_content)
+            proposed = self._normalized(new_config, strict=True)
+            if current == proposed:
                 print("📄 Configuration is up to date.")
             else:
                 # show differences before saving
-                show_diff_config(self.config_file_content, new_config)
+                show_diff_config(current, proposed)
 
             if dry_run:
                 print("📄 Dry run: no configuration or subscription changes saved.")
                 return True
 
-            if not self.is_windows:
-                shutil.chown(self._config_file, user=self.user, group=self.user)
-
-            if self.config_file_content != new_config:
+            if current != proposed:
                 self.config_file_content = new_config
 
-            # Update subscription url file
-            if sub_url != self.sub_url:
-                self.sub_url = sub_url
-            if token != self.token_content:
-                self.token_content = token
+            # Save the subscription once it is known to work
+            if (sub_url, token) != (self.sub_url, self.token_content):
+                if given != sub_url:
+                    stored = given  # the token came inside the URL: keep it as given
+                else:
+                    stored = with_token(sub_url, token) if token else sub_url
+                self._save_subscription(stored)
+            self._record_refresh()
             return True
         except Exception as e:
             print(f"❌ Failed to update configuration: {e}")
@@ -313,6 +406,12 @@ class ConfigHandler:
 
     def __str__(self) -> str:
         """Return a string representation of the configuration."""
+        if self._desktop_app:
+            return "🔧 Using sing-box desktop daemon\n" + (
+                f"📄 Using configuration: {self._profile.path}"
+                if self._profile
+                else f"⚠️ {self._profile_error}"
+            )
         info = (
             f"🔧 Using binary: {self.bin_path}\n"
             f"📄 Using configuration: {self._config_file}\n"