ybox 0.9.8.1__py3-none-any.whl → 0.9.11__py3-none-any.whl

ybox/run/graphics.py

@@ -20,7 +20,8 @@ _STD_LIB_DIR_PATTERNS = ["&/usr/lib/*-linux-gnu", "&/lib/*-linux-gnu", "&/usr/li
                          "&/lib64/*-linux-gnu", "&/usr/lib32/*-linux-gnu", "&/lib32/*-linux-gnu"]
 _STD_LD_LIB_PATH_VARS = ["LD_LIBRARY_PATH", "LD_LIBRARY_PATH_64", "LD_LIBRARY_PATH_32"]
 _NVIDIA_LIB_PATTERNS = ["*nvidia*.so*", "*NVIDIA*.so*", "libcuda*.so*", "libnvcuvid*.so*",
-                        "libnvoptix*.so*", "gbm/*nvidia*.so*", "vdpau/*nvidia*.so*"]
+                        "libnvoptix*.so*", "gbm/*nvidia*.so*", "vdpau/*nvidia*.so*",
+                        "libXNVCtrl.so*"]
 _NVIDIA_BIN_PATTERNS = ["nvidia-smi", "nvidia-cuda*", "nvidia-debug*", "nvidia-bug*"]
 # note that the code below assumes that file name pattern below is always of the form *nvidia*
 # (while others are directories), so if that changes then update _process_nvidia_data_files
@@ -45,7 +46,8 @@ def add_env_option(docker_args: list[str], env_var: str, env_val: Optional[str]
         docker_args.append(f"-e={env_var}={env_val}")
 
 
-def add_mount_option(docker_args: list[str], src: str, dest: str, flags: str = "") -> None:
+def add_mount_option(docker_args: list[str], src: str, dest: str, flags: str = "",
+                     check_exists: bool = False) -> None:
     """
     Add option to the list of podman/docker arguments to bind mount a source directory to
     given destination directory.
@@ -54,11 +56,40 @@ def add_mount_option(docker_args: list[str], src: str, dest: str, flags: str = "
     :param src: the source directory in the host system
     :param dest: the destination directory in the container
     :param flags: any additional flags to be passed to `-v` podman/docker argument, defaults to ""
+    :param check_exists: check if the bind mount was already added (and skip if so)
     """
-    if flags:
-        docker_args.append(f"-v={src}:{dest}:{flags}")
+    mount_arg = f"-v={src}:{dest}:{flags}" if flags else f"-v={src}:{dest}"
+    if not check_exists or mount_arg not in docker_args:
+        docker_args.append(mount_arg)
+
+
+def handle_variable_mount(docker_args: list[str], env: Environ, mount_path: str) -> str:
+    """
+    Handle the case where a mount point may change in different starts or even within the same
+    started container instance. In these cases the "base" directory of the mount point is
+    mounted instead which should normally be `/tmp` or `$XDG_RUNTIME_DIR`. The variable values
+    are assumed to lie between these two, or the parent directory of the mount point if it does
+    not lie within these two base directories. The actual passing of the required environment
+    variable (that can change) is handled by the `run-in-dir` script that will adjust the variable
+    value to reflect that mount point added by this method.
+
+    :param docker_args: list of podman/docker arguments to which the options have to be appended
+    :param env: an instance of the current :class:`Environ`
+    :param mount_path: the variable path which is usually the value of an environment variable
+    :return: the result mount point inside the container for the `mount_path`
+    """
+    base_dir = os.path.dirname(mount_path)
+    # check if parent_dir is in $XDG_RUNTIME_DIR or /tmp
+    if not env.xdg_rt_dir:
+        base_dirs = {base_dir, "/tmp"}
+    elif mount_path.startswith(env.xdg_rt_dir + "/") or mount_path.startswith("/tmp/"):
+        base_dirs = (env.xdg_rt_dir, "/tmp")
+        base_dir = "/tmp" if base_dir.startswith("/tmp") else env.xdg_rt_dir
     else:
-        docker_args.append(f"-v={src}:{dest}")
+        base_dirs = (base_dir, env.xdg_rt_dir, "/tmp")
+    for b_dir in base_dirs:
+        add_mount_option(docker_args, b_dir, f"{b_dir}-host", "ro", check_exists=True)
+    return mount_path.replace(base_dir, f"{base_dir}-host")
 
 
 def enable_x11(docker_args: list[str], env: Environ) -> None:
@@ -82,18 +113,7 @@ def enable_x11(docker_args: list[str], env: Environ) -> None:
         # parent can cause trouble if one changes the display manager, for example, which
         # uses an entirely different mount point (e.g. gdm uses /run/user/... while sddm
         #   uses /tmp)
-        parent_dir = os.path.dirname(xauth)
-        # check if parent_dir is in $XDG_RUNTIME_DIR or /tmp
-        if not env.xdg_rt_dir:
-            parent_dirs = {parent_dir, "/tmp"}
-        elif xauth.startswith(f"{env.xdg_rt_dir}/") or xauth.startswith("/tmp/"):
-            parent_dirs = (env.xdg_rt_dir, "/tmp")
-            parent_dir = "/tmp" if parent_dir.startswith("/tmp") else env.xdg_rt_dir
-        else:
-            parent_dirs = (parent_dir, env.xdg_rt_dir, "/tmp")
-        for p_dir in parent_dirs:
-            add_mount_option(docker_args, p_dir, f"{p_dir}-host", "ro")
-        target_xauth = xauth.replace(parent_dir, f"{parent_dir}-host")
+        target_xauth = handle_variable_mount(docker_args, env, xauth)
         add_env_option(docker_args, "XAUTHORITY", target_xauth)
         add_env_option(docker_args, "XAUTHORITY_ORIG", target_xauth)
 

ybox/run/logs.py

@@ -6,7 +6,7 @@ ybox container.
 import argparse
 import sys
 
-from ybox.cmd import check_ybox_exists, run_command
+from ybox.cmd import check_ybox_exists, parser_version_check, run_command
 from ybox.env import get_docker_command
 from ybox.print import print_info
 
@@ -54,4 +54,5 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     parser.add_argument("-f", "--follow", action="store_true",
                         help="follow log output like 'tail -f'")
     parser.add_argument("container_name", type=str, help="name of the running ybox")
+    parser_version_check(parser, argv)
     return parser.parse_args(argv)

ybox/run/ls.py

@@ -5,7 +5,7 @@ Code for the `ybox-ls` script that is used to show the active or stopped ybox co
 import argparse
 import sys
 
-from ybox.cmd import YboxLabel, run_command
+from ybox.cmd import YboxLabel, parser_version_check, run_command
 from ybox.env import get_docker_command
 
 
@@ -61,4 +61,5 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
                              "https://docs.docker.com/reference/cli/docker/container/ls)")
     parser.add_argument("-l", "--long-format", action="store_true",
                         help="display extended information without truncating fields")
