ruyi 0.42.0a20251005__py3-none-any.whl → 0.42.0a20251013__py3-none-any.whl

ruyi/cli/config_cli.py

@@ -43,15 +43,23 @@ class ConfigGetCommand(
 
     @classmethod
     def main(cls, cfg: "config.GlobalConfig", args: argparse.Namespace) -> int:
+        from ..config.errors import InvalidConfigKeyError
         from ..config.schema import encode_value
+        from ..utils.toml import NoneValue
 
         key: str = args.key
 
-        val = cfg.get_by_key(key)
-        if val is None:
+        try:
+            val = cfg.get_by_key(key)
+        except InvalidConfigKeyError:
             return 1
 
-        cfg.logger.stdout(encode_value(val))
+        try:
+            encoded_val = encode_value(val)
+        except NoneValue:
+            return 1
+
+        cfg.logger.stdout(encoded_val)
         return 0
 
 
@@ -80,6 +88,7 @@ class ConfigSetCommand(
     @classmethod
     def main(cls, cfg: "config.GlobalConfig", args: argparse.Namespace) -> int:
         from ..config.editor import ConfigEditor
+        from ..config.errors import ProtectedGlobalConfigError
         from ..config.schema import decode_value
 
         key: str = args.key
@@ -87,7 +96,14 @@ class ConfigSetCommand(
 
         pyval = decode_value(key, val)
         with ConfigEditor.work_on_user_local_config(cfg) as ed:
-            ed.set_value(key, pyval)
+            try:
+                ed.set_value(key, pyval)
+            except ProtectedGlobalConfigError:
+                cfg.logger.F(
+                    f"the config [yellow]{key}[/] is protected and not meant to be overridden by users",
+                )
+                return 2
+
             ed.stage()
 
         return 0

ruyi/cli/main.py

@@ -27,15 +27,20 @@ def should_prompt_for_renaming(argv0: str) -> bool:
 
 def main(gm: GlobalModeProvider, gc: GlobalConfig, argv: list[str]) -> int:
     logger = gc.logger
-    oobe = OOBE(gc)
 
-    if tm := gc.telemetry:
-        tm.check_first_run_status()
-        tm.init_installation(False)
-        atexit.register(tm.flush)
-        oobe.handlers.append(tm.oobe_prompt)
+    # do not init telemetry or OOBE on CLI auto-completion invocations, because
+    # our output isn't meant for humans in that case, and a "real" invocation
+    # will likely follow shortly after
+    if not gm.is_cli_autocomplete:
+        oobe = OOBE(gc)
+
+        if tm := gc.telemetry:
+            tm.check_first_run_status()
+            tm.init_installation(False)
+            atexit.register(tm.flush)
+            oobe.handlers.append(tm.oobe_prompt)
 
-    oobe.maybe_prompt()
+        oobe.maybe_prompt()
 
     if not is_called_as_ruyi(gm.argv0):
         if should_prompt_for_renaming(gm.argv0):

ruyi/config/__init__.py

@@ -15,8 +15,10 @@ if TYPE_CHECKING:
     from ..ruyipkg.state import RuyipkgGlobalStateStore
     from ..telemetry.provider import TelemetryProvider
     from ..utils.global_mode import ProvidesGlobalMode
+    from ..utils.xdg_basedir import XDGPathEntry
     from .news import NewsReadStatusStore
 
+from . import errors
 from . import schema
 
 
@@ -33,6 +35,7 @@ else:
 DEFAULT_APP_NAME: Final = "ruyi"
 DEFAULT_REPO_URL: Final = "https://github.com/ruyisdk/packages-index.git"
 DEFAULT_REPO_BRANCH: Final = "main"
+DEFAULT_TELEMETRY_MODE: Final = "local"  # "off", "local", "on"
 
 
 def get_host_path_fragment_for_binary_install_dir(canonicalized_host: str) -> str:
@@ -101,12 +104,21 @@ class GlobalConfig:
         self._telemetry_upload_consent: datetime.datetime | None = None
         self._telemetry_pm_telemetry_url: str | None = None
 
-    def apply_config(self, config_data: GlobalConfigRootType) -> None:
+    def _apply_config(
+        self,
+        config_data: GlobalConfigRootType,
+        *,
+        is_global_scope: bool,
+    ) -> None:
         if ins_cfg := config_data.get(schema.SECTION_INSTALLATION):
-            self.is_installation_externally_managed = ins_cfg.get(
-                schema.KEY_INSTALLATION_EXTERNALLY_MANAGED,
-                False,
-            )
+            iem = ins_cfg.get(schema.KEY_INSTALLATION_EXTERNALLY_MANAGED, None)
+            if iem is not None and not is_global_scope:
+                iem_cfg_key = f"{schema.SECTION_INSTALLATION}.{schema.KEY_INSTALLATION_EXTERNALLY_MANAGED}"
+                self.logger.W(
+                    f"the config key [yellow]{iem_cfg_key}[/] cannot be set from user config; ignoring",
+                )
+            else:
+                self.is_installation_externally_managed = bool(iem)
 
         if pkgs_cfg := config_data.get(schema.SECTION_PACKAGES):
             self.include_prereleases = pkgs_cfg.get(
@@ -137,61 +149,90 @@ class GlobalConfig:
                 if isinstance(consent, datetime.datetime):
                     self._telemetry_upload_consent = consent
 
-    def get_by_key(self, key: str | Sequence[str]) -> object | None:
+    def get_by_key(self, key: str | Sequence[str]) -> object:
+        parsed_key = schema.parse_config_key(key)
+        section, sel = parsed_key[0], parsed_key[1:]
+        attr_name = self._get_attr_name_by_key(section, sel)
+        if attr_name is None:
+            raise errors.InvalidConfigKeyError(key)
+        return getattr(self, attr_name)
+
+    def set_by_key(self, key: str | Sequence[str], value: object) -> None:
+        # We don't have to check for global-only keys here because this
+        # method is only used for programmatic changes to the in-memory
+        # config, not for loading from config files.
         parsed_key = schema.parse_config_key(key)
         section, sel = parsed_key[0], parsed_key[1:]
+        attr_name = self._get_attr_name_by_key(section, sel)
+        if attr_name is None:
+            raise errors.InvalidConfigKeyError(key)
+
+        expected_type = schema.get_expected_type_for_config_key(key)
+        if not isinstance(value, expected_type):
+            raise TypeError(
+                f"expected type {expected_type.__name__} for config key '{key}', got {type(value).__name__}"
+            )
+
+        setattr(self, attr_name, value)
+
+    @classmethod
+    def _get_attr_name_by_key(cls, section: str, sel: list[str]) -> str | None:
         if section == schema.SECTION_INSTALLATION:
-            return self._get_section_installation(sel)
+            return cls._get_section_installation(sel)
         elif section == schema.SECTION_PACKAGES:
-            return self._get_section_packages(sel)
+            return cls._get_section_packages(sel)
         elif section == schema.SECTION_REPO:
-            return self._get_section_repo(sel)
+            return cls._get_section_repo(sel)
         elif section == schema.SECTION_TELEMETRY:
-            return self._get_section_telemetry(sel)
+            return cls._get_section_telemetry(sel)
         else:
             return None
 
-    def _get_section_installation(self, selector: list[str]) -> object | None:
+    @classmethod
+    def _get_section_installation(cls, selector: list[str]) -> str | None:
         if len(selector) != 1:
             return None
         leaf = selector[0]
         if leaf == schema.KEY_INSTALLATION_EXTERNALLY_MANAGED:
-            return self.is_installation_externally_managed
+            return "is_installation_externally_managed"
         else:
             return None
 
-    def _get_section_packages(self, selector: list[str]) -> object | None:
+    @classmethod
+    def _get_section_packages(cls, selector: list[str]) -> str | None:
         if len(selector) != 1:
             return None
         leaf = selector[0]
         if leaf == schema.KEY_PACKAGES_PRERELEASES:
-            return self.include_prereleases
+            return "include_prereleases"
         else:
             return None
 
-    def _get_section_repo(self, selector: list[str]) -> object | None:
+    @classmethod
+    def _get_section_repo(cls, selector: list[str]) -> str | None:
         if len(selector) != 1:
             return None
         leaf = selector[0]
         if leaf == schema.KEY_REPO_BRANCH:
-            return self.override_repo_branch
+            return "override_repo_branch"
         elif leaf == schema.KEY_REPO_LOCAL:
-            return self.override_repo_dir
+            return "override_repo_dir"
         elif leaf == schema.KEY_REPO_REMOTE:
-            return self.override_repo_url
+            return "override_repo_url"
         else:
             return None
 
-    def _get_section_telemetry(self, selector: list[str]) -> object | None:
+    @classmethod
+    def _get_section_telemetry(cls, selector: list[str]) -> str | None:
         if len(selector) != 1:
             return None
         leaf = selector[0]
         if leaf == schema.KEY_TELEMETRY_MODE:
-            return self.telemetry_mode
+            return "telemetry_mode"
         elif leaf == schema.KEY_TELEMETRY_PM_TELEMETRY_URL:
-            return self.override_pm_telemetry_url
+            return "override_pm_telemetry_url"
         elif leaf == schema.KEY_TELEMETRY_UPLOAD_CONSENT:
-            return self.telemetry_upload_consent_time
+            return "telemetry_upload_consent_time"
         else:
             return None
 
@@ -262,26 +303,63 @@ class GlobalConfig:
     def telemetry_root(self) -> os.PathLike[Any]:
         return pathlib.Path(self.ensure_state_dir()) / "telemetry"
 
-    @cached_property
+    @property
     def telemetry(self) -> "TelemetryProvider | None":
+        return None if self.telemetry_mode == "off" else self._telemetry_provider
+
+    @cached_property
+    def _telemetry_provider(self) -> "TelemetryProvider | None":
+        """Do not access directly; use the ``telemetry`` property instead."""
+
         from ..telemetry.provider import TelemetryProvider
 
         return None if self.telemetry_mode == "off" else TelemetryProvider(self)
 
     @property
     def telemetry_mode(self) -> str:
-        return self._telemetry_mode or "on"
+        return self._telemetry_mode or DEFAULT_TELEMETRY_MODE
+
+    @telemetry_mode.setter
+    def telemetry_mode(self, mode: str) -> None:
+        if mode not in ("off", "local", "on"):
+            raise ValueError("telemetry mode must be one of: off, local, on")
+        if self._gm.is_telemetry_optout and mode != "off":
+            raise ValueError(
+                "cannot enable telemetry when the environment variable opt-out is set"
+            )
+        self._telemetry_mode = mode
 
     @property
     def telemetry_upload_consent_time(self) -> datetime.datetime | None:
         return self._telemetry_upload_consent
 
+    @telemetry_upload_consent_time.setter
+    def telemetry_upload_consent_time(self, t: datetime.datetime | None) -> None:
+        self._telemetry_upload_consent = t
+
     @property
     def override_pm_telemetry_url(self) -> str | None:
         return self._telemetry_pm_telemetry_url
 
+    @override_pm_telemetry_url.setter
+    def override_pm_telemetry_url(self, url: str | None) -> None:
+        self._telemetry_pm_telemetry_url = url
+
+    @cached_property
+    def default_repo_dir(self) -> str:
+        return os.path.join(self.cache_root, "packages-index")
+
     def get_repo_dir(self) -> str:
-        return self.override_repo_dir or os.path.join(self.cache_root, "packages-index")
+        return self.override_repo_dir or self.default_repo_dir
+
+    @cached_property
+    def have_overridden_repo_dir(self) -> bool:
+        if not self.override_repo_dir:
+            return False
+        override_path = pathlib.Path(self.override_repo_dir)
+        default_path = pathlib.Path(self.default_repo_dir)
+        # we don't use samefile() here because the path may not exist
+        return override_path.resolve() != default_path.resolve()
 
     def get_repo_url(self) -> str:
         return self.override_repo_url or DEFAULT_REPO_URL
@@ -312,7 +390,7 @@ class GlobalConfig:
     def lookup_binary_install_dir(self, host: str, slug: str) -> PathLike[Any] | None:
         host_path = get_host_path_fragment_for_binary_install_dir(host)
         for data_dir in self._dirs.app_data_dirs:
-            p = data_dir / "binaries" / host_path / slug
+            p = data_dir.path / "binaries" / host_path / slug
             if p.exists():
                 return p
         return None
@@ -347,30 +425,40 @@ class GlobalConfig:
         p.mkdir(parents=True, exist_ok=True)
         return p
 
-    def iter_preset_configs(self) -> Iterable[os.PathLike[Any]]:
+    def iter_preset_configs(self) -> "Iterable[XDGPathEntry]":
         """
         Yields possible Ruyi config files in all preset config path locations,
         sorted by precedence from lowest to highest (so that each file may be
         simply applied consecutively).
         """
 
+        from ..utils.xdg_basedir import XDGPathEntry
+
         for path in PRESET_GLOBAL_CONFIG_LOCATIONS:
-            yield pathlib.Path(path)
+            yield XDGPathEntry(pathlib.Path(path), True)
 
-    def iter_xdg_configs(self) -> Iterable[os.PathLike[Any]]:
+    def iter_xdg_configs(self) -> "Iterable[XDGPathEntry]":
         """
         Yields possible Ruyi config files in all XDG config paths, sorted by precedence
         from lowest to highest (so that each file may be simply applied consecutively).
         """
 
-        for config_dir in reversed(list(self._dirs.app_config_dirs)):
-            yield config_dir / "config.toml"
+        from ..utils.xdg_basedir import XDGPathEntry
+
+        entries = list(self._dirs.app_config_dirs)
+        for e in reversed(entries):
+            yield XDGPathEntry(e.path / "config.toml", e.is_global)
 
     @property
     def local_user_config_file(self) -> pathlib.Path:
         return self._dirs.app_config / "config.toml"
 
-    def try_apply_config_file(self, path: os.PathLike[Any]) -> None:
+    def _try_apply_config_file(
+        self,
+        path: os.PathLike[Any],
+        *,
+        is_global_scope: bool,
+    ) -> None:
         import tomlkit
 
         try:
@@ -379,23 +467,24 @@ class GlobalConfig:
         except FileNotFoundError:
             return
 
-        self.logger.D(f"applying config: {data}")
-        self.apply_config(data)
+        self.logger.D(f"applying config: {data}, is_global_scope={is_global_scope}")
+        self._apply_config(data, is_global_scope=is_global_scope)
 
     @classmethod
     def load_from_config(cls, gm: "ProvidesGlobalMode", logger: "RuyiLogger") -> "Self":
         obj = cls(gm, logger)
 
-        for config_path in obj.iter_preset_configs():
+        for config_path, is_global in obj.iter_preset_configs():
             obj.logger.D(f"trying config file from preset location: {config_path}")
-            obj.try_apply_config_file(config_path)
+            obj._try_apply_config_file(config_path, is_global_scope=is_global)
 
-        for config_path in obj.iter_xdg_configs():
+        for config_path, is_global in obj.iter_xdg_configs():
             obj.logger.D(f"trying config file from XDG path: {config_path}")
-            obj.try_apply_config_file(config_path)
+            obj._try_apply_config_file(config_path, is_global_scope=is_global)
 
         # let environment variable take precedence
         if gm.is_telemetry_optout:
             obj._telemetry_mode = "off"
+            obj._telemetry_upload_consent = None
 
         return obj

ruyi/config/editor.py

@@ -1,6 +1,6 @@
 from contextlib import AbstractContextManager
 import pathlib
-from typing import Sequence, TYPE_CHECKING, cast
+from typing import Final, Sequence, TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -9,13 +9,35 @@ if TYPE_CHECKING:
 import tomlkit
 from tomlkit.items import Table
 
-from .errors import MalformedConfigFileError
-from .schema import ensure_valid_config_kv, parse_config_key, validate_section
+from .errors import MalformedConfigFileError, ProtectedGlobalConfigError
+from .schema import (
+    SECTION_INSTALLATION,
+    KEY_INSTALLATION_EXTERNALLY_MANAGED,
+    ensure_valid_config_kv,
+    parse_config_key,
+    validate_section,
+)
 
 if TYPE_CHECKING:
     from . import GlobalConfig
 
 
+GLOBAL_ONLY_CONFIG_KEYS: Final[set[tuple[str, str]]] = {
+    (SECTION_INSTALLATION, KEY_INSTALLATION_EXTERNALLY_MANAGED),
+}
+"""Settings that can only be set in global-scope config files.
+
+Changes should be reflected in ``GlobalConfig._apply_config`` too."""
+
+
+def _is_config_key_global_only(key: str | Sequence[str]) -> bool:
+    parsed_key = parse_config_key(key)
+    if len(parsed_key) != 2:
+        return False
+    section, leaf = parsed_key
+    return (section, leaf) in GLOBAL_ONLY_CONFIG_KEYS
+
+
 class ConfigEditor(AbstractContextManager["ConfigEditor"]):
     def __init__(self, path: pathlib.Path) -> None:
         self._path = path
@@ -63,6 +85,15 @@ class ConfigEditor(AbstractContextManager["ConfigEditor"]):
         parsed_key = parse_config_key(key)
         ensure_valid_config_kv(parsed_key, check_val=True, val=val)
 
+        # Gate protected settings: user-local config is not allowed to override
+        # global-only settings.
+        if _is_config_key_global_only(parsed_key):
+            # This mechanism is only meant for modifying user-local configs,
+            # because global configs are assumed to be maintained by packagers
+            # and/or sysadmins, who are expected to write the config file by
+            # hand.
+            raise ProtectedGlobalConfigError(parsed_key)
+
         section, sel = parsed_key[0], parsed_key[1:]
         if section in self._stage:
             existing_section = self._stage[section]

ruyi/config/errors.py

@@ -74,3 +74,15 @@ class MalformedConfigFileError(Exception):
 
     def __repr__(self) -> str:
         return f"MalformedConfigFileError({self._path:!r})"
+
+
+class ProtectedGlobalConfigError(Exception):
+    def __init__(self, key: str | Sequence[str]) -> None:
+        super().__init__()
+        self._key = key
+
+    def __str__(self) -> str:
+        return f"attempt to modify protected global config key: {self._key}"
+
+    def __repr__(self) -> str:
+        return f"ProtectedGlobalConfigError({self._key!r})"

ruyi/config/schema.py

@@ -145,6 +145,11 @@ def encode_value(v: object) -> str:
     """Encodes the given config value into a string representation suitable for
     display or storage into TOML config files."""
 
+    if v is None:
+        from ..utils.toml import NoneValue
+
+        raise NoneValue()
+
     if isinstance(v, bool):
         return "true" if v else "false"
     elif isinstance(v, int):

ruyi/device/provision.py

@@ -276,7 +276,7 @@ We are about to:
                 """
 Some flashing steps require the use of fastboot, in which case you should
 ensure the target device is showing up in [yellow]fastboot devices[/] output.
-Please confirm it yourself before the flashing begins.
+Please [bold red]confirm it yourself before continuing[/].
 """
             )
             if not user_input.ask_for_yesno_confirmation(

ruyi/ruyipkg/distfile.py

@@ -1,10 +1,10 @@
 from functools import cached_property
 import os
-from typing import Final
+from typing import Any, Final
 
 from ..log import RuyiLogger
 from .checksum import Checksummer
-from .fetch import BaseFetcher
+from .fetcher import BaseFetcher
 from .pkg_manifest import DistfileDecl
 from .repo import MetadataRepo
 from .unpack import do_unpack, do_unpack_or_symlink
@@ -187,7 +187,11 @@ class Distfile:
                 f"failed to fetch distfile: {self.dest} failed integrity checks"
             )
 
-    def unpack(self, root: str | None, logger: RuyiLogger) -> None:
+    def unpack(
+        self,
+        root: str | os.PathLike[Any] | None,
+        logger: RuyiLogger,
+    ) -> None:
         return do_unpack(
             logger,
             self.dest,
@@ -197,7 +201,11 @@ class Distfile:
             prefixes_to_unpack=self.prefixes_to_unpack,
         )
 
-    def unpack_or_symlink(self, root: str | None, logger: RuyiLogger) -> None:
+    def unpack_or_symlink(
+        self,
+        root: str | os.PathLike[Any] | None,
+        logger: RuyiLogger,
+    ) -> None:
         return do_unpack_or_symlink(
             logger,
             self.dest,

ruyi/ruyipkg/install.py

@@ -1,7 +1,8 @@
-import os.path
+import os
 import pathlib
 import shutil
 import tempfile
+from typing import Any
 
 from ruyi.ruyipkg.state import BoundInstallationStateStore
 
@@ -29,6 +30,9 @@ def do_extract_atoms(
     atom_strs: set[str],
     *,
     canonicalized_host: str | RuyiHost,
+    dest_dir: os.PathLike[Any] | None,  # None for CWD
+    extract_without_subdir: bool,
+    fetch_only: bool,
 ) -> int:
     logger = cfg.logger
     logger.D(f"about to extract for host {canonicalized_host}: {atom_strs}")
@@ -41,7 +45,6 @@ def do_extract_atoms(
         if pm is None:
             logger.F(f"atom {a_str} matches no package in the repository")
             return 1
-        pkg_name = pm.name_for_installation
 
         sv = pm.service_level
         if sv.has_known_issues:
@@ -49,43 +52,92 @@ def do_extract_atoms(
             for s in sv.render_known_issues(pm.repo.messages, cfg.lang_code):
                 logger.I(s)
 
-        bm = pm.binary_metadata
-        sm = pm.source_metadata
-        if bm is None and sm is None:
-            logger.F(f"don't know how to extract package [green]{pkg_name}[/]")
-            return 2
+        ret = _do_extract_pkg(
+            cfg,
+            pm,
+            canonicalized_host=canonicalized_host,
+            fetch_only=fetch_only,
+            dest_dir=dest_dir,
+            extract_without_subdir=extract_without_subdir,
+        )
+        if ret != 0:
+            return ret
 
-        if bm is not None and sm is not None:
-            logger.F(
-                f"cannot handle package [green]{pkg_name}[/]: package is both binary and source"
-            )
-            return 2
+    return 0
 
-        distfiles_for_host: list[str] | None = None
-        if bm is not None:
-            distfiles_for_host = bm.get_distfile_names_for_host(canonicalized_host)
-        elif sm is not None:
-            distfiles_for_host = sm.get_distfile_names_for_host(canonicalized_host)
 
-        if not distfiles_for_host:
-            logger.F(
-                f"package [green]{pkg_name}[/] declares no distfile for host {canonicalized_host}"
-            )
-            return 2
+def _do_extract_pkg(
+    cfg: GlobalConfig,
+    pm: BoundPackageManifest,
+    *,
+    canonicalized_host: str | RuyiHost,
+    dest_dir: os.PathLike[Any] | None,  # None for CWD
+    extract_without_subdir: bool,
+    fetch_only: bool,
+) -> int:
+    logger = cfg.logger
 
-        dfs = pm.distfiles
+    pkg_name = pm.name_for_installation
 
-        for df_name in distfiles_for_host:
-            df_decl = dfs[df_name]
-            ensure_unpack_cmd_for_method(logger, df_decl.unpack_method)
-            df = Distfile(df_decl, mr)
-            df.ensure(logger)
+    if not extract_without_subdir:
+        # extract into a subdirectory named <pkg_name>-<version>
+        subdir_name = pm.name_for_installation
+        if dest_dir is None:
+            dest_dir = pathlib.Path(subdir_name)
+        else:
+            dest_dir = pathlib.Path(dest_dir) / subdir_name
 
-            logger.I(f"extracting [green]{df_name}[/] for package [green]{pkg_name}[/]")
-            # unpack into CWD
-            df.unpack(None, logger)
+    logger.D(f"about to extract {pm} to {dest_dir}")
 
-        logger.I(f"package [green]{pkg_name}[/] extracted to current working directory")
+    # Make sure destination directory exists
+    if dest_dir is not None:
+        dest_dir = pathlib.Path(dest_dir)
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+    bm = pm.binary_metadata
+    sm = pm.source_metadata
+    if bm is None and sm is None:
+        logger.F(f"don't know how to extract package [green]{pkg_name}[/]")
+        return 2
+
+    if bm is not None and sm is not None:
+        logger.F(
+            f"cannot handle package [green]{pkg_name}[/]: package is both binary and source"
+        )
+        return 2
+
+    distfiles_for_host: list[str] | None = None
+    if bm is not None:
+        distfiles_for_host = bm.get_distfile_names_for_host(canonicalized_host)
+    elif sm is not None:
+        distfiles_for_host = sm.get_distfile_names_for_host(canonicalized_host)
+
+    if not distfiles_for_host:
+        logger.F(
+            f"package [green]{pkg_name}[/] declares no distfile for host {canonicalized_host}"
+        )
+        return 2
+
+    dfs = pm.distfiles
+
+    for df_name in distfiles_for_host:
+        df_decl = dfs[df_name]
+        ensure_unpack_cmd_for_method(logger, df_decl.unpack_method)
+        df = Distfile(df_decl, pm.repo)
+        df.ensure(logger)
+
+        if fetch_only:
+            logger.D("skipping extraction because [yellow]--fetch-only[/] is given")
+            continue
+
+        logger.I(f"extracting [green]{df_name}[/] for package [green]{pkg_name}[/]")
+        # unpack into destination
+        df.unpack(dest_dir, logger)
+
+    if not fetch_only:
+        logger.I(
+            f"package [green]{pkg_name}[/] has been extracted to {dest_dir}",
+        )
 
     return 0
 
@@ -147,6 +199,21 @@ def do_install_atoms(
                 return ret
             continue
 
+        # the user may be trying to fetch a source-only package with `ruyi install --fetch-only`,
+        # so try that too for better UX
+        if fetch_only and pm.source_metadata is not None:
+            ret = _do_extract_pkg(
+                config,
+                pm,
+                canonicalized_host=canonicalized_host,
+                dest_dir=None,  # unused in this case
+                extract_without_subdir=False,  # unused in this case
+                fetch_only=fetch_only,
+            )
+            if ret != 0:
+                return ret
+            continue
+
         logger.F(f"don't know how to handle non-binary package [green]{pkg_name}[/]")
         return 2
 

ruyi/ruyipkg/install_cli.py

@@ -1,4 +1,5 @@
 import argparse
+import pathlib
 from typing import TYPE_CHECKING
 
 from ..cli.cmd import RootCommand
@@ -26,6 +27,25 @@ class ExtractCommand(
         if gc.is_cli_autocomplete:
             a.completer = package_completer_builder(gc)
 
+        p.add_argument(
+            "-d",
+            "--dest-dir",
+            type=str,
+            metavar="DESTDIR",
+            default=".",
+            help="Destination directory to extract to (default: current directory)",
+        )
+        p.add_argument(
+            "--extract-without-subdir",
+            action="store_true",
+            help="Extract files directly into DESTDIR instead of package-named subdirectories",
+        )
+        p.add_argument(
+            "-f",
+            "--fetch-only",
+            action="store_true",
+            help="Fetch distribution files only without installing",
+        )
         p.add_argument(
             "--host",
             type=str,
@@ -38,14 +58,22 @@ class ExtractCommand(
         from .host import canonicalize_host_str
         from .install import do_extract_atoms
 
-        host: str = args.host
         atom_strs: set[str] = set(args.atom)
+        dest_dir_arg: str = args.dest_dir
+        extract_without_subdir: bool = args.extract_without_subdir
+        host: str = args.host
+        fetch_only: bool = args.fetch_only
+
+        dest_dir = None if dest_dir_arg == "." else pathlib.Path(dest_dir_arg)
 
         return do_extract_atoms(
             cfg,
             cfg.repo,
             atom_strs,
             canonicalized_host=canonicalize_host_str(host),
+            dest_dir=dest_dir,
+            extract_without_subdir=extract_without_subdir,
+            fetch_only=fetch_only,
         )
 
 

ruyi/ruyipkg/repo.py

@@ -315,7 +315,7 @@ class MetadataRepo(ProvidesPackageManifests):
 
         # only manage the repo settings on the user's behalf if the user
         # has not overridden the repo directory themselves
-        allow_auto_management = self._gc.override_repo_dir is None
+        allow_auto_management = not self._gc.have_overridden_repo_dir
 
         pull_ff_or_die(
             self.logger,

ruyi/ruyipkg/unpack.py

@@ -2,7 +2,7 @@ import mmap
 import os
 import shutil
 import subprocess
-from typing import BinaryIO, NoReturn, Protocol
+from typing import Any, BinaryIO, NoReturn, Protocol
 
 from ..log import RuyiLogger
 from ..utils import ar, prereqs
@@ -20,7 +20,7 @@ class SupportsRead(Protocol):
 def do_unpack(
     logger: RuyiLogger,
     filename: str,
-    dest: str | None,
+    dest: str | os.PathLike[Any] | None,
     strip_components: int,
     unpack_method: UnpackMethod,
     stream: BinaryIO | SupportsRead | None = None,
@@ -77,7 +77,7 @@ def do_unpack(
 def do_unpack_or_symlink(
     logger: RuyiLogger,
     filename: str,
-    dest: str | None,
+    dest: str | os.PathLike[Any] | None,
     strip_components: int,
     unpack_method: UnpackMethod,
     stream: BinaryIO | SupportsRead | None = None,
@@ -100,7 +100,7 @@ def do_unpack_or_symlink(
 
 def _do_copy_raw(
     src_path: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     src_filename = os.path.basename(src_path)
     if destdir is None:
@@ -114,7 +114,7 @@ def _do_copy_raw(
 
 def do_symlink(
     src_path: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     src_filename = os.path.basename(src_path)
     if destdir is None:
@@ -132,7 +132,7 @@ def do_symlink(
 def _do_unpack_tar(
     logger: RuyiLogger,
     filename: str,
-    dest: str | None,
+    dest: str | os.PathLike[Any] | None,
     strip_components: int,
     unpack_method: UnpackMethod,
     stream: SupportsRead | None,
@@ -164,8 +164,6 @@ def _do_unpack_tar(
         stdin = subprocess.PIPE
 
     argv.extend(("-f", filename, f"--strip-components={strip_components}"))
-    if dest is not None:
-        argv.extend(("-C", dest))
     if prefixes_to_unpack:
         if any(p.startswith("-") for p in prefixes_to_unpack):
             raise ValueError(
@@ -200,11 +198,11 @@ def _do_unpack_tar(
 def _do_unpack_zip(
     logger: RuyiLogger,
     filename: str,
-    dest: str | None,
+    dest: str | os.PathLike[Any] | None,
 ) -> None:
     argv = ["unzip", filename]
     if dest is not None:
-        argv.extend(("-d", dest))
+        argv.extend(("-d", str(dest)))
     logger.D(f"about to call unzip: argv={argv}")
     retcode = subprocess.call(argv, cwd=dest)
     if retcode != 0:
@@ -214,7 +212,7 @@ def _do_unpack_zip(
 def _do_unpack_bare_gz(
     logger: RuyiLogger,
     filename: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     # the suffix may not be ".gz" so do this generically
     dest_filename = os.path.splitext(os.path.basename(filename))[0]
@@ -235,7 +233,7 @@ def _do_unpack_bare_gz(
 def _do_unpack_bare_bzip2(
     logger: RuyiLogger,
     filename: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     # the suffix may not be ".bz2" so do this generically
     dest_filename = os.path.splitext(os.path.basename(filename))[0]
@@ -256,7 +254,7 @@ def _do_unpack_bare_bzip2(
 def _do_unpack_bare_lz4(
     logger: RuyiLogger,
     filename: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     # the suffix may not be ".lz4" so do this generically
     dest_filename = os.path.splitext(os.path.basename(filename))[0]
@@ -271,7 +269,7 @@ def _do_unpack_bare_lz4(
 def _do_unpack_bare_xz(
     logger: RuyiLogger,
     filename: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     # the suffix may not be ".xz" so do this generically
     dest_filename = os.path.splitext(os.path.basename(filename))[0]
@@ -292,7 +290,7 @@ def _do_unpack_bare_xz(
 def _do_unpack_bare_zstd(
     logger: RuyiLogger,
     filename: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     # the suffix may not be ".zst" so do this generically
     dest_filename = os.path.splitext(os.path.basename(filename))[0]
@@ -307,7 +305,7 @@ def _do_unpack_bare_zstd(
 def _do_unpack_deb(
     logger: RuyiLogger,
     filename: str,
-    destdir: str | None,
+    destdir: str | os.PathLike[Any] | None,
 ) -> None:
     with ar.ArpyArchiveWrapper(filename) as a:
         for f in a.infolist():

ruyi/telemetry/provider.py

@@ -18,19 +18,23 @@ if TYPE_CHECKING:
 
 FALLBACK_PM_TELEMETRY_ENDPOINT = "https://api.ruyisdk.cn/telemetry/pm/"
 
-TELEMETRY_INITIAL_UPLOAD_PROMPT = """
-By default, the RuyiSDK team collects anonymous usage data to help us improve
-the product. No personal information or detail about your project is ever
-collected. The data will be uploaded to RuyiSDK team-managed servers located
-in the Chinese mainland if you agree to the uploading. You can change this
-setting at any time by running [yellow]ruyi telemetry consent[/] or
-[yellow]ruyi telemetry optout[/].
-
-We would like to ask if you agree to have basic information about this [yellow]ruyi[/]
-installation uploaded, right now, for one time. This will allow the RuyiSDK team
-to have more precise knowledge about the product's adoption. Thank you for
-your support!
+TELEMETRY_CONSENT_AND_UPLOAD_DESC = """
+RuyiSDK collects anonymized usage data locally to help us improve the product.
+
+[green]By default, nothing leaves your machine[/], and you can also turn off usage data
+collection completely. Only with your explicit permission can [yellow]ruyi[/] upload
+collected telemetry, periodically to RuyiSDK team-managed servers located in
+the Chinese mainland. You can change this setting at any time by running
+[yellow]ruyi telemetry consent[/], [yellow]ruyi telemetry local[/], or [yellow]ruyi telemetry optout[/].
+
+If you enable uploads now, we'll also send a one-time report from this [yellow]ruyi[/]
+installation so the RuyiSDK team can better understand adoption. Thank you for
+helping us build a better experience!
 """
+TELEMETRY_CONSENT_AND_UPLOAD_PROMPT = (
+    "Enable telemetry uploads and send a one-time report now?"
+)
+TELEMETRY_OPTOUT_PROMPT = "\nDo you want to disable telemetry entirely?"
 
 
 def next_utc_weekday(wday: int, now: float | None = None) -> int:
@@ -66,12 +70,17 @@ def set_telemetry_mode(
 
     logger = gc.logger
 
+    if mode == "on":
+        if consent_time is None:
+            consent_time = datetime.datetime.now().astimezone()
+    else:
+        # clear any previously recorded consent time
+        consent_time = None
+
+    # First, persist the changes to user config
     with ConfigEditor.work_on_user_local_config(gc) as ed:
         ed.set_value((schema.SECTION_TELEMETRY, schema.KEY_TELEMETRY_MODE), mode)
-
-        if mode == "on":
-            if consent_time is None:
-                consent_time = datetime.datetime.now().astimezone()
+        if consent_time is not None:
             ed.set_value(
                 (schema.SECTION_TELEMETRY, schema.KEY_TELEMETRY_UPLOAD_CONSENT),
                 consent_time,
@@ -83,6 +92,18 @@ def set_telemetry_mode(
 
         ed.stage()
 
+    # Then, apply the changes to the running instance's GlobalConfig
+    # TelemetryProvider instance (if any) will pick them up automatically
+    # because the properties are backed by GlobalConfig.
+    gc.set_by_key(
+        (schema.SECTION_TELEMETRY, schema.KEY_TELEMETRY_MODE),
+        mode,
+    )
+    gc.set_by_key(
+        (schema.SECTION_TELEMETRY, schema.KEY_TELEMETRY_UPLOAD_CONSENT),
+        consent_time,
+    )
+
     if not show_cli_feedback:
         return
     match mode:
@@ -111,8 +132,6 @@ def set_telemetry_mode(
 class TelemetryProvider:
     def __init__(self, gc: "GlobalConfig") -> None:
         self.state_root = pathlib.Path(gc.telemetry_root)
-        self.local_mode = gc.telemetry_mode == "local"
-        self.upload_consent_time = gc.telemetry_upload_consent_time
 
         self._discard_events = False
         self._gc = gc
@@ -129,6 +148,14 @@ class TelemetryProvider:
     def logger(self) -> RuyiLogger:
         return self._gc.logger
 
+    @property
+    def local_mode(self) -> bool:
+        return self._gc.telemetry_mode == "local"
+
+    @property
+    def upload_consent_time(self) -> datetime.datetime | None:
+        return self._gc.telemetry_upload_consent_time
+
     def store(self, scope: TelemetryScope) -> TelemetryStore | None:
         return self._stores.get(scope)
 
@@ -386,16 +413,32 @@ class TelemetryProvider:
         return store.upload_staged_payloads()
 
     def oobe_prompt(self) -> None:
-        """Ask whether the user consents to a first-run telemetry upload."""
+        """Ask whether the user consents to a first-run telemetry upload, and
+        persist the user's exact telemetry choice."""
 
         from ..cli import user_input
 
-        self.logger.stdout(TELEMETRY_INITIAL_UPLOAD_PROMPT)
+        self.logger.stdout(TELEMETRY_CONSENT_AND_UPLOAD_DESC)
         if not user_input.ask_for_yesno_confirmation(
             self.logger,
-            "Do you agree?",
-            True,
+            TELEMETRY_CONSENT_AND_UPLOAD_PROMPT,
+            False,
         ):
+            # ask if the user wants to opt out entirely
+            if user_input.ask_for_yesno_confirmation(
+                self.logger,
+                TELEMETRY_OPTOUT_PROMPT,
+                False,
+            ):
+                set_telemetry_mode(self._gc, "off")
+                return
+
+            # user wants to stay in local mode
+            # explicitly record the preference, so we don't have to worry about
+            # us potentially changing defaults yet another time
+            set_telemetry_mode(self._gc, "local")
             return
 
+        consent_time = datetime.datetime.now().astimezone()
+        set_telemetry_mode(self._gc, "on", consent_time)
         self._upload_on_exit = True

ruyi/utils/git.py

@@ -119,13 +119,15 @@ def pull_ff_or_die(
             logger.I(f"repository:          [yellow]{repo_path}[/]")
             logger.I(f"expected remote URL: [yellow]{remote_url}[/]")
             logger.I(f"actual remote URL:   [yellow]{remote.url}[/]")
-            logger.I("please fix the repo settings manually")
+            logger.I("please [bold red]fix the repo settings manually[/]")
             raise SystemExit(1)
 
         logger.D(
             f"updating url of remote {remote_name} from {remote.url} to {remote_url}"
         )
-        repo.remotes.set_url("origin", remote_url)
+        repo.remotes.set_url(remote_name, remote_url)
+        # this needs manual refreshing
+        remote = repo.remotes[remote_name]
 
     logger.D("fetching")
     try:

ruyi/utils/toml.py

@@ -7,6 +7,17 @@ from tomlkit.container import Container
 from tomlkit.items import Array, Comment, InlineTable, Item, Table, Trivia, Whitespace
 
 
+class NoneValue(Exception):
+    """Used to indicate that a None value is to be dumped in TOML. Because TOML
+    does not support None natively, this means special handling is needed."""
+
+    def __str__(self) -> str:
+        return "NoneValue()"
+
+    def __repr__(self) -> str:
+        return "NoneValue()"
+
+
 def with_indent(item: Item, spaces: int = 2) -> Item:
     item.indent(spaces)
     return item

ruyi/utils/xdg_basedir.py

@@ -4,7 +4,12 @@
 
 import os
 import pathlib
-from typing import Iterable
+from typing import Iterable, NamedTuple
+
+
+class XDGPathEntry(NamedTuple):
+    path: pathlib.Path
+    is_global: bool
 
 
 def _paths_from_env(env: str, default: str) -> Iterable[pathlib.Path]:
@@ -38,14 +43,16 @@ class XDGBaseDir:
         return pathlib.Path(v) if v else pathlib.Path.home() / ".local" / "state"
 
     @property
-    def config_dirs(self) -> Iterable[pathlib.Path]:
+    def config_dirs(self) -> Iterable[XDGPathEntry]:
         # from highest precedence to lowest
-        yield from _paths_from_env("XDG_CONFIG_DIRS", "/etc/xdg")
+        for p in _paths_from_env("XDG_CONFIG_DIRS", "/etc/xdg"):
+            yield XDGPathEntry(p, True)
 
     @property
-    def data_dirs(self) -> Iterable[pathlib.Path]:
+    def data_dirs(self) -> Iterable[XDGPathEntry]:
         # from highest precedence to lowest
-        yield from _paths_from_env("XDG_DATA_DIRS", "/usr/local/share/:/usr/share/")
+        for p in _paths_from_env("XDG_DATA_DIRS", "/usr/local/share/:/usr/share/"):
+            yield XDGPathEntry(p, True)
 
     # derived info
 
@@ -66,15 +73,15 @@ class XDGBaseDir:
         return self.state_home / self.app_name
 
     @property
-    def app_config_dirs(self) -> Iterable[pathlib.Path]:
+    def app_config_dirs(self) -> Iterable[XDGPathEntry]:
         # from highest precedence to lowest
-        yield self.app_config
-        for p in self.config_dirs:
-            yield p / self.app_name
+        yield XDGPathEntry(self.app_config, False)
+        for e in self.config_dirs:
+            yield XDGPathEntry(e.path / self.app_name, e.is_global)
 
     @property
-    def app_data_dirs(self) -> Iterable[pathlib.Path]:
+    def app_data_dirs(self) -> Iterable[XDGPathEntry]:
         # from highest precedence to lowest
-        yield self.app_data
-        for p in self.data_dirs:
-            yield p / self.app_name
+        yield XDGPathEntry(self.app_data, False)
+        for e in self.data_dirs:
+            yield XDGPathEntry(e.path / self.app_name, e.is_global)

{ruyi-0.42.0a20251005.dist-info → ruyi-0.42.0a20251013.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ruyi
-Version: 0.42.0a20251005
+Version: 0.42.0a20251013
 Summary: Package manager for RuyiSDK
 License: Apache License
                                     Version 2.0, January 2004
@@ -332,6 +332,10 @@ Various aspects of `ruyi` can be configured with files or environment variables.
 look up its config accordingly. If these are not explicitly set though, as in
 typical use cases, the default config directory is most likely `~/.config/ruyi`.
 
+GNU/Linux distribution packagers and system administrators will find that the
+directories `/usr/share/ruyi` and `/usr/local/share/ruyi` are searched for the
+config file on such systems.
+
 ### Config file
 
 Currently `ruyi` will look for an optional `config.toml` in its XDG config
@@ -361,9 +365,8 @@ branch = "main"
 # details.
 #
 # If unset or empty, this default value is used: data will be collected and
-# uploaded every week, on a random weekday determined by the installation's
-# anonymous ID alone.
-mode = "on"
+# stored locally; nothing will be uploaded automatically.
+mode = "local"
 # The time the user's consent is given to telemetry data uploading. If the
 # system time is later than the time given here, telemetry consent banner will
 # not be displayed any more each time `ruyi` is executed. The exact consent
@@ -407,12 +410,16 @@ There are 3 telemetry modes available:
 * `off`: data will not be collected nor uploaded.
 * `on`: data will be collected and periodically uploaded.
 
-By default the `on` mode is active, which means every `ruyi` invocation
-will record some non-sensitive information locally alongside various other
-states of `ruyi`, and collected data will be periodically uploaded to servers
-managed by the RuyiSDK team in the People's Republic of China, in a weekly fashion.
-The upload will happen on a random weekday which is determined by the
-installation's anonymous ID alone.
+By default the `local` mode is active from `ruyi` 0.42.0 (inclusive) on, which
+means every `ruyi` invocation will record some non-sensitive information locally
+alongside various other states of `ruyi`, but collected data will not be
+uploaded automatically unless you explicitly request so (for example by
+switching to the `on` mode, or by executing `ruyi telemetry upload`).
+
+In case the `on` mode is active, collected data will be periodically uploaded
+to servers managed by the RuyiSDK team in the People's Republic of China, in a
+weekly fashion. The upload will happen on a random weekday which is determined
+by the installation's anonymous ID alone.
 
 You can change the telemetry mode by editing `ruyi`'s config file, or simply
 disable telemetry altogether by setting the `RUYI_TELEMETRY_OPTOUT` environment

{ruyi-0.42.0a20251005.dist-info → ruyi-0.42.0a20251013.dist-info}/RECORD

@@ -5,19 +5,19 @@ ruyi/cli/builtin_commands.py,sha256=cYyPSF00DSBH1WMv6mHcMygbFRBGXObMWhbXHs5K1Mc,
 ruyi/cli/cmd.py,sha256=kR3aEiDE3AfPoP0Zr7MO-09CKoExbkLLmPvve9oKaUg,6725
 ruyi/cli/completer.py,sha256=cnOkU7veDe-jP8ROXZL2uBop2HgWfaAZl6dromnPLx8,1426
 ruyi/cli/completion.py,sha256=ffLs3Dv7pY_uinwH98wkBPohRvAjpUOGqy01OTA_Bgo,841
-ruyi/cli/config_cli.py,sha256=IMsUEs1iiFCvGLdGAVByMxwjNiP4IMZammkUMs0nFio,3497
-ruyi/cli/main.py,sha256=x3L_EQ1sb2F3JK5bY-4iH59pJUk93KWZAjyj-gAG8-g,3863
+ruyi/cli/config_cli.py,sha256=9kq5W3Ir_lfwImhvrUmQ1KTKy1aRCv_UU1CmL5eGyJs,4038
+ruyi/cli/main.py,sha256=X1xyD7mYcCdQAWxGU7F27XPI77LzG0oifJx_el_UOBs,4124
 ruyi/cli/oobe.py,sha256=fpzNukwpT16CSqAobClC615Fii7GFDYc5g5ArZMur1A,2463
 ruyi/cli/self_cli.py,sha256=opDHVpvgg0AgZdzi7kEY73_jwV6LRjtIpdgsFkRL1hI,8668
 ruyi/cli/user_input.py,sha256=ZJPyCAD7Aizkt37f_KDtW683aKvGZ2pL85Rg_y1LLfg,3711
 ruyi/cli/version_cli.py,sha256=L2pejZ7LIPYLUTb9NIz4t51KB8ai8igPBuE64tyqUuI,1275
-ruyi/config/__init__.py,sha256=VqHcXAt82bDJPsLnZKzzL-d-tNbe5X4SnLKlx9WdfRw,13501
-ruyi/config/editor.py,sha256=6b4VpViEPvfPHtEyrQHAjeFpJOT8-mfTla6dXbKf--g,3148
-ruyi/config/errors.py,sha256=EO-ezHgtkWoiH0jOjkkw3MgiTAHHLhppks6F9-p2i6I,2162
+ruyi/config/__init__.py,sha256=IeRfS51U4f-d---jKVNrBZshJrlrK06u25LssMgd8sI,17075
+ruyi/config/editor.py,sha256=piAJ-a68iX6IFWXy1g9OXoSs_3DardZwoaSPdStKKL0,4243
+ruyi/config/errors.py,sha256=pSu9bzVmQLh5ov36i1T6SkZOYwdus1v2DoMGWV7caKY,2518
 ruyi/config/news.py,sha256=83LjQjJHsqOPdRrytG7VBFubG6pyDwJ-Mg37gpBRU20,1061
-ruyi/config/schema.py,sha256=j-oXLl5qeoaWNONxSzAfuaBM6be9m1Xjliez2FUEpjg,5862
+ruyi/config/schema.py,sha256=btw3dwuTfNRIEVWa9JwIqrdfnxhbQ72uX_PV5Q7kCvM,5951
 ruyi/device/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ruyi/device/provision.py,sha256=0Lywhs9_sLMG21DRMP1DyijYFIB4k4-xYYNJikH8qcs,20902
+ruyi/device/provision.py,sha256=9rUbLtybBQ8x9qRXaMwz_yAMf51vb3wmYE0qm54P5Bk,20906
 ruyi/device/provision_cli.py,sha256=sc6AF8ohWrXA-kIAYdZcD6sl1HHbj_dH2cCi-pjjOQg,1031
 ruyi/log/__init__.py,sha256=ehgUl8iY1oRfP_nJKrln5lnvJFSPPU1J-3g-PK28YWk,6516
 ruyi/mux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,14 +45,14 @@ ruyi/ruyipkg/augmented_pkg.py,sha256=QbzYNHCRanFx9xwYRosN_dAEzOSxmOBxyBVli8SC9FE
 ruyi/ruyipkg/canonical_dump.py,sha256=Qu25YXwJpjWUBte0C3bmmaJxe7zyqfN-2-__u2_dJDM,9363
 ruyi/ruyipkg/checksum.py,sha256=ChYFPXl7-Y8p_bDerkXOGroRz4k6ejjWY9ViaVWuEgk,1274
 ruyi/ruyipkg/cli_completion.py,sha256=kJf7vN5rXi5zAwTI3dr4J8HdUzR3-ZXnsdaNQV6kqzo,1151
-ruyi/ruyipkg/distfile.py,sha256=mgEZAS8jv9zP_7SSk59B8QCZfcouUf4qZGBnL44B5zg,6895
+ruyi/ruyipkg/distfile.py,sha256=wkyYVcSM2b3vD462TtoltdLcUZElCwWvcZBiPG3lTZ0,7002
 ruyi/ruyipkg/entity.py,sha256=s8h5kNaR2vsP6v_QUFIO6SZiUrt0jrb8GU11bNT6fn4,14498
 ruyi/ruyipkg/entity_cli.py,sha256=hF66i3sJX8XVLIWq376GA9vzgegfQy-6s0x0L831Irk,3802
 ruyi/ruyipkg/entity_provider.py,sha256=jDfS2Jh01PVHo0kb1XyI5WkZgL4fv21AooXLLwqK-1I,8741
-ruyi/ruyipkg/fetch.py,sha256=_btz2hkTz0uEUCCSAhOK7tlhAuvzCu42ZTUCP-RpU7U,9047
+ruyi/ruyipkg/fetcher.py,sha256=_btz2hkTz0uEUCCSAhOK7tlhAuvzCu42ZTUCP-RpU7U,9047
 ruyi/ruyipkg/host.py,sha256=pmqgggi7koDCWgzFexwHpycv4SZ07VF6xUbi4s8FSKA,1399
-ruyi/ruyipkg/install.py,sha256=1RpDVEGkni8Z9z-3GVJepDYpF9ADdkh2vXTyG7BZms4,16299
-ruyi/ruyipkg/install_cli.py,sha256=BuhGJcrKsJqr63-8AamouY1mXAvjEe2nkxHYuAQ3U0Y,4269
+ruyi/ruyipkg/install.py,sha256=RhJwIqGxMveWrGmpP-2uWpZBRnqkA75HwyHwrNTdqow,18176
+ruyi/ruyipkg/install_cli.py,sha256=joIV5iY4iblDinoH2pgbHNYkMVWqMxtVNj89T0IpJuk,5267
 ruyi/ruyipkg/list.py,sha256=iO7666xFEWKTDNtJqVLaaQKsp0BfLTzgXBwFFHrqCGc,4172
 ruyi/ruyipkg/list_cli.py,sha256=9tRWWRcJv3yJqzup6Oc89E3xahGp5jIfybfEvwwd55I,2243
 ruyi/ruyipkg/list_filter.py,sha256=F64_UhwUEiaUR73EkLu91qoUBA-Yz9mEVWj8XY46MXQ,5467
@@ -64,16 +64,16 @@ ruyi/ruyipkg/pkg_manifest.py,sha256=FmksKjQyBnU4zA3MFXiHdB2EjNmhs-J9km9vE-zBQlk,
 ruyi/ruyipkg/profile.py,sha256=FVppmA6x12m3JfeAWd3Vl9osk4aBprZL4ff7akO018Q,6467
 ruyi/ruyipkg/profile_cli.py,sha256=ud9MS9JQLOtec_1tFRu669I-imVfi1DHU3AuBJym9mw,848
 ruyi/ruyipkg/protocols.py,sha256=lPKRaAcK3DY3wmkyO2tKpFvPQ_4QA4aSNNsNLvi78O8,1833
-ruyi/ruyipkg/repo.py,sha256=cdqEkeFgCnPieynyoZlp_19BAExBZnCWuD3kE1NQ6JA,25164
+ruyi/ruyipkg/repo.py,sha256=3D_R9JjztY2IbyeQsfnrwJHNJ_Bcx3o_QZZEOk02YNo,25167
 ruyi/ruyipkg/state.py,sha256=3DRYyHvm_GOvKFVWZUV0iFVnXdK2vn6_RKBXKxFzK64,11235
-ruyi/ruyipkg/unpack.py,sha256=X_MKcxU1bcgIM-th1--CUfmnjQOFp-EqWWpvk27YttA,11028
+ruyi/ruyipkg/unpack.py,sha256=hPd-lOnDXp1lEb4mdbLUEckT4QXblSFxz-dGAdwaAjc,11207
 ruyi/ruyipkg/unpack_method.py,sha256=MonFFvcDb7MVsi2w4yitnCeZkmWmS7nRMMY-wSt9AMs,2106
 ruyi/ruyipkg/update_cli.py,sha256=ywsAAUPctJ3_2qPDvFL2__ql9m8tGZ6ZfrwbSk30Xh4,1425
 ruyi/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ruyi/telemetry/aggregate.py,sha256=Ybt25xrg0n62A9Ipslv18EBC-kLkyYsPeEzgguTtChg,1981
 ruyi/telemetry/event.py,sha256=GZnFj6E59Q7mjp-2VRApAZH3rT_bu4_cWb5QMCPm-Zc,982
 ruyi/telemetry/node_info.py,sha256=ix-udhoKQI-HV7qVeEbd-jy3ZyhXL62sVA9uX4fowEg,5178
-ruyi/telemetry/provider.py,sha256=KKYoic29hWq4u2Bk_usORkT9yQCpREinOLYZXj3eN9k,14832
+ruyi/telemetry/provider.py,sha256=U88ydGga3dwYAi7mfNKmEEyfhAZ4xelF2L-jNAk29IY,16486
 ruyi/telemetry/scope.py,sha256=e45VPAvRAqSxrL0ESorN9SCnR_I6Bwi2CMPJDDshJEE,1133
 ruyi/telemetry/store.py,sha256=7ThCzKF2txT_xU3qgjotOcwRqwNhozIkIyYQ0GSUxBg,8015
 ruyi/telemetry/telemetry_cli.py,sha256=PBVMUSE3P6IBKQVMji_bueVenCdbchbOlowySXy0468,3364
@@ -81,7 +81,7 @@ ruyi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ruyi/utils/ar.py,sha256=w9wiYYdbInLewr5IRTcP0TiOw2ibVDQEmnV0hHm9WlA,2271
 ruyi/utils/ci.py,sha256=66DBm4ooA7yozDtXCJFd1n2jJXTsEnxPSpkNzLfE28M,2970
 ruyi/utils/frontmatter.py,sha256=4EOohEYCZ_q6ncpDv7ktJYf9PN4WEdgFfdE9hZBV3Zg,1052
-ruyi/utils/git.py,sha256=SlOaS9sR4_0mhNgTXMvrmI8Q7-eh2z8pyhGq_9HuqSU,5893
+ruyi/utils/git.py,sha256=YspRRkfxLXluCv4LNx6q_mjkPdoX7WSM9aR7EfudqlM,5991
 ruyi/utils/global_mode.py,sha256=A9ehY4z1ckUSMHqiDDlXmJpjPzTajCgsDvDqyTwZZj4,4979
 ruyi/utils/l10n.py,sha256=l003oQ5M8fWIKQHbYTVSc6oHzFFGU2sbKac7Hh6FNFU,2530
 ruyi/utils/markdown.py,sha256=Mpq--ClM4j9lm_-5zO53ptYePUTLI4rg0V1YshOwsf8,2654
@@ -91,12 +91,12 @@ ruyi/utils/porcelain.py,sha256=pF6ieSE2xlnC0HBADFY0m-uuwVNNME3wlbHo2jWdLFA,1403
 ruyi/utils/prereqs.py,sha256=oWAaH-smpTMQxpHt782YBxqHxrTaheataslN988-a78,2076
 ruyi/utils/ssl_patch.py,sha256=a5gf4br6nC39wTHsqiFtcJ-mGzqB-YzK6DHSeERLaHQ,5661
 ruyi/utils/templating.py,sha256=94xBJTkIfDqmUBTc9hnLO54zQoC7hwGWONGF3YbaqHk,966
-ruyi/utils/toml.py,sha256=ri97Ki0xhBwoDtrjngCc6hlPXuEsma1ShPFFuFMYqpA,3192
+ruyi/utils/toml.py,sha256=aniIF3SGfR69_s3GWWwlnoKxW4B5IDVY2CM0eUI55_c,3501
 ruyi/utils/url.py,sha256=Wyct6syS4GmZC6mY7SK-YgBWxKl3cOOBXtp9UtvGkto,186
-ruyi/utils/xdg_basedir.py,sha256=vd9p-JZru2DkXvt_W3gCS1_Wj4QkuftErI1MLPaBiz4,2478
+ruyi/utils/xdg_basedir.py,sha256=RwVH199jPcLVsg5ngR62RaNS5hqnMpkdt31LqkCfa1g,2751
 ruyi/version.py,sha256=KLJkvKexU07mu-GVDbYKsQvReRvwlVFYkRmcvnyfQNY,2142
-ruyi-0.42.0a20251005.dist-info/METADATA,sha256=6BbsE9zC6zyCzC-rlAsG2h3s5wUOBNY1TdcUvIZkjhA,23892
-ruyi-0.42.0a20251005.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-ruyi-0.42.0a20251005.dist-info/entry_points.txt,sha256=GXSNSy7OgFrnlU5xm5dE3l3PGO92Qf6VDIUCdvQNm8E,49
-ruyi-0.42.0a20251005.dist-info/licenses/LICENSE-Apache.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ruyi-0.42.0a20251005.dist-info/RECORD,,
+ruyi-0.42.0a20251013.dist-info/METADATA,sha256=S9n6IZt93cQ9AXUc1vAdp6XAgOAtFTLOkKFjMvnhhog,24282
+ruyi-0.42.0a20251013.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+ruyi-0.42.0a20251013.dist-info/entry_points.txt,sha256=GXSNSy7OgFrnlU5xm5dE3l3PGO92Qf6VDIUCdvQNm8E,49
+ruyi-0.42.0a20251013.dist-info/licenses/LICENSE-Apache.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ruyi-0.42.0a20251013.dist-info/RECORD,,