Update dependency arch/python-textual to v8.2.7 (#4556)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.flake8

@@ -1,11 +1,8 @@
 [flake8]
 count = True
-# Several of the following could be autofixed or improved by running the code through psf/black
-ignore = E722,W191,W503
+ignore = W191,W503,E704,E203
 max-complexity = 40
-max-line-length = 220
+max-line-length = 160
 show-source = True
 statistics = True
-builtins = _
-per-file-ignores = __init__.py:E128,F401
 exclude = .git,__pycache__,build,docs,actions-runner

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: [archlinux]
+custom: ['https://archlinux.org/donate/']

.github/ISSUE_TEMPLATE/01_bug.yml

@@ -41,8 +41,8 @@ body:
     attributes:
       value: >
         **Note**: Assuming you have network connectivity,
-        you can easily post the installation log using the following command:
-        `curl -F'file=@/var/log/archinstall/install.log' https://0x0.st`
+        you can easily upload the installation log and get a shareable URL by running:
+        `archinstall share-log`
 
   - type: textarea
     id: freeform

.github/workflows/bandit.yaml

@@ -6,7 +6,7 @@ jobs:
         container:
             image: archlinux/archlinux:latest
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
             - run: pacman --noconfirm -Syu bandit
             - name: Security checkup with Bandit
               run: bandit -r archinstall || exit 0

.github/workflows/flake8.yaml

@@ -1,18 +1,18 @@
 on: [ push, pull_request ]
-name: flake8 linting (3 ignores)
+name: flake8 linting
 jobs:
     flake8:
         runs-on: ubuntu-latest
         container:
             image: archlinux/archlinux:latest
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
             - name: Prepare arch
               run: |
                 pacman-key --init
                 pacman --noconfirm -Sy archlinux-keyring
                 pacman --noconfirm -Syyu
-                pacman --noconfirm -Sy python-pip python-pyparted python-simple-term-menu pkgconfig gcc
+                pacman --noconfirm -Sy python-pip python-pyparted pkgconfig gcc
             - run: pip install --break-system-packages --upgrade pip
             # this will install the exact version of flake8 that is in the pyproject.toml file
             - name: Install archinstall dependencies

.github/workflows/github-pages.yml

@@ -21,16 +21,16 @@ jobs:
       image: archlinux/archlinux:latest
       options: --privileged
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
       - name: Install pre-dependencies
         run: |
-          pacman -Sy --noconfirm tree git python-pyparted python-simple-term-menu python-setuptools python-sphinx python-sphinx_rtd_theme python-build python-installer python-wheel
+          pacman -Sy --noconfirm tree git python-pyparted python-setuptools python-sphinx python-sphinx_rtd_theme python-build python-installer python-wheel
       - name: Sphinx build
         run: |
           sphinx-build docs _build
       - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v4
+        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4
         if: ${{ github.event_name != 'pull_request' }}
         with:
           publish_branch: gh-pages

.github/workflows/iso-build.yaml

@@ -26,14 +26,14 @@ jobs:
       image: archlinux/archlinux:latest
       options: --privileged
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
       - run: pwd
       - run: find .
       - run: cat /etc/os-release
       - run: pacman-key --init
       - run: pacman --noconfirm -Sy archlinux-keyring
-      - run: ./build_iso.sh
-      - uses: actions/upload-artifact@v4
+      - run: ./test_tooling/mkarchiso/build_iso.sh
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: Arch Live ISO
           path: /tmp/archlive/out/*.iso

.github/workflows/mypy.yaml

@@ -6,13 +6,13 @@ jobs:
         container:
             image: archlinux/archlinux:latest
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
             - name: Prepare arch
               run: |
                 pacman-key --init
                 pacman --noconfirm -Sy archlinux-keyring
                 pacman --noconfirm -Syyu
-                pacman --noconfirm -Sy python-pip python-pyparted python-simple-term-menu pkgconfig gcc
+                pacman --noconfirm -Sy python-pip python-pyparted pkgconfig gcc
             - run: pip install --break-system-packages --upgrade pip
             # this will install the exact version of mypy that is in the pyproject.toml file
             - name: Install archinstall dependencies

.github/workflows/pylint.yaml

@@ -6,15 +6,15 @@ jobs:
         container:
             image: archlinux/archlinux:latest
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
             - name: Prepare arch
               run: |
                 pacman-key --init
                 pacman --noconfirm -Sy archlinux-keyring
                 pacman --noconfirm -Syyu
-                pacman --noconfirm -Sy python-pip python-pyparted python-simple-term-menu pkgconfig gcc
+                pacman --noconfirm -Sy python-pip python-pyparted pkgconfig gcc
             - run: pip install --break-system-packages --upgrade pip
-            - name: Install Pylint and Pylint plug-ins
+            - name: Install Pylint
               run: pip install --break-system-packages .[dev]
             - run: python --version
             - run: pylint --version

.github/workflows/pytest.yaml

@@ -7,9 +7,15 @@ jobs:
             image: archlinux/archlinux:latest
             options: --privileged
         steps:
-            - uses: actions/checkout@v4
-            - run: pacman --noconfirm -Syu python python-pip qemu gcc
-            - run: python -m pip install --break-system-packages --upgrade pip
-            - run: pip install --break-system-packages pytest
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+            - name: Prepare arch
+              run: |
+                pacman-key --init
+                pacman --noconfirm -Sy archlinux-keyring
+                pacman --noconfirm -Syyu
+                pacman --noconfirm -Sy python-pip python-pyparted pkgconfig gcc
+            - run: pip install --break-system-packages --upgrade pip
+            - name: Install archinstall dependencies
+              run: pip install --break-system-packages .[dev]
             - name: Test with pytest
-              run: python -m pytest || exit 0
+              run: pytest

.github/workflows/python-build.yml

@@ -11,30 +11,29 @@ jobs:
       image: archlinux/archlinux:latest
       options: --privileged
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
       - name: Prepare arch
         run: |
           pacman-key --init
           pacman --noconfirm -Sy archlinux-keyring
           pacman --noconfirm -Syyu
-          pacman --noconfirm -Sy python-pip python-pydantic python-pyparted python-simple-term-menu pkgconfig gcc
-      - name: Install build dependencies
-        run: |
-          python -m pip install --break-system-packages --upgrade pip
-          pip install --break-system-packages --upgrade build twine wheel setuptools installer
-          pip uninstall archinstall -y --break-system-packages
+          pacman --noconfirm -Sy python-uv python-setuptools python-pip
+          pacman --noconfirm -Sy python-pyparted python-pydantic python-textual
+      - name: Remove existing archinstall (if any)
+        run: 
+          uv pip uninstall archinstall --break-system-packages --system
       - name: Build archinstall
-        run: python -m build --wheel --no-isolation
+        run: uv build --no-build-isolation --wheel
       - name: Install archinstall
-        run: python -m installer dist/*.whl
+        run: |
+          uv pip install dist/*.whl --break-system-packages --system --no-build --no-deps
       - name: Run archinstall
         run: |
           python -V
           archinstall --script guided -v
-          archinstall --script swiss -v
           archinstall --script only_hd -v
           archinstall --script minimal -v
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: archinstall
           path: dist/*

.github/workflows/python-publish.yml

@@ -1,4 +1,4 @@
-# This workflow will upload a Python Package using Twine when a release is created
+# This workflow will upload a Python Package when a release is created
 # For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
 
 name: Upload archinstall to PyPi
@@ -11,23 +11,23 @@ jobs:
   deploy:
 
     runs-on: ubuntu-latest
-
+    permissions:
+      # IMPORTANT: this permission is mandatory for Trusted Publishing
+      id-token: write
+    container:
+      image: archlinux/archlinux:latest
+      options: --privileged
     steps:
-      - uses: actions/checkout@v4
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-      - name: Install dependencies
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - name: Prepare arch
         run: |
-          python -m pip install --upgrade pip
-          pip install build twine
+          pacman-key --init
+          pacman --noconfirm -Sy archlinux-keyring
+          pacman --noconfirm -Syyu
+          pacman --noconfirm -Sy python python-uv python-setuptools python-pip python-pyparted python-pydantic python-textual
       - name: Build archinstall
         run: |
-          python -m build . --wheel
+          uv build --no-build-isolation --wheel
       - name: Publish archinstall to PyPi
-        env:
-          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
         run: |
-          twine upload dist/*
+          uv publish --trusted-publishing always

.github/workflows/ruff-format.yaml

@@ -0,0 +1,9 @@
+on: [ push, pull_request ]
+name: ruff check formatting
+jobs:
+  ruff_format_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: astral-sh/ruff-action@0ce1b0bf8b818ef400413f810f8a11cdbda0034b  # v4.0.0
+      - run: ruff format --diff

.github/workflows/ruff-lint.yaml

@@ -0,0 +1,8 @@
+on: [ push, pull_request ]
+name: ruff check linting
+jobs:
+    ruff:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+            - uses: astral-sh/ruff-action@0ce1b0bf8b818ef400413f810f8a11cdbda0034b  # v4.0.0

.github/workflows/ruff.yaml

@@ -1,12 +0,0 @@
-on: [ push, pull_request ]
-name: ruff linting
-jobs:
-    ruff:
-        runs-on: ubuntu-latest
-        container:
-            image: archlinux/archlinux:latest
-        steps:
-            - uses: actions/checkout@v4
-            - run: pacman --noconfirm -Syu ruff
-            - name: Lint with ruff
-              run: ruff check

.github/workflows/translation-check.yaml

@@ -1,28 +1,22 @@
-#on:
-#    push:
-#        paths:
-#        - 'archinstall/locales/**'
-#    pull_request:
-#        paths:
-#        - 'archinstall/locales/**'
-#name: Verify local_generate script was run on translation changes
-#jobs:
-#    translation-check:
-#        runs-on: ubuntu-latest
-#        container:
-#            image: archlinux/archlinux:latest
-#        steps:
-#            - uses: actions/checkout@v4
-#            - run: pacman --noconfirm -Syu python git diffutils
-#            - name: Verify all translation scripts are up to date
-#              run: |
-#                cd ..
-#                cp -r archinstall archinstall_orig
-#                cd archinstall/archinstall/locales
-#                bash locales_generator.sh 1> /dev/null
-#                cd ../../..
-#                git diff \
-#                  --quiet --no-index --name-only \
-#                  archinstall_orig/archinstall/locales \
-#                  archinstall/archinstall/locales \
-#                  || (echo "Translation files have not been updated after translation, please run ./locales_generator.sh once more and commit" && exit 1)
+name: Translation validation
+on:
+    push:
+        paths:
+            - 'archinstall/**/*.py'
+            - 'archinstall/locales/**'
+            - '.github/workflows/translation-check.yaml'
+    pull_request:
+        paths:
+            - 'archinstall/**/*.py'
+            - 'archinstall/locales/**'
+            - '.github/workflows/translation-check.yaml'
+jobs:
+    translations:
+        name: Validate translations
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+            - name: Install gettext
+              run: sudo apt-get update && sudo apt-get install -y gettext
+            - name: Run translation checks
+              run: bash archinstall/locales/locales_generator.sh check

.github/workflows/uki-build.yaml

@@ -0,0 +1,40 @@
+# This workflow will build an Arch Linux UKI file with the commit on it
+
+name: Build Arch UKI with ArchInstall Commit
+
+on:
+  push:
+    branches:
+      - master
+      - main # In case we adopt this convention in the future
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**.editorconfig'
+      - '**.gitignore'
+      - '**.md'
+      - 'LICENSE'
+      - 'PKGBUILD'
+  release:
+    types:
+      - created
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: archlinux/archlinux:latest
+      options: --privileged
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - run: pwd
+      - run: find .
+      - run: cat /etc/os-release
+      - run: pacman-key --init
+      - run: pacman --noconfirm -Sy archlinux-keyring
+      - run: pacman --noconfirm -Sy mkosi
+      - run: (cd test_tooling/mkosi/ && mkosi build -B)
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: Arch Live UKI
+          path: test_tooling/mkosi/mkosi.output/*.efi

.gitignore

@@ -39,3 +39,9 @@ requirements.txt
 /.gitconfig
 /actions-runner
 /cmd_output.txt
+node_modules/
+uv.lock
+test_tooling/mkosi/mkosi.output/*image*
+test_tooling/mkosi/mkosi.cache/**
+test_tooling/mkosi/mkosi.tools/**
+test_tooling/mkosi/mkosi.tools.manifest

.gitlab-ci.yml

@@ -36,7 +36,7 @@ flake8:
     - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
 
 # We currently do not have unit tests implemented but this stage is written in anticipation of their future usage.
-# When a stage name is preceeded with a '.' it's treated as "disabled" by GitLab and is not executed, so it's fine for it to be declared.
+# When a stage name is preceded with a '.' it's treated as "disabled" by GitLab and is not executed, so it's fine for it to be declared.
 .pytest:
   stage: test
   tags:

.pre-commit-config.yaml

@@ -1,19 +1,17 @@
-default_stages: ['commit']
+default_stages: ['pre-commit']
 repos:
-  - repo: https://github.com/pycqa/autoflake
-    rev: v2.3.1
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.14
     hooks:
-      - id: autoflake
-        args: [
-          '--in-place',
-          '--remove-all-unused-imports',
-          '--ignore-init-module-imports'
-        ]
-        files: \.py$
-        require_serial: true
-        fail_fast: true
+        # fix unused imports and sort them
+      - id: ruff
+        args: ["--extend-select", "I", "--fix"]
+        # format the code
+      - id: ruff-format
+        # run the linter
+      - id: ruff
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
     # general hooks:
     - id: check-added-large-files  # Prevent giant files from being committed
@@ -23,19 +21,17 @@ repos:
     - id: check-yaml  # Attempts to load all yaml files to verify syntax
     - id: destroyed-symlinks  # Detects symlinks which are changed to regular files
     - id: detect-private-key  # Checks for the existence of private keys
-    - id: end-of-file-fixer  # Makes sure files end in a newline and only a newline
-    - id: trailing-whitespace  # Trims trailing whitespace
     # Python specific hooks:
     - id: check-ast  # Simply check whether files parse as valid python
     - id: check-docstring-first  # Checks for a common error of placing code before the docstring
   - repo: https://github.com/pycqa/flake8
-    rev: 7.1.1
+    rev: 7.3.0
     hooks:
     - id: flake8
       args: [--config=.flake8]
       fail_fast: true
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.13.0
+    rev: v2.1.0
     hooks:
     - id: mypy
       args: [
@@ -44,11 +40,10 @@ repos:
       fail_fast: true
       additional_dependencies:
         - pydantic
-        - pydantic-settings
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.4
-    hooks:
-      - id: ruff
+        - pytest
+        - hypothesis
+        - cryptography
+        - textual
   - repo: local
     hooks:
       - id: pylint

.readthedocs.yaml

@@ -12,4 +12,4 @@ sphinx:
 build:
   os: "ubuntu-22.04"
   tools:
-    python: "3.11"
+    python: "3.12"

CONTRIBUTING.md

@@ -16,7 +16,7 @@ Patch releases will be done against their own branches, branched from stable tag
 ## Discussions
 
 Currently, questions, bugs and suggestions should be reported through [GitHub issue tracker](https://github.com/archlinux/archinstall/issues).<br>
-For less formal discussions there is also an [archinstall Discord server](https://discord.gg/cqXU88y).
+For less formal discussions there is also an [archinstall Discord server](https://discord.gg/aDeMffrxNg).
 
 ## Coding convention
 
@@ -27,9 +27,7 @@ The exceptions to PEP8 are:
 * Archinstall uses [tabs instead of spaces](https://www.python.org/dev/peps/pep-0008/#tabs-or-spaces) simply to make it
   easier for non-IDE developers to navigate the code *(Tab display-width should be equal to 4 spaces)*. Exception to the
   rule are comments that need fine-tuned indentation for documentation purposes.
-* [Line length](https://www.python.org/dev/peps/pep-0008/#maximum-line-length) a maximum line length is enforced via flake8 with 220 characters
-* [Line breaks before/after binary operator](https://www.python.org/dev/peps/pep-0008/#should-a-line-break-before-or-after-a-binary-operator)
-  is not enforced, as long as the style of line breaks is consistent within the same code block.
+* [Line length](https://www.python.org/dev/peps/pep-0008/#maximum-line-length) a maximum line length is enforced via flake8 with 160 characters
 * Archinstall should always be saved with **Unix-formatted line endings** and no other platform-specific formats.
 * [String quotes](https://www.python.org/dev/peps/pep-0008/#string-quotes) follow PEP8, the exception being when
   creating formatted strings, double-quoted strings are *preferred* but not required on the outer edges *(
@@ -70,15 +68,4 @@ squash commits when the pull request is merged.
 Maintainer:
 * Anton Hvornum ([@Torxed](https://github.com/Torxed))
 
-At present the current contributors are (alphabetically):
-* Anton Hvornum ([@Torxed](https://github.com/Torxed))
-* Borislav Kosharov ([@nikibobi](https://github.com/nikibobi))
-* demostanis ([@demostanis](https://github.com/demostanis))
-* Dylan Taylor ([@dylanmtaylor](https://github.com/dylanmtaylor))
-* Giancarlo Razzolini (@[grazzolini](https://github.com/grazzolini))
-* Jerker Bengtsson ([@jaybent](https://github.com/jaybent))
-* j-james ([@j-james](https://github.com/j-james))
-* Ninchester ([@ninchester](https://github.com/ninchester))
-* nullrequest ([@advaithm](https://github.com/advaithm))
-* Philipp Schaffrath ([@phisch](https://github.com/phisch))
-* Varun Madiath ([@vamega](https://github.com/vamega))
+[Contributors](https://github.com/archlinux/archinstall/graphs/contributors)

PKGBUILD

@@ -1,15 +1,16 @@
 # Maintainer: David Runge <dvzrv@archlinux.org>
 # Maintainer: Giancarlo Razzolini <grazzolini@archlinux.org>
+# Maintainer: Anton Hvornum <torxed@archlinux.org>
 # Contributor: Anton Hvornum <anton@hvornum.se>
 # Contributor: demostanis worlds <demostanis@protonmail.com>
 
 pkgname=archinstall
-pkgver=3.0.0
+pkgver=4.3
 pkgrel=1
 pkgdesc="Just another guided/automated Arch Linux installer with a twist"
 arch=(any)
 url="https://github.com/archlinux/archinstall"
-license=(GPL3)
+license=(GPL-3.0-only)
 depends=(
   'arch-install-scripts'
   'btrfs-progs'
@@ -19,26 +20,34 @@ depends=(
   'e2fsprogs'
   'glibc'
   'kbd'
+  'libcrypt.so'
+  'libxcrypt'
   'pciutils'
   'procps-ng'
   'python'
+  'python-cryptography'
   'python-pydantic'
   'python-pyparted'
+  'python-textual'
+  'python-markdown-it-py'
+  'python-linkify-it-py'
   'systemd'
   'util-linux'
   'xfsprogs'
   'lvm2'
   'f2fs-tools'
-  'ntfs-3g'
-  'reiserfsprogs'
+  'libfido2'
 )
 makedepends=(
-  'python-setuptools'
-  'python-sphinx'
   'python-build'
   'python-installer'
+  'python-setuptools'
+  'python-sphinx'
   'python-wheel'
   'python-sphinx_rtd_theme'
+  'python-pylint'
+  'python-pylint-pydantic'
+  'ruff'
 )
 optdepends=(
   'python-systemd: Adds journald logging'
@@ -47,14 +56,17 @@ provides=(python-archinstall archinstall)
 conflicts=(python-archinstall archinstall-git)
 replaces=(python-archinstall archinstall-git)
 source=(
-  $pkgname-$pkgver.tar.gz::$url/archive/refs/tags/v$pkgver.tar.gz
-  $pkgname-$pkgver.tar.gz.sig::$url/releases/download/v$pkgver/$pkgname-$pkgver.tar.gz.sig
+  $pkgname-$pkgver.tar.gz::$url/archive/refs/tags/$pkgver.tar.gz
+  $pkgname-$pkgver.tar.gz.sig::$url/releases/download/$pkgver/$pkgname-$pkgver.tar.gz.sig
 )
-sha512sums=('64cb3593c5091b3885ad14ef073cfab31090b4f9bcb4405b18cf9b19adb5ca42255ba8891ec62e21f92d59872541ef6d94f186fb05c625822af63525441e08d9'
-            'SKIP')
-b2sums=('9c0ec0871841804377ba8310dc744711adcec4eed7319a8d89d684af8e7b822bb9d47540b00f4d746a9fcd7b9ea1b9e07bac773e6c28fabc760e4df38b16748b'
-        'SKIP')
-validpgpkeys=('256F73CEEFC6705C6BBAB20E5FBBB32941E3740A') # Anton Hvornum (Torxed) <anton@hvornum.se>
+sha512sums=()
+b2sums=()
+validpgpkeys=('8AA2213C8464C82D879C8127D4B58E897A929F2E') # torxed@archlinux.org
+
+check() {
+  cd $pkgname-$pkgver
+  ruff check
+}
 
 pkgver() {
   cd $pkgname-$pkgver
@@ -62,13 +74,6 @@ pkgver() {
   awk '$1 ~ /^__version__/ {gsub("\"", ""); print $3}' archinstall/__init__.py
 }
 
-prepare() {
-  cd $pkgname-$pkgver
-
-  # use real directories for examples and profiles, as symlinks do not work
-  rm -fv $pkgname/{examples,profiles}
-}
-
 build() {
   cd $pkgname-$pkgver
 

README.md

@@ -6,36 +6,61 @@
 [![Lint Python and Find Syntax Errors](https://github.com/archlinux/archinstall/actions/workflows/flake8.yaml/badge.svg)](https://github.com/archlinux/archinstall/actions/workflows/flake8.yaml)
 
 Just another guided/automated [Arch Linux](https://wiki.archlinux.org/index.php/Arch_Linux) installer with a twist.
-The installer also doubles as a python library to install Arch Linux and manage services, packages, and other things inside the installed system *(Usually from a live medium)*.
+The installer also doubles as a python library to install Arch Linux and manage services, packages, and other things inside the installed system *(Usually from a live medium or from an existing installation)*.
 
-* archinstall [discord](https://discord.gg/cqXU88y) server
-* archinstall [matrix.org](https://app.element.io/#/room/#archinstall:matrix.org) channel
-* archinstall [#archinstall@irc.libera.chat](irc://#archinstall@irc.libera.chat:6697)
+* archinstall [discord](https://discord.gg/aDeMffrxNg) server
+* archinstall [#archinstall:matrix.org](https://matrix.to/#/#archinstall:matrix.org) Matrix channel
+* archinstall [#archinstall@irc.libera.chat:6697](https://web.libera.chat/?channel=#archinstall)
 * archinstall [documentation](https://archinstall.archlinux.page/)
 
 # Installation & Usage
+> [!TIP]
+> In the ISO you are root by default. Use sudo if running from an existing system.
+
 ```shell
-sudo pacman -S archinstall
-```
-
-Alternative ways to install are `git clone` the repository or `pip install --upgrade archinstall`.
-
-## Running the [guided](https://github.com/archlinux/archinstall/blob/master/archinstall/scripts/guided.py) installer
-
-Assuming you are on an Arch Linux live-ISO or installed via `pip`:
-```shell
+pacman-key --init
+pacman -Sy archinstall
 archinstall
 ```
 
-## Running the [guided](https://github.com/archlinux/archinstall/blob/master/archinstall/scripts/guided.py) installer using `git`
+Alternative ways to install are `git clone` the repository (and is better since you get the latest code regardless of [build date](https://archlinux.org/packages/?sort=&q=archinstall)) or `pip install --upgrade archinstall`.
+
+## Upgrade `archinstall` on live Arch ISO image
+
+Upgrading archinstall on the ISO needs to be done via a full system upgrade using 
 
 ```shell
-    # cd archinstall-git
-    # python -m archinstall
+pacman -Syu
+```
+
+When booting from a live USB, the space on the ramdisk is limited and may not be sufficient to allow running a re-installation or upgrade of the installer.
+In case one runs into this issue, any of the following can be used
+
+* Resize the root partition https://wiki.archlinux.org/title/Archiso#Adjusting_the_size_of_the_root_file_system
+* Specify the boot parameter copytoram=y (https://gitlab.archlinux.org/archlinux/mkinitcpio/mkinitcpio-archiso/-/blob/master/docs/README.bootparams#L26) which will copy the root filesystem to tmpfs
+
+## Running the [guided](https://github.com/archlinux/archinstall/blob/master/archinstall/scripts/guided.py) installer
+
+Assuming you are on an Arch Linux live-ISO or installed via `pip`, `archinstall` will use the `guided` script by default
+```shell
+archinstall
+```
+similar goes for running the [guided](https://github.com/archlinux/archinstall/blob/master/archinstall/scripts/guided.py) installer using `git
+
+```shell
+git clone https://github.com/archlinux/archinstall
+cd archinstall
+python -m archinstall $@
+```
+
+To run alternative scripts using the `--script` parameter
+
+```
+archinstall --script <name>
 ```
 
 #### Advanced
-Some additional options that most users do not need are hidden behind the `--advanced` flag.
+Some additional options that most users do not need are hidden behind the `--advanced` flag and all options/args can be consulted through `-h` or `--help`. 
 
 ## Running from a declarative configuration file or URL
 
@@ -56,17 +81,29 @@ To load the configuration file into `archinstall` run the following command
 archinstall --config <path to user config file or URL> --creds <path to user credentials config file or URL>
 ```
 
+### Credentials configuration file encryption
+By default, all user account credentials are hashed with `yescrypt` and only the hash is stored in the saved `user_credentials.json` file.
+This is not possible for disk encryption password which needs to be stored in plaintext to be able to apply it.
+
+However, when selecting to save configuration files, `archinstall` will prompt for the option to encrypt the `user_credentials.json` file content.
+A prompt will require to enter a encryption password to encrypt the file. When providing an encrypted `user_configuration.json` as a argument with `--creds <user_credentials.json>`
+there are multiple ways to provide the decryption key:
+* Provide the decryption key via the command line argument `--creds-decryption-key <password>`
+* Store the encryption key in the environment variable `ARCHINSTALL_CREDS_DECRYPTION_KEY` which will be read automatically
+* If none of the above is provided a prompt will be shown to enter the decryption key manually
+
+
 # Help or Issues
 
-If you come across any issues, kindly submit your issue here on Github or post your query in the
-[discord](https://discord.gg/cqXU88y) help channel.
+If you come across any issues, kindly submit your issue here on GitHub or post your query in the
+[discord](https://discord.gg/aDeMffrxNg) help channel.
 
 When submitting an issue, please:
 * Provide the stacktrace of the output if applicable
 * Attach the `/var/log/archinstall/install.log` to the issue ticket. This helps us help you!
-  * To extract the log from the ISO image, one way is to use<br>
+  * To upload the log from the ISO image and get a shareable URL, run<br>
     ```shell
-    curl -F'file=@/var/log/archinstall/install.log' https://0x0.st
+    archinstall share-log
     ```
 
 
@@ -92,67 +129,9 @@ All available console fonts can be found in `/usr/share/kbd/consolefonts` and se
 
 ## Scripting interactive installation
 
-There are some examples in the `examples/` directory that should serve as a starting point.
+For an example of a fully scripted, interactive installation please refer to the example
+[interactive_installation.py](https://github.com/archlinux/archinstall/blob/master/archinstall/scripts/guided.py)
 
-The following is a small example of how to script your own *interactive* installation:
-
-```python
-from pathlib import Path
-
-from archinstall import Installer, ProfileConfiguration, profile_handler, User
-from archinstall.default_profiles.minimal import MinimalProfile
-from archinstall.lib.disk.device_model import FilesystemType
-from archinstall.lib.disk.encryption_menu import DiskEncryptionMenu
-from archinstall.lib.disk.filesystem import FilesystemHandler
-from archinstall.lib.interactions.disk_conf import select_disk_config
-
-fs_type = FilesystemType('ext4')
-
-# Select a device to use for the installation
-disk_config = select_disk_config()
-
-# Optional: ask for disk encryption configuration
-data_store = {}
-disk_encryption = DiskEncryptionMenu(disk_config.device_modifications, data_store).run()
-
-# initiate file handler with the disk config and the optional disk encryption config
-fs_handler = FilesystemHandler(disk_config, disk_encryption)
-
-# perform all file operations
-# WARNING: this will potentially format the filesystem and delete all data
-fs_handler.perform_filesystem_operations()
-
-mountpoint = Path('/tmp')
-
-with Installer(
-        mountpoint,
-        disk_config,
-        disk_encryption=disk_encryption,
-        kernels=['linux']
-) as installation:
-    installation.mount_ordered_layout()
-    installation.minimal_installation(hostname='minimal-arch')
-    installation.add_additional_packages(['nano', 'wget', 'git'])
-
-    # Optionally, install a profile of choice.
-    # In this case, we install a minimal profile that is empty
-    profile_config = ProfileConfiguration(MinimalProfile())
-    profile_handler.install_profile_config(installation, profile_config)
-
-    user = User('archinstall', 'password', True)
-    installation.create_users(user)
-```
-
-This installer will perform the following actions:
-
-* Prompt the user to configure the disk partitioning
-* Prompt the user to setup disk encryption
-* Create a file handler instance for the configured disk and the optional disk encryption
-* Perform the disk operations (WARNING: this will potentially format the disks and erase all data)
-* Install a basic instance of Arch Linux *(base base-devel linux linux-firmware btrfs-progs efibootmgr)*
-* Install and configures a bootloader to partition 0 on UEFI. On BIOS, it sets the root to partition 0.
-* Install additional packages *(nano, wget, git)*
-* Create a new user
 
 > **To create your own ISO with this script in it:** Follow [ArchISO](https://wiki.archlinux.org/index.php/archiso)'s guide on creating your own ISO.
 
@@ -161,14 +140,6 @@ This installer will perform the following actions:
 For an example of a fully scripted, automated installation please refer to the example
 [full_automated_installation.py](https://github.com/archlinux/archinstall/blob/master/examples/full_automated_installation.py)
 
-## Unattended installation based on MAC address
-
-Archinstall comes with an [unattended](https://github.com/archlinux/archinstall/blob/master/examples/mac_address_installation.py)
-example which will look for a matching profile for the machine it is being run on, based on any local MAC address.
-For instance, if the machine the code is executed on has the MAC address `52:54:00:12:34:56` it will look for a profile called
-[52-54-00-12-34-56.py](https://github.com/archlinux/archinstall/blob/master/archinstall/default_profiles/tailored.py).
-If it's found, the unattended installation will begin and source that profile as its installation procedure.
-
 # Profiles
 
 `archinstall` comes with a set of pre-configured profiles available for selection during the installation process.
@@ -187,12 +158,6 @@ The profiles' definitions and the packages they will install can be directly vie
 If you want to test a commit, branch, or bleeding edge release from the repository using the standard Arch Linux Live ISO image,
 replace the archinstall version with a newer one and execute the subsequent steps defined below.
 
-*Note: When booting from a live USB, the space on the ramdisk is limited and may not be sufficient to allow
-running a re-installation or upgrade of the installer. In case one runs into this issue, any of the following can be used
-- Resize the root partition https://wiki.archlinux.org/title/Archiso#Adjusting_the_size_of_the_root_file_system
-- The boot parameter `copytoram=y` (https://gitlab.archlinux.org/archlinux/mkinitcpio/mkinitcpio-archiso/-/blob/master/docs/README.bootparams#L26)
-can be specified which will copy the root filesystem to tmpfs.*
-
 1. You need a working network connection
 2. Install the build requirements with `pacman -Sy; pacman -S git python-pip gcc pkgconf`
    *(note that this may or may not work depending on your RAM and current state of the squashfs maximum filesystem free space)*
@@ -211,10 +176,10 @@ To test this without a live ISO, the simplest approach is to use a local image a
 This can be done by installing `pacman -S arch-install-scripts util-linux` locally and doing the following:
 
     # truncate -s 20G testimage.img
-    # losetup --partscan --show --find ./testimage.img
+    # losetup --partscan --show ./testimage.img
     # pip install --upgrade archinstall
     # python -m archinstall --script guided
-    # qemu-system-x86_64 -enable-kvm -machine q35,accel=kvm -device intel-iommu -cpu host -m 4096 -boot order=d -drive file=./testimage.img,format=raw -drive if=pflash,format=raw,readonly,file=/usr/share/ovmf/x64/OVMF_CODE.fd -drive if=pflash,format=raw,readonly,file=/usr/share/ovmf/x64/OVMF_VARS.fd
+    # qemu-system-x86_64 -enable-kvm -machine q35,accel=kvm -device intel-iommu -cpu host -m 4096 -boot order=d -drive file=./testimage.img,format=raw -drive if=pflash,format=raw,readonly,file=/usr/share/edk2/x64/OVMF_CODE.4m.fd -drive if=pflash,format=raw,readonly,file=/usr/share/edk2/x64/OVMF_VARS.4m.fd 
 
 This will create a *20 GB* `testimage.img` and create a loop device which we can use to format and install to.<br>
 `archinstall` is installed and executed in [guided mode](#docs-todo). Once the installation is complete, ~~you can use qemu/kvm to boot the test media.~~<br>
@@ -223,9 +188,41 @@ This will create a *20 GB* `testimage.img` and create a loop device which we can
 There's also a [Building and Testing](https://github.com/archlinux/archinstall/wiki/Building-and-Testing) guide.<br>
 It will go through everything from packaging, building and running *(with qemu)* the installer against a dev branch.
 
+## Boot an Arch ISO image in a VM
+
+You may want to boot an ISO image in a VM to test `archinstall` in there.
+
+* Download the latest [Arch ISO](https://archlinux.org/download/)
+* Use the the below command to boot the ISO in a VM
+
+```
+qemu-system-x86_64 -enable-kvm \
+-machine q35,accel=kvm -device intel-iommu \
+-cpu host -m 4096 -boot order=d \
+-drive if=pflash,format=raw,readonly,file=/usr/share/edk2/x64/OVMF_CODE.4m.fd \
+-drive if=pflash,format=raw,readonly,file=/usr/share/edk2/x64/OVMF_VARS.4m.fd \
+-drive file=./archlinux-2025.12.01-x86_64.iso,format=raw
+```
+
+HINT: For espeakup support
+```
+qemu-system-x86_64 -enable-kvm \
+-machine q35,accel=kvm -device intel-iommu \
+-cpu host -m 4096 -boot order=d \
+-drive if=pflash,format=raw,readonly,file=/usr/share/edk2/x64/OVMF_CODE.4m.fd \
+-drive if=pflash,format=raw,readonly,file=/usr/share/edk2/x64/OVMF_VARS.4m.fd \
+-drive file=./archlinux-2025.12.01-x86_64.iso,format=raw \
+-device intel-hda -device hda-duplex,audiodev=snd0 \
+-audiodev pa,id=snd0,server=/run/user/1000/pulse/native
+```
+
 
 # FAQ
 
+## AUR
+
+`archinstall` will not offer or bundle AUR helpers or AUR packages due to a current consensus. This is not any individual developers decision. The reasons and discussions for this stance on the topic can be found on our mailing list thread: [(optional) AUR helper in archinstall](https://lists.archlinux.org/archives/list/arch-dev-public@lists.archlinux.org/thread/VYOULH2GOJLFM2BXOFLWH3D754YXFPSL/).
+
 ## Keyring out-of-date
 For a description of the problem see https://archinstall.archlinux.page/help/known_issues.html#keyring-is-out-of-date-2213 and discussion in issue https://github.com/archlinux/archinstall/issues/2213.
 

archinstall/__init__.py

@@ -1,355 +1,3 @@
-"""Arch Linux installer - guided, templates etc."""
-import importlib
-import os
-import sys
-import time
-import curses
-import traceback
-from argparse import ArgumentParser, Namespace
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Union
+from archinstall.lib.plugins import plugin
 
-from .lib import disk
-from .lib import models
-from .lib import packages
-from .lib import exceptions
-from .lib import luks
-from .lib import locale
-from .lib import mirrors
-from .lib import networking
-from .lib import profile
-from .lib import interactions
-from . import default_profiles
-
-from .lib.hardware import SysInfo, GfxDriver
-from .lib.installer import Installer, accessibility_tools_in_use
-from .lib.output import FormattedOutput, log, error, debug, warn, info
-from .lib.pacman import Pacman
-from .lib.storage import storage
-from .lib.global_menu import GlobalMenu
-from .lib.boot import Boot
-from .lib.translationhandler import TranslationHandler, Language, DeferredTranslation
-from .lib.plugins import plugins, load_plugin
-from .lib.configuration import ConfigurationOutput
-from .tui import Tui
-
-from .lib.general import (
-	generate_password, locate_binary, clear_vt100_escape_codes,
-	JSON, UNSAFE_JSON, SysCommandWorker, SysCommand,
-	run_custom_user_commands, json_stream_to_structure, secret
-)
-
-if TYPE_CHECKING:
-	_: Any
-
-
-__version__ = "3.0.0"
-storage['__version__'] = __version__
-
-# add the custom _ as a builtin, it can now be used anywhere in the
-# project to mark strings as translatable with _('translate me')
-DeferredTranslation.install()
-
-# Log various information about hardware before starting the installation. This might assist in troubleshooting
-debug(f"Hardware model detected: {SysInfo.sys_vendor()} {SysInfo.product_name()}; UEFI mode: {SysInfo.has_uefi()}")
-debug(f"Processor model detected: {SysInfo.cpu_model()}")
-debug(f"Memory statistics: {SysInfo.mem_available()} available out of {SysInfo.mem_total()} total installed")
-debug(f"Virtualization detected: {SysInfo.virtualization()}; is VM: {SysInfo.is_vm()}")
-debug(f"Graphics devices detected: {SysInfo._graphics_devices().keys()}")
-
-# For support reasons, we'll log the disk layout pre installation to match against post-installation layout
-debug(f"Disk states before installing: {disk.disk_layouts()}")
-
-parser = ArgumentParser()
-
-
-def define_arguments() -> None:
-	"""
-	Define which explicit arguments do we allow.
-	Refer to https://docs.python.org/3/library/argparse.html for documentation and
-			https://docs.python.org/3/howto/argparse.html for a tutorial
-	Remember that the property/entry name python assigns to the parameters is the first string defined as argument and
-	dashes inside it '-' are changed to '_'
-	"""
-	parser.add_argument("-v", "--version", action="version", version="%(prog)s " + __version__)
-	parser.add_argument("--config", nargs="?", help="JSON configuration file or URL")
-	parser.add_argument("--creds", nargs="?", help="JSON credentials configuration file")
-	parser.add_argument("--silent", action="store_true",
-						help="WARNING: Disables all prompts for input and confirmation. If no configuration is provided, this is ignored")
-	parser.add_argument("--dry-run", "--dry_run", action="store_true",
-						help="Generates a configuration file and then exits instead of performing an installation")
-	parser.add_argument("--script", default="guided", nargs="?", help="Script to run for installation", type=str)
-	parser.add_argument("--mount-point", "--mount_point", nargs="?", type=str,
-						help="Define an alternate mount point for installation")
-	parser.add_argument("--skip-ntp", action="store_true", help="Disables NTP checks during installation", default=False)
-	parser.add_argument("--debug", action="store_true", default=False, help="Adds debug info into the log")
-	parser.add_argument("--offline", action="store_true", default=False,
-						help="Disabled online upstream services such as package search and key-ring auto update.")
-	parser.add_argument("--no-pkg-lookups", action="store_true", default=False,
-						help="Disabled package validation specifically prior to starting installation.")
-	parser.add_argument("--plugin", nargs="?", type=str)
-	parser.add_argument("--skip-version-check", action="store_true",
-						help="Skip the version check when running archinstall")
-
-
-if 'sphinx' not in sys.modules:
-	if '--help' in sys.argv or '-h' in sys.argv:
-		define_arguments()
-		parser.print_help()
-		exit(0)
-	if os.getuid() != 0:
-		print(_("Archinstall requires root privileges to run. See --help for more."))
-		exit(1)
-
-
-def parse_unspecified_argument_list(unknowns: list, multiple: bool = False, err: bool = False) -> dict:  # type: ignore[type-arg]
-	"""We accept arguments not defined to the parser. (arguments "ad hoc").
-	Internally argparse return to us a list of words so we have to parse its contents, manually.
-	We accept following individual syntax for each argument
-		--argument value
-		--argument=value
-		--argument = value
-		--argument   (boolean as default)
-	the optional parameters to the function alter a bit its behaviour:
-	* multiple allows multivalued arguments, each value separated by whitespace. They're returned as a list
-	* error. If set any non correctly specified argument-value pair to raise an exception. Else, simply notifies the existence of a problem and continues processing.
-
-	To a certain extent, multiple and error are incompatible. In fact, the only error this routine can catch, as of now, is the event
-	argument value value ...
-	which isn't am error if multiple is specified
-	"""
-	tmp_list = [arg for arg in unknowns if arg != "="]  # wastes a few bytes, but avoids any collateral effect of the destructive nature of the pop method()
-	config = {}
-	key = None
-	last_key = None
-	while tmp_list:
-		element = tmp_list.pop(0)  # retrieve an element of the list
-
-		if element.startswith('--'):  # is an argument ?
-			if '=' in element:  # uses the arg=value syntax ?
-				key, value = [x.strip() for x in element[2:].split('=', 1)]
-				config[key] = value
-				last_key = key  # for multiple handling
-				key = None  # we have the kwy value pair we need
-			else:
-				key = element[2:]
-				config[key] = True  # every argument starts its lifecycle as boolean
-		elif key:
-			config[key] = element
-			last_key = key  # multiple
-			key = None
-		elif multiple and last_key:
-			if isinstance(config[last_key], str):
-				config[last_key] = [config[last_key], element]
-			else:
-				config[last_key].append(element)
-		elif err:
-			raise ValueError(f"Entry {element} is not related to any argument")
-		else:
-			print(f" We ignore the entry {element} as it isn't related to any argument")
-	return config
-
-
-def cleanup_empty_args(args: Union[Namespace, dict]) -> dict:  # type: ignore[type-arg]
-	"""
-	Takes arguments (dictionary or argparse Namespace) and removes any
-	None values. This ensures clean mergers during dict.update(args)
-	"""
-	if type(args) is Namespace:
-		args = vars(args)
-
-	clean_args = {}
-	for key, val in args.items():
-		if isinstance(val, dict):
-			val = cleanup_empty_args(val)
-
-		if val is not None:
-			clean_args[key] = val
-
-	return clean_args
-
-
-def get_arguments() -> dict[str, Any]:
-	""" The handling of parameters from the command line
-	Is done on following steps:
-	0) we create a dict to store the arguments and their values
-	1) preprocess.
-		We take those arguments which use JSON files, and read them into the argument dict. So each first level entry becomes a argument on it's own right
-	2) Load.
-		We convert the predefined argument list directly into the dict via the vars() function. Non specified arguments are loaded with value None or false if they are booleans (action="store_true").
-		The name is chosen according to argparse conventions. See above (the first text is used as argument name, but underscore substitutes dash)
-		We then load all the undefined arguments. In this case the names are taken as written.
-		Important. This way explicit command line arguments take precedence over configuration files.
-	3) Amend
-		Change whatever is needed on the configuration dictionary (it could be done in post_process_arguments but  this ougth to be left to changes anywhere else in the code, not in the arguments dictionary
-	"""
-	config: dict[str, Any] = {}
-	args, unknowns = parser.parse_known_args()
-	# preprocess the JSON files.
-	# TODO Expand the url access to the other JSON file arguments ?
-	if args.config is not None:
-		if not json_stream_to_structure('--config', args.config, config):
-			exit(1)
-
-	if args.creds is not None:
-		if not json_stream_to_structure('--creds', args.creds, config):
-			exit(1)
-
-	# load the parameters. first the known, then the unknowns
-	clean_args = cleanup_empty_args(args)
-	config.update(clean_args)
-	config.update(parse_unspecified_argument_list(unknowns))
-	# amend the parameters (check internal consistency)
-	# Installation can't be silent if config is not passed
-	if clean_args.get('config') is None:
-		config["silent"] = False
-	else:
-		config["silent"] = clean_args.get('silent')
-
-	# avoiding a compatibility issue
-	if 'dry-run' in config:
-		del config['dry-run']
-
-	return config
-
-
-def load_config() -> None:
-	"""
-	refine and set some arguments. Formerly at the scripts
-	"""
-	from .lib.models import NetworkConfiguration
-
-	arguments['locale_config'] = locale.LocaleConfiguration.parse_arg(arguments)
-
-	if (archinstall_lang := arguments.get('archinstall-language', None)) is not None:
-		arguments['archinstall-language'] = TranslationHandler().get_language_by_name(archinstall_lang)
-
-	if disk_config := arguments.get('disk_config', {}):
-		arguments['disk_config'] = disk.DiskLayoutConfiguration.parse_arg(disk_config)
-
-	if profile_config := arguments.get('profile_config', None):
-		arguments['profile_config'] = profile.ProfileConfiguration.parse_arg(profile_config)
-
-	if mirror_config := arguments.get('mirror_config', None):
-		arguments['mirror_config'] = mirrors.MirrorConfiguration.parse_args(mirror_config)
-
-	if arguments.get('servers', None) is not None:
-		storage['_selected_servers'] = arguments.get('servers', None)
-
-	if (net_config := arguments.get('network_config', None)) is not None:
-		config = NetworkConfiguration.parse_arg(net_config)
-		arguments['network_config'] = config
-
-	if arguments.get('!users', None) is not None or arguments.get('!superusers', None) is not None:
-		users = arguments.get('!users', None)
-		superusers = arguments.get('!superusers', None)
-		arguments['!users'] = models.User.parse_arguments(users, superusers)
-
-	if arguments.get('bootloader', None) is not None:
-		arguments['bootloader'] = models.Bootloader.from_arg(arguments['bootloader'])
-
-		if arguments.get('uki') and not arguments['bootloader'].has_uki_support():
-			arguments['uki'] = False
-
-	if arguments.get('audio_config', None) is not None:
-		arguments['audio_config'] = models.AudioConfiguration.parse_arg(arguments['audio_config'])
-
-	if arguments.get('disk_encryption', None) is not None and disk_config is not None:
-		arguments['disk_encryption'] = disk.DiskEncryption.parse_arg(
-			arguments['disk_config'],
-			arguments['disk_encryption'],
-			arguments.get('encryption_password', '')
-		)
-
-
-def post_process_arguments(arguments: dict[str, Any]) -> None:
-	storage['arguments'] = arguments
-	if mountpoint := arguments.get('mount_point', None):
-		storage['MOUNT_POINT'] = Path(mountpoint)
-
-	if arguments.get('debug', False):
-		warn(f"Warning: --debug mode will write certain credentials to {storage['LOG_PATH']}/{storage['LOG_FILE']}!")
-
-	if arguments.get('plugin', None):
-		path = arguments['plugin']
-		load_plugin(path)
-
-	load_config()
-
-
-define_arguments()
-arguments: dict[str, Any] = get_arguments()
-post_process_arguments(arguments)
-
-
-# @archinstall.plugin decorator hook to programmatically add
-# plugins in runtime. Useful in profiles_bck and other things.
-def plugin(f, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
-	plugins[f.__name__] = f
-
-
-def _check_new_version() -> None:
-	info("Checking version...")
-
-	try:
-		Pacman.run("-Sy")
-	except Exception as e:
-		debug(f'Failed to perform version check: {e}')
-		info('Arch Linux mirrors are not reachable. Please check your internet connection')
-		exit(1)
-
-	upgrade = None
-
-	try:
-		upgrade = Pacman.run("-Qu archinstall").decode()
-	except Exception as e:
-		debug(f'Failed determine pacman version: {e}')
-
-	if upgrade:
-		text = f'New version available: {upgrade}'
-		info(text)
-		time.sleep(3)
-
-
-def main() -> None:
-	"""
-	This can either be run as the compiled and installed application: python setup.py install
-	OR straight as a module: python -m archinstall
-	In any case we will be attempting to load the provided script to be run from the scripts/ folder
-	"""
-	if not arguments.get('skip_version_check', False):
-		_check_new_version()
-
-	script = arguments.get('script', None)
-
-	if script is None:
-		print('No script to run provided')
-
-	mod_name = f'archinstall.scripts.{script}'
-	# by loading the module we'll automatically run the script
-	importlib.import_module(mod_name)
-
-
-def run_as_a_module() -> None:
-	exc = None
-
-	try:
-		main()
-	except Exception as e:
-		exc = e
-	finally:
-		# restore the terminal to the original state
-		Tui.shutdown()
-
-		if exc:
-			err = ''.join(traceback.format_exception(exc))
-			error(err)
-
-			text = (
-				'Archinstall experienced the above error. If you think this is a bug, please report it to\n'
-				'https://github.com/archlinux/archinstall and include the log file "/var/log/archinstall/install.log".\n\n'
-				'Hint: To extract the log from a live ISO \ncurl -F\'file=@/var/log/archinstall/install.log\' https://0x0.st\n'
-			)
-
-			warn(text)
-			exit(1)
+__all__ = ['plugin']

archinstall/__main__.py

@@ -1,19 +1,6 @@
-import importlib
 import sys
-import pathlib
 
-# Load .git version before the builtin version
-if pathlib.Path('./archinstall/__init__.py').absolute().exists():
-	spec = importlib.util.spec_from_file_location("archinstall", "./archinstall/__init__.py")
-
-	if spec is None or spec.loader is None:
-		raise ValueError('Could not retrieve spec from file: archinstall/__init__.py')
-
-	archinstall = importlib.util.module_from_spec(spec)
-	sys.modules["archinstall"] = archinstall
-	spec.loader.exec_module(archinstall)
-else:
-	import archinstall
+from archinstall.main import main
 
 if __name__ == '__main__':
-	archinstall.run_as_a_module()
+	sys.exit(main())

archinstall/applications/audio.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING
+
+from archinstall.lib.hardware import SysInfo
+from archinstall.lib.log import debug
+from archinstall.lib.models.application import Audio, AudioConfiguration
+from archinstall.lib.models.users import User
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class AudioApp:
+	@property
+	def pulseaudio_packages(self) -> list[str]:
+		return [
+			'pulseaudio',
+		]
+
+	@property
+	def pipewire_packages(self) -> list[str]:
+		return [
+			'pipewire',
+			'pipewire-alsa',
+			'pipewire-jack',
+			'pipewire-pulse',
+			'gst-plugin-pipewire',
+			'libpulse',
+			'wireplumber',
+		]
+
+	def _enable_pipewire(
+		self,
+		install_session: Installer,
+		users: list[User] | None = None,
+	) -> None:
+		if users is None:
+			return
+
+		for user in users:
+			# Create the full path for enabling the pipewire systemd items
+			service_dir = install_session.target / 'home' / user.username / '.config' / 'systemd' / 'user' / 'default.target.wants'
+			service_dir.mkdir(parents=True, exist_ok=True)
+
+			# Set ownership of the entire user catalogue
+			install_session.arch_chroot(f'chown -R {user.username}:{user.username} /home/{user.username}')
+
+			# symlink in the correct pipewire systemd items
+			install_session.arch_chroot(
+				f'ln -sf /usr/lib/systemd/user/pipewire-pulse.service /home/{user.username}/.config/systemd/user/default.target.wants/pipewire-pulse.service',
+				run_as=user.username,
+			)
+			install_session.arch_chroot(
+				f'ln -sf /usr/lib/systemd/user/pipewire-pulse.socket /home/{user.username}/.config/systemd/user/default.target.wants/pipewire-pulse.socket',
+				run_as=user.username,
+			)
+
+	def install(
+		self,
+		install_session: Installer,
+		audio_config: AudioConfiguration,
+		users: list[User] | None = None,
+	) -> None:
+		debug(f'Installing audio server: {audio_config.audio.value}')
+
+		if audio_config.audio == Audio.NO_AUDIO:
+			debug('No audio server selected, skipping installation.')
+			return
+
+		if SysInfo.requires_sof_fw():
+			install_session.add_additional_packages('sof-firmware')
+
+		if SysInfo.requires_alsa_fw():
+			install_session.add_additional_packages('alsa-firmware')
+
+		match audio_config.audio:
+			case Audio.PIPEWIRE:
+				install_session.add_additional_packages(self.pipewire_packages)
+				self._enable_pipewire(install_session, users)
+			case Audio.PULSEAUDIO:
+				install_session.add_additional_packages(self.pulseaudio_packages)

archinstall/applications/bluetooth.py

@@ -0,0 +1,26 @@
+from typing import TYPE_CHECKING
+
+from archinstall.lib.log import debug
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class BluetoothApp:
+	@property
+	def packages(self) -> list[str]:
+		return [
+			'bluez',
+			'bluez-utils',
+		]
+
+	@property
+	def services(self) -> list[str]:
+		return [
+			'bluetooth.service',
+		]
+
+	def install(self, install_session: Installer) -> None:
+		debug('Installing Bluetooth')
+		install_session.add_additional_packages(self.packages)
+		install_session.enable_service(self.services)

archinstall/applications/firewall.py

@@ -0,0 +1,52 @@
+from typing import TYPE_CHECKING
+
+from archinstall.lib.log import debug
+from archinstall.lib.models.application import Firewall, FirewallConfiguration
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class FirewallApp:
+	@property
+	def ufw_packages(self) -> list[str]:
+		return [
+			'ufw',
+		]
+
+	@property
+	def fwd_packages(self) -> list[str]:
+		return [
+			'firewalld',
+		]
+
+	@property
+	def ufw_services(self) -> list[str]:
+		return [
+			'ufw.service',
+		]
+
+	@property
+	def fwd_services(self) -> list[str]:
+		return [
+			'firewalld.service',
+		]
+
+	def install(
+		self,
+		install_session: Installer,
+		firewall_config: FirewallConfiguration,
+	) -> None:
+		debug(f'Installing firewall: {firewall_config.firewall.value}')
+
+		match firewall_config.firewall:
+			case Firewall.UFW:
+				install_session.add_additional_packages(self.ufw_packages)
+				install_session.enable_service(self.ufw_services)
+				# write default conf file to enabled
+				ufw_conf = install_session.target / 'etc/ufw/ufw.conf'
+				ufw_conf.write_text(ufw_conf.read_text().replace('ENABLED=no', 'ENABLED=yes'))
+
+			case Firewall.FWD:
+				install_session.add_additional_packages(self.fwd_packages)
+				install_session.enable_service(self.fwd_services)

archinstall/applications/fonts.py

@@ -0,0 +1,14 @@
+from typing import TYPE_CHECKING
+
+from archinstall.lib.log import debug
+from archinstall.lib.models.application import FontsConfiguration
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class FontsApp:
+	def install(self, install_session: Installer, fonts_config: FontsConfiguration) -> None:
+		packages = [f.value for f in fonts_config.fonts]
+		debug(f'Installing fonts: {packages}')
+		install_session.add_additional_packages(packages)

archinstall/applications/power_management.py

@@ -0,0 +1,49 @@
+from typing import TYPE_CHECKING
+
+from archinstall.lib.log import debug
+from archinstall.lib.models.application import PowerManagement, PowerManagementConfiguration
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class PowerManagementApp:
+	@property
+	def ppd_packages(self) -> list[str]:
+		return [
+			'power-profiles-daemon',
+		]
+
+	@property
+	def tuned_packages(self) -> list[str]:
+		return [
+			'tuned',
+			'tuned-ppd',
+		]
+
+	@property
+	def ppd_services(self) -> list[str]:
+		return [
+			'power-profiles-daemon.service',
+		]
+
+	@property
+	def tuned_services(self) -> list[str]:
+		return [
+			'tuned.service',
+		]
+
+	def install(
+		self,
+		install_session: Installer,
+		power_management_config: PowerManagementConfiguration,
+	) -> None:
+		debug(f'Installing power management daemon: {power_management_config.power_management.value}')
+
+		match power_management_config.power_management:
+			case PowerManagement.POWER_PROFILES_DAEMON:
+				install_session.add_additional_packages(self.ppd_packages)
+				install_session.enable_service(self.ppd_services)
+			case PowerManagement.TUNED:
+				install_session.add_additional_packages(self.tuned_packages)
+				install_session.enable_service(self.tuned_services)

archinstall/applications/print_service.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING
+
+from archinstall.lib.log import debug
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class PrintServiceApp:
+	@property
+	def packages(self) -> list[str]:
+		return ['cups', 'system-config-printer', 'cups-pk-helper']
+
+	@property
+	def services(self) -> list[str]:
+		return [
+			'cups.service',
+		]
+
+	def install(self, install_session: Installer) -> None:
+		debug('Installing print service')
+		install_session.add_additional_packages(self.packages)
+		install_session.enable_service(self.services)

archinstall/default_profiles/applications/pipewire.py

@@ -1,49 +0,0 @@
-from typing import Union, Any, TYPE_CHECKING
-
-import archinstall
-
-from archinstall.default_profiles.profile import Profile, ProfileType
-from archinstall.lib.models import User
-
-if TYPE_CHECKING:
-	from archinstall.lib.installer import Installer
-	_: Any
-
-
-class PipewireProfile(Profile):
-	def __init__(self) -> None:
-		super().__init__('Pipewire', ProfileType.Application)
-
-	@property
-	def packages(self) -> list[str]:
-		return [
-			'pipewire',
-			'pipewire-alsa',
-			'pipewire-jack',
-			'pipewire-pulse',
-			'gst-plugin-pipewire',
-			'libpulse',
-			'wireplumber'
-		]
-
-	def _enable_pipewire_for_all(self, install_session: 'Installer') -> None:
-		users: Union[User, list[User]] = archinstall.arguments.get('!users', [])
-		if not isinstance(users, list):
-			users = [users]
-
-		for user in users:
-			# Create the full path for enabling the pipewire systemd items
-			service_dir = install_session.target / "home" / user.username / ".config" / "systemd" / "user" / "default.target.wants"
-			service_dir.mkdir(parents=True, exist_ok=True)
-
-			# Set ownership of the entire user catalogue
-			install_session.arch_chroot(f'chown -R {user.username}:{user.username} /home/{user.username}')
-
-			# symlink in the correct pipewire systemd items
-			install_session.arch_chroot(f'ln -s /usr/lib/systemd/user/pipewire-pulse.service /home/{user.username}/.config/systemd/user/default.target.wants/pipewire-pulse.service', run_as=user.username)
-			install_session.arch_chroot(f'ln -s /usr/lib/systemd/user/pipewire-pulse.socket /home/{user.username}/.config/systemd/user/default.target.wants/pipewire-pulse.socket', run_as=user.username)
-
-	def install(self, install_session: 'Installer') -> None:
-		super().install(install_session)
-		install_session.add_additional_packages(self.packages)
-		self._enable_pipewire_for_all(install_session)

archinstall/default_profiles/custom.py

@@ -1,218 +0,0 @@
-# from typing import List, Dict, Optional, TYPE_CHECKING, Any
-#
-# from ..lib import menu
-# from archinstall.lib.output import log, FormattedOutput
-# from archinstall.lib.profile.profiles_handler import profile_handler
-# from archinstall.default_profiles.profile import Profile, ProfileType, SelectResult, ProfileInfo, TProfile
-#
-# if TYPE_CHECKING:
-# 	from archinstall.lib.installer import Installer
-# 	_: Any
-#
-#
-# class CustomProfileList(menu.ListManager):
-# 	def __init__(self, prompt: str, profiles: List[TProfile]):
-# 		self._actions = [
-# 			str(_('Add profile')),
-# 			str(_('Edit profile')),
-# 			str(_('Delete profile'))
-# 		]
-# 		super().__init__(prompt, profiles, [self._actions[0]], self._actions[1:])
-#
-# 	def reformat(self, data: List[TProfile]) -> Dict[str, Optional[TProfile]]:
-# 		table = FormattedOutput.as_table(data)
-# 		rows = table.split('\n')
-#
-# 		# these are the header rows of the table and do not map to any profile obviously
-# 		# we're adding 2 spaces as prefix because the menu selector '> ' will be put before
-# 		# the selectable rows so the header has to be aligned
-# 		display_data: Dict[str, Optional[TProfile]] = {f'  {rows[0]}': None, f'  {rows[1]}': None}
-#
-# 		for row, profile in zip(rows[2:], data):
-# 			row = row.replace('|', '\\|')
-# 			display_data[row] = profile
-#
-# 		return display_data
-#
-# 	def selected_action_display(self, profile: TProfile) -> str:
-# 		return profile.name
-#
-# 	def handle_action(
-# 		self,
-# 		action: str,
-# 		entry: Optional['CustomTypeProfile'],
-# 		data: List['CustomTypeProfile']
-# 	) -> List['CustomTypeProfile']:
-# 		if action == self._actions[0]:  # add
-# 			new_profile = self._add_profile()
-# 			if new_profile is not None:
-# 				# in case a profile with the same name as an existing profile
-# 				# was created we'll replace the existing one
-# 				data = [d for d in data if d.name != new_profile.name]
-# 				data += [new_profile]
-# 		elif entry is not None:
-# 			if action == self._actions[1]:  # edit
-# 				new_profile = self._add_profile(entry)
-# 				if new_profile is not None:
-# 					# we'll remove the original profile and add the modified version
-# 					data = [d for d in data if d.name != entry.name and d.name != new_profile.name]
-# 					data += [new_profile]
-# 			elif action == self._actions[2]:  # delete
-# 				data = [d for d in data if d != entry]
-#
-# 		return data
-#
-# 	def _is_new_profile_name(self, name: str) -> bool:
-# 		existing_profile = profile_handler.get_profile_by_name(name)
-# 		if existing_profile is not None and existing_profile.profile_type != ProfileType.CustomType:
-# 			return False
-# 		return True
-#
-# 	def _add_profile(self, editing: Optional['CustomTypeProfile'] = None) -> Optional['CustomTypeProfile']:
-# 		name_prompt = '\n\n' + str(_('Profile name: '))
-#
-# 		while True:
-# 			profile_name = menu.TextInput(name_prompt, editing.name if editing else '').run().strip()
-#
-# 			if not profile_name:
-# 				return None
-#
-# 			if not self._is_new_profile_name(profile_name):
-# 				error_prompt = str(_("The profile name you entered is already in use. Try again"))
-# 				print(error_prompt)
-# 			else:
-# 				break
-#
-# 		packages_prompt = str(_('Packages to be install with this profile (space separated, leave blank to skip): '))
-# 		edit_packages = ' '.join(editing.packages) if editing else ''
-# 		packages = menu.TextInput(packages_prompt, edit_packages).run().strip()
-#
-# 		services_prompt = str(_('Services to be enabled with this profile (space separated, leave blank to skip): '))
-# 		edit_services = ' '.join(editing.services) if editing else ''
-# 		services = menu.TextInput(services_prompt, edit_services).run().strip()
-#
-# 		choice = menu.Menu(
-# 			str(_('Should this profile be enabled for installation?')),
-# 			menu.Menu.yes_no(),
-# 			skip=False,
-# 			default_option=menu.Menu.no(),
-# 			clear_screen=False,
-# 			show_search_hint=False
-# 		).run()
-#
-# 		enable_profile = True if choice.value == menu.Menu.yes() else False
-#
-# 		profile = CustomTypeProfile(
-# 			profile_name,
-# 			enabled=enable_profile,
-# 			packages=packages.split(' '),
-# 			services=services.split(' ')
-# 		)
-#
-# 		return profile
-#
-#
-# # TODO
-# # Still needs some ironing out
-# class CustomProfile():
-# 	def __init__(self):
-# 		super().__init__(
-# 			'Custom',
-# 			ProfileType.Custom,
-# 			description=str(_('Create your own'))
-# 		)
-#
-# 	def json(self) -> Dict[str, Any]:
-# 		data: Dict[str, Any] = {'main': self.name, 'gfx_driver': self.gfx_driver, 'custom': []}
-#
-# 		for profile in self._current_selection:
-# 			data['custom'].append({
-# 				'name': profile.name,
-# 				'packages': profile.packages,
-# 				'services': profile.services,
-# 				'enabled': profile.custom_enabled
-# 			})
-#
-# 		return data
-#
-# 	def do_on_select(self) -> SelectResult:
-# 		custom_profile_list = CustomProfileList('', profile_handler.get_custom_profiles())
-# 		custom_profiles = custom_profile_list.run()
-#
-# 		# we'll first remove existing custom default_profiles with
-# 		# the same name and then add the new ones this
-# 		# will avoid errors of default_profiles with duplicate naming
-# 		profile_handler.remove_custom_profiles(custom_profiles)
-# 		profile_handler.add_custom_profiles(custom_profiles)
-#
-# 		self.set_current_selection(custom_profiles)
-#
-# 		if custom_profile_list.is_last_choice_cancel():
-# 			return SelectResult.SameSelection
-#
-# 		enabled_profiles = [p for p in self._current_selection if p.custom_enabled]
-# 		# in  case we only created inactive default_profiles we wanna store them but
-# 		# we want to reset the original setting
-# 		if not enabled_profiles:
-# 			return SelectResult.ResetCurrent
-#
-# 		return SelectResult.NewSelection
-#
-# 	def post_install(self, install_session: 'Installer'):
-# 		for profile in self._current_selection:
-# 			profile.post_install(install_session)
-#
-# 	def install(self, install_session: 'Installer'):
-# 		driver_packages = self.gfx_driver_packages()
-# 		install_session.add_additional_packages(driver_packages)
-#
-# 		for profile in self._current_selection:
-# 			if profile.custom_enabled:
-# 				log(f'Installing custom profile {profile.name}...')
-#
-# 				install_session.add_additional_packages(profile.packages)
-# 				install_session.enable_service(profile.services)
-#
-# 				profile.install(install_session)
-#
-# 	def info(self) -> Optional[ProfileInfo]:
-# 		enabled_profiles = [p for p in self._current_selection if p.custom_enabled]
-# 		if enabled_profiles:
-# 			details = ', '.join([p.name for p in enabled_profiles])
-# 			gfx_driver = self.gfx_driver
-# 			return ProfileInfo(self.name, details, gfx_driver)
-#
-# 		return None
-#
-# 	def reset(self):
-# 		for profile in self._current_selection:
-# 			profile.set_enabled(False)
-#
-# 		self.gfx_driver = None
-#
-#
-# class CustomTypeProfile(Profile):
-# 	def __init__(
-# 		self,
-# 		name: str,
-# 		enabled: bool = False,
-# 		packages: List[str] = [],
-# 		services: List[str] = []
-# 	):
-# 		super().__init__(
-# 			name,
-# 			ProfileType.CustomType,
-# 			packages=packages,
-# 			services=services,
-# 			support_gfx_driver=True
-# 		)
-#
-# 		self.custom_enabled = enabled
-#
-# 	def json(self) -> Dict[str, Any]:
-# 		return {
-# 			'name': self.name,
-# 			'packages': self.packages,
-# 			'services': self.services,
-# 			'enabled': self.custom_enabled
-# 		}

archinstall/default_profiles/desktop.py

@@ -1,30 +1,28 @@
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Self, override
 
-from archinstall.lib.output import info
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType, SelectResult
+from archinstall.lib.log import info
+from archinstall.lib.menu.helpers import Selection
 from archinstall.lib.profile.profiles_handler import profile_handler
-from archinstall.default_profiles.profile import Profile, ProfileType, SelectResult, GreeterType
-
-from archinstall.tui import (
-	MenuItemGroup, MenuItem, SelectMenu,
-	FrameProperties, ResultType, PreviewStyle
-)
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
 
 if TYPE_CHECKING:
 	from archinstall.lib.installer import Installer
-	_: Any
+	from archinstall.lib.models.users import User
 
 
 class DesktopProfile(Profile):
-	def __init__(self, current_selection: list[Profile] = []) -> None:
+	def __init__(self, current_selection: list[Self] = []) -> None:
 		super().__init__(
 			'Desktop',
 			ProfileType.Desktop,
-			description=str(_('Provides a selection of desktop environments and tiling window managers, e.g. GNOME, KDE Plasma, Sway')),
 			current_selection=current_selection,
-			support_greeter=True
+			support_greeter=True,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
 			'nano',
@@ -32,14 +30,12 @@ class DesktopProfile(Profile):
 			'openssh',
 			'htop',
 			'wget',
-			'iwd',
-			'wireless_tools',
-			'wpa_supplicant',
 			'smartmontools',
-			'xdg-utils'
+			'xdg-utils',
 		]
 
 	@property
+	@override
 	def default_greeter_type(self) -> GreeterType | None:
 		combined_greeters: dict[GreeterType, int] = {}
 		for profile in self.current_selection:
@@ -52,54 +48,67 @@ class DesktopProfile(Profile):
 
 		return None
 
-	def _do_on_select_profiles(self) -> None:
+	async def _do_on_select_profiles(self) -> None:
 		for profile in self.current_selection:
-			profile.do_on_select()
+			await profile.do_on_select()
 
-	def do_on_select(self) -> SelectResult | None:
+	@override
+	async def do_on_select(self) -> SelectResult:
 		items = [
 			MenuItem(
 				p.name,
 				value=p,
-				preview_action=lambda x: x.value.preview_text()
-			) for p in profile_handler.get_desktop_profiles()
+				preview_action=lambda x: x.value.preview_text() if x.value else None,
+			)
+			for p in profile_handler.get_desktop_profiles()
 		]
 
-		group = MenuItemGroup(items, sort_items=True)
+		group = MenuItemGroup(items, sort_items=True, sort_case_sensitive=False)
 		group.set_selected_by_value(self.current_selection)
 
-		result = SelectMenu(
+		result = await Selection[Self](
 			group,
 			multi=True,
 			allow_reset=True,
 			allow_skip=True,
-			preview_style=PreviewStyle.RIGHT,
-			preview_size='auto',
-			preview_frame=FrameProperties.max('Info')
-		).run()
+			preview_location='right',
+		).show()
 
 		match result.type_:
 			case ResultType.Selection:
 				self.current_selection = result.get_values()
-				self._do_on_select_profiles()
+				await self._do_on_select_profiles()
 				return SelectResult.NewSelection
 			case ResultType.Skip:
 				return SelectResult.SameSelection
 			case ResultType.Reset:
 				return SelectResult.ResetCurrent
 
-	def post_install(self, install_session: 'Installer') -> None:
+	@override
+	def post_install(self, install_session: Installer) -> None:
 		for profile in self.current_selection:
 			profile.post_install(install_session)
 
-	def install(self, install_session: 'Installer') -> None:
+	@override
+	def provision(self, install_session: Installer, users: list[User]) -> None:
+		for profile in self.current_selection:
+			profile.provision(install_session, users)
+
+	@override
+	def install(self, install_session: Installer) -> None:
 		# Install common packages for all desktop environments
 		install_session.add_additional_packages(self.packages)
 
+		xorg_installed = False
+
 		for profile in self.current_selection:
 			info(f'Installing profile {profile.name}...')
 
 			install_session.add_additional_packages(profile.packages)
 			install_session.enable_service(profile.services)
 
+			if not xorg_installed and profile.display_server == DisplayServerType.Xorg:
+				install_session.add_additional_packages(['xorg-server', 'xorg-xinit'])
+				xorg_installed = True
+
 			profile.install(install_session)

archinstall/default_profiles/desktops/awesome.py

@@ -1,23 +1,26 @@
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, override
 
-from archinstall.default_profiles.profile import ProfileType
-from archinstall.default_profiles.xorg import XorgProfile
+from archinstall.default_profiles.profile import DisplayServerType, Profile, ProfileType
 
 if TYPE_CHECKING:
 	from archinstall.lib.installer import Installer
-	_: Any
 
 
-class AwesomeProfile(XorgProfile):
+class AwesomeProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Awesome', ProfileType.WindowMgr, description='')
+		super().__init__(
+			'Awesome',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
-		return super().packages + [
+		return [
 			'awesome',
 			'alacritty',
-			'xorg-xinit',
 			'xorg-xrandr',
 			'xterm',
 			'feh',
@@ -28,36 +31,37 @@ class AwesomeProfile(XorgProfile):
 			'xsel',
 		]
 
-	def install(self, install_session: 'Installer') -> None:
+	@override
+	def install(self, install_session: Installer) -> None:
 		super().install(install_session)
 
 		# TODO: Copy a full configuration to ~/.config/awesome/rc.lua instead.
-		with open(f"{install_session.target}/etc/xdg/awesome/rc.lua") as fh:
+		with open(f'{install_session.target}/etc/xdg/awesome/rc.lua') as fh:
 			awesome_lua = fh.read()
 
 		# Replace xterm with alacritty for a smoother experience.
 		awesome_lua = awesome_lua.replace('"xterm"', '"alacritty"')
 
-		with open(f"{install_session.target}/etc/xdg/awesome/rc.lua", 'w') as fh:
+		with open(f'{install_session.target}/etc/xdg/awesome/rc.lua', 'w') as fh:
 			fh.write(awesome_lua)
 
 		# TODO: Configure the right-click-menu to contain the above packages that were installed. (as a user config)
 
 		# TODO: check if we selected a greeter,
 		# but for now, awesome is intended to run without one.
-		with open(f"{install_session.target}/etc/X11/xinit/xinitrc") as xinitrc:
+		with open(f'{install_session.target}/etc/X11/xinit/xinitrc') as xinitrc:
 			xinitrc_data = xinitrc.read()
 
 		for line in xinitrc_data.split('\n'):
-			if "twm &" in line:
-				xinitrc_data = xinitrc_data.replace(line, f"# {line}")
-			if "xclock" in line:
-				xinitrc_data = xinitrc_data.replace(line, f"# {line}")
-			if "xterm" in line:
-				xinitrc_data = xinitrc_data.replace(line, f"# {line}")
+			if 'twm &' in line:
+				xinitrc_data = xinitrc_data.replace(line, f'# {line}')
+			if 'xclock' in line:
+				xinitrc_data = xinitrc_data.replace(line, f'# {line}')
+			if 'xterm' in line:
+				xinitrc_data = xinitrc_data.replace(line, f'# {line}')
 
 		xinitrc_data += '\n'
 		xinitrc_data += 'exec awesome\n'
 
-		with open(f"{install_session.target}/etc/X11/xinit/xinitrc", 'w') as xinitrc:
+		with open(f'{install_session.target}/etc/X11/xinit/xinitrc', 'w') as xinitrc:
 			xinitrc.write(xinitrc_data)

archinstall/default_profiles/desktops/bspwm.py

@@ -1,27 +1,39 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
+from archinstall.lib.installer import Installer
+from archinstall.lib.models.users import User
 
 
-class BspwmProfile(XorgProfile):
+class BspwmProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Bspwm', ProfileType.WindowMgr, description='')
+		super().__init__(
+			'Bspwm',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
-		# return super().packages + [
 		return [
 			'bspwm',
 			'sxhkd',
 			'dmenu',
 			'xdo',
-			'rxvt-unicode'
+			'rxvt-unicode',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm
+
+	@override
+	def provision(self, install_session: Installer, users: list[User]) -> None:
+		for user in users:
+			install_session.arch_chroot('mkdir -p ~/.config/bspwm ~/.config/sxhkd', run_as=user.username)
+			install_session.arch_chroot('cp /usr/share/doc/bspwm/examples/bspwmrc ~/.config/bspwm/', run_as=user.username)
+			install_session.arch_chroot('cp /usr/share/doc/bspwm/examples/sxhkdrc ~/.config/sxhkd/', run_as=user.username)
+			install_session.arch_chroot('chmod +x ~/.config/bspwm/bspwmrc', run_as=user.username)

archinstall/default_profiles/desktops/budgie.py

@@ -1,26 +1,30 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class BudgieProfile(XorgProfile):
+class BudgieProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Budgie', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Budgie',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"arc-gtk-theme",
-			"budgie",
-			"mate-terminal",
-			"nemo",
-			"papirus-icon-theme"
+			'materia-gtk-theme',
+			'budgie',
+			'mate-terminal',
+			'nemo',
+			'nemo-fileroller',
+			'papirus-icon-theme',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.LightdmSlick

archinstall/default_profiles/desktops/cinnamon.py

@@ -1,32 +1,33 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class CinnamonProfile(XorgProfile):
+class CinnamonProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Cinnamon', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Cinnamon',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"cinnamon",
-			"system-config-printer",
-			"gnome-keyring",
-			"gnome-terminal",
-			"blueman",
-			"bluez-utils",
-			"engrampa",
-			"gnome-screenshot",
-			"gvfs-smb",
-			"xed",
-			"xdg-user-dirs-gtk"
+			'cinnamon',
+			'system-config-printer',
+			'gnome-keyring',
+			'gnome-terminal',
+			'engrampa',
+			'gnome-screenshot',
+			'gvfs-smb',
+			'xed',
+			'xdg-user-dirs-gtk',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/cosmic.py

@@ -1,22 +1,26 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class CosmicProfile(XorgProfile):
+class CosmicProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('cosmic-epoch', ProfileType.DesktopEnv, description='', advanced=True)
+		super().__init__(
+			'Cosmic',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"cosmic",
+			'cosmic',
+			'xdg-user-dirs',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.CosmicSession

archinstall/default_profiles/desktops/cutefish.py

@@ -1,27 +0,0 @@
-from typing import Any, TYPE_CHECKING
-
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	from archinstall.lib.installer import Installer
-	_: Any
-
-
-class CutefishProfile(XorgProfile):
-	def __init__(self) -> None:
-		super().__init__('Cutefish', ProfileType.DesktopEnv, description='')
-
-	@property
-	def packages(self) -> list[str]:
-		return [
-			"cutefish",
-			"noto-fonts"
-		]
-
-	@property
-	def default_greeter_type(self) -> GreeterType | None:
-		return GreeterType.Sddm
-
-	def install(self, install_session: 'Installer') -> None:
-		super().install(install_session)

archinstall/default_profiles/desktops/deepin.py

@@ -1,24 +1,27 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class DeepinProfile(XorgProfile):
+class DeepinProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Deepin', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Deepin',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"deepin",
-			"deepin-terminal",
-			"deepin-editor"
+			'deepin',
+			'deepin-terminal',
+			'deepin-editor',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/enlightenment.py

@@ -1,23 +1,26 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class EnlighenmentProfile(XorgProfile):
+class EnlightenmentProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Enlightenment', ProfileType.WindowMgr, description='')
+		super().__init__(
+			'Enlightenment',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"enlightenment",
-			"terminology"
+			'enlightenment',
+			'terminology',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/gnome.py

@@ -1,23 +1,26 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class GnomeProfile(XorgProfile):
+class GnomeProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Gnome', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'GNOME',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
 			'gnome',
-			'gnome-tweaks'
+			'gnome-tweaks',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Gdm

archinstall/default_profiles/desktops/hyprland.py

@@ -1,81 +1,52 @@
-from enum import Enum
-from typing import TYPE_CHECKING, Any
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType, SelectResult
-from archinstall.default_profiles.xorg import XorgProfile
-from archinstall.tui import (
-	MenuItemGroup, MenuItem, SelectMenu,
-	FrameProperties, ResultType, Alignment
-)
-
-if TYPE_CHECKING:
-	from archinstall.lib.installer import Installer
-	_: Any
+from archinstall.default_profiles.desktops.utils import select_seat_access
+from archinstall.default_profiles.profile import CustomSetting, DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class SeatAccess(Enum):
-	seatd = 'seatd'
-	polkit = 'polkit'
-
-
-class HyprlandProfile(XorgProfile):
+class HyprlandProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Hyprland', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Hyprland',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
 
-		self.custom_settings = {'seat_access': None}
+		self.custom_settings = {CustomSetting.SeatAccess: None}
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"hyprland",
-			"dunst",
-			"kitty",
-			"dolphin",
-			"wofi",
-			"xdg-desktop-portal-hyprland",
-			"qt5-wayland",
-			"qt6-wayland",
-			"polkit-kde-agent",
-			"grim",
-			"slurp"
+			'hyprland',
+			'dunst',
+			'kitty',
+			'uwsm',
+			'dolphin',
+			'wofi',
+			'xdg-desktop-portal-hyprland',
+			'qt5-wayland',
+			'qt6-wayland',
+			'polkit-kde-agent',
+			'grim',
+			'slurp',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Sddm
 
 	@property
+	@override
 	def services(self) -> list[str]:
-		if pref := self.custom_settings.get('seat_access', None):
+		if pref := self.custom_settings.get(CustomSetting.SeatAccess, None):
 			return [pref]
 		return []
 
-	def _ask_seat_access(self) -> None:
-		# need to activate seat service and add to seat group
-		header = str(_('Sway needs access to your seat (collection of hardware devices i.e. keyboard, mouse, etc)'))
-		header += '\n' + str(_('Choose an option to give Sway access to your hardware')) + '\n'
-
-		items = [MenuItem(s.value, value=s) for s in SeatAccess]
-		group = MenuItemGroup(items, sort_items=True)
-
-		default = self.custom_settings.get('seat_access', None)
-		group.set_default_by_value(default)
-
-		result = SelectMenu(
-			group,
-			header=header,
-			allow_skip=False,
-			frame=FrameProperties.min(str(_('Seat access'))),
-			alignment=Alignment.CENTER
-		).run()
-
-		if result.type_ == ResultType.Selection:
-			if result.item() is not None:
-				self.custom_settings['seat_access'] = result.get_value()
-
-	def do_on_select(self) -> SelectResult | None:
-		self._ask_seat_access()
-		return None
-
-	def install(self, install_session: 'Installer') -> None:
-		super().install(install_session)
+	@override
+	async def do_on_select(self) -> None:
+		default = self.custom_settings.get(CustomSetting.SeatAccess, None)
+		seat_access = await select_seat_access(self.name, default)
+		self.custom_settings[CustomSetting.SeatAccess] = seat_access.value

archinstall/default_profiles/desktops/i3.py

@@ -1,17 +1,19 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class I3wmProfile(XorgProfile):
+class I3wmProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('i3-wm', ProfileType.WindowMgr, description='')
+		super().__init__(
+			'i3-wm',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
 			'i3-wm',
@@ -22,9 +24,10 @@ class I3wmProfile(XorgProfile):
 			'xterm',
 			'lightdm-gtk-greeter',
 			'lightdm',
-			'dmenu'
+			'dmenu',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/labwc.py

@@ -0,0 +1,46 @@
+from typing import override
+
+from archinstall.default_profiles.desktops.utils import select_seat_access
+from archinstall.default_profiles.profile import CustomSetting, DisplayServerType, GreeterType, Profile, ProfileType
+
+
+class LabwcProfile(Profile):
+	def __init__(self) -> None:
+		super().__init__(
+			'Labwc',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
+
+		self.custom_settings = {CustomSetting.SeatAccess: None}
+
+	@property
+	@override
+	def packages(self) -> list[str]:
+		additional = []
+		if seat := self.custom_settings.get(CustomSetting.SeatAccess, None):
+			additional = [seat]
+
+		return [
+			'alacritty',
+			'labwc',
+		] + additional
+
+	@property
+	@override
+	def default_greeter_type(self) -> GreeterType:
+		return GreeterType.Lightdm
+
+	@property
+	@override
+	def services(self) -> list[str]:
+		if pref := self.custom_settings.get(CustomSetting.SeatAccess, None):
+			return [pref]
+		return []
+
+	@override
+	async def do_on_select(self) -> None:
+		default = self.custom_settings.get(CustomSetting.SeatAccess, None)
+		seat_access = await select_seat_access(self.name, default)
+		self.custom_settings[CustomSetting.SeatAccess] = seat_access.value

archinstall/default_profiles/desktops/lxqt.py

@@ -1,31 +1,34 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class LxqtProfile(XorgProfile):
+class LxqtProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Lxqt', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Lxqt',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	# NOTE: SDDM is the only officially supported greeter for LXQt, so unlike other DEs, lightdm is not used here.
 	# LXQt works with lightdm, but since this is not supported, we will not default to this.
 	# https://github.com/lxqt/lxqt/issues/795
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"lxqt",
-			"breeze-icons",
-			"oxygen-icons",
-			"xdg-utils",
-			"ttf-freefont",
-			"leafpad",
-			"slock"
+			'lxqt',
+			'breeze-icons',
+			'oxygen-icons',
+			'xdg-utils',
+			'ttf-freefont',
+			'l3afpad',
+			'slock',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Sddm

archinstall/default_profiles/desktops/mate.py

@@ -1,23 +1,26 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class MateProfile(XorgProfile):
+class MateProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Mate', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Mate',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"mate",
-			"mate-extra"
+			'mate',
+			'mate-extra',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/niri.py

@@ -0,0 +1,54 @@
+from typing import override
+
+from archinstall.default_profiles.desktops.utils import select_seat_access
+from archinstall.default_profiles.profile import CustomSetting, DisplayServerType, GreeterType, Profile, ProfileType
+
+
+class NiriProfile(Profile):
+	def __init__(self) -> None:
+		super().__init__(
+			'niri',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
+
+		self.custom_settings = {CustomSetting.SeatAccess: None}
+
+	@property
+	@override
+	def packages(self) -> list[str]:
+		additional = []
+		if seat := self.custom_settings.get(CustomSetting.SeatAccess, None):
+			additional = [seat]
+
+		return [
+			'niri',
+			'alacritty',
+			'fuzzel',
+			'mako',
+			'xorg-xwayland',
+			'waybar',
+			'swaybg',
+			'swayidle',
+			'swaylock',
+			'xdg-desktop-portal-gnome',
+		] + additional
+
+	@property
+	@override
+	def default_greeter_type(self) -> GreeterType:
+		return GreeterType.Lightdm
+
+	@property
+	@override
+	def services(self) -> list[str]:
+		if pref := self.custom_settings.get(CustomSetting.SeatAccess, None):
+			return [pref]
+		return []
+
+	@override
+	async def do_on_select(self) -> None:
+		default = self.custom_settings.get(CustomSetting.SeatAccess, None)
+		seat_access = await select_seat_access(self.name, default)
+		self.custom_settings[CustomSetting.SeatAccess] = seat_access.value

archinstall/default_profiles/desktops/niri_dms.py

@@ -0,0 +1,66 @@
+import shutil
+from pathlib import Path
+from typing import TYPE_CHECKING, override
+
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+	from archinstall.lib.models.users import User
+
+
+_TERMINAL = 'alacritty'
+_ASSETS_DIR = Path(__file__).parent / 'niri_dms_assets'
+
+
+class NiriDmsProfile(Profile):
+	def __init__(self) -> None:
+		super().__init__(
+			'niri - DankMaterialShell',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
+
+	@property
+	@override
+	def packages(self) -> list[str]:
+		return [
+			'niri',
+			'dms-shell-niri',
+			'polkit',
+			'xdg-desktop-portal-gnome',
+			'xorg-xwayland',
+			'matugen',
+			'cava',
+			'kimageformats',
+			'cups-pk-helper',
+			'tuned-ppd',
+			_TERMINAL,
+		]
+
+	@property
+	@override
+	def default_greeter_type(self) -> GreeterType:
+		return GreeterType.GreetdDms
+
+	@override
+	def provision(self, install_session: Installer, users: list[User]) -> None:
+		binds = (_ASSETS_DIR / 'dms/binds.kdl').read_text().replace('{{TERMINAL_COMMAND}}', _TERMINAL)
+
+		for user in users:
+			home = install_session.target / 'home' / user.username
+			niri_dir = home / '.config/niri'
+			dms_dir = niri_dir / 'dms'
+			dms_dir.mkdir(parents=True, exist_ok=True)
+
+			shutil.copy(_ASSETS_DIR / 'niri.kdl', niri_dir / 'config.kdl')
+			for name in ('colors.kdl', 'layout.kdl', 'alttab.kdl', 'outputs.kdl', 'cursor.kdl'):
+				shutil.copy(_ASSETS_DIR / 'dms' / name, dms_dir / name)
+			(dms_dir / 'binds.kdl').write_text(binds)
+
+			niri_unit_dropin = home / '.config/systemd/user/niri.service.d'
+			niri_unit_dropin.mkdir(parents=True, exist_ok=True)
+			(niri_unit_dropin / 'dms.conf').write_text('[Unit]\nWants=dms.service\n')
+
+			install_session.arch_chroot(f'chown -R {user.username}:{user.username} /home/{user.username}/.config')

archinstall/default_profiles/desktops/niri_dms_assets/dms/alttab.kdl

@@ -0,0 +1,10 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+recent-windows {
+    highlight {
+        corner-radius 12
+    }
+}

archinstall/default_profiles/desktops/niri_dms_assets/dms/binds.kdl

@@ -0,0 +1,221 @@
+binds {
+    // === System & Overview ===
+    Mod+D repeat=false { toggle-overview; }
+    Mod+Tab repeat=false { toggle-overview; }
+    Mod+Shift+Slash { show-hotkey-overlay; }
+
+    // === Application Launchers ===
+    Mod+T hotkey-overlay-title="Open Terminal" { spawn "{{TERMINAL_COMMAND}}"; }
+    Mod+Space hotkey-overlay-title="Application Launcher" {
+        spawn "dms" "ipc" "call" "spotlight" "toggle";
+    }
+    Mod+V hotkey-overlay-title="Clipboard Manager" {
+        spawn "dms" "ipc" "call" "clipboard" "toggle";
+    }
+    Mod+M hotkey-overlay-title="Task Manager" {
+        spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
+    }
+
+    Super+X hotkey-overlay-title="Power Menu: Toggle" { spawn "dms" "ipc" "call" "powermenu" "toggle"; }
+    Mod+Comma hotkey-overlay-title="Settings" {
+        spawn "dms" "ipc" "call" "settings" "focusOrToggle";
+    }
+    Mod+Y hotkey-overlay-title="Browse Wallpapers" {
+        spawn "dms" "ipc" "call" "dankdash" "wallpaper";
+    }
+    Mod+N hotkey-overlay-title="Notification Center" { spawn "dms" "ipc" "call" "notifications" "toggle"; }
+    Mod+Shift+N hotkey-overlay-title="Notepad" { spawn "dms" "ipc" "call" "notepad" "toggle"; }
+
+    // === Security ===
+    Mod+Alt+L hotkey-overlay-title="Lock Screen" {
+        spawn "dms" "ipc" "call" "lock" "lock";
+    }
+    Mod+Shift+E { quit; }
+    Ctrl+Alt+Delete hotkey-overlay-title="Task Manager" {
+        spawn "dms" "ipc" "call" "processlist" "focusOrToggle";
+    }
+
+    // === Audio Controls ===
+    XF86AudioRaiseVolume allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "increment" "3";
+    }
+    XF86AudioLowerVolume allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "decrement" "3";
+    }
+    XF86AudioMute allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "mute";
+    }
+    XF86AudioMicMute allow-when-locked=true {
+        spawn "dms" "ipc" "call" "audio" "micmute";
+    }
+		XF86AudioPause allow-when-locked=true {
+		    spawn "dms" "ipc" "call" "mpris" "playPause";
+		}
+		XF86AudioPlay allow-when-locked=true {
+		    spawn "dms" "ipc" "call" "mpris" "playPause";
+		}
+		XF86AudioPrev allow-when-locked=true {
+		    spawn "dms" "ipc" "call" "mpris" "previous";
+		}
+		XF86AudioNext allow-when-locked=true {
+		    spawn "dms" "ipc" "call" "mpris" "next";
+		}
+        Ctrl+XF86AudioRaiseVolume allow-when-locked=true {
+            spawn "dms" "ipc" "call" "mpris" "increment" "3";
+        }
+        Ctrl+XF86AudioLowerVolume allow-when-locked=true {
+            spawn "dms" "ipc" "call" "mpris" "decrement" "3";
+        }
+
+    // === Brightness Controls ===
+    XF86MonBrightnessUp allow-when-locked=true {
+       spawn "dms" "ipc" "call" "brightness" "increment" "5" "";
+    }
+    XF86MonBrightnessDown allow-when-locked=true {
+       spawn "dms" "ipc" "call" "brightness" "decrement" "5" "";
+    }
+
+    // === Window Management ===
+    Mod+Q repeat=false { close-window; }
+    Mod+F { maximize-column; }
+    Mod+Shift+F { fullscreen-window; }
+    Mod+Shift+T { toggle-window-floating; }
+    Mod+Shift+V { switch-focus-between-floating-and-tiling; }
+    Mod+W { toggle-column-tabbed-display; }
+    Mod+Shift+W hotkey-overlay-title="Create window rule" { spawn "dms" "ipc" "call" "window-rules" "toggle"; }
+
+    // === Focus Navigation ===
+    Mod+Left  { focus-column-left; }
+    Mod+Down  { focus-window-down; }
+    Mod+Up    { focus-window-up; }
+    Mod+Right { focus-column-right; }
+    Mod+H     { focus-column-left; }
+    Mod+J     { focus-window-down; }
+    Mod+K     { focus-window-up; }
+    Mod+L     { focus-column-right; }
+
+    // === Window Movement ===
+    Mod+Shift+Left  { move-column-left; }
+    Mod+Shift+Down  { move-window-down; }
+    Mod+Shift+Up    { move-window-up; }
+    Mod+Shift+Right { move-column-right; }
+    Mod+Shift+H     { move-column-left; }
+    Mod+Shift+J     { move-window-down; }
+    Mod+Shift+K     { move-window-up; }
+    Mod+Shift+L     { move-column-right; }
+
+    // === Column Navigation ===
+    Mod+Home { focus-column-first; }
+    Mod+End  { focus-column-last; }
+    Mod+Ctrl+Home { move-column-to-first; }
+    Mod+Ctrl+End  { move-column-to-last; }
+
+    // === Monitor Navigation ===
+    Mod+Ctrl+Left  { focus-monitor-left; }
+    //Mod+Ctrl+Down  { focus-monitor-down; }
+    //Mod+Ctrl+Up    { focus-monitor-up; }
+    Mod+Ctrl+Right { focus-monitor-right; }
+    Mod+Ctrl+H     { focus-monitor-left; }
+    Mod+Ctrl+J     { focus-monitor-down; }
+    Mod+Ctrl+K     { focus-monitor-up; }
+    Mod+Ctrl+L     { focus-monitor-right; }
+
+    // === Move to Monitor ===
+    Mod+Shift+Ctrl+Left  { move-column-to-monitor-left; }
+    Mod+Shift+Ctrl+Down  { move-column-to-monitor-down; }
+    Mod+Shift+Ctrl+Up    { move-column-to-monitor-up; }
+    Mod+Shift+Ctrl+Right { move-column-to-monitor-right; }
+    Mod+Shift+Ctrl+H     { move-column-to-monitor-left; }
+    Mod+Shift+Ctrl+J     { move-column-to-monitor-down; }
+    Mod+Shift+Ctrl+K     { move-column-to-monitor-up; }
+    Mod+Shift+Ctrl+L     { move-column-to-monitor-right; }
+
+    // === Workspace Navigation ===
+    Mod+Page_Down      { focus-workspace-down; }
+    Mod+Page_Up        { focus-workspace-up; }
+    Mod+U              { focus-workspace-down; }
+    Mod+I              { focus-workspace-up; }
+    Mod+Ctrl+Down { move-column-to-workspace-down; }
+    Mod+Ctrl+Up   { move-column-to-workspace-up; }
+    Mod+Ctrl+U         { move-column-to-workspace-down; }
+    Mod+Ctrl+I         { move-column-to-workspace-up; }
+
+    // === Workspace Management ===
+    Ctrl+Shift+R hotkey-overlay-title="Rename Workspace" {
+        spawn "dms" "ipc" "call" "workspace-rename" "open";
+    }
+
+    // === Move Workspaces ===
+    Mod+Shift+Page_Down { move-workspace-down; }
+    Mod+Shift+Page_Up   { move-workspace-up; }
+    Mod+Shift+U         { move-workspace-down; }
+    Mod+Shift+I         { move-workspace-up; }
+
+    // === Mouse Wheel Navigation ===
+    Mod+WheelScrollDown      cooldown-ms=150 { focus-workspace-down; }
+    Mod+WheelScrollUp        cooldown-ms=150 { focus-workspace-up; }
+    Mod+Ctrl+WheelScrollDown cooldown-ms=150 { move-column-to-workspace-down; }
+    Mod+Ctrl+WheelScrollUp   cooldown-ms=150 { move-column-to-workspace-up; }
+
+    Mod+WheelScrollRight      { focus-column-right; }
+    Mod+WheelScrollLeft       { focus-column-left; }
+    Mod+Ctrl+WheelScrollRight { move-column-right; }
+    Mod+Ctrl+WheelScrollLeft  { move-column-left; }
+
+    Mod+Shift+WheelScrollDown      { focus-column-right; }
+    Mod+Shift+WheelScrollUp        { focus-column-left; }
+    Mod+Ctrl+Shift+WheelScrollDown { move-column-right; }
+    Mod+Ctrl+Shift+WheelScrollUp   { move-column-left; }
+
+    // === Numbered Workspaces ===
+    Mod+1 { focus-workspace 1; }
+    Mod+2 { focus-workspace 2; }
+    Mod+3 { focus-workspace 3; }
+    Mod+4 { focus-workspace 4; }
+    Mod+5 { focus-workspace 5; }
+    Mod+6 { focus-workspace 6; }
+    Mod+7 { focus-workspace 7; }
+    Mod+8 { focus-workspace 8; }
+    Mod+9 { focus-workspace 9; }
+
+    // === Move to Numbered Workspaces ===
+    Mod+Shift+1 { move-column-to-workspace 1; }
+    Mod+Shift+2 { move-column-to-workspace 2; }
+    Mod+Shift+3 { move-column-to-workspace 3; }
+    Mod+Shift+4 { move-column-to-workspace 4; }
+    Mod+Shift+5 { move-column-to-workspace 5; }
+    Mod+Shift+6 { move-column-to-workspace 6; }
+    Mod+Shift+7 { move-column-to-workspace 7; }
+    Mod+Shift+8 { move-column-to-workspace 8; }
+    Mod+Shift+9 { move-column-to-workspace 9; }
+
+    // === Column Management ===
+    Mod+BracketLeft  { consume-or-expel-window-left; }
+    Mod+BracketRight { consume-or-expel-window-right; }
+    Mod+Period { expel-window-from-column; }
+
+    // === Sizing & Layout ===
+    Mod+R { switch-preset-column-width; }
+    Mod+Shift+R { switch-preset-window-height; }
+    Mod+Ctrl+R { reset-window-height; }
+    Mod+Ctrl+F { expand-column-to-available-width; }
+    Mod+C { center-column; }
+    Mod+Ctrl+C { center-visible-columns; }
+
+    // === Manual Sizing ===
+    Mod+Minus { set-column-width "-10%"; }
+    Mod+Equal { set-column-width "+10%"; }
+    Mod+Shift+Minus { set-window-height "-10%"; }
+    Mod+Shift+Equal { set-window-height "+10%"; }
+
+    // === Screenshots ===
+    XF86Launch1 { screenshot; }
+    Ctrl+XF86Launch1 { screenshot-screen; }
+    Alt+XF86Launch1 { screenshot-window; }
+    Print { screenshot; }
+    Ctrl+Print { screenshot-screen; }
+    Alt+Print { screenshot-window; }
+    // === System Controls ===
+    Mod+Escape allow-inhibiting=false { toggle-keyboard-shortcuts-inhibit; }
+    Mod+Shift+P { power-off-monitors; }
+}

archinstall/default_profiles/desktops/niri_dms_assets/dms/colors.kdl

@@ -0,0 +1,39 @@
+// ! Auto-generated file. Do not edit directly.
+// Remove `include "dms/colors.kdl"` from your config to override.
+
+layout {
+    background-color "transparent"
+
+    focus-ring {
+        active-color   "#d0bcff"
+        inactive-color "#948f99"
+        urgent-color   "#f2b8b5"
+    }
+
+    border {
+        active-color   "#d0bcff"
+        inactive-color "#948f99"
+        urgent-color   "#f2b8b5"
+    }
+
+    shadow {
+        color "#00000070"
+    }
+
+    tab-indicator {
+        active-color   "#d0bcff"
+        inactive-color "#948f99"
+        urgent-color   "#f2b8b5"
+    }
+
+    insert-hint {
+        color "#d0bcff80"
+    }
+}
+
+recent-windows {
+    highlight {
+        active-color   "#4f378b"
+        urgent-color   "#f2b8b5"
+    }
+}

archinstall/default_profiles/desktops/niri_dms_assets/dms/cursor.kdl

@@ -0,0 +1,6 @@
+// Place cursor configuration here.
+// Example:
+// cursor {
+//     xcursor-theme "Adwaita"
+//     xcursor-size 24
+// }

archinstall/default_profiles/desktops/niri_dms_assets/dms/layout.kdl

@@ -0,0 +1,22 @@
+// ! DO NOT EDIT !
+// ! AUTO-GENERATED BY DMS !
+// ! CHANGES WILL BE OVERWRITTEN !
+// ! PLACE YOUR CUSTOM CONFIGURATION ELSEWHERE !
+
+layout {
+    gaps 4
+
+    border {
+        width 2
+    }
+
+    focus-ring {
+        width 2
+    }
+}
+window-rule {
+    geometry-corner-radius 12
+    clip-to-geometry true
+    tiled-state true
+    draw-border-with-background false
+}

archinstall/default_profiles/desktops/niri_dms_assets/dms/outputs.kdl

@@ -0,0 +1,7 @@
+// Place per-output configuration here.
+// Example:
+// output "DP-1" {
+//     mode "2560x1440@165"
+//     position x=0 y=0
+//     scale 1
+// }

archinstall/default_profiles/desktops/niri_dms_assets/niri.kdl

@@ -0,0 +1,279 @@
+// This config is in the KDL format: https://kdl.dev
+// "/-" comments out the following node.
+// Check the wiki for a full description of the configuration:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Introduction
+config-notification {
+    disable-failed
+}
+
+gestures {
+    hot-corners {
+        off
+    }
+}
+
+// Input device configuration.
+// Find the full list of options on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Input
+input {
+    keyboard {
+        xkb {
+            // You can set rules, model, layout, variant and options.
+            // For more information, see xkeyboard-config(7).
+
+            // For example:
+            // layout "us,ru"
+            // options "grp:win_space_toggle,compose:ralt,ctrl:nocaps"
+
+            // If this section is empty, niri will fetch xkb settings
+            // from org.freedesktop.locale1. You can control these using
+            // localectl set-x11-keymap.
+        }
+
+        // Enable numlock on startup, omitting this setting disables it.
+        numlock
+    }
+
+    // Next sections include libinput settings.
+    // Omitting settings disables them, or leaves them at their default values.
+    // All commented-out settings here are examples, not defaults.
+    touchpad {
+        // off
+        tap
+        // dwt
+        // dwtp
+        // drag false
+        // drag-lock
+        natural-scroll
+        // accel-speed 0.2
+        // accel-profile "flat"
+        // scroll-method "two-finger"
+        // disabled-on-external-mouse
+    }
+
+    mouse {
+        // off
+        // natural-scroll
+        // accel-speed 0.2
+        // accel-profile "flat"
+        // scroll-method "no-scroll"
+    }
+
+    trackpoint {
+        // off
+        // natural-scroll
+        // accel-speed 0.2
+        // accel-profile "flat"
+        // scroll-method "on-button-down"
+        // scroll-button 273
+        // scroll-button-lock
+        // middle-emulation
+    }
+
+    // Uncomment this to make the mouse warp to the center of newly focused windows.
+    // warp-mouse-to-focus
+
+    // Focus windows and outputs automatically when moving the mouse into them.
+    // Setting max-scroll-amount="0%" makes it work only on windows already fully on screen.
+    // focus-follows-mouse max-scroll-amount="0%"
+}
+// You can configure outputs by their name, which you can find
+// by running `niri msg outputs` while inside a niri instance.
+// The built-in laptop monitor is usually called "eDP-1".
+// Find more information on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Outputs
+// Remember to uncomment the node by removing "/-"!
+/-output "eDP-2" {
+    mode "2560x1600@239.998993"
+    position x=2560 y=0
+    variable-refresh-rate
+}
+// Settings that influence how windows are positioned and sized.
+// Find more information on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Layout
+layout {
+    // Set gaps around windows in logical pixels.
+    background-color "transparent"
+    // When to center a column when changing focus, options are:
+    // - "never", default behavior, focusing an off-screen column will keep at the left
+    //   or right edge of the screen.
+    // - "always", the focused column will always be centered.
+    // - "on-overflow", focusing a column will center it if it doesn't fit
+    //   together with the previously focused column.
+    center-focused-column "never"
+    // You can customize the widths that "switch-preset-column-width" (Mod+R) toggles between.
+    preset-column-widths {
+        // Proportion sets the width as a fraction of the output width, taking gaps into account.
+        // For example, you can perfectly fit four windows sized "proportion 0.25" on an output.
+        // The default preset widths are 1/3, 1/2 and 2/3 of the output.
+        proportion 0.33333
+        proportion 0.5
+        proportion 0.66667
+        // Fixed sets the width in logical pixels exactly.
+        // fixed 1920
+    }
+    // You can also customize the heights that "switch-preset-window-height" (Mod+Shift+R) toggles between.
+    // preset-window-heights { }
+    // You can change the default width of the new windows.
+    default-column-width { proportion 0.5; }
+    // If you leave the brackets empty, the windows themselves will decide their initial width.
+    // default-column-width {}
+    // By default focus ring and border are rendered as a solid background rectangle
+    // behind windows. That is, they will show up through semitransparent windows.
+    // This is because windows using client-side decorations can have an arbitrary shape.
+    //
+    // If you don't like that, you should uncomment `prefer-no-csd` below.
+    // Niri will draw focus ring and border *around* windows that agree to omit their
+    // client-side decorations.
+    //
+    // Alternatively, you can override it with a window rule called
+    // `draw-border-with-background`.
+    border {
+        off
+        width 4
+        active-color   "#707070"      // Neutral gray
+        inactive-color "#d0d0d0"      // Light gray
+        urgent-color   "#cc4444"      // Softer red
+    }
+    shadow {
+        softness 30
+        spread 5
+        offset x=0 y=5
+        color "#0007"
+    }
+    struts {
+    }
+}
+layer-rule {
+    match namespace="^quickshell$"
+    place-within-backdrop true
+}
+overview {
+    workspace-shadow {
+        off
+    }
+}
+// Add lines like this to spawn processes at startup.
+// Note that running niri as a session supports xdg-desktop-autostart,
+// which may be more convenient to use.
+// See the binds section below for more spawn examples.
+// This line starts waybar, a commonly used bar for Wayland compositors.
+environment {
+  XDG_CURRENT_DESKTOP "niri"
+}
+hotkey-overlay {
+    skip-at-startup
+}
+prefer-no-csd
+screenshot-path "~/Pictures/Screenshots/Screenshot from %Y-%m-%d %H-%M-%S.png"
+animations {
+    workspace-switch {
+        spring damping-ratio=0.80 stiffness=523 epsilon=0.0001
+    }
+    window-open {
+        duration-ms 150
+        curve "ease-out-expo"
+    }
+    window-close {
+        duration-ms 150
+        curve "ease-out-quad"
+    }
+    horizontal-view-movement {
+        spring damping-ratio=0.85 stiffness=423 epsilon=0.0001
+    }
+    window-movement {
+        spring damping-ratio=0.75 stiffness=323 epsilon=0.0001
+    }
+    window-resize {
+        spring damping-ratio=0.85 stiffness=423 epsilon=0.0001
+    }
+    config-notification-open-close {
+        spring damping-ratio=0.65 stiffness=923 epsilon=0.001
+    }
+    screenshot-ui-open {
+        duration-ms 200
+        curve "ease-out-quad"
+    }
+    overview-open-close {
+        spring damping-ratio=0.85 stiffness=800 epsilon=0.0001
+    }
+}
+// Window rules let you adjust behavior for individual windows.
+// Find more information on the wiki:
+// https://github.com/YaLTeR/niri/wiki/Configuration:-Window-Rules
+// Work around WezTerm's initial configure bug
+// by setting an empty default-column-width.
+window-rule {
+    // This regular expression is intentionally made as specific as possible,
+    // since this is the default config, and we want no false positives.
+    // You can get away with just app-id="wezterm" if you want.
+    match app-id=r#"^org\.wezfurlong\.wezterm$"#
+    default-column-width {}
+}
+window-rule {
+    match app-id=r#"^org\.gnome\."#
+    draw-border-with-background false
+    geometry-corner-radius 12
+    clip-to-geometry true
+}
+window-rule {
+    match app-id=r#"^gnome-control-center$"#
+    match app-id=r#"^pavucontrol$"#
+    match app-id=r#"^nm-connection-editor$"#
+    default-column-width { proportion 0.5; }
+    open-floating false
+}
+window-rule {
+    match app-id=r#"^org\.gnome\.Calculator$"#
+    match app-id=r#"^gnome-calculator$"#
+    match app-id=r#"^galculator$"#
+    match app-id=r#"^blueman-manager$"#
+    match app-id=r#"^org\.gnome\.Nautilus$"#
+    match app-id=r#"^xdg-desktop-portal$"#
+    open-floating true
+}
+window-rule {
+    match app-id=r#"^steam$"# title=r#"^notificationtoasts_\d+_desktop$"#
+    default-floating-position x=10 y=10 relative-to="bottom-right"
+    open-focused false
+}
+window-rule {
+    match app-id=r#"^org\.wezfurlong\.wezterm$"#
+    match app-id="Alacritty"
+    match app-id="zen"
+    match app-id="com.mitchellh.ghostty"
+    match app-id="kitty"
+    draw-border-with-background false
+}
+window-rule {
+    match app-id=r#"firefox$"# title="^Picture-in-Picture$"
+    match app-id="zoom"
+    open-floating true
+}
+// Open dms windows as floating by default
+window-rule {
+    match app-id=r#"org.quickshell$"#
+    match app-id=r#"com.danklinux.dms$"#
+    open-floating true
+}
+debug {
+    honor-xdg-activation-with-invalid-serial
+}
+
+// Override to disable super+tab
+recent-windows {
+    binds {
+        Alt+Tab         { next-window scope="output"; }
+        Alt+Shift+Tab   { previous-window scope="output"; }
+        Alt+grave       { next-window filter="app-id"; }
+        Alt+Shift+grave { previous-window filter="app-id"; }
+    }
+}
+
+// Include dms files
+include "dms/colors.kdl"
+include "dms/layout.kdl"
+include "dms/alttab.kdl"
+include "dms/binds.kdl"
+include "dms/outputs.kdl"
+include "dms/cursor.kdl"

archinstall/default_profiles/desktops/plasma.py

@@ -1,28 +1,120 @@
-from typing import Any, TYPE_CHECKING
+from enum import StrEnum
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import CustomSetting, DisplayServerType, GreeterType, Profile, ProfileType
+from archinstall.lib.menu.helpers import Selection
+from archinstall.lib.packages.packages import available_package, package_group_info
+from archinstall.lib.translationhandler import tr
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
 
 
-class PlasmaProfile(XorgProfile):
-	def __init__(self) -> None:
-		super().__init__('KDE Plasma', ProfileType.DesktopEnv, description='')
+class PlasmaFlavor(StrEnum):
+	Meta = 'plasma-meta'
+	Plasma = 'plasma'
+	Desktop = 'plasma-desktop'
+
+	def show(self) -> str:
+		match self:
+			case PlasmaFlavor.Meta:
+				return f'{self.value} ({tr("Recommended")})'
+			case PlasmaFlavor.Plasma | PlasmaFlavor.Desktop:
+				return self.value
+
+	def package_details(self) -> str:
+		ty = ''
+		details = ''
+		desc = ''
+
+		match self:
+			case PlasmaFlavor.Meta:
+				ty = tr('Package')
+				desc = tr('Curated selection of KDE Plasma packages')
+				info = available_package(self.value)
+
+				if info is not None:
+					details = tr('Dependencies') + '\n'
+					details += '\n'.join(f'- {entry}' for entry in info.get_depends_on)
+			case PlasmaFlavor.Plasma:
+				ty = tr('Package group')
+				desc = tr('Extensive KDE Plasma installation')
+				group = package_group_info(self.value)
+
+				if group is not None:
+					details = tr('Packages in group') + '\n'
+					details += '\n'.join(f'- {entry}' for entry in group.packages)
+			case PlasmaFlavor.Desktop:
+				ty = tr('Package group')
+				desc = tr('Minimal KDE Plasma installation')
+				info = available_package(self.value)
+
+				if info is not None:
+					details = tr('Dependencies') + '\n'
+					details += '\n'.join(f'- {entry}' for entry in info.get_depends_on)
+
+		return f'{tr("Type")}: {ty}\n{tr("Description")}: {desc}\n\n{details}'
 
-	@property
 	def packages(self) -> list[str]:
-		return [
-			"plasma-meta",
-			"konsole",
-			"kwrite",
-			"dolphin",
-			"ark",
-			"plasma-workspace",
-			"egl-wayland"
-		]
+		match self:
+			case PlasmaFlavor.Meta:
+				return ['plasma-meta']
+			case PlasmaFlavor.Plasma:
+				return ['plasma']
+			case PlasmaFlavor.Desktop:
+				return ['plasma-desktop']
+
+
+class PlasmaProfile(Profile):
+	def __init__(self) -> None:
+		super().__init__(
+			'KDE Plasma',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
-		return GreeterType.Sddm
+	@override
+	def packages(self) -> list[str]:
+		flavor_str = self.custom_settings.get(CustomSetting.PlasmaFlavor)
+
+		if flavor_str is not None:
+			flavor = PlasmaFlavor(flavor_str)
+			return flavor.packages()
+		else:
+			return PlasmaFlavor.Meta.packages()  # use plasma-meta as the recommended default
+
+	@property
+	@override
+	def default_greeter_type(self) -> GreeterType:
+		return GreeterType.PlasmaLoginManager
+
+	async def _select_flavor(self) -> None:
+		header = tr('Select a flavor of KDE Plasma to install') + '\n'
+
+		items = [
+			MenuItem(
+				s.show(),
+				value=s,
+				preview_action=lambda x: x.value.package_details() if x.value else None,
+			)
+			for s in PlasmaFlavor
+		]
+		group = MenuItemGroup(items, sort_items=False)
+
+		default = self.custom_settings.get(CustomSetting.PlasmaFlavor, None)
+		group.set_default_by_value(default)
+
+		result = await Selection[PlasmaFlavor](
+			group,
+			header=header,
+			allow_skip=False,
+			preview_location='right',
+		).show()
+
+		if result.type_ == ResultType.Selection:
+			self.custom_settings[CustomSetting.PlasmaFlavor] = result.get_value().value
+
+	@override
+	async def do_on_select(self) -> None:
+		await self._select_flavor()

archinstall/default_profiles/desktops/qtile.py

@@ -1,23 +1,26 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class QtileProfile(XorgProfile):
+class QtileProfile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Qtile', ProfileType.WindowMgr, description='')
+		super().__init__(
+			'Qtile',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
 			'qtile',
-			'alacritty'
+			'alacritty',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/river.py

@@ -0,0 +1,27 @@
+from typing import override
+
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
+
+
+class RiverProfile(Profile):
+	def __init__(self) -> None:
+		super().__init__(
+			'River',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
+		)
+
+	@property
+	@override
+	def packages(self) -> list[str]:
+		return [
+			'foot',
+			'xdg-desktop-portal-wlr',
+			'river',
+		]
+
+	@property
+	@override
+	def default_greeter_type(self) -> GreeterType:
+		return GreeterType.Lightdm

archinstall/default_profiles/desktops/sway.py

@@ -1,91 +1,56 @@
-from enum import Enum
-from typing import TYPE_CHECKING, Any
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType, SelectResult
-from archinstall.default_profiles.xorg import XorgProfile
-
-from archinstall.tui import (
-	MenuItemGroup, MenuItem, SelectMenu,
-	FrameProperties, Alignment, ResultType
-)
-
-if TYPE_CHECKING:
-	from archinstall.lib.installer import Installer
-	_: Any
+from archinstall.default_profiles.desktops.utils import select_seat_access
+from archinstall.default_profiles.profile import CustomSetting, DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class SeatAccess(Enum):
-	seatd = 'seatd'
-	polkit = 'polkit'
-
-
-class SwayProfile(XorgProfile):
+class SwayProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Sway',
 			ProfileType.WindowMgr,
-			description=''
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Wayland,
 		)
 
-		self.custom_settings = {'seat_access': None}
+		self.custom_settings = {CustomSetting.SeatAccess: None}
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		additional = []
-		if seat := self.custom_settings.get('seat_access', None):
+		if seat := self.custom_settings.get(CustomSetting.SeatAccess, None):
 			additional = [seat]
 
 		return [
-			"sway",
-			"swaybg",
-			"swaylock",
-			"swayidle",
-			"waybar",
-			"dmenu",
-			"brightnessctl",
-			"grim",
-			"slurp",
-			"pavucontrol",
-			"foot",
-			"xorg-xwayland"
+			'sway',
+			'swaybg',
+			'swaylock',
+			'swayidle',
+			'waybar',
+			'wmenu',
+			'brightnessctl',
+			'grim',
+			'slurp',
+			'pavucontrol',
+			'foot',
+			'xorg-xwayland',
 		] + additional
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm
 
 	@property
+	@override
 	def services(self) -> list[str]:
-		if pref := self.custom_settings.get('seat_access', None):
+		if pref := self.custom_settings.get(CustomSetting.SeatAccess, None):
 			return [pref]
 		return []
 
-	def _ask_seat_access(self) -> None:
-		# need to activate seat service and add to seat group
-		header = str(_('Sway needs access to your seat (collection of hardware devices i.e. keyboard, mouse, etc)'))
-		header += '\n' + str(_('Choose an option to give Sway access to your hardware')) + '\n'
-
-		items = [MenuItem(s.value, value=s) for s in SeatAccess]
-		group = MenuItemGroup(items, sort_items=True)
-
-		default = self.custom_settings.get('seat_access', None)
-		group.set_default_by_value(default)
-
-		result = SelectMenu(
-			group,
-			header=header,
-			allow_skip=False,
-			frame=FrameProperties.min(str(_('Seat access'))),
-			alignment=Alignment.CENTER
-		).run()
-
-		if result.type_ == ResultType.Selection:
-			if result.item() is not None:
-				self.custom_settings['seat_access'] = result.get_value()
-
-	def do_on_select(self) -> SelectResult | None:
-		self._ask_seat_access()
-		return None
-
-	def install(self, install_session: 'Installer') -> None:
-		super().install(install_session)
+	@override
+	async def do_on_select(self) -> None:
+		default = self.custom_settings.get(CustomSetting.SeatAccess, None)
+		seat_access = await select_seat_access(self.name, default)
+		self.custom_settings[CustomSetting.SeatAccess] = seat_access.value

archinstall/default_profiles/desktops/utils.py

@@ -0,0 +1,33 @@
+from enum import Enum
+
+from archinstall.lib.menu.helpers import Selection
+from archinstall.lib.translationhandler import tr
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
+
+
+class SeatAccess(Enum):
+	seatd = 'seatd'
+	polkit = 'polkit'
+
+
+async def select_seat_access(profile_name: str, default: str | None) -> SeatAccess:
+	header = tr('{} needs access to your seat').format(profile_name)
+	header += f' ({tr("collection of hardware devices i.e. keyboard, mouse")})' + '\n'
+	header += tr('Choose an option how to give {} access to your hardware').format(profile_name)
+
+	items = [MenuItem(s.value, value=s) for s in SeatAccess]
+	group = MenuItemGroup(items, sort_items=True)
+
+	group.set_default_by_value(default)
+
+	result = await Selection[SeatAccess](
+		group,
+		header=header,
+		allow_skip=False,
+	).show()
+
+	if result.type_ == ResultType.Selection:
+		return result.get_value()
+	else:
+		raise ValueError('Unexpected result type from seat access selection')

archinstall/default_profiles/desktops/xfce4.py

@@ -1,26 +1,29 @@
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from archinstall.default_profiles.profile import ProfileType, GreeterType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
 
 
-class Xfce4Profile(XorgProfile):
+class Xfce4Profile(Profile):
 	def __init__(self) -> None:
-		super().__init__('Xfce4', ProfileType.DesktopEnv, description='')
+		super().__init__(
+			'Xfce4',
+			ProfileType.DesktopEnv,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			"xfce4",
-			"xfce4-goodies",
-			"pavucontrol",
-			"gvfs",
-			"xarchiver"
+			'xfce4',
+			'xfce4-goodies',
+			'pavucontrol',
+			'gvfs',
+			'xarchiver',
 		]
 
 	@property
-	def default_greeter_type(self) -> GreeterType | None:
+	@override
+	def default_greeter_type(self) -> GreeterType:
 		return GreeterType.Lightdm

archinstall/default_profiles/desktops/xmonad.py

@@ -0,0 +1,29 @@
+from typing import override
+
+from archinstall.default_profiles.profile import DisplayServerType, GreeterType, Profile, ProfileType
+
+
+class XmonadProfile(Profile):
+	def __init__(self) -> None:
+		super().__init__(
+			'Xmonad',
+			ProfileType.WindowMgr,
+			support_gfx_driver=True,
+			display_server=DisplayServerType.Xorg,
+		)
+
+	@property
+	@override
+	def packages(self) -> list[str]:
+		return [
+			'xmonad',
+			'xmonad-contrib',
+			'xmonad-extras',
+			'xterm',
+			'dmenu',
+		]
+
+	@property
+	@override
+	def default_greeter_type(self) -> GreeterType:
+		return GreeterType.Lightdm

archinstall/default_profiles/minimal.py

@@ -1,15 +1,9 @@
-from typing import Any, TYPE_CHECKING
-
 from archinstall.default_profiles.profile import Profile, ProfileType
 
-if TYPE_CHECKING:
-	_: Any
-
 
 class MinimalProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Minimal',
 			ProfileType.Minimal,
-			description=str(_('A very basic installation that allows you to customize Arch Linux as you see fit.'))
 		)

archinstall/default_profiles/profile.py

@@ -1,14 +1,16 @@
-from __future__ import annotations
+from enum import Enum, StrEnum, auto
+from typing import TYPE_CHECKING, Self
 
-import sys
-from enum import Enum, auto
-from typing import Any, TYPE_CHECKING
-
-from ..lib.storage import storage
+from archinstall.lib.translationhandler import tr
 
 if TYPE_CHECKING:
-	from ..lib.installer import Installer
-	_: Any
+	from archinstall.lib.installer import Installer
+	from archinstall.lib.models.users import User
+
+
+class DisplayServerType(Enum):
+	Xorg = 'Xorg'
+	Wayland = 'Wayland'
 
 
 class ProfileType(Enum):
@@ -24,7 +26,6 @@ class ProfileType(Enum):
 	DesktopEnv = 'Desktop Environment'
 	CustomType = 'CustomType'
 	# special things
-	Tailored = 'Tailored'
 	Application = 'Application'
 
 
@@ -34,10 +35,9 @@ class GreeterType(Enum):
 	Sddm = 'sddm'
 	Gdm = 'gdm'
 	Ly = 'ly'
-
-	# .. todo:: Remove when we un-hide cosmic behind --advanced
-	if '--advanced' in sys.argv:
-		CosmicSession = "cosmic-greeter"
+	CosmicSession = 'cosmic-greeter'
+	PlasmaLoginManager = 'plasma-login-manager'
+	GreetdDms = 'dms-greeter'
 
 
 class SelectResult(Enum):
@@ -46,27 +46,30 @@ class SelectResult(Enum):
 	ResetCurrent = auto()
 
 
+class CustomSetting(StrEnum):
+	SeatAccess = 'seat_access'
+	PlasmaFlavor = 'plasma_flavor'
+
+
 class Profile:
 	def __init__(
 		self,
 		name: str,
 		profile_type: ProfileType,
-		description: str = '',
-		current_selection: list[Profile] = [],
+		current_selection: list[Self] = [],
 		packages: list[str] = [],
 		services: list[str] = [],
 		support_gfx_driver: bool = False,
 		support_greeter: bool = False,
-		advanced: bool = False
+		display_server: DisplayServerType | None = None,
 	) -> None:
 		self.name = name
-		self.description = description
 		self.profile_type = profile_type
-		self.custom_settings: dict[str, Any] = {}
-		self.advanced = advanced
+		self.custom_settings: dict[CustomSetting, str | None] = {}
 
 		self._support_gfx_driver = support_gfx_driver
 		self._support_greeter = support_greeter
+		self._display_server = display_server
 
 		# self.gfx_driver: str | None = None
 
@@ -100,38 +103,38 @@ class Profile:
 		"""
 		return None
 
-	def _advanced_check(self) -> bool:
-		"""
-		Used to control if the Profile() should be visible or not in different contexts.
-		Returns True if --advanced is given on a Profile(advanced=True) instance.
-		"""
-		return self.advanced is False or storage['arguments'].get('advanced', False) is True
-
-	def install(self, install_session: 'Installer') -> None:
+	def install(self, install_session: Installer) -> None:
 		"""
 		Performs installation steps when this profile was selected
 		"""
 
-	def post_install(self, install_session: 'Installer') -> None:
+	def post_install(self, install_session: Installer) -> None:
 		"""
 		Hook that will be called when the installation process is
 		finished and custom installation steps for specific default_profiles
 		are needed
 		"""
 
-	def json(self) -> dict[str, Any]:
+	def provision(self, install_session: Installer, users: list[User]) -> None:
+		"""
+		Hook that will be called when the installation process is
+		finished and user configuration for specific default_profiles
+		is needed
+		"""
+
+	def json(self) -> dict[str, str]:
 		"""
 		Returns a json representation of the profile
 		"""
 		return {}
 
-	def do_on_select(self) -> SelectResult | None:
+	async def do_on_select(self) -> SelectResult | None:
 		"""
 		Hook that will be called when a profile is selected
 		"""
 		return SelectResult.NewSelection
 
-	def set_custom_settings(self, settings: dict[str, Any]) -> None:
+	def set_custom_settings(self, settings: dict[CustomSetting, str | None]) -> None:
 		"""
 		Set the custom settings for the profile.
 		This is also called when the settings are parsed from the config
@@ -152,19 +155,16 @@ class Profile:
 		return self.profile_type in top_levels
 
 	def is_desktop_profile(self) -> bool:
-		return self.profile_type == ProfileType.Desktop if self._advanced_check() else False
+		return self.profile_type == ProfileType.Desktop
 
 	def is_server_type_profile(self) -> bool:
 		return self.profile_type == ProfileType.ServerType
 
 	def is_desktop_type_profile(self) -> bool:
-		return (self.profile_type == ProfileType.DesktopEnv or self.profile_type == ProfileType.WindowMgr) if self._advanced_check() else False
+		return self.profile_type == ProfileType.DesktopEnv or self.profile_type == ProfileType.WindowMgr
 
 	def is_xorg_type_profile(self) -> bool:
-		return self.profile_type == ProfileType.Xorg if self._advanced_check() else False
-
-	def is_tailored(self) -> bool:
-		return self.profile_type == ProfileType.Tailored
+		return self.profile_type == ProfileType.Xorg
 
 	def is_custom_type_profile(self) -> bool:
 		return self.profile_type == ProfileType.CustomType
@@ -180,10 +180,23 @@ class Profile:
 	def is_greeter_supported(self) -> bool:
 		return self._support_greeter
 
-	def preview_text(self) -> str | None:
+	@property
+	def display_server(self) -> DisplayServerType | None:
+		return self._display_server
+
+	def preview_text(self) -> str:
 		"""
 		Override this method to provide a preview text for the profile
 		"""
+		if self.is_desktop_type_profile():
+			if self._display_server:
+				text = tr('Environment type: {} {}').format(self._display_server.value, self.profile_type.value)
+			else:
+				text = tr('Environment type: {}').format(self.profile_type.value)
+			if packages := self.packages_text():
+				text += f'\n{packages}'
+			return text
+
 		return self.packages_text()
 
 	def packages_text(self, include_sub_packages: bool = False) -> str:
@@ -197,9 +210,9 @@ class Profile:
 				if sub_profile.packages:
 					packages.update(sub_profile.packages)
 
-		text = str(_('Installed packages')) + ':\n'
+		text = tr('Installed packages') + ':\n'
 
 		for pkg in sorted(packages):
-			text += f'\t- {pkg}\n'
+			text += f'    - {pkg}\n'
 
 		return text

archinstall/default_profiles/server.py

@@ -1,49 +1,46 @@
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Self, override
 
-from archinstall.lib.output import info
+from archinstall.default_profiles.profile import Profile, ProfileType, SelectResult
+from archinstall.lib.log import info
+from archinstall.lib.menu.helpers import Selection
 from archinstall.lib.profile.profiles_handler import profile_handler
-from archinstall.default_profiles.profile import ProfileType, Profile, SelectResult
-
-from archinstall.tui import (
-	MenuItemGroup, MenuItem, SelectMenu,
-	FrameProperties, ResultType, PreviewStyle
-)
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
 
 if TYPE_CHECKING:
 	from archinstall.lib.installer import Installer
-	_: Any
+	from archinstall.lib.models.users import User
 
 
 class ServerProfile(Profile):
-	def __init__(self, current_value: list[Profile] = []):
+	def __init__(self, current_value: list[Self] = []):
 		super().__init__(
 			'Server',
 			ProfileType.Server,
-			description=str(_('Provides a selection of various server packages to install and enable, e.g. httpd, nginx, mariadb')),
-			current_selection=current_value
+			current_selection=current_value,
 		)
 
-	def do_on_select(self) -> SelectResult | None:
+	@override
+	async def do_on_select(self) -> SelectResult:
 		items = [
 			MenuItem(
 				p.name,
 				value=p,
-				preview_action=lambda x: x.value.preview_text()
-			) for p in profile_handler.get_server_profiles()
+				preview_action=lambda x: x.value.preview_text() if x.value else None,
+			)
+			for p in profile_handler.get_server_profiles()
 		]
 
 		group = MenuItemGroup(items, sort_items=True)
 		group.set_selected_by_value(self.current_selection)
 
-		result = SelectMenu(
+		result = await Selection[Self](
 			group,
 			allow_reset=True,
 			allow_skip=True,
-			preview_style=PreviewStyle.RIGHT,
-			preview_size='auto',
-			preview_frame=FrameProperties.max('Info'),
-			multi=True
-		).run()
+			multi=True,
+			preview_location='right',
+		).show()
 
 		match result.type_:
 			case ResultType.Selection:
@@ -55,11 +52,18 @@ class ServerProfile(Profile):
 			case ResultType.Reset:
 				return SelectResult.ResetCurrent
 
-	def post_install(self, install_session: 'Installer') -> None:
+	@override
+	def provision(self, install_session: Installer, users: list[User]) -> None:
+		for profile in self.current_selection:
+			profile.provision(install_session, users)
+
+	@override
+	def post_install(self, install_session: Installer) -> None:
 		for profile in self.current_selection:
 			profile.post_install(install_session)
 
-	def install(self, install_session: 'Installer') -> None:
+	@override
+	def install(self, install_session: Installer) -> None:
 		server_info = self.current_selection_names()
 		details = ', '.join(server_info)
 		info(f'Now installing the selected servers: {details}')

archinstall/default_profiles/servers/cockpit.py

@@ -1,3 +1,5 @@
+from typing import override
+
 from archinstall.default_profiles.profile import Profile, ProfileType
 
 
@@ -5,13 +7,15 @@ class CockpitProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Cockpit',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['cockpit', 'udisks2', 'packagekit']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['cockpit.socket']

archinstall/default_profiles/servers/docker.py

@@ -1,33 +1,30 @@
-from typing import Union, TYPE_CHECKING
-
-import archinstall
+from typing import TYPE_CHECKING, override
 
 from archinstall.default_profiles.profile import Profile, ProfileType
-from archinstall.lib.models import User
 
 if TYPE_CHECKING:
 	from archinstall.lib.installer import Installer
+	from archinstall.lib.models.users import User
 
 
 class DockerProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Docker',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['docker']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['docker']
 
-	def post_install(self, install_session: 'Installer') -> None:
-		users: Union[User, list[User]] = archinstall.arguments.get('!users', [])
-		if not isinstance(users, list):
-			users = [users]
-
+	@override
+	def provision(self, install_session: Installer, users: list[User]) -> None:
 		for user in users:
 			install_session.arch_chroot(f'usermod -a -G docker {user.username}')

archinstall/default_profiles/servers/httpd.py

@@ -1,3 +1,5 @@
+from typing import override
+
 from archinstall.default_profiles.profile import Profile, ProfileType
 
 
@@ -5,13 +7,15 @@ class HttpdProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'httpd',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['apache']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['httpd']

archinstall/default_profiles/servers/lighttpd.py

@@ -1,3 +1,5 @@
+from typing import override
+
 from archinstall.default_profiles.profile import Profile, ProfileType
 
 
@@ -5,13 +7,15 @@ class LighttpdProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Lighttpd',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['lighttpd']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['lighttpd']

archinstall/default_profiles/servers/mariadb.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, override
 
 from archinstall.default_profiles.profile import Profile, ProfileType
 
@@ -10,16 +10,19 @@ class MariadbProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Mariadb',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['mariadb']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['mariadb']
 
-	def post_install(self, install_session: 'Installer') -> None:
+	@override
+	def post_install(self, install_session: Installer) -> None:
 		install_session.arch_chroot('mariadb-install-db --user=mysql --basedir=/usr --datadir=/var/lib/mysql')

archinstall/default_profiles/servers/nginx.py

@@ -1,3 +1,5 @@
+from typing import override
+
 from archinstall.default_profiles.profile import Profile, ProfileType
 
 
@@ -5,13 +7,15 @@ class NginxProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Nginx',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['nginx']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['nginx']

archinstall/default_profiles/servers/postgresql.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, override
 
 from archinstall.default_profiles.profile import Profile, ProfileType
 
@@ -11,16 +11,18 @@ class PostgresqlProfile(Profile):
 		super().__init__(
 			'Postgresql',
 			ProfileType.ServerType,
-			''
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['postgresql']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['postgresql']
 
-	def post_install(self, install_session: 'Installer') -> None:
-		install_session.arch_chroot("initdb -D /var/lib/postgres/data", run_as='postgres')
+	@override
+	def post_install(self, install_session: Installer) -> None:
+		install_session.arch_chroot('initdb -D /var/lib/postgres/data', run_as='postgres')

archinstall/default_profiles/servers/sshd.py

@@ -1,3 +1,5 @@
+from typing import override
+
 from archinstall.default_profiles.profile import Profile, ProfileType
 
 
@@ -5,13 +7,15 @@ class SshdProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'sshd',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['openssh']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['sshd']

archinstall/default_profiles/servers/tomcat.py

@@ -1,3 +1,5 @@
+from typing import override
+
 from archinstall.default_profiles.profile import Profile, ProfileType
 
 
@@ -5,13 +7,15 @@ class TomcatProfile(Profile):
 	def __init__(self) -> None:
 		super().__init__(
 			'Tomcat',
-			ProfileType.ServerType
+			ProfileType.ServerType,
 		)
 
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return ['tomcat10']
 
 	@property
+	@override
 	def services(self) -> list[str]:
 		return ['tomcat10']

archinstall/default_profiles/tailored.py

@@ -1,21 +0,0 @@
-from typing import Any, TYPE_CHECKING
-
-from archinstall.default_profiles.profile import ProfileType
-from archinstall.default_profiles.xorg import XorgProfile
-
-if TYPE_CHECKING:
-	from archinstall.lib.installer import Installer
-	_: Any
-
-
-class TailoredProfile(XorgProfile):
-	def __init__(self) -> None:
-		super().__init__('52-54-00-12-34-56', ProfileType.Tailored, description='')
-
-	@property
-	def packages(self) -> list[str]:
-		return ['nano', 'wget', 'git']
-
-	def install(self, install_session: 'Installer') -> None:
-		super().install(install_session)
-		# do whatever you like here :)

archinstall/default_profiles/xorg.py

@@ -1,9 +1,9 @@
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, override
 
-from archinstall.default_profiles.profile import Profile, ProfileType
+from archinstall.default_profiles.profile import DisplayServerType, Profile, ProfileType
 
 if TYPE_CHECKING:
-	_: Any
+	from archinstall.lib.installer import Installer
 
 
 class XorgProfile(Profile):
@@ -11,26 +11,22 @@ class XorgProfile(Profile):
 		self,
 		name: str = 'Xorg',
 		profile_type: ProfileType = ProfileType.Xorg,
-		description: str = str(_('Installs a minimal system as well as xorg and graphics drivers.')),
-		advanced: bool = False
 	):
 		super().__init__(
 			name,
 			profile_type,
-			description=description,
 			support_gfx_driver=True,
-			advanced=advanced
+			display_server=DisplayServerType.Xorg,
 		)
 
-	def preview_text(self) -> str | None:
-		text = str(_('Environment type: {}')).format(self.profile_type.value)
-		if packages := self.packages_text():
-			text += f'\n{packages}'
-
-		return text
-
 	@property
+	@override
 	def packages(self) -> list[str]:
 		return [
-			'xorg-server'
+			'xorg-server',
+			'xorg-xinit',
 		]
+
+	@override
+	def install(self, install_session: Installer) -> None:
+		install_session.add_additional_packages(self.packages)

archinstall/lib/applications/application_handler.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING
+
+from archinstall.applications.audio import AudioApp
+from archinstall.applications.bluetooth import BluetoothApp
+from archinstall.applications.firewall import FirewallApp
+from archinstall.applications.fonts import FontsApp
+from archinstall.applications.power_management import PowerManagementApp
+from archinstall.applications.print_service import PrintServiceApp
+from archinstall.lib.models import Audio
+from archinstall.lib.models.application import ApplicationConfiguration
+from archinstall.lib.models.users import User
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class ApplicationHandler:
+	def __init__(self) -> None:
+		pass
+
+	def install_applications(self, install_session: Installer, app_config: ApplicationConfiguration, users: list[User] | None = None) -> None:
+		if app_config.bluetooth_config and app_config.bluetooth_config.enabled:
+			BluetoothApp().install(install_session)
+
+		if app_config.audio_config and app_config.audio_config.audio != Audio.NO_AUDIO:
+			AudioApp().install(
+				install_session,
+				app_config.audio_config,
+				users,
+			)
+
+		if app_config.power_management_config:
+			PowerManagementApp().install(
+				install_session,
+				app_config.power_management_config,
+			)
+
+		if app_config.print_service_config and app_config.print_service_config.enabled:
+			PrintServiceApp().install(install_session)
+
+		if app_config.firewall_config:
+			FirewallApp().install(
+				install_session,
+				app_config.firewall_config,
+			)
+
+		if app_config.fonts_config:
+			FontsApp().install(
+				install_session,
+				app_config.fonts_config,
+			)

archinstall/lib/applications/application_menu.py

@@ -0,0 +1,263 @@
+from typing import override
+
+from archinstall.lib.hardware import SysInfo
+from archinstall.lib.menu.abstract_menu import AbstractSubMenu
+from archinstall.lib.menu.helpers import Confirmation, Selection
+from archinstall.lib.models.application import (
+	ApplicationConfiguration,
+	Audio,
+	AudioConfiguration,
+	BluetoothConfiguration,
+	Firewall,
+	FirewallConfiguration,
+	FontPackage,
+	FontsConfiguration,
+	PowerManagement,
+	PowerManagementConfiguration,
+	PrintServiceConfiguration,
+)
+from archinstall.lib.translationhandler import tr
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
+
+
+class ApplicationMenu(AbstractSubMenu[ApplicationConfiguration]):
+	def __init__(
+		self,
+		preset: ApplicationConfiguration | None = None,
+	):
+		if preset:
+			self._app_config = preset
+		else:
+			self._app_config = ApplicationConfiguration()
+
+		menu_options = self._define_menu_options()
+		self._item_group = MenuItemGroup(menu_options, checkmarks=True)
+
+		super().__init__(
+			self._item_group,
+			config=self._app_config,
+			allow_reset=True,
+		)
+
+	@override
+	async def show(self) -> ApplicationConfiguration | None:
+		_ = await super().show()
+		return self._app_config
+
+	def _define_menu_options(self) -> list[MenuItem]:
+		return [
+			MenuItem(
+				text=tr('Bluetooth'),
+				action=select_bluetooth,
+				value=self._app_config.bluetooth_config,
+				preview_action=self._prev_bluetooth,
+				key='bluetooth_config',
+			),
+			MenuItem(
+				text=tr('Audio'),
+				action=select_audio,
+				preview_action=self._prev_audio,
+				key='audio_config',
+			),
+			MenuItem(
+				text=tr('Print service'),
+				action=select_print_service,
+				preview_action=self._prev_print_service,
+				key='print_service_config',
+			),
+			MenuItem(
+				text=tr('Power management'),
+				action=select_power_management,
+				preview_action=self._prev_power_management,
+				enabled=SysInfo.has_battery(),
+				key='power_management_config',
+			),
+			MenuItem(
+				text=tr('Firewall'),
+				action=select_firewall,
+				preview_action=self._prev_firewall,
+				key='firewall_config',
+			),
+			MenuItem(
+				text=tr('Additional fonts'),
+				action=select_fonts,
+				value=self._app_config.fonts_config,
+				preview_action=self._prev_fonts,
+				key='fonts_config',
+			),
+		]
+
+	def _prev_power_management(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			config: PowerManagementConfiguration = item.value
+			return f'{tr("Power management")}: {config.power_management.value}'
+		return None
+
+	def _prev_bluetooth(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			bluetooth_config: BluetoothConfiguration = item.value
+
+			output = f'{tr("Bluetooth")}: '
+			output += tr('Enabled') if bluetooth_config.enabled else tr('Disabled')
+			return output
+		return None
+
+	def _prev_audio(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			config: AudioConfiguration = item.value
+			return f'{tr("Audio")}: {config.audio.value}'
+		return None
+
+	def _prev_print_service(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			print_service_config: PrintServiceConfiguration = item.value
+
+			output = f'{tr("Print service")}: '
+			output += tr('Enabled') if print_service_config.enabled else tr('Disabled')
+			return output
+		return None
+
+	def _prev_firewall(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			config: FirewallConfiguration = item.value
+			return f'{tr("Firewall")}: {config.firewall.value}'
+		return None
+
+	def _prev_fonts(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			config: FontsConfiguration = item.value
+			packages = ', '.join(f.value for f in config.fonts)
+			return f'{tr("Additional fonts")}: {packages}'
+		return None
+
+
+async def select_power_management(preset: PowerManagementConfiguration | None = None) -> PowerManagementConfiguration | None:
+	group = MenuItemGroup.from_enum(PowerManagement)
+
+	if preset:
+		group.set_focus_by_value(preset.power_management)
+
+	result = await Selection[PowerManagement](
+		group,
+		allow_skip=True,
+		allow_reset=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Selection:
+			return PowerManagementConfiguration(power_management=result.get_value())
+		case ResultType.Reset:
+			return None
+
+
+async def select_bluetooth(preset: BluetoothConfiguration | None) -> BluetoothConfiguration | None:
+	header = tr('Would you like to configure Bluetooth?') + '\n'
+	preset_val = preset.enabled if preset else False
+
+	result = await Confirmation(
+		header=header,
+		allow_skip=True,
+		preset=preset_val,
+	).show()
+
+	match result.type_:
+		case ResultType.Selection:
+			return BluetoothConfiguration(result.get_value())
+		case ResultType.Skip:
+			return preset
+		case _:
+			raise ValueError('Unhandled result type')
+
+
+async def select_print_service(preset: PrintServiceConfiguration | None) -> PrintServiceConfiguration | None:
+	header = tr('Would you like to configure the print service?') + '\n'
+	preset_val = preset.enabled if preset else False
+
+	result = await Confirmation(
+		header=header,
+		allow_skip=True,
+		preset=preset_val,
+	).show()
+
+	match result.type_:
+		case ResultType.Selection:
+			result.get_value()
+			return PrintServiceConfiguration(result.get_value())
+		case ResultType.Skip:
+			return preset
+		case _:
+			raise ValueError('Unhandled result type')
+
+
+async def select_audio(preset: AudioConfiguration | None = None) -> AudioConfiguration | None:
+	items = [MenuItem(a.value, value=a) for a in Audio]
+	group = MenuItemGroup(items)
+
+	if preset:
+		group.set_focus_by_value(preset.audio)
+
+	result = await Selection[Audio](
+		group,
+		header=tr('Select audio configuration'),
+		allow_skip=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Selection:
+			return AudioConfiguration(audio=result.get_value())
+		case ResultType.Reset:
+			raise ValueError('Unhandled result type')
+
+
+async def select_firewall(preset: FirewallConfiguration | None = None) -> FirewallConfiguration | None:
+	group = MenuItemGroup.from_enum(Firewall)
+
+	if preset:
+		group.set_focus_by_value(preset.firewall)
+
+	result = await Selection[Firewall](
+		group,
+		allow_skip=True,
+		allow_reset=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Selection:
+			return FirewallConfiguration(firewall=result.get_value())
+		case ResultType.Reset:
+			return None
+
+
+async def select_fonts(preset: FontsConfiguration | None = None) -> FontsConfiguration | None:
+	items = [MenuItem(f'{f.value} ({f.description()})', value=f) for f in FontPackage]
+	group = MenuItemGroup(items)
+
+	if preset:
+		for f in preset.fonts:
+			group.set_selected_by_value(f)
+
+	result = await Selection[FontPackage](
+		group,
+		header=tr('Select font packages to install'),
+		allow_skip=True,
+		allow_reset=True,
+		multi=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Selection:
+			selected = result.get_values()
+			if selected:
+				return FontsConfiguration(fonts=selected)
+			return None
+		case ResultType.Reset:
+			return None

archinstall/lib/args.py

@@ -0,0 +1,671 @@
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass, field
+from enum import Enum, StrEnum
+from pathlib import Path
+from typing import Any, Self
+from urllib.request import Request, urlopen
+
+from pydantic.dataclasses import dataclass as p_dataclass
+
+from archinstall.lib.crypt import decrypt
+from archinstall.lib.log import debug, error, logger, warn
+from archinstall.lib.menu.util import get_password
+from archinstall.lib.models.application import ApplicationConfiguration, ZramConfiguration
+from archinstall.lib.models.authentication import AuthenticationConfiguration
+from archinstall.lib.models.bootloader import Bootloader, BootloaderConfiguration
+from archinstall.lib.models.config import SubConfig
+from archinstall.lib.models.device import DiskEncryption, DiskLayoutConfiguration
+from archinstall.lib.models.locale import LocaleConfiguration
+from archinstall.lib.models.mirrors import MirrorConfiguration
+from archinstall.lib.models.network import NetworkConfiguration
+from archinstall.lib.models.package_types import DEFAULT_KERNEL
+from archinstall.lib.models.packages import Repository
+from archinstall.lib.models.pacman import PacmanConfiguration
+from archinstall.lib.models.profile import ProfileConfiguration
+from archinstall.lib.models.users import Password, User, UserSerialization
+from archinstall.lib.plugins import load_plugin
+from archinstall.lib.translationhandler import Language, tr, translation_handler
+from archinstall.lib.version import get_version
+from archinstall.tui.components import tui
+
+
+class SubCommand(Enum):
+	SHARE_LOG = 'share-log'
+
+
+@p_dataclass
+class Arguments:
+	config: Path | None = None
+	config_url: str | None = None
+	creds: Path | None = None
+	creds_url: str | None = None
+	creds_decryption_key: str | None = None
+	silent: bool = False
+	dry_run: bool = False
+	script: str | None = None
+	mountpoint: Path = Path('/mnt')
+	skip_ntp: bool = False
+	skip_wkd: bool = False
+	skip_boot: bool = False
+	debug: bool = False
+	offline: bool = False
+	no_pkg_lookups: bool = False
+	plugin: str | None = None
+	skip_version_check: bool = False
+	skip_wifi_check: bool = False
+	advanced: bool = False
+	verbose: bool = False
+
+	command: SubCommand | None = None
+
+
+class ArchConfigType(StrEnum):
+	VERSION = 'version'
+	SCRIPT = 'script'
+	LOCALE_CONFIG = 'locale_config'
+	ARCHINSTALL_LANGUAGE = 'archinstall_language'
+	DISK_CONFIG = 'disk_config'
+	PROFILE_CONFIG = 'profile_config'
+	MIRROR_CONFIG = 'mirror_config'
+	NETWORK_CONFIG = 'network_config'
+	BOOTLOADER_CONFIG = 'bootloader_config'
+	APP_CONFIG = 'app_config'
+	AUTH_CONFIG = 'auth_config'
+	SWAP = 'swap'
+	USERS = 'users'
+	ROOT_ENC_PASSWORD = 'root_enc_password'
+	ENCRYPTION_PASSWORD = 'encryption_password'
+	HOSTNAME = 'hostname'
+	KERNELS = 'kernels'
+	NTP = 'ntp'
+	TIMEZONE = 'timezone'
+	SERVICES = 'services'
+	PACKAGES = 'packages'
+	PACMAN_CONFIG = 'pacman_config'
+	CUSTOM_COMMANDS = 'custom_commands'
+
+	def text(self) -> str:
+		match self:
+			case ArchConfigType.ARCHINSTALL_LANGUAGE:
+				return tr('ArchInstall Language')
+			case ArchConfigType.VERSION:
+				return tr('Version')
+			case ArchConfigType.SCRIPT:
+				return tr('Installation Script')
+			case ArchConfigType.LOCALE_CONFIG:
+				return tr('Locales')
+			case ArchConfigType.DISK_CONFIG:
+				return tr('Disk configuration')
+			case ArchConfigType.PROFILE_CONFIG:
+				return tr('Profile')
+			case ArchConfigType.MIRROR_CONFIG:
+				return tr('Mirrors and repositories')
+			case ArchConfigType.NETWORK_CONFIG:
+				return tr('Network')
+			case ArchConfigType.BOOTLOADER_CONFIG:
+				return tr('Bootloader')
+			case ArchConfigType.APP_CONFIG:
+				return tr('Application')
+			case ArchConfigType.AUTH_CONFIG:
+				return tr('Authentication')
+			case ArchConfigType.SWAP:
+				return tr('Swap')
+			case ArchConfigType.HOSTNAME:
+				return tr('Hostname')
+			case ArchConfigType.KERNELS:
+				return tr('Kernels')
+			case ArchConfigType.NTP:
+				return tr('Automatic time sync (NTP)')
+			case ArchConfigType.TIMEZONE:
+				return tr('Timezone')
+			case ArchConfigType.SERVICES:
+				return tr('Services')
+			case ArchConfigType.PACKAGES:
+				return tr('Additional packages')
+			case ArchConfigType.PACMAN_CONFIG:
+				return tr('Pacman')
+			case ArchConfigType.CUSTOM_COMMANDS:
+				return tr('Custom commands')
+			case ArchConfigType.USERS:
+				return tr('Users')
+			case ArchConfigType.ROOT_ENC_PASSWORD:
+				return tr('Root encrypted password')
+			case ArchConfigType.ENCRYPTION_PASSWORD:
+				return tr('Disk encryption password')
+
+
+@dataclass
+class ArchConfig:
+	version: str | None = None
+	script: str | None = None
+	locale_config: LocaleConfiguration | None = None
+	archinstall_language: Language = field(default_factory=lambda: translation_handler.get_language_by_abbr('en'))
+	disk_config: DiskLayoutConfiguration | None = None
+	profile_config: ProfileConfiguration | None = None
+	mirror_config: MirrorConfiguration | None = None
+	network_config: NetworkConfiguration | None = None
+	bootloader_config: BootloaderConfiguration | None = None
+	app_config: ApplicationConfiguration | None = None
+	auth_config: AuthenticationConfiguration | None = None
+	swap: ZramConfiguration | None = None
+	hostname: str = 'archlinux'
+	kernels: list[str] = field(default_factory=lambda: [DEFAULT_KERNEL.value])
+	ntp: bool = True
+	packages: list[str] = field(default_factory=list)
+	pacman_config: PacmanConfiguration = field(default_factory=PacmanConfiguration.default)
+	timezone: str = 'UTC'
+	services: list[str] = field(default_factory=list)
+	custom_commands: list[str] = field(default_factory=list)
+
+	def unsafe_config(self) -> dict[ArchConfigType, Any]:
+		config: dict[ArchConfigType, list[UserSerialization] | str | None] = {}
+
+		if self.auth_config:
+			if self.auth_config.users:
+				config[ArchConfigType.USERS] = [user.json() for user in self.auth_config.users]
+
+			if self.auth_config.root_enc_password:
+				config[ArchConfigType.ROOT_ENC_PASSWORD] = self.auth_config.root_enc_password.enc_password
+
+		if self.disk_config:
+			disk_encryption = self.disk_config.disk_encryption
+			if disk_encryption and disk_encryption.encryption_password:
+				config[ArchConfigType.ENCRYPTION_PASSWORD] = disk_encryption.encryption_password.plaintext
+
+		return config
+
+	def safe_config(self) -> dict[ArchConfigType, Any]:
+		base_config: dict[ArchConfigType, Any] = {
+			ArchConfigType.VERSION: self.version,
+			ArchConfigType.SCRIPT: self.script,
+			ArchConfigType.ARCHINSTALL_LANGUAGE: self.archinstall_language.json(),
+		}
+
+		base_config.update(self.plain_cfg())
+		sub_config = self.sub_cfg()
+
+		for config_type, value in sub_config.items():
+			if not hasattr(value, 'json'):
+				raise ValueError(f'Config value for {config_type} must implement json() method')
+			base_config[config_type] = value.json()
+
+		return base_config
+
+	def plain_cfg(self) -> dict[ArchConfigType, str | list[str] | bool]:
+		return {
+			ArchConfigType.HOSTNAME: self.hostname,
+			ArchConfigType.KERNELS: self.kernels,
+			ArchConfigType.NTP: self.ntp,
+			ArchConfigType.TIMEZONE: self.timezone,
+			ArchConfigType.SERVICES: self.services,
+			ArchConfigType.PACKAGES: self.packages,
+			ArchConfigType.CUSTOM_COMMANDS: self.custom_commands,
+		}
+
+	def sub_cfg(self) -> dict[ArchConfigType, SubConfig]:
+		cfg: dict[ArchConfigType, SubConfig] = {
+			ArchConfigType.PACMAN_CONFIG: self.pacman_config,
+		}
+
+		if self.mirror_config:
+			cfg[ArchConfigType.MIRROR_CONFIG] = self.mirror_config
+
+		if self.bootloader_config:
+			cfg[ArchConfigType.BOOTLOADER_CONFIG] = self.bootloader_config
+
+		if self.disk_config:
+			cfg[ArchConfigType.DISK_CONFIG] = self.disk_config
+
+		if self.swap:
+			cfg[ArchConfigType.SWAP] = self.swap
+
+		if self.auth_config:
+			cfg[ArchConfigType.AUTH_CONFIG] = self.auth_config
+
+		if self.locale_config:
+			cfg[ArchConfigType.LOCALE_CONFIG] = self.locale_config
+
+		if self.profile_config:
+			cfg[ArchConfigType.PROFILE_CONFIG] = self.profile_config
+
+		if self.network_config:
+			cfg[ArchConfigType.NETWORK_CONFIG] = self.network_config
+
+		if self.app_config:
+			cfg[ArchConfigType.APP_CONFIG] = self.app_config
+
+		return cfg
+
+	@classmethod
+	def from_config(cls, args_config: dict[str, Any], args: Arguments) -> Self:
+		arch_config = cls()
+
+		arch_config.locale_config = LocaleConfiguration.parse_arg(args_config)
+
+		if script := args_config.get('script', None):
+			arch_config.script = script
+
+		if archinstall_lang := args_config.get('archinstall-language', None):
+			arch_config.archinstall_language = translation_handler.get_language_by_name(archinstall_lang)
+			translation_handler.activate(arch_config.archinstall_language, set_font=False)
+
+		if disk_config := args_config.get('disk_config', {}):
+			enc_password = args_config.get('encryption_password', '')
+			password = Password(plaintext=enc_password) if enc_password else None
+			arch_config.disk_config = DiskLayoutConfiguration.parse_arg(disk_config, password)
+
+			# DEPRECATED
+			# backwards compatibility for main level disk_encryption entry
+			disk_encryption: DiskEncryption | None = None
+
+			if args_config.get('disk_encryption', None) is not None and arch_config.disk_config is not None:
+				disk_encryption = DiskEncryption.parse_arg(
+					arch_config.disk_config,
+					args_config['disk_encryption'],
+					Password(plaintext=args_config.get('encryption_password', '')),
+				)
+
+				if disk_encryption:
+					arch_config.disk_config.disk_encryption = disk_encryption
+
+		if profile_config := args_config.get('profile_config', None):
+			arch_config.profile_config = ProfileConfiguration.parse_arg(profile_config)
+
+		if mirror_config := args_config.get('mirror_config', None):
+			backwards_compatible_repo = []
+			if additional_repositories := args_config.get('additional-repositories', []):
+				backwards_compatible_repo = [Repository(r) for r in additional_repositories]
+
+			arch_config.mirror_config = MirrorConfiguration.parse_args(
+				mirror_config,
+				backwards_compatible_repo,
+			)
+
+		if net_config := args_config.get('network_config', None):
+			arch_config.network_config = NetworkConfiguration.parse_arg(net_config)
+
+		if bootloader_config_dict := args_config.get('bootloader_config', None):
+			arch_config.bootloader_config = BootloaderConfiguration.parse_arg(bootloader_config_dict, args.skip_boot)
+		# DEPRECATED: separate bootloader and uki fields (backward compatibility)
+		elif bootloader_str := args_config.get('bootloader', None):
+			bootloader = Bootloader.from_arg(bootloader_str, args.skip_boot)
+			uki = args_config.get('uki', False)
+			if uki and not bootloader.has_uki_support():
+				uki = False
+			arch_config.bootloader_config = BootloaderConfiguration(bootloader=bootloader, uki=uki, removable=True)
+
+		# deprecated: backwards compatibility
+		audio_config_args = args_config.get('audio_config', None)
+		app_config_args = args_config.get('app_config', None)
+
+		if audio_config_args is not None or app_config_args is not None:
+			arch_config.app_config = ApplicationConfiguration.parse_arg(app_config_args, audio_config_args)
+
+		if auth_config_args := args_config.get('auth_config', None):
+			arch_config.auth_config = AuthenticationConfiguration.parse_arg(auth_config_args)
+
+		if hostname := args_config.get('hostname', ''):
+			arch_config.hostname = hostname
+
+		if kernels := args_config.get('kernels', []):
+			arch_config.kernels = kernels
+
+		arch_config.ntp = args_config.get('ntp', True)
+
+		if packages := args_config.get('packages', []):
+			arch_config.packages = packages
+
+		if pacman_config := args_config.get('pacman_config', None):
+			arch_config.pacman_config = PacmanConfiguration.parse_arg(pacman_config)
+		elif parallel_downloads := args_config.get('parallel_downloads', 0):
+			arch_config.pacman_config = PacmanConfiguration(parallel_downloads=int(parallel_downloads))
+
+		swap_arg = args_config.get('swap')
+		if swap_arg is not None:
+			arch_config.swap = ZramConfiguration.parse_arg(swap_arg)
+
+		if timezone := args_config.get('timezone', 'UTC'):
+			arch_config.timezone = timezone
+
+		if services := args_config.get('services', []):
+			arch_config.services = services
+
+		# DEPRECATED: backwards compatibility
+		root_password = None
+		if root_password := args_config.get('!root-password', None):
+			root_password = Password(plaintext=root_password)
+
+		if enc_password := args_config.get('root_enc_password', None):
+			root_password = Password(enc_password=enc_password)
+
+		if root_password is not None:
+			if arch_config.auth_config is None:
+				arch_config.auth_config = AuthenticationConfiguration()
+			arch_config.auth_config.root_enc_password = root_password
+
+		# DEPRECATED: backwards compatibility
+		users: list[User] = []
+		if args_users := args_config.get('!users', None):
+			users = User.parse_arguments(args_users)
+
+		if args_users := args_config.get('users', None):
+			users = User.parse_arguments(args_users)
+
+		if users:
+			if arch_config.auth_config is None:
+				arch_config.auth_config = AuthenticationConfiguration()
+			arch_config.auth_config.users = users
+
+		if custom_commands := args_config.get('custom_commands', []):
+			arch_config.custom_commands = custom_commands
+
+		return arch_config
+
+
+class ArchConfigHandler:
+	def __init__(self) -> None:
+		self._parser: ArgumentParser = self._define_arguments()
+		self._add_sub_parsers()
+
+		self._args: Arguments = self._parse_args()
+		config = self._parse_config()
+
+		try:
+			self._config = ArchConfig.from_config(config, self._args)
+			self._config.version = get_version()
+		except ValueError as err:
+			warn(str(err))
+			sys.exit(1)
+
+	@property
+	def config(self) -> ArchConfig:
+		return self._config
+
+	@property
+	def args(self) -> Arguments:
+		return self._args
+
+	def get_script(self) -> str:
+		if script := self.args.script:
+			return script
+
+		if script := self.config.script:
+			return script
+
+		return 'guided'
+
+	def print_help(self) -> None:
+		self._parser.print_help()
+
+	def _add_sub_parsers(self) -> None:
+		subparsers = self._parser.add_subparsers(dest='command', help='Available subcommands')
+		_ = subparsers.add_parser(SubCommand.SHARE_LOG.value, help='Upload log file to public server')
+
+	def _define_arguments(self) -> ArgumentParser:
+		parser = ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+		parser.add_argument(
+			'-v',
+			'--version',
+			action='version',
+			default=False,
+			version='%(prog)s ' + get_version(),
+		)
+		parser.add_argument(
+			'--config',
+			type=Path,
+			nargs='?',
+			default=None,
+			help='JSON configuration file',
+		)
+		parser.add_argument(
+			'--config-url',
+			type=str,
+			nargs='?',
+			default=None,
+			help='Url to a JSON configuration file',
+		)
+		parser.add_argument(
+			'--creds',
+			type=Path,
+			nargs='?',
+			default=None,
+			help='JSON credentials configuration file',
+		)
+		parser.add_argument(
+			'--creds-url',
+			type=str,
+			nargs='?',
+			default=None,
+			help='Url to a JSON credentials configuration file',
+		)
+		parser.add_argument(
+			'--creds-decryption-key',
+			type=str,
+			nargs='?',
+			default=None,
+			help='Decryption key for credentials file',
+		)
+		parser.add_argument(
+			'--silent',
+			action='store_true',
+			default=False,
+			help='WARNING: Disables all prompts for input and confirmation. If no configuration is provided, this is ignored',
+		)
+		parser.add_argument(
+			'--dry-run',
+			'--dry_run',
+			action='store_true',
+			default=False,
+			help='Generates a configuration file and then exits instead of performing an installation',
+		)
+		parser.add_argument(
+			'--script',
+			nargs='?',
+			help='Script to run for installation',
+			type=str,
+		)
+		parser.add_argument(
+			'--mountpoint',
+			type=Path,
+			nargs='?',
+			default=Path('/mnt'),
+			help='Define an alternate mount point for installation',
+		)
+		parser.add_argument(
+			'--skip-ntp',
+			action='store_true',
+			help='Disables NTP checks during installation',
+			default=False,
+		)
+		parser.add_argument(
+			'--skip-wkd',
+			action='store_true',
+			help='Disables checking if archlinux keyring wkd sync is complete.',
+			default=False,
+		)
+		parser.add_argument(
+			'--skip-boot',
+			action='store_true',
+			help='Disables installation of a boot loader (note: only use this when problems arise with the boot loader step).',
+			default=False,
+		)
+		parser.add_argument(
+			'--debug',
+			action='store_true',
+			default=False,
+			help='Adds debug info into the log',
+		)
+		parser.add_argument(
+			'--offline',
+			action='store_true',
+			default=False,
+			help='Disabled online upstream services such as package search and key-ring auto update.',
+		)
+		parser.add_argument(
+			'--no-pkg-lookups',
+			action='store_true',
+			default=False,
+			help='Disabled package validation specifically prior to starting installation.',
+		)
+		parser.add_argument(
+			'--plugin',
+			nargs='?',
+			type=str,
+			default=None,
+			help='File path to a plugin to load',
+		)
+		parser.add_argument(
+			'--skip-version-check',
+			action='store_true',
+			default=False,
+			help='Skip the version check when running archinstall',
+		)
+		parser.add_argument(
+			'--skip-wifi-check',
+			action='store_true',
+			default=False,
+			help='Skip wifi check when running archinstall',
+		)
+		parser.add_argument(
+			'--advanced',
+			action='store_true',
+			default=False,
+			help='Enabled advanced options',
+		)
+		parser.add_argument(
+			'--verbose',
+			action='store_true',
+			default=False,
+			help='Enabled verbose options',
+		)
+		return parser
+
+	def _parse_args(self) -> Arguments:
+		argparse_args = vars(self._parser.parse_args())
+		args: Arguments = Arguments(**argparse_args)
+
+		# amend the parameters (check internal consistency)
+		# Installation can't be silent if config is not passed
+		if args.config is None and args.config_url is None:
+			args.silent = False
+
+		if args.debug:
+			warn(f'Warning: --debug mode will write certain credentials to {logger.path}!')
+
+		if args.plugin:
+			plugin_path = Path(args.plugin)
+			load_plugin(plugin_path)
+
+		if args.creds_decryption_key is None:
+			if os.environ.get('ARCHINSTALL_CREDS_DECRYPTION_KEY'):
+				args.creds_decryption_key = os.environ.get('ARCHINSTALL_CREDS_DECRYPTION_KEY')
+
+		return args
+
+	def _parse_config(self) -> dict[str, Any]:
+		config: dict[str, Any] = {}
+		config_data: str | None = None
+		creds_data: str | None = None
+
+		if self._args.config is not None:
+			config_data = self._read_file(self._args.config)
+		elif self._args.config_url is not None:
+			config_data = self._fetch_from_url(self._args.config_url)
+
+		if config_data is not None:
+			config.update(json.loads(config_data))
+
+		if self._args.creds is not None:
+			creds_data = self._read_file(self._args.creds)
+		elif self._args.creds_url is not None:
+			creds_data = self._fetch_from_url(self._args.creds_url)
+
+		if creds_data is not None:
+			json_data = self._process_creds_data(creds_data)
+			if json_data is not None:
+				config.update(json_data)
+
+		config = self._cleanup_config(config)
+
+		return config
+
+	def _process_creds_data(self, creds_data: str) -> dict[str, Any] | None:
+		if creds_data.startswith('$'):  # encrypted data
+			if self._args.creds_decryption_key is not None:
+				try:
+					creds_data = decrypt(creds_data, self._args.creds_decryption_key)
+					return json.loads(creds_data)
+				except ValueError as err:
+					if 'Invalid password' in str(err):
+						error(tr('Incorrect credentials file decryption password'))
+						sys.exit(1)
+					else:
+						debug(f'Error decrypting credentials file: {err}')
+						raise err from err
+			else:
+				header = tr('Enter credentials file decryption password')
+				wrong_pwd_text = tr('Incorrect password')
+				prompt = header
+
+				while True:
+					decryption_pwd: Password | None = tui.run(
+						lambda p=prompt: get_password(  # type: ignore[misc]
+							header=p,
+							allow_skip=False,
+							no_confirmation=True,
+						)
+					)
+
+					if not decryption_pwd:
+						return None
+
+					try:
+						creds_data = decrypt(creds_data, decryption_pwd.plaintext)
+						break
+					except ValueError as err:
+						if 'Invalid password' in str(err):
+							debug('Incorrect credentials file decryption password')
+							prompt = f'{header}' + f'\n\n{wrong_pwd_text}'
+						else:
+							debug(f'Error decrypting credentials file: {err}')
+							raise err from err
+
+		return json.loads(creds_data)
+
+	def _fetch_from_url(self, url: str) -> str:
+		if urllib.parse.urlparse(url).scheme:
+			try:
+				req = Request(url, headers={'User-Agent': 'ArchInstall'})
+				with urlopen(req) as resp:
+					return resp.read().decode('utf-8')
+			except urllib.error.HTTPError as err:
+				error(f'Could not fetch JSON from {url}: {err}')
+		else:
+			error('Not a valid url')
+
+		sys.exit(1)
+
+	def _read_file(self, path: Path) -> str:
+		if not path.exists():
+			error(f'Could not find file {path}')
+			sys.exit(1)
+
+		return path.read_text()
+
+	def _cleanup_config(self, config: Namespace | dict[str, Any]) -> dict[str, Any]:
+		clean_args = {}
+		for key, val in config.items():
+			if isinstance(val, dict):
+				val = self._cleanup_config(val)
+
+			if val is not None:
+				clean_args[key] = val
+
+		return clean_args

archinstall/lib/authentication/authentication_handler.py

@@ -0,0 +1,126 @@
+import getpass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from archinstall.lib.command import SysCommandWorker
+from archinstall.lib.log import debug, info
+from archinstall.lib.models.authentication import AuthenticationConfiguration, U2FLoginConfiguration, U2FLoginMethod
+from archinstall.lib.models.users import User
+from archinstall.lib.translationhandler import tr
+
+if TYPE_CHECKING:
+	from archinstall.lib.installer import Installer
+
+
+class AuthenticationHandler:
+	def setup_auth(
+		self,
+		install_session: Installer,
+		auth_config: AuthenticationConfiguration,
+		hostname: str,
+	) -> None:
+		if auth_config.u2f_config and auth_config.users is not None:
+			self._setup_u2f_login(install_session, auth_config.u2f_config, auth_config.users, hostname)
+
+	def _setup_u2f_login(self, install_session: Installer, u2f_config: U2FLoginConfiguration, users: list[User], hostname: str) -> None:
+		self._configure_u2f_mapping(install_session, u2f_config, users, hostname)
+		self._update_pam_config(install_session, u2f_config)
+
+	def _update_pam_config(
+		self,
+		install_session: Installer,
+		u2f_config: U2FLoginConfiguration,
+	) -> None:
+		match u2f_config.u2f_login_method:
+			case U2FLoginMethod.Passwordless:
+				config_entry = 'auth sufficient pam_u2f.so authfile=/etc/u2f_mappings cue'
+			case U2FLoginMethod.SecondFactor:
+				config_entry = 'auth required pam_u2f.so authfile=/etc/u2f_mappings cue'
+			case _:
+				raise ValueError(f'Unknown U2F login method: {u2f_config.u2f_login_method}')
+
+		debug(f'U2F PAM configuration: {config_entry}')
+		debug(f'Passwordless sudo enabled: {u2f_config.passwordless_sudo}')
+
+		sudo_config = install_session.target / 'etc/pam.d/sudo'
+		sys_login = install_session.target / 'etc/pam.d/system-login'
+
+		if u2f_config.passwordless_sudo:
+			self._add_u2f_entry(sudo_config, config_entry)
+
+		self._add_u2f_entry(sys_login, config_entry)
+
+	def _add_u2f_entry(self, file: Path, entry: str) -> None:
+		if not file.exists():
+			debug(f'File does not exist: {file}')
+			return
+
+		content = file.read_text().splitlines()
+
+		# remove any existing u2f auth entry
+		content = [line for line in content if 'pam_u2f.so' not in line]
+
+		# add the u2f auth entry as the first one after comments
+		for i, line in enumerate(content):
+			if not line.startswith('#'):
+				content.insert(i, entry)
+				break
+		else:
+			content.append(entry)
+
+		file.write_text('\n'.join(content) + '\n')
+
+	def _configure_u2f_mapping(
+		self,
+		install_session: Installer,
+		u2f_config: U2FLoginConfiguration,
+		users: list[User],
+		hostname: str,
+	) -> None:
+		debug(f'Setting up U2F login: {u2f_config.u2f_login_method.value}')
+
+		install_session.pacman.strap('pam-u2f')
+
+		print(tr('Setting up U2F login: {}').format(u2f_config.u2f_login_method.value))
+
+		# https://developers.yubico.com/pam-u2f/
+		u2f_auth_file = install_session.target / 'etc/u2f_mappings'
+		u2f_auth_file.touch()
+		existing_keys = u2f_auth_file.read_text()
+
+		registered_keys: list[str] = []
+
+		for user in users:
+			print('')
+			info(tr('Setting up U2F device for user: {}').format(user.username))
+			info(tr('You may need to enter the PIN and then touch your U2F device to register it'))
+
+			cmd = ' '.join(
+				['arch-chroot', '-S', str(install_session.target), 'pamu2fcfg', '-u', user.username, '-o', f'pam://{hostname}', '-i', f'pam://{hostname}']
+			)
+
+			debug(f'Enrolling U2F device: {cmd}')
+
+			worker = SysCommandWorker(cmd, peek_output=True)
+			pin_inputted = False
+
+			while worker.is_alive():
+				if pin_inputted is False:
+					if bytes('enter pin for', 'UTF-8') in worker._trace_log.lower():
+						worker.write(bytes(getpass.getpass(''), 'UTF-8'))
+						pin_inputted = True
+
+			output = worker.decode().strip().splitlines()
+			debug(f'Output from pamu2fcfg: {output}')
+
+			key = output[-1].strip()
+			registered_keys.append(key)
+
+		all_keys = '\n'.join(registered_keys)
+
+		if existing_keys:
+			existing_keys += f'\n{all_keys}'
+		else:
+			existing_keys = all_keys
+
+		u2f_auth_file.write_text(existing_keys)

archinstall/lib/authentication/authentication_menu.py

@@ -0,0 +1,147 @@
+from typing import override
+
+from archinstall.lib.disk.fido import Fido2
+from archinstall.lib.menu.abstract_menu import AbstractSubMenu
+from archinstall.lib.menu.helpers import Confirmation, Selection
+from archinstall.lib.menu.util import get_password
+from archinstall.lib.models.authentication import AuthenticationConfiguration, U2FLoginConfiguration, U2FLoginMethod
+from archinstall.lib.models.users import Password, User
+from archinstall.lib.translationhandler import tr
+from archinstall.lib.user.user_menu import select_users
+from archinstall.lib.utils.format import as_table
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
+
+
+class AuthenticationMenu(AbstractSubMenu[AuthenticationConfiguration]):
+	def __init__(self, preset: AuthenticationConfiguration | None = None):
+		if preset:
+			self._auth_config = preset
+		else:
+			self._auth_config = AuthenticationConfiguration()
+
+		menu_options = self._define_menu_options()
+		self._item_group = MenuItemGroup(menu_options, checkmarks=True)
+
+		super().__init__(
+			self._item_group,
+			config=self._auth_config,
+			allow_reset=True,
+		)
+
+	@override
+	async def show(self) -> AuthenticationConfiguration | None:
+		return await super().show()
+
+	def _define_menu_options(self) -> list[MenuItem]:
+		return [
+			MenuItem(
+				text=tr('Root password'),
+				action=lambda x: select_root_password(),
+				preview_action=self._prev_root_pwd,
+				key='root_enc_password',
+			),
+			MenuItem(
+				text=tr('User account'),
+				action=self._create_user_account,
+				preview_action=self._prev_users,
+				key='users',
+			),
+			MenuItem(
+				text=tr('U2F login setup'),
+				action=select_u2f_login,
+				value=self._auth_config.u2f_config,
+				preview_action=self._prev_u2f_login,
+				key='u2f_config',
+			),
+		]
+
+	async def _create_user_account(self, preset: list[User] | None = None) -> list[User]:
+		preset = [] if preset is None else preset
+		users = await select_users(preset=preset)
+		return users
+
+	def _prev_users(self, item: MenuItem) -> str | None:
+		users: list[User] | None = item.value
+
+		if users:
+			return as_table(users)
+		return None
+
+	def _prev_root_pwd(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			password: Password = item.value
+			return f'{tr("Root password")}: {password.hidden()}'
+		return None
+
+	def _depends_on_u2f(self) -> bool:
+		devices = Fido2.get_fido2_devices()
+		if not devices:
+			return False
+		return True
+
+	def _prev_u2f_login(self, item: MenuItem) -> str | None:
+		if item.value is not None:
+			u2f_config: U2FLoginConfiguration = item.value
+
+			login_method = u2f_config.u2f_login_method.display_value()
+			output = tr('U2F login method: ') + login_method
+
+			output += '\n'
+			output += tr('Passwordless sudo: ') + (tr('Enabled') if u2f_config.passwordless_sudo else tr('Disabled'))
+
+			return output
+
+		devices = Fido2.get_fido2_devices()
+		if not devices:
+			return tr('No U2F devices found')
+
+		return None
+
+
+async def select_root_password() -> Password | None:
+	password = await get_password(header=tr('Enter root password'), allow_skip=True)
+	return password
+
+
+async def select_u2f_login(preset: U2FLoginConfiguration | None) -> U2FLoginConfiguration | None:
+	devices = Fido2.get_fido2_devices()
+	if not devices:
+		return None
+
+	items = []
+	for method in U2FLoginMethod:
+		items.append(MenuItem(method.display_value(), value=method))
+
+	group = MenuItemGroup(items)
+
+	if preset is not None:
+		group.set_selected_by_value(preset.u2f_login_method)
+
+	result = await Selection[U2FLoginMethod](
+		group,
+		allow_skip=True,
+		allow_reset=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Selection:
+			u2f_method = result.get_value()
+			header = tr('Enable passwordless sudo?')
+
+			result_sudo = await Confirmation(
+				header=header,
+				allow_skip=True,
+				preset=False,
+			).show()
+
+			passwordless_sudo = result_sudo.item() == MenuItem.yes()
+
+			return U2FLoginConfiguration(
+				u2f_login_method=u2f_method,
+				passwordless_sudo=passwordless_sudo,
+			)
+		case ResultType.Skip:
+			return preset
+		case ResultType.Reset:
+			return None

archinstall/lib/boot.py

@@ -1,37 +1,48 @@
 import time
 from collections.abc import Iterator
-from .exceptions import SysCallError
-from .general import SysCommand, SysCommandWorker, locate_binary
-from .installer import Installer
-from .output import error
-from .storage import storage
+from pathlib import Path
+from types import TracebackType
+from typing import ClassVar, Self
+
+from archinstall.lib.command import SysCommand, SysCommandWorker
+from archinstall.lib.exceptions import SysCallError
+from archinstall.lib.log import error
 
 
 class Boot:
-	def __init__(self, installation: Installer):
-		self.instance = installation
+	_active_boot: ClassVar[Self | None] = None
+
+	def __init__(self, path: Path | str):
+		if isinstance(path, Path):
+			path = str(path)
+
+		self.path = path
 		self.container_name = 'archinstall'
 		self.session: SysCommandWorker | None = None
 		self.ready = False
 
-	def __enter__(self) -> 'Boot':
-		if (existing_session := storage.get('active_boot', None)) and existing_session.instance != self.instance:
-			raise KeyError("Archinstall only supports booting up one instance, and a active session is already active and it is not this one.")
+	def __enter__(self) -> Self:
+		if Boot._active_boot and Boot._active_boot.path != self.path:
+			raise KeyError('Archinstall only supports booting up one instance and another session is already active.')
 
-		if existing_session:
-			self.session = existing_session.session
-			self.ready = existing_session.ready
+		if Boot._active_boot:
+			self.session = Boot._active_boot.session
+			self.ready = Boot._active_boot.ready
 		else:
 			# '-P' or --console=pipe  could help us not having to do a bunch
 			# of os.write() calls, but instead use pipes (stdin, stdout and stderr) as usual.
-			self.session = SysCommandWorker([
-				'/usr/bin/systemd-nspawn',
-				'-D', str(self.instance.target),
-				'--timezone=off',
-				'-b',
-				'--no-pager',
-				'--machine', self.container_name
-			])
+			self.session = SysCommandWorker(
+				[
+					'systemd-nspawn',
+					'-D',
+					self.path,
+					'--timezone=off',
+					'-b',
+					'--no-pager',
+					'--machine',
+					self.container_name,
+				]
+			)
 
 		if not self.ready and self.session:
 			while self.session.is_alive():
@@ -39,17 +50,17 @@ class Boot:
 					self.ready = True
 					break
 
-		storage['active_boot'] = self
+		Boot._active_boot = self
 		return self
 
-	def __exit__(self, *args: str, **kwargs: str) -> None:
+	def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
 		# b''.join(sys_command('sync')) # No need to, since the underlying fs() object will call sync.
 		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
 
-		if len(args) >= 2 and args[1]:
+		if exc_type is not None:
 			error(
-				args[1],
-				f"The error above occurred in a temporary boot-up of the installation {self.instance}"
+				str(exc_value),
+				f'The error above occurred in a temporary boot-up of the installation {self.path!r}',
 			)
 
 		shutdown = None
@@ -68,19 +79,18 @@ class Boot:
 			shutdown_exit_code = shutdown.exit_code
 
 		if self.session and (self.session.exit_code == 0 or shutdown_exit_code == 0):
-			storage['active_boot'] = None
+			Boot._active_boot = None
 		else:
 			session_exit_code = self.session.exit_code if self.session else -1
 
 			raise SysCallError(
-				f"Could not shut down temporary boot of {self.instance}: {session_exit_code}/{shutdown_exit_code}",
-				exit_code=next(filter(bool, [session_exit_code, shutdown_exit_code]))
+				f'Could not shut down temporary boot of {self.path!r}: {session_exit_code}/{shutdown_exit_code}',
+				exit_code=next(filter(bool, [session_exit_code, shutdown_exit_code])),
 			)
 
 	def __iter__(self) -> Iterator[bytes]:
 		if self.session:
-			for value in self.session:
-				yield value
+			yield from self.session
 
 	def __contains__(self, key: bytes) -> bool:
 		if self.session is None:
@@ -94,18 +104,8 @@ class Boot:
 
 		return self.session.is_alive()
 
-	def SysCommand(self, cmd: list[str], *args, **kwargs) -> SysCommand:
-		if cmd[0][0] != '/' and cmd[0][:2] != './':
-			# This check is also done in SysCommand & SysCommandWorker.
-			# However, that check is done for `machinectl` and not for our chroot command.
-			# So this wrapper for SysCommand will do this additionally.
+	def SysCommand(self, cmd: list[str], *args, **kwargs) -> SysCommand:  # type: ignore[no-untyped-def]
+		return SysCommand(['systemd-run', f'--machine={self.container_name}', '--pty', *cmd], *args, **kwargs)
 
-			cmd[0] = locate_binary(cmd[0])
-
-		return SysCommand(["systemd-run", f"--machine={self.container_name}", "--pty", *cmd], *args, **kwargs)
-
-	def SysCommandWorker(self, cmd: list[str], *args, **kwargs) -> SysCommandWorker:
-		if cmd[0][0] != '/' and cmd[0][:2] != './':
-			cmd[0] = locate_binary(cmd[0])
-
-		return SysCommandWorker(["systemd-run", f"--machine={self.container_name}", "--pty", *cmd], *args, **kwargs)
+	def SysCommandWorker(self, cmd: list[str], *args, **kwargs) -> SysCommandWorker:  # type: ignore[no-untyped-def]
+		return SysCommandWorker(['systemd-run', f'--machine={self.container_name}', '--pty', *cmd], *args, **kwargs)

archinstall/lib/bootloader/bootloader_menu.py

@@ -0,0 +1,217 @@
+import textwrap
+from typing import override
+
+from archinstall.lib.menu.abstract_menu import AbstractSubMenu
+from archinstall.lib.menu.helpers import Confirmation, Selection
+from archinstall.lib.models.bootloader import Bootloader, BootloaderConfiguration
+from archinstall.lib.translationhandler import tr
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
+
+
+class BootloaderMenu(AbstractSubMenu[BootloaderConfiguration]):
+	def __init__(
+		self,
+		bootloader_conf: BootloaderConfiguration,
+		uefi: bool,
+		skip_boot: bool = False,
+	):
+		self._bootloader_conf = bootloader_conf
+		self._skip_boot = skip_boot
+		self._uefi = uefi
+		menu_options = self._define_menu_options()
+
+		self._item_group = MenuItemGroup(menu_options, sort_items=False, checkmarks=True)
+		super().__init__(
+			self._item_group,
+			config=self._bootloader_conf,
+			allow_reset=False,
+		)
+
+	def _define_menu_options(self) -> list[MenuItem]:
+		bootloader = self._bootloader_conf.bootloader
+
+		# UKI availability
+		uki_enabled = self._uefi and bootloader.has_uki_support()
+		if not uki_enabled:
+			self._bootloader_conf.uki = False
+
+		# Removable availability
+		removable_enabled = self._uefi and bootloader.has_removable_support()
+		if not removable_enabled:
+			self._bootloader_conf.removable = False
+
+		return [
+			MenuItem(
+				text=tr('Bootloader'),
+				action=self._select_bootloader,
+				value=self._bootloader_conf.bootloader,
+				preview_action=self._prev_bootloader,
+				mandatory=True,
+				key='bootloader',
+			),
+			MenuItem(
+				text=tr('Unified kernel images'),
+				action=self._select_uki,
+				value=self._bootloader_conf.uki,
+				preview_action=self._prev_uki,
+				key='uki',
+				enabled=uki_enabled,
+			),
+			MenuItem(
+				text=tr('Install to removable location'),
+				action=self._select_removable,
+				value=self._bootloader_conf.removable,
+				preview_action=self._prev_removable,
+				key='removable',
+				enabled=removable_enabled,
+			),
+		]
+
+	def _prev_bootloader(self, item: MenuItem) -> str | None:
+		if item.value:
+			return f'{tr("Bootloader")}: {item.value.value}'
+		return None
+
+	def _prev_uki(self, item: MenuItem) -> str | None:
+		uki_text = f'{tr("Unified kernel images")}'
+		if item.value:
+			return f'{uki_text}: {tr("Enabled")}'
+		else:
+			return f'{uki_text}: {tr("Disabled")}'
+
+	def _prev_removable(self, item: MenuItem) -> str | None:
+		if item.value:
+			return tr('Will install to /EFI/BOOT/ (removable location, safe default)')
+		return tr('Will install to custom location with NVRAM entry')
+
+	@override
+	async def show(self) -> BootloaderConfiguration:
+		_ = await super().show()
+		return self._bootloader_conf
+
+	async def _select_bootloader(self, preset: Bootloader | None) -> Bootloader | None:
+		bootloader = await select_bootloader(preset, self._uefi, self._skip_boot)
+
+		if bootloader:
+			# Update UKI option based on bootloader
+			uki_item = self._menu_item_group.find_by_key('uki')
+			if not self._uefi or not bootloader.has_uki_support():
+				uki_item.enabled = False
+				uki_item.value = False
+				self._bootloader_conf.uki = False
+			else:
+				uki_item.enabled = True
+
+			# Update removable option based on bootloader
+			removable_item = self._menu_item_group.find_by_key('removable')
+			if not self._uefi or not bootloader.has_removable_support():
+				removable_item.enabled = False
+				removable_item.value = False
+				self._bootloader_conf.removable = False
+			else:
+				if not removable_item.enabled:
+					removable_item.value = True
+					self._bootloader_conf.removable = True
+				removable_item.enabled = True
+
+		return bootloader
+
+	async def _select_uki(self, preset: bool) -> bool:
+		prompt = tr('Would you like to use unified kernel images?') + '\n'
+
+		result = await Confirmation(header=prompt, allow_skip=True, preset=preset).show()
+
+		match result.type_:
+			case ResultType.Skip:
+				return preset
+			case ResultType.Selection:
+				return result.item() == MenuItem.yes()
+			case ResultType.Reset:
+				raise ValueError('Unhandled result type')
+
+	async def _select_removable(self, preset: bool) -> bool:
+		prompt = (
+			tr('Would you like to install the bootloader to the default removable media search location?')
+			+ '\n\n'
+			+ tr('This installs the bootloader to /EFI/BOOT/BOOTX64.EFI (or similar) which is useful for:')
+			+ '\n\n  • '
+			+ tr('Firmware that does not properly support NVRAM boot entries like most MSI motherboards,')
+			+ '\n	 '
+			+ tr('most Apple Macs, many laptops...')
+			+ '\n  • '
+			+ tr('USB drives or other portable external media.')
+			+ '\n  • '
+			+ tr('Systems where you want the disk to be bootable on any computer.')
+			+ '\n\n'
+			+ tr(
+				textwrap.dedent(
+					"""\
+					If you do not know what this means, LEAVE THIS OPTION ENABLED, as it is the safe default.
+
+					It is suggested to disable this if none of the above apply, as it makes installing multiple
+					EFI bootloaders on the same disk easier, and it will not overwrite whatever bootloader
+					was previously installed at the default removable media search location, if any.
+
+					It may also make the installation more resilient in case of dual-booting with Windows,
+					as Windows is known to sometimes erase or replace the bootloader installed at the removable
+					location.
+					"""
+				)
+			)
+			+ '\n'
+		)
+
+		result = await Confirmation(
+			header=prompt,
+			allow_skip=True,
+			preset=preset,
+		).show()
+
+		match result.type_:
+			case ResultType.Skip:
+				return preset
+			case ResultType.Selection:
+				return result.get_value()
+			case ResultType.Reset:
+				raise ValueError('Unhandled result type')
+
+
+async def select_bootloader(
+	preset: Bootloader | None,
+	uefi: bool,
+	skip_boot: bool = False,
+) -> Bootloader | None:
+	options = []
+	hidden_options = []
+	header = tr('Select bootloader to install')
+
+	default = Bootloader.get_default(uefi, skip_boot)
+
+	if not skip_boot:
+		hidden_options += [Bootloader.NO_BOOTLOADER]
+
+	if not uefi:
+		options += [Bootloader.Grub, Bootloader.Limine]
+		header += '\n' + tr('UEFI is not detected and some options are disabled')
+	else:
+		options += [b for b in Bootloader if b not in hidden_options]
+
+	items = [MenuItem(o.value, value=o) for o in options]
+	group = MenuItemGroup(items)
+	group.set_default_by_value(default)
+	group.set_focus_by_value(preset)
+
+	result = await Selection[Bootloader](
+		group,
+		header=header,
+		allow_skip=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Selection:
+			return result.get_value()
+		case ResultType.Reset:
+			raise ValueError('Unhandled result type')

archinstall/lib/bootloader/utils.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from pathlib import Path
+
+from archinstall.lib.hardware import SysInfo
+from archinstall.lib.models.bootloader import Bootloader, BootloaderConfiguration
+from archinstall.lib.models.device import DiskLayoutConfiguration
+
+
+class BootloaderValidationFailureKind(Enum):
+	LimineNonFatBoot = auto()
+	LimineLayout = auto()
+	BootloaderRequiresUefi = auto()
+	EfistubNonFatBoot = auto()
+
+
+@dataclass(frozen=True)
+class BootloaderValidationFailure:
+	kind: BootloaderValidationFailureKind
+	description: str
+
+
+def validate_bootloader_layout(
+	bootloader_config: BootloaderConfiguration | None,
+	disk_config: DiskLayoutConfiguration | None,
+) -> BootloaderValidationFailure | None:
+	"""Validate bootloader configuration against disk layout.
+
+	Returns a failure with a human-readable description if the configuration
+	would produce an unbootable system, or None if it is valid.
+	"""
+	if not (bootloader_config and disk_config):
+		return None
+
+	bootloader = bootloader_config.bootloader
+
+	if bootloader == Bootloader.NO_BOOTLOADER:
+		return None
+
+	if bootloader.is_uefi_only() and not SysInfo.has_uefi():
+		return BootloaderValidationFailure(
+			kind=BootloaderValidationFailureKind.BootloaderRequiresUefi,
+			description=f'{bootloader.value} requires a UEFI system.',
+		)
+
+	boot_part = next(
+		(p for m in disk_config.device_modifications if (p := m.get_boot_partition())),
+		None,
+	)
+
+	if bootloader == Bootloader.Efistub:
+		# The UEFI firmware reads the kernel directly from the boot partition,
+		# which must be FAT.
+		if boot_part and (boot_part.fs_type is None or not boot_part.fs_type.is_fat()):
+			return BootloaderValidationFailure(
+				kind=BootloaderValidationFailureKind.EfistubNonFatBoot,
+				description='Efistub does not support booting with a non-FAT boot partition.',
+			)
+
+	if bootloader == Bootloader.Limine:
+		# Limine reads its config and kernels from the boot partition, which
+		# must be FAT.
+		if boot_part and (boot_part.fs_type is None or not boot_part.fs_type.is_fat()):
+			return BootloaderValidationFailure(
+				kind=BootloaderValidationFailureKind.LimineNonFatBoot,
+				description='Limine does not support booting with a non-FAT boot partition.',
+			)
+
+		# When the ESP is the boot partition but mounted outside /boot and
+		# UKI is disabled, kernels end up on the root filesystem which
+		# Limine cannot access.
+		if not bootloader_config.uki:
+			efi_part = next(
+				(p for m in disk_config.device_modifications if (p := m.get_efi_partition())),
+				None,
+			)
+			if efi_part and efi_part == boot_part and efi_part.mountpoint != Path('/boot'):
+				return BootloaderValidationFailure(
+					kind=BootloaderValidationFailureKind.LimineLayout,
+					description=(
+						f'Limine requires kernels on a FAT partition. The ESP is mounted at {efi_part.mountpoint}, '
+						'enable UKI or add a separate /boot partition to install Limine.'
+					),
+				)
+
+	return None

archinstall/lib/command.py

@@ -0,0 +1,384 @@
+import os
+import shlex
+import stat
+import subprocess
+import sys
+import time
+from collections.abc import Iterator
+from select import EPOLLHUP, EPOLLIN, epoll
+from shutil import which
+from types import TracebackType
+from typing import Any, Self, override
+
+from archinstall.lib.exceptions import RequirementError, SysCallError
+from archinstall.lib.log import debug, error, logger
+from archinstall.lib.utils.encoding import clear_vt100_escape_codes
+
+
+class SysCommandWorker:
+	def __init__(
+		self,
+		cmd: str | list[str],
+		peek_output: bool | None = False,
+		environment_vars: dict[str, str] | None = None,
+		working_directory: str = './',
+		remove_vt100_escape_codes_from_lines: bool = True,
+	):
+		if isinstance(cmd, str):
+			cmd = shlex.split(cmd)
+
+		if cmd and not cmd[0].startswith(('/', './')):  # Path() does not work well
+			cmd[0] = locate_binary(cmd[0])
+
+		self.cmd = cmd
+		self.peek_output = peek_output
+		# define the standard locale for command outputs. For now the C ascii one. Can be overridden
+		self.environment_vars = {'LC_ALL': 'C'}
+		if environment_vars:
+			self.environment_vars.update(environment_vars)
+
+		self.working_directory = working_directory
+
+		self.exit_code: int | None = None
+		self._trace_log = b''
+		self._trace_log_pos = 0
+		self.poll_object = epoll()
+		self.child_fd: int | None = None
+		self.started = False
+		self.ended = False
+		self.remove_vt100_escape_codes_from_lines: bool = remove_vt100_escape_codes_from_lines
+
+	def __contains__(self, key: bytes) -> bool:
+		"""
+		Contains will also move the current buffert position forward.
+		This is to avoid re-checking the same data when looking for output.
+		"""
+		assert isinstance(key, bytes)
+
+		index = self._trace_log.find(key, self._trace_log_pos)
+		if index >= 0:
+			self._trace_log_pos += index + len(key)
+			return True
+
+		return False
+
+	def __iter__(self, *args: str, **kwargs: dict[str, Any]) -> Iterator[bytes]:
+		last_line = self._trace_log.rfind(b'\n')
+		lines = filter(None, self._trace_log[self._trace_log_pos : last_line].splitlines())
+		for line in lines:
+			if self.remove_vt100_escape_codes_from_lines:
+				line = clear_vt100_escape_codes(line)
+
+			yield line + b'\n'
+
+		self._trace_log_pos = last_line
+
+	@override
+	def __repr__(self) -> str:
+		self.make_sure_we_are_executing()
+		return str(self._trace_log)
+
+	@override
+	def __str__(self) -> str:
+		try:
+			return self._trace_log.decode('utf-8')
+		except UnicodeDecodeError:
+			return str(self._trace_log)
+
+	def __enter__(self) -> Self:
+		return self
+
+	def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+		# b''.join(sys_command('sync')) # No need to, since the underlying fs() object will call sync.
+		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
+
+		if self.child_fd:
+			try:
+				os.close(self.child_fd)
+			except Exception:
+				pass
+
+		if self.peek_output:
+			# To make sure any peaked output didn't leave us hanging
+			# on the same line we were on.
+			sys.stdout.write('\n')
+			sys.stdout.flush()
+
+		if exc_type is not None:
+			debug(str(exc_value))
+
+		if self.exit_code != 0:
+			raise SysCallError(
+				f'{self.cmd} exited with abnormal exit code [{self.exit_code}]: {str(self)[-500:]}',
+				self.exit_code,
+				worker_log=self._trace_log,
+			)
+
+	def is_alive(self) -> bool:
+		self.poll()
+
+		if self.started and not self.ended:
+			return True
+
+		return False
+
+	def write(self, data: bytes, line_ending: bool = True) -> int:
+		assert isinstance(data, bytes)  # TODO: Maybe we can support str as well and encode it
+
+		self.make_sure_we_are_executing()
+
+		if self.child_fd:
+			return os.write(self.child_fd, data + (b'\n' if line_ending else b''))
+
+		return 0
+
+	def make_sure_we_are_executing(self) -> bool:
+		if not self.started:
+			return self.execute()
+		return True
+
+	def tell(self) -> int:
+		self.make_sure_we_are_executing()
+		return self._trace_log_pos
+
+	def seek(self, pos: int) -> None:
+		self.make_sure_we_are_executing()
+		# Safety check to ensure 0 < pos < len(tracelog)
+		self._trace_log_pos = min(max(0, pos), len(self._trace_log))
+
+	def peak(self, output: str | bytes) -> bool:
+		if self.peek_output:
+			if isinstance(output, bytes):
+				try:
+					output = output.decode('UTF-8')
+				except UnicodeDecodeError:
+					return False
+
+			_cmd_output(output)
+
+			sys.stdout.write(output)
+			sys.stdout.flush()
+
+		return True
+
+	def poll(self) -> None:
+		self.make_sure_we_are_executing()
+
+		if self.child_fd:
+			got_output = False
+			for _fileno, _event in self.poll_object.poll(0.1):
+				try:
+					output = os.read(self.child_fd, 8192)
+					got_output = True
+					self.peak(output)
+					self._trace_log += output
+				except OSError:
+					self.ended = True
+					break
+
+			if self.ended or (not got_output and not _pid_exists(self.pid)):
+				self.ended = True
+				try:
+					wait_status = os.waitpid(self.pid, 0)[1]
+					self.exit_code = os.waitstatus_to_exitcode(wait_status)
+				except ChildProcessError:
+					try:
+						wait_status = os.waitpid(self.child_fd, 0)[1]
+						self.exit_code = os.waitstatus_to_exitcode(wait_status)
+					except ChildProcessError:
+						self.exit_code = 1
+
+	def execute(self) -> bool:
+		import pty
+
+		if (old_dir := os.getcwd()) != self.working_directory:
+			os.chdir(str(self.working_directory))
+
+		# Note: If for any reason, we get a Python exception between here
+		# and until os.close(), the traceback will get locked inside
+		# stdout of the child_fd object. `os.read(self.child_fd, 8192)` is the
+		# only way to get the traceback without losing it.
+
+		self.pid, self.child_fd = pty.fork()
+
+		# https://stackoverflow.com/questions/4022600/python-pty-fork-how-does-it-work
+		if not self.pid:
+			_cmd_history(self.cmd)
+
+			try:
+				os.execve(self.cmd[0], list(self.cmd), {**os.environ, **self.environment_vars})
+			except FileNotFoundError:
+				error(f'{self.cmd[0]} does not exist.')
+				self.exit_code = 1
+				return False
+		else:
+			# Only parent process moves back to the original working directory
+			os.chdir(old_dir)
+
+		self.started = True
+		self.poll_object.register(self.child_fd, EPOLLIN | EPOLLHUP)
+
+		return True
+
+	def decode(self, encoding: str = 'UTF-8') -> str:
+		return self._trace_log.decode(encoding)
+
+
+class SysCommand:
+	def __init__(
+		self,
+		cmd: str | list[str],
+		peek_output: bool | None = False,
+		environment_vars: dict[str, str] | None = None,
+		working_directory: str = './',
+		remove_vt100_escape_codes_from_lines: bool = True,
+	):
+		self.cmd = cmd
+		self.peek_output = peek_output
+		self.environment_vars = environment_vars
+		self.working_directory = working_directory
+		self.remove_vt100_escape_codes_from_lines = remove_vt100_escape_codes_from_lines
+
+		self.session: SysCommandWorker | None = None
+		self.create_session()
+
+	def __enter__(self) -> SysCommandWorker | None:
+		return self.session
+
+	def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+		# b''.join(sys_command('sync')) # No need to, since the underlying fs() object will call sync.
+		# TODO: https://stackoverflow.com/questions/28157929/how-to-safely-handle-an-exception-inside-a-context-manager
+
+		if exc_type is not None:
+			error(str(exc_value))
+
+	def __iter__(self, *args: list[Any], **kwargs: dict[str, Any]) -> Iterator[bytes]:
+		if self.session:
+			yield from self.session
+
+	def __getitem__(self, key: slice) -> bytes:
+		if not self.session:
+			raise KeyError('SysCommand() does not have an active session.')
+		elif type(key) is slice:
+			start = key.start or 0
+			end = key.stop or len(self.session._trace_log)
+
+			return self.session._trace_log[start:end]
+		else:
+			raise ValueError("SysCommand() doesn't have key & value pairs, only slices, SysCommand('ls')[:10] as an example.")
+
+	@override
+	def __repr__(self, *args: list[Any], **kwargs: dict[str, Any]) -> str:
+		return self.decode('UTF-8', errors='backslashreplace') or ''
+
+	def create_session(self) -> bool:
+		"""
+		Initiates a :ref:`SysCommandWorker` session in this class ``.session``.
+		It then proceeds to poll the process until it ends, after which it also
+		clears any printed output if ``.peek_output=True``.
+		"""
+		if self.session:
+			return True
+
+		with SysCommandWorker(
+			self.cmd,
+			peek_output=self.peek_output,
+			environment_vars=self.environment_vars,
+			remove_vt100_escape_codes_from_lines=self.remove_vt100_escape_codes_from_lines,
+			working_directory=self.working_directory,
+		) as session:
+			self.session = session
+
+			while not self.session.ended:
+				self.session.poll()
+
+		if self.peek_output:
+			sys.stdout.write('\n')
+			sys.stdout.flush()
+
+		return True
+
+	def decode(self, encoding: str = 'utf-8', errors: str = 'backslashreplace', strip: bool = True) -> str:
+		if not self.session:
+			raise ValueError('No session available to decode')
+
+		val = self.session._trace_log.decode(encoding, errors=errors)
+
+		if strip:
+			return val.strip()
+		return val
+
+	def output(self, remove_cr: bool = True) -> bytes:
+		if not self.session:
+			raise ValueError('No session available')
+
+		if remove_cr:
+			return self.session._trace_log.replace(b'\r\n', b'\n')
+
+		return self.session._trace_log
+
+	@property
+	def exit_code(self) -> int | None:
+		if self.session:
+			return self.session.exit_code
+		else:
+			return None
+
+	@property
+	def trace_log(self) -> bytes | None:
+		if self.session:
+			return self.session._trace_log
+		return None
+
+
+def run(
+	cmd: list[str],
+	input_data: bytes | None = None,
+) -> subprocess.CompletedProcess[bytes]:
+	_cmd_history(cmd)
+
+	return subprocess.run(
+		cmd,
+		input=input_data,
+		stdout=subprocess.PIPE,
+		stderr=subprocess.STDOUT,
+		check=True,
+	)
+
+
+def locate_binary(name: str) -> str:
+	if path := which(name):
+		return path
+	raise RequirementError(f'Binary {name} does not exist.')
+
+
+def _pid_exists(pid: int) -> bool:
+	try:
+		return any(subprocess.check_output(['ps', '--no-headers', '-o', 'pid', '-p', str(pid)]).strip())
+	except subprocess.CalledProcessError:
+		return False
+
+
+def _cmd_history(cmd: list[str]) -> None:
+	content = f'{time.time()} {cmd}\n'
+	_append_log('cmd_history.txt', content)
+
+
+def _cmd_output(output: str) -> None:
+	_append_log('cmd_output.txt', output)
+
+
+def _append_log(file: str, content: str) -> None:
+	path = logger.directory / file
+
+	change_perm = not path.exists()
+
+	try:
+		with path.open('a') as f:
+			f.write(content)
+
+		if change_perm:
+			path.chmod(stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP)
+	except PermissionError, FileNotFoundError:
+		# If the file does not exist, ignore the error
+		pass

archinstall/lib/configuration.py

@@ -1,115 +1,134 @@
-import os
 import json
-import stat
 import readline
+import stat
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
+from typing import Any
 
-from .storage import storage
-from .general import JSON, UNSAFE_JSON
-from .output import debug, warn
-from .utils.util import prompt_dir
+from pydantic import TypeAdapter
 
-from archinstall.tui import (
-	MenuItemGroup, MenuItem, SelectMenu,
-	FrameProperties, Alignment, ResultType,
-	PreviewStyle, Orientation, Tui
-)
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.lib.args import ArchConfig, ArchConfigType
+from archinstall.lib.crypt import encrypt
+from archinstall.lib.log import debug, logger, warn
+from archinstall.lib.menu.helpers import Confirmation, Selection
+from archinstall.lib.menu.util import get_password, prompt_dir
+from archinstall.lib.models.network import NetworkConfiguration
+from archinstall.lib.translationhandler import tr
+from archinstall.lib.utils.format import as_key_value_pair
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
 
 
 class ConfigurationOutput:
-	def __init__(self, config: dict):
+	def __init__(self, config: ArchConfig):
 		"""
-		Configuration output handler to parse the existing configuration data structure and prepare for output on the
+		Configuration output handler to parse the existing
+		configuration data structure and prepare for output on the
 		console and for saving it to configuration files
 
-		:param config: A dictionary containing configurations (basically archinstall.arguments)
-		:type config: dict
+		:param config: Archinstall configuration object
+		:type config: ArchConfig
 		"""
+
 		self._config = config
-		self._user_credentials: dict[str, Any] = {}
-		self._user_config: dict[str, Any] = {}
-		self._default_save_path = storage.get('LOG_PATH', Path('.'))
-		self._user_config_file = 'user_configuration.json'
-		self._user_creds_file = "user_credentials.json"
-
-		self._sensitive = ['!users', '!root-password']
-		self._ignore = ['abort', 'install', 'config', 'creds', 'dry_run']
-
-		self._process_config()
+		self._default_save_path = logger.directory
+		self._user_config_file = Path('user_configuration.json')
+		self._user_creds_file = Path('user_credentials.json')
 
 	@property
-	def user_credentials_file(self) -> str:
-		return self._user_creds_file
-
-	@property
-	def user_configuration_file(self) -> str:
+	def user_configuration_file(self) -> Path:
 		return self._user_config_file
 
-	def _process_config(self) -> None:
-		for key, value in self._config.items():
-			if key in self._sensitive:
-				self._user_credentials[key] = value
-			elif key in self._ignore:
-				pass
-			else:
-				self._user_config[key] = value
-
-			# special handling for encryption password
-			if key == 'disk_encryption' and value:
-				self._user_credentials['encryption_password'] = value.encryption_password
+	@property
+	def user_credentials_file(self) -> Path:
+		return self._user_creds_file
 
 	def user_config_to_json(self) -> str:
-		return json.dumps({
-			'config_version': storage['__version__'],  # Tells us what version was used to generate the config
-			**self._user_config,  # __version__ will be overwritten by old version definition found in config
-			'version': storage['__version__']
-		}, indent=4, sort_keys=True, cls=JSON)
+		config = self._config.safe_config()
 
-	def user_credentials_to_json(self) -> str | None:
-		if self._user_credentials:
-			return json.dumps(self._user_credentials, indent=4, sort_keys=True, cls=UNSAFE_JSON)
-		return None
+		adapter = TypeAdapter(dict[ArchConfigType, Any])
+		python_dict = adapter.dump_python(config)
+		return json.dumps(python_dict, indent=4, sort_keys=True)
+
+	def user_credentials_to_json(self) -> str:
+		cfg = self._config.unsafe_config()
+
+		adapter = TypeAdapter(dict[ArchConfigType, Any])
+		python_dict = adapter.dump_python(cfg)
+		return json.dumps(python_dict, indent=4, sort_keys=True)
 
 	def write_debug(self) -> None:
-		debug(" -- Chosen configuration --")
+		debug(' -- Chosen configuration --')
 		debug(self.user_config_to_json())
 
-	def confirm_config(self) -> bool:
-		header = f'{_("The specified configuration will be applied")}. '
-		header += str(_('Would you like to continue?')) + '\n'
+	def as_summary(self) -> str:
+		"""
+		Render a concise two-column summary of the current configuration.
 
-		with Tui():
-			group = MenuItemGroup.yes_no()
-			group.focus_item = MenuItem.yes()
-			group.set_preview_for_all(lambda x: self.user_config_to_json())
+		Returns an empty string if nothing meaningful to show.
+		"""
+		cfg: dict[str, str | list[str] | bool] = {}
 
-			result = SelectMenu(
-				group,
-				header=header,
-				alignment=Alignment.CENTER,
-				columns=2,
-				orientation=Orientation.HORIZONTAL,
-				allow_skip=False,
-				preview_size='auto',
-				preview_style=PreviewStyle.BOTTOM,
-				preview_frame=FrameProperties.max(str(_('Configuration')))
-			).run()
+		for key, value in self._config.plain_cfg().items():
+			cfg[key.text()] = value
 
-			if result.item() != MenuItem.yes():
-				return False
+		for config_type, obj in self._config.sub_cfg().items():
+			if not hasattr(obj, 'summary'):
+				continue
+
+			summary = obj.summary()
+			if summary:
+				cfg[config_type.text()] = summary
+
+		simple_summary = as_key_value_pair(cfg, ignore_empty=True)
+
+		return simple_summary
+
+	async def confirm_config(self, show_install_warnings: bool = False) -> bool:
+		header = f'{tr("The specified configuration will be applied")}. '
+		header += tr('Would you like to continue?') + '\n'
+
+		if show_install_warnings:
+			header += self._render_install_warnings()
+
+		group = MenuItemGroup.yes_no()
+		group.set_preview_for_all(lambda x: self.user_config_to_json())
+
+		result = await Confirmation(
+			group=group,
+			header=header,
+			allow_skip=False,
+			preset=True,
+			preview_location='bottom',
+			preview_header=tr('Configuration preview'),
+		).show()
+
+		if not result.get_value():
+			return False
 
 		return True
 
+	def get_install_warnings(self) -> list[str]:
+		warnings: list[str] = []
+
+		if not isinstance(self._config.network_config, NetworkConfiguration):
+			warnings.append(tr('Warning: no network configuration selected. Network will need to be set up manually on the installed system.'))
+
+		return warnings
+
+	def _render_install_warnings(self) -> str:
+		warnings = self.get_install_warnings()
+
+		if not warnings:
+			return ''
+
+		return '\n' + '\n'.join(f'[yellow]{w}[/]' for w in warnings) + '\n'
+
 	def _is_valid_path(self, dest_path: Path) -> bool:
 		dest_path_ok = dest_path.exists() and dest_path.is_dir()
 		if not dest_path_ok:
 			warn(
 				f'Destination directory {dest_path.resolve()} does not exist or is not a directory\n.',
-				'Configuration files can not be saved'
+				'Configuration files can not be saved',
 			)
 		return dest_path_ok
 
@@ -117,37 +136,51 @@ class ConfigurationOutput:
 		if self._is_valid_path(dest_path):
 			target = dest_path / self._user_config_file
 			target.write_text(self.user_config_to_json())
-			os.chmod(target, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP)
+			target.chmod(stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP)
 
-	def save_user_creds(self, dest_path: Path) -> None:
-		if self._is_valid_path(dest_path):
-			if user_creds := self.user_credentials_to_json():
-				target = dest_path / self._user_creds_file
-				target.write_text(user_creds)
-				os.chmod(target, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP)
+	def save_user_creds(
+		self,
+		dest_path: Path,
+		password: str | None = None,
+	) -> None:
+		data = self.user_credentials_to_json()
 
-	def save(self, dest_path: Path | None = None) -> None:
-		dest_path = dest_path or self._default_save_path
+		if password:
+			data = encrypt(password, data)
 
 		if self._is_valid_path(dest_path):
-			self.save_user_config(dest_path)
-			self.save_user_creds(dest_path)
+			target = dest_path / self._user_creds_file
+			target.write_text(data)
+			target.chmod(stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP)
+
+	def save(
+		self,
+		dest_path: Path | None = None,
+		creds: bool = False,
+		password: str | None = None,
+	) -> None:
+		save_path = dest_path or self._default_save_path
+
+		if self._is_valid_path(save_path):
+			self.save_user_config(save_path)
+			if creds:
+				self.save_user_creds(save_path, password=password)
 
 
-def save_config(config: dict[str, Any]) -> None:
+async def save_config(config: ArchConfig) -> None:
 	def preview(item: MenuItem) -> str | None:
 		match item.value:
-			case "user_config":
+			case 'user_config':
 				serialized = config_output.user_config_to_json()
-				return f"{config_output.user_configuration_file}\n{serialized}"
-			case "user_creds":
+				return f'{config_output.user_configuration_file}\n{serialized}'
+			case 'user_creds':
 				if maybe_serial := config_output.user_credentials_to_json():
-					return f"{config_output.user_credentials_file}\n{maybe_serial}"
-				return str(_("No configuration"))
-			case "all":
-				output = [config_output.user_configuration_file]
-				if config_output.user_credentials_to_json():
-					output.append(config_output.user_credentials_file)
+					return f'{config_output.user_credentials_file}\n{maybe_serial}'
+				return tr('No configuration')
+			case 'all':
+				output = [str(config_output.user_configuration_file)]
+				config_output.user_credentials_to_json()
+				output.append(str(config_output.user_credentials_file))
 				return '\n'.join(output)
 		return None
 
@@ -155,30 +188,28 @@ def save_config(config: dict[str, Any]) -> None:
 
 	items = [
 		MenuItem(
-			str(_("Save user configuration (including disk layout)")),
-			value="user_config",
-			preview_action=lambda x: preview(x)
+			tr('Save user configuration (including disk layout)'),
+			value='user_config',
+			preview_action=preview,
 		),
 		MenuItem(
-			str(_("Save user credentials")),
-			value="user_creds",
-			preview_action=lambda x: preview(x)
+			tr('Save user credentials'),
+			value='user_creds',
+			preview_action=preview,
 		),
 		MenuItem(
-			str(_("Save all")),
-			value="all",
-			preview_action=lambda x: preview(x)
-		)
+			tr('Save all'),
+			value='all',
+			preview_action=preview,
+		),
 	]
 
 	group = MenuItemGroup(items)
-	result = SelectMenu(
+	result = await Selection[str](
 		group,
 		allow_skip=True,
-		preview_frame=FrameProperties.max(str(_('Configuration'))),
-		preview_size='auto',
-		preview_style=PreviewStyle.RIGHT
-	).run()
+		preview_location='right',
+	).show()
 
 	match result.type_:
 		case ResultType.Skip:
@@ -188,43 +219,57 @@ def save_config(config: dict[str, Any]) -> None:
 		case _:
 			raise ValueError('Unhandled return type')
 
-	readline.set_completer_delims("\t\n=")
-	readline.parse_and_bind("tab: complete")
+	readline.set_completer_delims('\t\n=')
+	readline.parse_and_bind('tab: complete')
 
-	dest_path = prompt_dir(
-		str(_('Directory')),
-		str(_('Enter a directory for the configuration(s) to be saved (tab completion enabled)')) + '\n',
-		allow_skip=True
+	dest_path = await prompt_dir(
+		tr('Enter a directory for the configuration(s) to be saved') + '\n',
+		allow_skip=True,
 	)
 
 	if not dest_path:
 		return
 
-	header = str(_("Do you want to save the configuration file(s) to {}?")).format(dest_path)
+	header = tr('Do you want to save the configuration file(s) to {}?').format(dest_path)
 
-	group = MenuItemGroup.yes_no()
-	group.focus_item = MenuItem.yes()
-
-	result = SelectMenu(
-		group,
+	save_result = await Confirmation(
 		header=header,
 		allow_skip=False,
-		alignment=Alignment.CENTER,
-		columns=2,
-		orientation=Orientation.HORIZONTAL
-	).run()
+		preset=True,
+	).show()
 
-	match result.type_:
+	match save_result.type_:
 		case ResultType.Selection:
-			if result.item() == MenuItem.no():
+			if not save_result.get_value():
 				return
+		case _:
+			return
 
-	debug("Saving configuration files to {}".format(dest_path.absolute()))
+	debug(f'Saving configuration files to {dest_path.absolute()}')
+
+	header = tr('Do you want to encrypt the user_credentials.json file?')
+
+	enc_result = await Confirmation(
+		header=header,
+		allow_skip=False,
+		preset=False,
+	).show()
+
+	enc_password: str | None = None
+	if enc_result.type_ == ResultType.Selection:
+		if enc_result.get_value():
+			password = await get_password(
+				header=tr('Credentials file encryption password'),
+				allow_skip=True,
+			)
+
+			if password:
+				enc_password = password.plaintext
 
 	match save_option:
-		case "user_config":
+		case 'user_config':
 			config_output.save_user_config(dest_path)
-		case "user_creds":
-			config_output.save_user_creds(dest_path)
-		case "all":
-			config_output.save(dest_path)
+		case 'user_creds':
+			config_output.save_user_creds(dest_path, password=enc_password)
+		case 'all':
+			config_output.save(dest_path, creds=True, password=enc_password)

archinstall/lib/crypt.py

@@ -0,0 +1,125 @@
+import base64
+import ctypes
+import os
+from pathlib import Path
+
+from cryptography.fernet import Fernet, InvalidToken
+from cryptography.hazmat.primitives.kdf.argon2 import Argon2id
+
+from archinstall.lib.log import debug
+
+libcrypt = ctypes.CDLL('libcrypt.so')
+
+libcrypt.crypt.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
+libcrypt.crypt.restype = ctypes.c_char_p
+
+libcrypt.crypt_gensalt.argtypes = [ctypes.c_char_p, ctypes.c_ulong, ctypes.c_char_p, ctypes.c_int]
+libcrypt.crypt_gensalt.restype = ctypes.c_char_p
+
+LOGIN_DEFS = Path('/etc/login.defs')
+
+
+def _search_login_defs(key: str) -> str | None:
+	defs = LOGIN_DEFS.read_text()
+	for line in defs.split('\n'):
+		line = line.strip()
+
+		if line.startswith('#'):
+			continue
+
+		if line.startswith(key):
+			value = line.split(' ')[1]
+			return value
+
+	return None
+
+
+def crypt_gen_salt(prefix: str | bytes, rounds: int) -> bytes:
+	if isinstance(prefix, str):
+		prefix = prefix.encode('utf-8')
+
+	setting = libcrypt.crypt_gensalt(prefix, rounds, None, 0)
+
+	if setting is None:
+		raise ValueError(f'crypt_gensalt() returned NULL for prefix {prefix!r} and rounds {rounds}')
+
+	return setting
+
+
+def crypt_yescrypt(plaintext: str) -> str:
+	"""
+	By default chpasswd in Arch uses PAM to hash the password with crypt_yescrypt
+	the PAM code https://github.com/linux-pam/linux-pam/blob/master/modules/pam_unix/support.c
+	shows that the hashing rounds are determined from YESCRYPT_COST_FACTOR in /etc/login.defs
+	If no value was specified (or commented out) a default of 5 is chosen
+	"""
+	value = _search_login_defs('YESCRYPT_COST_FACTOR')
+	if value is not None:
+		rounds = int(value)
+		if rounds < 3:
+			rounds = 3
+		elif rounds > 11:
+			rounds = 11
+	else:
+		rounds = 5
+
+	debug(f'Creating yescrypt hash with rounds {rounds}')
+
+	enc_plaintext = plaintext.encode('utf-8')
+	salt = crypt_gen_salt('$y$', rounds)
+
+	crypt_hash = libcrypt.crypt(enc_plaintext, salt)
+
+	if crypt_hash is None:
+		raise ValueError('crypt() returned NULL')
+
+	return crypt_hash.decode('utf-8')
+
+
+def _get_fernet(salt: bytes, password: str) -> Fernet:
+	# https://cryptography.io/en/latest/hazmat/primitives/key-derivation-functions/#argon2id
+	kdf = Argon2id(
+		salt=salt,
+		length=32,
+		iterations=1,
+		lanes=4,
+		memory_cost=64 * 1024,
+		ad=None,
+		secret=None,
+	)
+
+	key = base64.urlsafe_b64encode(
+		kdf.derive(
+			password.encode('utf-8'),
+		),
+	)
+
+	return Fernet(key)
+
+
+def encrypt(password: str, data: str) -> str:
+	salt = os.urandom(16)
+	f = _get_fernet(salt, password)
+	token = f.encrypt(data.encode('utf-8'))
+
+	encoded_token = base64.urlsafe_b64encode(token).decode('utf-8')
+	encoded_salt = base64.urlsafe_b64encode(salt).decode('utf-8')
+
+	return f'$argon2id${encoded_salt}${encoded_token}'
+
+
+def decrypt(data: str, password: str) -> str:
+	_, algo, encoded_salt, encoded_token = data.split('$')
+	salt = base64.urlsafe_b64decode(encoded_salt)
+	token = base64.urlsafe_b64decode(encoded_token)
+
+	if algo != 'argon2id':
+		raise ValueError(f'Unsupported algorithm {algo!r}')
+
+	f = _get_fernet(salt, password)
+	try:
+		decrypted = f.decrypt(token)
+	except InvalidToken:
+		raise ValueError('Invalid password')
+
+	return decrypted.decode('utf-8')

archinstall/lib/disk/__init__.py

@@ -1,48 +0,0 @@
-from .device_handler import device_handler, disk_layouts
-from .fido import Fido2
-from .filesystem import FilesystemHandler
-from .subvolume_menu import SubvolumeMenu
-from .partitioning_menu import (
-	manual_partitioning,
-	PartitioningList
-)
-from .device_model import (
-	_DeviceInfo,
-	BDevice,
-	DiskLayoutType,
-	DiskLayoutConfiguration,
-	LvmLayoutType,
-	LvmConfiguration,
-	LvmVolumeGroup,
-	LvmVolume,
-	LvmVolumeStatus,
-	PartitionTable,
-	Unit,
-	Size,
-	SectorSize,
-	SubvolumeModification,
-	DeviceGeometry,
-	PartitionType,
-	PartitionFlag,
-	FilesystemType,
-	ModificationStatus,
-	PartitionModification,
-	DeviceModification,
-	EncryptionType,
-	DiskEncryption,
-	Fido2Device,
-	LsblkInfo,
-	CleanType,
-	get_lsblk_info,
-	get_all_lsblk_info,
-	get_lsblk_by_mountpoint,
-)
-from .encryption_menu import (
-	select_encryption_type,
-	select_encrypted_password,
-	select_hsm,
-	select_partitions_to_encrypt,
-	DiskEncryptionMenu,
-)
-
-from .disk_menu import DiskLayoutConfigurationMenu

archinstall/lib/disk/device_handler.py

@@ -1,59 +1,68 @@
-from __future__ import annotations
-
-import json
-import os
 import logging
-import time
-import uuid
+import os
 from pathlib import Path
-from typing import List, Dict, Any, Optional, TYPE_CHECKING, Literal, Iterable
 
-from parted import (
-	Disk, Geometry, FileSystem,
-	PartitionException, DiskException, IOException,
-	getDevice, getAllDevices, newDisk, freshDisk, Partition, Device
+from parted import Device, Disk, DiskException, FileSystem, Geometry, IOException, Partition, PartitionException, freshDisk, getAllDevices, getDevice, newDisk
+
+from archinstall.lib.command import SysCommand
+from archinstall.lib.disk.luks import Luks2, unlock_luks2_dev
+from archinstall.lib.disk.utils import (
+	find_lsblk_info,
+	get_all_lsblk_info,
+	get_lsblk_info,
+	mount,
+	udev_sync,
+	umount,
 )
-
-from .device_model import (
-	DeviceModification, PartitionModification,
-	BDevice, _DeviceInfo, _PartitionInfo,
-	FilesystemType, Unit, PartitionTable,
-	ModificationStatus, get_lsblk_info, find_lsblk_info, LsblkInfo,
-	_BtrfsSubvolumeInfo, get_all_lsblk_info, DiskEncryption, LvmVolumeGroup, LvmVolume, Size, LvmGroupInfo,
-	SectorSize, LvmVolumeInfo, LvmPVInfo, SubvolumeModification, BtrfsMountOption
+from archinstall.lib.exceptions import DiskError, SysCallError, UnknownFilesystemFormat
+from archinstall.lib.log import debug, error, info, log
+from archinstall.lib.models.device import (
+	DEFAULT_ITER_TIME,
+	BDevice,
+	BtrfsMountOption,
+	DeviceModification,
+	DiskEncryption,
+	FilesystemType,
+	LsblkInfo,
+	ModificationStatus,
+	PartitionFlag,
+	PartitionGUID,
+	PartitionModification,
+	PartitionTable,
+	SubvolumeModification,
+	Unit,
+	_BtrfsSubvolumeInfo,
+	_DeviceInfo,
+	_PartitionInfo,
 )
-
-from ..exceptions import DiskError, UnknownFilesystemFormat
-from ..general import SysCommand, SysCallError, JSON, SysCommandWorker
-from ..luks import Luks2
-from ..output import debug, error, info, warn, log
-from ..utils.util import is_subpath
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.lib.models.users import Password
+from archinstall.lib.pathnames import ARCHISO_MOUNTPOINT
 
 
 class DeviceHandler:
 	_TMP_BTRFS_MOUNT = Path('/mnt/arch_btrfs')
 
 	def __init__(self) -> None:
-		self._devices: Dict[Path, BDevice] = {}
+		self._devices: dict[Path, BDevice] = {}
+		self._partition_table = PartitionTable.default()
 		self.load_devices()
 
 	@property
-	def devices(self) -> List[BDevice]:
+	def devices(self) -> list[BDevice]:
 		return list(self._devices.values())
 
+	@property
+	def partition_table(self) -> PartitionTable:
+		return self._partition_table
+
 	def load_devices(self) -> None:
 		block_devices = {}
 
-		self.udev_sync()
+		udev_sync()
 		all_lsblk_info = get_all_lsblk_info()
 		devices = getAllDevices()
 		devices.extend(self.get_loop_devices())
 
-		archiso_mountpoint = Path('/run/archiso/airootfs')
-
 		for device in devices:
 			dev_lsblk_info = find_lsblk_info(device.path, all_lsblk_info)
 
@@ -65,14 +74,14 @@ class DeviceHandler:
 				continue
 
 			# exclude archiso loop device
-			if dev_lsblk_info.mountpoint == archiso_mountpoint:
+			if dev_lsblk_info.mountpoint == ARCHISO_MOUNTPOINT:
 				continue
 
 			try:
 				if dev_lsblk_info.pttype:
 					disk = newDisk(device)
 				else:
-					disk = freshDisk(device, PartitionTable.GPT.value)
+					disk = freshDisk(device, self.partition_table.value)
 			except DiskException as err:
 				debug(f'Unable to get disk from {device.path}: {err}')
 				continue
@@ -90,19 +99,16 @@ class DeviceHandler:
 				fs_type = self._determine_fs_type(partition, lsblk_info)
 				subvol_infos = []
 
-				if fs_type == FilesystemType.Btrfs:
+				if fs_type == FilesystemType.BTRFS:
 					subvol_infos = self.get_btrfs_info(partition.path, lsblk_info)
 
 				partition_infos.append(
 					_PartitionInfo.from_partition(
 						partition,
+						lsblk_info,
 						fs_type,
-						lsblk_info.partn,
-						lsblk_info.partuuid,
-						lsblk_info.uuid,
-						lsblk_info.mountpoints,
-						subvol_infos
-					)
+						subvol_infos,
+					),
 				)
 
 			block_device = BDevice(disk, device_info, partition_infos)
@@ -137,10 +143,12 @@ class DeviceHandler:
 	def _determine_fs_type(
 		self,
 		partition: Partition,
-		lsblk_info: Optional[LsblkInfo] = None
-	) -> Optional[FilesystemType]:
+		lsblk_info: LsblkInfo | None = None,
+	) -> FilesystemType | None:
 		try:
 			if partition.fileSystem:
+				if partition.fileSystem.type == FilesystemType.LINUX_SWAP.parted_value:
+					return FilesystemType.LINUX_SWAP
 				return FilesystemType(partition.fileSystem.type)
 			elif lsblk_info is not None:
 				return FilesystemType(lsblk_info.fstype) if lsblk_info.fstype else None
@@ -150,68 +158,51 @@ class DeviceHandler:
 
 		return None
 
-	def get_device(self, path: Path) -> Optional[BDevice]:
+	def get_device(self, path: Path) -> BDevice | None:
 		return self._devices.get(path, None)
 
-	def get_device_by_partition_path(self, partition_path: Path) -> Optional[BDevice]:
+	def get_device_by_partition_path(self, partition_path: Path) -> BDevice | None:
 		partition = self.find_partition(partition_path)
 		if partition:
 			device: Device = partition.disk.device
 			return self.get_device(Path(device.path))
 		return None
 
-	def find_partition(self, path: Path) -> Optional[_PartitionInfo]:
+	def find_partition(self, path: Path) -> _PartitionInfo | None:
 		for device in self._devices.values():
 			part = next(filter(lambda x: str(x.path) == str(path), device.partition_infos), None)
 			if part is not None:
 				return part
 		return None
 
-	def get_parent_device_path(self, dev_path: Path) -> Path:
-		lsblk = get_lsblk_info(dev_path)
-		return Path(f'/dev/{lsblk.pkname}')
-
-	def get_unique_path_for_device(self, dev_path: Path) -> Optional[Path]:
-		paths = Path('/dev/disk/by-id').glob('*')
-		linked_targets = {p.resolve(): p for p in paths}
-		linked_wwn_targets = {
-			p: linked_targets[p] for p in linked_targets
-			if p.name.startswith('wwn-') or p.name.startswith('nvme-eui.')
-		}
-
-		if dev_path in linked_wwn_targets:
-			return linked_wwn_targets[dev_path]
-
-		if dev_path in linked_targets:
-			return linked_targets[dev_path]
-
-		return None
-
-	def get_uuid_for_path(self, path: Path) -> Optional[str]:
+	def get_uuid_for_path(self, path: Path) -> str | None:
 		partition = self.find_partition(path)
 		return partition.partuuid if partition else None
 
 	def get_btrfs_info(
 		self,
 		dev_path: Path,
-		lsblk_info: Optional[LsblkInfo] = None
-	) -> List[_BtrfsSubvolumeInfo]:
+		lsblk_info: LsblkInfo | None = None,
+	) -> list[_BtrfsSubvolumeInfo]:
 		if not lsblk_info:
 			lsblk_info = get_lsblk_info(dev_path)
 
-		subvol_infos: List[_BtrfsSubvolumeInfo] = []
+		subvol_infos: list[_BtrfsSubvolumeInfo] = []
 
 		if not lsblk_info.mountpoint:
-			self.mount(dev_path, self._TMP_BTRFS_MOUNT, create_target_mountpoint=True)
+			mount(dev_path, self._TMP_BTRFS_MOUNT, create_target_mountpoint=True)
 			mountpoint = self._TMP_BTRFS_MOUNT
 		else:
 			# when multiple subvolumes are mounted then the lsblk output may look like
-			# "mountpoint": "/mnt/archinstall/.snapshots"
-			# "mountpoints": ["/mnt/archinstall/.snapshots", "/mnt/archinstall/home", ..]
+			# "mountpoint": "/mnt/archinstall/var/log"
+			# "mountpoints": ["/mnt/archinstall/var/log", "/mnt/archinstall/home", ..]
 			# so we'll determine the minimum common path and assume that's the root
-			path_strings = [str(m) for m in lsblk_info.mountpoints]
-			common_prefix = os.path.commonprefix(path_strings)
-			mountpoint = Path(common_prefix)
+			try:
+				common_path = os.path.commonpath(lsblk_info.mountpoints)
+			except ValueError:
+				return subvol_infos
+
+			mountpoint = Path(common_path)
 
 		try:
 			result = SysCommand(f'btrfs subvolume list {mountpoint}').decode()
@@ -219,20 +210,23 @@ class DeviceHandler:
 			debug(f'Failed to read btrfs subvolume information: {err}')
 			return subvol_infos
 
-		try:
-			# ID 256 gen 16 top level 5 path @
-			for line in result.splitlines():
-				# expected output format:
-				# ID 257 gen 8 top level 5 path @home
-				name = Path(line.split(' ')[-1])
-				sub_vol_mountpoint = lsblk_info.btrfs_subvol_info.get(name, None)
-				subvol_infos.append(_BtrfsSubvolumeInfo(name, sub_vol_mountpoint))
-		except json.decoder.JSONDecodeError as err:
-			error(f"Could not decode lsblk JSON: {result}")
-			raise err
+		# It is assumed that lsblk will contain the fields as
+		# "mountpoints": ["/mnt/archinstall/log", "/mnt/archinstall/home", "/mnt/archinstall", ...]
+		# "fsroots": ["/@log", "/@home", "/@"...]
+		# we'll thereby map the fsroot, which are the mounted filesystem roots
+		# to the corresponding mountpoints
+		btrfs_subvol_info = dict(zip(lsblk_info.fsroots, lsblk_info.mountpoints))
+
+		# ID 256 gen 16 top level 5 path @
+		for line in result.splitlines():
+			# expected output format:
+			# ID 257 gen 8 top level 5 path @home
+			name = Path(line.split(' ')[-1])
+			sub_vol_mountpoint = btrfs_subvol_info.get('/' / name, None)
+			subvol_infos.append(_BtrfsSubvolumeInfo(name, sub_vol_mountpoint))
 
 		if not lsblk_info.mountpoint:
-			self.umount(dev_path)
+			umount(dev_path)
 
 		return subvol_infos
 
@@ -240,31 +234,35 @@ class DeviceHandler:
 		self,
 		fs_type: FilesystemType,
 		path: Path,
-		additional_parted_options: List[str] = []
+		additional_parted_options: list[str] = [],
 	) -> None:
 		mkfs_type = fs_type.value
+		command = None
 		options = []
 
 		match fs_type:
-			case FilesystemType.Btrfs | FilesystemType.F2fs | FilesystemType.Xfs:
+			case FilesystemType.BTRFS | FilesystemType.XFS:
 				# Force overwrite
 				options.append('-f')
-			case FilesystemType.Ext2 | FilesystemType.Ext3 | FilesystemType.Ext4:
+			case FilesystemType.F2FS:
+				options.append('-f')
+				options.extend(('-O', 'extra_attr'))
+			case FilesystemType.EXT2 | FilesystemType.EXT3 | FilesystemType.EXT4:
 				# Force create
 				options.append('-F')
-			case FilesystemType.Fat16 | FilesystemType.Fat32:
+			case _ if fs_type.is_fat():
 				mkfs_type = 'fat'
 				# Set FAT size
 				options.extend(('-F', fs_type.value.removeprefix(mkfs_type)))
-			case FilesystemType.Ntfs:
-				# Skip zeroing and bad sector check
-				options.append('--fast')
-			case FilesystemType.Reiserfs:
-				pass
+			case FilesystemType.LINUX_SWAP:
+				command = 'mkswap'
 			case _:
 				raise UnknownFilesystemFormat(f'Filetype "{fs_type.value}" is not supported')
 
-		cmd = [f'mkfs.{mkfs_type}', *options, *additional_parted_options, str(path)]
+		if not command:
+			command = f'mkfs.{mkfs_type}'
+
+		cmd = [command, *options, *additional_parted_options, str(path)]
 
 		debug('Formatting filesystem:', ' '.join(cmd))
 
@@ -278,17 +276,20 @@ class DeviceHandler:
 	def encrypt(
 		self,
 		dev_path: Path,
-		mapper_name: Optional[str],
-		enc_password: str,
-		lock_after_create: bool = True
+		mapper_name: str | None,
+		enc_password: Password | None,
+		lock_after_create: bool = True,
+		iter_time: int = DEFAULT_ITER_TIME,
 	) -> Luks2:
 		luks_handler = Luks2(
 			dev_path,
 			mapper_name=mapper_name,
-			password=enc_password
+			password=enc_password,
 		)
 
-		key_file = luks_handler.encrypt()
+		key_file = luks_handler.encrypt(iter_time=iter_time)
+
+		udev_sync()
 
 		luks_handler.unlock(key_file=key_file)
 
@@ -304,17 +305,22 @@ class DeviceHandler:
 	def format_encrypted(
 		self,
 		dev_path: Path,
-		mapper_name: Optional[str],
+		mapper_name: str | None,
 		fs_type: FilesystemType,
-		enc_conf: DiskEncryption
+		enc_conf: DiskEncryption,
 	) -> None:
+		if not enc_conf.encryption_password:
+			raise ValueError('No encryption password provided')
+
 		luks_handler = Luks2(
 			dev_path,
 			mapper_name=mapper_name,
-			password=enc_conf.encryption_password
+			password=enc_conf.encryption_password,
 		)
 
-		key_file = luks_handler.encrypt()
+		key_file = luks_handler.encrypt(iter_time=enc_conf.iter_time)
+
+		udev_sync()
 
 		luks_handler.unlock(key_file=key_file)
 
@@ -327,156 +333,16 @@ class DeviceHandler:
 		info(f'luks2 locking device: {dev_path}')
 		luks_handler.lock()
 
-	def _lvm_info(
-		self,
-		cmd: str,
-		info_type: Literal['lv', 'vg', 'pvseg']
-	) -> Optional[Any]:
-		raw_info = SysCommand(cmd).decode().split('\n')
-
-		# for whatever reason the output sometimes contains
-		# "File descriptor X leaked leaked on vgs invocation
-		data = '\n'.join([raw for raw in raw_info if 'File descriptor' not in raw])
-
-		debug(f'LVM info: {data}')
-
-		reports = json.loads(data)
-
-		for report in reports['report']:
-			if len(report[info_type]) != 1:
-				raise ValueError('Report does not contain any entry')
-
-			entry = report[info_type][0]
-
-			match info_type:
-				case 'pvseg':
-					return LvmPVInfo(
-						pv_name=Path(entry['pv_name']),
-						lv_name=entry['lv_name'],
-						vg_name=entry['vg_name'],
-					)
-				case 'lv':
-					return LvmVolumeInfo(
-						lv_name=entry['lv_name'],
-						vg_name=entry['vg_name'],
-						lv_size=Size(int(entry['lv_size'][:-1]), Unit.B, SectorSize.default())
-					)
-				case 'vg':
-					return LvmGroupInfo(
-						vg_uuid=entry['vg_uuid'],
-						vg_size=Size(int(entry['vg_size'][:-1]), Unit.B, SectorSize.default())
-					)
-
-		return None
-
-	def _lvm_info_with_retry(self, cmd: str, info_type: Literal['lv', 'vg', 'pvseg']) -> Optional[Any]:
-		while True:
-			try:
-				return self._lvm_info(cmd, info_type)
-			except ValueError:
-				time.sleep(3)
-
-	def lvm_vol_info(self, lv_name: str) -> Optional[LvmVolumeInfo]:
-		cmd = (
-			'lvs --reportformat json '
-			'--unit B '
-			f'-S lv_name={lv_name}'
-		)
-
-		return self._lvm_info_with_retry(cmd, 'lv')
-
-	def lvm_group_info(self, vg_name: str) -> Optional[LvmGroupInfo]:
-		cmd = (
-			'vgs --reportformat json '
-			'--unit B '
-			'-o vg_name,vg_uuid,vg_size '
-			f'-S vg_name={vg_name}'
-		)
-
-		return self._lvm_info_with_retry(cmd, 'vg')
-
-	def lvm_pvseg_info(self, vg_name: str, lv_name: str) -> Optional[LvmPVInfo]:
-		cmd = (
-			'pvs '
-			'--segments -o+lv_name,vg_name '
-			f'-S vg_name={vg_name},lv_name={lv_name} '
-			'--reportformat json '
-		)
-
-		return self._lvm_info_with_retry(cmd, 'pvseg')
-
-	def lvm_vol_change(self, vol: LvmVolume, activate: bool) -> None:
-		active_flag = 'y' if activate else 'n'
-		cmd = f'lvchange -a {active_flag} {vol.safe_dev_path}'
-
-		debug(f'lvchange volume: {cmd}')
-		SysCommand(cmd)
-
-	def lvm_export_vg(self, vg: LvmVolumeGroup) -> None:
-		cmd = f'vgexport {vg.name}'
-
-		debug(f'vgexport: {cmd}')
-		SysCommand(cmd)
-
-	def lvm_import_vg(self, vg: LvmVolumeGroup) -> None:
-		cmd = f'vgimport {vg.name}'
-
-		debug(f'vgimport: {cmd}')
-		SysCommand(cmd)
-
-	def lvm_vol_reduce(self, vol_path: Path, amount: Size) -> None:
-		val = amount.format_size(Unit.B, include_unit=False)
-		cmd = f'lvreduce -L -{val}B {vol_path}'
-
-		debug(f'Reducing LVM volume size: {cmd}')
-		SysCommand(cmd)
-
-	def lvm_pv_create(self, pvs: Iterable[Path]) -> None:
-		cmd = 'pvcreate ' + ' '.join([str(pv) for pv in pvs])
-		debug(f'Creating LVM PVS: {cmd}')
-
-		worker = SysCommandWorker(cmd)
-		worker.poll()
-		worker.write(b'y\n', line_ending=False)
-
-	def lvm_vg_create(self, pvs: Iterable[Path], vg_name: str) -> None:
-		pvs_str = ' '.join([str(pv) for pv in pvs])
-		cmd = f'vgcreate --yes {vg_name} {pvs_str}'
-
-		debug(f'Creating LVM group: {cmd}')
-
-		worker = SysCommandWorker(cmd)
-		worker.poll()
-		worker.write(b'y\n', line_ending=False)
-
-	def lvm_vol_create(self, vg_name: str, volume: LvmVolume, offset: Optional[Size] = None) -> None:
-		if offset is not None:
-			length = volume.length - offset
-		else:
-			length = volume.length
-
-		length_str = length.format_size(Unit.B, include_unit=False)
-		cmd = f'lvcreate --yes -L {length_str}B {vg_name} -n {volume.name}'
-
-		debug(f'Creating volume: {cmd}')
-
-		worker = SysCommandWorker(cmd)
-		worker.poll()
-		worker.write(b'y\n', line_ending=False)
-
-		volume.vg_name = vg_name
-		volume.dev_path = Path(f'/dev/{vg_name}/{volume.name}')
-
 	def _setup_partition(
 		self,
 		part_mod: PartitionModification,
 		block_device: BDevice,
 		disk: Disk,
-		requires_delete: bool
+		requires_delete: bool,
 	) -> None:
 		# when we require a delete and the partition to be (re)created
 		# already exists then we have to delete it first
-		if requires_delete and part_mod.status in [ModificationStatus.Modify, ModificationStatus.Delete]:
+		if requires_delete and part_mod.status in [ModificationStatus.MODIFY, ModificationStatus.DELETE]:
 			info(f'Delete existing partition: {part_mod.safe_dev_path}')
 			part_info = self.find_partition(part_mod.safe_dev_path)
 
@@ -485,39 +351,40 @@ class DeviceHandler:
 
 			disk.deletePartition(part_info.partition)
 
-		if part_mod.status == ModificationStatus.Delete:
+		if part_mod.status == ModificationStatus.DELETE:
 			return
 
 		start_sector = part_mod.start.convert(
 			Unit.sectors,
-			block_device.device_info.sector_size
+			block_device.device_info.sector_size,
 		)
 
 		length_sector = part_mod.length.convert(
 			Unit.sectors,
-			block_device.device_info.sector_size
+			block_device.device_info.sector_size,
 		)
 
 		geometry = Geometry(
 			device=block_device.disk.device,
 			start=start_sector.value,
-			length=length_sector.value
+			length=length_sector.value,
 		)
 
-		filesystem = FileSystem(type=part_mod.safe_fs_type.value, geometry=geometry)
+		fs_value = part_mod.safe_fs_type.parted_value
+		filesystem = FileSystem(type=fs_value, geometry=geometry)
 
 		partition = Partition(
 			disk=disk,
 			type=part_mod.type.get_partition_code(),
 			fs=filesystem,
-			geometry=geometry
+			geometry=geometry,
 		)
 
 		for flag in part_mod.flags:
-			partition.setFlag(flag.value)
+			partition.setFlag(flag.flag_id)
 
 		debug(f'\tType: {part_mod.type.value}')
-		debug(f'\tFilesystem: {part_mod.safe_fs_type.value}')
+		debug(f'\tFilesystem: {fs_value}')
 		debug(f'\tGeometry: {start_sector.value} start sector, {length_sector.value} length')
 
 		try:
@@ -525,9 +392,11 @@ class DeviceHandler:
 		except PartitionException as ex:
 			raise DiskError(f'Unable to add partition, most likely due to overlapping sectors: {ex}') from ex
 
-		if disk.type == PartitionTable.GPT.value and part_mod.is_root():
-			linux_root_x86_64 = "4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709"
-			partition.type_uuid = uuid.UUID(linux_root_x86_64).bytes
+		if disk.type == PartitionTable.GPT.value:
+			if part_mod.is_root():
+				partition.type_uuid = PartitionGUID.LINUX_ROOT_X86_64.bytes
+			elif PartitionFlag.LINUX_HOME not in part_mod.flags and part_mod.is_home():
+				partition.setFlag(PartitionFlag.LINUX_HOME.flag_id)
 
 		# the partition has a path now that it has been added
 		part_mod.dev_path = Path(partition.path)
@@ -547,26 +416,26 @@ class DeviceHandler:
 			debug(f'Unable to determine new uuid: {path}\n{lsblk_info}')
 			raise DiskError(f'Unable to determine new uuid: {path}')
 
-		debug(f'partition information found: {lsblk_info.json()}')
+		debug(f'partition information found: {lsblk_info.model_dump_json()}')
 
 		return lsblk_info
 
 	def create_lvm_btrfs_subvolumes(
 		self,
 		path: Path,
-		btrfs_subvols: List[SubvolumeModification],
-		mount_options: List[str]
+		btrfs_subvols: list[SubvolumeModification],
+		mount_options: list[str],
 	) -> None:
 		info(f'Creating subvolumes: {path}')
 
-		self.mount(path, self._TMP_BTRFS_MOUNT, create_target_mountpoint=True)
+		mount(path, self._TMP_BTRFS_MOUNT, create_target_mountpoint=True)
 
-		for sub_vol in btrfs_subvols:
+		for sub_vol in sorted(btrfs_subvols, key=lambda x: x.name):
 			debug(f'Creating subvolume: {sub_vol.name}')
 
 			subvol_path = self._TMP_BTRFS_MOUNT / sub_vol.name
 
-			SysCommand(f"btrfs subvolume create {subvol_path}")
+			SysCommand(f'btrfs subvolume create -p {subvol_path}')
 
 			if BtrfsMountOption.nodatacow.value in mount_options:
 				try:
@@ -580,12 +449,12 @@ class DeviceHandler:
 				except SysCallError as err:
 					raise DiskError(f'Could not set compress attribute at {subvol_path}: {err}')
 
-		self.umount(path)
+		umount(path)
 
 	def create_btrfs_volumes(
 		self,
 		part_mod: PartitionModification,
-		enc_conf: Optional['DiskEncryption'] = None
+		enc_conf: DiskEncryption | None = None,
 	) -> None:
 		info(f'Creating subvolumes: {part_mod.safe_dev_path}')
 
@@ -594,10 +463,10 @@ class DeviceHandler:
 			if not part_mod.mapper_name:
 				raise ValueError('No device path specified for modification')
 
-			luks_handler = self.unlock_luks2_dev(
+			luks_handler = unlock_luks2_dev(
 				part_mod.safe_dev_path,
 				part_mod.mapper_name,
-				enc_conf.encryption_password
+				enc_conf.encryption_password,
 			)
 
 			if not luks_handler.mapper_dev:
@@ -608,36 +477,25 @@ class DeviceHandler:
 			luks_handler = None
 			dev_path = part_mod.safe_dev_path
 
-		self.mount(
+		mount(
 			dev_path,
 			self._TMP_BTRFS_MOUNT,
 			create_target_mountpoint=True,
-			options=part_mod.mount_options
+			options=part_mod.mount_options,
 		)
 
-		for sub_vol in part_mod.btrfs_subvols:
+		for sub_vol in sorted(part_mod.btrfs_subvols, key=lambda x: x.name):
 			debug(f'Creating subvolume: {sub_vol.name}')
 
 			subvol_path = self._TMP_BTRFS_MOUNT / sub_vol.name
 
-			SysCommand(f"btrfs subvolume create {subvol_path}")
+			SysCommand(f'btrfs subvolume create -p {subvol_path}')
 
-		self.umount(dev_path)
+		umount(dev_path)
 
 		if luks_handler is not None and luks_handler.mapper_dev is not None:
 			luks_handler.lock()
 
-	def unlock_luks2_dev(self, dev_path: Path, mapper_name: str, enc_password: str) -> Luks2:
-		luks_handler = Luks2(dev_path, mapper_name=mapper_name, password=enc_password)
-
-		if not luks_handler.is_unlocked():
-			luks_handler.unlock()
-
-		if not luks_handler.is_unlocked():
-			raise DiskError(f'Failed to unlock luks2 device: {dev_path}')
-
-		return luks_handler
-
 	def umount_all_existing(self, device_path: Path) -> None:
 		debug(f'Unmounting all existing partitions: {device_path}')
 
@@ -647,31 +505,28 @@ class DeviceHandler:
 			debug(f'Unmounting: {partition.path}')
 
 			# un-mount for existing encrypted partitions
-			if partition.fs_type == FilesystemType.Crypto_luks:
+			if partition.fs_type == FilesystemType.CRYPTO_LUKS:
 				Luks2(partition.path).lock()
 			else:
-				self.umount(partition.path, recursive=True)
+				umount(partition.path, recursive=True)
 
 	def partition(
 		self,
 		modification: DeviceModification,
-		partition_table: Optional[PartitionTable] = None
+		partition_table: PartitionTable | None = None,
 	) -> None:
 		"""
 		Create a partition table on the block device and create all partitions.
 		"""
-		if modification.wipe:
-			if partition_table is None:
-				raise ValueError('Modification is marked as wipe but no partitioning table was provided')
-
-			if partition_table.MBR and len(modification.partitions) > 3:
-				raise DiskError('Too many partitions on disk, MBR disks can only have 3 primary partitions')
+		partition_table = partition_table or self.partition_table
 
 		# WARNING: the entire device will be wiped and all data lost
 		if modification.wipe:
+			if partition_table.is_mbr() and len(modification.partitions) > 3:
+				raise DiskError('Too many partitions on disk, MBR disks can only have 3 primary partitions')
+
 			self.wipe_dev(modification.device)
-			part_table = partition_table.value if partition_table else None
-			disk = freshDisk(modification.device.disk.device, part_table)
+			disk = freshDisk(modification.device.disk.device, partition_table.value)
 		else:
 			info(f'Use existing device: {modification.device_path}')
 			disk = modification.device.disk
@@ -689,67 +544,24 @@ class DeviceHandler:
 
 		disk.commit()
 
-	def mount(
-		self,
-		dev_path: Path,
-		target_mountpoint: Path,
-		mount_fs: Optional[str] = None,
-		create_target_mountpoint: bool = True,
-		options: List[str] = []
-	) -> None:
-		if create_target_mountpoint and not target_mountpoint.exists():
-			target_mountpoint.mkdir(parents=True, exist_ok=True)
+		# Wipe filesystem/LVM signatures from newly created partitions
+		# to prevent "signature detected" errors
+		for part_mod in filtered_part:
+			if part_mod.dev_path:
+				debug(f'Wiping signatures from: {part_mod.dev_path}')
+				SysCommand(f'wipefs --all {part_mod.dev_path}')
 
-		if not target_mountpoint.exists():
-			raise ValueError('Target mountpoint does not exist')
+		# Sync with udev after wiping signatures
+		if filtered_part:
+			udev_sync()
 
-		lsblk_info = get_lsblk_info(dev_path)
-		if target_mountpoint in lsblk_info.mountpoints:
-			info(f'Device already mounted at {target_mountpoint}')
-			return
-
-		cmd = ['mount']
-
-		if len(options):
-			cmd.extend(('-o', ','.join(options)))
-		if mount_fs:
-			cmd.extend(('-t', mount_fs))
-
-		cmd.extend((str(dev_path), str(target_mountpoint)))
-
-		command = ' '.join(cmd)
-
-		debug(f'Mounting {dev_path}: {command}')
-
-		try:
-			SysCommand(command)
-		except SysCallError as err:
-			raise DiskError(f'Could not mount {dev_path}: {command}\n{err.message}')
-
-	def umount(self, mountpoint: Path, recursive: bool = False) -> None:
-		lsblk_info = get_lsblk_info(mountpoint)
-
-		if not lsblk_info.mountpoints:
-			return
-
-		debug(f'Partition {mountpoint} is currently mounted at: {[str(m) for m in lsblk_info.mountpoints]}')
-
-		cmd = ['umount']
-
-		if recursive:
-			cmd.append('-R')
-
-		for path in lsblk_info.mountpoints:
-			debug(f'Unmounting mountpoint: {path}')
-			SysCommand(cmd + [str(path)])
-
-	def detect_pre_mounted_mods(self, base_mountpoint: Path) -> List[DeviceModification]:
-		part_mods: Dict[Path, List[PartitionModification]] = {}
+	def detect_pre_mounted_mods(self, base_mountpoint: Path) -> list[DeviceModification]:
+		part_mods: dict[Path, list[PartitionModification]] = {}
 
 		for device in self.devices:
 			for part_info in device.partition_infos:
 				for mountpoint in part_info.mountpoints:
-					if is_subpath(mountpoint, base_mountpoint):
+					if mountpoint.is_relative_to(base_mountpoint):
 						path = Path(part_info.disk.device.path)
 						part_mods.setdefault(path, [])
 						part_mod = PartitionModification.from_existing_partition(part_info)
@@ -762,14 +574,14 @@ class DeviceHandler:
 						part_mods[path].append(part_mod)
 						break
 
-		device_mods: List[DeviceModification] = []
+		device_mods: list[DeviceModification] = []
 		for device_path, mods in part_mods.items():
 			device_mod = DeviceModification(self._devices[device_path], False, mods)
 			device_mods.append(device_mod)
 
 		return device_mods
 
-	def partprobe(self, path: Optional[Path] = None) -> None:
+	def partprobe(self, path: Path | None = None) -> None:
 		if path is not None:
 			command = f'partprobe {path}'
 		else:
@@ -780,15 +592,15 @@ class DeviceHandler:
 			SysCommand(command)
 		except SysCallError as err:
 			if 'have been written, but we have been unable to inform the kernel of the change' in str(err):
-				log(f"Partprobe was not able to inform the kernel of the new disk state (ignoring error): {err}", fg="gray", level=logging.INFO)
+				log(f'Partprobe was not able to inform the kernel of the new disk state (ignoring error): {err}', fg='gray', level=logging.INFO)
 			else:
 				error(f'"{command}" failed to run (continuing anyway): {err}')
 
 	def _wipe(self, dev_path: Path) -> None:
 		"""
 		Wipe a device (partition or otherwise) of meta-data, be it file system, LVM, etc.
-		@param dev_path:    Device path of the partition to be wiped.
-		@type dev_path:     str
+		@param dev_path:	Device path of the partition to be wiped.
+		@type dev_path:		str
 		"""
 		with open(dev_path, 'wb') as p:
 			p.write(bytearray(1024))
@@ -800,6 +612,7 @@ class DeviceHandler:
 		auto-discovery tools don't recognize anything here.
 		"""
 		info(f'Wiping partitions and metadata: {block_device.device_info.path}')
+
 		for partition in block_device.partition_infos:
 			luks = Luks2(partition.path)
 			if luks.isLuks():
@@ -809,24 +622,5 @@ class DeviceHandler:
 
 		self._wipe(block_device.device_info.path)
 
-	@staticmethod
-	def udev_sync() -> None:
-		try:
-			SysCommand('udevadm settle')
-		except SysCallError as err:
-			debug(f'Failed to synchronize with udev: {err}')
-
 
 device_handler = DeviceHandler()
-
-
-def disk_layouts() -> str:
-	try:
-		lsblk_info = get_all_lsblk_info()
-		return json.dumps(lsblk_info, indent=4, sort_keys=True, cls=JSON)
-	except SysCallError as err:
-		warn(f"Could not return disk layouts: {err}")
-		return ''
-	except json.decoder.JSONDecodeError as err:
-		warn(f"Could not return disk layouts: {err}")
-		return ''

archinstall/lib/disk/disk_menu.py

@@ -1,66 +1,130 @@
-from typing import Any, TYPE_CHECKING
+from dataclasses import dataclass
+from pathlib import Path
+from typing import override
 
-from . import DiskLayoutConfiguration, DiskLayoutType
-from .device_model import LvmConfiguration
-from ..disk import (
-	DeviceModification
+from archinstall.lib.disk.device_handler import device_handler
+from archinstall.lib.disk.encryption_menu import DiskEncryptionMenu
+from archinstall.lib.disk.partitioning_menu import manual_partitioning
+from archinstall.lib.log import debug
+from archinstall.lib.menu.abstract_menu import AbstractSubMenu
+from archinstall.lib.menu.helpers import Confirmation, Notify, Selection, Table
+from archinstall.lib.menu.util import prompt_dir
+from archinstall.lib.models.device import (
+	DEFAULT_ITER_TIME,
+	BDevice,
+	BtrfsMountOption,
+	BtrfsOptions,
+	DeviceModification,
+	DiskEncryption,
+	DiskLayoutConfiguration,
+	DiskLayoutType,
+	EncryptionType,
+	FilesystemType,
+	LvmConfiguration,
+	LvmLayoutType,
+	LvmVolume,
+	LvmVolumeGroup,
+	ModificationStatus,
+	PartitionFlag,
+	PartitionModification,
+	PartitionType,
+	SectorSize,
+	Size,
+	SnapshotConfig,
+	SnapshotType,
+	SubvolumeModification,
+	Unit,
+	_DeviceInfo,
 )
-from ..interactions import select_disk_config
-from ..interactions.disk_conf import select_lvm_config
-from ..output import FormattedOutput
-from ..menu import AbstractSubMenu
-
-from archinstall.tui import (
-	MenuItemGroup, MenuItem
-)
-
-if TYPE_CHECKING:
-	_: Any
+from archinstall.lib.translationhandler import tr
+from archinstall.lib.utils.format import as_table
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
 
 
-class DiskLayoutConfigurationMenu(AbstractSubMenu):
-	def __init__(
-		self,
-		disk_layout_config: DiskLayoutConfiguration | None,
-		advanced: bool = False
-	):
-		self._disk_layout_config = disk_layout_config
-		self._advanced = advanced
-		self._data_store: dict[str, Any] = {}
+@dataclass
+class DiskMenuConfig:
+	disk_config: DiskLayoutConfiguration | None
+	lvm_config: LvmConfiguration | None
+	btrfs_snapshot_config: SnapshotConfig | None
+	disk_encryption: DiskEncryption | None
 
-		menu_optioons = self._define_menu_options()
-		self._item_group = MenuItemGroup(menu_optioons, sort_items=False, checkmarks=True)
 
-		super().__init__(self._item_group, data_store=self._data_store, allow_reset=True)
+class DiskLayoutConfigurationMenu(AbstractSubMenu[DiskMenuConfig]):
+	def __init__(self, disk_layout_config: DiskLayoutConfiguration | None):
+		if not disk_layout_config:
+			self._disk_menu_config = DiskMenuConfig(
+				disk_config=None,
+				lvm_config=None,
+				btrfs_snapshot_config=None,
+				disk_encryption=None,
+			)
+		else:
+			snapshot_config = disk_layout_config.btrfs_options.snapshot_config if disk_layout_config.btrfs_options else None
+
+			self._disk_menu_config = DiskMenuConfig(
+				disk_config=disk_layout_config,
+				lvm_config=disk_layout_config.lvm_config,
+				disk_encryption=disk_layout_config.disk_encryption,
+				btrfs_snapshot_config=snapshot_config,
+			)
+
+		menu_options = self._define_menu_options()
+		self._item_group = MenuItemGroup(menu_options, sort_items=False, checkmarks=True)
+
+		super().__init__(
+			self._item_group,
+			self._disk_menu_config,
+			allow_reset=True,
+		)
 
 	def _define_menu_options(self) -> list[MenuItem]:
 		return [
 			MenuItem(
-				text=str(_('Partitioning')),
-				action=lambda x: self._select_disk_layout_config(x),
-				value=self._disk_layout_config,
+				text=tr('Partitioning'),
+				action=self._select_disk_layout_config,
+				value=self._disk_menu_config.disk_config,
 				preview_action=self._prev_disk_layouts,
-				key='disk_config'
+				key='disk_config',
 			),
 			MenuItem(
-				text='LVM (BETA)',
-				action=lambda x: self._select_lvm_config(x),
-				value=self._disk_layout_config.lvm_config if self._disk_layout_config else None,
+				text='LVM',
+				action=self._select_lvm_config,
+				value=self._disk_menu_config.lvm_config,
 				preview_action=self._prev_lvm_config,
 				dependencies=[self._check_dep_lvm],
-				key='lvm_config'
+				key='lvm_config',
+			),
+			MenuItem(
+				text=tr('Disk encryption'),
+				action=self._select_disk_encryption,
+				preview_action=self._prev_disk_encryption,
+				dependencies=['disk_config'],
+				key='disk_encryption',
+			),
+			MenuItem(
+				text='Btrfs snapshots',
+				action=self._select_btrfs_snapshots,
+				value=self._disk_menu_config.btrfs_snapshot_config,
+				preview_action=self._prev_btrfs_snapshots,
+				dependencies=[self._check_dep_btrfs],
+				key='btrfs_snapshot_config',
 			),
 		]
 
-	def run(self) -> DiskLayoutConfiguration | None:
-		super().run()
+	@override
+	async def show(self) -> DiskLayoutConfiguration | None:  # type: ignore[override]
+		config: DiskMenuConfig | None = await super().show()
+		if config is None:
+			return None
 
-		disk_layout_config: DiskLayoutConfiguration | None = self._data_store.get('disk_config', None)
+		if config.disk_config:
+			config.disk_config.lvm_config = self._disk_menu_config.lvm_config
+			config.disk_config.btrfs_options = BtrfsOptions(snapshot_config=self._disk_menu_config.btrfs_snapshot_config)
+			config.disk_config.disk_encryption = self._disk_menu_config.disk_encryption
+			return config.disk_config
 
-		if disk_layout_config:
-			disk_layout_config.lvm_config = self._data_store.get('lvm_config', None)
-
-		return disk_layout_config
+		return None
 
 	def _check_dep_lvm(self) -> bool:
 		disk_layout_conf: DiskLayoutConfiguration | None = self._menu_item_group.find_by_key('disk_config').value
@@ -70,56 +134,104 @@ class DiskLayoutConfigurationMenu(AbstractSubMenu):
 
 		return False
 
-	def _select_disk_layout_config(
-		self,
-		preset: DiskLayoutConfiguration | None
-	) -> DiskLayoutConfiguration | None:
-		disk_config = select_disk_config(preset, advanced_option=self._advanced)
+	def _check_dep_btrfs(self) -> bool:
+		disk_layout_conf: DiskLayoutConfiguration | None = self._menu_item_group.find_by_key('disk_config').value
+
+		if disk_layout_conf:
+			return disk_layout_conf.has_default_btrfs_vols()
+
+		return False
+
+	async def _select_disk_encryption(self, preset: DiskEncryption | None) -> DiskEncryption | None:
+		disk_config: DiskLayoutConfiguration | None = self._item_group.find_by_key('disk_config').value
+		lvm_config: LvmConfiguration | None = self._item_group.find_by_key('lvm_config').value
+
+		if not disk_config:
+			return preset
+
+		modifications = disk_config.device_modifications
+
+		if not DiskEncryption.validate_enc(modifications, lvm_config):
+			return None
+
+		disk_encryption = await DiskEncryptionMenu(modifications, lvm_config=lvm_config, preset=preset).show()
+
+		return disk_encryption
+
+	async def _select_disk_layout_config(self, preset: DiskLayoutConfiguration | None) -> DiskLayoutConfiguration | None:
+		disk_config = await select_disk_config(preset)
 
 		if disk_config != preset:
 			self._menu_item_group.find_by_key('lvm_config').value = None
+			self._menu_item_group.find_by_key('disk_encryption').value = None
 
 		return disk_config
 
-	def _select_lvm_config(self, preset: LvmConfiguration | None) -> LvmConfiguration | None:
+	async def _select_lvm_config(self, preset: LvmConfiguration | None) -> LvmConfiguration | None:
 		disk_config: DiskLayoutConfiguration | None = self._item_group.find_by_key('disk_config').value
 
-		if disk_config:
-			return select_lvm_config(disk_config, preset=preset)
+		if not disk_config:
+			return preset
 
-		return preset
+		lvm_config = await select_lvm_config(disk_config, preset=preset)
+
+		if lvm_config != preset:
+			self._menu_item_group.find_by_key('disk_encryption').value = None
+
+		return lvm_config
+
+	async def _select_btrfs_snapshots(self, preset: SnapshotConfig | None) -> SnapshotConfig | None:
+		preset_type = preset.snapshot_type if preset else None
+
+		group = MenuItemGroup.from_enum(
+			SnapshotType,
+			sort_items=True,
+			preset=preset_type,
+		)
+
+		result = await Selection[SnapshotType](
+			group,
+			allow_reset=True,
+			allow_skip=True,
+		).show()
+
+		match result.type_:
+			case ResultType.Skip:
+				return preset
+			case ResultType.Reset:
+				return None
+			case ResultType.Selection:
+				return SnapshotConfig(snapshot_type=result.get_value())
 
 	def _prev_disk_layouts(self, item: MenuItem) -> str | None:
 		if not item.value:
 			return None
 
-		disk_layout_conf: DiskLayoutConfiguration = item.get_value()
+		disk_layout_conf = item.get_value()
 
 		if disk_layout_conf.config_type == DiskLayoutType.Pre_mount:
-			msg = str(_('Configuration type: {}')).format(disk_layout_conf.config_type.display_msg()) + '\n'
-			msg += str(_('Mountpoint')) + ': ' + str(disk_layout_conf.mountpoint)
+			msg = tr('Configuration type: {}').format(disk_layout_conf.config_type.display_msg()) + '\n'
+			msg += tr('Mountpoint') + ': ' + str(disk_layout_conf.mountpoint)
 			return msg
 
-		device_mods: list[DeviceModification] = \
-			list(filter(lambda x: len(x.partitions) > 0, disk_layout_conf.device_modifications))
+		device_mods = [d for d in disk_layout_conf.device_modifications if d.partitions]
 
 		if device_mods:
-			output_partition = '{}: {}\n'.format(str(_('Configuration')), disk_layout_conf.config_type.display_msg())
+			output_partition = '{}: {}\n'.format(tr('Configuration'), disk_layout_conf.config_type.display_msg())
 			output_btrfs = ''
 
 			for mod in device_mods:
 				# create partition table
-				partition_table = FormattedOutput.as_table(mod.partitions)
+				partition_table = as_table(mod.partitions)
 
 				output_partition += f'{mod.device_path}: {mod.device.device_info.model}\n'
+				output_partition += '{}: {}\n'.format(tr('Wipe'), mod.wipe)
 				output_partition += partition_table + '\n'
 
 				# create btrfs table
-				btrfs_partitions = list(
-					filter(lambda p: len(p.btrfs_subvols) > 0, mod.partitions)
-				)
+				btrfs_partitions = [p for p in mod.partitions if p.btrfs_subvols]
 				for partition in btrfs_partitions:
-					output_btrfs += FormattedOutput.as_table(partition.btrfs_subvols) + '\n'
+					output_btrfs += as_table(partition.btrfs_subvols) + '\n'
 
 			output = output_partition + output_btrfs
 			return output.rstrip()
@@ -132,17 +244,633 @@ class DiskLayoutConfigurationMenu(AbstractSubMenu):
 
 		lvm_config: LvmConfiguration = item.value
 
-		output = '{}: {}\n'.format(str(_('Configuration')), lvm_config.config_type.display_msg())
+		output = '{}: {}\n'.format(tr('Configuration'), lvm_config.config_type.display_msg())
 
 		for vol_gp in lvm_config.vol_groups:
-			pv_table = FormattedOutput.as_table(vol_gp.pvs)
-			output += '{}:\n{}'.format(str(_('Physical volumes')), pv_table)
+			pv_table = as_table(vol_gp.pvs)
+			output += '{}:\n{}'.format(tr('Physical volumes'), pv_table)
 
 			output += f'\nVolume Group: {vol_gp.name}'
 
-			lvm_volumes = FormattedOutput.as_table(vol_gp.volumes)
-			output += '\n\n{}:\n{}'.format(str(_('Volumes')), lvm_volumes)
+			lvm_volumes = as_table(vol_gp.volumes)
+			output += '\n\n{}:\n{}'.format(tr('Volumes'), lvm_volumes)
 
 			return output
 
 		return None
+
+	def _prev_btrfs_snapshots(self, item: MenuItem) -> str | None:
+		if not item.value:
+			return None
+
+		snapshot_config: SnapshotConfig = item.value
+		return tr('Snapshot type: {}').format(snapshot_config.snapshot_type.value)
+
+	def _prev_disk_encryption(self, item: MenuItem) -> str | None:
+		disk_config: DiskLayoutConfiguration | None = self._item_group.find_by_key('disk_config').value
+		lvm_config: LvmConfiguration | None = self._item_group.find_by_key('lvm_config').value
+		enc_config: DiskEncryption | None = item.value
+
+		if disk_config and not DiskEncryption.validate_enc(disk_config.device_modifications, lvm_config):
+			return tr('LVM disk encryption with more than 2 partitions is currently not supported')
+
+		if enc_config:
+			enc_type = enc_config.encryption_type
+			output = tr('Encryption type') + f': {enc_type.type_to_text()}\n'
+
+			if enc_config.encryption_password:
+				output += tr('Password') + f': {enc_config.encryption_password.hidden()}\n'
+
+			if enc_type != EncryptionType.NO_ENCRYPTION:
+				output += tr('Iteration time') + f': {enc_config.iter_time or DEFAULT_ITER_TIME}ms\n'
+
+			if enc_config.partitions:
+				output += f'Partitions: {len(enc_config.partitions)} selected\n'
+			elif enc_config.lvm_volumes:
+				output += f'LVM volumes: {len(enc_config.lvm_volumes)} selected\n'
+
+			if enc_config.hsm_device:
+				output += f'HSM: {enc_config.hsm_device.manufacturer}'
+
+			return output
+
+		return None
+
+
+async def select_devices(preset: list[BDevice] | None = []) -> list[BDevice] | None:
+	def _preview_device_selection(item: MenuItem) -> str | None:
+		device: _DeviceInfo = item.value  # type: ignore[assignment]
+		dev = device_handler.get_device(device.path)
+
+		if dev and dev.partition_infos:
+			return as_table(dev.partition_infos)
+		return None
+
+	if preset is None:
+		preset = []
+
+	devices = device_handler.devices
+
+	items = [
+		MenuItem(
+			str(d.device_info.path),
+			d.device_info,
+			preview_action=_preview_device_selection,
+		)
+		for d in devices
+	]
+
+	presets = [p.device_info for p in preset]
+
+	group = MenuItemGroup(items)
+	group.set_selected_by_value(presets)
+
+	result = await Table[_DeviceInfo](
+		header=tr('Select disks for the installation'),
+		group=group,
+		presets=presets,
+		allow_skip=True,
+		multi=True,
+		preview_location='bottom',
+		preview_header=tr('Partitions'),
+	).show()
+
+	match result.type_:
+		case ResultType.Reset:
+			return None
+		case ResultType.Skip:
+			return None
+		case ResultType.Selection:
+			selected_device_info = result.get_values()
+			selected_devices = []
+
+			for device in devices:
+				if device.device_info in selected_device_info:
+					selected_devices.append(device)
+
+			return selected_devices
+
+
+async def get_default_partition_layout(
+	devices: list[BDevice],
+	filesystem_type: FilesystemType | None = None,
+) -> list[DeviceModification]:
+	if len(devices) == 1:
+		device_modification = await suggest_single_disk_layout(
+			devices[0],
+			filesystem_type=filesystem_type,
+		)
+		return [device_modification]
+	else:
+		return await suggest_multi_disk_layout(
+			devices,
+			filesystem_type=filesystem_type,
+		)
+
+
+async def _manual_partitioning(
+	preset: list[DeviceModification],
+	devices: list[BDevice],
+) -> list[DeviceModification] | None:
+	modifications: list[DeviceModification] = []
+
+	for device in devices:
+		mod = next(filter(lambda x: x.device == device, preset), None)
+		if not mod:
+			mod = DeviceModification(device, wipe=False)
+
+		device_mod = await manual_partitioning(mod, device_handler.partition_table)
+
+		if not device_mod:
+			return None
+
+		modifications.append(device_mod)
+
+	return modifications
+
+
+async def select_disk_config(preset: DiskLayoutConfiguration | None = None) -> DiskLayoutConfiguration | None:
+	default_layout = DiskLayoutType.Default.display_msg()
+	manual_mode = DiskLayoutType.Manual.display_msg()
+	pre_mount_mode = DiskLayoutType.Pre_mount.display_msg()
+
+	items = [
+		MenuItem(default_layout, value=default_layout),
+		MenuItem(manual_mode, value=manual_mode),
+		MenuItem(pre_mount_mode, value=pre_mount_mode),
+	]
+	group = MenuItemGroup(items, sort_items=False)
+
+	if preset:
+		group.set_selected_by_value(preset.config_type.display_msg())
+
+	result = await Selection[str](
+		group,
+		header=tr('Select a disk configuration'),
+		allow_skip=True,
+		allow_reset=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Reset:
+			return None
+		case ResultType.Selection:
+			selection = result.get_value()
+
+			if selection == pre_mount_mode:
+				output = tr('Enter root mount directory') + '\n\n'
+				output += tr('You will use whatever drive-setup is mounted at the specified directory') + '\n'
+				output += tr("WARNING: Archinstall won't check the suitability of this setup")
+
+				path = await prompt_dir(output, allow_skip=True)
+
+				if path is None:
+					return None
+
+				mods = device_handler.detect_pre_mounted_mods(path)
+
+				return DiskLayoutConfiguration(
+					config_type=DiskLayoutType.Pre_mount,
+					device_modifications=mods,
+					mountpoint=path,
+				)
+
+			preset_devices = [mod.device for mod in preset.device_modifications] if preset else []
+			devices = await select_devices(preset_devices)
+
+			if devices is None:
+				return preset
+
+			if result.get_value() == default_layout:
+				modifications = await get_default_partition_layout(devices)
+				if modifications:
+					return DiskLayoutConfiguration(
+						config_type=DiskLayoutType.Default,
+						device_modifications=modifications,
+					)
+			elif result.get_value() == manual_mode:
+				preset_mods = preset.device_modifications if preset else []
+				partitions = await _manual_partitioning(preset_mods, devices)
+
+				if not partitions:
+					return preset
+
+				return DiskLayoutConfiguration(
+					config_type=DiskLayoutType.Manual,
+					device_modifications=partitions,
+				)
+
+	return None
+
+
+async def select_lvm_config(
+	disk_config: DiskLayoutConfiguration,
+	preset: LvmConfiguration | None = None,
+) -> LvmConfiguration | None:
+	preset_value = preset.config_type.display_msg() if preset else None
+	default_mode = LvmLayoutType.Default.display_msg()
+
+	items = [MenuItem(default_mode, value=default_mode)]
+	group = MenuItemGroup(items)
+	group.set_focus_by_value(preset_value)
+
+	result = await Selection[str](
+		group,
+		allow_reset=True,
+		allow_skip=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Reset:
+			return None
+		case ResultType.Selection:
+			if result.get_value() == default_mode:
+				return await suggest_lvm_layout(disk_config)
+
+	return None
+
+
+def _boot_partition(sector_size: SectorSize, using_gpt: bool) -> PartitionModification:
+	flags = [PartitionFlag.BOOT]
+	size = Size(1, Unit.GiB, sector_size)
+	start = Size(1, Unit.MiB, sector_size)
+	if using_gpt:
+		flags.append(PartitionFlag.ESP)
+
+	# boot partition
+	return PartitionModification(
+		status=ModificationStatus.CREATE,
+		type=PartitionType.PRIMARY,
+		start=start,
+		length=size,
+		mountpoint=Path('/boot'),
+		fs_type=FilesystemType.FAT32,
+		flags=flags,
+	)
+
+
+async def select_main_filesystem_format() -> FilesystemType:
+	items = [
+		MenuItem(FilesystemType.BTRFS.value, value=FilesystemType.BTRFS),
+		MenuItem(FilesystemType.EXT4.value, value=FilesystemType.EXT4),
+		MenuItem(FilesystemType.XFS.value, value=FilesystemType.XFS),
+		MenuItem(FilesystemType.F2FS.value, value=FilesystemType.F2FS),
+	]
+
+	group = MenuItemGroup(items, sort_items=False)
+	result = await Selection[FilesystemType](
+		group,
+		header=tr('Select main filesystem'),
+		allow_skip=False,
+	).show()
+
+	match result.type_:
+		case ResultType.Selection:
+			return result.get_value()
+		case _:
+			raise ValueError('Unhandled result type')
+
+
+async def select_mount_options() -> list[str]:
+	prompt = tr('Would you like to use compression or disable CoW?') + '\n'
+	compression = tr('Use compression')
+	disable_cow = tr('Disable Copy-on-Write')
+
+	items = [
+		MenuItem(compression, value=BtrfsMountOption.compress.value),
+		MenuItem(disable_cow, value=BtrfsMountOption.nodatacow.value),
+	]
+	group = MenuItemGroup(items, sort_items=False)
+
+	result = await Selection[str](
+		group,
+		header=prompt,
+		allow_skip=True,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return []
+		case ResultType.Selection:
+			return [result.get_value()]
+		case _:
+			raise ValueError('Unhandled result type')
+
+
+def process_root_partition_size(total_size: Size, sector_size: SectorSize) -> Size:
+	# root partition size processing
+	total_device_size = total_size.convert(Unit.GiB)
+	if total_device_size.value > 500:
+		# maximum size
+		return Size(value=50, unit=Unit.GiB, sector_size=sector_size)
+	elif total_device_size.value < 320:
+		# minimum size
+		return Size(value=32, unit=Unit.GiB, sector_size=sector_size)
+	else:
+		# 10% of total size
+		length = total_device_size.value // 10
+		return Size(value=length, unit=Unit.GiB, sector_size=sector_size)
+
+
+def get_default_btrfs_subvols() -> list[SubvolumeModification]:
+	# https://btrfs.wiki.kernel.org/index.php/FAQ
+	# https://unix.stackexchange.com/questions/246976/btrfs-subvolume-uuid-clash
+	# https://github.com/classy-giraffe/easy-arch/blob/main/easy-arch.sh
+	return [
+		SubvolumeModification(Path('@'), Path('/')),
+		SubvolumeModification(Path('@home'), Path('/home')),
+		SubvolumeModification(Path('@log'), Path('/var/log')),
+		SubvolumeModification(Path('@pkg'), Path('/var/cache/pacman/pkg')),
+	]
+
+
+async def suggest_single_disk_layout(
+	device: BDevice,
+	filesystem_type: FilesystemType | None = None,
+	separate_home: bool | None = None,
+) -> DeviceModification:
+	if not filesystem_type:
+		filesystem_type = await select_main_filesystem_format()
+
+	sector_size = device.device_info.sector_size
+	total_size = device.device_info.total_size
+	available_space = total_size
+	min_size_to_allow_home_part = Size(64, Unit.GiB, sector_size)
+
+	if filesystem_type == FilesystemType.BTRFS:
+		prompt = tr('Would you like to use BTRFS subvolumes with a default structure?') + '\n'
+
+		result = await Confirmation(
+			header=prompt,
+			allow_skip=False,
+			preset=True,
+		).show()
+
+		using_subvolumes = result.item() == MenuItem.yes()
+		mount_options = await select_mount_options()
+	else:
+		using_subvolumes = False
+		mount_options = []
+
+	device_modification = DeviceModification(device, wipe=True)
+
+	using_gpt = device_handler.partition_table.is_gpt()
+
+	if using_gpt:
+		available_space = available_space.gpt_end()
+
+	available_space = available_space.align()
+
+	# Used for reference: https://wiki.archlinux.org/title/partitioning
+
+	boot_partition = _boot_partition(sector_size, using_gpt)
+	device_modification.add_partition(boot_partition)
+
+	if separate_home is False or using_subvolumes or total_size < min_size_to_allow_home_part:
+		using_home_partition = False
+	elif separate_home:
+		using_home_partition = True
+	else:
+		prompt = tr('Would you like to create a separate partition for /home?') + '\n'
+
+		result = await Confirmation(
+			header=prompt,
+			allow_skip=False,
+			preset=True,
+		).show()
+
+		using_home_partition = result.item() == MenuItem.yes()
+
+	# root partition
+	root_start = boot_partition.start + boot_partition.length
+
+	# Set a size for / (/root)
+	if using_home_partition:
+		root_length = process_root_partition_size(total_size, sector_size)
+	else:
+		root_length = available_space - root_start
+
+	root_partition = PartitionModification(
+		status=ModificationStatus.CREATE,
+		type=PartitionType.PRIMARY,
+		start=root_start,
+		length=root_length,
+		mountpoint=Path('/') if not using_subvolumes else None,
+		fs_type=filesystem_type,
+		mount_options=mount_options,
+	)
+
+	device_modification.add_partition(root_partition)
+
+	if using_subvolumes:
+		root_partition.btrfs_subvols = get_default_btrfs_subvols()
+	elif using_home_partition:
+		# If we don't want to use subvolumes,
+		# But we want to be able to reuse data between re-installs..
+		# A second partition for /home would be nice if we have the space for it
+		home_start = root_partition.start + root_partition.length
+		home_length = available_space - home_start
+
+		flags = []
+		if using_gpt:
+			flags.append(PartitionFlag.LINUX_HOME)
+
+		home_partition = PartitionModification(
+			status=ModificationStatus.CREATE,
+			type=PartitionType.PRIMARY,
+			start=home_start,
+			length=home_length,
+			mountpoint=Path('/home'),
+			fs_type=filesystem_type,
+			mount_options=mount_options,
+			flags=flags,
+		)
+		device_modification.add_partition(home_partition)
+
+	return device_modification
+
+
+async def suggest_multi_disk_layout(
+	devices: list[BDevice],
+	filesystem_type: FilesystemType | None = None,
+) -> list[DeviceModification]:
+	if not devices:
+		return []
+
+	# Not really a rock solid foundation of information to stand on, but it's a start:
+	# https://www.reddit.com/r/btrfs/comments/m287gp/partition_strategy_for_two_physical_disks/
+	# https://www.reddit.com/r/btrfs/comments/9us4hr/what_is_your_btrfs_partitionsubvolumes_scheme/
+	min_home_partition_size = Size(40, Unit.GiB, SectorSize.default())
+	# rough estimate taking in to account user desktops etc. TODO: Catch user packages to detect size?
+	desired_root_partition_size = Size(32, Unit.GiB, SectorSize.default())
+	mount_options = []
+
+	if not filesystem_type:
+		filesystem_type = await select_main_filesystem_format()
+
+	# find proper disk for /home
+	possible_devices = [d for d in devices if d.device_info.total_size >= min_home_partition_size]
+	home_device = max(possible_devices, key=lambda d: d.device_info.total_size) if possible_devices else None
+
+	# find proper device for /root
+	devices_delta = {}
+	for device in devices:
+		if device is not home_device:
+			delta = device.device_info.total_size - desired_root_partition_size
+			devices_delta[device] = delta
+
+	sorted_delta: list[tuple[BDevice, Size]] = sorted(devices_delta.items(), key=lambda x: x[1])
+	root_device: BDevice | None = sorted_delta[0][0]
+
+	if home_device is None or root_device is None:
+		text = tr('The selected drives do not have the minimum capacity required for an automatic suggestion\n')
+		text += tr('Minimum capacity for /home partition: {}GiB\n').format(min_home_partition_size.format_size(Unit.GiB))
+		text += tr('Minimum capacity for Arch Linux partition: {}GiB').format(desired_root_partition_size.format_size(Unit.GiB))
+
+		_ = await Notify(text).show()
+		return []
+
+	if filesystem_type == FilesystemType.BTRFS:
+		mount_options = await select_mount_options()
+
+	device_paths = ', '.join(str(d.device_info.path) for d in devices)
+
+	debug(f'Suggesting multi-disk-layout for devices: {device_paths}')
+	debug(f'/root: {root_device.device_info.path}')
+	debug(f'/home: {home_device.device_info.path}')
+
+	root_device_modification = DeviceModification(root_device, wipe=True)
+	home_device_modification = DeviceModification(home_device, wipe=True)
+
+	root_device_sector_size = root_device_modification.device.device_info.sector_size
+	home_device_sector_size = home_device_modification.device.device_info.sector_size
+
+	using_gpt = device_handler.partition_table.is_gpt()
+
+	# add boot partition to the root device
+	boot_partition = _boot_partition(root_device_sector_size, using_gpt)
+	root_device_modification.add_partition(boot_partition)
+
+	root_start = boot_partition.start + boot_partition.length
+	root_length = root_device.device_info.total_size - root_start
+
+	if using_gpt:
+		root_length = root_length.gpt_end()
+
+	root_length = root_length.align()
+
+	# add root partition to the root device
+	root_partition = PartitionModification(
+		status=ModificationStatus.CREATE,
+		type=PartitionType.PRIMARY,
+		start=root_start,
+		length=root_length,
+		mountpoint=Path('/'),
+		mount_options=mount_options,
+		fs_type=filesystem_type,
+	)
+	root_device_modification.add_partition(root_partition)
+
+	home_start = Size(1, Unit.MiB, home_device_sector_size)
+	home_length = home_device.device_info.total_size - home_start
+
+	flags = []
+	if using_gpt:
+		home_length = home_length.gpt_end()
+		flags.append(PartitionFlag.LINUX_HOME)
+
+	home_length = home_length.align()
+
+	# add home partition to home device
+	home_partition = PartitionModification(
+		status=ModificationStatus.CREATE,
+		type=PartitionType.PRIMARY,
+		start=home_start,
+		length=home_length,
+		mountpoint=Path('/home'),
+		mount_options=mount_options,
+		fs_type=filesystem_type,
+		flags=flags,
+	)
+	home_device_modification.add_partition(home_partition)
+
+	return [root_device_modification, home_device_modification]
+
+
+async def suggest_lvm_layout(
+	disk_config: DiskLayoutConfiguration,
+	filesystem_type: FilesystemType | None = None,
+	vg_grp_name: str = 'ArchinstallVg',
+) -> LvmConfiguration:
+	if disk_config.config_type != DiskLayoutType.Default:
+		raise ValueError('LVM suggested volumes are only available for default partitioning')
+
+	using_subvolumes = False
+	btrfs_subvols = []
+	home_volume = True
+	mount_options = []
+
+	if not filesystem_type:
+		filesystem_type = await select_main_filesystem_format()
+
+	if filesystem_type == FilesystemType.BTRFS:
+		prompt = tr('Would you like to use BTRFS subvolumes with a default structure?') + '\n'
+		result = await Confirmation(header=prompt, allow_skip=False, preset=True).show()
+
+		using_subvolumes = MenuItem.yes() == result.item()
+		mount_options = await select_mount_options()
+
+	if using_subvolumes:
+		btrfs_subvols = get_default_btrfs_subvols()
+		home_volume = False
+
+	boot_part: PartitionModification | None = None
+	other_part: list[PartitionModification] = []
+
+	for mod in disk_config.device_modifications:
+		for part in mod.partitions:
+			if part.is_boot():
+				boot_part = part
+			else:
+				other_part.append(part)
+
+	if not boot_part:
+		raise ValueError('Unable to find boot partition in partition modifications')
+
+	total_vol_available = sum(
+		[p.length for p in other_part],
+		Size(0, Unit.B, SectorSize.default()),
+	)
+	root_vol_size = process_root_partition_size(total_vol_available, SectorSize.default())
+	home_vol_size = total_vol_available - root_vol_size
+
+	lvm_vol_group = LvmVolumeGroup(vg_grp_name, pvs=other_part)
+
+	root_vol = LvmVolume(
+		status=ModificationStatus.CREATE,
+		name='root',
+		fs_type=filesystem_type,
+		length=root_vol_size,
+		mountpoint=Path('/'),
+		btrfs_subvols=btrfs_subvols,
+		mount_options=mount_options,
+	)
+
+	lvm_vol_group.volumes.append(root_vol)
+
+	if home_volume:
+		home_vol = LvmVolume(
+			status=ModificationStatus.CREATE,
+			name='home',
+			fs_type=filesystem_type,
+			length=home_vol_size,
+			mountpoint=Path('/home'),
+		)
+
+		lvm_vol_group.volumes.append(home_vol)
+
+	return LvmConfiguration(LvmLayoutType.Default, [lvm_vol_group])

archinstall/lib/disk/encryption_menu.py

@@ -1,140 +1,156 @@
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
+from typing import override
 
-from . import LvmConfiguration, LvmVolume
-from ..disk import (
-	DeviceModification,
-	DiskLayoutConfiguration,
-	PartitionModification,
-	DiskEncryption,
-	EncryptionType
-)
-from ..menu import AbstractSubMenu
-from .fido import Fido2Device, Fido2
-from ..output import FormattedOutput
-from ..utils.util import get_password
-
-from archinstall.tui import (
-	MenuItemGroup, MenuItem, SelectMenu,
-	FrameProperties, Alignment, ResultType
-)
+from archinstall.lib.disk.fido import Fido2
+from archinstall.lib.menu.abstract_menu import AbstractSubMenu
+from archinstall.lib.menu.helpers import Input, Selection, Table
 from archinstall.lib.menu.menu_helper import MenuHelper
+from archinstall.lib.menu.util import get_password
+from archinstall.lib.models.device import (
+	DEFAULT_ITER_TIME,
+	DeviceModification,
+	DiskEncryption,
+	EncryptionType,
+	Fido2Device,
+	LvmConfiguration,
+	LvmVolume,
+	PartitionModification,
+)
+from archinstall.lib.models.users import Password
+from archinstall.lib.translationhandler import tr
+from archinstall.lib.utils.format import as_table
+from archinstall.tui.menu_item import MenuItem, MenuItemGroup
+from archinstall.tui.result import ResultType
 
 
-if TYPE_CHECKING:
-	_: Any
-
-
-class DiskEncryptionMenu(AbstractSubMenu):
+class DiskEncryptionMenu(AbstractSubMenu[DiskEncryption]):
 	def __init__(
 		self,
-		disk_config: DiskLayoutConfiguration,
-		preset: DiskEncryption | None = None
+		device_modifications: list[DeviceModification],
+		lvm_config: LvmConfiguration | None = None,
+		preset: DiskEncryption | None = None,
 	):
 		if preset:
-			self._preset = preset
+			self._enc_config = preset
 		else:
-			self._preset = DiskEncryption()
+			self._enc_config = DiskEncryption()
 
-		self._data_store: dict[str, Any] = {}
-		self._disk_config = disk_config
+		self._device_modifications = device_modifications
+		self._lvm_config = lvm_config
 
-		menu_optioons = self._define_menu_options()
-		self._item_group = MenuItemGroup(menu_optioons, sort_items=False, checkmarks=True)
+		menu_options = self._define_menu_options()
+		self._item_group = MenuItemGroup(menu_options, sort_items=False, checkmarks=True)
 
-		super().__init__(self._item_group, data_store=self._data_store, allow_reset=True)
+		super().__init__(
+			self._item_group,
+			self._enc_config,
+			allow_reset=True,
+		)
 
 	def _define_menu_options(self) -> list[MenuItem]:
 		return [
 			MenuItem(
-				text=str(_('Encryption type')),
-				action=lambda x: select_encryption_type(self._disk_config, x),
-				value=self._preset.encryption_type,
-				preview_action=self._preview,
-				key='encryption_type'
+				text=tr('Encryption type'),
+				action=lambda x: select_encryption_type(self._lvm_config, x),
+				value=self._enc_config.encryption_type,
+				preview_action=self._prev_type,
+				key='encryption_type',
 			),
 			MenuItem(
-				text=str(_('Encryption password')),
+				text=tr('Encryption password'),
 				action=lambda x: select_encrypted_password(),
-				value=self._preset.encryption_password,
+				value=self._enc_config.encryption_password,
 				dependencies=[self._check_dep_enc_type],
-				preview_action=self._preview,
-				key='encryption_password'
+				preview_action=self._prev_password,
+				key='encryption_password',
 			),
 			MenuItem(
-				text=str(_('Partitions')),
-				action=lambda x: select_partitions_to_encrypt(self._disk_config.device_modifications, x),
-				value=self._preset.partitions,
+				text=tr('Iteration time'),
+				action=select_iteration_time,
+				value=self._enc_config.iter_time,
+				dependencies=[self._check_dep_enc_type],
+				preview_action=self._prev_iter_time,
+				key='iter_time',
+			),
+			MenuItem(
+				text=tr('Partitions'),
+				action=lambda x: select_partitions_to_encrypt(self._device_modifications, x),
+				value=self._enc_config.partitions,
 				dependencies=[self._check_dep_partitions],
-				preview_action=self._preview,
-				key='partitions'
+				preview_action=self._prev_partitions,
+				key='partitions',
 			),
 			MenuItem(
-				text=str(_('LVM volumes')),
-				action=lambda x: self._select_lvm_vols(x),
-				value=self._preset.lvm_volumes,
+				text=tr('LVM volumes'),
+				action=self._select_lvm_vols,
+				value=self._enc_config.lvm_volumes,
 				dependencies=[self._check_dep_lvm_vols],
-				preview_action=self._preview,
-				key='lvm_vols'
+				preview_action=self._prev_lvm_vols,
+				key='lvm_volumes',
 			),
 			MenuItem(
-				text=str(_('HSM')),
-				action=lambda x: select_hsm(x),
-				value=self._preset.hsm_device,
+				text=tr('HSM'),
+				action=select_hsm,
+				value=self._enc_config.hsm_device,
 				dependencies=[self._check_dep_enc_type],
-				preview_action=self._preview,
-				key='HSM'
+				preview_action=self._prev_hsm,
+				key='hsm_device',
 			),
 		]
 
-	def _select_lvm_vols(self, preset: list[LvmVolume]) -> list[LvmVolume]:
-		if self._disk_config.lvm_config:
-			return select_lvm_vols_to_encrypt(self._disk_config.lvm_config, preset=preset)
+	async def _select_lvm_vols(self, preset: list[LvmVolume]) -> list[LvmVolume]:
+		if self._lvm_config:
+			return await select_lvm_vols_to_encrypt(self._lvm_config, preset=preset)
 		return []
 
 	def _check_dep_enc_type(self) -> bool:
 		enc_type: EncryptionType | None = self._item_group.find_by_key('encryption_type').value
-		if enc_type and enc_type != EncryptionType.NoEncryption:
+		if enc_type and enc_type != EncryptionType.NO_ENCRYPTION:
 			return True
 		return False
 
 	def _check_dep_partitions(self) -> bool:
 		enc_type: EncryptionType | None = self._item_group.find_by_key('encryption_type').value
-		if enc_type and enc_type in [EncryptionType.Luks, EncryptionType.LvmOnLuks]:
+		if enc_type and enc_type in [EncryptionType.LUKS, EncryptionType.LVM_ON_LUKS]:
 			return True
 		return False
 
 	def _check_dep_lvm_vols(self) -> bool:
 		enc_type: EncryptionType | None = self._item_group.find_by_key('encryption_type').value
-		if enc_type and enc_type == EncryptionType.LuksOnLvm:
+		if enc_type and enc_type == EncryptionType.LUKS_ON_LVM:
 			return True
 		return False
 
-	def run(self) -> DiskEncryption | None:
-		super().run()
+	@override
+	async def show(self) -> DiskEncryption | None:
+		enc_config = await super().show()
+		if enc_config is None:
+			return None
 
 		enc_type: EncryptionType | None = self._item_group.find_by_key('encryption_type').value
-		enc_password: str | None = self._item_group.find_by_key('encryption_password').value
+		enc_password: Password | None = self._item_group.find_by_key('encryption_password').value
+		iter_time: int | None = self._item_group.find_by_key('iter_time').value
 		enc_partitions = self._item_group.find_by_key('partitions').value
-		enc_lvm_vols = self._item_group.find_by_key('lvm_vols').value
+		enc_lvm_vols = self._item_group.find_by_key('lvm_volumes').value
 
 		assert enc_type is not None
 		assert enc_partitions is not None
 		assert enc_lvm_vols is not None
 
-		if enc_type in [EncryptionType.Luks, EncryptionType.LvmOnLuks] and enc_partitions:
+		if enc_type in [EncryptionType.LUKS, EncryptionType.LVM_ON_LUKS] and enc_partitions:
 			enc_lvm_vols = []
 
-		if enc_type == EncryptionType.LuksOnLvm:
+		if enc_type == EncryptionType.LUKS_ON_LVM:
 			enc_partitions = []
 
-		if enc_type != EncryptionType.NoEncryption and enc_password and (enc_partitions or enc_lvm_vols):
+		if enc_type != EncryptionType.NO_ENCRYPTION and enc_password and (enc_partitions or enc_lvm_vols):
 			return DiskEncryption(
 				encryption_password=enc_password,
 				encryption_type=enc_type,
 				partitions=enc_partitions,
 				lvm_volumes=enc_lvm_vols,
-				hsm_device=self._data_store.get('HSM', None)
+				hsm_device=enc_config.hsm_device,
+				iter_time=iter_time or DEFAULT_ITER_TIME,
 			)
 
 		return None
@@ -142,19 +158,22 @@ class DiskEncryptionMenu(AbstractSubMenu):
 	def _preview(self, item: MenuItem) -> str | None:
 		output = ''
 
-		if (enc_type := self._prev_type()) is not None:
+		if (enc_type := self._prev_type(item)) is not None:
 			output += enc_type
 
-		if (enc_pwd := self._prev_password()) is not None:
+		if (enc_pwd := self._prev_password(item)) is not None:
 			output += f'\n{enc_pwd}'
 
-		if (fido_device := self._prev_hsm()) is not None:
+		if (iter_time := self._prev_iter_time(item)) is not None:
+			output += f'\n{iter_time}'
+
+		if (fido_device := self._prev_hsm(item)) is not None:
 			output += f'\n{fido_device}'
 
-		if (partitions := self._prev_partitions()) is not None:
+		if (partitions := self._prev_partitions(item)) is not None:
 			output += f'\n\n{partitions}'
 
-		if (lvm := self._prev_lvm_vols()) is not None:
+		if (lvm := self._prev_lvm_vols(item)) is not None:
 			output += f'\n\n{lvm}'
 
 		if not output:
@@ -162,75 +181,84 @@ class DiskEncryptionMenu(AbstractSubMenu):
 
 		return output
 
-	def _prev_type(self) -> str | None:
+	def _prev_type(self, item: MenuItem) -> str | None:
 		enc_type = self._item_group.find_by_key('encryption_type').value
 
 		if enc_type:
-			enc_text = EncryptionType.type_to_text(enc_type)
-			return f'{_("Encryption type")}: {enc_text}'
+			enc_text = enc_type.type_to_text()
+			return f'{tr("Encryption type")}: {enc_text}'
 
 		return None
 
-	def _prev_password(self) -> str | None:
-		enc_pwd = self._item_group.find_by_key('encryption_password').value
-
-		if enc_pwd:
-			pwd_text = '*' * len(enc_pwd)
-			return f'{_("Encryption password")}: {pwd_text}'
+	def _prev_password(self, item: MenuItem) -> str | None:
+		if item.value:
+			return f'{tr("Encryption password")}: {item.value.hidden()}'
 
 		return None
 
-	def _prev_partitions(self) -> str | None:
-		partitions: list[PartitionModification] | None = self._item_group.find_by_key('partitions').value
-
-		if partitions:
-			output = str(_('Partitions to be encrypted')) + '\n'
-			output += FormattedOutput.as_table(partitions)
+	def _prev_partitions(self, item: MenuItem) -> str | None:
+		if item.value:
+			output = tr('Partitions to be encrypted') + '\n'
+			output += as_table(item.value)
 			return output.rstrip()
 
 		return None
 
-	def _prev_lvm_vols(self) -> str | None:
-		volumes: list[PartitionModification] | None = self._item_group.find_by_key('lvm_vols').value
-
-		if volumes:
-			output = str(_('LVM volumes to be encrypted')) + '\n'
-			output += FormattedOutput.as_table(volumes)
+	def _prev_lvm_vols(self, item: MenuItem) -> str | None:
+		if item.value:
+			output = tr('LVM volumes to be encrypted') + '\n'
+			output += as_table(item.value)
 			return output.rstrip()
 
 		return None
 
-	def _prev_hsm(self) -> str | None:
-		fido_device: Fido2Device | None = self._item_group.find_by_key('HSM').value
-
-		if not fido_device:
+	def _prev_hsm(self, item: MenuItem) -> str | None:
+		if not item.value:
 			return None
 
+		fido_device: Fido2Device = item.value
+
 		output = str(fido_device.path)
 		output += f' ({fido_device.manufacturer}, {fido_device.product})'
-		return f'{_("HSM device")}: {output}'
+		return f'{tr("HSM device")}: {output}'
+
+	def _prev_iter_time(self, item: MenuItem) -> str | None:
+		if item.value:
+			iter_time = item.value
+			enc_type = self._item_group.find_by_key('encryption_type').value
+
+			if iter_time and enc_type != EncryptionType.NO_ENCRYPTION:
+				return f'{tr("Iteration time")}: {iter_time}ms'
+
+		return None
 
 
-def select_encryption_type(disk_config: DiskLayoutConfiguration, preset: EncryptionType) -> EncryptionType | None:
+async def select_encryption_type(
+	lvm_config: LvmConfiguration | None = None,
+	preset: EncryptionType | None = None,
+) -> EncryptionType | None:
 	options: list[EncryptionType] = []
-	preset_value = EncryptionType.type_to_text(preset)
 
-	if disk_config.lvm_config:
-		options = [EncryptionType.LvmOnLuks, EncryptionType.LuksOnLvm]
+	if lvm_config:
+		options = [EncryptionType.LVM_ON_LUKS, EncryptionType.LUKS_ON_LVM]
 	else:
-		options = [EncryptionType.Luks]
+		options = [EncryptionType.LUKS]
 
-	items = [MenuItem(EncryptionType.type_to_text(o), value=o) for o in options]
+	if not preset:
+		preset = options[0]
+
+	preset_value = preset.type_to_text()
+
+	items = [MenuItem(o.type_to_text(), value=o) for o in options]
 	group = MenuItemGroup(items)
 	group.set_focus_by_value(preset_value)
 
-	result = SelectMenu(
+	result = await Selection[EncryptionType](
 		group,
+		header=tr('Select encryption type'),
 		allow_skip=True,
 		allow_reset=True,
-		alignment=Alignment.CENTER,
-		frame=FrameProperties.min(str(_('Encryption type')))
-	).run()
+	).show()
 
 	match result.type_:
 		case ResultType.Reset:
@@ -241,34 +269,32 @@ def select_encryption_type(disk_config: DiskLayoutConfiguration, preset: Encrypt
 			return result.get_value()
 
 
-def select_encrypted_password() -> str | None:
-	header = str(_('Enter disk encryption password (leave blank for no encryption)')) + '\n'
-	password = get_password(
-		text=str(_('Disk encryption password')),
+async def select_encrypted_password() -> Password | None:
+	header = tr('Enter disk encryption password (leave blank for no encryption)') + '\n'
+	password = await get_password(
 		header=header,
-		allow_skip=True
+		allow_skip=True,
 	)
 
 	return password
 
 
-def select_hsm(preset: Fido2Device | None = None) -> Fido2Device | None:
-	header = str(_('Select a FIDO2 device to use for HSM'))
+async def select_hsm(preset: Fido2Device | None = None) -> Fido2Device | None:
+	header = tr('Select a FIDO2 device to use for HSM') + '\n'
 
 	try:
-		fido_devices = Fido2.get_fido2_devices()
+		fido_devices = Fido2.get_cryptenroll_devices()
 	except ValueError:
 		return None
 
 	if fido_devices:
-		group, table_header = MenuHelper.create_table(data=fido_devices)
-		header = f'{header}\n\n{table_header}'
+		group = MenuHelper(data=fido_devices).create_menu_group()
 
-		result = SelectMenu(
+		result = await Selection[Fido2Device](
 			group,
 			header=header,
-			alignment=Alignment.CENTER,
-		).run()
+			allow_skip=True,
+		).show()
 
 		match result.type_:
 			case ResultType.Reset:
@@ -281,28 +307,29 @@ def select_hsm(preset: Fido2Device | None = None) -> Fido2Device | None:
 	return None
 
 
-def select_partitions_to_encrypt(
+async def select_partitions_to_encrypt(
 	modification: list[DeviceModification],
-	preset: list[PartitionModification]
+	preset: list[PartitionModification],
 ) -> list[PartitionModification]:
 	partitions: list[PartitionModification] = []
 
 	# do not allow encrypting the boot partition
 	for mod in modification:
-		partitions += list(filter(lambda x: x.mountpoint != Path('/boot'), mod.partitions))
+		partitions += [p for p in mod.partitions if p.mountpoint != Path('/boot') and not p.is_swap()]
 
 	# do not allow encrypting existing partitions that are not marked as wipe
-	avail_partitions = list(filter(lambda x: not x.exists(), partitions))
+	avail_partitions = [p for p in partitions if not p.exists()]
 
 	if avail_partitions:
-		group, header = MenuHelper.create_table(data=avail_partitions)
+		group = MenuItemGroup.from_objects(avail_partitions)
+		group.set_selected_by_value(preset)
 
-		result = SelectMenu(
-			group,
-			header=header,
-			alignment=Alignment.CENTER,
-			multi=True
-		).run()
+		result = await Table[PartitionModification](
+			header=tr('Select disks for the installation'),
+			group=group,
+			allow_skip=True,
+			multi=True,
+		).show()
 
 		match result.type_:
 			case ResultType.Reset:
@@ -316,21 +343,22 @@ def select_partitions_to_encrypt(
 	return []
 
 
-def select_lvm_vols_to_encrypt(
+async def select_lvm_vols_to_encrypt(
 	lvm_config: LvmConfiguration,
-	preset: list[LvmVolume]
+	preset: list[LvmVolume],
 ) -> list[LvmVolume]:
 	volumes: list[LvmVolume] = lvm_config.get_all_volumes()
 
 	if volumes:
-		group, header = MenuHelper.create_table(data=volumes)
+		group = MenuItemGroup.from_objects(volumes)
+		group.set_selected_by_value(preset)
 
-		result = SelectMenu(
-			group,
-			header=header,
-			alignment=Alignment.CENTER,
-			multi=True
-		).run()
+		result = await Table[LvmVolume](
+			header=tr('Select disks for the installation'),
+			group=group,
+			allow_skip=True,
+			multi=True,
+		).show()
 
 		match result.type_:
 			case ResultType.Reset:
@@ -342,3 +370,37 @@ def select_lvm_vols_to_encrypt(
 				return volumes
 
 	return []
+
+
+async def select_iteration_time(preset: int | None = None) -> int | None:
+	header = tr('Enter iteration time for LUKS encryption (in milliseconds)') + '\n'
+	header += tr('Higher values increase security but slow down boot time') + '\n'
+	header += tr('Default: {}ms, Recommended range: 1000-60000').format(DEFAULT_ITER_TIME) + '\n'
+
+	def validate_iter_time(value: str) -> str | None:
+		try:
+			iter_time = int(value)
+			if iter_time < 100:
+				return tr('Iteration time must be at least 100ms')
+			if iter_time > 120000:
+				return tr('Iteration time must be at most 120000ms')
+			return None
+		except ValueError:
+			return tr('Please enter a valid number')
+
+	result = await Input(
+		header=header,
+		allow_skip=True,
+		default_value=str(preset) if preset else str(DEFAULT_ITER_TIME),
+		validator_callback=validate_iter_time,
+	).show()
+
+	match result.type_:
+		case ResultType.Skip:
+			return preset
+		case ResultType.Selection:
+			if not result.get_value():
+				return preset
+			return int(result.get_value())
+		case ResultType.Reset:
+			return None

archinstall/lib/disk/fido.py

@@ -1,20 +1,52 @@
-from __future__ import annotations
-
 import getpass
 from pathlib import Path
+from typing import ClassVar
 
-from .device_model import Fido2Device
-from ..general import SysCommand, SysCommandWorker, clear_vt100_escape_codes
-from ..output import error, info
-from ..exceptions import SysCallError
+from archinstall.lib.command import SysCommand, SysCommandWorker
+from archinstall.lib.exceptions import SysCallError
+from archinstall.lib.log import error, info
+from archinstall.lib.models.device import Fido2Device
+from archinstall.lib.models.users import Password
+from archinstall.lib.utils.encoding import clear_vt100_escape_codes_from_str
 
 
 class Fido2:
-	_loaded: bool = False
-	_fido2_devices: list[Fido2Device] = []
+	_loaded_cryptsetup: bool = False
+	_loaded_u2f: bool = False
+	_cryptenroll_devices: ClassVar[list[Fido2Device]] = []
+	_u2f_devices: ClassVar[list[Fido2Device]] = []
 
 	@classmethod
-	def get_fido2_devices(cls, reload: bool = False) -> list[Fido2Device]:
+	def get_fido2_devices(cls) -> list[Fido2Device]:
+		"""
+		fido2-tool output example:
+
+		/dev/hidraw4: vendor=0x1050, product=0x0407 (Yubico YubiKey OTP+FIDO+CCID)
+		"""
+
+		if not cls._loaded_u2f:
+			cls._loaded_u2f = True
+			try:
+				ret = SysCommand('fido2-token -L').decode()
+			except Exception as e:
+				error(f'failed to read fido2 devices: {e}')
+				return []
+
+			fido_devices = clear_vt100_escape_codes_from_str(ret)
+
+			if not fido_devices:
+				return []
+
+			for line in fido_devices.splitlines():
+				path, details = line.replace(',', '').split(':', maxsplit=1)
+				_, product, manufacturer = details.strip().split(' ', maxsplit=2)
+
+				cls._u2f_devices.append(Fido2Device(Path(path.strip()), manufacturer.strip(), product.strip().split('=')[1]))
+
+		return cls._u2f_devices
+
+	@classmethod
+	def get_cryptenroll_devices(cls, reload: bool = False) -> list[Fido2Device]:
 		"""
 		Uses systemd-cryptenroll to list the FIDO2 devices
 		connected that supports FIDO2.
@@ -29,20 +61,20 @@ class Fido2:
 
 		Output example:
 
-		PATH         MANUFACTURER PRODUCT
-		/dev/hidraw1 Yubico       YubiKey OTP+FIDO+CCID
+		PATH		 MANUFACTURER PRODUCT
+		/dev/hidraw1 Yubico		  YubiKey OTP+FIDO+CCID
 		"""
 
 		# to prevent continuous reloading which will slow
 		# down moving the cursor in the menu
-		if not cls._loaded or reload:
+		if not cls._loaded_cryptsetup or reload:
 			try:
-				ret = SysCommand("systemd-cryptenroll --fido2-device=list").decode()
+				ret = SysCommand('systemd-cryptenroll --fido2-device=list').decode()
 			except SysCallError:
 				error('fido2 support is most likely not installed')
 				raise ValueError('HSM devices can not be detected, is libfido2 installed?')
 
-			fido_devices: str = clear_vt100_escape_codes(ret)  # type: ignore
+			fido_devices = clear_vt100_escape_codes_from_str(ret)
 
 			manufacturer_pos = 0
 			product_pos = 0
@@ -59,33 +91,28 @@ class Fido2:
 				product = line[product_pos:]
 
 				devices.append(
-					Fido2Device(Path(path), manufacturer, product)
+					Fido2Device(Path(path), manufacturer, product),
 				)
 
-			cls._loaded = True
-			cls._fido2_devices = devices
+			cls._loaded_cryptsetup = True
+			cls._cryptenroll_devices = devices
 
-		return cls._fido2_devices
+		return cls._cryptenroll_devices
 
-	@classmethod
-	def fido2_enroll(
-		cls,
-		hsm_device: Fido2Device,
-		dev_path: Path,
-		password: str
-	) -> None:
-		worker = SysCommandWorker(f"systemd-cryptenroll --fido2-device={hsm_device.path} {dev_path}", peek_output=True)
+	@staticmethod
+	def fido2_enroll(hsm_device: Fido2Device, dev_path: Path, password: Password) -> None:
+		worker = SysCommandWorker(f'systemd-cryptenroll --fido2-device={hsm_device.path} {dev_path}', peek_output=True)
 		pw_inputted = False
 		pin_inputted = False
 
+		info('You might need to touch the FIDO2 device to unlock it if no prompt comes up after 3 seconds')
+
 		while worker.is_alive():
 			if pw_inputted is False:
-				if bytes(f"please enter current passphrase for disk {dev_path}", 'UTF-8') in worker._trace_log.lower():
-					worker.write(bytes(password, 'UTF-8'))
+				if bytes(f'please enter current passphrase for disk {dev_path}', 'UTF-8') in worker._trace_log.lower():
+					worker.write(bytes(password.plaintext, 'UTF-8'))
 					pw_inputted = True
 			elif pin_inputted is False:
-				if bytes("please enter security token pin", 'UTF-8') in worker._trace_log.lower():
-					worker.write(bytes(getpass.getpass(" "), 'UTF-8'))
+				if bytes('please enter security token pin', 'UTF-8') in worker._trace_log.lower():
+					worker.write(bytes(getpass.getpass(' '), 'UTF-8'))
 					pin_inputted = True
-
-				info('You might need to touch the FIDO2 device to unlock it if no prompt comes up after 3 seconds')

archinstall/lib/disk/filesystem.py

@@ -1,92 +1,81 @@
-from __future__ import annotations
-
+import math
 import time
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
 
-from ..interactions.general_conf import ask_abort
-from .device_handler import device_handler
-from .device_model import (
-	DiskLayoutConfiguration, DiskLayoutType, PartitionTable,
-	FilesystemType, DiskEncryption, LvmVolumeGroup,
-	Size, Unit, SectorSize, PartitionModification, EncryptionType,
-	LvmVolume, LvmConfiguration
+from archinstall.lib.disk.device_handler import device_handler
+from archinstall.lib.disk.luks import Luks2
+from archinstall.lib.disk.lvm import (
+	lvm_group_info,
+	lvm_pv_create,
+	lvm_vg_create,
+	lvm_vol_create,
+	lvm_vol_info,
+	lvm_vol_reduce,
 )
-from ..hardware import SysInfo
-from ..luks import Luks2
-from ..output import debug, info
-from archinstall.tui import (
-	Tui
+from archinstall.lib.disk.utils import udev_sync
+from archinstall.lib.log import debug, info
+from archinstall.lib.models.device import (
+	DiskEncryption,
+	DiskLayoutConfiguration,
+	DiskLayoutType,
+	EncryptionType,
+	FilesystemType,
+	LvmConfiguration,
+	LvmVolume,
+	LvmVolumeGroup,
+	PartitionModification,
+	SectorSize,
+	Size,
+	Unit,
 )
 
 
-if TYPE_CHECKING:
-	_: Any
-
-
 class FilesystemHandler:
-	def __init__(
-		self,
-		disk_config: DiskLayoutConfiguration,
-		enc_conf: DiskEncryption | None = None
-	):
+	def __init__(self, disk_config: DiskLayoutConfiguration):
 		self._disk_config = disk_config
-		self._enc_config = enc_conf
+		self._enc_config = disk_config.disk_encryption
 
-	def perform_filesystem_operations(self, show_countdown: bool = True) -> None:
+	def perform_filesystem_operations(self) -> None:
 		if self._disk_config.config_type == DiskLayoutType.Pre_mount:
 			debug('Disk layout configuration is set to pre-mount, not performing any operations')
 			return
 
-		device_mods = list(filter(lambda x: len(x.partitions) > 0, self._disk_config.device_modifications))
+		device_mods = [d for d in self._disk_config.device_modifications if d.partitions]
 
 		if not device_mods:
 			debug('No modifications required')
 			return
 
-		device_paths = ', '.join([str(mod.device.device_info.path) for mod in device_mods])
-
-		if show_countdown:
-			self._final_warning(device_paths)
-
 		# Setup the blockdevice, filesystem (and optionally encryption).
 		# Once that's done, we'll hand over to perform_installation()
-		partition_table = PartitionTable.GPT
-		if SysInfo.has_uefi() is False:
-			partition_table = PartitionTable.MBR
 
 		# make sure all devices are unmounted
 		for mod in device_mods:
 			device_handler.umount_all_existing(mod.device_path)
 
 		for mod in device_mods:
-			device_handler.partition(mod, partition_table=partition_table)
+			device_handler.partition(mod)
+
+		udev_sync()
 
 		if self._disk_config.lvm_config:
 			for mod in device_mods:
 				if boot_part := mod.get_boot_partition():
 					debug(f'Formatting boot partition: {boot_part.dev_path}')
-					self._format_partitions(
-						[boot_part],
-						mod.device_path
-					)
+					self._format_partitions([boot_part])
 
 			self.perform_lvm_operations()
 		else:
 			for mod in device_mods:
-				self._format_partitions(
-					mod.partitions,
-					mod.device_path
-				)
+				self._format_partitions(mod.partitions)
 
 				for part_mod in mod.partitions:
-					if part_mod.fs_type == FilesystemType.Btrfs:
+					if part_mod.fs_type == FilesystemType.BTRFS and part_mod.is_create_or_modify():
 						device_handler.create_btrfs_volumes(part_mod, enc_conf=self._enc_config)
 
 	def _format_partitions(
 		self,
 		partitions: list[PartitionModification],
-		device_path: Path
 	) -> None:
 		"""
 		Format can be given an overriding path, for instance /dev/null to test
@@ -105,13 +94,13 @@ class FilesystemHandler:
 					part_mod.safe_dev_path,
 					part_mod.mapper_name,
 					part_mod.safe_fs_type,
-					self._enc_config
+					self._enc_config,
 				)
 			else:
 				device_handler.format(part_mod.safe_fs_type, part_mod.safe_dev_path)
 
 			# synchronize with udev before using lsblk
-			device_handler.udev_sync()
+			udev_sync()
 
 			lsblk_info = device_handler.fetch_part_info(part_mod.safe_dev_path)
 
@@ -124,10 +113,9 @@ class FilesystemHandler:
 			# verify that all partitions have a path set (which implies that they have been created)
 			lambda x: x.dev_path is None: ValueError('When formatting, all partitions must have a path set'),
 			# crypto luks is not a valid file system type
-			lambda x: x.fs_type is FilesystemType.Crypto_luks: ValueError(
-				'Crypto luks cannot be set as a filesystem type'),
+			lambda x: x.fs_type is FilesystemType.CRYPTO_LUKS: ValueError('Crypto luks cannot be set as a filesystem type'),
 			# file system type must be set
-			lambda x: x.fs_type is None: ValueError('File system type must be set for modification')
+			lambda x: x.fs_type is None: ValueError('File system type must be set for modification'),
 		}
 
 		for check, exc in checks.items():
@@ -144,55 +132,46 @@ class FilesystemHandler:
 		if self._enc_config:
 			self._setup_lvm_encrypted(
 				self._disk_config.lvm_config,
-				self._enc_config
+				self._enc_config,
 			)
 		else:
 			self._setup_lvm(self._disk_config.lvm_config)
 			self._format_lvm_vols(self._disk_config.lvm_config)
 
 	def _setup_lvm_encrypted(self, lvm_config: LvmConfiguration, enc_config: DiskEncryption) -> None:
-		if enc_config.encryption_type == EncryptionType.LvmOnLuks:
+		if enc_config.encryption_type == EncryptionType.LVM_ON_LUKS:
 			enc_mods = self._encrypt_partitions(enc_config, lock_after_create=False)
 
 			self._setup_lvm(lvm_config, enc_mods)
 			self._format_lvm_vols(lvm_config)
 
-			# export the lvm group safely otherwise the Luks cannot be closed
-			self._safely_close_lvm(lvm_config)
-
-			for luks in enc_mods.values():
-				luks.lock()
-		elif enc_config.encryption_type == EncryptionType.LuksOnLvm:
+			# Don't close LVM or LUKS during setup - keep everything active
+			# The installation phase will handle unlocking and mounting
+			# Closing causes "parent leaked" and lvchange errors
+		elif enc_config.encryption_type == EncryptionType.LUKS_ON_LVM:
 			self._setup_lvm(lvm_config)
 			enc_vols = self._encrypt_lvm_vols(lvm_config, enc_config, False)
 			self._format_lvm_vols(lvm_config, enc_vols)
 
+			# Lock LUKS devices but keep LVM active
+			# LVM volumes must remain active for later re-unlock during installation
 			for luks in enc_vols.values():
 				luks.lock()
 
-			self._safely_close_lvm(lvm_config)
-
-	def _safely_close_lvm(self, lvm_config: LvmConfiguration) -> None:
-		for vg in lvm_config.vol_groups:
-			for vol in vg.volumes:
-				device_handler.lvm_vol_change(vol, False)
-
-			device_handler.lvm_export_vg(vg)
-
 	def _setup_lvm(
 		self,
 		lvm_config: LvmConfiguration,
-		enc_mods: dict[PartitionModification, Luks2] = {}
+		enc_mods: dict[PartitionModification, Luks2] = {},
 	) -> None:
 		self._lvm_create_pvs(lvm_config, enc_mods)
 
 		for vg in lvm_config.vol_groups:
 			pv_dev_paths = self._get_all_pv_dev_paths(vg.pvs, enc_mods)
 
-			device_handler.lvm_vg_create(pv_dev_paths, vg.name)
+			lvm_vg_create(pv_dev_paths, vg.name)
 
 			# figure out what the actual available size in the group is
-			vg_info = device_handler.lvm_group_info(vg.name)
+			vg_info = lvm_group_info(vg.name)
 
 			if not vg_info:
 				raise ValueError('Unable to fetch VG info')
@@ -206,7 +185,15 @@ class FilesystemHandler:
 			desired_size = sum([vol.length for vol in vg.volumes], Size(0, Unit.B, SectorSize.default()))
 
 			delta = desired_size - avail_size
-			max_vol_offset = delta.convert(Unit.B)
+			delta_bytes = delta.convert(Unit.B)
+
+			# Round the offset up to the next physical extent (PE, 4 MiB by default)
+			# to ensure lvcreate`s internal rounding doesn`t consume space reserved
+			# for subsequent logical volumes.
+			pe_bytes = Size(4, Unit.MiB, SectorSize.default()).convert(Unit.B)
+			pe_count = math.ceil(delta_bytes.value / pe_bytes.value)
+			rounded_offset = pe_count * pe_bytes.value
+			max_vol_offset = Size(rounded_offset, Unit.B, SectorSize.default())
 
 			max_vol = max(vg.volumes, key=lambda x: x.length)
 
@@ -214,11 +201,11 @@ class FilesystemHandler:
 				offset = max_vol_offset if lv == max_vol else None
 
 				debug(f'vg: {vg.name}, vol: {lv.name}, offset: {offset}')
-				device_handler.lvm_vol_create(vg.name, lv, offset)
+				lvm_vol_create(vg.name, lv, offset)
 
 				while True:
 					debug('Fetching LVM volume info')
-					lv_info = device_handler.lvm_vol_info(lv.name)
+					lv_info = lvm_vol_info(lv.name)
 					if lv_info is not None:
 						break
 
@@ -229,7 +216,7 @@ class FilesystemHandler:
 	def _format_lvm_vols(
 		self,
 		lvm_config: LvmConfiguration,
-		enc_vols: dict[LvmVolume, Luks2] = {}
+		enc_vols: dict[LvmVolume, Luks2] = {},
 	) -> None:
 		for vol in lvm_config.get_all_volumes():
 			if enc_vol := enc_vols.get(vol, None):
@@ -243,25 +230,25 @@ class FilesystemHandler:
 			# find the mapper device yet
 			device_handler.format(vol.fs_type, path)
 
-			if vol.fs_type == FilesystemType.Btrfs:
+			if vol.fs_type == FilesystemType.BTRFS:
 				device_handler.create_lvm_btrfs_subvolumes(path, vol.btrfs_subvols, vol.mount_options)
 
 	def _lvm_create_pvs(
 		self,
 		lvm_config: LvmConfiguration,
-		enc_mods: dict[PartitionModification, Luks2] = {}
+		enc_mods: dict[PartitionModification, Luks2] = {},
 	) -> None:
 		pv_paths: set[Path] = set()
 
 		for vg in lvm_config.vol_groups:
 			pv_paths |= self._get_all_pv_dev_paths(vg.pvs, enc_mods)
 
-		device_handler.lvm_pv_create(pv_paths)
+		lvm_pv_create(pv_paths)
 
 	def _get_all_pv_dev_paths(
 		self,
 		pvs: list[PartitionModification],
-		enc_mods: dict[PartitionModification, Luks2] = {}
+		enc_mods: dict[PartitionModification, Luks2] = {},
 	) -> set[Path]:
 		pv_paths: set[Path] = set()
 
@@ -278,7 +265,7 @@ class FilesystemHandler:
 		self,
 		lvm_config: LvmConfiguration,
 		enc_config: DiskEncryption,
-		lock_after_create: bool = True
+		lock_after_create: bool = True,
 	) -> dict[LvmVolume, Luks2]:
 		enc_vols: dict[LvmVolume, Luks2] = {}
 
@@ -288,7 +275,8 @@ class FilesystemHandler:
 					vol.safe_dev_path,
 					vol.mapper_name,
 					enc_config.encryption_password,
-					lock_after_create
+					lock_after_create,
+					iter_time=enc_config.iter_time,
 				)
 
 				enc_vols[vol] = luks_handler
@@ -298,7 +286,7 @@ class FilesystemHandler:
 	def _encrypt_partitions(
 		self,
 		enc_config: DiskEncryption,
-		lock_after_create: bool = True
+		lock_after_create: bool = True,
 	) -> dict[PartitionModification, Luks2]:
 		enc_mods: dict[PartitionModification, Luks2] = {}
 
@@ -318,7 +306,8 @@ class FilesystemHandler:
 						part_mod.safe_dev_path,
 						part_mod.mapper_name,
 						enc_config.encryption_password,
-						lock_after_create=lock_after_create
+						lock_after_create=lock_after_create,
+						iter_time=enc_config.iter_time,
 					)
 
 					enc_mods[part_mod] = luks_handler
@@ -329,27 +318,10 @@ class FilesystemHandler:
 		# from arch wiki:
 		# If a logical volume will be formatted with ext4, leave at least 256 MiB
 		# free space in the volume group to allow using e2scrub
-		if any([vol.fs_type == FilesystemType.Ext4 for vol in vol_gp.volumes]):
+		if any([vol.fs_type == FilesystemType.EXT4 for vol in vol_gp.volumes]):
 			largest_vol = max(vol_gp.volumes, key=lambda x: x.length)
 
-			device_handler.lvm_vol_reduce(
+			lvm_vol_reduce(
 				largest_vol.safe_dev_path,
-				Size(256, Unit.MiB, SectorSize.default())
+				Size(256, Unit.MiB, SectorSize.default()),
 			)
-
-	def _final_warning(self, device_paths: str) -> bool:
-		# Issue a final warning before we continue with something un-revertable.
-		# We mention the drive one last time, and count from 5 to 0.
-		out = str(_(' ! Formatting {} in ')).format(device_paths)
-		Tui.print(out, row=0, endl='', clear_screen=True)
-
-		try:
-			countdown = '\n5...4...3...2...1'
-			for c in countdown:
-				Tui.print(c, row=0, endl='')
-				time.sleep(0.25)
-		except KeyboardInterrupt:
-			with Tui():
-				ask_abort()
-
-		return True