+    parser_version_check(parser, argv)
     return parser.parse_args(argv)

ybox/run/pkg.py

@@ -7,7 +7,8 @@ import argparse
 import sys
 from typing import cast
 
-from ybox.cmd import YboxLabel, check_active_ybox, run_command
+from ybox.cmd import (YboxLabel, check_active_ybox, parser_version_check,
+                      run_command)
 from ybox.config import Consts, StaticConfiguration
 from ybox.env import Environ
 from ybox.pkg.clean import clean_cache
@@ -61,6 +62,29 @@ def main_argv(argv: list[str]) -> None:
         elif not containers:
             print_error("No active ybox container found!")
             sys.exit(1)
+        elif args.group_by_shared_root:
+            with YboxStateManagement(env) as state:
+                entries = state.get_containers_grouped_by_shared_root(containers)
+            if not entries:
+                print_error(f"No containers in state database for: {', '.join(containers)}")
+                sys.exit(1)
+            if len(entries) == 1:
+                # select the first container in the list for the shared_root
+                container_name = entries[0][0][0]
+            elif args.quiet:
+                msg = "\n  ".join([", ".join(t[0]) + (" on " + t[1] if t[1] else " (not shared)")
+                                   for t in entries])
+                print_error(
+                    f"Expected one activate container or shared root but found:\n  {msg}")
+                sys.exit(1)
+            else:
+                # display as container names grouped by distribution and shared_root
+                selection_list = [" / ".join(t[0]) + " : distro '" + t[2] +
+                                  ("' on " + t[1] if t[1] else "' (not shared)") for t in entries]
+                print_info("Please select the container to use:", file=sys.stderr)
+                if (selection := select_item_from_menu(selection_list)) is None:
+                    sys.exit(1)
+                container_name = selection[:selection.index(" ")]
         elif args.quiet:
             print_error(
                 f"Expected one active ybox container but found: {', '.join(containers)}")
@@ -73,6 +97,7 @@ def main_argv(argv: list[str]) -> None:
     if not args.quiet:
         print_info(f"Running the operation on '{container_name}'", file=sys.stderr)
 
+    code = 0
     with YboxStateManagement(env) as state:
         # ensure that all state database changes are done as a single transaction and only applied
         # if there were no failures (commit/rollback are automatic at the end of `with`)
@@ -93,10 +118,14 @@ def main_argv(argv: list[str]) -> None:
         if args.is_repo_cmd:
             code = args.func(args, pkgmgr, distro_config["repo"], docker_cmd, conf,
                              runtime_conf, state)
-        else:
+        elif args.needs_state:
             code = args.func(args, pkgmgr, docker_cmd, conf, runtime_conf, state)
-        if code != 0:
-            sys.exit(code)  # state will be automatically rolled back for exceptions
+
+    # when "state" is not needed then run the command outside the with block to release the db lock
+    if not args.is_repo_cmd and not args.needs_state:
+        code = args.func(args, pkgmgr, docker_cmd, conf)
+    if code != 0:
+        sys.exit(code)  # state will be automatically rolled back for exceptions
 
 
 def parse_args(argv: list[str]) -> argparse.Namespace:
@@ -129,6 +158,7 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
                            "mark a package as a dependency or an explicitly installed package"))
     add_repair(add_subparser(operations, "repair",
                              "try to repair state after a failed operation or an interrupt/kill"))
