ybox 0.9.8__py3-none-any.whl

ybox/__init__.py

@@ -0,0 +1,2 @@
+"""`ybox` is a tool to easily manage linux distributions in containers"""
+__version__ = "0.9.8"

ybox/cmd.py

@@ -0,0 +1,307 @@
+"""
+Utilities related to command execution like running a command, get podman/docker executable etc.
+"""
+
+import argparse
+import errno
+import shlex
+import subprocess
+import sys
+from enum import Enum
+from typing import Callable, Iterable, Optional, Union
+
+from ybox.config import Consts
+
+from .print import print_error, print_info, print_notice, print_warn
+
+
+class PkgMgr(str, Enum):
+    """
+    Package manager actions that are defined for each Linux distribution in its distro.ini file.
+    """
+    INSTALL = "install"
+    CHECK_AVAIL = "check_avail"
+    CHECK_INSTALL = "check_install"
+    QUIET_FLAG = "quiet_flag"
+    QUIET_DETAILS_FLAG = "quiet_details_flag"
+    OPT_DEPS = "opt_deps"
+    OPT_DEP_FLAG = "opt_dep_flag"
+    UNINSTALL = "uninstall"
+    PURGE_FLAG = "purge_flag"
+    REMOVE_DEPS_FLAG = "remove_deps_flag"
+    ORPHANS = "orphans"
+    UPDATE_META = "update_meta"
+    UPDATE = "update"
+    UPDATE_ALL = "update_all"
+    CLEAN = "clean"
+    CLEAN_QUIET = "clean_quiet"
+    MARK_EXPLICIT = "mark_explicit"
+    INFO = "info"
+    INFO_ALL = "info_all"
+    LIST = "list"
+    LIST_ALL = "list_all"
+    LIST_LONG = "list_long"
+    LIST_ALL_LONG = "list_all_long"
+    LIST_FILES = "list_files"
+    SEARCH = "search"
+    SEARCH_ALL = "search_all"
+    SEARCH_OFFICIAL_FLAG = "search_official_flag"
+    SEARCH_WORD_START_FLAG = "search_word_start_flag"
+    SEARCH_WORD_END_FLAG = "search_word_end_flag"
+    PROCESSES_PATTERN = "processes_pattern"
+    LOCKS_PATTERN = "locks_pattern"
+    REPAIR = "repair"
+    REPAIR_ALL = "repair_all"
+
+
+class RepoCmd(str, Enum):
+    """
+    Repository management actions defined for each Linux distribution in its distro.ini file.
+    """
+    EXISTS = "exists"
+    DEFAULT_GPG_KEY_SERVER = "default_gpg_key_server"
+    ADD_KEY = "add_key"
+    ADD_KEY_ID = "add_key_id"
+    ADD = "add"
+    ADD_SOURCE = "add_source"
+    REMOVE_KEY = "remove_key"
+    REMOVE = "remove"
+
+
+class YboxLabel(str, Enum):
+    """
+    Labels for ybox created objects.
+    """
+    CONTAINER_LABEL_GROUP = "io.ybox.container"
+    CONTAINER_TYPE = f"{CONTAINER_LABEL_GROUP}.type"
+    CONTAINER_DISTRIBUTION = f"{CONTAINER_LABEL_GROUP}.distribution"
+
+    # ybox container types (first two are temporary ones)
+    CONTAINER_BASE = f"{CONTAINER_TYPE}=base"
+    CONTAINER_COPY = f"{CONTAINER_TYPE}=copy"
+    CONTAINER_PRIMARY = f"{CONTAINER_TYPE}=primary"
+
+
+def get_ybox_state(docker_cmd: str, box_name: str, expected_states: Iterable[str],
+                   exit_on_error: bool = False, state_msg: str = "") -> tuple[str, str]:
+    """
+    Check if the given ybox container exists and is in one of the given states, or get the state
+    if the given `expected_states` is empty.
+
+    :param docker_cmd: the podman/docker executable to use
+    :param box_name: name of the ybox container
+    :param expected_states: Iterable of one or more expected states like 'running', 'exited';
+                            empty value means any state is permissible which is returned
+    :param exit_on_error: whether to exit using `sys.exit` if the check fails
+    :param state_msg: string to be inserted in the error message "No...ybox container ..."
+                      when `exit_on_error` is false, so this should be a display name for the
+                      `expected_states` with a space at the start e.g. ' active', ' stopped'
+    :return: if `exit_on_error` is False, then return a tuple of (state, distribution) of the
+             container if it was in the set of `expected_states` or if `expected_states` was empty
+    """
+    check_result = subprocess.run(
+        [docker_cmd, "inspect", "--type=container", '--format={{index .Config.Labels "' +
+         YboxLabel.CONTAINER_TYPE.value + '"}} {{index .Config.Labels "' +
+         YboxLabel.CONTAINER_DISTRIBUTION.value + '"}} {{.State.Status}}', box_name],
+        check=False, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+    if check_result.returncode != 0:
+        if exit_on_error:
+            print_error(f"No{state_msg} ybox container '{box_name}' found")
+            sys.exit(check_result.returncode)
+        return tuple[str, str]()
+    result = check_result.stdout.decode("utf-8").split()
+    if len(result) == 3 and result[0] == "primary":
+        distribution = result[1]
+        state = result[2]
+        if not expected_states or state in expected_states:
+            return (state, distribution)
+        if exit_on_error:
+            print_error(f"Unexpected state for ybox container '{box_name}': {state}")
+            sys.exit(1)
+        return tuple[str, str]()
+    if exit_on_error:
+        print_error(f"Container '{box_name}' not a ybox container!")
+        sys.exit(1)
+    return tuple[str, str]()
+
+
+def check_active_ybox(docker_cmd: str, box_name: str, exit_on_error: bool = False) -> bool:
+    """
+    Check if the given ybox container is up and running.
+
+    :param docker_cmd: the podman/docker executable to use
+    :param box_name: name of the ybox container
+    :param exit_on_error: whether to exit using `sys.exit` if the check fails
+    :return: if `exit_on_error` is False, then return the result of verification as True or False
+    """
+    return bool(get_ybox_state(docker_cmd, box_name, expected_states=("running",),
+                               exit_on_error=exit_on_error, state_msg=" active"))
+
+
+def check_ybox_exists(docker_cmd: str, box_name: str, exit_on_error: bool = False) -> bool:
+    """
+    Check if the given ybox container exists in either active or inactive state.
+
+    :param docker_cmd: the podman/docker executable to use
+    :param box_name: name of the ybox container
+    :param exit_on_error: whether to exit using `sys.exit` if the check fails
+    :return: if `exit_on_error` is False, then return the result of verification as True or False
+    """
+    return bool(get_ybox_state(docker_cmd, box_name, expected_states=(),
+                               exit_on_error=exit_on_error))
+
+
+def build_shell_command(docker_cmd: str, box_name: str, cmd: str,
+                        enable_pty: bool = True) -> list[str]:
+    """
+    Build a podman/docker command (as a list) to be run using `run-user-bash-cmd` in the given
+    ybox container (that in turn runs the command as non-root user using `sudo` with `/bin/bash`).
+
+    :param docker_cmd: the podman/docker executable to use
+    :param box_name: name of the ybox container
+    :param cmd: the command to be run in the container
+    :param enable_pty: if True then enable pseudo-pty allocation for the `podman/docker exec`
+                       command and set interactive mode else no pty is allocated, defaults to True
+    :return: command to be executed (e.g. in `subprocess`) as a list of strings
+    """
+    shell = f"/usr/local/bin/{Consts.run_user_bash_cmd()}"
+    if enable_pty:
+        return [docker_cmd, "exec", "-it", box_name, shell, cmd]
+    return [docker_cmd, "exec", box_name, shell, cmd]
+
+
+def run_command(cmd: Union[str, list[str]], capture_output: bool = False,
+                exit_on_error: bool = True, error_msg: Optional[str] = None) -> Union[str, int]:
+    """
+    Helper wrapper around `subprocess.run` to display failure message (in red foreground color)
+    for the case of failure, exit on failure and capturing and returning output if required.
+
+    :param cmd: the command to be run which can be either a list of strings, or a single string
+                which will be split like done by unix shell using `shlex.split`
+    :param capture_output: if True then capture stdout and return it but stderr is still displayed
+                           on screen using `print_warn` method in purple foreground color
+    :param exit_on_error: whether to exit using `sys.exit` if command fails
+    :param error_msg: string to be inserted in error message "FAILURE in ..." so should be a
+                      user-friendly name of the action that the command was supposed to do;
+                      if not specified then the entire command string is displayed;
+                      the special value 'SKIP' can be used to skip printing any error message
+    :return: the captured standard output if `capture_output` is true and command is successful
+             encoded as UTF-8 string else the return code of the command as an integer
+             (if `exit_on_error` is False)
+    """
+    args = shlex.split(cmd) if isinstance(cmd, str) else cmd
+    try:
+        result = subprocess.run(args, capture_output=capture_output, check=False)
+    except OSError as err:
+        if exit_on_error:
+            raise  # an unexpected internal issue, so keep the full stack trace
+        print_error(f"FAILURE invoking '{cmd}': {err}")
+        return err.errno or errno.ENOENT
+    if result.returncode != 0:
+        _print_subprocess_output(result)
+        if not error_msg:
+            error_msg = f"'{cmd}'"
+        if error_msg != "SKIP":
+            print_error(f"FAILURE in {error_msg} -- see the output above for details")
+        if exit_on_error:
+            sys.exit(result.returncode)
+        else:
+            return result.returncode
+    if capture_output and result.stderr:
+        print_warn(result.stderr.decode("utf-8"), file=sys.stderr)
+    return result.stdout.decode("utf-8") if capture_output else result.returncode
+
+
+def _print_subprocess_output(result: subprocess.CompletedProcess[bytes]) -> None:
+    """print completed subprocess output in color (orange for standard output and purple
+       for standard error)"""
+    if result.stdout:
+        print_notice(result.stdout.decode("utf-8"))
+    if result.stderr:
+        print_warn(result.stderr.decode("utf-8"), file=sys.stderr)
+
+
+def parse_opt_deps_args(argv: list[str]) -> argparse.Namespace:
+    """
+    Common command-line parser for `opt_deps` utilities (see [pkgmgr] section of distro.ini)
+    that parses given arguments for the program and returns the result :class:`argparse.Namespace`.
+
+    :param argv: the list of arguments to be parsed
+    :return: the result of parsing using the `argparse` library as a :class:`argparse.Namespace`
+    """
+    parser = argparse.ArgumentParser(
+        description="Recursively find optional dependencies of a package")
+    # default separator is something that does not appear in descriptions (at least so far)
+    parser.add_argument("-s", "--separator", type=str, default="::::",
+                        help="separator to use between the columns")
+    parser.add_argument("-p", "--prefix", type=str, default="",
+                        help="prefix string before each line of result")
+    parser.add_argument("-H", "--header", type=str, default="",
+                        help="header line to print before the results (without trailing newline)")
+    parser.add_argument("-l", "--level", type=int, default=2,
+                        help="maximum level to search for optional dependencies")
+    parser.add_argument("package", type=str, help="name of the package")
+    return parser.parse_args(argv)
+
+
+def page_output(output: Iterable[bytes], pager: str) -> int:
+    """
+    Display an `Iterable` of bytes on the terminal one screenful at a time using the given `pager`.
+
+    :param output: the `Iterable` of `bytes` to be displayed (e.g. file/stream object, `list` etc)
+    :param pager: the command to be executed for pagination as a separate process with any
+                  arguments that are required; the arguments are split using :func:`shlex.split`
+                  so you can use shell-like quoting/escaping if they have spaces
+    :return: the exit code of the `pager` command
+    """
+    if not pager:
+        for out in output:
+            sys.stdout.write(out.decode("utf-8"))
+        sys.stdout.flush()
+        return 0
+    try:
+        with subprocess.Popen(shlex.split(pager), stdin=subprocess.PIPE) as page_in:
+            assert page_in.stdin is not None
+            for out in output:
+                page_in.stdin.write(out)
+            page_in.communicate()
+            return page_in.returncode
+    except BrokenPipeError:
+        return 0  # this can happen if pager ends (e.g. using 'q' in less)
+    except OSError as err:
+        print_error(f"FAILURE invoking pager '{pager}': {err}")
+        return err.errno or errno.ENOENT
+    except KeyboardInterrupt:
+        # fail cleanly for user interrupt in the pager
+        print()
+        print_info("Interrupt")
+        return 130  # see https://tldp.org/LDP/abs/html/exitcodes.html
+
+
+def page_command(cmd: Union[str, list[str]], pager: str, error_msg: Optional[str] = None,
+                 transform: Optional[Callable[[str], str]] = None, header: str = "") -> int:
+    """
+    Execute a given command using `subprocess.run` and show its output one screenful at a time
+    as UTF-8 string using the given `pager` command. In case of failure of either the command
+    or the `pager`, a failure message is shown and the exit code of the failed process is returned.
+
+    :param cmd: the command to be run which can be either a list of strings, or a single string
+                which will be split like done by unix shell using `shlex.split`
+    :param pager: the command to be executed for pagination as a separate process,
+                  or empty to skip pagination
+    :param error_msg: string to be inserted in error message "FAILURE in ..." so should be a
+                      user-friendly name of the action that the command was supposed to do;
+                      if not specified then the entire command string is displayed;
+                      the special value 'SKIP' can be used to skip printing any error message
+    :param transform: optional function to apply to the output of command before pagination
+    :param header: header to be inserted at the start of output, default is empty string
+    :return: the exit code of `cmd` if it failed else the exit code of the `pager` command
+    """
+    result = run_command(cmd, capture_output=True, exit_on_error=False, error_msg=error_msg)
+    if isinstance(result, int):
+        return result
+    if not result:
+        return 0
+    result_bytes = transform(result).encode("utf-8") if transform else result.encode("utf-8")
+    output = (header.encode("utf-8"), result_bytes) if header else (result_bytes,)
+    return page_output(output, pager)

ybox/conf/completions/ybox.fish

@@ -0,0 +1,93 @@
+# Completions for ybox commands, a "Manage containers hosting Linux distributions and apps"
+
+function __fish_ybox_complete_containers
+  /usr/bin/python3 (type -p ybox-ls) --format="{{ .Names }}"
+end
+
+function __fish_ybox_complete_all_containers
+  /usr/bin/python3 (type -p ybox-ls) --all --format="{{ .Names }}"
+end
+
+function __fish_ybox_complete_stopped_containers
+  /usr/bin/python3 (type -p ybox-ls) --filter="status=exited" --format="{{ .Names }}"
+end
+
+function __fish_ybox_complete_distributions
+  set user_supported ~/.config/ybox/distros/supported.list
+  set sys_supported ~/.local/lib/python3*/site-packages/ybox/conf/distros/supported.list
+  set local_supported src/ybox/conf/distros/supported.list
+  if test -r "$user_supported"
+    /usr/bin/cat $user_supported
+  else if test -r "$sys_supported" 2>/dev/null
+    /usr/bin/cat $sys_supported
+  else if test -r "$local_supported" 2>/dev/null
+    /usr/bin/cat $local_supported
+  end
+end
+
+
+complete -f -c ybox-create -s h -l help -d "show help"
+complete -c ybox-create -s n -l name -d "name of the ybox container" -r
+complete -f -c ybox-create -s F -l force-own-orphans -d "force ownership of orphans on shared root"
+complete -f -c ybox-create -s q -l quiet -d "skip interactive questions"
+complete -f -c ybox-create -n "not __fish_seen_subcommand_from (__fish_ybox_complete_distributions)" -a "(__fish_ybox_complete_distributions)"
+
+
+complete -f -c ybox-destroy -s h -l help -d "show help"
+complete -f -c ybox-destroy -s f -l force -d "force destroy the container using SIGKILL if required"
+complete -f -c ybox-destroy -n "not __fish_seen_subcommand_from (__fish_ybox_complete_all_containers)" -a "(__fish_ybox_complete_all_containers)"
+
+complete -f -c ybox-logs -s h -l help -d "show help"
+complete -f -c ybox-logs -s f -l follow -d "follow log output like 'tail -f'"
+complete -f -c ybox-logs -n "not __fish_seen_subcommand_from (__fish_ybox_complete_all_containers)" -a "(__fish_ybox_complete_all_containers)"
+
+
+complete -f -c ybox-ls -s h -l help -d "show help"
+complete -f -c ybox-ls -s a -l all -d "show all containers including stopped"
+complete -f -c ybox-ls -s f -l filter -d "filter in <key>=<value> format" -r
+complete -f -c ybox-ls -s s -l format -d "format output using a JSON/Go template string" -r
+complete -f -c ybox-ls -s l -l long-format -d "show more extended information"
+
+
+complete -c ybox-cmd -s h -l help -d "show help"
+complete -c ybox-cmd -n "not __fish_seen_subcommand_from (__fish_ybox_complete_containers)" -a "(__fish_ybox_complete_containers)" -f
+
+
+# define subcommands for ybox-control
+set -l control_commands start stop restart status
+complete -c ybox-control -f
+# common options for all ybox-control subcommands
+complete -c ybox-control -s h -l help -d "show help"
+# available subcommands for ybox-control with descriptions
+complete -c ybox-control -n "not __fish_seen_subcommand_from $control_commands" -a start -d "start an inactive ybox container"
+complete -c ybox-control -n "not __fish_seen_subcommand_from $control_commands" -a stop -d "stop an active ybox container"
+complete -c ybox-control -n "not __fish_seen_subcommand_from $control_commands" -a restart -d "restart a ybox container"
+complete -c ybox-control -n "not __fish_seen_subcommand_from $control_commands" -a status -d "show status of a ybox container"
+# define arguments for individual subcommands using the "-n" option for the subcommand
+complete -c ybox-control -n "__fish_seen_subcommand_from start" -a "(__fish_ybox_complete_stopped_containers)"
+complete -c ybox-control -n "__fish_seen_subcommand_from stop" -a "(__fish_ybox_complete_containers)"
+complete -c ybox-control -n "__fish_seen_subcommand_from restart" -a "(__fish_ybox_complete_all_containers)"
+complete -c ybox-control -n "__fish_seen_subcommand_from status" -a "(__fish_ybox_complete_all_containers)"
+
+
+# define subcommands for ybox-pkg
+set -l pkg_commands install uninstall update list list-files info search mark clean repair
+complete -c ybox-pkg -f
+# common options for all ybox-pkg subcommands
+complete -c ybox-pkg -s h -l help -d "show help"
+complete -c ybox-pkg -s z -l ybox -d "ybox container to use for package operation" -rfa "(__fish_ybox_complete_containers)"
+complete -c ybox-pkg -s C -l distribution-config -d "path to distribution configuration file" -rF
+complete -c ybox-pkg -s q -l quiet -d "proceed without asking any questions using defaults"
+# available subcommands for ybox-pkg with descriptions
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a install -d "install a package with dependencies"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a uninstall -d "uninstall a package and optionally its dependencies"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a update -d "update some or all packages"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a list -d "list installed packages"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a list-files -d "list files of an installed package"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a info -d "show detailed information of package(s)"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a search -d "search repositories"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a mark -d "mark package as dependency or explicitly installed"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a clean -d "clean package cache"
+complete -c ybox-pkg -n "not __fish_seen_subcommand_from $pkg_commands" -a repair -d "try to repair package state"
+# define arguments for individual subcommands using the "-n" option for the subcommand
+complete -c ybox-pkg -n "__fish_seen_subcommand_from install" -s o -l skip-opt-deps -d "skip optional dependencies"

ybox/conf/distros/arch/add-gpg-key.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# this script fetches a GPG/PGP key file from a URL and adds the key to pacman
+
+set -e
+
+# Check if all arguments are provided
+if [ $# -ne 1 ]; then
+  echo "Usage: $0 <url>"
+  exit 1
+fi
+
+# ensure that only system paths are searched for all the system utilities
+export PATH="/usr/sbin:/usr/bin:/sbin:/bin"
+
+file="$(mktemp /tmp/gpg-key-XXXXXXXXXX)"
+
+trap "rm -f $file" 0 1 2 3 15
+
+curl -sSL "$1" -o "$file"
+KEYIDS="$(gpg --show-keys --with-colons "$file" | sed -n 's/^fpr:*\([^:]*\).*/\1/p' | tr '\n' ' ')"
+sudo pacman-key --add "$file"
+
+for keyid in $KEYIDS; do
+  sudo pacman-key --lsign-key $keyid
+done
+echo "KEYID=$KEYIDS"
+
+exit 0

ybox/conf/distros/arch/distro.ini

@@ -0,0 +1,192 @@
+# Configuration specific to each distribution (INI style file)
+
+# The following environment variables are set when running the init.sh and init-user.sh scripts.
+# The scripts are required to honor the meaning of the corresponding variables as described in
+# their comments.
+#   CONFIGURE_FASTEST_MIRRORS: empty or non-empty corresponding to configure_fastest_mirrors below
+#   REQUIRED_PKGS: packages specified in `packages.required` below
+#   REQUIRED_DEPS: packages specified in `packages.required_deps` below
+#   RECOMMENDED_PKGS: packages specified in `packages.recommended` below
+#   RECOMMENDED_DEPS: packages specified in `packages.recommended_deps` below
+#   SUGGESTED_PKGS: packages specified in `packages.suggested` below
+#   SUGGESTED_DEPS: packages specified in `packages.suggested_deps` below
+#   EXTRA_PKGS: packages specified in `packages.extra` below
+
+
+# Base configuration for the distribution
+[base]
+# name is required
+name = Arch Linux
+# Comma separated files to include before applying these settings.
+# Paths can be absolute or relative to the location of this file.
+includes =
+# points to the daily updated image to minimize upgrade size
+image = quay.io/archlinux/archlinux
+# directories which are shared between the containers of a distribution when
+# `shared_root` is provided in the container configuration
+shared_root_dirs = /etc,/opt,/usr,/var
+# the secondary groups of the container user; it requires to include at least the equivalent of
+# nobody/nogroup to work correctly (the last field in /etc/subgid)
+secondary_groups = nobody,wheel,video,input,lp,mail
+# whether to search for and configure fastest available mirrors for packages
+configure_fastest_mirrors = true
+# distribution scripts that need to be copied to the container in $YBOX_TARGET_SCRIPTS_DIR
+# (should include init.sh, init-base.sh and init-user.sh scripts that are are normally required
+# for all distributions)
+scripts = init-base.sh,init.sh,init-user.sh,pkgdeps.py,list_fmt_long.py,add-gpg-key.sh
+
+
+# Initial set of packages to be installed in the distribution image
+[packages]
+# packages required for a functional ybox container
+required = base-devel python-ijson expac lesspipe
+# dependencies of the `required` packages
+required_deps = git ed unzip fastjar
+# recommended packages required for many GUI/CLI apps to work properly
+recommended = aria2 bash-completion bc man-db man-pages pulseaudio-alsa zip wget shared-mime-info
+              libva-utils mesa-utils vulkan-tools ttf-liberation
+# dependencies of the `recommended` packages
+recommended_deps = intel-media-driver libva-mesa-driver vulkan-intel vulkan-mesa-layers python-pip
+# optional packages for enhanced experience in shell and GUI apps
+# (for some reason TERMINFO_DIRS does not work for root user, so explicitly installing terminfo
+#  packages for other terminal emulators available in arch which occupy only a tiny space)
+suggested = cantarell-fonts ttf-fira-code noto-fonts neovim eza ncdu fd bat
+            kitty-terminfo rxvt-unicode-terminfo realtime-privileges tree starship
+# dependencies of the `suggested` packages
+suggested_deps = xsel
+# additional packages that are in AUR and installed by paru in init-user.sh
+extra = neovim-symlinks tinyxxd autojump
+
+
+# The commands here will be run as normal userns mapped user, so use sudo if the command
+# needs to run as root inside the container
+[pkgmgr]
+# the variables here are all required ones unless noted otherwise
+
+# install command does not have a placeholder for {package} since it is also used by
+# entrypoint scripts to install packages, so this assumes that this command accepts a list of one
+# or more space-separated packages at the end
+install = /usr/bin/paru -S --needed --removemake --cleanafter {quiet} {opt_dep}
+# Show the packages that satisfy the given {package} where latter can be a virtual package
+# (i.e. "Provides") or an actual package or a combination of both (e.g. some packages provide and
+#  replace another actual package).
+# Not required for Arch since install command itself shows the selection if required.
+check_avail
+# check an installed actual or virtual (i.e. "Provides") package and list them in reverse
+# install/upgrade time order (i.e. most recently installed/upgraded first)
+check_install = /usr/bin/expac -Qs --timefmt=%%s '%%l\t%%n' '^{package}$' | \
+                /usr/bin/sort -nr | /usr/bin/cut -f2
+# proceed quietly without asking questions
+quiet_flag = --noconfirm
+# this is substituted for `{quiet}` placeholder in `info`, `info_all`, `search` and `search_all`
+quiet_details_flag = -q
+# --asdeps works correctly only if an optional dependency is actually marked to be so in
+# the arch package, but will cause trouble for cases where user wants to mark a package as
+# an optional dependency of another even otherwise (e.g. qt5ct as optional dependency of qt5-base)
+# opt_dep_flag = --asdeps
+opt_dep_flag =
+# Expected output of the `opt_deps` command is:
+# {header}
+# {prefix}<name>{separator}<level>{separator}<installed>{separator}<description>
+# where
+# <name>: name of the optional dependency
+# <level>: level of the dependency i.e. 1 for direct dependency, 2 for dependency of dependency and
+#          so on; resolution of level > 2 is not required since caller currently ignores those
+# <installed>: true if the dependency already installed and false otherwise
+opt_deps = /usr/bin/python3 $YBOX_TARGET_SCRIPTS_DIR/pkgdeps.py \
+           -s '{separator}' -p '{prefix}' -H '{header}'
+uninstall = /usr/bin/paru -R {quiet} {purge} {remove_deps} {package}
+purge_flag = --nosave
+remove_deps_flag = --recursive
+orphans = /usr/bin/pacman -Qdtq
+update_meta = /usr/bin/paru -Sy
+update = /usr/bin/paru -S --needed --removemake --cleanafter {quiet} {packages}
+update_all = /usr/bin/paru -Syu --removemake --cleanafter {quiet}
+clean = /usr/bin/paru -Sccd
+clean_quiet = /bin/yes | %(clean)s
+mark_explicit = /usr/bin/paru -D --asexplicit {package}
+
+info = /usr/bin/pacman -Qi {quiet} {packages}
+info_all = /usr/bin/paru -Si {quiet} {packages}
+
+# next two variables are not required ones rather are used for expansion in list variables
+# to avoid repetition
+list_fmt = /usr/bin/sed 's/^\([^[:space:]]*\)[[:space:]]\+/\1{separator}/'
+list_fmt_long = /usr/bin/python3 $YBOX_TARGET_SCRIPTS_DIR/list_fmt_long.py '{separator}'
+
+# list and list_all show package name and version separated by {separator}; the list command only
+# shows explicitly installed packages while the "_all" variant also shows dependents
+list = /usr/bin/pacman -Qe {packages} | %(list_fmt)s
+list_all = /usr/bin/pacman -Q {packages} | %(list_fmt)s
+# list_long and list_all_long show package name, version, dependency-of and description separated
+# by {separator}; the dependency-of column gives the required and optional dependencies in the
+# format: req(<pkg> <pkg> ...),opt(<pkg> <pkg> ...); like above the "_all" variant shows all
+# packages including dependents while other one shows only explicitly installed ones
+list_long = /usr/bin/pacman -Qie {packages} | %(list_fmt_long)s
+list_all_long = /usr/bin/pacman -Qi {packages} | %(list_fmt_long)s
+
+list_files = /usr/bin/pacman -Qlq {package}
+
+# next five variables are not required ones rather are used for expansion in search variables
+
+# --searchby=name only applies to the AUR packages, so filter out packages where only the package
+# names match; the weird "set ..." subcommand converts space-separated quoted arguments into a
+# regex i.e. ' one ' 'two' ' three' to " one |two | three" which is accomplished by declaring
+# those arguments as positional arguments $1, $2 etc, then echo all arguments with IFS as "|"
+args_re = "$(set -- {search}; IFS="|"; echo "$*")"
+# word matching works correctly after removing color codes, but keep those in the final output
+search_filter_prefix = /usr/bin/gawk 'BEGIN {{ IGNORECASE=1 }} /^[^[:space:]].*/ {{
+                           pkg = $0; gsub(/\x1B\[[0-9;]+m/, ""); pkg_nc = $0; getline; '
+search_filter_suffix = 'if (pkg_nc ~ /{word_start}('%(args_re)s'){word_end}/) print pkg"\n"$0 }}'
+name_filter = %(search_filter_prefix)s%(search_filter_suffix)s
+all_filter = %(search_filter_prefix)s'pkg_nc = pkg_nc $0; '%(search_filter_suffix)s
+
+# search in package names in the repositories
+search = /usr/bin/paru -Ss {quiet} {official} --searchby=name --sortby=popularity --color=always \
+         {search} | %(name_filter)s
+# search in package names and descriptions in the repositories
+search_all = /usr/bin/paru -Ss {quiet} {official} --sortby=popularity --color=always \
+             {search} | %(all_filter)s
+# this is substituted for `{official}` placeholder in `search` and `search_all`
+search_official_flag = --repo
+# this is substituted for `{word_start}` placeholder in `search` and `search_all`
+search_word_start_flag = \<
+# this is substituted for `{word_end}` placeholder in `search` and `search_all`
+search_word_end_flag = \>
+
+# regex pattern matching processes that may be invoked by package manager directly or indirectly
+# that may need to be terminated for cleanup
+processes_pattern = \b(pacman|paru|keyboxd|dirmngr)\b
+# comma separated globs for package manager related lock files (no spaces in names or within)
+locks_pattern = /var/lib/pacman/db.lck,$HOME/.gnupg/public-keys.d/*.lock
+repair = /usr/bin/paru -Syyuu {quiet}
+# reinstall all packages
+repair_all = %(repair)s && (/usr/bin/pacman -Qqn | /usr/bin/paru -S {quiet} -) && \
+             (/usr/bin/pacman -Qqm | /usr/bin/paru -S {quiet} -) && %(clean_quiet)s
+
+
+# Commands related to repository management
+[repo]
+conf_file = /etc/pacman.conf
+exists = /usr/bin/grep -q '^[[:space:]]*\[{name}\][[:space:]]*$' %(conf_file)s
+# Ubuntu's keyserver is more reliable than the standard gnupg.net/pgp.net ones
+default_gpg_key_server = hkps://keyserver.ubuntu.com
+# output of the `add_key` command should have a line of the form "KEYID=..." that provides the
+# registered keys that can be passed to `remove_key`
+add_key = /bin/bash $YBOX_TARGET_SCRIPTS_DIR/add-gpg-key.sh '{url}'
+add_key_id = /usr/bin/sudo /usr/bin/pacman-key --keyserver '{server}' --recv-keys '{key}' && \
+             /usr/bin/sudo /usr/bin/pacman-key --lsign-key '{key}'
+# additional options if supported should be mentioned using {options} below
+add = /bin/echo '[{name}],{urls}' | /usr/bin/sed 's/,/\nServer = /g' | \
+      /usr/bin/sudo /usr/bin/tee -a %(conf_file)s
+# if source repository is supported, then it should be provided in `add_source` like for `add`
+add_source
+remove_key = /usr/bin/sudo /usr/bin/pacman-key --delete {key}
+# The sed pattern below removes the [{name}] section from pacman.conf
+# (S_PAT matches start of the section while E_PAT matches next section which has to be retained).
+# If source repositories are supported in `add_source` command above, then {remove_source} boolean
+# should be checked to remove source repository too.
+rm_s_pat = ^[[:space:]]*\[{name}\][[:space:]]*$
+rm_e_pat = ^[[:space:]]*\[.*
+remove = /usr/bin/sudo /usr/bin/sed -i \
+         '/%(rm_s_pat)s/,/%(rm_e_pat)s/ {{/%(rm_s_pat)s/d;/%(rm_e_pat)s/!d;}}' %(conf_file)s

ybox/conf/distros/arch/init-base.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+# disable the sandbox in the newer pacman versions that does not work in container
+sed -i 's/^#[ ]*DisableSandbox/DisableSandbox/' /etc/pacman.conf
+# sudo is not present in the upstream archlinux image
+pacman -Sy
+pacman -S --noconfirm --needed sudo
+yes | pacman -Scc 2>/dev/null >/dev/null