+    parser_version_check(parser, argv)
     return parser.parse_args(argv)
 
 
@@ -146,6 +176,10 @@ def add_subparser(operations, name: str, hlp: str) -> argparse.ArgumentParser:
     add_common_args(subparser)
     # by default set the flag for repository command as false
     subparser.set_defaults(is_repo_cmd=False)
+    # set the flag to require state database by default
+    subparser.set_defaults(needs_state=True)
+    # don't group by shared_root by default
+    subparser.set_defaults(group_by_shared_root=False)
     return subparser
 
 
@@ -245,6 +279,7 @@ def add_update(subparser: argparse.ArgumentParser) -> None:
                            help="the packages to update if provided, else update the entire "
                                 "installation of the container (which will end up updating all "
                                 "other containers sharing the same root if configured)")
+    subparser.set_defaults(group_by_shared_root=True)
     subparser.set_defaults(func=update_packages)
 
 
@@ -291,6 +326,7 @@ def add_list_files(subparser: argparse.ArgumentParser) -> None:
     """
     add_pager_arg(subparser)
     subparser.add_argument("package", type=str, help="list files of this package")
+    subparser.set_defaults(needs_state=False)
     subparser.set_defaults(func=list_files)
 
 
@@ -310,6 +346,8 @@ def add_search(subparser: argparse.ArgumentParser) -> None:
                                 "(e.g. skip AUR repository on Arch Linux)")
     add_pager_arg(subparser)
     subparser.add_argument("search", nargs="+", help="one or more search terms")
+    subparser.set_defaults(needs_state=False)
+    subparser.set_defaults(group_by_shared_root=True)
     subparser.set_defaults(func=search_packages)
 
 
@@ -326,6 +364,7 @@ def add_info(subparser: argparse.ArgumentParser) -> None:
                                 "otherwise search only among the installed packages")
     add_pager_arg(subparser)
     subparser.add_argument("packages", nargs="+", help="one or more packages")
+    subparser.set_defaults(needs_state=False)
     subparser.set_defaults(func=info_packages)
 
 
@@ -337,6 +376,8 @@ def add_clean(subparser: argparse.ArgumentParser) -> None:
 
     :param subparser: the :class:`argparse.ArgumentParser` object for the sub-command
     """
+    subparser.set_defaults(needs_state=False)
+    subparser.set_defaults(group_by_shared_root=True)
     subparser.set_defaults(func=clean_cache)
 
 
@@ -351,11 +392,11 @@ def add_mark(subparser: argparse.ArgumentParser) -> None:
     subparser.add_argument("-e", "--explicit", action="store_true",
                            help="mark the package as explicitly installed; the package will "
                                 "henceforth be managed by `ybox-pkg` if not already; "
-                                "exactly one of -e or -D option must be specified")
-    subparser.add_argument("-D", "--dependency-of", type=str,
+                                "exactly one of -e or -d option must be specified")
+    subparser.add_argument("-d", "--dependency-of", type=str,
                            help="mark the package as a dependency of given package; both the "
                                 "packages will henceforth be managed by `ybox-pkg` if not "
-                                "already; exactly one of -e or -D option must be specified")
+                                "already; exactly one of -e or -d option must be specified")
     subparser.add_argument("package", type=str, help="the package to be marked")
     subparser.set_defaults(func=mark_package)
 
@@ -372,6 +413,7 @@ def add_repair(subparser: argparse.ArgumentParser) -> None:
                            help="repair thoroughly by reinstalling all packages; CAUTION: use "
                            "this only if the normal repair fails and the system cannot be "
                            "recovered otherwise")
+    subparser.set_defaults(group_by_shared_root=True)
     subparser.set_defaults(func=repair_package_state)
 
 

ybox/state.py

@@ -344,9 +344,8 @@ class YboxStateManagement:
         if self._version == old_version:
             return
         # run appropriate SQL migration scripts for product version change
-        if not (scripts := self._filter_and_sort_files_by_version(
-                files("ybox").joinpath("migrate").iterdir(), old_version, self._version, ".py")):
-            return
+        scripts = self._filter_and_sort_files_by_version(
+            files("ybox").joinpath("migrate").iterdir(), old_version, self._version, ".py")
         for script in scripts:
             print_color(f"Running migration script '{script}' for container version upgrade from "
                         f"{old_version} to {self._version}")
@@ -559,6 +558,26 @@ class YboxStateManagement:
             pass
         return shared_containers
 
+    def get_containers_grouped_by_shared_root(self, containers: list[str]) -> list[
+            tuple[list[str], str, str]]:
+        """
+        Get the containers grouped by their `shared_root`s, if present, else as separate entries.
+
+        :param containers: list of containers to include, or empty to include all containers
+        :return: list of tuple of (container list, shared_root, distribution) matching given
+                 containers (or all containers if empty list provided)
+        """
+        in_list = "name IN (" + ("?, " * (len(containers) - 1)) + "?) AND " if containers else ""
+        # using default "," to separate container names since a container name cannot have it
+        # (see the regex check in ybox.run.create.process_args)
+        with closing(cursor := self._conn.execute(
+            f"""SELECT STRING_AGG(name, ','), shared_root, MIN(distribution) FROM containers
+                WHERE {in_list}NOT destroyed
+                GROUP BY CASE WHEN length(shared_root) = 0 THEN name ELSE shared_root END""",
+                containers)):
+            rows = cursor.fetchall()
+            return [(str(row[0]).split(","), str(row[1]), str(row[2])) for row in rows]
+
     def register_package(self, container_name: str, package: str, local_copies: list[str],
                          copy_type: CopyType, app_flags: dict[str, str], shared_root: str,
                          dep_type: Optional[DependencyType], dep_of: str,

ybox/util.py

@@ -220,7 +220,7 @@ def get_ybox_version(conf: StaticConfiguration) -> str:
     return ""
 
 
-def wait_for_ybox_container(docker_cmd: str, conf: StaticConfiguration) -> None:
+def wait_for_ybox_container(docker_cmd: str, conf: StaticConfiguration, timeout: int) -> None:
     """
     Wait for container created with `create.start_container` to finish all its initialization.
     This depends on the specific entrypoint script used by `create.start_container` to write
@@ -229,10 +229,10 @@ def wait_for_ybox_container(docker_cmd: str, conf: StaticConfiguration) -> None:
 
     :param docker_cmd: the podman/docker executable to use
     :param conf: the :class:`StaticConfiguration` for the container
+    :param timeout: seconds to wait for container to start before exiting with failure code 1
     """
     sys.stdout.flush()
     box_name = conf.box_name
-    max_wait_secs = 600
     status_line = ""  # keeps the last valid line read from status file
     with open(conf.status_file, "r", encoding="utf-8") as status_fd:
 
@@ -251,7 +251,7 @@ def wait_for_ybox_container(docker_cmd: str, conf: StaticConfiguration) -> None:
                 print(line, end="")  # line already includes the terminating newline
             return False
 
-        for _ in range(max_wait_secs):
+        for _ in range(timeout):
             # check the container status first which may be running or stopping
             # in which case sleep and retry (if stopped, then read_lines should succeed)
             if get_ybox_state(docker_cmd, box_name, expected_states=("running", "stopping")):
@@ -267,8 +267,8 @@ def wait_for_ybox_container(docker_cmd: str, conf: StaticConfiguration) -> None:
             # using simple poll per second rather than inotify or similar because the
             # initialization can take a good amount of time and second granularity is enough
             time.sleep(1)
-    # reading did not end after max_wait_secs
-    print_error(f"TIMED OUT waiting for ready container after {max_wait_secs}secs (last status: "
+    # reading did not end after timeout
+    print_error(f"TIMED OUT waiting for ready container after {timeout}secs (last status: "
                 f"{status_line}).\nCheck 'ybox-logs -f {box_name}' for more details.")
     sys.exit(1)
 

{ybox-0.9.8.1.dist-info → ybox-0.9.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ybox
-Version: 0.9.8.1
+Version: 0.9.11
 Summary: Securely run Linux distribution inside a container
 Author-email: Sumedh Wale <sumwale@yahoo.com>, Vishal Rao <vishalrao@gmail.com>
 License: Copyright (c) 2024-2025 Sumedh Wale and contributors
@@ -25,7 +25,7 @@ License: Copyright (c) 2024-2025 Sumedh Wale and contributors
         
 Project-URL: Homepage, https://github.com/sumwale/ybox
 Project-URL: Issues, https://github.com/sumwale/ybox/issues
-Keywords: Linux in container,toolbox
+Keywords: Linux in container,toolbox,distrobox
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: MIT License
@@ -35,12 +35,14 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: packaging
 Requires-Dist: simple-term-menu
 Requires-Dist: tabulate>=0.9.0
+Dynamic: license-file
 
 ## Introduction
 
@@ -54,7 +56,17 @@ of the container including directories to be shared, logging etc.
 
 Special emphasis is given on security where users can choose to lock down
 or open up the container as required with reasonable defaults out of the
-box. There is no sharing of HOME or no privileged mode container.
+box. There is no sharing of HOME or no privileged mode container. This sets
+it apart from other similar solutions like distrobox/toolbx and the reason
+for starting this project since those other solutions don't care about
+security/sandboxing at all and share the entire HOME while running the
+containers in privileged mode. The other problem with those solutions is that
+the shared HOME means that the user's configuration dot files also get shared
+and can cause all kinds of trouble where container apps can overwrite
+with their own versions (especially for updated apps in the containers)
+breaking the app in the host system. It is, however, possible to share the
+entire HOME if user really wants but that needs to be explcitly configured
+in the ini profile.
 
 Expected usage is for users to group similar applications in a container
 and separate out containers depending on different needs like higher/lower
@@ -88,7 +100,7 @@ So, for example, if you want to run the latest and greatest Intellij IDEA commun
 to do is:
 
 ```sh
-# create an Arch Linux based container
+# create an Arch Linux based container and generate systemd service file (if possible)
 ybox-create arch
 # then select an appropriate built-in profile e.g. "dev.ini" from the menu
 
@@ -144,10 +156,11 @@ require you to install in a custom virtual environment which can be done manuall
  fish: `python3 -m venv ybox-venv && source ybox-env/bin/activate.fish`)
 or automatically using `pipx`. Alternatively you can add `--break-system-packages`
 flag to the `pip` command above or add it globally for all future packages using
-`python3 -m pip config set global.break-system-packages true`. The alternative
-approach works well for `ybox` which has a very minimal set of dependencies but
-in the rare case you see any issues due to package conflicts, use `pipx` or
-manual virtual environment.
+`python3 -m pip config set global.break-system-packages true`. This alternative
+approach works well for `ybox` which has a very minimal set of dependencies which will
+not conflict with system packages (rather work with whatever system version is installed),
+but if you prefer keeping the installation separate then use `pipx` or
+a manual virtual environment.
 
 Now you can run the `ybox-create` and other utilities that are normally installed
 in your `~/.local/bin` directory which should be in PATH for modern Linux distributions.
@@ -185,6 +198,8 @@ to point to the full path of the podman or docker executable.
 ybox-create
 ```
 
+By default this will also generate a user systemd service if possible (add `-S` or
+  `--skip-systemd-service` option to skip creation of a user systemd service).
 This will allow choosing from supported distributions, then from the available profiles.
 You can start with the Arch Linux distribution and `apps.ini` profile to try it out. The container
 will have a name like `ybox-<distribution>_<profile>` by default like `ybox-arch_apps` for the
@@ -209,7 +224,9 @@ does not run properly as root, then you cannot run it when using docker unless y
 `sudo/su` to the host user in the container command. However, running as host user when running
 rootless docker will map to a different user ID in the host (as specified in `/etc/subuid` on the
 host) so files shared with the host, including devices like those in `/dev/dri`, will cause
-permission issues that can hinder or break the application.
+permission issues that can hinder or break the application. Hence it is recommended to
+just install podman (even if you already have docker installed) which works out of the
+box in rootless mode in all tested distributions.
 
 
 ### Package management: install/uninstall/list/search/...
@@ -255,7 +272,7 @@ ybox-pkg list -o
 ```
 To show more details of the packages (combine with -a/-o as required):
 ```sh
-ybox-pkg list -o
+ybox-pkg list -v
 ```
 
 List all the files installed by the package:
@@ -295,6 +312,8 @@ Clean package cache, temporary downloads etc:
 ```sh
 ybox-pkg clean
 ```
+Add `-q` option to answer yes for any questions automatically if all your containers use
+the same shared root.
 
 Mark a package as explicitly installed (also registers with `ybox-pkg` if not present):
 ```sh
@@ -303,7 +322,7 @@ ybox-pkg mark firefox -e
 
 Mark a package as a dependency of another (also registers with `ybox-pkg` if not present):
 ```sh
-ybox-pkg mark qt5ct -D zoom  # mark qt5ct as an optional dependency of zoom
+ybox-pkg mark qt5ct -d zoom  # mark qt5ct as an optional dependency of zoom
 ```
 
 Repair package installation after a failure or interrupt:
@@ -342,10 +361,10 @@ ybox-destroy ybox-arch_apps
 ```
 
 Will destroy the `apps` container created in the example before. This does not delete the
-$HOME files, nor does it delete the shared root directory (if enabled). Hence, if you create
+`$HOME` files, nor does it delete the shared root directory (if enabled). Hence, if you create
 a new container having the same shared root, then it will inherit everything installed
 previously. Likewise, if you create the container with the same profile again, then it
-will also have the $HOME as before if you do not explicitly delete the directories
+will also have the `$HOME` as before if you do not explicitly delete the directories
 in `~/.local/share/ybox`.
 
 
@@ -374,10 +393,10 @@ ybox-cmd ybox-arch_apps -- ls -l
 ```
 
 The default profiles also link the .bashrc and starship configuration files from your host
-$HOME directory by default, so you should see the same bash shell configuration as in your
+`$HOME` directory by default, so you should see the same bash shell configuration as in your
 host. These are linked in read-only mode, so if you want to change these auto-linked
 configuration files inside the container, then you will need to create a copy from the symlink
-first (but then it will lose the link from the host $HOME).
+first (but then it will lose the link from the host `$HOME`).
 
 A shell on a container will act like a native Linux distribution environment for most purposes.
 The one prominent missing thing is systemd which is not enabled deliberately since it requires
@@ -423,33 +442,39 @@ for a ybox container. See the full set of options with `ybox-control -h/--help`.
 ### Auto-starting containers
 
 Containers can be auto-started as per the usual way for rootless podman/docker services.
-This is triggered by systemd on user login which is exactly what we want for ybox
+This is triggered by systemd on user login which is exactly what is required for ybox
 containers so that the container applications are available on login and are stopped on
-session logout. For docker the following should suffice:
-
-```sh
-systemctl --user enable docker
-```
+session logout. All the tested Linux distributions support this and provide for user
+systemd daemon on user login.
 
-See [docker docs](https://docs.docker.com/engine/security/rootless/#daemon) for details.
+The `ybox-create` command  autogenerates the systemd service file (in absence of `-S` or
+  `--skip-systemd-service` option) which is also removed by `ybox-destroy` automatically.
+The name of the generated service is `ybox-<NAME>` where `<NAME>` is the name of the
+container if `<NAME>` does not start with `ybox-` prefix, else it is just `<NAME>`.
 
-For podman you will need to explicitly generate systemd service file for each container and
-copy to your systemd configuration directory since podman does not use a background daemon.
-For the `ybox-arch_apps` container in the examples before:
+With a user service installed, the `systemctl` commands can be used to control the
+ybox container (`<SERVICE_NAME>` is `ybox-<NAME>/<NAME>` mentioned above):
 
 ```sh
-mkdir -p ~/.config/systemd/user/
-podman generate systemd --name ybox-arch_apps > ~/.config/systemd/user/container-ybox-arch_apps.service
-systemctl --user enable container-ybox-arch_apps.service
+systemctl --user status <SERVICE_NAME>  # show status of the service
+systemctl --user stop <SERVICE_NAME>    # stop the service
+systemctl --user start <SERVICE_NAME>   # start the service
 ```
 
+If your Linux distribution does not use systemd, then the autostart has to be handled
+manually as per the distribution's preferred way. For instance an appropriate desktop
+file can be added to `~/.config/autostart` directory to start a ybox container on
+graphical login, though performing a clean stop can be hard with this approach.
+Note that the preferred way to start/stop a ybox container is using the `ybox-control`
+command rather than directly using podman/docker.
+
 
 ## Development
 
 Virtual environment setup have been provided for consistent development, test and build
 with multiple python versions. The minimum python version required is 3.9 and tests are
-run against all major python versions higher than that (i.e. 3.10, 3.11, 3.12 and others
-in future).
+run against all major python versions higher than that (i.e. 3.10, 3.11, 3.12, 3.13 and
+    others in future).
 
 The setup uses pyenv with venv which can be used for development with IDEA/PyCharm/VSCode
 or in terminal, running tests against all supported python versions using `tox` etc.
@@ -476,14 +501,23 @@ Next you can install the required python versions and venv environment:
 pyenv/setup-venv.sh
 ```
 
-Finally, you can activate it in bash/zsh:
+Finally, you can activate it.
+
+bash:
+
+```sh
+source pyenv/activate.bash
+source .venv/bin/activate
+```
+
+zsh:
 
 ```sh
-source pyenv/activate.sh
+source pyenv/activate.zsh
 source .venv/bin/activate
 ```
 
-Or in fish shell:
+fish:
 
 ```
 source pyenv/activate.fish

ybox-0.9.11.dist-info/RECORD

@@ -0,0 +1,77 @@
+ybox/__init__.py,sha256=DJW4aoiXY2arxFg1eBQPfjHm19Ur_tXdLu332z66Esw,97
+ybox/cmd.py,sha256=RaNZ7LBqUNwpqQkitR29WLoItjkMfZmaFEeryLTR_tM,14962
+ybox/config.py,sha256=inmuUhlAZb6EKLGYWdymsqoHggtiLd58kc125l25ACA,9943
+ybox/env.py,sha256=6o0tJ163KWhVZHnhDRWw_16nMMYoy4-2yAHSJYBSL-0,9420
+ybox/filelock.py,sha256=nWBp3jvbtrNziRzNcWm6FVVA_lhMccLwgLCVT2IDK5c,3185
+ybox/print.py,sha256=hAQjTb6JmtjWh0sF4GdZHcKRph5iMKP5x23s8LE85q4,4343
+ybox/state.py,sha256=QSAfa4LGy7oDZVe6muBXFIylKB7CMalv3OgEQ3VtmAo,50174
+ybox/util.py,sha256=D4OgNCH0LXyHR9x0dCXCgkLFGvfgy--mqUbDbZRPobg,16520
+ybox/conf/completions/ybox.fish,sha256=zTfCb0XvTzzZUbYuIxV1BNSSpUZ1qbkbA5L4SfReLhc,6035
+ybox/conf/distros/supported.list,sha256=KAN7lbNfbRqF20KqEd0-BzF8U5uPx4n9h0W9zVh9z5o,52
+ybox/conf/distros/arch/add-gpg-key.sh,sha256=kLMCT15hYadjhInYwQiiyF4u6rJl8n4gGfzEKuMKvTg,644
+ybox/conf/distros/arch/distro.ini,sha256=NlCnhU4mmO9nE08BcO7hEQ83osMbHgIhLYybGG5rCNc,11026
+ybox/conf/distros/arch/init-base.sh,sha256=eqdVzrMqP0hP52S_xxYZJ8n1lStlPn-eSP2e4DpHvWc,311
+ybox/conf/distros/arch/init-user.sh,sha256=tb_NX4xNRU2pSuuVf2jSb7019uLfxBDbKI7ZyOtzSA4,1127
+ybox/conf/distros/arch/init.sh,sha256=7f96YVjgQnOWItaxDjllgOl4LD9ibqzuhSk2QbDutvU,3578
+ybox/conf/distros/arch/list_fmt_long.py,sha256=Ws9Mt9CKInxqUSn98P6-Csik2QqEjyBHp5NyUHlbcoU,2825
+ybox/conf/distros/arch/pkgdeps.py,sha256=Y77N1xHmHZRyZ9_diFVvoqBd44lZXIIJ2ipX7YVlrT8,14081
+ybox/conf/distros/deb-generic/check-package.sh,sha256=bMiOi6Cp_UrtXm_sXOWBq4Xng2EwXYerqBuRLtGYIlo,2621
+ybox/conf/distros/deb-generic/distro.ini,sha256=ZDWJG-cvx1BuI2RwynIvDwxzuzvVaYNv68PD-J57t84,11361
+ybox/conf/distros/deb-generic/fetch-gpg-key-id.sh,sha256=sTsLWILZosYJcGV1u8qBdczQAFBda2Zlsp1xbpy8nzo,836
+ybox/conf/distros/deb-generic/init-base.sh,sha256=rim7UckGos0phyOAiNYbIjOVG9C4gKQSB-YbZcTFIms,191
+ybox/conf/distros/deb-generic/init-user.sh,sha256=RDt9sZuv6cSX1WBaRGcLMq2ZTBhVZmZVWD1t0wjvizU,20
+ybox/conf/distros/deb-generic/init.sh,sha256=KW0a76BJm75VHDaLPCE4MdLThcy__NpE6Z8pLB0Q7IM,5748
+ybox/conf/distros/deb-generic/list_fmt_long.py,sha256=66sOC0Uzv5nuTRaQQ_9R-GFJju4PSPXNlXv_eHmx57k,5701
+ybox/conf/distros/deb-generic/pkgdeps.py,sha256=CKIJbftIjicGoGoYqScqb9zPZuKqT3r-gL9CRyraNbk,10571
+ybox/conf/distros/deb-oldstable/distro.ini,sha256=lr7140ftndEvs3Liavf3hg3v0qHHWAn0RRm_HAQTw8M,1103
+ybox/conf/distros/deb-stable/distro.ini,sha256=xyQ31mLOpj3Z1MK-UYuc_9NfEkb7Gy10MdDKXMgnqDo,1100
+ybox/conf/distros/ubuntu2204/distro.ini,sha256=3Pw1Q30USyKMUcHp_cvlqhwyU0FPo8O2AHWkgd0cdE4,1105
+ybox/conf/distros/ubuntu2404/distro.ini,sha256=ra4_EteDsHrw9UcehP4qLGTn98gAHc4JCb56CDzz1Wo,1102
+ybox/conf/profiles/apps.ini,sha256=vxVVy9oUw31to8CaagNZj9MQpGHIK2xARN4nzHy4vZ0,1270
+ybox/conf/profiles/basic.ini,sha256=FGSDOooI4meXhQlwFpPo_RxZ62it3bvdjqWkpVVDcA4,19713
+ybox/conf/profiles/dev.ini,sha256=Qicas_96ZoG3nsm1MSE1urarlBzIj9kBGmUqrk_cD3g,976
+ybox/conf/profiles/games.ini,sha256=FiBILNFOMpjKhrIR9nPbPj9QDUeI5h9wZaNXIb6Z7dc,1792
+ybox/conf/resources/entrypoint-base.sh,sha256=hcW8ZLHM-jlHx7McoKTo8HIFz_VBBPD0I3WqlX7LjHs,4890
+ybox/conf/resources/entrypoint-common.sh,sha256=fMopKBLeGuVV0ukANXh_ZHGTR1yGq108CTN_M2MNPyQ,461
+ybox/conf/resources/entrypoint-cp.sh,sha256=jemWFCqfme9blVtfVxqBzCsCp7b-bN2aFLajruF0GGQ,814
+ybox/conf/resources/entrypoint-root.sh,sha256=58xcDX58ZtEFSr7ZSUFmzKt1OyGU29OrxjOmDiR6V8Q,706
+ybox/conf/resources/entrypoint-user.sh,sha256=Tps_UyQGyGn30LbgKm3gpzZtjOHnJpnlKx-px2GAd7A,698
+ybox/conf/resources/entrypoint.sh,sha256=jbfFfUprU7ycp0moZLXNdnxk_bhtDxAk6byEiPMNz-s,8560
+ybox/conf/resources/prime-run,sha256=en8wEspc2Hzod9rq8KKnPQrjIPTLjUk44TqmtX-g0sw,339
+ybox/conf/resources/run-in-dir,sha256=-Xnwp4n6TK_2yPeBhGX6agenztyOtZ0316-vUlfOIag,2299
+ybox/conf/resources/run-user-bash-cmd,sha256=LMlPoHtzYNDcOI885ouBha9xGRnQ6AWCFVsSu2dxy10,1065
+ybox/conf/resources/ybox-systemd.template,sha256=bA-bJOmc07Be-mQYtoFzl0yq4SJACv-FkAoKscPTh3g,779
+ybox/migrate/0.9.0-0.9.10:0.9.11.py,sha256=WHvIWvUhXnruzSYwWYnv2zPNOlkXfAyaaJ_nZwG2wwE,1627
+ybox/pkg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ybox/pkg/clean.py,sha256=UlsrJLfZOyKg-7BE8s9xPvAyuUXSwvU5x-E7MMjGJSE,1219
+ybox/pkg/info.py,sha256=HoEsiAi-iPEnAOWBMy9SsA4TOfyqHonRURU8k5EeAWA,1607
+ybox/pkg/inst.py,sha256=wxFJo1GNrUGyjIqtEtOc_44Ty7zdZKj-qHcs9RdZudQ,36912
+ybox/pkg/list.py,sha256=Sk5THAmF132HKEZxJVDlqLLR8Z2w1wRA_E-gBsxlesQ,10097
+ybox/pkg/mark.py,sha256=Hb1FaowdBx8x3GFcakXsq4ERNqI60Gjljr24qXsDGR8,3748
+ybox/pkg/repair.py,sha256=rCwXXJbilJYU73feIIVWGFdbkh6SDcquxgiEnYV6pNs,8080
+ybox/pkg/repo.py,sha256=25gQgGMPeHgX83iqqWXyG6V6rIZ4i_KEnIbNG-CrxTk,13677
+ybox/pkg/search.py,sha256=GKfonxCLHtH-kojZpRJlRfe0qf768wUehVv20nM4lKY,2526
+ybox/pkg/uninst.py,sha256=ndqZ_WYr9HE5jVL1tQ_tTmSPyTFM6OJRCTLLmG-Qm4w,5338
+ybox/pkg/update.py,sha256=M-1MC8oh-baTHdSPWUUSTU_AhN3eu2nTCSge3bb6GmI,3269
+ybox/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ybox/run/cmd.py,sha256=a77RMC14Vovx2NV3LgdAzXVZXStC1TucgjcHPz4x03A,2105
+ybox/run/control.py,sha256=Lvew2tqtWy5xcZMPXuh5sTrM2K92MykXfdMfBuKsIDc,7540
+ybox/run/create.py,sha256=N2ULSoBsMWamBcm_JMLeZQdvMPhilhzFeM1aMkPDw7s,73062
+ybox/run/destroy.py,sha256=i3N2zRCgrQM_lGA6W28O6Y-D1NIwBP64PA1e6vhOkL4,6315
+ybox/run/graphics.py,sha256=mKQFU0la83Rv2V5l9TS25KIbqYmMnZjGQgGghLlfQp8,20309
+ybox/run/logs.py,sha256=pIdMWgNBNl-MgixArbMryUuBNNbi5JvDFP62IZ7jwr8,2050
+ybox/run/ls.py,sha256=7ylyxOOYEsVWK8baM0GaZcUlVQBwpdGiF7EhU09xf2s,2787
+ybox/run/pkg.py,sha256=6pes_wpVmPDiFYGfr8568GpyMByzor4dK5DSWaYmdsE,27219
+ybox/schema/0.9.1-added.sql,sha256=1rGp2DczZmmC_xwjmheeZNPSbDpFzasu6LO3tpTy3zI,1049
+ybox/schema/0.9.6-added.sql,sha256=Qcho6dP5OUpPUW3IBWl_kv88agMPHzueUAKqnZPnt3U,809
+ybox/schema/init.sql,sha256=fei8lPvjb-EIjm5zuA_XkEdjsIE3vtROhgRPt7QMlSs,1599
+ybox/schema/migrate/0.9.0:0.9.1.sql,sha256=e9JGwrjFZXdWKGv2JQZlKcWz8DmOuUARpToSsCyiksQ,1555
+ybox/schema/migrate/0.9.1:0.9.2.sql,sha256=X5J3unDS0eLeVvYKxQgx-iUBoAOk9T2suO34pWlQ-lE,362
+ybox/schema/migrate/0.9.2:0.9.3.sql,sha256=Y7GeBSuEEs7Hs9hh-KYDARgeeMgwQwercvTB5P_-k6I,102
+ybox/schema/migrate/0.9.5:0.9.6.sql,sha256=wqYhmputlUQzBI5zfP7O5kqIFWAbZQ05kolyHK4714A,70
+ybox-0.9.11.dist-info/licenses/LICENSE,sha256=7GbFgERMXSwD1VyLA5bo_XHvJipmNEUhDW5Sy51TFeY,1077
+ybox-0.9.11.dist-info/METADATA,sha256=64TAyPzQLQVg4KBazcBTshFP8OPYS5D1npAgIvu9QDQ,25772
+ybox-0.9.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ybox-0.9.11.dist-info/entry_points.txt,sha256=xDlI_84Hl3ytYO_ERyt0rkJ4ioUF8Z1r49Hx1xL28Rk,243
+ybox-0.9.11.dist-info/top_level.txt,sha256=DYX7jvndHcBaJXLJ8vDyKrq0_KWoSeXXFq8r0d5L6Nk,5
+ybox-0.9.11.dist-info/RECORD,,