fix(deps): update rust crate ignore to v0.4.25

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -8,41 +8,41 @@ assignees: ''
 ---
 
 <!--
-Thanks for taking the time to fill out this bug report! 
-Please make sure to 
-[search for existing issues](https://github.com/topgrade-rs/topgrade/issues) 
+Thanks for taking the time to fill out this bug report!
+Please make sure to
+[search for existing issues](https://github.com/topgrade-rs/topgrade/issues)
 before filing a new one!
 
 Questions labeled with `Optional` can be skipped.
 -->
 
-<!-- 
-If you're here to report about a "No asset found" error, please make sure that 
-an hour has been passed since the last release was made. 
+<!--
+If you're here to report about a "No asset found" error, please make sure that
+an hour has been passed since the last release was made.
 -->
 
 ## Erroneous Behavior
-<!-- 
+<!--
 What actually happened?
 -->
 
 ## Expected Behavior
-<!-- 
+<!--
 Describe the expected behavior
 -->
 
 ## Steps to reproduce
-<!-- 
+<!--
 A minimal example to reproduce the issue
 -->
 
 ## Possible Cause (Optional)
-<!-- 
+<!--
 If you know the possible cause of the issue, please tell us.
 -->
 
 ## Problem persists without calling from topgrade
-<!-- 
+<!--
 Execute the erroneous command directly to see if the problem persists
 -->
 - [ ] Yes
@@ -53,15 +53,15 @@ Execute the erroneous command directly to see if the problem persists
 - [ ] Yes
 - [ ] No
 
-If yes, does the issue still occur when you run topgrade directlly in your
+If yes, does the issue still occur when you run topgrade directly in your
 remote host
 
 - [ ] Yes
 - [ ] No
 
 ## Configuration file (Optional)
-<!-- 
-Paste your configuration file inside the code block if you think this issue is 
+<!--
+Paste your configuration file inside the code block if you think this issue is
 related to configuration.
 -->
 
@@ -74,15 +74,15 @@ related to configuration.
   <!-- For example, Fedora Linux 38 -->
 
 - Installation
-  <!-- 
-  How did you install topgrade: build from repo / crates.io (cargo install topgrade) 
+  <!--
+  How did you install topgrade: build from repo / crates.io (cargo install topgrade)
   / package manager (which one) / other (describe)
   -->
 
 - Topgrade version (`topgrade -V`)
 
 ## Verbose Output (`topgrade -v`)
-<!-- 
+<!--
 Paste the verbose output into the pre-tags
 -->
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -18,8 +18,10 @@ assignees: ''
   option to skip this step?
 
 ## I want to suggest some general feature
+
 Topgrade should...
 
 ## More information
+
 <!-- Assuming that someone else implements the feature,
 please state if you know how to test it from a side branch of Topgrade. -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,18 +1,17 @@
 ## What does this PR do
 
-
 ## Standards checklist
 
 - [ ] The PR title is descriptive
 - [ ] I have read `CONTRIBUTING.md`
 - [ ] *Optional:* I have tested the code myself
 - [ ] If this PR introduces new user-facing messages they are translated
- 
+
 ## For new steps
 
 - [ ] *Optional:* Topgrade skips this step where needed
 - [ ] *Optional:* The `--dry-run` option works with this step
-- [ ] *Optional:* The `--yes` option works with this step if it is supported by 
+- [ ] *Optional:* The `--yes` option works with this step if it is supported by
   the underlying command
 
 If you developed a feature or a bug fix for someone else and you do not have the

.github/dependabot.yml

@@ -1,10 +0,0 @@
-# Set update schedule for GitHub Actions
-
-version: 2
-updates:
-
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      # Check for updates to GitHub Actions every week
-      interval: "weekly"

.github/workflows/check_config_creation_if_not_exists.yml

@@ -7,15 +7,21 @@ env:
   CARGO_TERM_COLOR: always
 
 
+permissions:
+  contents: read
+
 jobs:
   TestConfig:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
-    - run: |
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - run: |
           CONFIG_PATH=~/.config/topgrade.toml;
           if [ -f "$CONFIG_PATH" ]; then rm $CONFIG_PATH; fi
-          cargo build; 
+          cargo build;
           TOPGRADE_SKIP_BRKC_NOTIFY=true ./target/debug/topgrade --dry-run --only system;
           stat $CONFIG_PATH;

.github/workflows/check_i18n.yml

@@ -6,12 +6,17 @@ on:
 
 name: Check i18n
 
+permissions:
+  contents: read
+
 jobs:
   check_locale:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
 
       - name: Install checker
         # Build it with the dev profile as this is faster and the checker still works

.github/workflows/check_security_vulnerability.yml

@@ -11,6 +11,9 @@ on:
     branches:
       - main
 
+permissions:
+  contents: read
+
 jobs:
   lint:
     name: DevSkim
@@ -21,12 +24,14 @@ jobs:
       security-events: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
 
       - name: Run DevSkim scanner
-        uses: microsoft/DevSkim-Action@v1
+        uses: microsoft/DevSkim-Action@4b5047945a44163b94642a1cecc0d93a3f428cc6 # v1.0.16
 
       - name: Upload DevSkim scan results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@v3
+        uses: github/codeql-action/upload-sarif@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           sarif_file: devskim-results.sarif

.github/workflows/check_semver.yml

@@ -1,27 +0,0 @@
-on:
-  release:
-    types: [published, edited]
-
-name: Check SemVer compliance
-
-jobs:
-  prepare:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2022-08-03
-          override: true
-          components: rustfmt, clippy
-
-  semver:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: --git https://github.com/rust-lang/rust-semverver
-      - run: eval "current_version=$(grep -e '^version = .*$' Cargo.toml | cut -d ' ' -f 3)"
-      - run: cargo semver | tee semver_out
-      - run: (head -n 1 semver_out | grep "\-> $current_version") || (echo "versioning mismatch" && return 1)

.github/workflows/ci.yml

@@ -10,22 +10,90 @@ env:
   CROSS_VER: '0.2.5'
   CARGO_NET_RETRY: 3
 
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash
+
 jobs:
   fmt:
     name: Rustfmt
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
 
       - name: Run cargo fmt
         env:
           TERM: xterm-256color
         run: |
+          rustup component add rustfmt
           cargo fmt --all -- --check
 
+  custom-checks:
+    name: Custom checks
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - name: Check if `Step` enum is sorted
+        run: |
+          ENUM_NAME="Step"
+          FILE="src/step.rs"
+          awk "/enum $ENUM_NAME/,/}/" "$FILE" | \
+          grep -E '^\s*[A-Za-z_][A-Za-z0-9_]*\s*,?$' | \
+          sed 's/[, ]//g' > original.txt
+          sort original.txt > sorted.txt
+          diff original.txt sorted.txt
+
+      - name: Check if `Step::run()`'s match is sorted
+        run: |
+          FILE="src/step.rs"
+          awk '/[[:alpha:]] =>/{print $1}' $FILE > original.txt
+          sort original.txt > sorted.txt
+          diff original.txt sorted.txt
+
+      - name: Check if `default_steps` contains every step
+        run: |
+          # Extract all variants from enum Step
+          all_variants=$(sed -n '/^pub enum Step {/,/^}/p' src/step.rs | grep -Po '^\s*\K[A-Z][A-Za-z0-9_]*' | sort)
+
+          # Extract variants used inside default_steps
+          used_variants=$(sed -n '/^pub(crate) fn default_steps()/,/^}/p' src/step.rs | \
+            grep -Po '\b[A-Z][A-Za-z0-9_]*\b' | \
+            grep -Fx -f <(echo "$all_variants") | \
+          sort)
+
+          # Check for missing variants
+          missing=$(comm -23 <(echo "$all_variants") <(echo "$used_variants"))
+          if [[ -z "$missing" ]]; then
+            echo "All variants are used."
+            else
+            echo "Missing variants:"
+            echo "$missing"
+            exit 1
+          fi
+
+          # Check for duplicates
+          duplicates=$(echo "$used_variants" | uniq -c | awk '$1 > 1 {print $2}')
+          if [[ -z "$duplicates" ]]; then
+            echo "No duplicates found."
+            else
+            echo "Duplicates found:"
+            echo "$duplicates"
+            # We allow duplicates, but lets keep this check for potential future usefulness
+            # exit 1
+          fi
+
   main:
-    needs: fmt
+    needs: [ fmt, custom-checks ]
     name: ${{ matrix.target_name }} (check, clippy)
     runs-on: ${{ matrix.os }}
     strategy:
@@ -48,7 +116,7 @@ jobs:
 
           - target: x86_64-apple-darwin
             target_name: macOS-x86_64
-            os: macos-13
+            os: macos-15-intel
 
           - target: aarch64-apple-darwin
             target_name: macOS-aarch64
@@ -62,26 +130,36 @@ jobs:
           - target: x86_64-pc-windows-msvc
             target_name: Windows
             os: windows-latest
+    env:
+      cargo_cmd: ${{ matrix.use_cross == true && 'cross' || 'cargo' }}
+      matrix_target: ${{ matrix.target }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
 
       - name: Setup Rust Cache
-        uses: Swatinem/rust-cache@v2
+        uses: Swatinem/rust-cache@f13886b937689c021905a6b90929199931d60db1 # v2.8.1
         with:
           prefix-key: ${{ matrix.target }}
 
       - name: Setup cross
         if: matrix.use_cross == true
-        run: curl -fL --retry 3 https://github.com/cross-rs/cross/releases/download/v${{ env.CROSS_VER }}/cross-x86_64-unknown-linux-musl.tar.gz | tar vxz -C /usr/local/bin
+        run: |
+          curl -fL --retry 3 "https://github.com/cross-rs/cross/releases/download/v${CROSS_VER}/cross-x86_64-unknown-linux-musl.tar.gz" | tar vxz -C /usr/local/bin
 
       - name: Run cargo/cross check
-        run: ${{ matrix.use_cross == true && 'cross' || 'cargo' }} check --locked --target ${{ matrix.target }}
+        run: |
+          "${cargo_cmd}" check --locked --target "${matrix_target}"
 
       - name: Run cargo/cross clippy
-        run: ${{ matrix.use_cross == true && 'cross' || 'cargo' }} clippy --locked --target ${{ matrix.target }} --all-features -- -D warnings
+        run: |
+          rustup component add clippy
+          "${cargo_cmd}" clippy --locked --target "${matrix_target}" --all-features -- -D warnings
 
       - name: Run cargo test
         # ONLY run test with cargo
         if: matrix.use_cross == false
-        run: cargo test --locked --target ${{ matrix.target }} 
+        run: |
+          cargo test --locked --target "${matrix_target}"

.github/workflows/create_release_assets.yml

@@ -1,26 +1,50 @@
-name: Publish release files for CD native environments
+name: Publish release files for CD native and non-cd-native environments
 
 on:
-  # workflow_run:
-  #   workflows: ["Check SemVer compliance"]
-  #   types:
-  #     - completed
-  release:
-    types: [ created ]
+  repository_dispatch:
+    types: [ release-created ]
+
+permissions:
+  # Write permissions to call the repository dispatch
+  contents: write
+
+defaults:
+  run:
+    shell: bash
 
 jobs:
-  build:
+  # Publish release files for CD native environments
+  native_build:
+    permissions:
+      # Use to sign the release artifacts
+      id-token: write
+      # Used to upload release artifacts
+      contents: write
+      # Used to generate artifact attestations
+      attestations: write
     strategy:
       fail-fast: false
       matrix:
-        platform: [ ubuntu-latest, macos-latest, macos-13, windows-latest ]
+        # Use the Ubuntu 22.04 image to link with a low version of glibc
+        #
+        # https://github.com/topgrade-rs/topgrade/issues/1095
+        platform: [ ubuntu-22.04, macos-latest, macos-15-intel, windows-latest ]
     runs-on: ${{ matrix.platform }}
+    env:
+      tag: ${{ github.event.client_payload.tag }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - name: Install needed components
+        run: |
+          rustup component add rustfmt
+          rustup component add clippy
 
       - name: Install cargo-deb
         run: cargo install cargo-deb
-        if: ${{ matrix.platform == 'ubuntu-latest' }}
+        if: ${{ startsWith(matrix.platform, 'ubuntu-') }}
         shell: bash
 
       - name: Check format
@@ -35,6 +59,30 @@ jobs:
       - name: Run tests
         run: cargo test
 
+      # Used `https://github.com/BurntSushi/ripgrep/blob/master/.github/workflows/release.yml`
+      # as a reference.
+      - name: Build debug binary to create release assets
+        shell: bash
+        run: |
+          cargo build --all-features
+          bin="target/debug/topgrade"
+          echo "BIN=$bin" >> $GITHUB_ENV
+
+      - name: Create deployment directory
+        shell: bash
+        run: |
+          dir=deployment/deb
+          mkdir -p "$dir"
+          echo "DEPLOY_DIR=$dir" >> $GITHUB_ENV
+
+      - name: Generate man page and shell completions
+        shell: bash
+        run: |
+          "$BIN" --gen-manpage > "$DEPLOY_DIR/topgrade.1"
+          "$BIN" --gen-completion bash > "$DEPLOY_DIR/topgrade.bash"
+          "$BIN" --gen-completion fish > "$DEPLOY_DIR/topgrade.fish"
+          "$BIN" --gen-completion zsh > "$DEPLOY_DIR/_topgrade"
+
       - name: Build in Release profile with all features enabled
         run: cargo build --release --all-features
 
@@ -42,7 +90,7 @@ jobs:
         run: |
           cargo install default-target
           mkdir -p assets
-          FILENAME=topgrade-${{github.event.release.tag_name}}-$(default-target)
+          FILENAME=topgrade-${tag}-$(default-target)
           mv target/release/topgrade assets
           cd assets
           tar --format=ustar -czf $FILENAME.tar.gz topgrade
@@ -59,21 +107,21 @@ jobs:
           rm -rf target/release
           cargo build --release
           cargo deb --no-build --no-strip
-        if: ${{ matrix.platform == 'ubuntu-latest' }}
+        if: ${{ startsWith(matrix.platform, 'ubuntu-') }}
         shell: bash
 
       - name: Move Debian-based system package
         run: |
           mkdir -p assets
           mv target/debian/*.deb assets
-        if: ${{ matrix.platform == 'ubuntu-latest' }}
+        if: ${{ startsWith(matrix.platform, 'ubuntu-') }}
         shell: bash
 
       - name: Rename Release (Windows)
         run: |
           cargo install default-target
           mkdir assets
-          FILENAME=topgrade-${{github.event.release.tag_name}}-$(default-target)
+          FILENAME=topgrade-${tag}-$(default-target)
           mv target/release/topgrade.exe assets/topgrade.exe
           cd assets
           powershell Compress-Archive -Path * -Destination ${FILENAME}.zip
@@ -82,7 +130,174 @@ jobs:
         if: ${{ matrix.platform == 'windows-latest' }}
         shell: bash
 
-      - name: Release
-        uses: softprops/action-gh-release@v2
+      - name: Upload assets
+        run: |
+          gh release upload "${tag}" assets/*
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate artifact attestations
+        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3.0.0
         with:
-          files: assets/*
+          subject-path: assets/*
+
+  # Publish release files for non-CD-native environments
+  cross_build:
+    permissions:
+      # Use to sign the release artifacts
+      id-token: write
+      # Used to upload release artifacts
+      contents: write
+      # Used to generate artifact attestations
+      attestations: write
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          [
+            "aarch64-unknown-linux-gnu",
+            "armv7-unknown-linux-gnueabihf",
+            "x86_64-unknown-linux-musl",
+            "aarch64-unknown-linux-musl",
+            "x86_64-unknown-freebsd",
+          ]
+    # Run this one on an older version as well, to limit glibc to 2.34 instead of 2.39.
+    # Even though this is cross-compiled, it links to the libc6-<arch>-cross installed on the host
+    # (see the apt-get install calls below)
+    runs-on: ubuntu-22.04
+    env:
+      matrix_target: ${{ matrix.target }}
+      tag: ${{ github.event.client_payload.tag }}
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - name: Install needed components
+        run: |
+          rustup component add rustfmt
+          rustup component add clippy
+
+      - name: Install cargo-deb cross compilation dependencies
+        run: sudo apt-get install libc6-arm64-cross libgcc-s1-arm64-cross
+        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' }}
+        shell: bash
+
+      - name: Install cargo-deb cross compilation dependencies for armv7
+        run: sudo apt-get install libc6-armhf-cross libgcc-s1-armhf-cross
+        if: ${{ matrix.target == 'armv7-unknown-linux-gnueabihf' }}
+        shell: bash
+
+      - name: Install cargo-deb
+        run: cargo install cargo-deb
+        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' || matrix.target == 'armv7-unknown-linux-gnueabihf' }}
+        shell: bash
+
+      - name: install targets
+        run: rustup target add "${matrix_target}"
+
+      - name: install cross
+        # Install from source to fix `ld: cannot find -lgeom` for freebsd build
+        run: cargo +stable install --git https://github.com/cross-rs/cross cross
+
+      - name: Run clippy
+        run: cross clippy --all-targets --locked --target "${matrix_target}" -- -D warnings
+
+      - name: Run clippy (All features)
+        run: cross clippy  --locked --all-features --target "${matrix_target}" -- -D warnings
+
+      - name: Run tests
+        run: cross test --target "${matrix_target}"
+        # Running tests on FreeBSD is impossible; see https://github.com/cross-rs/cross/wiki/FAQ#running-bsd-tests
+        # Not that this is *NOT* the same as the original issue with `ld: cannot find -lgeom`, but a new issue:
+        # error: test failed, to rerun pass `--lib`
+        # Caused by:
+        #   could not execute process `/target/x86_64-unknown-freebsd/debug/deps/topgrade-9b1670d87ca863dd` (never executed)
+        # Caused by:
+        #   No such file or directory (os error 2)
+        # TODO: I have not tested this in GHA yet, only locally
+        if: ${{ matrix.target != 'x86_64-unknown-freebsd' }}
+
+      # Used `https://github.com/BurntSushi/ripgrep/blob/master/.github/workflows/release.yml`
+      # as a reference.
+      - name: Build debug binary to create release assets
+        shell: bash
+        run: |
+          # This build is not using the target arch since this binary is only needed in CI. It needs
+          # to be the compiled for the runner since it has the run the binary to generate completion
+          # scripts.
+          cargo build --all-features
+          bin="target/debug/topgrade"
+          echo "BIN=$bin" >> $GITHUB_ENV
+
+      - name: Create deployment directory
+        shell: bash
+        run: |
+          dir=deployment/deb
+          mkdir -p "$dir"
+          echo "DEPLOY_DIR=$dir" >> $GITHUB_ENV
+
+      - name: Generate man page and shell completions
+        shell: bash
+        run: |
+          "$BIN" --gen-manpage > "$DEPLOY_DIR/topgrade.1"
+          "$BIN" --gen-completion bash > "$DEPLOY_DIR/topgrade.bash"
+          "$BIN" --gen-completion fish > "$DEPLOY_DIR/topgrade.fish"
+          "$BIN" --gen-completion zsh > "$DEPLOY_DIR/_topgrade"
+
+      - name: Build in Release profile with all features enabled
+        run: cross build --release --all-features --target "${matrix_target}"
+
+      - name: Rename Release
+        run: |
+          mkdir -p assets
+          FILENAME=topgrade-${tag}-${matrix_target}
+          mv "target/${matrix_target}/release/topgrade" assets
+          cd assets
+          tar --format=ustar -czf "$FILENAME.tar.gz" topgrade
+          rm topgrade
+          ls .
+
+      - name: Build Debian-based system package without autoupdate feature
+        # First remove the binary built by previous steps
+        # because we don't want the auto-update feature,
+        # then build the new binary without auto-updating.
+        run: |
+          rm -rf "target/${matrix_target}"
+          cross build --release --target "${matrix_target}"
+          cargo deb --target="${matrix_target}" --no-build --no-strip
+        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' || matrix.target == 'armv7-unknown-linux-gnueabihf' }}
+        shell: bash
+
+      - name: Move Debian-based system package
+        run: |
+          mkdir -p assets
+          mv target/"${matrix_target}"/debian/*.deb assets
+        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' || matrix.target == 'armv7-unknown-linux-gnueabihf' }}
+        shell: bash
+
+
+      - name: Upload assets
+        run:
+          gh release upload "${tag}" assets/*
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate artifact attestations
+        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3.0.0
+        with:
+          subject-path: assets/*
+
+  triggers:
+    runs-on: ubuntu-latest
+    needs: [ native_build, cross_build ]
+    env:
+      tag: ${{ github.event.client_payload.tag }}
+    steps:
+      - name: Trigger workflows
+        run: |
+          gh api "repos/${GITHUB_REPOSITORY}/dispatches" \
+            -f "event_type=release-assets-built" \
+            -F "client_payload[tag]=${tag}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/create_release_assets_cross.yml

@@ -1,97 +0,0 @@
-name: Publish release files for non-cd-native environments
-
-on:
-  # workflow_run:
-  #   workflows: ["Check SemVer compliance"]
-  #   types:
-  #     - completed
-  release:
-    types: [created]
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        target:
-          [
-            "aarch64-unknown-linux-gnu",
-            "armv7-unknown-linux-gnueabihf",
-            "x86_64-unknown-linux-musl",
-            "aarch64-unknown-linux-musl",
-            "x86_64-unknown-freebsd",
-          ]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install cargo-deb cross compilation dependencies
-        run: sudo apt-get install libc6-arm64-cross libgcc-s1-arm64-cross
-        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' }}
-        shell: bash
-
-      - name: Install cargo-deb cross compilation dependencies for armv7
-        run: sudo apt-get install libc6-armhf-cross libgcc-s1-armhf-cross
-        if: ${{ matrix.target == 'armv7-unknown-linux-gnueabihf' }}
-        shell: bash
-
-      - name: Install cargo-deb
-        run: cargo install cargo-deb
-        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' || matrix.target == 'armv7-unknown-linux-gnueabihf' }}
-        shell: bash
-
-      - name: install targets
-        run: rustup target add ${{ matrix.target }}
-
-      - name: install cross
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cross@0.2.5
-
-      - name: Check format
-        run: cross fmt --all -- --check
-
-      - name: Run clippy
-        run: cross clippy --all-targets --locked --target ${{matrix.target}} -- -D warnings
-
-      - name: Run clippy (All features)
-        run: cross clippy  --locked --all-features --target ${{matrix.target}} -- -D warnings
-
-      - name: Run tests
-        run: cross test --target ${{matrix.target}}
-
-      - name: Build in Release profile with all features enabled
-        run: cross build --release --all-features --target ${{matrix.target}}
-
-      - name: Rename Release
-        run: |
-          mkdir -p assets
-          FILENAME=topgrade-${{github.event.release.tag_name}}-${{matrix.target}}
-          mv target/${{matrix.target}}/release/topgrade assets
-          cd assets
-          tar --format=ustar -czf $FILENAME.tar.gz topgrade
-          rm topgrade
-          ls .
-
-      - name: Build Debian-based system package without autoupdate feature
-        # First remove the binary built by previous steps
-        # because we don't want the auto-update feature,
-        # then build the new binary without auto-updating.
-        run: |
-          rm -rf target/${{matrix.target}}
-          cross build --release --target ${{matrix.target}}
-          cargo deb --target=${{matrix.target}} --no-build --no-strip
-        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' || matrix.target == 'armv7-unknown-linux-gnueabihf' }}
-        shell: bash
-
-      - name: Move Debian-based system package
-        run: |
-          mkdir -p assets
-          mv target/${{matrix.target}}/debian/*.deb assets
-        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' || matrix.target == 'armv7-unknown-linux-gnueabihf' }}
-        shell: bash
-
-      - name: Release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: assets/*

.github/workflows/dependency-review.yml

@@ -0,0 +1,25 @@
+# Dependency Review Action
+#
+# This Action will scan dependency manifest files that change as part of a Pull Request,
+# surfacing known-vulnerable versions of the packages declared or updated in the PR.
+# Once installed, if the workflow run is marked as required,
+# PRs introducing known-vulnerable packages will be blocked from merging.
+#
+# Source repository: https://github.com/actions/dependency-review-action
+name: 'Dependency Review'
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  dependency-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout Repository'
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - name: 'Dependency Review'
+        uses: actions/dependency-review-action@3c4e3dcb1aa7874d2c16be7d79418e9b7efd6261 # v4.8.2

.github/workflows/lint_pr.yml

@@ -0,0 +1,19 @@
+name: 'Lint PR'
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - reopened
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    steps:
+      - uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release-plz.yml

@@ -0,0 +1,67 @@
+name: Release-plz
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+
+  # Release unpublished packages.
+  release-plz-release:
+    name: Release-plz release
+    runs-on: ubuntu-latest
+    environment: crates_io
+    permissions:
+      contents: write
+      id-token: write  # For trusted publishing
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        id: release-plz
+        uses: release-plz/action@d529f731ae3e89610ada96eda34e5c6ba3b12214 # v0.5
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Trigger workflows
+        if: steps.release-plz.outputs.releases_created == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ fromJSON(steps.release-plz.outputs.releases)[0].tag }}
+        run: |
+          gh api "repos/${GITHUB_REPOSITORY}/dispatches" \
+            -f "event_type=release-created" \
+            -F "client_payload[tag]=${tag}"
+
+  # Create a PR with the new versions and changelog, preparing the next release.
+  release-plz-pr:
+    name: Release-plz PR
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/action@d529f731ae3e89610ada96eda34e5c6ba3b12214 # v0.5
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release_to_aur.yml

@@ -1,30 +1,37 @@
 name: Publish to AUR
 
 on:
-  # workflow_run:
-  #   workflows: ["Check SemVer compliance"]
-  #   types:
-  #     - completed
-  push:
-    tags:
-      - "v*"
+  repository_dispatch:
+    types: [ release-assets-built ]
+
+permissions:
+  contents: read
 
 jobs:
   aur-publish:
     runs-on: ubuntu-latest
     steps:
+      - name: Determine version
+        id: determine_version
+        env:
+          tag: ${{ github.event.client_payload.tag }}
+        run: |
+          # tag should be something like "v16.0.4", remove the prefix v here
+          echo "version=${tag#v}" >> $GITHUB_OUTPUT
+
       - name: Publish source AUR package
-        uses: aksh1618/update-aur-package@v1.0.5
+        uses: varabyte/update-aur-package@572e31b1972fa289a27b1926c06a489eb89c7fd7
         with:
-          tag_version_prefix: v
+          version: ${{ steps.determine_version.outputs.version }}
           package_name: topgrade
           commit_username: "Thomas Schönauer"
           commit_email: t.schoenauer@hgs-wt.at
           ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+
       - name: Publish binary AUR package
-        uses: aksh1618/update-aur-package@v1.0.5
+        uses: varabyte/update-aur-package@572e31b1972fa289a27b1926c06a489eb89c7fd7
         with:
-          tag_version_prefix: v
+          version: ${{ steps.determine_version.outputs.version }}
           package_name: topgrade-bin
           commit_username: "Thomas Schönauer"
           commit_email: t.schoenauer@hgs-wt.at

.github/workflows/release_to_crates_io.yml

@@ -1,29 +0,0 @@
-on:
-  # workflow_run:
-  #   workflows: ["Check SemVer compliance"]
-  #   types:
-  #     - completed
-  release:
-    types: [published]
-
-name: Publish to crates.io on release
-
-jobs:
-  prepare:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: katyo/publish-crates@v2
-        with:
-          dry-run: true
-          check-repo: ${{ github.event_name == 'push' }}
-          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-          ignore-unpublished-changes: true

.github/workflows/release_to_homebrew.yml

@@ -1,39 +1,22 @@
 name: Publish to Homebrew
 
 on:
-  # workflow_run:
-  #   workflows: ["Check SemVer compliance"]
-  #   types:
-  #     - completed
-  workflow_dispatch:
-  push:
-    tags:
-      - "v*"
+  repository_dispatch:
+    types: [ release-created ]
+
+permissions:
+  contents: read
 
 jobs:
   homebrew-publish:
     runs-on: ubuntu-latest
     steps:
-    - name: Set up Homebrew
-      id: set-up-homebrew
-      uses: Homebrew/actions/setup-homebrew@master
-    - name: Cache Homebrew Bundler RubyGems
-      id: cache
-      uses: actions/cache@v4
-      with:
-        path: ${{ steps.set-up-homebrew.outputs.gems-path }}
-        key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
-        restore-keys: ${{ runner.os }}-rubygems-
-
-    - name: Install Homebrew Bundler RubyGems
-      if: steps.cache.outputs.cache-hit != 'true'
-      run: brew install-bundler-gems
     - name: Bump formulae
-      uses: Homebrew/actions/bump-packages@master
-      continue-on-error: true
+      uses: dawidd6/action-homebrew-bump-formula@3428a0601bba3173ec0bdcc945be23fa27aa4c31 # v5
       with:
         # Custom GitHub access token with only the 'public_repo' scope enabled
         token: ${{secrets.HOMEBREW_ACCESS_TOKEN}}
-        # Bump only these formulae if outdated
-        formulae: |
-          topgrade
+        formula: topgrade
+        tag: ${{ github.event.client_payload.tag }}
+        # We cannot use an org because org forks cannot give push access to maintainers, which Homebrew requires.
+        # org: topgrade-rs

.github/workflows/release_to_pypi.yml

@@ -1,31 +1,34 @@
 name: Update PyPi
 
 on:
-  release:
-    types: [published]
+  repository_dispatch:
+    types: [ release-created ]
 
 permissions:
   contents: read
 
 jobs:
+  # TODO: make linux/windows/macos/sdist a matrix. See how other workflows do it.
   linux:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         target: [x86_64, x86, aarch64]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1.49.4
         with:
           target: ${{ matrix.target }}
           args: --release --out dist
-          sccache: 'true'
           manylinux: auto
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
-          name: wheels
+          name: wheels-linux-${{ matrix.target }}
           path: dist
 
   windows:
@@ -34,17 +37,19 @@ jobs:
       matrix:
         target: [x64, x86]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1.49.4
         with:
           target: ${{ matrix.target }}
           args: --release --out dist
-          sccache: 'true'
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
-          name: wheels
+          name: wheels-windows-${{ matrix.target }}
           path: dist
 
   macos:
@@ -53,47 +58,62 @@ jobs:
       matrix:
         target: [x86_64, aarch64]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1.49.4
         with:
           target: ${{ matrix.target }}
           args: --release --out dist
-          sccache: 'true'
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
-          name: wheels
+          name: wheels-macos-${{ matrix.target }}
           path: dist
 
   sdist:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
       - name: Build sdist
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1.49.4
         with:
           command: sdist
           args: --out dist
       - name: Upload sdist
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
-          name: wheels
+          name: wheels-sdist
           path: dist
 
   release:
     name: Release
     runs-on: ubuntu-latest
-    if: "startsWith(github.ref, 'refs/tags/')"
     needs: [linux, windows, macos, sdist]
+    permissions:
+      # Use to sign the release artifacts
+      id-token: write
+      # Used to upload release artifacts
+      contents: write
+      # Used to generate artifact attestation
+      attestations: write
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3.0.0
         with:
-          name: wheels
+          subject-path: 'wheels-*/*'
+
       - name: Publish to PyPI
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@86b9d133d34bc1b40018696f782949dac11bd380 # v1.49.4
         env:
           MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
         with:
           command: upload
-          args: --skip-existing *
+          args: --non-interactive --skip-existing wheels-*/*

.github/workflows/release_to_winget.yml

@@ -1,13 +1,19 @@
 name: Publish to WinGet
+
 on:
-  release:
-    types: [released]
+  repository_dispatch:
+    types: [ release-created ]
+
+permissions:
+  contents: read
+
 jobs:
   publish:
     runs-on: windows-latest
     steps:
-      - uses: vedantmgoyal2009/winget-releaser@main
+      - uses: vedantmgoyal2009/winget-releaser@19e706d4c9121098010096f9c495a70a7518b30f # main
         with:
+          release-tag: ${{ github.event.client_payload.tag }}
           identifier: topgrade-rs.topgrade
           max-versions-to-keep: 5 # keep only latest 5 versions
-          token: ${{ secrets.WINGET_TOKEN }}
+          token: ${{ secrets.WINGET_TOKEN }}

.github/workflows/scorecards.yml

@@ -0,0 +1,76 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: '20 7 * * 2'
+  push:
+    branches: ["main"]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      contents: read
+      actions: read
+      # To allow GraphQL ListCommits to work
+      issues: read
+      pull-requests: read
+      # To detect SAST tools
+      checks: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # - you are installing Scorecards on a *private* repository
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories:
+          #   - `publish_results` will always be set to `false`, regardless
+          #     of the value entered here.
+          publish_results: true
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
+        with:
+          sarif_file: results.sarif

.pre-commit-config.yaml

@@ -0,0 +1,25 @@
+repos:
+- repo: https://github.com/gitleaks/gitleaks
+  rev: v8.28.0
+  hooks:
+  - id: gitleaks
+
+- repo: https://github.com/shellcheck-py/shellcheck-py
+  rev: v0.11.0.1
+  hooks:
+  - id: shellcheck
+
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v6.0.0
+  hooks:
+  - id: end-of-file-fixer
+  - id: trailing-whitespace
+
+- repo: https://github.com/crate-ci/typos
+  rev: v1.38.1
+  hooks:
+  - id: typos
+
+
+ci:
+  autoupdate_commit_msg: "chore(pre-commit): autoupdate"

.typos.toml

@@ -0,0 +1,20 @@
+# Typos configuration (minimal, conservative)
+# Exclude locales and OS fingerprint data to avoid false positives
+# - Recognize a few project-specific proper nouns
+
+[files]
+extend-exclude = [
+  "src/steps/os/os_release/**",
+  "locales/**",
+  # Include only English locale files - TODO: Split locales/app.yml into a Separate english File
+  # "!locales/en/**"
+]
+
+[default]
+# Mark specific words as always valid by mapping them to themselves
+check-file = true
+check-filename = true
+
+[default.extend-words]
+# Add project-specific terms that should not be flagged as typos
+# Example: topgrade = "topgrade"

BREAKINGCHANGES_dev.md

@@ -0,0 +1,3 @@
+1. The `jet_brains_toolbox` step was renamed to `jetbrains_toolbox`. If you're
+   using the old name in your configuration file in the `disable` or `only`
+   fields, simply change it to `jetbrains_toolbox`.

CHANGELOG.md

@@ -0,0 +1,229 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [16.2.1](https://github.com/topgrade-rs/topgrade/compare/v16.2.0...v16.2.1) - 2025-11-10
+
+### Fixed
+
+- *(release)* Use bash in Windows to fix powershell issues ([#1461](https://github.com/topgrade-rs/topgrade/pull/1461))
+- *(release)* Fix .deb distribution ([#1460](https://github.com/topgrade-rs/topgrade/pull/1460))
+- *(release)* Fix .deb distribution ([#1458](https://github.com/topgrade-rs/topgrade/pull/1458))
+
+## [16.2.0](https://github.com/topgrade-rs/topgrade/compare/v16.1.2...v16.2.0) - 2025-11-10
+
+### Added
+
+- *(mise)* run `mise self-update` ([#1450](https://github.com/topgrade-rs/topgrade/pull/1450))
+- *(falconf)* add falconf step ([#1219](https://github.com/topgrade-rs/topgrade/pull/1219))
+- *(hyprpm)* add hyprpm step ([#1213](https://github.com/topgrade-rs/topgrade/pull/1213))
+- *(doom)* add doom.aot option ([#1214](https://github.com/topgrade-rs/topgrade/pull/1214))
+- add show_distribution_summary config option ([#1259](https://github.com/topgrade-rs/topgrade/pull/1259))
+- *(rustup)* add rustup.channels config ([#1206](https://github.com/topgrade-rs/topgrade/pull/1206))
+- *(os)* add AOSC OS support ([#1424](https://github.com/topgrade-rs/topgrade/pull/1424))
+- add damp run type ([#1217](https://github.com/topgrade-rs/topgrade/pull/1217))
+
+### Fixed
+
+- *(release)* fix homebrew releases by migrating to dawidd6/action-homebrew-bump-formula ([#1457](https://github.com/topgrade-rs/topgrade/pull/1457))
+- *(mise)* fix mise self-update failing when installed via a package manager ([#1456](https://github.com/topgrade-rs/topgrade/pull/1456))
+- *(release)* Add man page to .deb distribution ([#1455](https://github.com/topgrade-rs/topgrade/pull/1455))
+- *(self-update)* fix windows self-update reporting failure on successful self-update ([#1452](https://github.com/topgrade-rs/topgrade/pull/1452))
+- *(pkgfile)* make pkgfile opt-in ([#1449](https://github.com/topgrade-rs/topgrade/pull/1449))
+- *(vcpkg)* fix permission denied when updating vcpkg if it's installed as root ([#1447](https://github.com/topgrade-rs/topgrade/pull/1447))
+- *(zh_TW)* fixed zh_TW strings ([#1446](https://github.com/topgrade-rs/topgrade/pull/1446))
+- *(git)* fix shellexpand::tilde in git_repos in topgrade.d/* ([#1223](https://github.com/topgrade-rs/topgrade/pull/1223))
+- *(auto-cpufreq)* skip when install script is not used ([#1215](https://github.com/topgrade-rs/topgrade/pull/1215))
+- *(vim)* change nvimrc base_dir for windows ([#1433](https://github.com/topgrade-rs/topgrade/pull/1433))
+- *(guix)* fix overcomplicated Guix step ([#1290](https://github.com/topgrade-rs/topgrade/pull/1290))
+- *(gem)* fix incorrectly placed debug message in `gem` step ([#1212](https://github.com/topgrade-rs/topgrade/pull/1212))
+- *(conda)* replace deprecated `auto_activate_base` ([#1158](https://github.com/topgrade-rs/topgrade/pull/1158))
+- *(containers)* fix panic in `containers` step ([#1150](https://github.com/topgrade-rs/topgrade/pull/1150))
+- *(jetbrains-toolbox)* fix step not dry running ([#1253](https://github.com/topgrade-rs/topgrade/pull/1253))
+
+### Other
+
+- comment run_config_update ([#1448](https://github.com/topgrade-rs/topgrade/pull/1448))
+- Expand LLM guidelines in CONTRIBUTING.md ([#1445](https://github.com/topgrade-rs/topgrade/pull/1445))
+- Add AI guidelines to CONTRIBUTING.md ([#1444](https://github.com/topgrade-rs/topgrade/pull/1444))
+- add comments to Config::allowed_steps ([#1291](https://github.com/topgrade-rs/topgrade/pull/1291))
+- *(nix)* Deduplicate run_nix and run_nix_self_upgrade nix --version checking ([#1376](https://github.com/topgrade-rs/topgrade/pull/1376))
+- remove commented-out library code and unnecessary bin declaration ([#1373](https://github.com/topgrade-rs/topgrade/pull/1373))
+- Simplify target cfgs ([#1346](https://github.com/topgrade-rs/topgrade/pull/1346))
+- tidy up binary-conflict code ([#1329](https://github.com/topgrade-rs/topgrade/pull/1329))
+- Improve installation section ([#1442](https://github.com/topgrade-rs/topgrade/pull/1442))
+- *(deps)* Update jetbrains-toolbox-updater ([#1438](https://github.com/topgrade-rs/topgrade/pull/1438))
+- remove template expansion in code contexts ([#1434](https://github.com/topgrade-rs/topgrade/pull/1434))
+- *(deps)* bump github/codeql-action from 4.31.0 to 4.31.2 ([#1427](https://github.com/topgrade-rs/topgrade/pull/1427))
+- don't persist credentials in actions/checkout ([#1422](https://github.com/topgrade-rs/topgrade/pull/1422))
+- Improve CONTRIBUTING.md ([#1420](https://github.com/topgrade-rs/topgrade/pull/1420))
+- Update SECURITY.md ([#1421](https://github.com/topgrade-rs/topgrade/pull/1421))
+- Enforce conventional commits in PR titles ([#1418](https://github.com/topgrade-rs/topgrade/pull/1418))
+- Improve contributing section
+- Remove roadmap
+- Reformat README.md
+- Update installation methods
+- *(release)* Fix dispatch error in create_release_assets.yml ([#1406](https://github.com/topgrade-rs/topgrade/pull/1406))
+
+## [16.1.2](https://github.com/topgrade-rs/topgrade/compare/v16.1.1...v16.1.2) - 2025-11-01
+
+### Fixed
+
+- *(release)* Fix cross-compilation for arm requiring glibc>=2.39 ([#1405](https://github.com/topgrade-rs/topgrade/pull/1405))
+- *(release)* Fix FreeBSD build ([#1404](https://github.com/topgrade-rs/topgrade/pull/1404))
+- *(release)* Fix FreeBSD build ([#1402](https://github.com/topgrade-rs/topgrade/pull/1402))
+- *(release)* Fix manual workflow trigger ([#1401](https://github.com/topgrade-rs/topgrade/pull/1401))
+- *(release)* Fix FreeBSD build and add manual workflow trigger ([#1399](https://github.com/topgrade-rs/topgrade/pull/1399))
+
+### Other
+
+- *(release)* Fix cross trying to fmt ([#1403](https://github.com/topgrade-rs/topgrade/pull/1403))
+
+## [16.1.1](https://github.com/topgrade-rs/topgrade/compare/v16.1.0...v16.1.1) - 2025-11-01
+
+### Fixed
+
+- *(typst)* Skip typst when self-update is disabled ([#1397](https://github.com/topgrade-rs/topgrade/pull/1397))
+- *(release)* Fix winget release workflow ([#1395](https://github.com/topgrade-rs/topgrade/pull/1395))
+- *(release)* Fix FreeBSD release ([#1393](https://github.com/topgrade-rs/topgrade/pull/1393))
+- *(release)* Fix FreeBSD release ([#1391](https://github.com/topgrade-rs/topgrade/pull/1391))
+
+### Other
+
+- Update from deprecated macos-13 to macos-15-intel ([#1394](https://github.com/topgrade-rs/topgrade/pull/1394))
+
+## [16.1.0](https://github.com/topgrade-rs/topgrade/compare/v16.0.4...v16.1.0) - 2025-10-31
+
+### Added
+
+- *(deb-get)* Skip non-deb-get packages by passing --dg-only ([#1386](https://github.com/topgrade-rs/topgrade/pull/1386))
+- *(typst)* add typst step ([#1374](https://github.com/topgrade-rs/topgrade/pull/1374))
+- *(step)* Add atuin step ([#1367](https://github.com/topgrade-rs/topgrade/pull/1367))
+- *(nix)* support upgrading Determinate Nix ([#1366](https://github.com/topgrade-rs/topgrade/pull/1366))
+- *(sudo)* print warning if Windows Sudo is misconfigured
+- *(sudo)* print warning if steps were skipped due to missing sudo
+- *(sudo)* add SudoKind::Null
+- detect and warn if running as root
+- add `--no-tmux` flag ([#1328](https://github.com/topgrade-rs/topgrade/pull/1328))
+- add step for mandb - user and system (update man entries) ([#1319](https://github.com/topgrade-rs/topgrade/pull/1319))
+- support for pkgfile ([#1306](https://github.com/topgrade-rs/topgrade/pull/1306))
+- add "show_skipped" option in config file #1280 ([#1286](https://github.com/topgrade-rs/topgrade/pull/1286))
+- fix typos ([#1221](https://github.com/topgrade-rs/topgrade/pull/1221))
+- *(conda)* allow configuring additional envs to update ([#1048](https://github.com/topgrade-rs/topgrade/pull/1048))
+- *(step)* nix-helper ([#1045](https://github.com/topgrade-rs/topgrade/pull/1045))
+- *(winget)* winget uses sudo when `[windows] winget_use_sudo = true` ([#1061](https://github.com/topgrade-rs/topgrade/pull/1061))
+- suppress pixi release notes by default ([#1225](https://github.com/topgrade-rs/topgrade/pull/1225))
+
+### Fixed
+
+- *(freshclam)* run with sudo when running without sudo fails ([#1118](https://github.com/topgrade-rs/topgrade/pull/1118))
+- *(tldr)* move tldr to be a generic step ([#1370](https://github.com/topgrade-rs/topgrade/pull/1370))
+- *(nix)* fix nix upgrade command selection for profiles in XDG_STATE_HOME ([#1354](https://github.com/topgrade-rs/topgrade/pull/1354))
+- *(containers)* Docker update fails on M Macs due to platform / ([#1360](https://github.com/topgrade-rs/topgrade/pull/1360))
+- *(sudo)* reorder require_sudo() after print_separator()
+- *(sudo)* use require_sudo for windows commands
+- *(sudo)* prevent sudo_command = "sudo" finding gsudo
+- *(sudo)* set sudo flags depending on kind
+- skip gcloud update step if component manager is disabled ([#1237](https://github.com/topgrade-rs/topgrade/pull/1237))
+- *(i18n)* use double-quotes for translations with newlines
+- *(powershell)* run microsoft_store command directly
+- *(powershell)* remove mentions of USOClient
+- *(powershell)* execution policy check breaks when run in pwsh
+- *(powershell)* don't use sudo with Update-Module for pwsh
+- *(powershell)* add -Command to module update cmdline
+- *(tmux)* support all default `tpm` locations (xdg and both hardcoded locations) ([#1146](https://github.com/topgrade-rs/topgrade/pull/1146))
+- fixed the German translation for "y/n/s/q" ([#1220](https://github.com/topgrade-rs/topgrade/pull/1220))
+
+### Other
+
+- *(release)* switch to release-plz ([#1333](https://github.com/topgrade-rs/topgrade/pull/1333))
+- *(pre-commit)* Make pre-commit.ci use conventional commits ([#1388](https://github.com/topgrade-rs/topgrade/pull/1388))
+- *(pre-commit)* pre-commit autoupdate ([#1383](https://github.com/topgrade-rs/topgrade/pull/1383))
+- *(deps)* bump actions/upload-artifact from 4.6.2 to 5.0.0 ([#1382](https://github.com/topgrade-rs/topgrade/pull/1382))
+- *(deps)* bump github/codeql-action from 4.30.9 to 4.31.0 ([#1379](https://github.com/topgrade-rs/topgrade/pull/1379))
+- *(deps)* bump actions/download-artifact from 5.0.0 to 6.0.0 ([#1380](https://github.com/topgrade-rs/topgrade/pull/1380))
+- *(deps)* bump taiki-e/install-action from 2.62.33 to 2.62.38 ([#1381](https://github.com/topgrade-rs/topgrade/pull/1381))
+- *(pre-commit)* Fix pre-commit-config.yaml ([#1378](https://github.com/topgrade-rs/topgrade/pull/1378))
+- *(release)* Add .deb auto completion script ([#1353](https://github.com/topgrade-rs/topgrade/pull/1353))
+- *(deps)* bump github/codeql-action from 4.30.8 to 4.30.9 ([#1369](https://github.com/topgrade-rs/topgrade/pull/1369))
+- *(deps)* bump taiki-e/install-action from 2.62.28 to 2.62.33 ([#1368](https://github.com/topgrade-rs/topgrade/pull/1368))
+- *(deps)* bump actions/dependency-review-action from 4.8.0 to 4.8.1 ([#1362](https://github.com/topgrade-rs/topgrade/pull/1362))
+- *(deps)* bump softprops/action-gh-release from 2.3.4 to 2.4.1 ([#1364](https://github.com/topgrade-rs/topgrade/pull/1364))
+- *(deps)* bump taiki-e/install-action from 2.62.21 to 2.62.28 ([#1363](https://github.com/topgrade-rs/topgrade/pull/1363))
+- *(deps)* bump github/codeql-action from 3.30.6 to 4.30.8 ([#1365](https://github.com/topgrade-rs/topgrade/pull/1365))
+- *(deps)* bump github/codeql-action from 3.30.5 to 3.30.6 ([#1355](https://github.com/topgrade-rs/topgrade/pull/1355))
+- *(deps)* bump softprops/action-gh-release from 2.3.3 to 2.3.4 ([#1356](https://github.com/topgrade-rs/topgrade/pull/1356))
+- *(deps)* bump taiki-e/install-action from 2.62.13 to 2.62.21 ([#1357](https://github.com/topgrade-rs/topgrade/pull/1357))
+- *(deps)* bump ossf/scorecard-action from 2.4.2 to 2.4.3 ([#1358](https://github.com/topgrade-rs/topgrade/pull/1358))
+- *(deps)* bump actions/dependency-review-action from 4.7.3 to 4.8.0 ([#1350](https://github.com/topgrade-rs/topgrade/pull/1350))
+- *(deps)* bump github/codeql-action from 3.30.3 to 3.30.5 ([#1349](https://github.com/topgrade-rs/topgrade/pull/1349))
+- *(deps)* bump taiki-e/install-action from 2.62.1 to 2.62.13 ([#1351](https://github.com/topgrade-rs/topgrade/pull/1351))
+- *(deps)* bump actions/cache from 4.2.4 to 4.3.0 ([#1352](https://github.com/topgrade-rs/topgrade/pull/1352))
+- Fix WSL distribution name cleanup ([#1348](https://github.com/topgrade-rs/topgrade/pull/1348))
+- *(pyproject)* mark version as dynamic ([#1347](https://github.com/topgrade-rs/topgrade/pull/1347))
+- *(deps)* replace winapi with windows
+- *(sudo)* rename interactive to login_shell
+- Fix "WSL already reported" panic ([#1344](https://github.com/topgrade-rs/topgrade/pull/1344))
+- Move step logic out of Powershell struct ([#1345](https://github.com/topgrade-rs/topgrade/pull/1345))
+- *(deps)* bump taiki-e/install-action from 2.61.5 to 2.62.1 ([#1335](https://github.com/topgrade-rs/topgrade/pull/1335))
+- *(deps)* bump Swatinem/rust-cache from 2.8.0 to 2.8.1 ([#1336](https://github.com/topgrade-rs/topgrade/pull/1336))
+- Fixes for #1188; custom_commands broken  ([#1332](https://github.com/topgrade-rs/topgrade/pull/1332))
+- use login shell when executing topgrade ([#1327](https://github.com/topgrade-rs/topgrade/pull/1327))
+- *(deps)* bump taiki-e/install-action from 2.60.0 to 2.61.5 ([#1325](https://github.com/topgrade-rs/topgrade/pull/1325))
+- *(deps)* bump github/codeql-action from 3.30.1 to 3.30.3 ([#1324](https://github.com/topgrade-rs/topgrade/pull/1324))
+- *(pre-commit)* add typos with conservative excludes; no content changes ([#1317](https://github.com/topgrade-rs/topgrade/pull/1317))
+- fix simple typos in code and comments (split var, whether, Extensions) ([#1318](https://github.com/topgrade-rs/topgrade/pull/1318))
+- *(deps)* bump github/codeql-action from 3.29.11 to 3.30.1 ([#1301](https://github.com/topgrade-rs/topgrade/pull/1301))
+- *(deps)* bump softprops/action-gh-release from 2.3.2 to 2.3.3 ([#1302](https://github.com/topgrade-rs/topgrade/pull/1302))
+- *(deps)* bump taiki-e/install-action from 2.58.21 to 2.60.0 ([#1303](https://github.com/topgrade-rs/topgrade/pull/1303))
+- *(deps)* bump actions/dependency-review-action from 4.7.2 to 4.7.3 ([#1304](https://github.com/topgrade-rs/topgrade/pull/1304))
+- *(deps)* bump actions/attest-build-provenance from 2.4.0 to 3.0.0 ([#1305](https://github.com/topgrade-rs/topgrade/pull/1305))
+- update tracing-subscriber to ~0.3.20 (ANSI escape injection fix, GHSA-xwfj-jgwm-7wp5) ([#1288](https://github.com/topgrade-rs/topgrade/pull/1288))
+- *(deps)* bump github/codeql-action from 3.29.8 to 3.29.11 ([#1281](https://github.com/topgrade-rs/topgrade/pull/1281))
+- *(deps)* bump actions/dependency-review-action from 4.7.1 to 4.7.2 ([#1282](https://github.com/topgrade-rs/topgrade/pull/1282))
+- *(deps)* bump taiki-e/install-action from 2.58.9 to 2.58.21 ([#1283](https://github.com/topgrade-rs/topgrade/pull/1283))
+- *(deps)* bump PyO3/maturin-action from 1.49.3 to 1.49.4 ([#1285](https://github.com/topgrade-rs/topgrade/pull/1285))
+- *(deps)* bump actions/cache from 4.2.3 to 4.2.4 ([#1284](https://github.com/topgrade-rs/topgrade/pull/1284))
+- Support "Insiders" versions of VSCode and VSCodium ([#1279](https://github.com/topgrade-rs/topgrade/pull/1279))
+- Sudo preserve env list argument is `--preserve-env` ([#1276](https://github.com/topgrade-rs/topgrade/pull/1276))
+- Clippy fixes from rust 1.91 nightly ([#1267](https://github.com/topgrade-rs/topgrade/pull/1267))
+- *(deps)* bump actions/checkout from 4.2.2 to 5.0.0 ([#1264](https://github.com/topgrade-rs/topgrade/pull/1264))
+- *(deps)* bump actions/download-artifact from 4.3.0 to 5.0.0 ([#1263](https://github.com/topgrade-rs/topgrade/pull/1263))
+- *(deps)* bump taiki-e/install-action from 2.58.0 to 2.58.9 ([#1261](https://github.com/topgrade-rs/topgrade/pull/1261))
+- *(deps)* bump ossf/scorecard-action from 2.4.0 to 2.4.2 ([#1262](https://github.com/topgrade-rs/topgrade/pull/1262))
+- *(deps)* bump github/codeql-action from 3.29.5 to 3.29.8 ([#1265](https://github.com/topgrade-rs/topgrade/pull/1265))
+- *(ci)* Dependabot, workflow security ([#1257](https://github.com/topgrade-rs/topgrade/pull/1257))
+- replace once_cell crate with std equivalent ([#1260](https://github.com/topgrade-rs/topgrade/pull/1260))
+- *(deps)* bump tokio from 1.38 to 1.47 ([#1256](https://github.com/topgrade-rs/topgrade/pull/1256))
+- *(app.yml)* fix fr language #1248
+- *(sudo)* add SudoKind::WinSudo
+- *(sudo)* add SudoExecuteOpts builder functions and preserve_env enum
+- *(yarn)* remove unnecessary Yarn::yarn field
+- *(apt)* extract detect_apt() function
+- route sudo usage through Sudo::execute*
+- move RunType::execute to ExecutionContext
+- *(powershell)* store powershell path directly
+- *(powershell)* cleanup and simplify code
+- Move step running into enum for dynamic ordering ([#1188](https://github.com/topgrade-rs/topgrade/pull/1188))
+- Generate artifact attestations for release assets ([#1216](https://github.com/topgrade-rs/topgrade/pull/1216))
+- windows update, use explicit reboot policy ([#1143](https://github.com/topgrade-rs/topgrade/pull/1143))
+- add Discord invite link to README ([#1203](https://github.com/topgrade-rs/topgrade/pull/1203))
+- Catch secondary uv self-update error ([#1201](https://github.com/topgrade-rs/topgrade/pull/1201))
+- Handle another format change in asdf version ([#1194](https://github.com/topgrade-rs/topgrade/pull/1194))
+- Preserve custom command order from config instead of sorting alphabetically ([#1182](https://github.com/topgrade-rs/topgrade/pull/1182))
+- Add support for multiple binary names and idea having multiple binaries ([#1167](https://github.com/topgrade-rs/topgrade/pull/1167))
+- fix the invalid action version ([#1185](https://github.com/topgrade-rs/topgrade/pull/1185))
+- allow us to re-run AUR CI ([#1184](https://github.com/topgrade-rs/topgrade/pull/1184))
+- Update Yazi upgrade step to use ya pkg. ([#1163](https://github.com/topgrade-rs/topgrade/pull/1163))
+- use the new tag name and specify shell to bash ([#1183](https://github.com/topgrade-rs/topgrade/pull/1183))
+- allow specifying tag when manually run 'create_release_assets.yml' ([#1180](https://github.com/topgrade-rs/topgrade/pull/1180))
+- fix homebrew ci, remove duplicate trigger event ([#1179](https://github.com/topgrade-rs/topgrade/pull/1179))
+- fix PyPI pipeline duplicate wheel name ([#1178](https://github.com/topgrade-rs/topgrade/pull/1178))
+- add event workflow_dispatch to release pipelines ([#1177](https://github.com/topgrade-rs/topgrade/pull/1177))
+- fix pipeline release to PyPI ([#1176](https://github.com/topgrade-rs/topgrade/pull/1176))
+- Install rustfmt and clippy where necessary ([#1171](https://github.com/topgrade-rs/topgrade/pull/1171))

CONTRIBUTING.md

@@ -7,24 +7,47 @@ We welcome and encourage contributions of all kinds, such as:
 2. Documentation improvements
 3. Code (PR or PR Review)
 
-Please follow the [Karma Runner guidelines](http://karma-runner.github.io/6.2/dev/git-commit-msg.html)
-for commit messages.
+### LLM/AI guidelines
 
-## Adding a new `step`
+You may use LLMs (AI tools) for:
 
-In `topgrade`'s term, package manager is called `step`.
-To add a new `step` to `topgrade`:
+* Inspiration, problem solving, help with Rust, translation, etc.
+* Generating small and self-contained snippets of code (e.g., shell scripts or utility functions)
+
+Do **not** use LLMs to:
+
+* Generate ("vibe code") entire pull requests
+* Write or generate issue or pull request descriptions
+
+### General guidelines
+
+**Please use [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) for your PR title**.
+
+We use [pre-commit](https://github.com/pre-commit/pre-commit). It runs in CI, but you can optionally install the hook
+locally with `pre-commit install`. If you don't want to use pre-commit, make sure the following pass before submitting
+your PR:
+
+```shell
+$ cargo fmt
+$ cargo clippy
+$ cargo test
+```
+
+### Adding a new step
+
+In `topgrade`'s terms, a package manager (or something else that can be upgraded) is called a step.
+To add a new step to `topgrade`:
 
 1. Add a new variant to
-   [`enum Step`](https://github.com/topgrade-rs/topgrade/blob/cb7adc8ced8a77addf2cb051d18bba9f202ab866/src/config.rs#L100)
+   [`enum Step`](https://github.com/topgrade-rs/topgrade/blob/main/src/step.rs)
 
    ```rust
    pub enum Step {
-       // Existed steps
+       // Existing steps
        // ...
 
        // Your new step here!
-       // You may want it to be sorted alphabetically because that looks great:)
+       // Make sure it stays sorted alphabetically because that looks great :)
        Xxx,
    }
    ```
@@ -32,9 +55,10 @@ To add a new `step` to `topgrade`:
 2. Implement the update function
 
    You need to find the appropriate location where this update function goes, it should be
-   a file under [`src/steps`](https://github.com/topgrade-rs/topgrade/tree/master/src/steps),
-   the file names are self-explanatory, for example, `step`s related to `zsh` are
-   placed in [`steps/zsh.rs`](https://github.com/topgrade-rs/topgrade/blob/master/src/steps/zsh.rs).
+   a file under [`src/steps`](https://github.com/topgrade-rs/topgrade/tree/main/src/steps),
+   the file names are self-explanatory, for example, steps related to `zsh` are
+   placed in [`steps/zsh.rs`](https://github.com/topgrade-rs/topgrade/blob/main/src/steps/zsh.rs), and steps that run on
+   Linux only are placed in [`steps/linux.rs`](https://github.com/topgrade-rs/topgrade/blob/main/src/steps/linux.rs).
 
    Then you implement the update function, and put it in the file where it belongs.
 
@@ -47,38 +71,35 @@ To add a new `step` to `topgrade`:
        print_separator("xxx");
 
        // Invoke the new step to get things updated!
-       ctx.run_type()
-          .execute(xxx)
+       ctx.execute(xxx)
           .arg(/* args required by this step */)
           .status_checked()
    }
    ```
 
-   Such a update function would be conventionally named `run_xxx()`, where `xxx`
-   is the name of the new step, and it should take a argument of type
-   `&ExecutionContext`, this is adequate for most cases unless some extra stuff is
-   needed (You can find some examples where extra arguments are needed
-   [here](https://github.com/topgrade-rs/topgrade/blob/7e48c5dedcfd5d0124bb9f39079a03e27ed23886/src/main.rs#L201-L219)).
+   Such an update function would be conventionally named `run_xxx()`, where `xxx`
+   is the name of the new step, and it should take an argument of type
+   `&ExecutionContext`.
 
-   Update function would usually do 3 things:
-   1. Check if the step is installed
-   2. Output the Separator
-   3. Invoke the step
+   The update function should usually do 3 things:
+    1. Check if the step is installed
+    2. Output the separator
+    3. Execute commands
 
-   Still, this is sufficient for most tools, but you may need some extra stuff
-   with complicated `step`.
+   This is sufficient for most tools, but you may need some extra stuff
+   for complicated steps.
 
-3. Finally, invoke that update function in `main.rs`
+3. Add a match arm to `Step::run()`
 
    ```rust
-   runner.execute(Step::Xxx, "xxx", || ItsModule::run_xxx(&ctx))?;
+   Xxx => runner.execute(*self, "xxx", || ItsModule::run_xxx(ctx))?
    ```
 
    We use [conditional compilation](https://doc.rust-lang.org/reference/conditional-compilation.html)
-   to separate the steps, for example, for steps that are Linux-only, it goes
+   to separate the steps. For example, for steps that are Linux-only, it goes
    like this:
 
-   ```
+   ```rust
    #[cfg(target_os = "linux")]
    {
        // Xxx is Linux-only
@@ -86,25 +107,31 @@ To add a new `step` to `topgrade`:
    }
    ```
 
-   Congrats, you just added a new `step`:)
+4. Finally, add the step to `default_steps()` in `step.rs`
+   ```rust
+   steps.push(Xxx)
+   ```
+   Keep the conditional compilation the same as in the above step 3.
 
-## Modification to the configuration entries
+   Congrats, you just added a new step :)
+
+### Modification to the configuration entries
 
 If your PR has the configuration options
-(in [`src/config.rs`](https://github.com/topgrade-rs/topgrade/blob/master/src/config.rs))
+(in [`src/config.rs`](https://github.com/topgrade-rs/topgrade/blob/main/src/config.rs))
 modified:
 
 1. Adding new options
 2. Changing the existing options
 
 Be sure to apply your changes to
-[`config.example.toml`](https://github.com/topgrade-rs/topgrade/blob/master/config.example.toml),
+[`config.example.toml`](https://github.com/topgrade-rs/topgrade/blob/main/config.example.toml),
 and have some basic documentations guiding user how to use these options.
 
-## Breaking changes
+### Breaking changes
 
-If your PR introduces a breaking change, document it in [`BREAKINGCHANGES_dev.md`][bc_dev],
-it should be written in Markdown and wrapped at 80, for example:
+If your PR introduces a breaking change, document it in [`BREAKINGCHANGES_dev.md`][bc_dev].
+It should be written in Markdown and wrapped at 80, for example:
 
 ```md
 1. The configuration location has been updated to x.
@@ -116,55 +143,40 @@ it should be written in Markdown and wrapped at 80, for example:
 
 [bc_dev]: https://github.com/topgrade-rs/topgrade/blob/main/BREAKINGCHANGES_dev.md
 
-## Before you submit your PR
+### I18n
 
-Make sure your patch passes the following tests on your host:
-
-```shell
-$ cargo build
-$ cargo fmt
-$ cargo clippy
-$ cargo test
-```
-
-Don't worry about other platforms, we have most of them covered in our CI.
-
-## I18n 
-
-If your PR introduces user-facing messages, we need to ensure they are translated. 
-Please add the translations to [`locales/app.yml`][app_yml]. For simple messages 
-without arguments (e.g., "hello world"), we can simply translate them according 
-(Tip: ChatGPT or similar LLMs is good at translation). If a message contains 
+If your PR introduces user-facing messages, we need to ensure they are translated.
+Please add the translations to [`locales/app.yml`][app_yml]. For simple messages
+without arguments (e.g., "hello world"), we can simply translate them according
+(Tip: LLMs are good at translation). If a message contains
 arguments, e.g., "hello <NAME>", please follow this convention:
 
 ```yml
-"hello {name}":        # key
+"hello {name}": # key
   en: "hello %{name}"  # translation
 ```
 
 Arguments in the key should be in format `{argument_name}`, and they will have
-a preceeding `%` when used in translations.
+a preceding `%` when used in translations.
 
 [app_yml]: https://github.com/topgrade-rs/topgrade/blob/main/locales/app.yml
 
-## Some tips
+### Locales
 
-1. Locale
+Some steps respect locale, which means their output can be in language other
+than English. In those cases, we cannot rely on the output of a command.
 
-   Some `step` respects locale, which means their output can be in language other
-   than English, we should not do check on it.
+For example, one may want to check if a tool works by doing this:
 
-   For example, one may want to check if a tool works by doing this:
+```rust
+let output = Command::new("xxx").arg("--help").output().unwrap();
+let stdout = from_utf8(output.stdout).expect("Assume it is UTF-8 encoded");
 
-   ```rust
-   let output = Command::new("xxx").arg("--help").output().unwrap();
-   let stdout = from_utf8(output.stdout).expect("Assume it is UTF-8 encoded");
+if stdout.contains("help") {
+// xxx works
+}
+```
 
-   if stdout.contains("help") {
-       // xxx works
-   }
-   ```
-
-   If `xxx` respects locale, then the above code should work on English system,
-   on a system that does not use English, e.g., it uses Chinese, that `"help"` may be
-   translated to `"帮助"`, and the above code won't work.
+If `xxx` respects locale, then the above code should work on English system,
+on a system that does not use English, e.g., it uses Chinese, that `"help"` may be
+translated to `"帮助"`, and the above code won't work.

Cargo.toml

@@ -6,24 +6,16 @@ keywords = ["upgrade", "update"]
 license = "GPL-3.0"
 repository = "https://github.com/topgrade-rs/topgrade"
 rust-version = "1.84.1"
-version = "16.0.3"
+version = "16.2.1"
 authors = ["Roey Darwish Dror <roey.ghost@gmail.com>", "Thomas Schönauer <t.schoenauer@hgs-wt.at>"]
 exclude = ["doc/screenshot.gif", "BREAKINGCHANGES_dev.md"]
 edition = "2021"
 
 readme = "README.md"
 
-[[bin]]
-name = "topgrade"
-path = "src/main.rs"
-
-##[lib]
-##name = "topgrade_lib"
-
 [dependencies]
-home = "~0.5"
+home = "~0.5,<0.5.11"
 etcetera = "~0.8"
-once_cell = "~1.19"
 serde = { version = "~1.0", features = ["derive"] }
 toml = "0.8"
 which_crate = { version = "~6.0", package = "which" }
@@ -33,28 +25,33 @@ clap_complete = "~4.5"
 clap_mangen = "~0.2"
 walkdir = "~2.5"
 console = "~0.15"
-lazy_static = "~1.4"
 chrono = "~0.4"
 glob = "~0.3"
 strum = { version = "~0.26", features = ["derive"] }
 thiserror = "~1.0"
 tempfile = "~3.10"
 cfg-if = "~1.0"
-tokio = { version = "~1.38", features = ["process", "rt-multi-thread"] }
+tokio = { version = "~1.47", features = ["process", "rt-multi-thread"] }
 futures = "~0.3"
 regex = "~1.10"
 semver = "~1.0"
 shell-words = "~1.1"
 color-eyre = "~0.6"
 tracing = { version = "~0.1", features = ["attributes", "log"] }
-tracing-subscriber = { version = "~0.3", features = ["env-filter", "time"] }
+tracing-subscriber = { version = "~0.3.20", features = ["env-filter", "time"] }
 merge = "~0.1"
 regex-split = "~0.1"
 notify-rust = "~4.11"
 wildmatch = "2.3.0"
 rust-i18n = "3.0.1"
 sys-locale = "0.3.1"
-jetbrains-toolbox-updater = "1.1.0"
+jetbrains-toolbox-updater = "5.0.0"
+indexmap = { version = "2.9.0", features = ["serde"] }
+serde_json = "1.0.145"
+# Temporary transitive dependency pins
+ignore = "=0.4.25"
+globset = "=0.4.16"
+base64ct = "<1.8.0"
 
 [package.metadata.generate-rpm]
 assets = [{ source = "target/release/topgrade", dest = "/usr/bin/topgrade" }]
@@ -72,6 +69,16 @@ extended-description = "Keeping your system up to date usually involves invoking
 section = "utils"
 priority = "optional"
 default-features = true
+assets = [
+  ["target/release/topgrade", "usr/bin/", "755"],
+  ["README.md", "usr/share/doc/topgrade/README.md", "644"],
+  # The man page and shell completions are automatically generated by topgrade's build process in CI,
+  # so these files aren't actually committed.
+  ["deployment/deb/topgrade.1", "usr/share/man/man1/topgrade.1", "644"],
+  ["deployment/deb/topgrade.bash", "usr/share/bash-completion/completions/topgrade", "644"],
+  ["deployment/deb/topgrade.fish", "usr/share/fish/vendor_completions.d/topgrade.fish", "644"],
+  ["deployment/deb/_topgrade", "usr/share/zsh/vendor-completions/", "644"],
+]
 
 [target.'cfg(unix)'.dependencies]
 nix = { version = "~0.29", features = ["hostname", "signal", "user"] }
@@ -79,9 +86,11 @@ rust-ini = "~0.21"
 self_update_crate = { version = "~0.40", default-features = false, optional = true, package = "self_update", features = ["archive-tar", "compression-flate2", "rustls"] }
 
 [target.'cfg(windows)'.dependencies]
-self_update_crate = { version = "~0.40", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
-winapi = "~0.3"
+is_elevated = "~0.1"
 parselnk = "~0.1"
+self_update_crate = { version = "~0.40", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
+windows = { version = "~0.62", features = ["Win32_System_Console"] }
+windows-registry = "~0.6"
 
 [profile.release]
 lto = true

README.md

@@ -2,7 +2,7 @@
   <h1>
     <img alt="Topgrade" src="doc/topgrade_transparent.png" width="850px">
   </h1>
-  
+
   <a href="https://github.com/topgrade-rs/topgrade/releases"><img alt="GitHub Release" src="https://img.shields.io/github/release/topgrade-rs/topgrade.svg"></a>
   <a href="https://crates.io/crates/topgrade"><img alt="crates.io" src="https://img.shields.io/crates/v/topgrade.svg"></a>
   <a href="https://aur.archlinux.org/packages/topgrade"><img alt="AUR" src="https://img.shields.io/aur/version/topgrade.svg"></a>
@@ -11,7 +11,6 @@
   <img alt="Demo" src="doc/topgrade_demo.gif">
 </div>
 
-
 ## Introduction
 
 > **Note**
@@ -25,33 +24,45 @@ To remedy this, **Topgrade** detects which tools you use and runs the appropriat
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/topgrade.svg)](https://repology.org/project/topgrade/versions)
 
-- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade)
-- NixOS: [Nixpkgs](https://search.nixos.org/packages?show=topgrade)
-- Void Linux: [XBPS](https://voidlinux.org/packages/?arch=x86_64&q=topgrade)
-- macOS: [Homebrew](https://formulae.brew.sh/formula/topgrade) or [MacPorts](https://ports.macports.org/port/topgrade/)
-- Windows: [Chocolatey][choco], [Scoop][scoop] or [Winget][winget]
-- PyPi: [pip](https://pypi.org/project/topgrade/)
-- Fedora: [Copr](https://copr.fedorainfracloud.org/coprs/lilay/topgrade/)
+### Official
 
-[choco]: https://community.chocolatey.org/packages/topgrade
-[scoop]: https://scoop.sh/#/apps?q=topgrade
-[winget]: https://winstall.app/apps/topgrade-rs.topgrade
+- Self-updating binary (all platforms): [releases](https://github.com/topgrade-rs/topgrade/releases)
+- Install from source (all platforms): [`cargo install topgrade`](https://crates.io/crates/topgrade)
+- Debian/Ubuntu ([deb-get](https://github.com/wimpysworld/deb-get)):
+  [`deb-get install topgrade`](https://github.com/wimpysworld/deb-get/blob/main/01-main/packages/topgrade)
+- Arch Linux (AUR): [topgrade](https://aur.archlinux.org/packages/topgrade)
+  or [topgrade-bin](https://aur.archlinux.org/packages/topgrade-bin)
+- [PyPi](https://pypi.org/): `pip`, `pipx`, or `uv tool` [
+  `install topgrade`](https://pypi.org/project/topgrade/)
+- Windows ([Winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/)): [
+  `winget install --id=topgrade-rs.topgrade  -e`](https://winstall.app/apps/topgrade-rs.topgrade)
+- macOS or Linux ([Homebrew](https://brew.sh/)): [`brew install topgrade`](https://formulae.brew.sh/formula/topgrade)
 
-Other systems users can either use `cargo install` or the compiled binaries from the release page.
-The compiled binaries contain a self-upgrading feature.
+### Community-maintained
+
+- Windows ([Chocolatey](https://chocolatey.org/)): [
+  `choco install topgrade`](https://community.chocolatey.org/packages/topgrade)
+- Windows ([Scoop](https://scoop.sh/)): [
+  `scoop bucket add main && scoop install main/topgrade`](https://scoop.sh/#/apps?q=topgrade)
+- macOS ([MacPorts](https://www.macports.org/)): [
+  `sudo port install topgrade`](https://ports.macports.org/port/topgrade/)
+- Fedora ([Copr](https://copr.fedorainfracloud.org/)): [
+  `dnf copr enable lilay/topgrade && dnf install topgrade`](https://copr.fedorainfracloud.org/coprs/lilay/topgrade/)
+- NixOS or Nix (nixpkgs): [topgrade](https://search.nixos.org/packages?show=topgrade)
+- Void Linux: [`sudo xbps-install -S topgrade`](https://voidlinux.org/packages/?arch=x86_64&q=topgrade)
 
 ## Usage
 
 Just run `topgrade`.
 
-## Configuration 
+## Configuration
 
 See `config.example.toml` for an example configuration file.
 
 ## Migration and Breaking Changes
 
 Whenever there is a **breaking change**, the major version number will be bumped,
-and we will document these changes in the release note, please take a look at 
+and we will document these changes in the release note, please take a look at
 it when updated to a major release.
 
 > Got a question? Feel free to open an issue or discussion!
@@ -59,6 +70,7 @@ it when updated to a major release.
 ### Configuration Path
 
 #### `CONFIG_DIR` on each platform
+
 - **Windows**: `%APPDATA%`
 - **macOS** and **other Unix systems**: `${XDG_CONFIG_HOME:-~/.config}`
 
@@ -67,16 +79,21 @@ it when updated to a major release.
 1. `CONFIG_DIR/topgrade.toml`
 2. `CONFIG_DIR/topgrade/topgrade.toml`
 
-If the file with higher priority is present, no matter it is valid or not, the other configuration files will be ignored.
+If the file with higher priority is present, no matter it is valid or not, the other configuration files will be
+ignored.
 
-On the first run(no configuration file exists), `topgrade` will create a configuration file at `CONFIG_DIR/topgrade.toml` for you.
+On the first run(no configuration file exists), `topgrade` will create a configuration file at
+`CONFIG_DIR/topgrade.toml` for you.
 
 ### Custom Commands
 
-Custom commands can be defined in the config file which can be run before, during, or after the inbuilt commands, as required.
-By default, the custom commands are run using a new shell according to the `$SHELL` environment variable on unix (falls back to `sh`) or `pwsh` on windows (falls back to `powershell`).
+Custom commands can be defined in the config file which can be run before, during, or after the inbuilt commands, as
+required.
+By default, the custom commands are run using a new shell according to the `$SHELL` environment variable on unix (falls
+back to `sh`) or `pwsh` on windows (falls back to `powershell`).
 
-On unix, if you want to run your command using an interactive shell, for example to source your shell's rc files, you can add `-i` at the start of your custom command.
+On unix, if you want to run your command using an interactive shell, for example to source your shell's rc files, you
+can add `-i` at the start of your custom command.
 But note that this requires the command to exit the shell correctly or else the shell will hang indefinitely.
 
 ## Remote Execution
@@ -95,18 +112,14 @@ Open a new issue describing your problem and if possible provide a solution.
 ### Missing a feature or found an unsupported tool/distro?
 
 Just let us now what you are missing by opening an issue.
-For tools, please open an issue describing the tool, which platforms it supports and if possible, give us an example of its usage.
+For tools, please open an issue describing the tool, which platforms it supports and if possible, give us an example of
+its usage.
 
-### Want to contribute to the code?
-
-Just fork the repository and start coding.
-
-### Contribution Guidelines
+### Want to contribute?
 
 See [CONTRIBUTING.md](https://github.com/topgrade-rs/topgrade/blob/master/CONTRIBUTING.md)
 
-## Roadmap
+## Discord server
 
-- [ ] Add a proper testing framework to the code base.
-- [ ] Add unit tests for package managers.
-- [ ] Split up code into more maintainable parts, eg. putting every linux package manager in a own submodule of linux.rs.
+Welcome to [join](https://discord.gg/Q8HGGWundY) our Discord server if you want
+to discuss Topgrade!

RELEASE_PROCEDURE.md

@@ -1,19 +1,14 @@
-> This document lists the steps that lead to a successful release of Topgrade.
-
-1. Open a PR that:
-   
-   > Here is an [Example PR](https://github.com/topgrade-rs/topgrade/pull/652) 
-   > that you can refer to.
+Non-major versions go via release-plz.
 
    1. bumps the version number.
 
       > If there are breaking changes, the major version number should be increased.
 
    2. If the major versioin number gets bumped, update [SECURITY.md][SECURITY_file_link].
-      
+
       [SECURITY_file_link]: https://github.com/topgrade-rs/topgrade/blob/main/SECURITY.md
 
-   3. Overwrite [`BREAKINGCHANGES`][breaking_changes] with 
+   3. Overwrite [`BREAKINGCHANGES`][breaking_changes] with
       [`BREAKINGCHANGES_dev`][breaking_changes_dev], and create a new dev file:
 
       ```sh'
@@ -24,46 +19,3 @@
 
       [breaking_changes_dev]: https://github.com/topgrade-rs/topgrade/blob/main/BREAKINGCHANGES_dev.md
       [breaking_changes]: https://github.com/topgrade-rs/topgrade/blob/main/BREAKINGCHANGES.md
-
-2. Check and merge that PR.
-
-3. Go to the [release](https://github.com/topgrade-rs/topgrade/releases) page 
-   and click the [Draft a new release button](https://github.com/topgrade-rs/topgrade/releases/new)
-
-4. Write the release notes
-
-   We usually use GitHub's [Automatically generated release notes][auto_gen_release_notes]
-   functionality to generate release notes, but you write your own one instead.
-
-   [auto_gen_release_notes]: https://docs.github.com/en/repositories/releasing-projects-on-github/automatically-generated-release-notes
-
-5. Attaching binaries
-
-   You don't need to do this as our CI will automatically do it for you, 
-   binaries for Linux, macOS and Windows will be created and attached.
-
-   And the CI will publish the new binary to:
-
-   1. AUR
-   2. PyPi
-   3. Homebrew (seems that this is not working correctly)
-   4. Winget
-
-6. Manually release it to Crates.io
-   
-   > Yeah, this is unfortunate, our CI won't do this for us. We should probably add one.
-
-   1. `cd` to the Topgrade directory, make sure that it is the latest version 
-      (i.e., including the PR that bumps the version number).
-   2. Set up your token with `cargo login`.
-   3. Dry-run the publish `cargo publish --dry-run`.
-   4. If step 3 works, then do the final release `cargo publish`.
-
-   > You can also take a look at the official tutorial [Publishing on crates.io][doc]
-   >
-   > [doc]: https://doc.rust-lang.org/cargo/reference/publishing.html
-
-
-
-
-

SECURITY.md

@@ -1,11 +1,9 @@
 # Security Policy
 
+## Reporting a vulnerability
+
+To report a security vulnerability, go to [the security tab](https://github.com/topgrade-rs/topgrade/security) and click "Report a vulnerability".
+
 ## Supported Versions
 
-We only support the latest major version and each subversion.
-
-| Version  | Supported          |
-| -------- | ------------------ |
-| 16.0.x   | :white_check_mark: |
-| < 16.0   | :x:                |
-
+We only support the latest version of Topgrade. Fixes are not backported.

build-all.sh

@@ -1,4 +1,5 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
+
 build_function() {
     rustup update
     cargo install cross
@@ -20,7 +21,7 @@ build_function() {
 
 package_function() {
 
-    cd build
+    cd build || exit 1
     mkdir x86_64-unknown-linux-gnu/
     mkdir x86_64-unknown-linux-musl/
     mkdir x86_64-unknown-freebsd/
@@ -35,28 +36,28 @@ package_function() {
     cp ../target/aarch64-unknown-linux-musl/release/topgrade    aarch64-unknown-linux-musl/topgrade
     cp ../target/x86_64-pc-windows-gnu/release/topgrade.exe     x86_64-pc-windows-gnu/topgrade.exe
 
-    cd x86_64-unknown-linux-gnu/
-    tar -czf ../topgrade-${ans}-x86_64-linux-gnu.tar.gz topgrade
+    cd x86_64-unknown-linux-gnu/ || exit 1
+    tar -czf "../topgrade-${ans}-x86_64-linux-gnu.tar.gz" topgrade
     cd ..
 
-    cd x86_64-unknown-linux-musl
-    tar -czf ../topgrade-${ans}-x86_64-linux-musl.tar.gz  topgrade
+    cd x86_64-unknown-linux-musl/ || exit 1
+    tar -czf "../topgrade-${ans}-x86_64-linux-musl.tar.gz"  topgrade
     cd ..
 
-    cd x86_64-unknown-freebsd/
-    tar -czf ../topgrade-${ans}-x86_64-freebsd.tar.gz     topgrade
+    cd x86_64-unknown-freebsd/ || exit 1
+    tar -czf "../topgrade-${ans}-x86_64-freebsd.tar.gz"     topgrade
     cd ..
 
-    cd aarch64-unknown-linux-gnu/
-    tar -czf ../topgrade-${ans}-aarch64-linux-gnu.tar.gz  topgrade
+    cd aarch64-unknown-linux-gnu/ || exit 1
+    tar -czf "../topgrade-${ans}-aarch64-linux-gnu.tar.gz"  topgrade
     cd ..
 
-    cd aarch64-unknown-linux-musl/
-    tar -czf ../topgrade-${ans}-aarch64-linux-musl.tar.gz topgrade
+    cd aarch64-unknown-linux-musl/ || exit 1
+    tar -czf "../topgrade-${ans}-aarch64-linux-musl.tar.gz" topgrade
     cd ..
 
-    cd x86_64-pc-windows-gnu/
-    zip -q ../topgrade-${ans}-x86_64-windows.zip           topgrade.exe
+    cd x86_64-pc-windows-gnu/ || exit 1
+    zip -q "../topgrade-${ans}-x86_64-windows.zip"           topgrade.exe
     cd ..
     cd ..
 
@@ -65,17 +66,19 @@ package_function() {
 print_checksums() {
 
 
-    cd build/
-    sha256sum topgrade-${ans}-*
+    cd build/ || exit 1
+    sha256sum topgrade-"${ans}"-*
     cd ../
 }
 
 while true; do
 
 echo "You should always have a look on scripts you download from the internet."
+# shellcheck disable=SC2162
 read -p "Do you still want to proceed? (y/n) " yn
 
 echo -n "Input version number: "
+# shellcheck disable=SC2162
 read ans
 mkdir build
 

config.example.toml

@@ -6,6 +6,13 @@
 
 
 [misc]
+# On Unix systems, Topgrade should not be run as root, it
+# will run commands with sudo or equivalent where needed.
+# Set this to true to suppress the warning and confirmation
+# prompt if Topgrade detects it is being run as root.
+# (default: false)
+# allow_root = false
+
 # Run `sudo -v` to cache credentials at the start of the run
 # This avoids a blocking password prompt in the middle of an unattended run
 # (default: false)
@@ -44,6 +51,10 @@
 # Do not ask to retry failed steps (default: false)
 # no_retry = true
 
+# Show the reason for skipped steps (default: false)
+# This has no effect if the "only" option is specified
+# show_skipped = true
+
 # Run inside tmux (default: false)
 # run_in_tmux = true
 
@@ -80,6 +91,11 @@
 # See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives
 # log_filters = ["topgrade::command=debug", "warn"]
 
+# Whether to show a distribution-specific summary if applicable, e.g. listing
+# Pacman backup configuration files (*.pacsave and *.pacnew)
+# (default: true)
+# show_distribution_summary = false
+
 
 # Commands to run before anything
 [pre_commands]
@@ -111,6 +127,19 @@
 # poetry_force_self_update = true
 
 
+[conda]
+# Additional named conda environments to update (`conda env update -n env_name`)
+# env_names = [
+#     "Toolbox",
+#     "PyTorch"
+# ]
+# Additional conda environment paths to update (`conda env update -p env_path`)
+# env_paths = [
+#     "~/webserver/.conda/",
+#     "~/experiments/.conda/"
+# ]
+
+
 [composer]
 # self_update = true
 
@@ -180,7 +209,7 @@
 # rpm_ostree = false
 
 # For Fedora/CentOS/RHEL Atomic variants, if `bootc` is available and this configuration entry is set to true, use
-# it to do the update - Will also supercede rpm-ostree if enabled
+# it to do the update - Will also supersede rpm-ostree if enabled
 # (default: false)
 # bootc = false
 
@@ -192,6 +221,20 @@
 # home_manager_arguments = ["--flake", "file"]
 
 
+[mandb]
+# Enable the mandb step (to update manual entries).
+# Mandb is updated in the background by a service on most systems by default.
+# (default: false)
+# enable = true
+
+
+[pkgfile]
+# Enable the pkgfile step (to update the pkgfile database).
+# Pkgfile is sometimes installed by default, but often not used and heavy to update.
+# (default: false)
+# enable = true
+
+
 [git]
 # How many repos to pull at max in parallel
 # max_concurrency = 5
@@ -213,13 +256,17 @@
 # Manually select Windows updates
 # accept_all_updates = false
 
+# Controls whether to automatically reboot the computer when updates are
+# installed that request it. (default: "no", allowed values: "yes", "no", "ask")
+# updates_auto_reboot = "yes"
+
 # open_remotes_in_new_terminal = true
 
 # wsl_update_pre_release = true
 
 # wsl_update_use_web_download = true
 
-# The default for winget_install_silently is true, 
+# The default for winget_install_silently is true,
 # this example turns off silent install.
 # winget_install_silently = false
 
@@ -228,6 +275,21 @@
 # manager such as Scoop or Cargo
 # self_rename = true
 
+# Use sudo to elevate privileges for the Windows Package Manager (winget)
+# Only use this option if you want to run the Winget step in sudo-mode.
+# Running winget in sudo-mode is generally not recommended, as not every
+# package supports installing / upgrading in sudo-mode and it may cause issues
+# with some packages or may even cause the Winget-step to fail.
+# If any problems occur, please try running Topgrade without this option first
+# before reporting an issue.
+# (default: false)
+# winget_use_sudo = true
+
+
+[chezmoi]
+# Exclude encrypted files from update
+# (default: false)
+# exclude_encrypted = false
 
 [npm]
 # Use sudo if the NPM directory isn't owned by the current user
@@ -281,7 +343,7 @@
 # runtime = "podman"
 
 [lensfun]
-# If disabled, Topgrade invokes `lensfun‑update‑data` without root priviledge,
+# If disabled, Topgrade invokes `lensfun‑update‑data` without root privilege,
 # then the update will be only available to you. Otherwise, `sudo` is required,
 # and the update will be installed system-wide, i.e., available to all users.
 # (default: false)
@@ -325,3 +387,20 @@
 # extensions should be updated for.
 # (default: this won't be set by default)
 # profile = ""
+
+[pixi]
+# Show the release notes of the latest pixi release
+# during the pixi step
+# (default: false)
+# include_release_notes = false
+
+[doom]
+# If this is set to true, the `--aot` flag is added to `doom upgrade`,
+# which enables ahead-of-time native compilation of packages.
+# (default: false)
+# aot = true
+
+[rustup]
+# If set, updates only these channels.
+# (default: [] (all channels))
+# channels = ["stable"]

locales/app.yml

@@ -16,6 +16,22 @@ _version: 2
   zh_CN: "正在模拟 %{program_name} %{arguments} 的运行过程"
   zh_TW: "正在模擬 %{program_name} %{arguments} 的執行過程"
   de: "Testlauf: %{program_name} %{arguments}"
+"Executing: {program_name} {arguments}":
+  en: "Executing: %{program_name} %{arguments}"
+  lt: "Vykdymas: %{program_name} %{arguments}"
+  es: "Ejecutando: %{program_name} %{arguments}"
+  fr: "Exécution: %{program_name} %{arguments}"
+  zh_CN: "执行： %{program_name} %{arguments}"
+  zh_TW: "执行： %{program_name} %{arguments}"
+  de: "Ausführung: %{program_name} %{arguments}"
+"with env: {env}":
+  en: "with env: %{env}"
+  lt: "su env: %{env}"
+  es: "con env: %{env}"
+  fr: "avec env: %{env}"
+  zh_CN: "与env： %{env}"
+  zh_TW: "與env： %{env}"
+  de: "mit env: %{env}"
 "in {directory}":
   en: "in %{directory}"
   lt: "kataloge %{directory}"
@@ -70,7 +86,7 @@ _version: 2
   es: "Cambiando al shell. Arregla lo que necesites y luego sal del shell."
   fr: "Ouverture d'un shell. Réparez ce dont vous avez besoin et quittez le shell."
   zh_CN: "已切换到 Shell 环境。请修复需要的内容，完成后退出 Shell 。"
-  zh_TW: "已切換到終端殼層。修復完畢後請退出殼層以繼續。"
+  zh_TW: "已切換到 shell 環境。修復完畢後請退出 shell 以繼續。"
   de: "Wechsel zur Shell. Beheben Sie die Probleme und verlassen Sie dann die Shell."
 "Topgrade launched in a new tmux session":
   en: "Topgrade launched in a new tmux session"
@@ -78,16 +94,16 @@ _version: 2
   es: "Topgrade lanzado en una nueva sesión tmux"
   fr: "Topgrade lancé dans une nouvelle session tmux"
   zh_CN: "Topgrade 已在新的 tmux 会话中启动"
-  zh_TW: "Topgrade 已啟動新 tmux 程序"
+  zh_TW: "Topgrade 已啟動新 tmux 程式"
   de: "Topgrade in einer neuen tmux-Sitzung gestartet"
-'Topgrade upgraded to {version}:\n':
-  en: 'Topgrade upgraded to %{version}:\n'
+"Topgrade upgraded to {version}:\n":
+  en: "Topgrade upgraded to %{version}:\n"
   lt: "Topgrade atnaujintas iki %{version}:\n"
-  es: 'Topgrade actualizado a %{version}:\n'
-  fr: 'Topgrade mis à jour vers %{version}:\n'
-  zh_CN: '已将 Topgrade 更新至 %{version}: \n'
-  zh_TW: '已將 Topgrade 更新至 %{version}：\n'
-  de: 'Topgrade auf Version %{version} aktualisiert:\n'
+  es: "Topgrade actualizado a %{version}:\n"
+  fr: "Topgrade mis à jour vers %{version}:\n"
+  zh_CN: "已将 Topgrade 更新至 %{version}: \n"
+  zh_TW: "已將 Topgrade 更新至 %{version}：\n"
+  de: "Topgrade auf Version %{version} aktualisiert:\n"
 "Topgrade is up-to-date":
   en: "Topgrade is up-to-date"
   lt: "Topgrade yra naujausia"
@@ -214,14 +230,6 @@ _version: 2
   zh_CN: "正在跳过"
   zh_TW: "正在略過"
   de: "Überspringe"
-"Aura(<0.4.6) requires sudo installed to work with AUR packages":
-  en: "Aura(<0.4.6) requires sudo installed to work with AUR packages"
-  lt: "Aura (<0.4.6) reikalauja sudo įdiegimo, kad galėtų naudoti AUR paketus"
-  es: "Aura(<0.4.6) requiere tener sudo instalado para funcionar con paquetes AUR"
-  fr: "Aura(<0.4.6) nécessite sudo pour fonctionner avec les paquets AUR"
-  zh_CN: "Aura(<0.4.6) 依赖 sudo 安装 AUR 软件包。"
-  zh_TW: "Aura（<0.4.6）依賴 sudo 安裝 AUR 套件"
-  de: "Aura(<0.4.6) benötigt sudo zur Verwendung von AUR-Paketen"
 "Pacman backup configuration files found:":
   en: "Pacman backup configuration files found:"
   lt: "Rasti Pacman atsarginės konfigūracijos failai:"
@@ -236,7 +244,7 @@ _version: 2
   es: "La auditoría del paquete fue exitosa, pero aún quedan paquetes vulnerables en el sistema"
   fr: "L'audit des paquets a réussi, mais des paquets vulnérables restent toujours sur le système"
   zh_CN: "软件包审计已通过，但系统中仍存在含漏洞的软件包"
-  zh_TW: "雖然套件檢測成功，但系統仍然包含危險套件"
+  zh_TW: "雖然套件審查成功，但系統仍然殘留危險套件"
   de: "Das Paket-Audit war erfolgreich, aber es befinden sich noch anfällige Pakete im System"
 "Syncing portage":
   en: "Syncing portage"
@@ -252,7 +260,7 @@ _version: 2
   es: "Buscando software disponible"
   fr: "Recherche de logiciels disponible"
   zh_CN: "正在寻找可用的软件"
-  zh_TW: "正在尋找軟體"
+  zh_TW: "正在尋找可用的軟體"
   de: "Suche nach verfügbarer Software"
 "A system update is available. Do you wish to install it?":
   en: "A system update is available. Do you wish to install it?"
@@ -260,14 +268,14 @@ _version: 2
   es: "Hay una actualización del sistema disponible. ¿Desea instalarla?"
   fr: "Une mise à jour du système est disponible. Voulez-vous l'installer ?"
   zh_CN: "系统更新可用。是否立即安装？"
-  zh_TW: "系統更新已就緒。是否現在安裝？"
+  zh_TW: "系統更新已就緒。是否立即安裝？"
   de: "Ein System-Update ist verfügbar. Möchten Sie es installieren?"
 "No new software available.":
   en: "No new software available."
   lt: "Nėra naujos programinės įrangos."
   es: "No hay ningún software nuevo disponible."
   fr: "Aucun nouveau logiciel disponible."
-  zh_CN: "没有新的可用的软件包"
+  zh_CN: "没有新的可用的软件包。"
   zh_TW: "沒有新軟體。"
   de: "Keine neue Software verfügbar."
 "No Xcode releases installed.":
@@ -275,7 +283,7 @@ _version: 2
   lt: "Nėra įdiegtų Xcode versijų."
   es: "No hay versiones de Xcode instaladas."
   fr: "Aucune version de Xcode installée."
-  zh_CN: "尚未安装 Xcode 发行版"
+  zh_CN: "尚未安装 Xcode 发行版。"
   zh_TW: "尚未安裝 Xcode 發行版。"
   de: "Keine Xcode-Versionen installiert."
 "Would you like to move the former Xcode release to the trash?":
@@ -300,7 +308,7 @@ _version: 2
   es: "¿Le gustaría instalarlo?"
   fr: "Voulez-vous l'installer ?"
   zh_CN: "是否立即安装？"
-  zh_TW: "是否現在安裝？"
+  zh_TW: "是否立即安裝？"
   de: "Möchten Sie sie installieren?"
 "No global packages installed":
   en: "No global packages installed"
@@ -332,7 +340,7 @@ _version: 2
   es: "Recolectando cajas Vagrant"
   fr: "Collecte des boîtes Vagrant"
   zh_CN: "正在收集 Vagrant 容器"
-  zh_TW: "正在蒐集 Vagrant 容器"
+  zh_TW: "正在收集 Vagrant 容器"
   de: "Sammle Vagrant-Boxen"
 "No Vagrant directories were specified in the configuration file":
   en: "No Vagrant directories were specified in the configuration file"
@@ -356,7 +364,7 @@ _version: 2
   es: "Sin cajas obsoletas"
   fr: "Aucune boîte obsolète"
   zh_CN: "没有需要更新的容器"
-  zh_TW: "未有需要更新的容器"
+  zh_TW: "沒有需要更新的容器"
   de: "Keine veralteten Boxen"
 "Summary":
   en: "Summary"
@@ -390,14 +398,6 @@ _version: 2
   zh_CN: "Topgrade %{version_str} 破坏性更改"
   zh_TW: "Topgrade %{version_str} 重大更改"
   de: "Topgrade %{version_str} Inkompatible Änderungen"
-"Path {path} expanded to {expanded}":
-  en: "Path %{path} expanded to %{expanded}"
-  lt: "Kelias %{path} išplėstas į %{expanded}"
-  es: "Ruta %{path} expandida a %{expanded}"
-  fr: "Le chemin %{path} a été transformé en %{expanded}"
-  zh_CN: "已扩展 %{path} 至 %{expanded}"
-  zh_TW: "已擴展 %{path} 至 %{expanded}"
-  de: "Pfad %{path} erweitert zu %{expanded}"
 "Path {path} doesn't exist":
   en: "Path %{path} doesn't exist"
   lt: "Kelias %{path} neegzistuoja"
@@ -414,6 +414,14 @@ _version: 2
   zh_CN: "在 $PATH 中找不到 %{binary_name} 二进制"
   zh_TW: "在 $PATH 中找不到 %{binary_name} 執行檔"
   de: "Kann %{binary_name} nicht im PATH finden"
+"Cannot find any of {binary_names} in PATH":
+  en: "Cannot find any of %{binary_names} in PATH"
+  lt: "Nepavyksta rasti jokių %{binary_names} PATH sąraše"
+  es: "No se puede encontrar ninguno de %{binary_names} en PATH"
+  fr: "Impossible de trouver l'un des %{binary_names} dans le PATH"
+  zh_CH: "在 PATH 中找不到 %{binary_names}"
+  zh_TW: "在 PATH 中找不到 %{binary_names}"
+  de: "Kann keines von %{binary_names} im PATH finden"
 "Failed to get a UTF-8 encoded hostname":
   en: "Failed to get a UTF-8 encoded hostname"
   lt: "Nepavyko gauti UTF-8 koduoto kompiuterio pavadinimo"
@@ -476,7 +484,7 @@ _version: 2
   es: "Auditoría de DragonFly BSD"
   fr: "Audit de DragonFly BSD"
   zh_CN: "DragonFly BSD 审计"
-  zh_TW: "DragonFly BSD 紀錄"
+  zh_TW: "DragonFly BSD 審查"
   de: "DragonFly BSD Audit"
 "FreeBSD Update":
   en: "FreeBSD Update"
@@ -500,7 +508,7 @@ _version: 2
   es: "Auditoría FreeBSD"
   fr: "Audit de FreeBSD"
   zh_CN: "FreeBSD 审计"
-  zh_TW: "FreeBSD 紀錄"
+  zh_TW: "FreeBSD 審查"
   de: "FreeBSD Audit"
 "System update":
   en: "System update"
@@ -532,7 +540,7 @@ _version: 2
   es: "No se debe ejecutar en WSL"
   fr: "Ne doit pas être exécuté dans WSL"
   zh_CN: "不应在 WSL 中运行"
-  zh_TW: "不該在 WSL 中執行"
+  zh_TW: "不應在 WSL 中執行"
   de: "Sollte nicht in WSL ausgeführt werden"
 "Firmware upgrades":
   en: "Firmware upgrades"
@@ -556,7 +564,7 @@ _version: 2
   es: "El socket Snapd no existe"
   fr: "Le socket Snapd n'existe pas"
   zh_CN: "找不到 Snapd 程序"
-  zh_TW: "找不到 Snapd 程序"
+  zh_TW: "找不到 Snapd 程式"
   de: "Snapd-Socket existiert nicht"
 "You need to specify at least one container":
   en: "You need to specify at least one container"
@@ -596,7 +604,7 @@ _version: 2
   es: "Omitiendo el paso de Waydroid debido a que el usuario no quiere continuar"
   fr: "Passer l'étape Waydroid car l'utilisateur ne souhaite pas l'exécuter"
   zh_CN: "使用者指定跳过 Waydroid 程序"
-  zh_TW: "使用者指定略過 Waydroid 程序"
+  zh_TW: "使用者指定略過 Waydroid 程式"
   de: "Überspringe den Waydroid-Schritt, da der Benutzer nicht fortfahren möchte"
 "macOS App Store":
   en: "macOS App Store"
@@ -654,29 +662,29 @@ _version: 2
   zh_CN: "无法使用 `fish_update_completions`"
   zh_TW: "無法使用 `fish_update_completions`"
   de: "`fish_update_completions` ist nicht verfügbar"
-"Desktop doest not appear to be gnome":
-  en: "Desktop doest not appear to be gnome"
-  lt: "Darbalaukis, matyt, nėra Gnome"
-  es: "El escritorio no parece ser Gnome"
-  fr: "Le bureau ne semble pas être Gnome"
-  zh_CN: "桌面环境不是 Gnome"
-  zh_TW: "桌面環境不是 Gnome"
+"Desktop does not appear to be GNOME":
+  en: "Desktop does not appear to be GNOME"
+  lt: "Darbalaukis, matyt, nėra GNOME"
+  es: "El escritorio no parece ser GNOME"
+  fr: "Le bureau ne semble pas être GNOME"
+  zh_CN: "桌面环境不是 GNOME"
+  zh_TW: "桌面環境不是 GNOME"
   de: "Desktop scheint nicht GNOME zu sein"
-"Gnome shell extensions are unregistered in DBus":
-  en: "Gnome shell extensions are unregistered in DBus"
-  lt: "Gnome Shell priedai nėra užregistruoti DBus'e"
-  es: "Las extensiones de Gnome Shell no están registradas en DBus"
-  fr: "Les extensions de Gnome Shell ne sont pas enregistrées dans DBus"
-  zh_CN: "Gnome Shell 扩展在 DBus中未被注册"
-  zh_TW: "Gnome Shell 擴充功能在 DBus 中未被註冊"
+"GNOME shell extensions are unregistered in DBus":
+  en: "GNOME shell extensions are unregistered in DBus"
+  lt: "GNOME Shell priedai nėra užregistruoti DBus'e"
+  es: "Las extensiones de GNOME Shell no están registradas en DBus"
+  fr: "Les extensions de GNOME Shell ne sont pas enregistrées dans DBus"
+  zh_CN: "GNOME Shell 扩展在 DBus中未被注册"
+  zh_TW: "GNOME Shell 擴充功能在 DBus 中未被註冊"
   de: "GNOME-Shell-Erweiterungen sind im DBus nicht registriert"
-"Gnome Shell extensions":
-  en: "Gnome Shell extensions"
-  lt: "Gnome Shell priedai"
-  es: "Extensiones de Gnome Shell"
-  fr: "Extensions de Gnome Shell"
-  zh_CN: "Gnome Shell 扩展"
-  zh_TW: "Gnome Shell 擴充功能"
+"GNOME Shell extensions":
+  en: "GNOME Shell extensions"
+  lt: "GNOME Shell priedai"
+  es: "Extensiones de GNOME Shell"
+  fr: "Extensions de GNOME Shell"
+  zh_CN: "GNOME Shell 扩展"
+  zh_TW: "GNOME Shell 擴充功能"
   de: "GNOME-Shell-Erweiterungen"
 "Not a custom brew for macOS":
   en: "Not a custom brew for macOS"
@@ -774,22 +782,22 @@ _version: 2
   zh_CN: "无法找到安装在 WSL 中的 Topgrade"
   zh_TW: "尚未在 WSL 內安裝 Topgrade"
   de: "Konnte Topgrade nicht in WSL finden"
-"Consider installing PSWindowsUpdate as the use of Windows Update via USOClient is not supported.":
-  en: "Consider installing PSWindowsUpdate as the use of Windows Update via USOClient is not supported."
-  lt: "Apsvarstykite PSWindowsUpdate įdiegimą, nes Windows Update per USOClient nepalaikomas."
-  es: "Considere instalar PSWindowsUpdate ya que no se admite el uso de Windows Update a través de USOClient."
-  fr: "Envisagez d'installer PSWindowsUpdate car l'utilisation de Windows Update via USOClient n'est pas prise en charge."
-  zh_CN: "目前不支持使用 USOClient 管理 Windows 更新。建议安装 PSWindowsUpdate。"
-  zh_TW: "目前不支援使用 USOClient 管理 Windows 更新。建議安裝 PSWindowsUpdate。"
-  de: "Erwägen Sie die Installation von PSWindowsUpdate, da die Verwendung von Windows Update über USOClient nicht unterstützt wird."
-"USOClient not supported.":
-  en: "USOClient not supported."
-  lt: "USOClient nepalaikomas."
-  es: "USOClient no es admitido."
-  fr: "USOClient n'est pas pris en charge."
-  zh_CN: "不支持 USOClient"
-  zh_TW: "不支援 USOClient。"
-  de: "USOClient wird nicht unterstützt."
+"The PSWindowsUpdate PowerShell module isn't installed so Topgrade can't run Windows Update.\nInstall PSWindowsUpdate by running `Install-Module PSWindowsUpdate` in PowerShell.":
+  en: "The PSWindowsUpdate PowerShell module isn't installed so Topgrade can't run Windows Update.\nInstall PSWindowsUpdate by running `Install-Module PSWindowsUpdate` in PowerShell."
+  lt: "PowerShell modulis PSWindowsUpdate nėra įdiegtas, todėl Topgrade negali paleisti „Windows Update“.\nĮdiekite PSWindowsUpdate paleisdami `Install-Module PSWindowsUpdate` PowerShell aplinkoje."
+  es: "El módulo de PowerShell PSWindowsUpdate no está instalado, por lo que Topgrade no puede ejecutar Windows Update.\nInstala PSWindowsUpdate ejecutando `Install-Module PSWindowsUpdate` en PowerShell."
+  fr: "Le module PowerShell PSWindowsUpdate n’est pas installé, donc Topgrade ne peut pas exécuter Windows Update.\nInstallez PSWindowsUpdate en exécutant `Install-Module PSWindowsUpdate` dans PowerShell."
+  zh_CN: "未安装 PowerShell 模块 PSWindowsUpdate，因此 Topgrade 无法运行 Windows 更新。\n请在 PowerShell 中运行 `Install-Module PSWindowsUpdate` 来安装 PSWindowsUpdate。"
+  zh_TW: "PowerShell 模組 PSWindowsUpdate 未安裝，因此 Topgrade 無法執行 Windows 更新。\n請在 PowerShell 中執行 `Install-Module PSWindowsUpdate` 來安裝 PSWindowsUpdate。"
+  de: "Das PowerShell-Modul PSWindowsUpdate ist nicht installiert, daher kann Topgrade Windows Update nicht ausführen.\nInstallieren Sie PSWindowsUpdate, indem Sie `Install-Module PSWindowsUpdate` in PowerShell ausführen."
+"PSWindowsUpdate is not installed":
+  en: "PSWindowsUpdate is not installed"
+  lt: "PSWindowsUpdate nėra įdiegtas"
+  es: "PSWindowsUpdate no está instalado"
+  fr: "PSWindowsUpdate n'est pas installé"
+  zh_CN: "未安装 PSWindowsUpdate"
+  zh_TW: "未安裝 PSWindowsUpdate"
+  de: "PSWindowsUpdate ist nicht installiert"
 "Connecting to {hostname}...":
   en: "Connecting to %{hostname}..."
   lt: "Jungiamasi prie %{hostname}..."
@@ -942,13 +950,21 @@ _version: 2
   zh_CN: "拉取 %{repo}"
   zh_TW: "拉取 %{repo}"
   de: "Würde %{repo} abrufen"
+"No Neovim config found":
+  en: "No Neovim config found"
+  lt: "Neovim konfigūracija nerasta"
+  es: "No se encontró ninguna configuración de Neovim"
+  fr: "Aucune configuration Neovim trouvée"
+  zh_CN: "未找到 Neovim 配置"
+  zh_TW: "未找到 Neovim 設定"
+  de: "Keine Neovim-Konfiguration gefunden"
 "Node Package Manager":
   en: "Node Package Manager"
   lt: "Node paketų tvarkyklė (npm)"
   es: "Node Package Manager (npm)"
   fr: "Gestionnaire de paquets Node (npm)"
   zh_CN: "Node Package Manager（npm）"
-  zh_TW: "Node 套件管理員（npm）"
+  zh_TW: "Node Package Manager（npm）"
   de: "Node Package Manager (npm)"
 "Performant Node Package Manager":
   en: "Performant Node Package Manager"
@@ -956,7 +972,7 @@ _version: 2
   es: "Performant Node Package Manager (pnpm)"
   fr: "Gestionnaire de paquets Node performant (pnpm)"
   zh_CN: "Performant Node Package Manager (pnpm)"
-  zh_TW: "效能 Node 套件管理員（pnpm）"
+  zh_TW: "Performant Node Package Manager（pnpm）"
   de: "Performanter Node Package Manager (pnpm)"
 "Yarn Package Manager":
   en: "Yarn Package Manager"
@@ -1012,7 +1028,7 @@ _version: 2
   es: "Distribución de Linux desconocida"
   fr: "Distribution Linux inconnue"
   zh_CN: "未知 Linux 发行版"
-  zh_TW: "未知 Linux"
+  zh_TW: "未知 Linux 發行版"
   de: "Unbekannte Linux-Distribution"
 'File "/etc/os-release" does not exist or is empty':
   en: 'File "/etc/os-release" does not exist or is empty'
@@ -1046,14 +1062,6 @@ _version: 2
   zh_CN: "模拟运行"
   zh_TW: "模擬執行"
   de: "Testlauf"
-"Topgrade Upgraded":
-  en: "Topgrade Upgraded"
-  lt: "Topgrade atnaujintas"
-  es: "Topgrade Actualizado"
-  fr: "Topgrade mis à jour"
-  zh_CN: "已升级 Topgrade"
-  zh_TW: "已更新 Topgrade"
-  de: "Topgrade aktualisiert"
 
 # Summary texts
 "OK":
@@ -1108,33 +1116,131 @@ _version: 2
   es: "¿Reintentar? (y) Si / (N) No / (s) Shell / (q) Salir"
   fr: "Réessayer ? (y) Oui / (N) Non / (s) Shell / (q) Quitter"
   zh_CN: "再试一次？(y)是/(N)否/(s)Shell/(q)退出"
-  zh_TW: "再試一次？ (y)是/(N)否/(s)殼層/(q)退出"
-  de: "Wiederholen? (y)a/(N)ein/(s)hell/(q)uit"
+  zh_TW: "再試一次？ (y)是/(N)否/(s)Shell/(q)退出"
+  de: "Wiederholen? (y) Ja / (n) Nein / (s) Shell / (q) Beenden"
 
 # 'R', 'S', 'Q'  have to stay the same throughout all translations. Eg German would look like "\n(R) Neustarten\n(S) Konsole\n(Q) Beenden"
-'\n(R)eboot\n(S)hell\n(Q)uit':
-  en: '\n(R)eboot\n(S)hell\n(Q)uit'
+"\n(R)eboot\n(S)hell\n(Q)uit":
+  en: "\n(R)eboot\n(S)hell\n(Q)uit"
   lt: "\n(R)perkrovimas\n(S)shell\n(Q)išeiti"
   es: "\n(R) Reiniciar\n(S) Shell\n(Q) Salir"
-  fr: '\n(R) Redémarrer\n(S) Shell\n(Q) Quitter'
-  zh_CN: '\n(R)重启\n(S)Shell\n(Q)退出'
-  zh_TW: '\n(R)重新啟動\n(S)殼層\n(Q)退出'
-  de: '\n(R) Neustarten\n(S)hell\n(Q)uit beenden'
-"Require sudo or counterpart but not found, skip":
-  en: "Require sudo or counterpart but not found, skip"
-  lt: "Reikalingas sudo arba atitikmuo, bet nerasta, praleidžiama"
-  es: "Se requiere sudo o su equivalente pero no ha sido encontrado, omitiendo"
-  fr: "Nécessite sudo ou un équivalent mais n'a pas été trouvé, passé"
-  zh_CN: "找不到权限管理程序（sudo 等），跳过"
-  zh_TW: "找不到權限管理程式（sudo 等），略過"
-  de: "Benötigt sudo oder Äquivalent, aber nicht gefunden, überspringe"
+  fr: "\n(R) Redémarrer\n(S) Shell\n(Q) Quitter"
+  zh_CN: "\n(R)重启\n(S)Shell\n(Q)退出"
+  zh_TW: "\n(R)重新啟動\n(S)shell\n(Q)退出"
+  de: "\n(R) Neustarten\n(S)hell\n(Q)uit beenden"
+
+"Continue?":
+  en: "Continue?"
+  lt: "Tęsti?"
+  es: "¿Continuar?"
+  fr: "Continuer ?"
+  zh_CN: "继续？"
+  zh_TW: "繼續？"
+  de: "Fortfahren?"
+
+"Topgrade should not be run as root, it will run commands with sudo or equivalent where needed.":
+  en: "Topgrade should not be run as root, it will run commands with sudo or equivalent where needed."
+  lt: "Topgrade neturėtų būti paleistas kaip root, jis vykdys komandas su sudo ar atitikmeniu, kai to reikės."
+  es: "Topgrade no debe ejecutarse como root, ejecutará comandos con sudo o equivalente cuando sea necesario."
+  fr: "Topgrade ne doit pas être exécuté en tant que root, il exécutera les commandes avec sudo ou équivalent si nécessaire."
+  zh_CN: "Topgrade 不应以 root 身份运行，它会在需要时使用 sudo 或等效工具执行命令。"
+  zh_TW: "Topgrade 不應以 root 身份執行，它會在需要時使用 sudo 或等效工具執行命令。"
+  de: "Topgrade sollte nicht als Root ausgeführt werden, es führt Befehle mit sudo oder einem Äquivalent aus, wenn erforderlich."
+"Could not find sudo":
+  en: "Could not find sudo"
+  lt: "Nepavyko rasti sudo"
+  es: "No se pudo encontrar sudo"
+  fr: "Impossible de trouver sudo"
+  zh_CN: "未找到 sudo"
+  zh_TW: "找不到 sudo"
+  de: "Konnte sudo nicht finden"
+"Skipping step, sudo is required":
+  en: "Skipping step, sudo is required"
+  lt: "Žingsnis praleidžiamas, reikalingas sudo"
+  es: "Omitiendo paso, se requiere sudo"
+  fr: "Étape ignorée, sudo est requis"
+  zh_CN: "跳过步骤，需要 sudo"
+  zh_TW: "跳過步驟，需要 sudo"
+  de: "Schritt wird übersprungen, sudo ist erforderlich"
+"\nSome steps were skipped as sudo or equivalent could not be found.":
+  en: "\nSome steps were skipped as sudo or equivalent could not be found."
+  lt: "\nKai kurie veiksmai buvo praleisti, nes nepavyko rasti sudo ar atitikmens."
+  es: "\nAlgunos pasos se omitieron porque no se pudo encontrar sudo o equivalente."
+  fr: "\nCertaines étapes ont été ignorées car sudo ou équivalent est introuvable."
+  zh_CN: "\n由于未找到 sudo 或等效工具，某些步骤被跳过。"
+  zh_TW: "\n某些步驟因為找不到 sudo 或同等的工具而被跳過。"
+  de: "\nEinige Schritte wurden übersprungen, da sudo oder ein Äquivalent nicht gefunden wurde."
+"Install one of `sudo`, `doas`, `pkexec`, `run0` or `please` to run these steps.":
+  en: "Install one of `sudo`, `doas`, `pkexec`, `run0` or `please` to run these steps."
+  lt: "Įdiekite vieną iš `sudo`, `doas`, `pkexec`, `run0` arba `please`, kad vykdytumėte šiuos veiksmus."
+  es: "Instale uno de `sudo`, `doas`, `pkexec`, `run0` o `please` para ejecutar estos pasos."
+  fr: "Installez l’un de `sudo`, `doas`, `pkexec`, `run0` ou `please` pour exécuter ces étapes."
+  zh_CN: "请安装 `sudo`、`doas`、`pkexec`、`run0` 或 `please` 之一来运行这些步骤。"
+  zh_TW: "請安裝 `sudo`、`doas`、`pkexec`、`run0` 或 `please` 以執行這些步驟。"
+  de: "Installieren Sie `sudo`, `doas`, `pkexec`, `run0` oder `please`, um diese Schritte auszuführen."
+"Install gsudo to run these steps.":
+  en: "Install gsudo to run these steps."
+  lt: "Įdiekite gsudo, kad vykdytumėte šiuos veiksmus."
+  es: "Instale gsudo para ejecutar estos pasos."
+  fr: "Installez gsudo pour exécuter ces étapes."
+  zh_CN: "请安装 gsudo 来运行这些步骤。"
+  zh_TW: "請安裝 gsudo 來執行這些步驟。"
+  de: "Installieren Sie gsudo, um diese Schritte auszuführen."
+"Install gsudo or enable Windows Sudo to run these steps.\nFor Windows Sudo, the default 'In a new window' mode is not supported as it prevents Topgrade from waiting for commands to finish. Please configure it to use 'Inline' mode instead.\nGo to https://go.microsoft.com/fwlink/?linkid=2257346 to learn more.":
+  en: "Install gsudo or enable Windows Sudo to run these steps.\nFor Windows Sudo, the default 'In a new window' mode is not supported as it prevents Topgrade from waiting for commands to finish. Please configure it to use 'Inline' mode instead.\nGo to https://go.microsoft.com/fwlink/?linkid=2257346 to learn more."
+  lt: "Įdiekite gsudo arba įjunkite Windows Sudo, kad vykdytumėte šiuos veiksmus.\nWindows Sudo numatytasis „Naujo lango“ režimas nepalaikomas, nes jis neleidžia Topgrade laukti, kol komandos bus baigtos. Prašome nustatyti „Inline“ režimą.\nDaugiau sužinokite adresu https://go.microsoft.com/fwlink/?linkid=2257346."
+  es: "Instale gsudo o habilite Windows Sudo para ejecutar estos pasos.\nEn Windows Sudo, el modo predeterminado 'En una nueva ventana' no es compatible porque impide que Topgrade espere a que los comandos terminen. Por favor, configúrelo en modo 'Inline'.\nMás información en https://go.microsoft.com/fwlink/?linkid=2257346."
+  fr: "Installez gsudo ou activez Windows Sudo pour exécuter ces étapes.\nAvec Windows Sudo, le mode par défaut « Dans une nouvelle fenêtre » n’est pas pris en charge car il empêche Topgrade d’attendre la fin des commandes. Veuillez le configurer en mode « Inline ».\nEn savoir plus sur https://go.microsoft.com/fwlink/?linkid=2257346."
+  zh_CN: "请安装 gsudo 或启用 Windows Sudo 来运行这些步骤。\n在 Windows Sudo 中，默认的“新窗口”模式不受支持，因为它会阻止 Topgrade 等待命令完成。请将其配置为“内联”模式。\n了解更多信息：https://go.microsoft.com/fwlink/?linkid=2257346"
+  zh_TW: "請安裝 gsudo 或啟用 Windows Sudo 來執行這些步驟。\n在 Windows Sudo 中，預設的「新視窗」模式不受支援，因為它會阻止 Topgrade 等待命令完成。請將其設定為「內嵌」模式。\n了解更多資訊：https://go.microsoft.com/fwlink/?linkid=2257346"
+  de: "Installieren Sie gsudo oder aktivieren Sie Windows Sudo, um diese Schritte auszuführen.\nFür Windows Sudo wird der Standardmodus „In einem neuen Fenster“ nicht unterstützt, da er verhindert, dass Topgrade auf den Abschluss der Befehle wartet. Bitte konfigurieren Sie es stattdessen auf „Inline“-Modus.\nMehr erfahren unter https://go.microsoft.com/fwlink/?linkid=2257346."
+"Windows Sudo was found, but it is set to 'In a new window' mode, which prevents Topgrade from waiting for commands to finish. Please configure it to use 'Inline' mode instead.\nGo to https://go.microsoft.com/fwlink/?linkid=2257346 to learn more.":
+  en: "Windows Sudo was found, but it is set to 'In a new window' mode, which prevents Topgrade from waiting for commands to finish. Please configure it to use 'Inline' mode instead.\nGo to https://go.microsoft.com/fwlink/?linkid=2257346 to learn more."
+  lt: "Rastas Windows Sudo, bet jis nustatytas „Naujo lango“ režimu, kuris neleidžia Topgrade laukti, kol bus baigtos komandos. Prašome nustatyti „Inline“ režimą.\nDaugiau sužinokite adresu https://go.microsoft.com/fwlink/?linkid=2257346."
+  es: "Se encontró Windows Sudo, pero está configurado en el modo 'En una nueva ventana', lo que impide que Topgrade espere a que los comandos finalicen. Por favor, configúrelo en modo 'Inline'.\nMás información en https://go.microsoft.com/fwlink/?linkid=2257346."
+  fr: "Windows Sudo a été trouvé, mais il est configuré en mode « Dans une nouvelle fenêtre », ce qui empêche Topgrade d’attendre la fin des commandes. Veuillez le configurer en mode « Inline ».\nEn savoir plus sur https://go.microsoft.com/fwlink/?linkid=2257346."
+  zh_CN: "检测到 Windows Sudo，但其被设置为“新窗口”模式，这会阻止 Topgrade 等待命令完成。请将其配置为“内联”模式。\n了解更多信息：https://go.microsoft.com/fwlink/?linkid=2257346"
+  zh_TW: "偵測到 Windows Sudo，但它被設定為「新視窗」模式，這會阻止 Topgrade 等待命令完成。請將其設定為「內嵌」模式。\n了解更多資訊：https://go.microsoft.com/fwlink/?linkid=2257346"
+  de: "Windows Sudo wurde gefunden, aber es ist auf den Modus „In einem neuen Fenster“ eingestellt, wodurch Topgrade nicht auf den Abschluss der Befehle warten kann. Bitte konfigurieren Sie es stattdessen auf den „Inline“-Modus.\nMehr erfahren unter https://go.microsoft.com/fwlink/?linkid=2257346."
+"Cannot find sudo binary":
+  en: "Cannot find sudo binary"
+  lt: "Nepavyko rasti sudo dvejetainio failo"
+  es: "No se puede encontrar el binario de sudo"
+  fr: "Impossible de trouver le binaire sudo"
+  zh_CN: "找不到 sudo 可执行文件"
+  zh_TW: "找不到 sudo 可執行檔"
+  de: "Kann die sudo-Binärdatei nicht finden"
+"Found Windows Sudo, but it is disabled":
+  en: "Found Windows Sudo, but it is disabled"
+  lt: "Rastas Windows Sudo, bet jis išjungtas"
+  es: "Se encontró Windows Sudo, pero está deshabilitado"
+  fr: "Windows Sudo a été trouvé, mais il est désactivé"
+  zh_CN: "检测到 Windows Sudo，但已被禁用"
+  zh_TW: "偵測到 Windows Sudo，但已被停用"
+  de: "Windows Sudo gefunden, aber es ist deaktiviert"
+"Found Windows Sudo, but it is using 'In a new window' mode":
+  en: "Found Windows Sudo, but it is using 'In a new window' mode"
+  lt: "Rastas Windows Sudo, bet jis naudoja „Naujo lango“ režimą"
+  es: "Se encontró Windows Sudo, pero está usando el modo 'En una nueva ventana'"
+  fr: "Windows Sudo a été trouvé, mais il utilise le mode « Dans une nouvelle fenêtre »"
+  zh_CN: "检测到 Windows Sudo，但其正在使用“新窗口”模式"
+  zh_TW: "偵測到 Windows Sudo，但它正在使用「新視窗」模式"
+  de: "Windows Sudo gefunden, aber es verwendet den Modus „In einem neuen Fenster“"
+"{sudo_kind} does not support the {option} option":
+  en: "%{sudo_kind} does not support the %{option} option"
+  lt: "%{sudo_kind} nepalaiko parinkties %{option}"
+  es: "%{sudo_kind} no admite la opción %{option}"
+  fr: "%{sudo_kind} ne prend pas en charge l’option %{option}"
+  zh_CN: "%{sudo_kind} 不支持 %{option} 选项"
+  zh_TW: "%{sudo_kind} 不支援 %{option} 選項"
+  de: "%{sudo_kind} unterstützt die Option %{option} nicht"
 "sudo as user '{user}'":
   en: "sudo as user '%{user}'"
   lt: "sudo kaip vartotojas '%{user}'"
   es: "sudo como usuario '%{user}'"
   fr: "sudo en tant qu'utilisateur '%{user}'"
   zh_CN: "sudo 作为用户 '%{user}'"
-  zh_TW: "sudo 以使用者 '%{user}'"
+  zh_TW: "sudo 作為使用者 '%{user}'"
   de: "sudo als Benutzer '%{user}'"
 "Updating aqua ...":
   en: "Updating aqua ..."
@@ -1181,16 +1287,16 @@ _version: 2
   lt: "Vėl paleidžiama..."
   es: "Reapareciendo..."
   fr: "Relancement..."
-  zh_CN: "正在重新生成"
+  zh_CN: "正在重新生成..."
   zh_TW: "正在重新生成..."
   de: "Neustarten..."
-"Could not find Topgrade in any WSL disribution":
-  en: "Could not find Topgrade in any WSL disribution"
+"Could not find Topgrade in any WSL distribution":
+  en: "Could not find Topgrade in any WSL distribution"
   lt: "Nepavyko rasti Topgrade jokioje WSL distribucijoje"
   es: "No se pudo encontrar Topgrade en ninguna distribución WSL"
   fr: "Impossible de trouver Topgrade installé dans WSL"
   zh_CN: "无法在任何 WSL 发行版中找到 Topgrade"
-  zh_TW: "在所有 WSL 中找不到 Topgrade"
+  zh_TW: "無法在任何 WSL 發行版中找到 Topgrade"
   de: "Konnte Topgrade in keiner WSL-Distribution finden"
 "Windows Update":
   en: "Windows Update"
@@ -1200,30 +1306,6 @@ _version: 2
   zh_CN: "Windows 更新"
   zh_TW: "Windows 更新"
   de: "Windows-Update"
-"Would check if OpenBSD is -current":
-  en: "Would check if OpenBSD is -current"
-  lt: "Patikrintų, ar OpenBSD yra -current"
-  es: "Comprobaría si OpenBSD está en -current"
-  fr: "Vérifierait si OpenBSD est à -curent"
-  zh_CN: "将检查 OpenBSD 是否为 -current"
-  zh_TW: "會檢查 OpenBSD 是否為 -current"
-  de: "Würde überprüfen, ob OpenBSD -current ist"
-"Would upgrade the OpenBSD system":
-  en: "Would upgrade the OpenBSD system"
-  lt: "Atnaujintų OpenBSD sistemą"
-  es: "Actualizaría el sistema OpenBSD"
-  fr: "Mettrait à jour le système OpenBSD"
-  zh_CN: "将升级 OpenBSD 系统"
-  zh_TW: "會升級 OpenBSD 系統"
-  de: "Würde das OpenBSD-System aktualisieren"
-"Would upgrade OpenBSD packages":
-  en: "Would upgrade OpenBSD packages"
-  lt: "Atnaujintų OpenBSD paketus"
-  es: "Actualizaría los paquetes de OpenBSD"
-  fr: "Mettrait à jour les paquets OpenBSD"
-  zh_CN: "将升级 OpenBSD 软件包"
-  zh_TW: "會升級 OpenBSD 套件"
-  de: "Würde OpenBSD-Pakete aktualisieren"
 "Microsoft Store":
   en: "Microsoft Store"
   lt: "Microsoft parduotuvė"
@@ -1248,14 +1330,6 @@ _version: 2
   zh_CN: "成功，Microsoft Store 应用正在后台更新"
   zh_TW: "成功，Microsoft Store 應用程式正在後台更新"
   de: "Erfolg, Microsoft Store-Apps werden im Hintergrund aktualisiert"
-"Unable to update Microsoft Store apps, manual intervention is required":
-  en: "Unable to update Microsoft Store apps, manual intervention is required"
-  lt: "Nepavyksta atnaujinti Microsoft Store programų, reikia rankinio įsikišimo"
-  es: "No se pueden actualizar las aplicaciones de Microsoft Store, se requiere intervención manual"
-  fr: "Impossible de mettre à jour les applications du Microsoft Store, une intervention manuelle est nécessaire"
-  zh_CN: "无法更新 Microsoft Store 应用，需手动干预"
-  zh_TW: "無法更新 Microsoft Store 應用，需手動幹預"
-  de: "Microsoft Store-Apps können nicht aktualisiert werden, manuelles Eingreifen erforderlich"
 "No JetBrains Toolbox installation found":
   en: "No JetBrains Toolbox installation found"
   lt: "Nerasta JetBrains Toolbox įdiegimo"
@@ -1277,7 +1351,7 @@ _version: 2
   lt: "jetbrains-toolbox-updater susidūrė su netikėta klaida ieškant:"
   es: "jetbrains-toolbox-updater encontró un error inesperado durante la búsqueda:"
   fr: "jetbrains-toolbox-updater a rencontré une erreur inattendue lors de la recherche:"
-  zh_CN: "jetbrains-toolbox-updater 在寻找过程中遇到意外错误"
+  zh_CN: "jetbrains-toolbox-updater 在寻找过程中遇到意外错误："
   zh_TW: "jetbrains-toolbox-updater 在尋找過程中遇到意外錯誤："
   de: "jetbrains-toolbox-updater ist auf einen unerwarteten Fehler bei der Suche gestoßen:"
 "jetbrains-toolbox-updater encountered an unexpected error during updating:":
@@ -1285,6 +1359,54 @@ _version: 2
   lt: "jetbrains-toolbox-updater susidūrė su netikėta klaida atnaujinant:"
   es: "jetbrains-toolbox-updater encontró un error inesperado durante la actualización:"
   fr: "jetbrains-toolbox-updater a rencontré une erreur inattendue lors de la mise à jour:"
-  zh_CN: "jetbrains-toolbox-updater 在更新过程中遇到意外错误"
+  zh_CN: "jetbrains-toolbox-updater 在更新过程中遇到意外错误："
   zh_TW: "jetbrains-toolbox-updater 在更新過程中遇到意外錯誤："
   de: "jetbrains-toolbox-updater ist auf einen unerwarteten Fehler während der Aktualisierung gestoßen:"
+"<output from `deb-get clean` omitted>":
+  en: "<output from `deb-get clean` omitted>"
+  lt: "<išvestis iš `deb-get clean` praleista>"
+  es: "<salida de `deb-get clean` omitido>"
+  fr: "<sortie de `deb-get clean` omise>"
+  zh_CN: "<省略了 `deb-get clean` 的输出>"
+  zh_TW: "<省略了 `deb-get clean` 的輸出>"
+  de: "<Ausgabe von `deb-get clean` ausgelassen>"
+"You have a flake inside of $FLAKE. This is deprecated for nh.":
+  en: "You have a flake inside of $FLAKE. This is deprecated for nh."
+  lt: "Jūs turite flake viduje $FLAKE. Tai yra pasenę nh."
+  es: "Tienes un flake dentro de $FLAKE. Esto está en desuso para nh."
+  fr: "Vous avez un flake à l'intérieur de $FLAKE. Ceci est obsolète pour nh."
+  zh_CN: "你在 $FLAKE 里有一个 flake。这在 nh 中已被弃用。"
+  zh_TW: "你在 $FLAKE 裡有一個 flake。這在 nh 中已被棄用。"
+  de: "Sie haben ein flake in $FLAKE. Dies ist für nh veraltet."
+"nh cannot find any configured flakes":
+  en: "nh cannot find any configured flakes"
+  lt: "nh nepavyksta rasti jokių sukonfigūruotų flake"
+  es: "nh no puede encontrar ningún flake configurado"
+  fr: "nh ne peut trouver aucun flake configuré"
+  zh_CN: "nh 无法找到任何已配置的 flake"
+  zh_TW: "nh 找不到任何已設定的 flake"
+  de: "nh kann keine konfigurierten flakes finden"
+"System Manuals":
+  en: "System Manuals"
+  lt: "Sistemos Vadovai"
+  es: "Manuales del Sistema"
+  fr: "Manuels du Système"
+  zh_CN: "系统手册"
+  zh_TW: "系統手冊"
+  de: "Systemhandbücher"
+"User Manuals":
+  en: "User Manuals"
+  lt: "Vartotojo Vadovai"
+  es: "Manuales de Usuario"
+  fr: "Manuels de l'utilisateur"
+  zh_CN: "用户手册"
+  zh_TW: "使用者手冊"
+  de: "Benutzerhandbücher"
+"ManDB isn't enabled":
+  en: "ManDB isn't enabled"
+  lt: "ManDB nėra įjungtas"
+  es: "ManDB no está habilitado"
+  fr: "ManDB n'est pas activé"
+  zh_CN: "ManDB 未启用"
+  zh_TW: "ManDB 未啟用"
+  de: "ManDB ist nicht aktiviert"

pyproject.toml

@@ -4,6 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "topgrade"
+dynamic = ["version"]
 requires-python = ">=3.7"
 classifiers = [
     "Programming Language :: Rust",

renovate.json

@@ -0,0 +1,10 @@
+{
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "extends": [
+        "config:best-practices",
+        ":semanticCommits"
+    ],
+    "lockFileMaintenance": {
+        "enabled": true
+    }
+}

src/command.rs

@@ -115,6 +115,9 @@ pub trait CommandExt {
     ///
     /// Returns an `Err` if the command failed to execute, if `succeeded` returns an `Err`, or if
     /// the output contains invalid UTF-8.
+    // This function is currently unused, but is useful and makes sense with `output_checked_with`
+    //  and `output_checked_utf8` existing.
+    #[allow(dead_code)]
     #[track_caller]
     fn output_checked_with_utf8(
         &mut self,

src/config.rs

@@ -1,6 +1,5 @@
 #![allow(dead_code)]
 
-use std::collections::BTreeMap;
 use std::fs::{write, File};
 use std::io::Write;
 use std::path::{Path, PathBuf};
@@ -12,19 +11,21 @@ use clap_complete::Shell;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
 use etcetera::base_strategy::BaseStrategy;
+use indexmap::IndexMap;
 use merge::Merge;
 use regex::Regex;
 use regex_split::RegexSplit;
-use rust_i18n::t;
 use serde::Deserialize;
-use strum::{EnumIter, EnumString, IntoEnumIterator, VariantNames};
+use strum::IntoEnumIterator;
+use tracing::{debug, error};
 use which_crate::which;
 
 use super::utils::editor;
 use crate::command::CommandExt;
+use crate::execution_context::RunType;
+use crate::step::Step;
 use crate::sudo::SudoKind;
 use crate::utils::string_prepend_str;
-use tracing::{debug, error};
 
 // TODO: Add i18n to this. Tracking issue: https://github.com/topgrade-rs/topgrade/issues/859
 pub static EXAMPLE_CONFIG: &str = include_str!("../config.example.toml");
@@ -44,139 +45,7 @@ macro_rules! str_value {
     };
 }
 
-pub type Commands = BTreeMap<String, String>;
-
-#[derive(ValueEnum, EnumString, VariantNames, Debug, Clone, PartialEq, Eq, Deserialize, EnumIter, Copy)]
-#[clap(rename_all = "snake_case")]
-#[serde(rename_all = "snake_case")]
-#[strum(serialize_all = "snake_case")]
-pub enum Step {
-    AM,
-    AppMan,
-    Asdf,
-    Atom,
-    Aqua,
-    Audit,
-    AutoCpufreq,
-    Bin,
-    Bob,
-    BrewCask,
-    BrewFormula,
-    Bun,
-    BunPackages,
-    Cargo,
-    Certbot,
-    Chezmoi,
-    Chocolatey,
-    Choosenim,
-    CinnamonSpices,
-    ClamAvDb,
-    Composer,
-    Conda,
-    ConfigUpdate,
-    Containers,
-    CustomCommands,
-    DebGet,
-    Deno,
-    Distrobox,
-    DkpPacman,
-    Dotnet,
-    Elan,
-    Emacs,
-    Firmware,
-    Flatpak,
-    Flutter,
-    Fossil,
-    Gcloud,
-    Gem,
-    Ghcup,
-    GithubCliExtensions,
-    GitRepos,
-    GnomeShellExtensions,
-    Go,
-    Guix,
-    Haxelib,
-    Helm,
-    HomeManager,
-    JetBrainsToolbox,
-    Jetpack,
-    Julia,
-    Juliaup,
-    Kakoune,
-    Helix,
-    Krew,
-    Lure,
-    Lensfun,
-    Macports,
-    Mamba,
-    Miktex,
-    Mas,
-    Maza,
-    Micro,
-    MicrosoftStore,
-    Mise,
-    Myrepos,
-    Nix,
-    Node,
-    Opam,
-    Pacdef,
-    Pacstall,
-    Pearl,
-    Pip3,
-    PipReview,
-    PipReviewLocal,
-    Pipupgrade,
-    Pipx,
-    Pipxu,
-    Pixi,
-    Pkg,
-    Pkgin,
-    PlatformioCore,
-    Pnpm,
-    Poetry,
-    Powershell,
-    Protonup,
-    Pyenv,
-    Raco,
-    Rcm,
-    Remotes,
-    Restarts,
-    Rtcl,
-    RubyGems,
-    Rustup,
-    Rye,
-    Scoop,
-    Sdkman,
-    SelfUpdate,
-    Sheldon,
-    Shell,
-    Snap,
-    Sparkle,
-    Spicetify,
-    Stack,
-    Stew,
-    System,
-    Tldr,
-    Tlmgr,
-    Tmux,
-    Toolbx,
-    Uv,
-    Vagrant,
-    Vcpkg,
-    Vim,
-    VoltaPackages,
-    Vscode,
-    Vscodium,
-    Waydroid,
-    Winget,
-    Wsl,
-    WslUpdate,
-    Xcodes,
-    Yadm,
-    Yarn,
-    Zigup,
-    Zvm,
-}
+pub type Commands = IndexMap<String, String>;
 
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
@@ -193,6 +62,12 @@ pub struct Containers {
     runtime: Option<ContainerRuntime>,
 }
 
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+pub struct Mandb {
+    enable: Option<bool>,
+}
+
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 pub struct Git {
@@ -217,15 +92,26 @@ pub struct Vagrant {
     always_suspend: Option<bool>,
 }
 
+#[derive(Deserialize, Default, Debug, Copy, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum UpdatesAutoReboot {
+    Yes,
+    #[default]
+    No,
+    Ask,
+}
+
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 pub struct Windows {
     accept_all_updates: Option<bool>,
+    updates_auto_reboot: Option<UpdatesAutoReboot>,
     self_rename: Option<bool>,
     open_remotes_in_new_terminal: Option<bool>,
     wsl_update_pre_release: Option<bool>,
     wsl_update_use_web_download: Option<bool>,
     winget_silent_install: Option<bool>,
+    winget_use_sudo: Option<bool>,
 }
 
 #[derive(Deserialize, Default, Debug, Merge)]
@@ -238,6 +124,16 @@ pub struct Python {
     poetry_force_self_update: Option<bool>,
 }
 
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+pub struct Conda {
+    #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
+    env_names: Option<Vec<String>>,
+
+    #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
+    env_paths: Option<Vec<String>>,
+}
+
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 #[allow(clippy::upper_case_acronyms)]
@@ -269,6 +165,13 @@ pub struct Deno {
     version: Option<String>,
 }
 
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+#[allow(clippy::upper_case_acronyms)]
+pub struct Chezmoi {
+    exclude_encrypted: Option<bool>,
+}
+
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 #[allow(clippy::upper_case_acronyms)]
@@ -283,6 +186,13 @@ pub struct Flatpak {
     use_sudo: Option<bool>,
 }
 
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+#[allow(clippy::upper_case_acronyms)]
+pub struct Pixi {
+    include_release_notes: Option<bool>,
+}
+
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 pub struct Brew {
@@ -392,6 +302,8 @@ pub struct Vim {
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 pub struct Misc {
+    allow_root: Option<bool>,
+
     pre_sudo: Option<bool>,
 
     sudo_command: Option<SudoKind>,
@@ -421,6 +333,8 @@ pub struct Misc {
 
     no_retry: Option<bool>,
 
+    show_skipped: Option<bool>,
+
     run_in_tmux: Option<bool>,
 
     tmux_session_mode: Option<TmuxSessionMode>,
@@ -439,6 +353,8 @@ pub struct Misc {
     no_self_update: Option<bool>,
 
     log_filters: Option<Vec<String>>,
+
+    show_distribution_summary: Option<bool>,
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, ValueEnum)]
@@ -481,6 +397,24 @@ pub struct VscodeConfig {
     profile: Option<String>,
 }
 
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+pub struct DoomConfig {
+    aot: Option<bool>,
+}
+
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+pub struct Rustup {
+    channels: Option<Vec<String>>,
+}
+
+#[derive(Deserialize, Default, Debug, Merge)]
+#[serde(deny_unknown_fields)]
+pub struct Pkgfile {
+    enable: Option<bool>,
+}
+
 #[derive(Deserialize, Default, Debug, Merge)]
 #[serde(deny_unknown_fields)]
 /// Configuration file
@@ -500,6 +434,9 @@ pub struct ConfigFile {
     #[merge(strategy = crate::utils::merge_strategies::commands_merge_opt)]
     commands: Option<Commands>,
 
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    conda: Option<Conda>,
+
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     python: Option<Python>,
 
@@ -512,6 +449,9 @@ pub struct ConfigFile {
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     linux: Option<Linux>,
 
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    mandb: Option<Mandb>,
+
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     git: Option<Git>,
 
@@ -524,6 +464,9 @@ pub struct ConfigFile {
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     npm: Option<NPM>,
 
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    chezmoi: Option<Chezmoi>,
+
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     yarn: Option<Yarn>,
 
@@ -542,6 +485,9 @@ pub struct ConfigFile {
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     flatpak: Option<Flatpak>,
 
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    pixi: Option<Pixi>,
+
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     distrobox: Option<Distrobox>,
 
@@ -556,6 +502,15 @@ pub struct ConfigFile {
 
     #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
     vscode: Option<VscodeConfig>,
+
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    doom: Option<DoomConfig>,
+
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    rustup: Option<Rustup>,
+
+    #[merge(strategy = crate::utils::merge_strategies::inner_merge_opt)]
+    pkgfile: Option<Pkgfile>,
 }
 
 fn config_directory() -> PathBuf {
@@ -722,17 +677,6 @@ impl ConfigFile {
             }
         }
 
-        if let Some(paths) = result.git.as_mut().and_then(|git| git.repos.as_mut()) {
-            for path in paths.iter_mut() {
-                let expanded = shellexpand::tilde::<&str>(&path.as_ref()).into_owned();
-                debug!(
-                    "{}",
-                    t!("Path {path} expanded to {expanded}", path = path, expanded = expanded)
-                );
-                *path = expanded;
-            }
-        }
-
         debug!("Loaded configuration: {:?}", result);
         Ok(result)
     }
@@ -783,14 +727,24 @@ pub struct CommandLineArgs {
     #[arg(short = 't', long = "tmux")]
     run_in_tmux: bool,
 
+    /// Don't run inside tmux
+    #[arg(long = "no-tmux")]
+    no_tmux: bool,
+
     /// Cleanup temporary or old files
     #[arg(short = 'c', long = "cleanup")]
     cleanup: bool,
 
     /// Print what would be done
+    ///
+    /// Alias for --run-type dry
     #[arg(short = 'n', long = "dry-run")]
     dry_run: bool,
 
+    /// Pick between just running commands, running and logging commands, and just logging commands
+    #[arg(short = 'r', long = "run-type", value_enum, default_value_t)]
+    run_type: RunType,
+
     /// Do not ask to retry failed steps
     #[arg(long = "no-retry")]
     no_retry: bool,
@@ -849,6 +803,10 @@ pub struct CommandLineArgs {
     #[arg(long = "show-skipped")]
     show_skipped: bool,
 
+    /// Suppress warning and confirmation prompt if running as root
+    #[arg(long = "allow-root")]
+    allow_root: bool,
+
     /// Tracing filter directives.
     ///
     /// See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives
@@ -962,6 +920,22 @@ impl Config {
         &self.config_file.commands
     }
 
+    /// The list of additional named conda environments.
+    pub fn conda_env_names(&self) -> Option<&Vec<String>> {
+        self.config_file
+            .conda
+            .as_ref()
+            .and_then(|conda| conda.env_names.as_ref())
+    }
+
+    /// The list of additional conda environment paths.
+    pub fn conda_env_paths(&self) -> Option<&Vec<String>> {
+        self.config_file
+            .conda
+            .as_ref()
+            .and_then(|conda| conda.env_paths.as_ref())
+    }
+
     /// The list of additional git repositories to pull.
     pub fn git_repos(&self) -> Option<&Vec<String>> {
         self.config_file.git.as_ref().and_then(|git| git.repos.as_ref())
@@ -993,16 +967,21 @@ impl Config {
     }
 
     fn allowed_steps(opt: &CommandLineArgs, config_file: &ConfigFile) -> Vec<Step> {
+        // The enabled steps are
         let mut enabled_steps: Vec<Step> = Vec::new();
+        // Any steps that are passed with `--only`
         enabled_steps.extend(&opt.only);
 
+        // Plus any steps in the config file's `misc.only`
         if let Some(misc) = config_file.misc.as_ref() {
             if let Some(only) = misc.only.as_ref() {
                 enabled_steps.extend(only);
             }
         }
 
+        // If neither of those contain anything
         if enabled_steps.is_empty() {
+            // All steps are enabled
             enabled_steps.extend(Step::iter());
         }
 
@@ -1014,6 +993,7 @@ impl Config {
             }
         }
 
+        // All steps that are disabled are not enabled, except ones that are passed to `--only`
         enabled_steps.retain(|e| !disabled_steps.contains(e) || opt.only.contains(e));
         enabled_steps
     }
@@ -1031,13 +1011,14 @@ impl Config {
 
     /// Tell whether we should run in tmux.
     pub fn run_in_tmux(&self) -> bool {
-        self.opt.run_in_tmux
-            || self
-                .config_file
-                .misc
-                .as_ref()
-                .and_then(|misc| misc.run_in_tmux)
-                .unwrap_or(false)
+        !self.opt.no_tmux
+            && (self.opt.run_in_tmux
+                || self
+                    .config_file
+                    .misc
+                    .as_ref()
+                    .and_then(|misc| misc.run_in_tmux)
+                    .unwrap_or(false))
     }
 
     /// The preferred way to run the new tmux session.
@@ -1060,9 +1041,13 @@ impl Config {
                 .unwrap_or(false)
     }
 
-    /// Tell whether we are dry-running.
-    pub fn dry_run(&self) -> bool {
-        self.opt.dry_run
+    /// Get the [RunType] for the current execution
+    pub fn run_type(&self) -> RunType {
+        if self.opt.dry_run {
+            RunType::Dry
+        } else {
+            self.opt.run_type
+        }
     }
 
     /// Tell whether we should not attempt to retry anything.
@@ -1191,6 +1176,15 @@ impl Config {
             .unwrap_or(true)
     }
 
+    /// Whether to auto reboot for Windows updates that require it
+    pub fn windows_updates_auto_reboot(&self) -> UpdatesAutoReboot {
+        self.config_file
+            .windows
+            .as_ref()
+            .and_then(|windows| windows.updates_auto_reboot)
+            .unwrap_or_default()
+    }
+
     /// Whether to self rename the Topgrade executable during the run
     pub fn self_rename(&self) -> bool {
         self.config_file
@@ -1218,6 +1212,15 @@ impl Config {
             .unwrap_or(false)
     }
 
+    /// Should use sudo for Winget
+    pub fn winget_use_sudo(&self) -> bool {
+        self.config_file
+            .windows
+            .as_ref()
+            .and_then(|w| w.winget_use_sudo)
+            .unwrap_or(false)
+    }
+
     /// Whether Brew cask should be greedy
     pub fn brew_cask_greedy(&self) -> bool {
         self.config_file
@@ -1327,6 +1330,15 @@ impl Config {
             .unwrap_or("")
     }
 
+    /// Show release notes of latest pixi release
+    pub fn show_pixi_release_notes(&self) -> bool {
+        self.config_file
+            .pixi
+            .as_ref()
+            .and_then(|s| s.include_release_notes)
+            .unwrap_or(false)
+    }
+
     /// Show news on Arch Linux
     pub fn show_arch_news(&self) -> bool {
         self.config_file
@@ -1514,6 +1526,14 @@ impl Config {
                 .unwrap_or(true)
     }
 
+    pub fn rustup_channels(&self) -> Vec<String> {
+        self.config_file
+            .rustup
+            .as_ref()
+            .and_then(|rustup| rustup.channels.clone())
+            .unwrap_or_default()
+    }
+
     pub fn verbose(&self) -> bool {
         self.opt.verbose
     }
@@ -1541,6 +1561,20 @@ impl Config {
 
     pub fn show_skipped(&self) -> bool {
         self.opt.show_skipped
+            || self
+                .config_file
+                .misc
+                .as_ref()
+                .and_then(|misc| misc.show_skipped)
+                .unwrap_or(false)
+    }
+
+    pub fn enable_mandb(&self) -> bool {
+        self.config_file
+            .mandb
+            .as_ref()
+            .and_then(|mandb| mandb.enable)
+            .unwrap_or(false)
     }
 
     pub fn open_remotes_in_new_terminal(&self) -> bool {
@@ -1559,12 +1593,21 @@ impl Config {
             .unwrap_or(true)
     }
 
+    pub fn allow_root(&self) -> bool {
+        self.opt.allow_root
+            || self
+                .config_file
+                .misc
+                .as_ref()
+                .and_then(|misc| misc.allow_root)
+                .unwrap_or(false)
+    }
+
     pub fn sudo_command(&self) -> Option<SudoKind> {
         self.config_file.misc.as_ref().and_then(|misc| misc.sudo_command)
     }
 
-    /// If `true`, `sudo` should be called after `pre_commands` in order to elevate at the
-    /// start of the session (and not in the middle).
+    /// If `true`, `sudo -v` should be called to cache credentials at the start of the run
     pub fn pre_sudo(&self) -> bool {
         self.config_file
             .misc
@@ -1573,6 +1616,14 @@ impl Config {
             .unwrap_or(false)
     }
 
+    pub fn show_distribution_summary(&self) -> bool {
+        self.config_file
+            .misc
+            .as_ref()
+            .and_then(|misc| misc.show_distribution_summary)
+            .unwrap_or(true)
+    }
+
     #[cfg(target_os = "linux")]
     pub fn npm_use_sudo(&self) -> bool {
         self.config_file
@@ -1732,6 +1783,14 @@ impl Config {
             .unwrap_or(false)
     }
 
+    pub fn chezmoi_exclude_encrypted(&self) -> bool {
+        self.config_file
+            .chezmoi
+            .as_ref()
+            .and_then(|chezmoi| chezmoi.exclude_encrypted)
+            .unwrap_or(false)
+    }
+
     pub fn vscode_profile(&self) -> Option<&str> {
         let vscode_cfg = self.config_file.vscode.as_ref()?;
         let profile = vscode_cfg.profile.as_ref()?;
@@ -1742,6 +1801,22 @@ impl Config {
             Some(profile.as_str())
         }
     }
+
+    pub fn doom_aot(&self) -> bool {
+        self.config_file
+            .doom
+            .as_ref()
+            .and_then(|doom| doom.aot)
+            .unwrap_or(false)
+    }
+
+    pub fn enable_pkgfile(&self) -> bool {
+        self.config_file
+            .pkgfile
+            .as_ref()
+            .and_then(|pkgfile| pkgfile.enable)
+            .unwrap_or(false)
+    }
 }
 
 #[cfg(test)]

src/ctrlc/windows.rs

@@ -1,22 +1,21 @@
 //! A stub for Ctrl + C handling.
 use crate::ctrlc::interrupted::set_interrupted;
 use tracing::error;
-use winapi::shared::minwindef::{BOOL, DWORD, FALSE, TRUE};
-use winapi::um::consoleapi::SetConsoleCtrlHandler;
-use winapi::um::wincon::CTRL_C_EVENT;
+use windows::core::BOOL;
+use windows::Win32::System::Console::{SetConsoleCtrlHandler, CTRL_C_EVENT};
 
-extern "system" fn handler(ctrl_type: DWORD) -> BOOL {
+extern "system" fn handler(ctrl_type: u32) -> BOOL {
     match ctrl_type {
         CTRL_C_EVENT => {
             set_interrupted();
-            TRUE
+            true.into()
         }
-        _ => FALSE,
+        _ => false.into(),
     }
 }
 
 pub fn set_handler() {
-    if 0 == unsafe { SetConsoleCtrlHandler(Some(handler), TRUE) } {
-        error!("Cannot set a control C handler")
+    if let Err(e) = unsafe { SetConsoleCtrlHandler(Some(handler), true) } {
+        error!("Cannot set a control C handler: {e}")
     }
 }

src/error.rs

@@ -3,6 +3,8 @@ use std::{fmt::Display, process::ExitStatus};
 use rust_i18n::t;
 use thiserror::Error;
 
+use crate::sudo::SudoKind;
+
 #[derive(Error, Debug, PartialEq, Eq)]
 pub enum TopgradeError {
     ProcessFailed(String, ExitStatus),
@@ -68,6 +70,35 @@ impl Display for StepFailed {
     }
 }
 
+#[derive(Error, Debug)]
+pub struct UnsupportedSudo<'a> {
+    pub sudo_kind: SudoKind,
+    pub option: &'a str,
+}
+
+impl Display for UnsupportedSudo<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            t!(
+                "{sudo_kind} does not support the {option} option",
+                sudo_kind = self.sudo_kind,
+                option = self.option
+            )
+        )
+    }
+}
+
+#[derive(Error, Debug)]
+pub struct MissingSudo();
+
+impl Display for MissingSudo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", t!("Could not find sudo"))
+    }
+}
+
 #[derive(Error, Debug)]
 pub struct DryRun();
 
@@ -85,14 +116,3 @@ impl Display for SkipStep {
         write!(f, "{}", self.0)
     }
 }
-
-#[cfg(all(windows, feature = "self-update"))]
-#[derive(Error, Debug)]
-pub struct Upgraded(pub ExitStatus);
-
-#[cfg(all(windows, feature = "self-update"))]
-impl Display for Upgraded {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", t!("Topgrade Upgraded"))
-    }
-}

src/execution_context.rs

@@ -1,12 +1,48 @@
 #![allow(dead_code)]
-use crate::executor::RunType;
-use crate::sudo::Sudo;
-use crate::utils::{get_require_sudo_string, require_option};
-use crate::{config::Config, executor::Executor};
-use color_eyre::eyre::Result;
 use std::env::var;
-use std::path::Path;
-use std::sync::Mutex;
+use std::ffi::OsStr;
+use std::process::Command;
+use std::sync::{LazyLock, Mutex};
+
+use clap::ValueEnum;
+use color_eyre::eyre::Result;
+use rust_i18n::t;
+use serde::Deserialize;
+use strum::EnumString;
+
+use crate::config::Config;
+use crate::error::MissingSudo;
+use crate::executor::{DryCommand, Executor};
+use crate::powershell::Powershell;
+#[cfg(target_os = "linux")]
+use crate::steps::linux::Distribution;
+use crate::sudo::Sudo;
+use crate::utils::require_option;
+
+/// An enum telling whether Topgrade should perform dry runs or actually perform the steps.
+#[derive(Clone, Copy, Debug, Deserialize, Default, EnumString, ValueEnum)]
+pub enum RunType {
+    /// Executing commands will just print the command with its argument.
+    Dry,
+
+    /// Executing commands will perform actual execution.
+    #[default]
+    Wet,
+
+    /// Executing commands will print the command and perform actual execution.
+    Damp,
+}
+
+impl RunType {
+    /// Tells whether we're performing a dry run.
+    pub fn dry(self) -> bool {
+        match self {
+            RunType::Dry => true,
+            RunType::Wet => false,
+            RunType::Damp => false,
+        }
+    }
+}
 
 pub struct ExecutionContext<'a> {
     run_type: RunType,
@@ -18,10 +54,18 @@ pub struct ExecutionContext<'a> {
     tmux_session: Mutex<Option<String>>,
     /// True if topgrade is running under ssh.
     under_ssh: bool,
+    #[cfg(target_os = "linux")]
+    distribution: &'a Result<Distribution>,
+    powershell: LazyLock<Option<Powershell>>,
 }
 
 impl<'a> ExecutionContext<'a> {
-    pub fn new(run_type: RunType, sudo: Option<Sudo>, config: &'a Config) -> Self {
+    pub fn new(
+        run_type: RunType,
+        sudo: Option<Sudo>,
+        config: &'a Config,
+        #[cfg(target_os = "linux")] distribution: &'a Result<Distribution>,
+    ) -> Self {
         let under_ssh = var("SSH_CLIENT").is_ok() || var("SSH_TTY").is_ok();
         Self {
             run_type,
@@ -29,12 +73,19 @@ impl<'a> ExecutionContext<'a> {
             config,
             tmux_session: Mutex::new(None),
             under_ssh,
+            #[cfg(target_os = "linux")]
+            distribution,
+            powershell: LazyLock::new(Powershell::new),
         }
     }
 
-    pub fn execute_elevated(&self, command: &Path, interactive: bool) -> Result<Executor> {
-        let sudo = require_option(self.sudo.as_ref(), get_require_sudo_string())?;
-        Ok(sudo.execute_elevated(self, command, interactive))
+    /// Create an instance of `Executor` that should run `program`.
+    pub fn execute<S: AsRef<OsStr>>(&self, program: S) -> Executor {
+        match self.run_type {
+            RunType::Dry => Executor::Dry(DryCommand::new(program)),
+            RunType::Wet => Executor::Wet(Command::new(program)),
+            RunType::Damp => Executor::Damp(Command::new(program)),
+        }
     }
 
     pub fn run_type(&self) -> RunType {
@@ -45,6 +96,14 @@ impl<'a> ExecutionContext<'a> {
         &self.sudo
     }
 
+    pub fn require_sudo(&self) -> Result<&Sudo> {
+        if let Some(value) = self.sudo() {
+            Ok(value)
+        } else {
+            Err(MissingSudo().into())
+        }
+    }
+
     pub fn config(&self) -> &Config {
         self.config
     }
@@ -60,4 +119,17 @@ impl<'a> ExecutionContext<'a> {
     pub fn get_tmux_session(&self) -> Option<String> {
         self.tmux_session.lock().unwrap().clone()
     }
+
+    #[cfg(target_os = "linux")]
+    pub fn distribution(&self) -> &Result<Distribution> {
+        self.distribution
+    }
+
+    pub fn powershell(&self) -> &Option<Powershell> {
+        &self.powershell
+    }
+
+    pub fn require_powershell(&self) -> Result<&Powershell> {
+        require_option(self.powershell.as_ref(), t!("Powershell is not installed").to_string())
+    }
 }

src/executor.rs

@@ -1,60 +1,23 @@
 //! Utilities for command execution
 use std::ffi::{OsStr, OsString};
+use std::fmt::Debug;
+use std::iter;
 use std::path::Path;
 use std::process::{Child, Command, ExitStatus, Output};
 
 use color_eyre::eyre::Result;
 use rust_i18n::t;
-use tracing::debug;
+use tracing::{debug, enabled, Level};
 
 use crate::command::CommandExt;
 use crate::error::DryRun;
 
-/// An enum telling whether Topgrade should perform dry runs or actually perform the steps.
-#[derive(Clone, Copy, Debug)]
-pub enum RunType {
-    /// Executing commands will just print the command with its argument.
-    Dry,
-
-    /// Executing commands will perform actual execution.
-    Wet,
-}
-
-impl RunType {
-    /// Create a new instance from a boolean telling whether to dry run.
-    pub fn new(dry_run: bool) -> Self {
-        if dry_run {
-            RunType::Dry
-        } else {
-            RunType::Wet
-        }
-    }
-
-    /// Create an instance of `Executor` that should run `program`.
-    pub fn execute<S: AsRef<OsStr>>(self, program: S) -> Executor {
-        match self {
-            RunType::Dry => Executor::Dry(DryCommand {
-                program: program.as_ref().into(),
-                ..Default::default()
-            }),
-            RunType::Wet => Executor::Wet(Command::new(program)),
-        }
-    }
-
-    /// Tells whether we're performing a dry run.
-    pub fn dry(self) -> bool {
-        match self {
-            RunType::Dry => true,
-            RunType::Wet => false,
-        }
-    }
-}
-
 /// An enum providing a similar interface to `std::process::Command`.
 /// If the enum is set to `Wet`, execution will be performed with `std::process::Command`.
 /// If the enum is set to `Dry`, execution will just print the command with its arguments.
 pub enum Executor {
     Wet(Command),
+    Damp(Command),
     Dry(DryCommand),
 }
 
@@ -64,7 +27,7 @@ impl Executor {
     /// Will give weird results for non-UTF-8 programs; see `to_string_lossy()`.
     pub fn get_program(&self) -> String {
         match self {
-            Executor::Wet(c) => c.get_program().to_string_lossy().into_owned(),
+            Executor::Wet(c) | Executor::Damp(c) => c.get_program().to_string_lossy().into_owned(),
             Executor::Dry(c) => c.program.to_string_lossy().into_owned(),
         }
     }
@@ -72,7 +35,7 @@ impl Executor {
     /// See `std::process::Command::arg`
     pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Executor {
         match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 c.arg(arg);
             }
             Executor::Dry(c) => {
@@ -90,7 +53,7 @@ impl Executor {
         S: AsRef<OsStr>,
     {
         match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 c.args(args);
             }
             Executor::Dry(c) => {
@@ -105,7 +68,7 @@ impl Executor {
     /// See `std::process::Command::current_dir`
     pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Executor {
         match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 c.current_dir(dir);
             }
             Executor::Dry(c) => c.directory = Some(dir.as_ref().into()),
@@ -121,7 +84,7 @@ impl Executor {
         K: AsRef<OsStr>,
     {
         match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 c.env_remove(key);
             }
             Executor::Dry(_) => (),
@@ -138,7 +101,7 @@ impl Executor {
         V: AsRef<OsStr>,
     {
         match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 c.env(key, val);
             }
             Executor::Dry(_) => (),
@@ -149,18 +112,16 @@ impl Executor {
 
     /// See `std::process::Command::spawn`
     pub fn spawn(&mut self) -> Result<ExecutorChild> {
+        self.log_command();
         let result = match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 debug!("Running {:?}", c);
                 // We should use `spawn()` here rather than `spawn_checked()` since
                 // their semantics and behaviors are different.
                 #[allow(clippy::disallowed_methods)]
                 c.spawn().map(ExecutorChild::Wet)?
             }
-            Executor::Dry(c) => {
-                c.dry_run();
-                ExecutorChild::Dry
-            }
+            Executor::Dry(_) => ExecutorChild::Dry,
         };
 
         Ok(result)
@@ -168,17 +129,15 @@ impl Executor {
 
     /// See `std::process::Command::output`
     pub fn output(&mut self) -> Result<ExecutorOutput> {
+        self.log_command();
         match self {
-            Executor::Wet(c) => {
+            Executor::Wet(c) | Executor::Damp(c) => {
                 // We should use `output()` here rather than `output_checked()` since
                 // their semantics and behaviors are different.
                 #[allow(clippy::disallowed_methods)]
                 Ok(ExecutorOutput::Wet(c.output()?))
             }
-            Executor::Dry(c) => {
-                c.dry_run();
-                Ok(ExecutorOutput::Dry)
-            }
+            Executor::Dry(_) => Ok(ExecutorOutput::Dry),
         }
     }
 
@@ -186,18 +145,38 @@ impl Executor {
     /// that can indicate success of a script
     #[allow(dead_code)]
     pub fn status_checked_with_codes(&mut self, codes: &[i32]) -> Result<()> {
+        self.log_command();
         match self {
-            Executor::Wet(c) => c.status_checked_with(|status| {
+            Executor::Wet(c) | Executor::Damp(c) => c.status_checked_with(|status| {
                 if status.success() || status.code().as_ref().is_some_and(|c| codes.contains(c)) {
                     Ok(())
                 } else {
                     Err(())
                 }
             }),
-            Executor::Dry(c) => {
-                c.dry_run();
-                Ok(())
+            Executor::Dry(_) => Ok(()),
+        }
+    }
+
+    fn log_command(&self) {
+        match self {
+            Executor::Wet(_) => (),
+            Executor::Damp(c) => {
+                log_command(
+                    "Executing: {program_name} {arguments}",
+                    c.get_program(),
+                    c.get_args(),
+                    c.get_envs(),
+                    c.get_current_dir(),
+                );
             }
+            Executor::Dry(c) => log_command(
+                "Dry running: {program_name} {arguments}",
+                &c.program,
+                &c.args,
+                iter::empty(),
+                c.directory.as_ref(),
+            ),
         }
     }
 }
@@ -207,8 +186,7 @@ pub enum ExecutorOutput {
     Dry,
 }
 
-/// A struct represending a command. Trying to execute it will just print its arguments.
-#[derive(Default)]
+/// A struct representing a command. Trying to execute it will just print its arguments.
 pub struct DryCommand {
     program: OsString,
     args: Vec<OsString>,
@@ -216,29 +194,18 @@ pub struct DryCommand {
 }
 
 impl DryCommand {
-    fn dry_run(&self) {
-        print!(
-            "{}",
-            t!(
-                "Dry running: {program_name} {arguments}",
-                program_name = self.program.to_string_lossy(),
-                arguments = shell_words::join(
-                    self.args
-                        .iter()
-                        .map(|a| String::from(a.to_string_lossy()))
-                        .collect::<Vec<String>>()
-                )
-            )
-        );
-        match &self.directory {
-            Some(dir) => println!(" {}", t!("in {directory}", directory = dir.to_string_lossy())),
-            None => println!(),
-        };
+    pub fn new<S: AsRef<OsStr>>(program: S) -> Self {
+        Self {
+            program: program.as_ref().to_os_string(),
+            args: Vec::new(),
+            directory: None,
+        }
     }
 }
 
 /// The Result of spawn. Contains an actual `std::process::Child` if executed by a wet command.
 pub enum ExecutorChild {
+    // Both RunType::Wet and RunType::Damp use this variant
     #[allow(unused)] // this type has not been used
     Wet(Child),
     Dry,
@@ -251,22 +218,18 @@ impl CommandExt for Executor {
     // variant for wet/dry runs.
 
     fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> Result<Output> {
+        self.log_command();
         match self {
-            Executor::Wet(c) => c.output_checked_with(succeeded),
-            Executor::Dry(c) => {
-                c.dry_run();
-                Err(DryRun().into())
-            }
+            Executor::Wet(c) | Executor::Damp(c) => c.output_checked_with(succeeded),
+            Executor::Dry(_) => Err(DryRun().into()),
         }
     }
 
     fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> Result<()> {
+        self.log_command();
         match self {
-            Executor::Wet(c) => c.status_checked_with(succeeded),
-            Executor::Dry(c) => {
-                c.dry_run();
-                Ok(())
-            }
+            Executor::Wet(c) | Executor::Damp(c) => c.status_checked_with(succeeded),
+            Executor::Dry(_) => Ok(()),
         }
     }
 
@@ -274,3 +237,42 @@ impl CommandExt for Executor {
         self.spawn()
     }
 }
+
+fn log_command<
+    'a,
+    I: ExactSizeIterator<Item = (&'a (impl Debug + 'a + ?Sized), Option<&'a (impl Debug + 'a + ?Sized)>)>,
+>(
+    prefix: &str,
+    exec: &OsStr,
+    args: impl IntoIterator<Item = &'a (impl AsRef<OsStr> + ?Sized + 'a)>,
+    env: impl IntoIterator<Item = (&'a OsStr, Option<&'a OsStr>), IntoIter = I>,
+    dir: Option<&'a (impl AsRef<Path> + ?Sized)>,
+) {
+    println!(
+        "{}",
+        t!(
+            prefix,
+            program_name = exec.to_string_lossy(),
+            arguments = shell_words::join(args.into_iter().map(|s| s.as_ref().to_string_lossy()))
+        )
+    );
+
+    let env_iter = env.into_iter();
+    if env_iter.len() != 0 && enabled!(Level::DEBUG) {
+        println!(
+            "  {}",
+            t!(
+                "with env: {env}",
+                env = env_iter
+                    .filter(|(_, val)| val.is_some())
+                    .map(|(key, val)| format!("{:?}={:?}", key, val.unwrap()))
+                    .collect::<Vec<_>>()
+                    .join(" ")
+            )
+        )
+    }
+
+    if let Some(d) = dir {
+        println!("  {}", t!("in {directory}", directory = d.as_ref().display()));
+    }
+}

src/lib.rs

@@ -1,2 +0,0 @@
-//pub mod steps;
-//pub mod utils;

src/main.rs

@@ -17,20 +17,19 @@ use etcetera::base_strategy::BaseStrategy;
 use etcetera::base_strategy::Windows;
 #[cfg(unix)]
 use etcetera::base_strategy::Xdg;
-use once_cell::sync::Lazy;
 use rust_i18n::{i18n, t};
+use std::sync::LazyLock;
 use tracing::debug;
 
-use self::config::{CommandLineArgs, Config, Step};
+use self::config::{CommandLineArgs, Config};
 use self::error::StepFailed;
-#[cfg(all(windows, feature = "self-update"))]
-use self::error::Upgraded;
+use self::runner::StepResult;
 #[allow(clippy::wildcard_imports)]
 use self::steps::{remote::*, *};
+use self::sudo::{Sudo, SudoCreateError, SudoKind};
 #[allow(clippy::wildcard_imports)]
 use self::terminal::*;
-
-use self::utils::{hostname, install_color_eyre, install_tracing, update_tracing};
+use self::utils::{install_color_eyre, install_tracing, is_elevated, update_tracing};
 
 mod breaking_changes;
 mod command;
@@ -39,23 +38,23 @@ mod ctrlc;
 mod error;
 mod execution_context;
 mod executor;
-mod report;
 mod runner;
 #[cfg(windows)]
 mod self_renamer;
 #[cfg(feature = "self-update")]
 mod self_update;
+mod step;
 mod steps;
 mod sudo;
 mod terminal;
 mod utils;
 
-pub(crate) static HOME_DIR: Lazy<PathBuf> = Lazy::new(|| home::home_dir().expect("No home directory"));
+pub(crate) static HOME_DIR: LazyLock<PathBuf> = LazyLock::new(|| home::home_dir().expect("No home directory"));
 #[cfg(unix)]
-pub(crate) static XDG_DIRS: Lazy<Xdg> = Lazy::new(|| Xdg::new().expect("No home directory"));
+pub(crate) static XDG_DIRS: LazyLock<Xdg> = LazyLock::new(|| Xdg::new().expect("No home directory"));
 
 #[cfg(windows)]
-pub(crate) static WINDOWS_DIRS: Lazy<Windows> = Lazy::new(|| Windows::new().expect("No home directory"));
+pub(crate) static WINDOWS_DIRS: LazyLock<Windows> = LazyLock::new(|| Windows::new().expect("No home directory"));
 
 // Init and load the i18n files
 i18n!("locales", fallback = "en");
@@ -97,9 +96,9 @@ fn run() -> Result<()> {
     }
 
     for env in opt.env_variables() {
-        let mut splitted = env.split('=');
-        let var = splitted.next().unwrap();
-        let value = splitted.next().unwrap();
+        let mut parts = env.split('=');
+        let var = parts.next().unwrap();
+        let value = parts.next().unwrap();
         env::set_var(var, value);
     }
 
@@ -122,8 +121,8 @@ fn run() -> Result<()> {
 
     debug!("Version: {}", crate_version!());
     debug!("OS: {}", env!("TARGET"));
-    debug!("{:?}", std::env::args());
-    debug!("Binary path: {:?}", std::env::current_exe());
+    debug!("{:?}", env::args());
+    debug!("Binary path: {:?}", env::current_exe());
     debug!("self-update Feature Enabled: {:?}", cfg!(feature = "self-update"));
     debug!("Configuration: {:?}", config);
 
@@ -135,44 +134,60 @@ fn run() -> Result<()> {
         }
     }
 
-    let powershell = powershell::Powershell::new();
-    let should_run_powershell = powershell.profile().is_some() && config.should_run(Step::Powershell);
-    let emacs = emacs::Emacs::new();
+    let elevated = is_elevated();
+
+    #[cfg(unix)]
+    if !config.allow_root() && elevated {
+        print_warning(t!(
+            "Topgrade should not be run as root, it will run commands with sudo or equivalent where needed."
+        ));
+        if !prompt_yesno(&t!("Continue?"))? {
+            exit(1)
+        }
+    }
+
+    let sudo = match config.sudo_command() {
+        Some(kind) => Sudo::new(kind),
+        None if elevated => Sudo::new(SudoKind::Null),
+        None => Sudo::detect(),
+    };
+    debug!("Sudo: {:?}", sudo);
+
+    let (sudo, sudo_err) = match sudo {
+        Ok(sudo) => (Some(sudo), None),
+        Err(e) => (None, Some(e)),
+    };
+
     #[cfg(target_os = "linux")]
     let distribution = linux::Distribution::detect();
 
-    let sudo = config.sudo_command().map_or_else(sudo::Sudo::detect, sudo::Sudo::new);
-    let run_type = executor::RunType::new(config.dry_run());
-    let ctx = execution_context::ExecutionContext::new(run_type, sudo, &config);
+    let run_type = config.run_type();
+    let ctx = execution_context::ExecutionContext::new(
+        run_type,
+        sudo,
+        &config,
+        #[cfg(target_os = "linux")]
+        &distribution,
+    );
     let mut runner = runner::Runner::new(&ctx);
 
     // If
     //
-    // 1. the breaking changes notification shouldnot be skipped
+    // 1. the breaking changes notification shouldn't be skipped
     // 2. this is the first execution of a major release
     //
     // inform user of breaking changes
     if !should_skip() && first_run_of_major_release()? {
         print_breaking_changes();
 
-        if prompt_yesno("Confirmed?")? {
+        if prompt_yesno(&t!("Continue?"))? {
             write_keep_file()?;
         } else {
             exit(1);
         }
     }
 
-    // Self-Update step, this will execute only if:
-    // 1. the `self-update` feature is enabled
-    // 2. it is not disabled from configuration (env var/CLI opt/file)
-    #[cfg(feature = "self-update")]
-    {
-        let should_self_update = env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !config.no_self_update();
-
-        if should_self_update {
-            runner.execute(Step::SelfUpdate, "Self Update", || self_update::self_update(&ctx))?;
-        }
-    }
+    step::Step::SelfUpdate.run(&mut runner, &ctx)?;
 
     #[cfg(windows)]
     let _self_rename = if config.self_rename() {
@@ -181,322 +196,85 @@ fn run() -> Result<()> {
         None
     };
 
-    if let Some(commands) = config.pre_commands() {
-        for (name, command) in commands {
-            generic::run_custom_command(name, command, &ctx)?;
-        }
-    }
-
     if config.pre_sudo() {
         if let Some(sudo) = ctx.sudo() {
             sudo.elevate(&ctx)?;
         }
     }
 
-    if let Some(topgrades) = config.remote_topgrades() {
-        for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(hostname(), t)) {
-            runner.execute(Step::Remotes, format!("Remote ({remote_topgrade})"), || {
-                ssh::ssh_step(&ctx, remote_topgrade)
-            })?;
-        }
-    }
-
-    #[cfg(windows)]
-    {
-        runner.execute(Step::Wsl, "WSL", || windows::run_wsl_topgrade(&ctx))?;
-        runner.execute(Step::WslUpdate, "WSL", || windows::update_wsl(&ctx))?;
-        runner.execute(Step::Chocolatey, "Chocolatey", || windows::run_chocolatey(&ctx))?;
-        runner.execute(Step::Scoop, "Scoop", || windows::run_scoop(&ctx))?;
-        runner.execute(Step::Winget, "Winget", || windows::run_winget(&ctx))?;
-        runner.execute(Step::System, "Windows update", || windows::windows_update(&ctx))?;
-        runner.execute(Step::MicrosoftStore, "Microsoft Store", || {
-            windows::microsoft_store(&ctx)
-        })?;
-    }
-
-    #[cfg(target_os = "linux")]
-    {
-        // NOTE: Due to breaking `nu` updates, `packer.nu` needs to be updated before `nu` get updated
-        // by other package managers.
-        runner.execute(Step::Shell, "packer.nu", || linux::run_packer_nu(&ctx))?;
-
-        match &distribution {
-            Ok(distribution) => {
-                runner.execute(Step::System, "System update", || distribution.upgrade(&ctx))?;
-            }
-            Err(e) => {
-                println!("{}", t!("Error detecting current distribution: {error}", error = e));
-            }
-        }
-        runner.execute(Step::ConfigUpdate, "config-update", || linux::run_config_update(&ctx))?;
-
-        runner.execute(Step::AM, "am", || linux::run_am(&ctx))?;
-        runner.execute(Step::AppMan, "appman", || linux::run_appman(&ctx))?;
-        runner.execute(Step::DebGet, "deb-get", || linux::run_deb_get(&ctx))?;
-        runner.execute(Step::Toolbx, "toolbx", || toolbx::run_toolbx(&ctx))?;
-        runner.execute(Step::Snap, "snap", || linux::run_snap(&ctx))?;
-        runner.execute(Step::Pacstall, "pacstall", || linux::run_pacstall(&ctx))?;
-        runner.execute(Step::Pacdef, "pacdef", || linux::run_pacdef(&ctx))?;
-        runner.execute(Step::Protonup, "protonup", || linux::run_protonup_update(&ctx))?;
-        runner.execute(Step::Distrobox, "distrobox", || linux::run_distrobox_update(&ctx))?;
-        runner.execute(Step::DkpPacman, "dkp-pacman", || linux::run_dkp_pacman_update(&ctx))?;
-        runner.execute(Step::System, "pihole", || linux::run_pihole_update(&ctx))?;
-        runner.execute(Step::Firmware, "Firmware upgrades", || linux::run_fwupdmgr(&ctx))?;
-        runner.execute(Step::Restarts, "Restarts", || linux::run_needrestart(&ctx))?;
-
-        runner.execute(Step::Flatpak, "Flatpak", || linux::run_flatpak(&ctx))?;
-        runner.execute(Step::BrewFormula, "Brew", || {
-            unix::run_brew_formula(&ctx, unix::BrewVariant::Path)
-        })?;
-        runner.execute(Step::Lure, "LURE", || linux::run_lure_update(&ctx))?;
-        runner.execute(Step::Waydroid, "Waydroid", || linux::run_waydroid(&ctx))?;
-        runner.execute(Step::AutoCpufreq, "auto-cpufreq", || linux::run_auto_cpufreq(&ctx))?;
-        runner.execute(Step::CinnamonSpices, "Cinnamon spices", || {
-            linux::run_cinnamon_spices_updater(&ctx)
-        })?;
-    }
-
-    #[cfg(target_os = "macos")]
-    {
-        runner.execute(Step::BrewFormula, "Brew (ARM)", || {
-            unix::run_brew_formula(&ctx, unix::BrewVariant::MacArm)
-        })?;
-        runner.execute(Step::BrewFormula, "Brew (Intel)", || {
-            unix::run_brew_formula(&ctx, unix::BrewVariant::MacIntel)
-        })?;
-        runner.execute(Step::BrewFormula, "Brew", || {
-            unix::run_brew_formula(&ctx, unix::BrewVariant::Path)
-        })?;
-        runner.execute(Step::BrewCask, "Brew Cask (ARM)", || {
-            unix::run_brew_cask(&ctx, unix::BrewVariant::MacArm)
-        })?;
-        runner.execute(Step::BrewCask, "Brew Cask (Intel)", || {
-            unix::run_brew_cask(&ctx, unix::BrewVariant::MacIntel)
-        })?;
-        runner.execute(Step::BrewCask, "Brew Cask", || {
-            unix::run_brew_cask(&ctx, unix::BrewVariant::Path)
-        })?;
-        runner.execute(Step::Macports, "MacPorts", || macos::run_macports(&ctx))?;
-        runner.execute(Step::Xcodes, "Xcodes", || macos::update_xcodes(&ctx))?;
-        runner.execute(Step::Sparkle, "Sparkle", || macos::run_sparkle(&ctx))?;
-        runner.execute(Step::Mas, "App Store", || macos::run_mas(&ctx))?;
-        runner.execute(Step::System, "System upgrade", || macos::upgrade_macos(&ctx))?;
-    }
-
-    #[cfg(target_os = "dragonfly")]
-    {
-        runner.execute(Step::Pkg, "DragonFly BSD Packages", || {
-            dragonfly::upgrade_packages(&ctx)
-        })?;
-        runner.execute(Step::Audit, "DragonFly Audit", || dragonfly::audit_packages(&ctx))?;
-    }
-
-    #[cfg(target_os = "freebsd")]
-    {
-        runner.execute(Step::Pkg, "FreeBSD Packages", || freebsd::upgrade_packages(&ctx))?;
-        runner.execute(Step::System, "FreeBSD Upgrade", || freebsd::upgrade_freebsd(&ctx))?;
-        runner.execute(Step::Audit, "FreeBSD Audit", || freebsd::audit_packages(&ctx))?;
-    }
-
-    #[cfg(target_os = "openbsd")]
-    {
-        runner.execute(Step::Pkg, "OpenBSD Packages", || openbsd::upgrade_packages(&ctx))?;
-        runner.execute(Step::System, "OpenBSD Upgrade", || openbsd::upgrade_openbsd(&ctx))?;
-    }
-
-    #[cfg(target_os = "android")]
-    {
-        runner.execute(Step::Pkg, "Termux Packages", || android::upgrade_packages(&ctx))?;
-    }
-
-    #[cfg(unix)]
-    {
-        runner.execute(Step::Yadm, "yadm", || unix::run_yadm(&ctx))?;
-        runner.execute(Step::Nix, "nix", || unix::run_nix(&ctx))?;
-        runner.execute(Step::Nix, "nix upgrade-nix", || unix::run_nix_self_upgrade(&ctx))?;
-        runner.execute(Step::Guix, "guix", || unix::run_guix(&ctx))?;
-        runner.execute(Step::HomeManager, "home-manager", || unix::run_home_manager(&ctx))?;
-        runner.execute(Step::Asdf, "asdf", || unix::run_asdf(&ctx))?;
-        runner.execute(Step::Mise, "mise", || unix::run_mise(&ctx))?;
-        runner.execute(Step::Pkgin, "pkgin", || unix::run_pkgin(&ctx))?;
-        runner.execute(Step::BunPackages, "bun-packages", || unix::run_bun_packages(&ctx))?;
-        runner.execute(Step::Shell, "zr", || zsh::run_zr(&ctx))?;
-        runner.execute(Step::Shell, "antibody", || zsh::run_antibody(&ctx))?;
-        runner.execute(Step::Shell, "antidote", || zsh::run_antidote(&ctx))?;
-        runner.execute(Step::Shell, "antigen", || zsh::run_antigen(&ctx))?;
-        runner.execute(Step::Shell, "zgenom", || zsh::run_zgenom(&ctx))?;
-        runner.execute(Step::Shell, "zplug", || zsh::run_zplug(&ctx))?;
-        runner.execute(Step::Shell, "zinit", || zsh::run_zinit(&ctx))?;
-        runner.execute(Step::Shell, "zi", || zsh::run_zi(&ctx))?;
-        runner.execute(Step::Shell, "zim", || zsh::run_zim(&ctx))?;
-        runner.execute(Step::Shell, "oh-my-zsh", || zsh::run_oh_my_zsh(&ctx))?;
-        runner.execute(Step::Shell, "oh-my-bash", || unix::run_oh_my_bash(&ctx))?;
-        runner.execute(Step::Shell, "fisher", || unix::run_fisher(&ctx))?;
-        runner.execute(Step::Shell, "bash-it", || unix::run_bashit(&ctx))?;
-        runner.execute(Step::Shell, "oh-my-fish", || unix::run_oh_my_fish(&ctx))?;
-        runner.execute(Step::Shell, "fish-plug", || unix::run_fish_plug(&ctx))?;
-        runner.execute(Step::Shell, "fundle", || unix::run_fundle(&ctx))?;
-        runner.execute(Step::Tmux, "tmux", || tmux::run_tpm(&ctx))?;
-        runner.execute(Step::Tldr, "TLDR", || unix::run_tldr(&ctx))?;
-        runner.execute(Step::Pearl, "pearl", || unix::run_pearl(&ctx))?;
-        #[cfg(not(any(target_os = "macos", target_os = "android")))]
-        runner.execute(Step::GnomeShellExtensions, "Gnome Shell Extensions", || {
-            unix::upgrade_gnome_extensions(&ctx)
-        })?;
-        runner.execute(Step::Pyenv, "pyenv", || unix::run_pyenv(&ctx))?;
-        runner.execute(Step::Sdkman, "SDKMAN!", || unix::run_sdkman(&ctx))?;
-        runner.execute(Step::Rcm, "rcm", || unix::run_rcm(&ctx))?;
-        runner.execute(Step::Maza, "maza", || unix::run_maza(&ctx))?;
-    }
-
-    #[cfg(not(any(
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "netbsd",
-        target_os = "dragonfly"
-    )))]
-    {
-        runner.execute(Step::Atom, "apm", || generic::run_apm(&ctx))?;
-    }
-
-    // The following update function should be executed on all OSes.
-    runner.execute(Step::Fossil, "fossil", || generic::run_fossil(&ctx))?;
-    runner.execute(Step::Elan, "elan", || generic::run_elan(&ctx))?;
-    runner.execute(Step::Rye, "rye", || generic::run_rye(&ctx))?;
-    runner.execute(Step::Rustup, "rustup", || generic::run_rustup(&ctx))?;
-    runner.execute(Step::Juliaup, "juliaup", || generic::run_juliaup(&ctx))?;
-    runner.execute(Step::Dotnet, ".NET", || generic::run_dotnet_upgrade(&ctx))?;
-    runner.execute(Step::Choosenim, "choosenim", || generic::run_choosenim(&ctx))?;
-    runner.execute(Step::Cargo, "cargo", || generic::run_cargo_update(&ctx))?;
-    runner.execute(Step::Flutter, "Flutter", || generic::run_flutter_upgrade(&ctx))?;
-    runner.execute(Step::Go, "go-global-update", || go::run_go_global_update(&ctx))?;
-    runner.execute(Step::Go, "gup", || go::run_go_gup(&ctx))?;
-    runner.execute(Step::Emacs, "Emacs", || emacs.upgrade(&ctx))?;
-    runner.execute(Step::Opam, "opam", || generic::run_opam_update(&ctx))?;
-    runner.execute(Step::Vcpkg, "vcpkg", || generic::run_vcpkg_update(&ctx))?;
-    runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(&ctx))?;
-    runner.execute(Step::Pipxu, "pipxu", || generic::run_pipxu_update(&ctx))?;
-    runner.execute(Step::Vscode, "Visual Studio Code extensions", || {
-        generic::run_vscode_extensions_update(&ctx)
-    })?;
-    runner.execute(Step::Vscodium, "VSCodium extensions", || {
-        generic::run_vscodium_extensions_update(&ctx)
-    })?;
-    runner.execute(Step::Conda, "conda", || generic::run_conda_update(&ctx))?;
-    runner.execute(Step::Mamba, "mamba", || generic::run_mamba_update(&ctx))?;
-    runner.execute(Step::Pixi, "pixi", || generic::run_pixi_update(&ctx))?;
-    runner.execute(Step::Miktex, "miktex", || generic::run_miktex_packages_update(&ctx))?;
-    runner.execute(Step::Pip3, "pip3", || generic::run_pip3_update(&ctx))?;
-    runner.execute(Step::PipReview, "pip-review", || generic::run_pip_review_update(&ctx))?;
-    runner.execute(Step::PipReviewLocal, "pip-review (local)", || {
-        generic::run_pip_review_local_update(&ctx)
-    })?;
-    runner.execute(Step::Pipupgrade, "pipupgrade", || generic::run_pipupgrade_update(&ctx))?;
-    runner.execute(Step::Ghcup, "ghcup", || generic::run_ghcup_update(&ctx))?;
-    runner.execute(Step::Stack, "stack", || generic::run_stack_update(&ctx))?;
-    runner.execute(Step::Tlmgr, "tlmgr", || generic::run_tlmgr_update(&ctx))?;
-    runner.execute(Step::Myrepos, "myrepos", || generic::run_myrepos_update(&ctx))?;
-    runner.execute(Step::Chezmoi, "chezmoi", || generic::run_chezmoi_update(&ctx))?;
-    runner.execute(Step::Jetpack, "jetpack", || generic::run_jetpack(&ctx))?;
-    runner.execute(Step::Vim, "vim", || vim::upgrade_vim(&ctx))?;
-    runner.execute(Step::Vim, "Neovim", || vim::upgrade_neovim(&ctx))?;
-    runner.execute(Step::Vim, "The Ultimate vimrc", || vim::upgrade_ultimate_vimrc(&ctx))?;
-    runner.execute(Step::Vim, "voom", || vim::run_voom(&ctx))?;
-    runner.execute(Step::Kakoune, "Kakoune", || kakoune::upgrade_kak_plug(&ctx))?;
-    runner.execute(Step::Helix, "helix", || generic::run_helix_grammars(&ctx))?;
-    runner.execute(Step::Node, "npm", || node::run_npm_upgrade(&ctx))?;
-    runner.execute(Step::Yarn, "yarn", || node::run_yarn_upgrade(&ctx))?;
-    runner.execute(Step::Pnpm, "pnpm", || node::run_pnpm_upgrade(&ctx))?;
-    runner.execute(Step::VoltaPackages, "volta packages", || {
-        node::run_volta_packages_upgrade(&ctx)
-    })?;
-    runner.execute(Step::Containers, "Containers", || containers::run_containers(&ctx))?;
-    runner.execute(Step::Deno, "deno", || node::deno_upgrade(&ctx))?;
-    runner.execute(Step::Composer, "composer", || generic::run_composer_update(&ctx))?;
-    runner.execute(Step::Krew, "krew", || generic::run_krew_upgrade(&ctx))?;
-    runner.execute(Step::Helm, "helm", || generic::run_helm_repo_update(&ctx))?;
-    runner.execute(Step::Gem, "gem", || generic::run_gem(&ctx))?;
-    runner.execute(Step::RubyGems, "rubygems", || generic::run_rubygems(&ctx))?;
-    runner.execute(Step::Julia, "julia", || generic::update_julia_packages(&ctx))?;
-    runner.execute(Step::Haxelib, "haxelib", || generic::run_haxelib_update(&ctx))?;
-    runner.execute(Step::Sheldon, "sheldon", || generic::run_sheldon(&ctx))?;
-    runner.execute(Step::Stew, "stew", || generic::run_stew(&ctx))?;
-    runner.execute(Step::Rtcl, "rtcl", || generic::run_rtcl(&ctx))?;
-    runner.execute(Step::Bin, "bin", || generic::bin_update(&ctx))?;
-    runner.execute(Step::Gcloud, "gcloud", || generic::run_gcloud_components_update(&ctx))?;
-    runner.execute(Step::Micro, "micro", || generic::run_micro(&ctx))?;
-    runner.execute(Step::Raco, "raco", || generic::run_raco_update(&ctx))?;
-    runner.execute(Step::Spicetify, "spicetify", || generic::spicetify_upgrade(&ctx))?;
-    runner.execute(Step::GithubCliExtensions, "GitHub CLI Extensions", || {
-        generic::run_ghcli_extensions_upgrade(&ctx)
-    })?;
-    runner.execute(Step::Bob, "Bob", || generic::run_bob(&ctx))?;
-    runner.execute(Step::Certbot, "Certbot", || generic::run_certbot(&ctx))?;
-    runner.execute(Step::GitRepos, "Git Repositories", || git::run_git_pull(&ctx))?;
-    runner.execute(Step::ClamAvDb, "ClamAV Databases", || generic::run_freshclam(&ctx))?;
-    runner.execute(Step::PlatformioCore, "PlatformIO Core", || {
-        generic::run_platform_io(&ctx)
-    })?;
-    runner.execute(Step::Lensfun, "Lensfun's database update", || {
-        generic::run_lensfun_update_data(&ctx)
-    })?;
-    runner.execute(Step::Poetry, "Poetry", || generic::run_poetry(&ctx))?;
-    runner.execute(Step::Uv, "uv", || generic::run_uv(&ctx))?;
-    runner.execute(Step::Zvm, "ZVM", || generic::run_zvm(&ctx))?;
-    runner.execute(Step::Aqua, "aqua", || generic::run_aqua(&ctx))?;
-    runner.execute(Step::Bun, "bun", || generic::run_bun(&ctx))?;
-    runner.execute(Step::Zigup, "zigup", || generic::run_zigup(&ctx))?;
-    runner.execute(Step::JetBrainsToolbox, "JetBrains Toolbox", || {
-        generic::run_jetbrains_toolbox(&ctx)
-    })?;
-
-    if should_run_powershell {
-        runner.execute(Step::Powershell, "Powershell Modules Update", || {
-            powershell.update_modules(&ctx)
-        })?;
-    }
-
-    if let Some(commands) = config.commands() {
+    if let Some(commands) = config.pre_commands() {
         for (name, command) in commands {
-            if config.should_run_custom_command(name) {
-                runner.execute(Step::CustomCommands, name, || {
-                    generic::run_custom_command(name, command, &ctx)
-                })?;
-            }
+            generic::run_custom_command(name, command, &ctx)?;
         }
     }
 
-    if config.should_run(Step::Vagrant) {
-        if let Ok(boxes) = vagrant::collect_boxes(&ctx) {
-            for vagrant_box in boxes {
-                runner.execute(Step::Vagrant, format!("Vagrant ({})", vagrant_box.smart_name()), || {
-                    vagrant::topgrade_vagrant_box(&ctx, &vagrant_box)
-                })?;
-            }
-        }
+    for step in step::default_steps() {
+        step.run(&mut runner, &ctx)?
     }
-    runner.execute(Step::Vagrant, "Vagrant boxes", || vagrant::upgrade_vagrant_boxes(&ctx))?;
 
-    if !runner.report().data().is_empty() {
+    let mut failed = false;
+
+    let report = runner.report();
+    if !report.is_empty() {
         print_separator(t!("Summary"));
 
-        for (key, result) in runner.report().data() {
+        let mut skipped_missing_sudo = false;
+
+        for (key, result) in report {
+            if !failed && result.failed() {
+                failed = true;
+            }
+            if let StepResult::SkippedMissingSudo = result {
+                skipped_missing_sudo = true;
+            }
             print_result(key, result);
         }
 
-        #[cfg(target_os = "linux")]
-        {
-            if let Ok(distribution) = &distribution {
-                distribution.show_summary();
+        if skipped_missing_sudo {
+            print_warning(t!(
+                "\nSome steps were skipped as sudo or equivalent could not be found."
+            ));
+            // Steps can only fail with SkippedMissingSudo if sudo is None,
+            // therefore we must have a sudo_err
+            match sudo_err.unwrap() {
+                SudoCreateError::CannotFindBinary => {
+                    #[cfg(unix)]
+                    print_warning(t!(
+                        "Install one of `sudo`, `doas`, `pkexec`, `run0` or `please` to run these steps."
+                    ));
+
+                    // if this windows version supported Windows Sudo, the error would have been WinSudoDisabled
+                    #[cfg(windows)]
+                    print_warning(t!("Install gsudo to run these steps."));
+                }
+                #[cfg(windows)]
+                SudoCreateError::WinSudoDisabled => {
+                    print_warning(t!(
+                        "Install gsudo or enable Windows Sudo to run these steps.\nFor Windows Sudo, the default 'In a new window' mode is not supported as it prevents Topgrade from waiting for commands to finish. Please configure it to use 'Inline' mode instead.\nGo to https://go.microsoft.com/fwlink/?linkid=2257346 to learn more."
+                    ));
+                }
+                #[cfg(windows)]
+                SudoCreateError::WinSudoNewWindowMode => {
+                    print_warning(t!(
+                        "Windows Sudo was found, but it is set to 'In a new window' mode, which prevents Topgrade from waiting for commands to finish. Please configure it to use 'Inline' mode instead.\nGo to https://go.microsoft.com/fwlink/?linkid=2257346 to learn more."
+                    ));
+                }
             }
         }
     }
 
-    let mut post_command_failed = false;
+    #[cfg(target_os = "linux")]
+    if config.show_distribution_summary() {
+        if let Ok(distribution) = &distribution {
+            distribution.show_summary();
+        }
+    }
+
     if let Some(commands) = config.post_commands() {
         for (name, command) in commands {
-            if generic::run_custom_command(name, command, &ctx).is_err() {
-                post_command_failed = true;
+            let result = generic::run_custom_command(name, command, &ctx);
+            if !failed && result.is_err() {
+                failed = true;
             }
         }
     }
@@ -509,7 +287,8 @@ fn run() -> Result<()> {
                     run_shell().context("Failed to execute shell")?;
                 }
                 Ok(Key::Char('r' | 'R')) => {
-                    reboot().context("Failed to reboot")?;
+                    println!("{}", t!("Rebooting..."));
+                    reboot(&ctx).context("Failed to reboot")?;
                 }
                 Ok(Key::Char('q' | 'Q')) => (),
                 _ => {
@@ -520,8 +299,6 @@ fn run() -> Result<()> {
         }
     }
 
-    let failed = post_command_failed || runner.report().data().iter().any(|(_, result)| result.failed());
-
     if !config.skip_notify() {
         notify_desktop(
             if failed {
@@ -546,13 +323,6 @@ fn main() {
             exit(0);
         }
         Err(error) => {
-            #[cfg(all(windows, feature = "self-update"))]
-            {
-                if let Some(Upgraded(status)) = error.downcast_ref::<Upgraded>() {
-                    exit(status.code().unwrap());
-                }
-            }
-
             let skip_print = (error.downcast_ref::<StepFailed>().is_some())
                 || (error
                     .downcast_ref::<io::Error>()

src/report.rs

@@ -1,45 +0,0 @@
-use std::borrow::Cow;
-
-pub enum StepResult {
-    Success,
-    Failure,
-    Ignored,
-    Skipped(String),
-}
-
-impl StepResult {
-    pub fn failed(&self) -> bool {
-        match self {
-            StepResult::Success | StepResult::Ignored | StepResult::Skipped(_) => false,
-            StepResult::Failure => true,
-        }
-    }
-}
-
-type CowString<'a> = Cow<'a, str>;
-type ReportData<'a> = Vec<(CowString<'a>, StepResult)>;
-pub struct Report<'a> {
-    data: ReportData<'a>,
-}
-
-impl<'a> Report<'a> {
-    pub fn new() -> Self {
-        Self { data: Vec::new() }
-    }
-
-    pub fn push_result<M>(&mut self, result: Option<(M, StepResult)>)
-    where
-        M: Into<CowString<'a>>,
-    {
-        if let Some((key, success)) = result {
-            let key = key.into();
-
-            debug_assert!(!self.data.iter().any(|(k, _)| k == &key), "{key} already reported");
-            self.data.push((key, success));
-        }
-    }
-
-    pub fn data(&self) -> &ReportData<'a> {
-        &self.data
-    }
-}

src/runner.rs

@@ -1,14 +1,36 @@
-use crate::ctrlc;
-use crate::error::{DryRun, SkipStep};
-use crate::execution_context::ExecutionContext;
-use crate::report::{Report, StepResult};
-use crate::terminal::print_error;
-use crate::{config::Step, terminal::should_retry};
 use color_eyre::eyre::Result;
+use rust_i18n::t;
 use std::borrow::Cow;
 use std::fmt::Debug;
 use tracing::debug;
 
+use crate::ctrlc;
+use crate::error::{DryRun, MissingSudo, SkipStep};
+use crate::execution_context::ExecutionContext;
+use crate::step::Step;
+use crate::terminal::{print_error, print_warning, should_retry};
+
+pub enum StepResult {
+    Success,
+    Failure,
+    Ignored,
+    SkippedMissingSudo,
+    Skipped(String),
+}
+
+impl StepResult {
+    pub fn failed(&self) -> bool {
+        use StepResult::*;
+
+        match self {
+            Success | Ignored | Skipped(_) | SkippedMissingSudo => false,
+            Failure => true,
+        }
+    }
+}
+
+type Report<'a> = Vec<(Cow<'a, str>, StepResult)>;
+
 pub struct Runner<'a> {
     ctx: &'a ExecutionContext<'a>,
     report: Report<'a>,
@@ -18,20 +40,25 @@ impl<'a> Runner<'a> {
     pub fn new(ctx: &'a ExecutionContext) -> Runner<'a> {
         Runner {
             ctx,
-            report: Report::new(),
+            report: Vec::new(),
         }
     }
 
-    pub fn execute<F, M>(&mut self, step: Step, key: M, func: F) -> Result<()>
+    fn push_result(&mut self, key: Cow<'a, str>, result: StepResult) {
+        debug_assert!(!self.report.iter().any(|(k, _)| k == &key), "{key} already reported");
+        self.report.push((key, result));
+    }
+
+    pub fn execute<K, F>(&mut self, step: Step, key: K, func: F) -> Result<()>
     where
+        K: Into<Cow<'a, str>> + Debug,
         F: Fn() -> Result<()>,
-        M: Into<Cow<'a, str>> + Debug,
     {
         if !self.ctx.config().should_run(step) {
             return Ok(());
         }
 
-        let key = key.into();
+        let key: Cow<'a, str> = key.into();
         debug!("Step {:?}", key);
 
         // alter the `func` to put it in a span
@@ -45,13 +72,18 @@ impl<'a> Runner<'a> {
         loop {
             match func() {
                 Ok(()) => {
-                    self.report.push_result(Some((key, StepResult::Success)));
+                    self.push_result(key, StepResult::Success);
                     break;
                 }
                 Err(e) if e.downcast_ref::<DryRun>().is_some() => break,
+                Err(e) if e.downcast_ref::<MissingSudo>().is_some() => {
+                    print_warning(t!("Skipping step, sudo is required"));
+                    self.push_result(key, StepResult::SkippedMissingSudo);
+                    break;
+                }
                 Err(e) if e.downcast_ref::<SkipStep>().is_some() => {
                     if self.ctx.config().verbose() || self.ctx.config().show_skipped() {
-                        self.report.push_result(Some((key, StepResult::Skipped(e.to_string()))));
+                        self.push_result(key, StepResult::Skipped(e.to_string()));
                     }
                     break;
                 }
@@ -72,14 +104,14 @@ impl<'a> Runner<'a> {
                     };
 
                     if !should_retry {
-                        self.report.push_result(Some((
+                        self.push_result(
                             key,
                             if ignore_failure {
                                 StepResult::Ignored
                             } else {
                                 StepResult::Failure
                             },
-                        )));
+                        );
                         break;
                     }
                 }
@@ -89,7 +121,7 @@ impl<'a> Runner<'a> {
         Ok(())
     }
 
-    pub fn report(&self) -> &Report {
+    pub fn report(&self) -> &Report<'_> {
         &self.report
     }
 }

src/self_update.rs

@@ -1,18 +1,19 @@
 use std::env;
 #[cfg(unix)]
 use std::os::unix::process::CommandExt as _;
+#[cfg(windows)]
+use std::process::exit;
 use std::process::Command;
 
-use crate::config::Step;
-use color_eyre::eyre::{bail, Result};
+use crate::step::Step;
+#[cfg(unix)]
+use color_eyre::eyre::bail;
+use color_eyre::eyre::Result;
 use rust_i18n::t;
 use self_update_crate::backends::github::Update;
 use self_update_crate::update::UpdateStatus;
 
 use super::terminal::{print_info, print_separator};
-#[cfg(windows)]
-use crate::error::Upgraded;
-
 use crate::execution_context::ExecutionContext;
 
 pub fn self_update(ctx: &ExecutionContext) -> Result<()> {
@@ -63,7 +64,7 @@ pub fn self_update(ctx: &ExecutionContext) -> Result<()> {
                 {
                     #[allow(clippy::disallowed_methods)]
                     let status = command.status()?;
-                    bail!(Upgraded(status));
+                    exit(status.code().expect("This cannot return None on Windows"));
                 }
             }
         }

src/step.rs

@@ -0,0 +1,901 @@
+use crate::execution_context::ExecutionContext;
+use crate::runner::Runner;
+use clap::ValueEnum;
+use color_eyre::Result;
+#[cfg(target_os = "linux")]
+use rust_i18n::t;
+use serde::Deserialize;
+use strum::{EnumCount, EnumIter, EnumString, VariantNames};
+
+#[cfg(feature = "self-update")]
+use crate::self_update;
+use crate::steps::remote::vagrant;
+#[allow(clippy::wildcard_imports)]
+use crate::steps::*;
+use crate::utils::hostname;
+
+#[derive(ValueEnum, EnumString, VariantNames, Debug, Clone, PartialEq, Eq, Deserialize, EnumIter, Copy, EnumCount)]
+#[clap(rename_all = "snake_case")]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum Step {
+    AM,
+    AndroidStudio,
+    AppMan,
+    Aqua,
+    Asdf,
+    Atom,
+    Atuin,
+    Audit,
+    AutoCpufreq,
+    Bin,
+    Bob,
+    BrewCask,
+    BrewFormula,
+    Bun,
+    BunPackages,
+    Cargo,
+    Certbot,
+    Chezmoi,
+    Chocolatey,
+    Choosenim,
+    CinnamonSpices,
+    ClamAvDb,
+    Composer,
+    Conda,
+    ConfigUpdate,
+    Containers,
+    CustomCommands,
+    DebGet,
+    Deno,
+    Distrobox,
+    DkpPacman,
+    Dotnet,
+    Elan,
+    Emacs,
+    Falconf,
+    Firmware,
+    Flatpak,
+    Flutter,
+    Fossil,
+    Gcloud,
+    Gem,
+    Ghcup,
+    GitRepos,
+    GithubCliExtensions,
+    GnomeShellExtensions,
+    Go,
+    Guix,
+    Haxelib,
+    Helix,
+    Helm,
+    HomeManager,
+    Hyprpm,
+    // These names are miscapitalized on purpose, so the CLI name is
+    //  `jetbrains_pycharm` instead of `jet_brains_py_charm`.
+    JetbrainsAqua,
+    JetbrainsClion,
+    JetbrainsDatagrip,
+    JetbrainsDataspell,
+    JetbrainsGateway,
+    JetbrainsGoland,
+    JetbrainsIdea,
+    JetbrainsMps,
+    JetbrainsPhpstorm,
+    JetbrainsPycharm,
+    JetbrainsRider,
+    JetbrainsRubymine,
+    JetbrainsRustrover,
+    JetbrainsToolbox,
+    JetbrainsWebstorm,
+    Jetpack,
+    Julia,
+    Juliaup,
+    Kakoune,
+    Krew,
+    Lensfun,
+    Lure,
+    Macports,
+    Mamba,
+    Mandb,
+    Mas,
+    Maza,
+    Micro,
+    MicrosoftStore,
+    Miktex,
+    Mise,
+    Myrepos,
+    Nix,
+    NixHelper,
+    Node,
+    Opam,
+    Pacdef,
+    Pacstall,
+    Pearl,
+    Pip3,
+    PipReview,
+    PipReviewLocal,
+    Pipupgrade,
+    Pipx,
+    Pipxu,
+    Pixi,
+    Pkg,
+    Pkgfile,
+    Pkgin,
+    PlatformioCore,
+    Pnpm,
+    Poetry,
+    Powershell,
+    Protonup,
+    Pyenv,
+    Raco,
+    Rcm,
+    Remotes,
+    Restarts,
+    Rtcl,
+    RubyGems,
+    Rustup,
+    Rye,
+    Scoop,
+    Sdkman,
+    SelfUpdate,
+    Sheldon,
+    Shell,
+    Snap,
+    Sparkle,
+    Spicetify,
+    Stack,
+    Stew,
+    System,
+    Tldr,
+    Tlmgr,
+    Tmux,
+    Toolbx,
+    Typst,
+    Uv,
+    Vagrant,
+    Vcpkg,
+    Vim,
+    VoltaPackages,
+    Vscode,
+    VscodeInsiders,
+    Vscodium,
+    VscodiumInsiders,
+    Waydroid,
+    Winget,
+    Wsl,
+    WslUpdate,
+    Xcodes,
+    Yadm,
+    Yarn,
+    Yazi,
+    Zigup,
+    Zvm,
+}
+
+impl Step {
+    #[allow(clippy::too_many_lines)]
+    pub fn run(&self, runner: &mut Runner, ctx: &ExecutionContext) -> Result<()> {
+        use Step::*;
+
+        match *self {
+            AM =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "am", || linux::run_am(ctx))?
+            }
+            AndroidStudio => runner.execute(*self, "Android Studio Plugins", || generic::run_android_studio(ctx))?,
+            AppMan =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "appman", || linux::run_appman(ctx))?
+            }
+            Aqua => runner.execute(*self, "aqua", || generic::run_aqua(ctx))?,
+            Asdf =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "asdf", || unix::run_asdf(ctx))?
+            }
+            Atom =>
+            {
+                #[cfg(not(any(
+                    target_os = "freebsd",
+                    target_os = "openbsd",
+                    target_os = "netbsd",
+                    target_os = "dragonfly"
+                )))]
+                runner.execute(*self, "apm", || generic::run_apm(ctx))?
+            }
+            Atuin =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "atuin", || unix::run_atuin(ctx))?
+            }
+            Audit => {
+                #[cfg(target_os = "dragonfly")]
+                runner.execute(*self, "DragonFly Audit", || dragonfly::audit_packages(ctx))?;
+                #[cfg(target_os = "freebsd")]
+                runner.execute(*self, "FreeBSD Audit", || freebsd::audit_packages(ctx))?
+            }
+            AutoCpufreq =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "auto-cpufreq", || linux::run_auto_cpufreq(ctx))?
+            }
+            Bin => runner.execute(*self, "bin", || generic::bin_update(ctx))?,
+            Bob => runner.execute(*self, "Bob", || generic::run_bob(ctx))?,
+            BrewCask => {
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Brew Cask", || unix::run_brew_cask(ctx, unix::BrewVariant::Path))?;
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Brew Cask (Intel)", || {
+                    unix::run_brew_cask(ctx, unix::BrewVariant::MacIntel)
+                })?;
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Brew Cask (ARM)", || {
+                    unix::run_brew_cask(ctx, unix::BrewVariant::MacArm)
+                })?
+            }
+            BrewFormula => {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Brew", || unix::run_brew_formula(ctx, unix::BrewVariant::Path))?;
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Brew (ARM)", || {
+                    unix::run_brew_formula(ctx, unix::BrewVariant::MacArm)
+                })?;
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Brew (Intel)", || {
+                    unix::run_brew_formula(ctx, unix::BrewVariant::MacIntel)
+                })?
+            }
+            Bun => runner.execute(*self, "bun", || generic::run_bun(ctx))?,
+            BunPackages =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "bun-packages", || unix::run_bun_packages(ctx))?
+            }
+            Cargo => runner.execute(*self, "cargo", || generic::run_cargo_update(ctx))?,
+            Certbot => runner.execute(*self, "Certbot", || generic::run_certbot(ctx))?,
+            Chezmoi => runner.execute(*self, "chezmoi", || generic::run_chezmoi_update(ctx))?,
+            Chocolatey =>
+            {
+                #[cfg(windows)]
+                runner.execute(*self, "Chocolatey", || windows::run_chocolatey(ctx))?
+            }
+            Choosenim => runner.execute(*self, "choosenim", || generic::run_choosenim(ctx))?,
+            CinnamonSpices =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Cinnamon spices", || linux::run_cinnamon_spices_updater(ctx))?
+            }
+            ClamAvDb => runner.execute(*self, "ClamAV Databases", || generic::run_freshclam(ctx))?,
+            Composer => runner.execute(*self, "composer", || generic::run_composer_update(ctx))?,
+            Conda => runner.execute(*self, "conda", || generic::run_conda_update(ctx))?,
+            ConfigUpdate =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "config-update", || linux::run_config_update(ctx))?
+            }
+            Containers => runner.execute(*self, "Containers", || containers::run_containers(ctx))?,
+            CustomCommands => {
+                if let Some(commands) = ctx.config().commands() {
+                    for (name, command) in commands
+                        .iter()
+                        .filter(|(n, _)| ctx.config().should_run_custom_command(n))
+                    {
+                        runner.execute(*self, name.clone(), || generic::run_custom_command(name, command, ctx))?;
+                    }
+                }
+            }
+            DebGet =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "deb-get", || linux::run_deb_get(ctx))?
+            }
+            Deno => runner.execute(*self, "deno", || node::deno_upgrade(ctx))?,
+            Distrobox =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "distrobox", || linux::run_distrobox_update(ctx))?
+            }
+            DkpPacman =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "dkp-pacman", || linux::run_dkp_pacman_update(ctx))?
+            }
+            Dotnet => runner.execute(*self, ".NET", || generic::run_dotnet_upgrade(ctx))?,
+            Elan => runner.execute(*self, "elan", || generic::run_elan(ctx))?,
+            Emacs => runner.execute(*self, "Emacs", || emacs::Emacs::new().upgrade(ctx))?,
+            Falconf => runner.execute(*self, "falconf sync", || generic::run_falconf(ctx))?,
+            Firmware =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Firmware", || linux::run_fwupdmgr(ctx))?
+            }
+            Flatpak =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Flatpak", || linux::run_flatpak(ctx))?
+            }
+            Flutter => runner.execute(*self, "Flutter", || generic::run_flutter_upgrade(ctx))?,
+            Fossil => runner.execute(*self, "fossil", || generic::run_fossil(ctx))?,
+            Gcloud => runner.execute(*self, "gcloud", || generic::run_gcloud_components_update(ctx))?,
+            Gem => runner.execute(*self, "gem", || generic::run_gem(ctx))?,
+            Ghcup => runner.execute(*self, "ghcup", || generic::run_ghcup_update(ctx))?,
+            GitRepos => runner.execute(*self, "Git Repositories", || git::run_git_pull(ctx))?,
+            GithubCliExtensions => runner.execute(*self, "GitHub CLI Extensions", || {
+                generic::run_ghcli_extensions_upgrade(ctx)
+            })?,
+            GnomeShellExtensions =>
+            {
+                #[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
+                runner.execute(*self, "Gnome Shell Extensions", || unix::upgrade_gnome_extensions(ctx))?
+            }
+            Go => {
+                runner.execute(*self, "go-global-update", || go::run_go_global_update(ctx))?;
+                runner.execute(*self, "gup", || go::run_go_gup(ctx))?
+            }
+            Guix =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "guix", || unix::run_guix(ctx))?
+            }
+            Haxelib => runner.execute(*self, "haxelib", || generic::run_haxelib_update(ctx))?,
+            Helix => runner.execute(*self, "helix", || generic::run_helix_grammars(ctx))?,
+            Helm => runner.execute(*self, "helm", || generic::run_helm_repo_update(ctx))?,
+            HomeManager =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "home-manager", || unix::run_home_manager(ctx))?
+            }
+            Hyprpm =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "hyprpm", || unix::run_hyprpm(ctx))?
+            }
+            JetbrainsAqua => runner.execute(*self, "JetBrains Aqua Plugins", || generic::run_jetbrains_aqua(ctx))?,
+            JetbrainsClion => runner.execute(*self, "JetBrains CL", || generic::run_jetbrains_clion(ctx))?,
+            JetbrainsDatagrip => {
+                runner.execute(*self, "JetBrains DataGrip", || generic::run_jetbrains_datagrip(ctx))?
+            }
+            JetbrainsDataspell => runner.execute(*self, "JetBrains DataSpell Plugins", || {
+                generic::run_jetbrains_dataspell(ctx)
+            })?,
+            JetbrainsGateway => runner.execute(*self, "JetBrains Gateway Plugins", || {
+                generic::run_jetbrains_gateway(ctx)
+            })?,
+            JetbrainsGoland => {
+                runner.execute(*self, "JetBrains GoLand Plugins", || generic::run_jetbrains_goland(ctx))?
+            }
+            JetbrainsIdea => runner.execute(*self, "JetBrains IntelliJ IDEA Plugins", || {
+                generic::run_jetbrains_idea(ctx)
+            })?,
+            JetbrainsMps => runner.execute(*self, "JetBrains MPS Plugins", || generic::run_jetbrains_mps(ctx))?,
+            JetbrainsPhpstorm => runner.execute(*self, "JetBrains PhpStorm Plugins", || {
+                generic::run_jetbrains_phpstorm(ctx)
+            })?,
+            JetbrainsPycharm => runner.execute(*self, "JetBrains PyCharm Plugins", || {
+                generic::run_jetbrains_pycharm(ctx)
+            })?,
+            JetbrainsRider => runner.execute(*self, "JetBrains Rider Plugins", || generic::run_jetbrains_rider(ctx))?,
+            JetbrainsRubymine => runner.execute(*self, "JetBrains RubyMine Plugins", || {
+                generic::run_jetbrains_rubymine(ctx)
+            })?,
+            JetbrainsRustrover => runner.execute(*self, "JetBrains RustRover Plugins", || {
+                generic::run_jetbrains_rustrover(ctx)
+            })?,
+            JetbrainsToolbox => runner.execute(*self, "JetBrains Toolbox", || generic::run_jetbrains_toolbox(ctx))?,
+            JetbrainsWebstorm => runner.execute(*self, "JetBrains WebStorm Plugins", || {
+                generic::run_jetbrains_webstorm(ctx)
+            })?,
+            Jetpack => runner.execute(*self, "jetpack", || generic::run_jetpack(ctx))?,
+            Julia => runner.execute(*self, "julia", || generic::update_julia_packages(ctx))?,
+            Juliaup => runner.execute(*self, "juliaup", || generic::run_juliaup(ctx))?,
+            Kakoune => runner.execute(*self, "Kakoune", || kakoune::upgrade_kak_plug(ctx))?,
+            Krew => runner.execute(*self, "krew", || generic::run_krew_upgrade(ctx))?,
+            Lensfun => runner.execute(*self, "Lensfun's database update", || {
+                generic::run_lensfun_update_data(ctx)
+            })?,
+            Lure =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "LURE", || linux::run_lure_update(ctx))?
+            }
+            Macports =>
+            {
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "MacPorts", || macos::run_macports(ctx))?
+            }
+            Mamba => runner.execute(*self, "mamba", || generic::run_mamba_update(ctx))?,
+            Mandb =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Manual Entries", || linux::run_mandb(ctx))?
+            }
+            Mas =>
+            {
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "App Store", || macos::run_mas(ctx))?
+            }
+            Maza =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "maza", || unix::run_maza(ctx))?
+            }
+            Micro => runner.execute(*self, "micro", || generic::run_micro(ctx))?,
+            MicrosoftStore =>
+            {
+                #[cfg(windows)]
+                runner.execute(*self, "Microsoft Store", || windows::microsoft_store(ctx))?
+            }
+            Miktex => runner.execute(*self, "miktex", || generic::run_miktex_packages_update(ctx))?,
+            Mise =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "mise", || unix::run_mise(ctx))?
+            }
+            Myrepos => runner.execute(*self, "myrepos", || generic::run_myrepos_update(ctx))?,
+            Nix => {
+                #[cfg(unix)]
+                runner.execute(*self, "nix", || unix::run_nix(ctx))?;
+                #[cfg(unix)]
+                runner.execute(*self, "nix upgrade-nix", || unix::run_nix_self_upgrade(ctx))?
+            }
+            NixHelper =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "nh", || unix::run_nix_helper(ctx))?
+            }
+            Node => runner.execute(*self, "npm", || node::run_npm_upgrade(ctx))?,
+            Opam => runner.execute(*self, "opam", || generic::run_opam_update(ctx))?,
+            Pacdef =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "pacdef", || linux::run_pacdef(ctx))?
+            }
+            Pacstall =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "pacstall", || linux::run_pacstall(ctx))?
+            }
+            Pearl =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "pearl", || unix::run_pearl(ctx))?
+            }
+            Pip3 => runner.execute(*self, "pip3", || generic::run_pip3_update(ctx))?,
+            PipReview => runner.execute(*self, "pip-review", || generic::run_pip_review_update(ctx))?,
+            PipReviewLocal => runner.execute(*self, "pip-review (local)", || {
+                generic::run_pip_review_local_update(ctx)
+            })?,
+            Pipupgrade => runner.execute(*self, "pipupgrade", || generic::run_pipupgrade_update(ctx))?,
+            Pipx => runner.execute(*self, "pipx", || generic::run_pipx_update(ctx))?,
+            Pipxu => runner.execute(*self, "pipxu", || generic::run_pipxu_update(ctx))?,
+            Pixi => runner.execute(*self, "pixi", || generic::run_pixi_update(ctx))?,
+            Pkg => {
+                #[cfg(target_os = "dragonfly")]
+                runner.execute(*self, "Dragonfly BSD Packages", || dragonfly::upgrade_packages(ctx))?;
+                #[cfg(target_os = "freebsd")]
+                runner.execute(*self, "FreeBSD Packages", || freebsd::upgrade_packages(ctx))?;
+                #[cfg(target_os = "openbsd")]
+                runner.execute(*self, "OpenBSD Packages", || openbsd::upgrade_packages(ctx))?;
+                #[cfg(target_os = "android")]
+                runner.execute(*self, "Termux Packages", || android::upgrade_packages(ctx))?
+            }
+            Pkgfile =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "pkgfile", || linux::run_pkgfile(ctx))?
+            }
+            Pkgin =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "pkgin", || unix::run_pkgin(ctx))?
+            }
+            PlatformioCore => runner.execute(*self, "PlatformIO Core", || generic::run_platform_io(ctx))?,
+            Pnpm => runner.execute(*self, "pnpm", || node::run_pnpm_upgrade(ctx))?,
+            Poetry => runner.execute(*self, "Poetry", || generic::run_poetry(ctx))?,
+            Powershell => runner.execute(*self, "Powershell Modules Update", || generic::run_powershell(ctx))?,
+            Protonup =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "protonup", || linux::run_protonup_update(ctx))?
+            }
+            Pyenv =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "pyenv", || unix::run_pyenv(ctx))?
+            }
+            Raco => runner.execute(*self, "raco", || generic::run_raco_update(ctx))?,
+            Rcm =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "rcm", || unix::run_rcm(ctx))?
+            }
+            Remotes => {
+                if let Some(topgrades) = ctx.config().remote_topgrades() {
+                    for remote_topgrade in topgrades
+                        .iter()
+                        .filter(|t| ctx.config().should_execute_remote(hostname(), t))
+                    {
+                        runner.execute(*self, format!("Remote ({remote_topgrade})"), || {
+                            crate::ssh::ssh_step(ctx, remote_topgrade)
+                        })?;
+                    }
+                }
+            }
+            Restarts =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Restarts", || linux::run_needrestart(ctx))?
+            }
+            Rtcl => runner.execute(*self, "rtcl", || generic::run_rtcl(ctx))?,
+            RubyGems => runner.execute(*self, "rubygems", || generic::run_rubygems(ctx))?,
+            Rustup => runner.execute(*self, "rustup", || generic::run_rustup(ctx))?,
+            Rye => runner.execute(*self, "rye", || generic::run_rye(ctx))?,
+            Scoop =>
+            {
+                #[cfg(windows)]
+                runner.execute(*self, "Scoop", || windows::run_scoop(ctx))?
+            }
+            Sdkman =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "SDKMAN!", || unix::run_sdkman(ctx))?
+            }
+            SelfUpdate => {
+                // Self-Update step, this will execute only if:
+                // 1. the `self-update` feature is enabled
+                // 2. it is not disabled from configuration (env var/CLI opt/file)
+                #[cfg(feature = "self-update")]
+                {
+                    if std::env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !ctx.config().no_self_update() {
+                        runner.execute(*self, "Self Update", || self_update::self_update(ctx))?;
+                    }
+                }
+            }
+            Sheldon => runner.execute(*self, "sheldon", || generic::run_sheldon(ctx))?,
+            Shell => {
+                #[cfg(unix)]
+                {
+                    runner.execute(*self, "zr", || zsh::run_zr(ctx))?;
+                    runner.execute(*self, "antibody", || zsh::run_antibody(ctx))?;
+                    runner.execute(*self, "antidote", || zsh::run_antidote(ctx))?;
+                    runner.execute(*self, "antigen", || zsh::run_antigen(ctx))?;
+                    runner.execute(*self, "zgenom", || zsh::run_zgenom(ctx))?;
+                    runner.execute(*self, "zplug", || zsh::run_zplug(ctx))?;
+                    runner.execute(*self, "zinit", || zsh::run_zinit(ctx))?;
+                    runner.execute(*self, "zi", || zsh::run_zi(ctx))?;
+                    runner.execute(*self, "zim", || zsh::run_zim(ctx))?;
+                    runner.execute(*self, "oh-my-zsh", || zsh::run_oh_my_zsh(ctx))?;
+                    runner.execute(*self, "oh-my-bash", || unix::run_oh_my_bash(ctx))?;
+                    runner.execute(*self, "fisher", || unix::run_fisher(ctx))?;
+                    runner.execute(*self, "bash-it", || unix::run_bashit(ctx))?;
+                    runner.execute(*self, "oh-my-fish", || unix::run_oh_my_fish(ctx))?;
+                    runner.execute(*self, "fish-plug", || unix::run_fish_plug(ctx))?;
+                    runner.execute(*self, "fundle", || unix::run_fundle(ctx))?
+                }
+            }
+            Snap =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "snap", || linux::run_snap(ctx))?
+            }
+            Sparkle =>
+            {
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Sparkle", || macos::run_sparkle(ctx))?
+            }
+            Spicetify => runner.execute(*self, "spicetify", || generic::spicetify_upgrade(ctx))?,
+            Stack => runner.execute(*self, "stack", || generic::run_stack_update(ctx))?,
+            Stew => runner.execute(*self, "stew", || generic::run_stew(ctx))?,
+            System => {
+                #[cfg(target_os = "linux")]
+                {
+                    // NOTE: Due to breaking `nu` updates, `packer.nu` needs to be updated before `nu` get updated
+                    // by other package managers.
+                    runner.execute(Shell, "packer.nu", || linux::run_packer_nu(ctx))?;
+
+                    match ctx.distribution() {
+                        Ok(distribution) => {
+                            runner.execute(*self, "System update", || distribution.upgrade(ctx))?;
+                        }
+                        Err(e) => {
+                            println!("{}", t!("Error detecting current distribution: {error}", error = e));
+                        }
+                    }
+                    runner.execute(*self, "pihole", || linux::run_pihole_update(ctx))?;
+                }
+                #[cfg(windows)]
+                runner.execute(*self, "Windows update", || windows::windows_update(ctx))?;
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "System update", || macos::upgrade_macos(ctx))?;
+                #[cfg(target_os = "freebsd")]
+                runner.execute(*self, "FreeBSD Upgrade", || freebsd::upgrade_freebsd(ctx))?;
+                #[cfg(target_os = "openbsd")]
+                runner.execute(*self, "OpenBSD Upgrade", || openbsd::upgrade_openbsd(ctx))?
+            }
+            Tldr => runner.execute(*self, "TLDR", || generic::run_tldr(ctx))?,
+            Tlmgr => runner.execute(*self, "tlmgr", || generic::run_tlmgr_update(ctx))?,
+            Tmux =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "tmux", || tmux::run_tpm(ctx))?
+            }
+            Toolbx =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "toolbx", || toolbx::run_toolbx(ctx))?
+            }
+            Typst => runner.execute(*self, "Typst", || generic::run_typst(ctx))?,
+            Uv => runner.execute(*self, "uv", || generic::run_uv(ctx))?,
+            Vagrant => {
+                if ctx.config().should_run(Vagrant) {
+                    if let Ok(boxes) = vagrant::collect_boxes(ctx) {
+                        for vagrant_box in boxes {
+                            runner.execute(*self, format!("Vagrant ({})", vagrant_box.smart_name()), || {
+                                vagrant::topgrade_vagrant_box(ctx, &vagrant_box)
+                            })?;
+                        }
+                    }
+                }
+                runner.execute(*self, "Vagrant boxes", || vagrant::upgrade_vagrant_boxes(ctx))?;
+            }
+            Vcpkg => runner.execute(*self, "vcpkg", || generic::run_vcpkg_update(ctx))?,
+            Vim => {
+                runner.execute(*self, "vim", || vim::upgrade_vim(ctx))?;
+                runner.execute(*self, "Neovim", || vim::upgrade_neovim(ctx))?;
+                runner.execute(*self, "The Ultimate vimrc", || vim::upgrade_ultimate_vimrc(ctx))?;
+                runner.execute(*self, "voom", || vim::run_voom(ctx))?
+            }
+            VoltaPackages => runner.execute(*self, "volta packages", || node::run_volta_packages_upgrade(ctx))?,
+            Vscode => runner.execute(*self, "Visual Studio Code extensions", || {
+                generic::run_vscode_extensions_update(ctx)
+            })?,
+            VscodeInsiders => runner.execute(*self, "Visual Studio Code Insiders extensions", || {
+                generic::run_vscode_insiders_extensions_update(ctx)
+            })?,
+            Vscodium => runner.execute(*self, "VSCodium extensions", || {
+                generic::run_vscodium_extensions_update(ctx)
+            })?,
+            VscodiumInsiders => runner.execute(*self, "VSCodium Insiders extensions", || {
+                generic::run_vscodium_insiders_extensions_update(ctx)
+            })?,
+            Waydroid =>
+            {
+                #[cfg(target_os = "linux")]
+                runner.execute(*self, "Waydroid", || linux::run_waydroid(ctx))?
+            }
+            Winget =>
+            {
+                #[cfg(windows)]
+                runner.execute(*self, "Winget", || windows::run_winget(ctx))?
+            }
+            Wsl =>
+            {
+                #[cfg(windows)]
+                runner.execute(*self, "WSL", || windows::run_wsl_topgrade(ctx))?
+            }
+            WslUpdate =>
+            {
+                #[cfg(windows)]
+                runner.execute(*self, "Update WSL", || windows::update_wsl(ctx))?
+            }
+            Xcodes =>
+            {
+                #[cfg(target_os = "macos")]
+                runner.execute(*self, "Xcodes", || macos::update_xcodes(ctx))?
+            }
+            Yadm =>
+            {
+                #[cfg(unix)]
+                runner.execute(*self, "yadm", || unix::run_yadm(ctx))?
+            }
+            Yarn => runner.execute(*self, "yarn", || node::run_yarn_upgrade(ctx))?,
+            Yazi => runner.execute(*self, "Yazi packages", || generic::run_yazi(ctx))?,
+            Zigup => runner.execute(*self, "zigup", || generic::run_zigup(ctx))?,
+            Zvm => runner.execute(*self, "ZVM", || generic::run_zvm(ctx))?,
+        }
+
+        Ok(())
+    }
+}
+
+#[allow(clippy::too_many_lines)]
+pub(crate) fn default_steps() -> Vec<Step> {
+    // For now, SelfRenamer and SelfUpdate isn't included as they're ran before the other non-steps (pre-commands, sudo, etc)
+
+    use Step::*;
+    // Could probably have a smaller starting capacity, but this at least ensures only 2 allocations:
+    // initial and shrink
+    let mut steps = Vec::with_capacity(Step::COUNT);
+
+    // Not combined with other generic steps to preserve the order as it was in main.rs originally,
+    // but this can be changed in the future.
+    steps.push(Remotes);
+
+    #[cfg(windows)]
+    steps.extend_from_slice(&[Wsl, WslUpdate, Chocolatey, Scoop, Winget, System, MicrosoftStore]);
+
+    #[cfg(target_os = "macos")]
+    steps.extend_from_slice(&[BrewFormula, BrewCask, Macports, Xcodes, Sparkle, Mas, System]);
+
+    #[cfg(target_os = "dragonfly")]
+    steps.extend_from_slice(&[Pkg, Audit]);
+
+    #[cfg(target_os = "freebsd")]
+    steps.extend_from_slice(&[Pkg, System, Audit]);
+
+    #[cfg(target_os = "openbsd")]
+    steps.extend_from_slice(&[Pkg, System]);
+
+    #[cfg(target_os = "android")]
+    steps.push(Pkg);
+
+    #[cfg(target_os = "linux")]
+    steps.extend_from_slice(&[
+        System,
+        ConfigUpdate,
+        AM,
+        AppMan,
+        DebGet,
+        Toolbx,
+        Snap,
+        Pacstall,
+        Pacdef,
+        Protonup,
+        Distrobox,
+        DkpPacman,
+        Firmware,
+        Restarts,
+        Flatpak,
+        BrewFormula,
+        Lure,
+        Waydroid,
+        AutoCpufreq,
+        CinnamonSpices,
+        Mandb,
+        Pkgfile,
+    ]);
+
+    #[cfg(unix)]
+    steps.extend_from_slice(&[
+        Yadm,
+        Nix,
+        NixHelper,
+        Guix,
+        HomeManager,
+        Asdf,
+        Mise,
+        Pkgin,
+        BunPackages,
+        Shell,
+        Tmux,
+        Pearl,
+        #[cfg(not(any(target_os = "macos", target_os = "android")))]
+        GnomeShellExtensions,
+        Pyenv,
+        Sdkman,
+        Rcm,
+        Maza,
+        Hyprpm,
+        Atuin,
+    ]);
+
+    #[cfg(not(any(
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    )))]
+    steps.push(Atom);
+
+    // The following update function should be executed on all OSes.
+    steps.extend_from_slice(&[
+        Fossil,
+        Elan,
+        Rye,
+        Rustup,
+        Juliaup,
+        Dotnet,
+        Choosenim,
+        Cargo,
+        Flutter,
+        Go,
+        Emacs,
+        Opam,
+        Vcpkg,
+        Pipx,
+        Pipxu,
+        Vscode,
+        VscodeInsiders,
+        Vscodium,
+        VscodiumInsiders,
+        Conda,
+        Mamba,
+        Pixi,
+        Miktex,
+        Pip3,
+        PipReview,
+        PipReviewLocal,
+        Pipupgrade,
+        Ghcup,
+        Stack,
+        Tldr,
+        Tlmgr,
+        Myrepos,
+        Chezmoi,
+        Jetpack,
+        Vim,
+        Kakoune,
+        Helix,
+        Node,
+        Yarn,
+        Pnpm,
+        VoltaPackages,
+        Containers,
+        Deno,
+        Composer,
+        Krew,
+        Helm,
+        Gem,
+        RubyGems,
+        Julia,
+        Haxelib,
+        Sheldon,
+        Stew,
+        Rtcl,
+        Bin,
+        Gcloud,
+        Micro,
+        Raco,
+        Spicetify,
+        GithubCliExtensions,
+        Bob,
+        Certbot,
+        GitRepos,
+        ClamAvDb,
+        PlatformioCore,
+        Lensfun,
+        Poetry,
+        Uv,
+        Zvm,
+        Aqua,
+        Bun,
+        Zigup,
+        JetbrainsToolbox,
+        AndroidStudio,
+        JetbrainsAqua,
+        JetbrainsClion,
+        JetbrainsDatagrip,
+        JetbrainsDataspell,
+        // JetBrains dotCover has no CLI
+        // JetBrains dotMemory has no CLI
+        // JetBrains dotPeek has no CLI
+        // JetBrains dotTrace has no CLI
+        // JetBrains Fleet has a different CLI without a `fleet update` command.
+        JetbrainsGateway,
+        JetbrainsGoland,
+        JetbrainsIdea,
+        JetbrainsMps,
+        JetbrainsPhpstorm,
+        JetbrainsPycharm,
+        // JetBrains ReSharper has no CLI (it's a VSCode extension)
+        // JetBrains ReSharper C++ has no CLI (it's a VSCode extension)
+        JetbrainsRider,
+        JetbrainsRubymine,
+        JetbrainsRustrover,
+        // JetBrains Space Desktop does not have a CLI
+        JetbrainsWebstorm,
+        Yazi,
+        Falconf,
+        Powershell,
+        CustomCommands,
+        Vagrant,
+        Typst,
+    ]);
+
+    steps.shrink_to_fit();
+
+    steps
+}

src/steps/containers.rs

@@ -1,15 +1,17 @@
 use std::fmt::{Display, Formatter};
+use std::io;
+use std::io::Write;
 use std::path::Path;
 use std::process::Command;
 
-use color_eyre::eyre::eyre;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
+use color_eyre::eyre::{eyre, OptionExt};
 use tracing::{debug, error, warn};
 use wildmatch::WildMatch;
 
 use crate::command::CommandExt;
-use crate::error::{self, TopgradeError};
+use crate::error::{self, SkipStep, TopgradeError};
 use crate::terminal::print_separator;
 use crate::{execution_context::ExecutionContext, utils::require};
 use rust_i18n::t;
@@ -21,6 +23,9 @@ use rust_i18n::t;
 // themselves or when using docker-compose.
 const NONEXISTENT_REPO: &str = "repository does not exist";
 
+// A string found in the output of docker when Docker Desktop is not running.
+const DOCKER_NOT_RUNNING: &str = "We recommend to activate the WSL integration in Docker Desktop settings.";
+
 /// Uniquely identifies a `Container`.
 #[derive(Debug)]
 struct Container {
@@ -74,7 +79,7 @@ fn list_containers(crt: &Path, ignored_containers: Option<&Vec<String>>) -> Resu
     );
     let output = Command::new(crt)
         .args(["image", "ls", "--format", "{{.Repository}}:{{.Tag}} {{.ID}}"])
-        .output_checked_with_utf8(|_| Ok(()))?;
+        .output_checked_utf8()?;
 
     let mut retval = vec![];
     for line in output.stdout.lines() {
@@ -99,7 +104,12 @@ fn list_containers(crt: &Path, ignored_containers: Option<&Vec<String>>) -> Resu
 
         // line is of format: `Repository:Tag ImageID`, e.g., `nixos/nix:latest d80fea9c32b4`
         let split_res = line.split(' ').collect::<Vec<&str>>();
-        assert_eq!(split_res.len(), 2);
+        if split_res.len() != 2 {
+            return Err(eyre!(format!(
+                "Got erroneous output from `{} image ls --format \"{{.Repository}}:{{.Tag}} {{.ID}}\"; Expected line to split into 2 parts",
+                crt.display()
+            )));
+        }
         let (repo_tag, image_id) = (split_res[0], split_res[1]);
 
         if let Some(ref ignored_containers) = ignored_containers {
@@ -116,11 +126,16 @@ fn list_containers(crt: &Path, ignored_containers: Option<&Vec<String>>) -> Resu
         );
         let inspect_output = Command::new(crt)
             .args(["image", "inspect", image_id, "--format", "{{.Os}}/{{.Architecture}}"])
-            .output_checked_with_utf8(|_| Ok(()))?;
+            .output_checked_utf8()?;
         let mut platform = inspect_output.stdout;
         // truncate the tailing new line character
         platform.truncate(platform.len() - 1);
-        assert!(platform.contains('/'));
+        if !platform.contains('/') {
+            return Err(eyre!(format!(
+                "Got erroneous output from `{} image ls --format \"{{.Repository}}:{{.Tag}} {{.ID}}\"; Expected platform to contain '/'",
+                crt.display()
+            )));
+        }
 
         retval.push(Container::new(repo_tag.to_string(), platform));
     }
@@ -135,6 +150,41 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
     debug!("Using container runtime '{}'", crt.display());
 
     print_separator(t!("Containers"));
+
+    let output = Command::new(&crt).arg("--help").output_checked_with(|_| Ok(()))?;
+    let status_code = output
+        .status
+        .code()
+        .ok_or_eyre("Couldn't get status code (terminated by signal)")?;
+    let stdout = std::str::from_utf8(&output.stdout).wrap_err("Expected output to be valid UTF-8")?;
+    if stdout.contains(DOCKER_NOT_RUNNING) && status_code == 1 {
+        // Write the output
+        io::stdout().write_all(&output.stdout)?;
+        io::stderr().write_all(&output.stderr)?;
+        // Don't crash, but don't be silent either.
+        // This can happen in other ways than Docker Desktop not running, but even in those cases
+        //  we don't want to crash, since the containers step is enabled by default.
+        warn!(
+            "{} seems to be non-functional right now (see above). Is WSL integration enabled for Docker Desktop? Is Docker Desktop running?",
+            crt.display()
+        );
+        return Err(SkipStep(format!(
+            "{} seems to be non-functional right now. Possibly WSL integration is not enabled for Docker Desktop, or Docker Desktop is not running.",
+            crt.display()
+        )).into());
+    } else if !output.status.success() {
+        // Write the output
+        io::stdout().write_all(&output.stdout)?;
+        io::stderr().write_all(&output.stderr)?;
+        // If we saw the message, but the code is not 1 (e.g. 0, or a non-1 failure), crash, as we expect a 1.
+        // If we did not see the message, it's broken in some way we do not understand.
+        return Err(eyre!(
+            "{0} seems to be non-functional (`{0} --help` returned non-zero exit code {1})",
+            crt.display(),
+            status_code,
+        ));
+    }
+
     let mut success = true;
     let containers =
         list_containers(&crt, ctx.config().containers_ignored_tags()).context("Failed to list Docker containers")?;
@@ -142,13 +192,13 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
 
     for container in &containers {
         debug!("Pulling container '{}'", container);
-        let args = vec![
-            "pull",
-            container.repo_tag.as_str(),
-            "--platform",
-            container.platform.as_str(),
-        ];
-        let mut exec = ctx.run_type().execute(&crt);
+        let mut args = vec!["pull", container.repo_tag.as_str()];
+        if container.platform.as_str() != "/" {
+            args.push("--platform");
+            args.push(container.platform.as_str());
+        }
+
+        let mut exec = ctx.execute(&crt);
 
         if let Err(e) = exec.args(&args).status_checked() {
             error!("Pulling container '{}' failed: {}", container, e);
@@ -177,12 +227,7 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
     if ctx.config().cleanup() {
         // Remove dangling images
         debug!("Removing dangling images");
-        if let Err(e) = ctx
-            .run_type()
-            .execute(&crt)
-            .args(["image", "prune", "-f"])
-            .status_checked()
-        {
+        if let Err(e) = ctx.execute(&crt).args(["image", "prune", "-f"]).status_checked() {
             error!("Removing dangling images failed: {}", e);
             success = false;
         }

src/steps/emacs.rs

@@ -8,9 +8,9 @@ use rust_i18n::t;
 
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::print_separator;
 use crate::utils::{require, require_option, PathExt};
-use crate::Step;
 
 const EMACS_UPGRADE: &str = include_str!("emacs.el");
 #[cfg(windows)]
@@ -60,12 +60,16 @@ impl Emacs {
     fn update_doom(doom: &Path, ctx: &ExecutionContext) -> Result<()> {
         print_separator("Doom Emacs");
 
-        let mut command = ctx.run_type().execute(doom);
+        let mut command = ctx.execute(doom);
         if ctx.config().yes(Step::Emacs) {
             command.arg("--force");
         }
 
-        command.args(["upgrade"]);
+        command.arg("upgrade");
+
+        if ctx.config().doom_aot() {
+            command.arg("--aot");
+        }
 
         command.status_checked()
     }
@@ -84,7 +88,7 @@ impl Emacs {
 
         print_separator("Emacs");
 
-        let mut command = ctx.run_type().execute(emacs);
+        let mut command = ctx.execute(emacs);
 
         command
             .args(["--batch", "--debug-init", "-l"])

src/steps/git.rs

@@ -13,8 +13,8 @@ use tokio::runtime;
 use tracing::{debug, error};
 
 use crate::command::CommandExt;
-use crate::config::Step;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::steps::emacs::Emacs;
 use crate::terminal::print_separator;
 use crate::utils::{require, PathExt};
@@ -58,9 +58,10 @@ pub fn run_git_pull(ctx: &ExecutionContext) -> Result<()> {
                 repos.insert_if_repo(HOME_DIR.join(".dotfiles"));
             }
 
-            let powershell = crate::steps::powershell::Powershell::new();
-            if let Some(profile) = powershell.profile() {
-                repos.insert_if_repo(profile);
+            if let Some(powershell) = ctx.powershell() {
+                if let Some(profile) = powershell.profile() {
+                    repos.insert_if_repo(profile);
+                }
             }
         }
 
@@ -92,7 +93,7 @@ pub fn run_git_pull(ctx: &ExecutionContext) -> Result<()> {
     // Handle user-defined repos
     if let Some(custom_git_repos) = config.git_repos() {
         for git_repo in custom_git_repos {
-            repos.glob_insert(git_repo);
+            repos.glob_insert(&shellexpand::tilde(git_repo));
         }
     }
 

src/steps/go.rs

@@ -15,7 +15,7 @@ pub fn run_go_global_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("go-global-update");
 
-    ctx.run_type().execute(go_global_update).status_checked()
+    ctx.execute(go_global_update).status_checked()
 }
 
 /// <https://github.com/nao1215/gup>
@@ -24,7 +24,7 @@ pub fn run_go_gup(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("gup");
 
-    ctx.run_type().execute(gup).arg("update").status_checked()
+    ctx.execute(gup).arg("update").status_checked()
 }
 
 /// Get the path of a Go binary.

src/steps/kakoune.rs

@@ -12,11 +12,8 @@ pub fn upgrade_kak_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Kakoune");
 
-    // TODO: Why supress output for this command?
-    ctx.run_type()
-        .execute(kak)
-        .args(["-ui", "dummy", "-e", UPGRADE_KAK])
-        .output()?;
+    // TODO: Why suppress output for this command?
+    ctx.execute(kak).args(["-ui", "dummy", "-e", UPGRADE_KAK]).output()?;
 
     println!("{}", t!("Plugins upgraded"));
 

src/steps/node.rs

@@ -4,7 +4,6 @@ use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-use crate::utils::{get_require_sudo_string, require_option};
 use crate::HOME_DIR;
 use color_eyre::eyre::Result;
 #[cfg(target_os = "linux")]
@@ -93,14 +92,10 @@ impl NPM {
     fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
         let args = ["update", self.global_location_arg()];
         if use_sudo {
-            let sudo = require_option(ctx.sudo().clone(), get_require_sudo_string())?;
-            ctx.run_type()
-                .execute(sudo)
-                .arg(&self.command)
-                .args(args)
-                .status_checked()?;
+            let sudo = ctx.require_sudo()?;
+            sudo.execute(ctx, &self.command)?.args(args).status_checked()?;
         } else {
-            ctx.run_type().execute(&self.command).args(args).status_checked()?;
+            ctx.execute(&self.command).args(args).status_checked()?;
         }
 
         Ok(())
@@ -122,15 +117,11 @@ impl NPM {
 
 struct Yarn {
     command: PathBuf,
-    yarn: Option<PathBuf>,
 }
 
 impl Yarn {
     fn new(command: PathBuf) -> Self {
-        Self {
-            command,
-            yarn: require("yarn").ok(),
-        }
+        Self { command }
     }
 
     fn has_global_subcmd(&self) -> bool {
@@ -157,14 +148,10 @@ impl Yarn {
         let args = ["global", "upgrade"];
 
         if use_sudo {
-            let sudo = require_option(ctx.sudo().clone(), get_require_sudo_string())?;
-            ctx.run_type()
-                .execute(sudo)
-                .arg(self.yarn.as_ref().unwrap_or(&self.command))
-                .args(args)
-                .status_checked()?;
+            let sudo = ctx.require_sudo()?;
+            sudo.execute(ctx, &self.command)?.args(args).status_checked()?;
         } else {
-            ctx.run_type().execute(&self.command).args(args).status_checked()?;
+            ctx.execute(&self.command).args(args).status_checked()?;
         }
 
         Ok(())
@@ -245,11 +232,7 @@ impl Deno {
             }
         }
 
-        ctx.run_type()
-            .execute(&self.command)
-            .arg("upgrade")
-            .args(args)
-            .status_checked()?;
+        ctx.execute(&self.command).arg("upgrade").args(args).status_checked()?;
         Ok(())
     }
 
@@ -376,7 +359,6 @@ pub fn run_volta_packages_upgrade(ctx: &ExecutionContext) -> Result<()> {
     }
 
     let list_output = ctx
-        .run_type()
         .execute(&volta)
         .args(["list", "--format=plain"])
         .output_checked_utf8()?
@@ -400,10 +382,7 @@ pub fn run_volta_packages_upgrade(ctx: &ExecutionContext) -> Result<()> {
     }
 
     for package in &installed_packages {
-        ctx.run_type()
-            .execute(&volta)
-            .args(["install", package])
-            .status_checked()?;
+        ctx.execute(&volta).args(["install", package]).status_checked()?;
     }
 
     Ok(())

src/steps/os/android.rs

@@ -1,10 +1,10 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::print_separator;
 use crate::utils::require;
 use crate::utils::which;
-use crate::Step;
-use color_eyre::eyre::Result;
+use color_eyre::Result;
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
     //let pkg = require("pkg")?;
@@ -14,7 +14,7 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
 
     let is_nala = pkg.ends_with("nala");
 
-    let mut command = ctx.run_type().execute(&pkg);
+    let mut command = ctx.execute(&pkg);
     command.arg("upgrade");
 
     if ctx.config().yes(Step::System) {
@@ -23,10 +23,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
     command.status_checked()?;
 
     if !is_nala && ctx.config().cleanup() {
-        ctx.run_type().execute(&pkg).arg("clean").status_checked()?;
+        ctx.execute(&pkg).arg("clean").status_checked()?;
 
         let apt = require("apt")?;
-        let mut command = ctx.run_type().execute(apt);
+        let mut command = ctx.execute(apt);
         command.arg("autoremove");
         if ctx.config().yes(Step::System) {
             command.arg("-y");

src/steps/os/archlinux.rs

@@ -3,16 +3,16 @@ use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 
 use color_eyre::eyre;
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{Context, Result};
 use rust_i18n::t;
 use walkdir::WalkDir;
 
 use crate::command::CommandExt;
 use crate::error::TopgradeError;
 use crate::execution_context::ExecutionContext;
-use crate::utils::require_option;
+use crate::step::Step;
 use crate::utils::which;
-use crate::{config, Step};
+use crate::{config, output_changed_message};
 
 fn get_execution_path() -> OsString {
     let mut path = OsString::from("/usr/bin:");
@@ -32,13 +32,12 @@ pub struct YayParu {
 impl ArchPackageManager for YayParu {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().show_arch_news() {
-            ctx.run_type()
-                .execute(&self.executable)
+            ctx.execute(&self.executable)
                 .arg("-Pw")
                 .status_checked_with_codes(&[1, 0])?;
         }
 
-        let mut command = ctx.run_type().execute(&self.executable);
+        let mut command = ctx.execute(&self.executable);
 
         command
             .arg("--pacman")
@@ -53,7 +52,7 @@ impl ArchPackageManager for YayParu {
         command.status_checked()?;
 
         if ctx.config().cleanup() {
-            let mut command = ctx.run_type().execute(&self.executable);
+            let mut command = ctx.execute(&self.executable);
             command.arg("--pacman").arg(&self.pacman).arg("-Scc");
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
@@ -80,7 +79,7 @@ pub struct GarudaUpdate {
 
 impl ArchPackageManager for GarudaUpdate {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let mut command = ctx.run_type().execute(&self.executable);
+        let mut command = ctx.execute(&self.executable);
 
         command
             .env("PATH", get_execution_path())
@@ -111,7 +110,7 @@ pub struct Trizen {
 
 impl ArchPackageManager for Trizen {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let mut command = ctx.run_type().execute(&self.executable);
+        let mut command = ctx.execute(&self.executable);
 
         command
             .arg("-Syu")
@@ -124,7 +123,7 @@ impl ArchPackageManager for Trizen {
         command.status_checked()?;
 
         if ctx.config().cleanup() {
-            let mut command = ctx.run_type().execute(&self.executable);
+            let mut command = ctx.execute(&self.executable);
             command.arg("-Sc");
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
@@ -150,20 +149,17 @@ pub struct Pacman {
 
 impl ArchPackageManager for Pacman {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let sudo = require_option(ctx.sudo().as_ref(), "sudo is required to run pacman".into())?;
-        let mut command = ctx.run_type().execute(sudo);
-        command
-            .arg(&self.executable)
-            .arg("-Syu")
-            .env("PATH", get_execution_path());
+        let sudo = ctx.require_sudo()?;
+        let mut command = sudo.execute(ctx, &self.executable)?;
+        command.arg("-Syu").env("PATH", get_execution_path());
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
         command.status_checked()?;
 
         if ctx.config().cleanup() {
-            let mut command = ctx.run_type().execute(sudo);
-            command.arg(&self.executable).arg("-Scc");
+            let mut command = sudo.execute(ctx, &self.executable)?;
+            command.arg("-Scc");
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
@@ -196,7 +192,7 @@ impl Pikaur {
 
 impl ArchPackageManager for Pikaur {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let mut command = ctx.run_type().execute(&self.executable);
+        let mut command = ctx.execute(&self.executable);
 
         command
             .arg("-Syu")
@@ -210,7 +206,7 @@ impl ArchPackageManager for Pikaur {
         command.status_checked()?;
 
         if ctx.config().cleanup() {
-            let mut command = ctx.run_type().execute(&self.executable);
+            let mut command = ctx.execute(&self.executable);
             command.arg("-Sc");
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
@@ -235,7 +231,7 @@ impl Pamac {
 }
 impl ArchPackageManager for Pamac {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let mut command = ctx.run_type().execute(&self.executable);
+        let mut command = ctx.execute(&self.executable);
 
         command
             .arg("upgrade")
@@ -249,7 +245,7 @@ impl ArchPackageManager for Pamac {
         command.status_checked()?;
 
         if ctx.config().cleanup() {
-            let mut command = ctx.run_type().execute(&self.executable);
+            let mut command = ctx.execute(&self.executable);
             command.arg("clean");
             if ctx.config().yes(Step::System) {
                 command.arg("--no-confirm");
@@ -277,15 +273,12 @@ impl ArchPackageManager for Aura {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
         use semver::Version;
 
-        let version_cmd_output = ctx
-            .run_type()
-            .execute(&self.executable)
-            .arg("--version")
-            .output_checked_utf8()?;
+        let version_cmd_output = ctx.execute(&self.executable).arg("--version").output_checked_utf8()?;
         // Output will be something like: "aura x.x.x\n"
         let version_cmd_stdout = version_cmd_output.stdout;
         let version_str = version_cmd_stdout.trim_start_matches("aura ").trim_end();
-        let version = Version::parse(version_str).expect("invalid version");
+        let version = Version::parse(version_str)
+            .wrap_err_with(|| output_changed_message!("aura --version", "invalid version"))?;
 
         // Aura, since version 4.0.6, no longer needs sudo.
         //
@@ -293,7 +286,7 @@ impl ArchPackageManager for Aura {
         let version_no_sudo = Version::new(4, 0, 6);
 
         if version >= version_no_sudo {
-            let mut cmd = ctx.run_type().execute(&self.executable);
+            let mut cmd = ctx.execute(&self.executable);
             cmd.arg("-Au")
                 .args(ctx.config().aura_aur_arguments().split_whitespace());
             if ctx.config().yes(Step::System) {
@@ -301,7 +294,7 @@ impl ArchPackageManager for Aura {
             }
             cmd.status_checked()?;
 
-            let mut cmd = ctx.run_type().execute(&self.executable);
+            let mut cmd = ctx.execute(&self.executable);
             cmd.arg("-Syu")
                 .args(ctx.config().aura_pacman_arguments().split_whitespace());
             if ctx.config().yes(Step::System) {
@@ -309,23 +302,18 @@ impl ArchPackageManager for Aura {
             }
             cmd.status_checked()?;
         } else {
-            let sudo = crate::utils::require_option(
-                ctx.sudo().as_ref(),
-                t!("Aura(<0.4.6) requires sudo installed to work with AUR packages").to_string(),
-            )?;
+            let sudo = ctx.require_sudo()?;
 
-            let mut cmd = ctx.run_type().execute(sudo);
-            cmd.arg(&self.executable)
-                .arg("-Au")
+            let mut cmd = sudo.execute(ctx, &self.executable)?;
+            cmd.arg("-Au")
                 .args(ctx.config().aura_aur_arguments().split_whitespace());
             if ctx.config().yes(Step::System) {
                 cmd.arg("--noconfirm");
             }
             cmd.status_checked()?;
 
-            let mut cmd = ctx.run_type().execute(sudo);
-            cmd.arg(&self.executable)
-                .arg("-Syu")
+            let mut cmd = sudo.execute(ctx, &self.executable)?;
+            cmd.arg("-Syu")
                 .args(ctx.config().aura_pacman_arguments().split_whitespace());
             if ctx.config().yes(Step::System) {
                 cmd.arg("--noconfirm");

src/steps/os/dragonfly.rs

@@ -1,16 +1,16 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::print_separator;
-use crate::utils::{get_require_sudo_string, require_option};
-use crate::Step;
 use color_eyre::eyre::Result;
-use std::process::Command;
+use rust_i18n::t;
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
     print_separator(t!("DragonFly BSD Packages"));
-    let mut cmd = ctx.run_type().execute(sudo);
-    cmd.args(["/usr/local/sbin/pkg", "upgrade"]);
+
+    let sudo = ctx.require_sudo()?;
+    let mut cmd = sudo.execute(ctx, "/usr/local/sbin/pkg")?;
+    cmd.arg("upgrade");
     if ctx.config().yes(Step::System) {
         cmd.arg("-y");
     }
@@ -18,19 +18,18 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
-
     print_separator(t!("DragonFly BSD Audit"));
 
-    #[allow(clippy::disallowed_methods)]
-    if !Command::new(sudo)
-        .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
-        .status()?
-        .success()
-    {
-        println!(t!(
-            "The package audit was successful, but vulnerable packages still remain on the system"
-        ));
-    }
-    Ok(())
+    let sudo = ctx.require_sudo()?;
+    sudo.execute(ctx, "/usr/local/sbin/pkg")?
+        .args(["audit", "-Fr"])
+        .status_checked_with(|status| {
+            if !status.success() {
+                println!(
+                    "{}",
+                    t!("The package audit was successful, but vulnerable packages still remain on the system")
+                );
+            }
+            Ok(())
+        })
 }

src/steps/os/freebsd.rs

@@ -1,28 +1,25 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::print_separator;
-use crate::utils::{get_require_sudo_string, require_option};
-use crate::Step;
-use color_eyre::eyre::Result;
+use color_eyre::Result;
 use rust_i18n::t;
-use std::process::Command;
 
 pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
     print_separator(t!("FreeBSD Update"));
-    ctx.run_type()
-        .execute(sudo)
-        .args(["/usr/sbin/freebsd-update", "fetch", "install"])
+
+    let sudo = ctx.require_sudo()?;
+    sudo.execute(ctx, "/usr/sbin/freebsd-update")?
+        .args(["fetch", "install"])
         .status_checked()
 }
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
     print_separator(t!("FreeBSD Packages"));
 
-    let mut command = ctx.run_type().execute(sudo);
-
-    command.args(["/usr/sbin/pkg", "upgrade"]);
+    let sudo = ctx.require_sudo()?;
+    let mut command = sudo.execute(ctx, "/usr/sbin/pkg")?;
+    command.arg("upgrade");
     if ctx.config().yes(Step::System) {
         command.arg("-y");
     }
@@ -30,12 +27,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
-
     print_separator(t!("FreeBSD Audit"));
 
-    Command::new(sudo)
-        .args(["/usr/sbin/pkg", "audit", "-Fr"])
-        .status_checked()?;
-    Ok(())
+    let sudo = ctx.require_sudo()?;
+    sudo.execute(ctx, "/usr/sbin/pkg")?
+        .args(["audit", "-Fr"])
+        .status_checked()
 }

src/steps/os/macos.rs

@@ -1,8 +1,8 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::{print_separator, prompt_yesno};
-use crate::utils::{get_require_sudo_string, require_option};
-use crate::{utils::require, Step};
+use crate::utils::require;
 use color_eyre::eyre::Result;
 use rust_i18n::t;
 use std::collections::HashSet;
@@ -11,23 +11,18 @@ use std::process::Command;
 use tracing::debug;
 
 pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
-    require("port")?;
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
+    let port = require("port")?;
 
     print_separator("MacPorts");
-    ctx.run_type()
-        .execute(sudo)
-        .args(["port", "selfupdate"])
-        .status_checked()?;
-    ctx.run_type()
-        .execute(sudo)
-        .args(["port", "-u", "upgrade", "outdated"])
+
+    let sudo = ctx.require_sudo()?;
+
+    sudo.execute(ctx, &port)?.arg("selfupdate").status_checked()?;
+    sudo.execute(ctx, &port)?
+        .args(["-u", "upgrade", "outdated"])
         .status_checked()?;
     if ctx.config().cleanup() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["port", "-N", "reclaim"])
-            .status_checked()?;
+        sudo.execute(ctx, &port)?.args(["-N", "reclaim"]).status_checked()?;
     }
 
     Ok(())
@@ -37,13 +32,13 @@ pub fn run_mas(ctx: &ExecutionContext) -> Result<()> {
     let mas = require("mas")?;
     print_separator(t!("macOS App Store"));
 
-    ctx.run_type().execute(mas).arg("upgrade").status_checked()
+    ctx.execute(mas).arg("upgrade").status_checked()
 }
 
 pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
     print_separator(t!("macOS system update"));
 
-    let should_ask = !(ctx.config().yes(Step::System) || ctx.config().dry_run());
+    let should_ask = !(ctx.config().yes(Step::System) || ctx.run_type().dry());
     if should_ask {
         println!("{}", t!("Finding available software"));
         if system_update_available()? {
@@ -58,7 +53,7 @@ pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
         }
     }
 
-    let mut command = ctx.run_type().execute("softwareupdate");
+    let mut command = ctx.execute("softwareupdate");
     command.args(["--install", "--all"]);
 
     if should_ask {
@@ -87,7 +82,7 @@ pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
             .arg(application.path())
             .output_checked_utf8();
         if probe.is_ok() {
-            let mut command = ctx.run_type().execute(&sparkle);
+            let mut command = ctx.execute(&sparkle);
             command.args(["bundle", "--check-immediately", "--application"]);
             command.arg(application.path());
             command.status_checked()?;
@@ -100,14 +95,9 @@ pub fn update_xcodes(ctx: &ExecutionContext) -> Result<()> {
     let xcodes = require("xcodes")?;
     print_separator("Xcodes");
 
-    let should_ask = !(ctx.config().yes(Step::Xcodes) || ctx.config().dry_run());
+    let should_ask = !(ctx.config().yes(Step::Xcodes) || ctx.run_type().dry());
 
-    let releases = ctx
-        .run_type()
-        .execute(&xcodes)
-        .args(["update"])
-        .output_checked_utf8()?
-        .stdout;
+    let releases = ctx.execute(&xcodes).args(["update"]).output_checked_utf8()?.stdout;
 
     let releases_installed: Vec<String> = releases
         .lines()
@@ -164,12 +154,7 @@ pub fn update_xcodes(ctx: &ExecutionContext) -> Result<()> {
         process_xcodes_releases(releases_regular, should_ask, ctx)?;
     }
 
-    let releases_new = ctx
-        .run_type()
-        .execute(&xcodes)
-        .args(["list"])
-        .output_checked_utf8()?
-        .stdout;
+    let releases_new = ctx.execute(&xcodes).args(["list"]).output_checked_utf8()?.stdout;
 
     let releases_gm_new_installed: HashSet<_> = releases_new
         .lines()
@@ -199,7 +184,6 @@ pub fn update_xcodes(ctx: &ExecutionContext) -> Result<()> {
                 prompt_yesno(t!("Would you like to move the former Xcode release to the trash?").as_ref())?;
             if answer_uninstall {
                 let _ = ctx
-                    .run_type()
                     .execute(&xcodes)
                     .args([
                         "uninstall",
@@ -226,7 +210,6 @@ pub fn process_xcodes_releases(releases_filtered: Vec<String>, should_ask: bool,
             let answer_install = prompt_yesno(t!("Would you like to install it?").as_ref())?;
             if answer_install {
                 let _ = ctx
-                    .run_type()
                     .execute(xcodes)
                     .args(["install", &releases_filtered.last().cloned().unwrap_or_default()])
                     .status_checked();

src/steps/os/mod.rs

@@ -14,7 +14,7 @@ pub mod macos;
 pub mod openbsd;
 #[cfg(unix)]
 pub mod unix;
-#[cfg(target_os = "windows")]
+#[cfg(windows)]
 pub mod windows;
 
 #[cfg(windows)]

src/steps/os/openbsd.rs

@@ -1,66 +1,49 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::{get_require_sudo_string, require_option};
 use color_eyre::eyre::Result;
 use rust_i18n::t;
 use std::fs;
+use tracing::debug;
 
-fn is_openbsd_current(ctx: &ExecutionContext) -> Result<bool> {
+fn is_openbsd_current() -> Result<bool> {
     let motd_content = fs::read_to_string("/etc/motd")?;
     let is_current = ["-current", "-beta"].iter().any(|&s| motd_content.contains(s));
-    if ctx.config().dry_run() {
-        println!("{}", t!("Would check if OpenBSD is -current"));
-        Ok(is_current)
-    } else {
-        Ok(is_current)
-    }
+
+    debug!("OpenBSD is -current/-beta: {is_current}");
+
+    Ok(is_current)
 }
 
 pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
     print_separator(t!("OpenBSD Update"));
 
-    let is_current = is_openbsd_current(ctx)?;
+    let sudo = ctx.require_sudo()?;
 
-    if ctx.config().dry_run() {
-        println!("{}", t!("Would upgrade the OpenBSD system"));
-        return Ok(());
-    }
+    let is_current = is_openbsd_current()?;
 
-    let args = if is_current {
-        vec!["/usr/sbin/sysupgrade", "-sn"]
+    if is_current {
+        sudo.execute(ctx, "/usr/sbin/sysupgrade")?.arg("-sn").status_checked()
     } else {
-        vec!["/usr/sbin/syspatch"]
-    };
-
-    ctx.run_type().execute(sudo).args(&args).status_checked()
+        sudo.execute(ctx, "/usr/sbin/syspatch")?.status_checked()
+    }
 }
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
     print_separator(t!("OpenBSD Packages"));
 
-    let is_current = is_openbsd_current(ctx)?;
+    let sudo = ctx.require_sudo()?;
 
-    if ctx.config().dry_run() {
-        println!("{}", t!("Would upgrade OpenBSD packages"));
-        return Ok(());
-    }
+    let is_current = is_openbsd_current()?;
 
     if ctx.config().cleanup() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["/usr/sbin/pkg_delete", "-ac"])
-            .status_checked()?;
+        sudo.execute(ctx, "/usr/sbin/pkg_delete")?.arg("-ac").status_checked()?;
     }
 
-    let mut args = vec!["/usr/sbin/pkg_add", "-u"];
+    let mut command = sudo.execute(ctx, "/usr/sbin/pkg_add")?;
+    command.arg("-u");
     if is_current {
-        args.push("-Dsnap");
+        command.arg("-Dsnap");
     }
-
-    ctx.run_type().execute(sudo).args(&args).status_checked()?;
-
-    Ok(())
+    command.status_checked()
 }

src/steps/os/os_release/amazon_linux

@@ -6,4 +6,4 @@ VERSION_ID="2"
 PRETTY_NAME="Amazon Linux 2"
 ANSI_COLOR="0;33"
 CPE_NAME="cpe:2.3:o:amazon:amazon_linux:2"
-HOME_URL="https://amazonlinux.com/"
+HOME_URL="https://amazonlinux.com/"

src/steps/os/os_release/aosc

@@ -0,0 +1,10 @@
+PRETTY_NAME="AOSC OS (12.2.2)"
+NAME="AOSC OS"
+VERSION_ID="12.2.2"
+VERSION="12.2.2 (localhost)"
+BUILD_ID="20250916"
+ID=aosc
+ANSI_COLOR="1;36"
+HOME_URL="https://aosc.io/"
+SUPPORT_URL="https://github.com/AOSC-Dev/aosc-os-abbs"
+BUG_REPORT_URL="https://github.com/AOSC-Dev/aosc-os-abbs/issues"

src/steps/os/os_release/arch32

@@ -8,4 +8,4 @@ HOME_URL="https://www.archlinux32.org/"
 DOCUMENTATION_URL="https://wiki.archlinux.org/"
 SUPPORT_URL="https://bbs.archlinux32.org/"
 BUG_REPORT_URL="https://bugs.archlinux32.org/"
-LOGO=archlinux
+LOGO=archlinux

src/steps/os/os_release/bazzite

@@ -22,4 +22,4 @@ OSTREE_VERSION='41.20250208.0'
 BUILD_ID="Stable (F41.20250208)"
 BOOTLOADER_NAME="Bazzite Stable (F41.20250208)"
 BUILD_ID="Stable (F41.20250208)"
-BOOTLOADER_NAME="Bazzite Stable (F41.20250208)"
+BOOTLOADER_NAME="Bazzite Stable (F41.20250208)"

src/steps/os/os_release/cachyos

@@ -0,0 +1,11 @@
+NAME="CachyOS Linux"
+PRETTY_NAME="CachyOS"
+ID=cachyos
+BUILD_ID=rolling
+ANSI_COLOR="38;2;23;147;209"
+HOME_URL="https://cachyos.org/"
+DOCUMENTATION_URL="https://wiki.cachyos.org/"
+SUPPORT_URL="https://discuss.cachyos.org/"
+BUG_REPORT_URL="https://github.com/cachyos"
+PRIVACY_POLICY_URL="https://terms.archlinux.org/docs/privacy-policy/"
+LOGO=cachyos

src/steps/os/os_release/centos

@@ -13,4 +13,3 @@ CENTOS_MANTISBT_PROJECT="CentOS-7"
 CENTOS_MANTISBT_PROJECT_VERSION="7"
 REDHAT_SUPPORT_PRODUCT="centos"
 REDHAT_SUPPORT_PRODUCT_VERSION="7"
-

src/steps/os/os_release/fedoraswayatomic

@@ -20,4 +20,4 @@ REDHAT_SUPPORT_PRODUCT_VERSION=40
 SUPPORT_END=2025-05-13
 VARIANT="Sway Atomic"
 VARIANT_ID=sway-atomic
-OSTREE_VERSION='40.20240426.0'
+OSTREE_VERSION='40.20240426.0'

src/steps/os/os_release/garuda

@@ -7,4 +7,4 @@ HOME_URL="https://www.garudalinux.in/"
 DOCUMENTATION_URL="https://wiki.archlinux.org/"
 SUPPORT_URL="https://forum.garudalinux.in/"
 BUG_REPORT_URL="https://gitlab.com/groups/garuda-linux/"
-LOGO=garudalinux
+LOGO=garudalinux

src/steps/os/os_release/manjaro-arm

@@ -4,4 +4,3 @@ PRETTY_NAME="Manjaro ARM"
 ANSI_COLOR="1;32"
 HOME_URL="https://www.manjaro.org/"
 SUPPORT_URL="https://forum.manjaro.org/c/manjaro-arm/"
-

src/steps/os/unix.rs

@@ -1,36 +1,39 @@
-use std::ffi::OsStr;
-use std::fs;
-use std::os::unix::fs::MetadataExt;
-use std::path::Component;
-use std::path::PathBuf;
-use std::process::Command;
-use std::{env::var, path::Path};
-
-use crate::command::CommandExt;
-use crate::{Step, HOME_DIR};
-use color_eyre::eyre::eyre;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
+use color_eyre::eyre::{eyre, OptionExt};
+use etcetera::BaseStrategy;
 use home;
 use ini::Ini;
-use lazy_static::lazy_static;
 #[cfg(target_os = "linux")]
 use nix::unistd::Uid;
 use regex::Regex;
 use rust_i18n::t;
 use semver::Version;
-use tracing::debug;
+use std::ffi::OsStr;
+use std::io::Write;
+use std::os::unix::fs::MetadataExt;
+use std::path::Component;
+use std::path::PathBuf;
+use std::process::Command;
+use std::sync::LazyLock;
+use std::{env::var, path::Path};
+use std::{fs, io};
+use tracing::{debug, warn};
+
+use crate::command::CommandExt;
+use crate::sudo::SudoExecuteOpts;
+use crate::XDG_DIRS;
+use crate::{output_changed_message, HOME_DIR};
 
 #[cfg(target_os = "linux")]
 use super::linux::Distribution;
-use crate::error::SkipStep;
+use crate::error::{SkipStep, StepFailed};
 use crate::execution_context::ExecutionContext;
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 use crate::executor::Executor;
-#[cfg(any(target_os = "linux", target_os = "macos"))]
-use crate::executor::RunType;
+use crate::step::Step;
 use crate::terminal::print_separator;
-use crate::utils::{get_require_sudo_string, require, require_option, PathExt};
+use crate::utils::{require, PathExt};
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 const INTEL_BREW: &str = "/usr/local/bin/brew";
@@ -75,19 +78,41 @@ impl BrewVariant {
         }
     }
 
-    fn execute(self, run_type: RunType) -> Executor {
+    /// Execute an "internal" brew command, i.e. one that should always be run
+    /// even when dry-running. Basically just a wrapper around [`Command::new`]
+    /// that uses `arch` to run using the correct architecture if needed.
+    #[cfg(target_os = "macos")]
+    fn execute_internal(self) -> Command {
         match self {
             BrewVariant::MacIntel if cfg!(target_arch = "aarch64") => {
-                let mut command = run_type.execute("arch");
+                let mut command = Command::new("arch");
                 command.arg("-x86_64").arg(self.binary_name());
                 command
             }
             BrewVariant::MacArm if cfg!(target_arch = "x86_64") => {
-                let mut command = run_type.execute("arch");
+                let mut command = Command::new("arch");
                 command.arg("-arm64e").arg(self.binary_name());
                 command
             }
-            _ => run_type.execute(self.binary_name()),
+            _ => Command::new(self.binary_name()),
+        }
+    }
+
+    /// Execute a brew command. Uses `arch` to run using the correct
+    /// architecture on macOS if needed.
+    fn execute(self, ctx: &ExecutionContext) -> Executor {
+        match self {
+            BrewVariant::MacIntel if cfg!(target_arch = "aarch64") => {
+                let mut command = ctx.execute("arch");
+                command.arg("-x86_64").arg(self.binary_name());
+                command
+            }
+            BrewVariant::MacArm if cfg!(target_arch = "x86_64") => {
+                let mut command = ctx.execute("arch");
+                command.arg("-arm64e").arg(self.binary_name());
+                command
+            }
+            _ => ctx.execute(self.binary_name()),
         }
     }
 
@@ -121,7 +146,6 @@ pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Fisher");
 
     let version_str = ctx
-        .run_type()
         .execute(&fish)
         .args(["-c", "fisher --version"])
         .output_checked_utf8()?
@@ -130,13 +154,10 @@ pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
 
     if version_str.starts_with("fisher version 3.") {
         // v3 - see https://github.com/topgrade-rs/topgrade/pull/37#issuecomment-1283844506
-        ctx.run_type().execute(&fish).args(["-c", "fisher"]).status_checked()
+        ctx.execute(&fish).args(["-c", "fisher"]).status_checked()
     } else {
         // v4
-        ctx.run_type()
-            .execute(&fish)
-            .args(["-c", "fisher update"])
-            .status_checked()
+        ctx.execute(&fish).args(["-c", "fisher update"]).status_checked()
     }
 }
 
@@ -145,8 +166,7 @@ pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Bash-it");
 
-    ctx.run_type()
-        .execute("bash")
+    ctx.execute("bash")
         .args(["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
         .status_checked()
 }
@@ -169,7 +189,7 @@ pub fn run_oh_my_bash(ctx: &ExecutionContext) -> Result<()> {
     let mut update_script = oh_my_bash;
     update_script.push_str("/tools/upgrade.sh");
 
-    ctx.run_type().execute("bash").arg(update_script).status_checked()
+    ctx.execute("bash").arg(update_script).status_checked()
 }
 
 pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
@@ -178,24 +198,25 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("oh-my-fish");
 
-    ctx.run_type().execute(fish).args(["-c", "omf update"]).status_checked()
+    ctx.execute(fish).args(["-c", "omf update"]).status_checked()
 }
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
     let pkgin = require("pkgin")?;
-    let sudo = require_option(ctx.sudo().as_ref(), get_require_sudo_string())?;
 
     print_separator("Pkgin");
 
-    let mut command = ctx.run_type().execute(sudo);
-    command.arg(&pkgin).arg("update");
+    let sudo = ctx.require_sudo()?;
+
+    let mut command = sudo.execute(ctx, &pkgin)?;
+    command.arg("update");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
     command.status_checked()?;
 
-    let mut command = ctx.run_type().execute(sudo);
-    command.arg(&pkgin).arg("upgrade");
+    let mut command = sudo.execute(ctx, &pkgin)?;
+    command.arg("upgrade");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
@@ -210,10 +231,7 @@ pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("fish-plug");
 
-    ctx.run_type()
-        .execute(fish)
-        .args(["-c", "plug update"])
-        .status_checked()
+    ctx.execute(fish).args(["-c", "plug update"]).status_checked()
 }
 
 /// Upgrades `fundle` and `fundle` plugins.
@@ -227,8 +245,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("fundle");
 
-    ctx.run_type()
-        .execute(fish)
+    ctx.execute(fish)
         .args(["-c", "fundle self-update && fundle update"])
         .status_checked()
 }
@@ -236,9 +253,9 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
 #[cfg(not(any(target_os = "android", target_os = "macos")))]
 pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
     let gdbus = require("gdbus")?;
-    require_option(
+    crate::utils::require_option(
         var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
-        t!("Desktop doest not appear to be gnome").to_string(),
+        t!("Desktop does not appear to be GNOME").to_string(),
     )?;
     let output = Command::new("gdbus")
         .args([
@@ -253,15 +270,14 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
         ])
         .output_checked_utf8()?;
 
-    debug!("Checking for gnome extensions: {}", output);
+    debug!("Checking for GNOME extensions: {}", output);
     if !output.stdout.contains("org.gnome.Shell.Extensions") {
-        return Err(SkipStep(t!("Gnome shell extensions are unregistered in DBus").to_string()).into());
+        return Err(SkipStep(t!("GNOME shell extensions are unregistered in DBus").to_string()).into());
     }
 
-    print_separator(t!("Gnome Shell extensions"));
+    print_separator(t!("GNOME Shell extensions"));
 
-    ctx.run_type()
-        .execute(gdbus)
+    ctx.execute(gdbus)
         .args([
             "call",
             "--session",
@@ -317,26 +333,19 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
             let sudo_as_user = t!("sudo as user '{user}'", user = user.name);
             print_separator(format!("{} ({})", variant.step_title(), sudo_as_user));
 
-            let sudo = crate::utils::require_option(ctx.sudo().as_ref(), crate::utils::get_require_sudo_string())?;
-            ctx.run_type()
-                .execute(sudo)
+            let sudo = ctx.require_sudo()?;
+            sudo.execute_opts(ctx, &binary_name, SudoExecuteOpts::new().set_home().user(&user.name))?
                 .current_dir("/tmp") // brew needs a writable current directory
-                .args([
-                    "--set-home",
-                    &format!("--user={}", user.name),
-                    &format!("{}", binary_name.to_string_lossy()),
-                    "update",
-                ])
+                .arg("update")
                 .status_checked()?;
             return Ok(());
         }
     }
     print_separator(variant.step_title());
-    let run_type = ctx.run_type();
 
-    variant.execute(run_type).arg("update").status_checked()?;
+    variant.execute(ctx).arg("update").status_checked()?;
 
-    let mut command = variant.execute(run_type);
+    let mut command = variant.execute(ctx);
     command.args(["upgrade", "--formula"]);
 
     if ctx.config().brew_fetch_head() {
@@ -346,11 +355,11 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
     command.status_checked()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").status_checked()?;
+        variant.execute(ctx).arg("cleanup").status_checked()?;
     }
 
     if ctx.config().brew_autoremove() {
-        variant.execute(run_type).arg("autoremove").status_checked()?;
+        variant.execute(ctx).arg("autoremove").status_checked()?;
     }
 
     Ok(())
@@ -363,10 +372,9 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
         return Err(SkipStep(t!("Not a custom brew for macOS").to_string()).into());
     }
     print_separator(format!("{} - Cask", variant.step_title()));
-    let run_type = ctx.run_type();
 
     let cask_upgrade_exists = variant
-        .execute(RunType::Wet)
+        .execute_internal()
         .args(["--repository", "buo/cask-upgrade"])
         .output_checked_utf8()
         .map(|p| Path::new(p.stdout.trim()).exists())?;
@@ -391,10 +399,10 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
         }
     }
 
-    variant.execute(run_type).args(&brew_args).status_checked()?;
+    variant.execute(ctx).args(&brew_args).status_checked()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").status_checked()?;
+        variant.execute(ctx).arg("cleanup").status_checked()?;
     }
 
     Ok(())
@@ -403,19 +411,80 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
 pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
     let guix = require("guix")?;
 
-    let run_type = ctx.run_type();
-
-    let output = Command::new(&guix).arg("pull").output_checked_utf8();
-    debug!("guix pull output: {:?}", output);
-    let should_upgrade = output.is_ok();
-    debug!("Can Upgrade Guix: {:?}", should_upgrade);
-
     print_separator("Guix");
 
-    if should_upgrade {
-        return run_type.execute(&guix).args(["package", "-u"]).status_checked();
+    ctx.execute(&guix).arg("pull").status_checked()?;
+    ctx.execute(&guix).args(["package", "-u"]).status_checked()?;
+
+    Ok(())
+}
+
+struct NixVersion {
+    version_string: String,
+}
+
+impl NixVersion {
+    fn new(ctx: &ExecutionContext, nix: &Path) -> Result<Self> {
+        let version_output = ctx.execute(nix).arg("--version").output_checked_utf8()?;
+
+        debug!(
+            output=%version_output,
+            "`nix --version` output"
+        );
+
+        let version_string = version_output
+            .stdout
+            .lines()
+            .next()
+            .ok_or_else(|| eyre!("`nix --version` output is empty"))?
+            .to_string();
+
+        if version_string.is_empty() {
+            return Err(eyre!("`nix --version` output was empty"));
+        }
+
+        Ok(Self { version_string })
+    }
+
+    fn version(&self) -> Result<Version> {
+        static NIX_VERSION_REGEX: LazyLock<Regex> =
+            LazyLock::new(|| Regex::new(r"^nix \([^)]*\) ([0-9.]+)").expect("Nix version regex always compiles"));
+
+        let captures = NIX_VERSION_REGEX
+            .captures(&self.version_string)
+            .ok_or_else(|| eyre!(output_changed_message!("nix --version", "regex did not match")))?;
+        let raw_version = &captures[1];
+
+        debug!("Raw Nix version: {raw_version}");
+
+        // Nix 2.29.0 outputs "2.29" instead of "2.29.0", so we need to add that if necessary.
+        let corrected_raw_version = if raw_version.chars().filter(|&c| c == '.').count() == 1 {
+            &format!("{raw_version}.0")
+        } else {
+            raw_version
+        };
+
+        debug!("Corrected raw Nix version: {corrected_raw_version}");
+
+        let version = Version::parse(corrected_raw_version)
+            .wrap_err_with(|| output_changed_message!("nix --version", "Invalid version"))?;
+
+        debug!("Nix version: {:?}", version);
+
+        Ok(version)
+    }
+
+    fn is_lix(&self) -> bool {
+        let is_lix = self.version_string.contains("Lix");
+        debug!(?is_lix);
+        is_lix
+    }
+
+    fn is_determinate_nix(&self) -> bool {
+        let is_determinate_nix = self.version_string.contains("Determinate Nix");
+        debug!(?is_determinate_nix);
+        is_determinate_nix
     }
-    Err(SkipStep(t!("Guix Pull Failed, Skipping").to_string()).into())
 }
 
 pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
@@ -424,7 +493,11 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     let nix_env = require("nix-env")?;
     // TODO: Is None possible here?
     let profile_path = match home::home_dir() {
-        Some(home) => Path::new(&home).join(".nix-profile"),
+        Some(home) => XDG_DIRS
+            .state_dir()
+            .map(|d| d.join("nix/profile"))
+            .filter(|p| p.exists())
+            .unwrap_or(Path::new(&home).join(".nix-profile")),
         None => Path::new("/nix/var/nix/profiles/per-user/default").into(),
     };
     debug!("nix profile: {:?}", profile_path);
@@ -441,62 +514,20 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
         }
     }
 
-    let run_type = ctx.run_type();
-    run_type.execute(nix_channel).arg("--update").status_checked()?;
+    ctx.execute(nix_channel).arg("--update").status_checked()?;
 
-    let mut get_version_cmd = ctx.run_type().execute(&nix);
-    get_version_cmd.arg("--version");
-    let get_version_cmd_output = get_version_cmd.output_checked_utf8()?;
-    let get_version_cmd_first_line_stdout = get_version_cmd_output
-        .stdout
-        .lines()
-        .next()
-        .ok_or_else(|| eyre!("`nix --version` output is empty"))?;
-
-    let is_lix = get_version_cmd_first_line_stdout.contains("Lix");
-
-    debug!(
-        output=%get_version_cmd_output,
-        ?is_lix,
-        "`nix --version` output"
-    );
-
-    lazy_static! {
-        static ref NIX_VERSION_REGEX: Regex =
-            Regex::new(r"^nix \([^)]*\) ([0-9.]+)").expect("Nix version regex always compiles");
-    }
-
-    if get_version_cmd_first_line_stdout.is_empty() {
-        return Err(eyre!("`nix --version` output was empty"));
-    }
-
-    let captures = NIX_VERSION_REGEX.captures(get_version_cmd_first_line_stdout);
-    let raw_version = match &captures {
-        None => {
-            return Err(eyre!(
-                "`nix --version` output was weird: {get_version_cmd_first_line_stdout:?}\n\
-                If the `nix --version` output format changed, please file an issue to Topgrade"
-            ));
-        }
-        Some(captures) => &captures[1],
-    };
-
-    let version =
-        Version::parse(raw_version).wrap_err_with(|| format!("Unable to parse Nix version: {raw_version:?}"))?;
-
-    debug!("Nix version: {:?}", version);
+    let nix_version = NixVersion::new(ctx, &nix)?;
 
     // Nix since 2.21.0 uses `--all --impure` rather than `.*` to upgrade all packages.
     // Lix is based on Nix 2.18, so it doesn't!
-    let packages = if version >= Version::new(2, 21, 0) && !is_lix {
+    let packages = if nix_version.version()? >= Version::new(2, 21, 0) && !nix_version.is_lix() {
         vec!["--all", "--impure"]
     } else {
         vec![".*"]
     };
 
     if Path::new(&manifest_json_path).exists() {
-        run_type
-            .execute(nix)
+        ctx.execute(nix)
             .args(nix_args())
             .arg("profile")
             .arg("upgrade")
@@ -504,7 +535,7 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
             .arg("--verbose")
             .status_checked()
     } else {
-        let mut command = run_type.execute(nix_env);
+        let mut command = ctx.execute(nix_env);
         command.arg("--upgrade");
         if let Some(args) = ctx.config().nix_env_arguments() {
             command.args(args.split_whitespace());
@@ -540,21 +571,37 @@ pub fn run_nix_self_upgrade(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator(t!("Nix (self-upgrade)"));
 
+    let nix_version = NixVersion::new(ctx, &nix)?;
+
+    if nix_version.is_determinate_nix() {
+        let nixd = require("determinate-nixd");
+        let nixd = match nixd {
+            Err(_) => {
+                println!("Found Determinate Nix, but could not find determinate-nixd");
+                return Err(StepFailed.into());
+            }
+            Ok(nixd) => nixd,
+        };
+
+        let sudo = ctx.require_sudo()?;
+        return sudo
+            .execute_opts(ctx, nixd, SudoExecuteOpts::new().login_shell())?
+            .arg("upgrade")
+            .status_checked();
+    }
+
     let multi_user = fs::metadata(&nix)?.uid() == 0;
     debug!("Multi user nix: {}", multi_user);
 
     let nix_args = nix_args();
     if multi_user {
-        ctx.execute_elevated(&nix, true)?
+        let sudo = ctx.require_sudo()?;
+        sudo.execute_opts(ctx, &nix, SudoExecuteOpts::new().login_shell())?
             .args(nix_args)
             .arg("upgrade-nix")
             .status_checked()
     } else {
-        ctx.run_type()
-            .execute(&nix)
-            .args(nix_args)
-            .arg("upgrade-nix")
-            .status_checked()
+        ctx.execute(&nix).args(nix_args).arg("upgrade-nix").status_checked()
     }
 }
 
@@ -620,6 +667,84 @@ fn nix_profile_dir(nix: &Path) -> Result<Option<PathBuf>> {
     )
 }
 
+/// Returns a directory from an environment variable, if and only if it is a directory which
+/// contains a flake.nix
+fn flake_dir(var: &'static str) -> Option<PathBuf> {
+    std::env::var_os(var)
+        .map(PathBuf::from)
+        .take_if(|x| std::fs::exists(x.join("flake.nix")).is_ok_and(|x| x))
+}
+
+/// Update NixOS and home-manager through a flake using `nh`
+///
+/// See: https://github.com/viperML/nh
+pub fn run_nix_helper(ctx: &ExecutionContext) -> Result<()> {
+    require("nix")?;
+    let nix_helper = require("nh")?;
+
+    let fallback_flake_path = flake_dir("NH_FLAKE");
+    let darwin_flake_path = flake_dir("NH_DARWIN_FLAKE");
+    let home_flake_path = flake_dir("NH_HOME_FLAKE");
+    let nixos_flake_path = flake_dir("NH_OS_FLAKE");
+
+    let all_flake_paths: Vec<_> = [
+        fallback_flake_path.as_ref(),
+        darwin_flake_path.as_ref(),
+        home_flake_path.as_ref(),
+        nixos_flake_path.as_ref(),
+    ]
+    .into_iter()
+    .flatten()
+    .collect();
+
+    // if none of the paths exist AND contain a `flake.nix`, skip
+    if all_flake_paths.is_empty() {
+        if flake_dir("FLAKE").is_some() {
+            warn!(
+                "{}",
+                t!("You have a flake inside of $FLAKE. This is deprecated for nh.")
+            );
+        }
+        return Err(SkipStep(t!("nh cannot find any configured flakes").into()).into());
+    }
+
+    let nh_switch = |ty: &'static str| -> Result<()> {
+        print_separator(format!("nh {ty}"));
+
+        let mut cmd = ctx.execute(&nix_helper);
+        cmd.arg(ty);
+        cmd.arg("switch");
+        cmd.arg("-u");
+
+        if !ctx.config().yes(Step::NixHelper) {
+            cmd.arg("--ask");
+        }
+        cmd.status_checked()?;
+        Ok(())
+    };
+
+    // We assume that if the user has set these variables, we can throw an error if nh cannot find
+    // a flake there. So we do not anymore perform an eval check to find out whether we should skip
+    // or not.
+    #[cfg(target_os = "macos")]
+    if darwin_flake_path.is_some() || fallback_flake_path.is_some() {
+        nh_switch("darwin")?;
+    }
+
+    if home_flake_path.is_some() || fallback_flake_path.is_some() {
+        nh_switch("home")?;
+    }
+
+    #[cfg(target_os = "linux")]
+    if matches!(Distribution::detect(), Ok(Distribution::NixOS))
+        && (nixos_flake_path.is_some() || fallback_flake_path.is_some())
+    {
+        nh_switch("os")?;
+    }
+
+    Ok(())
+}
+
 fn nix_args() -> [&'static str; 2] {
     ["--extra-experimental-features", "nix-command"]
 }
@@ -629,7 +754,7 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("yadm");
 
-    ctx.run_type().execute(yadm).arg("pull").status_checked()
+    ctx.execute(yadm).arg("pull").status_checked()
 }
 
 pub fn run_asdf(ctx: &ExecutionContext) -> Result<()> {
@@ -648,26 +773,28 @@ pub fn run_asdf(ctx: &ExecutionContext) -> Result<()> {
     // v0.15.0-31e8c93
     //
     // ```
+    // ```
+    // $ asdf version
+    // v0.16.7
+    // ```
+    // ```
+    // $ asdf version
+    // 0.18.0 (revision unknown)
+    // ```
     let version_stdout = version_output.stdout.trim();
     // trim the starting 'v'
     let mut remaining = version_stdout.trim_start_matches('v');
-    let idx = remaining
-        .find('-')
-        .expect("the output of `asdf version` changed, please file an issue to Topgrade");
-    // remove the hash part
-    remaining = &remaining[..idx];
-    let version = Version::parse(remaining).expect("should be a valid version");
+    // remove the hash or revision part if present
+    if let Some(idx) = remaining.find(['-', ' ']) {
+        remaining = &remaining[..idx];
+    }
+    let version =
+        Version::parse(remaining).wrap_err_with(|| output_changed_message!("asdf version", "invalid version"))?;
     if version < Version::new(0, 15, 0) {
-        ctx.run_type()
-            .execute(&asdf)
-            .arg("update")
-            .status_checked_with_codes(&[42])?;
+        ctx.execute(&asdf).arg("update").status_checked_with_codes(&[42])?;
     }
 
-    ctx.run_type()
-        .execute(&asdf)
-        .args(["plugin", "update", "--all"])
-        .status_checked()
+    ctx.execute(&asdf).args(["plugin", "update", "--all"]).status_checked()
 }
 
 pub fn run_mise(ctx: &ExecutionContext) -> Result<()> {
@@ -675,12 +802,29 @@ pub fn run_mise(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("mise");
 
-    ctx.run_type()
-        .execute(&mise)
-        .args(["plugins", "update"])
-        .status_checked()?;
+    ctx.execute(&mise).args(["plugins", "update"]).status_checked()?;
 
-    ctx.run_type().execute(&mise).arg("upgrade").status_checked()
+    let output = ctx
+        .execute(&mise)
+        .args(["self-update"])
+        .output_checked_with(|_| Ok(()))?;
+    let status_code = output
+        .status
+        .code()
+        .ok_or_eyre("Couldn't get status code (terminated by signal)")?;
+    let stderr = std::str::from_utf8(&output.stderr).wrap_err("Expected output to be valid UTF-8")?;
+    if stderr.contains("mise is installed via a package manager") && status_code == 1 {
+        debug!("Mise self-update not available")
+    } else {
+        // Write the output
+        io::stdout().write_all(&output.stdout)?;
+        io::stderr().write_all(&output.stderr)?;
+        if status_code != 0 {
+            return Err(StepFailed.into());
+        }
+    }
+
+    ctx.execute(&mise).arg("upgrade").status_checked()
 }
 
 pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
@@ -688,7 +832,7 @@ pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("home-manager");
 
-    let mut cmd = ctx.run_type().execute(home_manager);
+    let mut cmd = ctx.execute(home_manager);
     cmd.arg("switch");
 
     if let Some(extra_args) = ctx.config().home_manager() {
@@ -698,18 +842,11 @@ pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
     cmd.status_checked()
 }
 
-pub fn run_tldr(ctx: &ExecutionContext) -> Result<()> {
-    let tldr = require("tldr")?;
-
-    print_separator("TLDR");
-    ctx.run_type().execute(tldr).arg("--update").status_checked()
-}
-
 pub fn run_pearl(ctx: &ExecutionContext) -> Result<()> {
     let pearl = require("pearl")?;
     print_separator("pearl");
 
-    ctx.run_type().execute(pearl).arg("update").status_checked()
+    ctx.execute(pearl).arg("update").status_checked()
 }
 
 pub fn run_pyenv(ctx: &ExecutionContext) -> Result<()> {
@@ -730,7 +867,7 @@ pub fn run_pyenv(ctx: &ExecutionContext) -> Result<()> {
         return Err(SkipStep(t!("pyenv-update plugin is not installed").to_string()).into());
     }
 
-    ctx.run_type().execute(pyenv).arg("update").status_checked()
+    ctx.execute(pyenv).arg("update").status_checked()
 }
 
 pub fn run_sdkman(ctx: &ExecutionContext) -> Result<()> {
@@ -759,34 +896,25 @@ pub fn run_sdkman(ctx: &ExecutionContext) -> Result<()> {
 
     if selfupdate_enabled == "true" {
         let cmd_selfupdate = format!("source {} && sdk selfupdate", &sdkman_init_path);
-        ctx.run_type()
-            .execute(&bash)
+        ctx.execute(&bash)
             .args(["-c", cmd_selfupdate.as_str()])
             .status_checked()?;
     }
 
     let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
-    ctx.run_type()
-        .execute(&bash)
-        .args(["-c", cmd_update.as_str()])
-        .status_checked()?;
+    ctx.execute(&bash).args(["-c", cmd_update.as_str()]).status_checked()?;
 
     let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
-    ctx.run_type()
-        .execute(&bash)
-        .args(["-c", cmd_upgrade.as_str()])
-        .status_checked()?;
+    ctx.execute(&bash).args(["-c", cmd_upgrade.as_str()]).status_checked()?;
 
     if ctx.config().cleanup() {
         let cmd_flush_archives = format!("source {} && sdk flush archives", &sdkman_init_path);
-        ctx.run_type()
-            .execute(&bash)
+        ctx.execute(&bash)
             .args(["-c", cmd_flush_archives.as_str()])
             .status_checked()?;
 
         let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
-        ctx.run_type()
-            .execute(&bash)
+        ctx.execute(&bash)
             .args(["-c", cmd_flush_temp.as_str()])
             .status_checked()?;
     }
@@ -807,7 +935,7 @@ pub fn run_bun_packages(ctx: &ExecutionContext) -> Result<()> {
         return Ok(());
     }
 
-    ctx.run_type().execute(bun).args(["-g", "update"]).status_checked()
+    ctx.execute(bun).args(["-g", "update"]).status_checked()
 }
 
 /// Update dotfiles with `rcm(7)`.
@@ -817,18 +945,35 @@ pub fn run_rcm(ctx: &ExecutionContext) -> Result<()> {
     let rcup = require("rcup")?;
 
     print_separator("rcm");
-    ctx.run_type().execute(rcup).arg("-v").status_checked()
+    ctx.execute(rcup).arg("-v").status_checked()
 }
 
 pub fn run_maza(ctx: &ExecutionContext) -> Result<()> {
     let maza = require("maza")?;
 
     print_separator("maza");
-    ctx.run_type().execute(maza).arg("update").status_checked()
+    ctx.execute(maza).arg("update").status_checked()
 }
 
-pub fn reboot() -> Result<()> {
-    print!("{}", t!("Rebooting..."));
+pub fn run_hyprpm(ctx: &ExecutionContext) -> Result<()> {
+    let hyprpm = require("hyprpm")?;
 
-    Command::new("sudo").arg("reboot").status_checked()
+    print_separator("hyprpm");
+
+    ctx.execute(hyprpm).arg("update").status_checked()
+}
+
+pub fn run_atuin(ctx: &ExecutionContext) -> Result<()> {
+    let atuin = require("atuin-update")?;
+
+    print_separator("atuin");
+
+    ctx.execute(atuin).status_checked()
+}
+
+pub fn reboot(ctx: &ExecutionContext) -> Result<()> {
+    match ctx.sudo() {
+        Some(sudo) => sudo.execute(ctx, "reboot")?.status_checked(),
+        None => ctx.execute("reboot").status_checked(),
+    }
 }

src/steps/os/windows.rs

@@ -3,15 +3,16 @@ use std::{ffi::OsStr, process::Command};
 
 use color_eyre::eyre::Result;
 use etcetera::base_strategy::BaseStrategy;
+use rust_i18n::t;
 use tracing::debug;
 
 use crate::command::CommandExt;
+use crate::config::UpdatesAutoReboot;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::{print_separator, print_warning};
 use crate::utils::{require, which};
 use crate::{error::SkipStep, steps::git::RepoStep};
-use crate::{powershell, Step};
-use rust_i18n::t;
 
 pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {
     let choco = require("choco")?;
@@ -19,15 +20,9 @@ pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Chocolatey");
 
-    let mut command = match ctx.sudo() {
-        Some(sudo) => {
-            let mut command = ctx.run_type().execute(sudo);
-            command.arg(choco);
-            command
-        }
-        None => ctx.run_type().execute(choco),
-    };
+    let sudo = ctx.require_sudo()?;
 
+    let mut command = sudo.execute(ctx, &choco)?;
     command.args(["upgrade", "all"]);
 
     if yes {
@@ -42,12 +37,23 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("winget");
 
+    ctx.execute(&winget).args(["source", "update"]).status_checked()?;
+
+    let mut command = if ctx.config().winget_use_sudo() {
+        let sudo = ctx.require_sudo()?;
+        sudo.execute(ctx, &winget)?
+    } else {
+        ctx.execute(winget)
+    };
+
     let mut args = vec!["upgrade", "--all"];
     if ctx.config().winget_silent_install() {
         args.push("--silent");
     }
 
-    ctx.run_type().execute(winget).args(args).status_checked()
+    command.args(args).status_checked()?;
+
+    Ok(())
 }
 
 pub fn run_scoop(ctx: &ExecutionContext) -> Result<()> {
@@ -55,17 +61,13 @@ pub fn run_scoop(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Scoop");
 
-    ctx.run_type().execute(&scoop).args(["update"]).status_checked()?;
-    ctx.run_type().execute(&scoop).args(["update", "*"]).status_checked()?;
+    ctx.execute(&scoop).args(["update"]).status_checked()?;
+    ctx.execute(&scoop).args(["update", "*"]).status_checked()?;
 
     if ctx.config().cleanup() {
-        ctx.run_type().execute(&scoop).args(["cleanup", "*"]).status_checked()?;
-        ctx.run_type()
-            .execute(&scoop)
-            .args(["cache", "rm", "-a"])
-            .status_checked()?
+        ctx.execute(&scoop).args(["cleanup", "*"]).status_checked()?;
+        ctx.execute(&scoop).args(["cache", "rm", "-a"]).status_checked()?
     }
-
     Ok(())
 }
 
@@ -78,7 +80,7 @@ pub fn update_wsl(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator(t!("Update WSL"));
 
-    let mut wsl_command = ctx.run_type().execute(wsl);
+    let mut wsl_command = ctx.execute(wsl);
     wsl_command.args(["--update"]);
 
     if ctx.config().wsl_update_pre_release() {
@@ -95,7 +97,7 @@ pub fn update_wsl(ctx: &ExecutionContext) -> Result<()> {
 /// Detect if WSL is installed or not.
 ///
 /// For WSL, we cannot simply check if command `wsl` is installed as on newer
-/// versions of Windows (since windows 10 version 2004), this commmand is
+/// versions of Windows (since windows 10 version 2004), this command is
 /// installed by default.
 ///
 /// If the command is installed and the user hasn't installed any Linux distros
@@ -120,8 +122,8 @@ fn get_wsl_distributions(wsl: &Path) -> Result<Vec<String>> {
     let output = Command::new(wsl).args(["--list", "-q"]).output_checked_utf8()?.stdout;
     Ok(output
         .lines()
+        .map(|x| x.replace(['\u{0}', '\r'], "").trim().to_owned())
         .filter(|s| !s.is_empty())
-        .map(|x| x.replace(['\u{0}', '\r'], ""))
         .collect())
 }
 
@@ -134,7 +136,7 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
         .trim_end()
         .to_owned();
 
-    let mut command = ctx.run_type().execute(wsl);
+    let mut command = ctx.execute(wsl);
 
     // The `arg` method automatically quotes its arguments.
     // This means we can't append additional arguments to `topgrade` in WSL
@@ -144,12 +146,12 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
     //
     // ```rust
     // command
-    //  .args(["-d", dist, "bash", "-c"])
+    //  .args(["-d", dist, "bash", "-lc"])
     //  .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade}"));
     // ```
     //
     // creates a command string like:
-    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -c 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade'`
+    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -lc 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade'`
     //
     // Adding the following:
     //
@@ -158,7 +160,7 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
     // ```
     //
     // appends the next argument like so:
-    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -c 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade' -v`
+    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -lc 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade' -v`
     // which means `-v` isn't passed to `topgrade`.
     let mut args = String::new();
     if ctx.config().verbose() {
@@ -166,7 +168,7 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
     }
 
     command
-        .args(["-d", dist, "bash", "-c"])
+        .args(["-d", dist, "bash", "-lc"])
         .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade} {args}"));
 
     if ctx.config().yes(Step::Wsl) {
@@ -201,40 +203,74 @@ pub fn run_wsl_topgrade(ctx: &ExecutionContext) -> Result<()> {
     if ran {
         Ok(())
     } else {
-        Err(SkipStep(t!("Could not find Topgrade in any WSL disribution").to_string()).into())
+        Err(SkipStep(t!("Could not find Topgrade in any WSL distribution").to_string()).into())
     }
 }
 
 pub fn windows_update(ctx: &ExecutionContext) -> Result<()> {
-    let powershell = powershell::Powershell::windows_powershell();
+    let powershell = ctx.require_powershell()?;
 
     print_separator(t!("Windows Update"));
 
-    if powershell.supports_windows_update() {
-        println!("The installer will request to run as administrator, expect a prompt.");
-
-        powershell.windows_update(ctx)
-    } else {
+    if !powershell.has_module("PSWindowsUpdate") {
         print_warning(t!(
-            "Consider installing PSWindowsUpdate as the use of Windows Update via USOClient is not supported."
+            "The PSWindowsUpdate PowerShell module isn't installed so Topgrade can't run Windows Update.\nInstall PSWindowsUpdate by running `Install-Module PSWindowsUpdate` in PowerShell."
         ));
 
-        Err(SkipStep(t!("USOClient not supported.").to_string()).into())
+        return Err(SkipStep(t!("PSWindowsUpdate is not installed").to_string()).into());
     }
+
+    let mut cmd = "Import-Module PSWindowsUpdate; Install-WindowsUpdate -Verbose".to_string();
+
+    if ctx.config().accept_all_windows_updates() {
+        cmd.push_str(" -AcceptAll");
+    }
+
+    match ctx.config().windows_updates_auto_reboot() {
+        UpdatesAutoReboot::Yes => cmd.push_str(" -AutoReboot"),
+        UpdatesAutoReboot::No => cmd.push_str(" -IgnoreReboot"),
+        UpdatesAutoReboot::Ask => (), // Prompting is the default for Install-WindowsUpdate
+    }
+
+    powershell.build_command(ctx, &cmd, true)?.status_checked()
 }
 
 pub fn microsoft_store(ctx: &ExecutionContext) -> Result<()> {
-    let powershell = powershell::Powershell::windows_powershell();
+    let powershell = ctx.require_powershell()?;
 
     print_separator(t!("Microsoft Store"));
 
-    powershell.microsoft_store(ctx)
+    println!("{}", t!("Scanning for updates..."));
+
+    // Scan for updates using the MDM UpdateScanMethod
+    // This method is also available for non-MDM devices
+    let cmd = r#"(Get-CimInstance -Namespace "Root\cimv2\mdm\dmmap" -ClassName "MDM_EnterpriseModernAppManagement_AppManagement01" | Invoke-CimMethod -MethodName UpdateScanMethod).ReturnValue"#;
+
+    powershell
+        .build_command(ctx, cmd, true)?
+        .output_checked_with_utf8(|output| {
+            if !output.status.success() {
+                return Err(());
+            }
+            let ret_val = output.stdout.trim();
+            debug!("Command return value: {}", ret_val);
+            if ret_val == "0" {
+                Ok(())
+            } else {
+                Err(())
+            }
+        })?;
+    println!(
+        "{}",
+        t!("Success, Microsoft Store apps are being updated in the background")
+    );
+    Ok(())
 }
 
-pub fn reboot() -> Result<()> {
+pub fn reboot(ctx: &ExecutionContext) -> Result<()> {
     // If this works, it won't return, but if it doesn't work, it may return a useful error
     // message.
-    Command::new("shutdown").args(["/R", "/T", "0"]).status_checked()
+    ctx.execute("shutdown.exe").args(["/R", "/T", "0"]).status_checked()
 }
 
 pub fn insert_startup_scripts(git_repos: &mut RepoStep) -> Result<()> {

src/steps/powershell.rs

@@ -1,161 +1,159 @@
-#[cfg(windows)]
-use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 
+#[cfg(windows)]
+use color_eyre::eyre::eyre;
 use color_eyre::eyre::Result;
-use rust_i18n::t;
+use tracing::debug;
 
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::terminal::{is_dumb, print_separator};
-use crate::utils::{require_option, which};
-use crate::Step;
+use crate::terminal;
+use crate::utils::{which, PathExt};
 
 pub struct Powershell {
-    path: Option<PathBuf>,
+    path: PathBuf,
     profile: Option<PathBuf>,
+    is_pwsh: bool,
 }
 
 impl Powershell {
-    /// Returns a powershell instance.
-    ///
-    /// If the powershell binary is not found, or the current terminal is dumb
-    /// then the instance of this struct will skip all the powershell steps.
-    pub fn new() -> Self {
-        let path = which("pwsh").or_else(|| which("powershell")).filter(|_| !is_dumb());
-
-        let profile = path.as_ref().and_then(|path| {
-            Command::new(path)
-                .args(["-NoProfile", "-Command", "Split-Path $profile"])
-                .output_checked_utf8()
-                .map(|output| PathBuf::from(output.stdout.trim()))
-                .and_then(super::super::utils::PathExt::require)
-                .ok()
-        });
-
-        Powershell { path, profile }
-    }
-
-    #[cfg(windows)]
-    pub fn windows_powershell() -> Self {
-        Powershell {
-            path: which("powershell").filter(|_| !is_dumb()),
-            profile: None,
+    pub fn new() -> Option<Self> {
+        if terminal::is_dumb() {
+            return None;
         }
-    }
 
-    #[cfg(windows)]
-    pub fn has_module(powershell: &Path, command: &str) -> bool {
-        Command::new(powershell)
-            .args([
-                "-NoProfile",
-                "-Command",
-                &format!("Get-Module -ListAvailable {command}"),
-            ])
-            .output_checked_utf8()
-            .map(|result| !result.stdout.is_empty())
-            .unwrap_or(false)
+        let (path, is_pwsh) = which("pwsh")
+            .map(|p| (Some(p), true))
+            .or_else(|| which("powershell").map(|p| (Some(p), false)))
+            .unwrap_or((None, false));
+
+        path.map(|path| {
+            let mut ret = Self {
+                path,
+                profile: None,
+                is_pwsh,
+            };
+            ret.set_profile();
+            ret
+        })
     }
 
     pub fn profile(&self) -> Option<&PathBuf> {
         self.profile.as_ref()
     }
 
-    pub fn update_modules(&self, ctx: &ExecutionContext) -> Result<()> {
-        let powershell = require_option(self.path.as_ref(), t!("Powershell is not installed").to_string())?;
+    fn set_profile(&mut self) {
+        let profile = self
+            .build_command_internal("Split-Path $PROFILE")
+            .output_checked_utf8()
+            .map(|output| output.stdout.trim().to_string())
+            .and_then(|s| PathBuf::from(s).require())
+            .ok();
+        debug!("Found PowerShell profile: {:?}", profile);
+        self.profile = profile;
+    }
 
-        print_separator(t!("Powershell Modules Update"));
+    pub fn is_pwsh(&self) -> bool {
+        self.is_pwsh
+    }
 
-        let mut cmd = vec!["Update-Module"];
+    /// Builds an "internal" powershell command
+    pub fn build_command_internal(&self, cmd: &str) -> Command {
+        let mut command = Command::new(&self.path);
 
-        if ctx.config().verbose() {
-            cmd.push("-Verbose");
+        command.args(["-NoProfile", "-Command"]);
+        command.arg(cmd);
+
+        // If topgrade was run from pwsh, but we are trying to run powershell, then
+        // the inherited PSModulePath breaks module imports
+        if !self.is_pwsh {
+            command.env_remove("PSModulePath");
         }
 
-        if ctx.config().yes(Step::Powershell) {
-            cmd.push("-Force");
+        command
+    }
+
+    /// Builds a "primary" powershell command (uses dry-run if required):
+    /// {powershell} -NoProfile -Command {cmd}
+    pub fn build_command<'a>(
+        &self,
+        ctx: &'a ExecutionContext,
+        cmd: &str,
+        use_sudo: bool,
+    ) -> Result<impl CommandExt + 'a> {
+        let mut command = if use_sudo {
+            let sudo = ctx.require_sudo()?;
+            sudo.execute(ctx, &self.path)?
+        } else {
+            ctx.execute(&self.path)
+        };
+
+        #[cfg(windows)]
+        {
+            // Check execution policy and return early if it's not set correctly
+            self.execution_policy_args_if_needed()?;
         }
 
-        println!("{}", t!("Updating modules..."));
-        ctx.run_type()
-            .execute(powershell)
-            // This probably doesn't need `shell_words::join`.
-            .args(["-NoProfile", "-Command", &cmd.join(" ")])
-            .status_checked()
+        command.args(["-NoProfile", "-Command"]);
+        command.arg(cmd);
+
+        // If topgrade was run from pwsh, but we are trying to run powershell, then
+        // the inherited PSModulePath breaks module imports
+        if !self.is_pwsh {
+            command.env_remove("PSModulePath");
+        }
+
+        Ok(command)
     }
 
     #[cfg(windows)]
-    pub fn supports_windows_update(&self) -> bool {
-        self.path
-            .as_ref()
-            .map(|p| Self::has_module(p, "PSWindowsUpdate"))
+    fn execution_policy_args_if_needed(&self) -> Result<()> {
+        if !self.is_execution_policy_set("RemoteSigned") {
+            Err(eyre!(
+                "PowerShell execution policy is too restrictive. \
+                Please run 'Set-ExecutionPolicy RemoteSigned -Scope CurrentUser' in PowerShell \
+                (or use Unrestricted/Bypass if you're sure about the security implications)"
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    #[cfg(windows)]
+    fn is_execution_policy_set(&self, policy: &str) -> bool {
+        // These policies are ordered from most restrictive to least restrictive
+        let valid_policies = ["Restricted", "AllSigned", "RemoteSigned", "Unrestricted", "Bypass"];
+
+        // Find the index of our target policy
+        let target_idx = valid_policies.iter().position(|&p| p == policy);
+
+        let current_policy = self
+            .build_command_internal("Get-ExecutionPolicy")
+            .output_checked_utf8()
+            .map(|output| output.stdout.trim().to_string());
+
+        debug!("Found PowerShell ExecutionPolicy: {:?}", current_policy);
+
+        current_policy.is_ok_and(|current_policy| {
+            // Find the index of the current policy
+            let current_idx = valid_policies.iter().position(|&p| p == current_policy);
+
+            // Check if current policy exists and is at least as permissive as the target
+            match (current_idx, target_idx) {
+                (Some(current), Some(target)) => current >= target,
+                _ => false,
+            }
+        })
+    }
+
+    #[cfg(windows)]
+    pub fn has_module(&self, module_name: &str) -> bool {
+        let cmd = format!("Get-Module -ListAvailable {}", module_name);
+
+        self.build_command_internal(&cmd)
+            .output_checked()
+            .map(|output| !output.stdout.trim_ascii().is_empty())
             .unwrap_or(false)
     }
-
-    #[cfg(windows)]
-    pub fn windows_update(&self, ctx: &ExecutionContext) -> Result<()> {
-        let powershell = require_option(self.path.as_ref(), t!("Powershell is not installed").to_string())?;
-
-        debug_assert!(self.supports_windows_update());
-
-        let accept_all = if ctx.config().accept_all_windows_updates() {
-            "-AcceptAll"
-        } else {
-            ""
-        };
-
-        let install_windowsupdate_verbose = "Install-WindowsUpdate -Verbose".to_string();
-
-        let mut command = if let Some(sudo) = ctx.sudo() {
-            let mut command = ctx.run_type().execute(sudo);
-            command.arg(powershell);
-            command
-        } else {
-            ctx.run_type().execute(powershell)
-        };
-
-        command
-            .args(["-NoProfile", &install_windowsupdate_verbose, accept_all])
-            .status_checked()
-    }
-
-    #[cfg(windows)]
-    pub fn microsoft_store(&self, ctx: &ExecutionContext) -> Result<()> {
-        let powershell = require_option(self.path.as_ref(), t!("Powershell is not installed").to_string())?;
-
-        let mut command = if let Some(sudo) = ctx.sudo() {
-            let mut command = ctx.run_type().execute(sudo);
-            command.arg(powershell);
-            command
-        } else {
-            ctx.run_type().execute(powershell)
-        };
-
-        println!("{}", t!("Scanning for updates..."));
-
-        // Scan for updates using the MDM UpdateScanMethod
-        // This method is also available for non-MDM devices
-        let update_command = "(Get-CimInstance -Namespace \"Root\\cimv2\\mdm\\dmmap\" -ClassName \"MDM_EnterpriseModernAppManagement_AppManagement01\" | Invoke-CimMethod -MethodName UpdateScanMethod).ReturnValue";
-
-        command.args(["-NoProfile", update_command]);
-
-        command
-            .output_checked_with_utf8(|output| {
-                if output.stdout.trim() == "0" {
-                    println!(
-                        "{}",
-                        t!("Success, Microsoft Store apps are being updated in the background")
-                    );
-                    Ok(())
-                } else {
-                    println!(
-                        "{}",
-                        t!("Unable to update Microsoft Store apps, manual intervention is required")
-                    );
-                    Err(())
-                }
-            })
-            .map(|_| ())
-    }
 }

src/steps/remote/ssh.rs

@@ -35,7 +35,7 @@ pub fn ssh_step(ctx: &ExecutionContext, hostname: &str) -> Result<()> {
         unreachable!("Tmux execution is only implemented in Unix");
     } else if ctx.config().open_remotes_in_new_terminal() && !ctx.run_type().dry() && cfg!(windows) {
         prepare_async_ssh_command(&mut args);
-        ctx.run_type().execute("wt").args(&args).spawn()?;
+        ctx.execute("wt").args(&args).spawn()?;
         Err(SkipStep(String::from(t!("Remote Topgrade launched in an external terminal"))).into())
     } else {
         let mut args = vec!["-t", hostname];
@@ -50,6 +50,6 @@ pub fn ssh_step(ctx: &ExecutionContext, hostname: &str) -> Result<()> {
         print_separator(format!("Remote ({hostname})"));
         println!("{}", t!("Connecting to {hostname}...", hostname = hostname));
 
-        ctx.run_type().execute(ssh).args(&args).status_checked()
+        ctx.execute(ssh).args(&args).status_checked()
     }
 }

src/steps/remote/vagrant.rs

@@ -10,8 +10,9 @@ use tracing::{debug, error};
 
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::step::Step;
 use crate::terminal::print_separator;
-use crate::{error::SkipStep, utils, Step};
+use crate::{error::SkipStep, utils};
 
 #[derive(Debug, Copy, Clone, EnumString)]
 #[strum(serialize_all = "lowercase")]
@@ -113,8 +114,7 @@ impl<'a> TemporaryPowerOn<'a> {
             BoxStatus::Running => unreachable!(),
         };
 
-        ctx.run_type()
-            .execute(vagrant)
+        ctx.execute(vagrant)
             .args([subcommand, &vagrant_box.name])
             .current_dir(vagrant_box.path.clone())
             .status_checked()?;
@@ -140,7 +140,6 @@ impl Drop for TemporaryPowerOn<'_> {
 
         println!();
         self.ctx
-            .run_type()
             .execute(self.vagrant)
             .args([subcommand, &self.vagrant_box.name])
             .current_dir(self.vagrant_box.path.clone())
@@ -180,7 +179,7 @@ pub fn topgrade_vagrant_box(ctx: &ExecutionContext, vagrant_box: &VagrantBox) ->
         path: utils::require("vagrant")?,
     };
 
-    let seperator = format!("Vagrant ({})", vagrant_box.smart_name());
+    let separator = format!("Vagrant ({})", vagrant_box.smart_name());
     let mut _poweron = None;
     if !vagrant_box.initial_status.powered_on() {
         if !(ctx.config().vagrant_power_on().unwrap_or(true)) {
@@ -190,19 +189,18 @@ pub fn topgrade_vagrant_box(ctx: &ExecutionContext, vagrant_box: &VagrantBox) ->
             ))
             .into());
         } else {
-            print_separator(seperator);
+            print_separator(separator);
             _poweron = Some(vagrant.temporary_power_on(vagrant_box, ctx)?);
         }
     } else {
-        print_separator(seperator);
+        print_separator(separator);
     }
     let mut command = format!("env TOPGRADE_PREFIX={} topgrade", vagrant_box.smart_name());
     if ctx.config().yes(Step::Vagrant) {
         command.push_str(" -y");
     }
 
-    ctx.run_type()
-        .execute(&vagrant.path)
+    ctx.execute(&vagrant.path)
         .current_dir(&vagrant_box.path)
         .args(["ssh", "-c", &command])
         .status_checked()
@@ -222,7 +220,6 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
     for ele in re.captures_iter(&outdated.stdout) {
         found = true;
         let _ = ctx
-            .run_type()
             .execute(&vagrant)
             .args(["box", "update", "--box"])
             .arg(ele.get(1).unwrap().as_str())
@@ -234,10 +231,7 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
     if !found {
         println!("{}", t!("No outdated boxes"));
     } else {
-        ctx.run_type()
-            .execute(&vagrant)
-            .args(["box", "prune"])
-            .status_checked()?;
+        ctx.execute(&vagrant).args(["box", "prune"]).status_checked()?;
     }
 
     Ok(())

src/steps/tmux.rs

@@ -5,34 +5,50 @@ use std::process::Command;
 use color_eyre::eyre::eyre;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
+use etcetera::base_strategy::BaseStrategy;
 
 use crate::command::CommandExt;
 use crate::config::TmuxConfig;
 use crate::config::TmuxSessionMode;
 use crate::terminal::print_separator;
-use crate::HOME_DIR;
 use crate::{
     execution_context::ExecutionContext,
     utils::{which, PathExt},
 };
+use crate::{HOME_DIR, XDG_DIRS};
 
 use rust_i18n::t;
 #[cfg(unix)]
 use std::os::unix::process::CommandExt as _;
 
+// update_plugins path is relative to the TPM path
+const UPDATE_PLUGINS: &str = "bin/update_plugins";
+// Default TPM path relative to the TMux config directory
+const TPM_PATH: &str = "plugins/tpm";
+
 pub fn run_tpm(ctx: &ExecutionContext) -> Result<()> {
     let tpm = match env::var("TMUX_PLUGIN_MANAGER_PATH") {
-        // If `TMUX_PLUGIN_MANAGER_PATH` is set, search for
-        // `$TMUX_PLUGIN_MANAGER_PATH/bin/install_plugins/tpm/bin/update_plugins`
-        Ok(var) => PathBuf::from(var).join("bin/install_plugins/tpm/bin/update_plugins"),
-        // Otherwise, use the default location `~/.tmux/plugins/tpm/bin/update_plugins`
-        Err(_) => HOME_DIR.join(".tmux/plugins/tpm/bin/update_plugins"),
+        // Use `$TMUX_PLUGIN_MANAGER_PATH` if set,
+        Ok(var) => PathBuf::from(var).join(UPDATE_PLUGINS),
+        Err(_) => {
+            // otherwise, use the default XDG location `~/.config/tmux`
+            #[cfg(unix)]
+            let xdg_path = XDG_DIRS.config_dir().join("tmux").join(TPM_PATH).join(UPDATE_PLUGINS);
+            #[cfg(windows)]
+            let xdg_path = HOME_DIR.join(".config/tmux").join(TPM_PATH).join(UPDATE_PLUGINS);
+            if xdg_path.exists() {
+                xdg_path
+            } else {
+                // or fallback on the standard default location `~/.tmux`.
+                HOME_DIR.join(".tmux").join(TPM_PATH).join(UPDATE_PLUGINS)
+            }
+        }
     }
     .require()?;
 
     print_separator("tmux plugins");
 
-    ctx.run_type().execute(tpm).arg("all").status_checked()
+    ctx.execute(tpm).arg("all").status_checked()
 }
 
 struct Tmux {

src/steps/toolbx.rs

@@ -1,7 +1,7 @@
 use color_eyre::eyre::Result;
 
 use crate::command::CommandExt;
-use crate::config::Step;
+use crate::step::Step;
 use crate::terminal::print_separator;
 use crate::{execution_context::ExecutionContext, utils::require};
 use std::path::Path;
@@ -59,7 +59,7 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
             args.push("--yes");
         }
 
-        ctx.run_type().execute(&toolbx).args(&args).status_checked()?;
+        ctx.execute(&toolbx).args(&args).status_checked()?;
     }
 
     Ok(())

src/steps/vim.rs

@@ -29,15 +29,32 @@ pub fn vimrc() -> Result<PathBuf> {
 
 fn nvimrc() -> Result<PathBuf> {
     #[cfg(unix)]
-    let base_dir = crate::XDG_DIRS.config_dir();
+    let bases: Vec<PathBuf> = vec![crate::XDG_DIRS.config_dir()];
 
     #[cfg(windows)]
-    let base_dir = crate::WINDOWS_DIRS.cache_dir();
+    let mut bases: Vec<PathBuf> = vec![crate::WINDOWS_DIRS.cache_dir()];
 
-    base_dir
-        .join("nvim/init.vim")
-        .require()
-        .or_else(|_| base_dir.join("nvim/init.lua").require())
+    #[cfg(windows)]
+    {
+        if let Some(xdg) = std::env::var_os("XDG_CONFIG_HOME")
+            .map(PathBuf::from)
+            .filter(|path| path.is_absolute())
+        {
+            bases.insert(0, xdg);
+        }
+    }
+
+    for base_dir in bases {
+        if let Ok(p) = base_dir
+            .join("nvim/init.vim")
+            .require()
+            .or_else(|_| base_dir.join("nvim/init.lua").require())
+        {
+            return Ok(p);
+        }
+    }
+
+    Err(SkipStep(format!("{}", t!("No Neovim config found"))).into())
 }
 
 fn upgrade_script() -> Result<tempfile::NamedTempFile> {
@@ -80,23 +97,19 @@ pub fn upgrade_ultimate_vimrc(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator(t!("The Ultimate vimrc"));
 
-    ctx.run_type()
-        .execute(&git)
+    ctx.execute(&git)
         .current_dir(&config_dir)
         .args(["reset", "--hard"])
         .status_checked()?;
-    ctx.run_type()
-        .execute(&git)
+    ctx.execute(&git)
         .current_dir(&config_dir)
         .args(["clean", "-d", "--force"])
         .status_checked()?;
-    ctx.run_type()
-        .execute(&git)
+    ctx.execute(&git)
         .current_dir(&config_dir)
         .args(["pull", "--rebase"])
         .status_checked()?;
-    ctx.run_type()
-        .execute(python)
+    ctx.execute(python)
         .current_dir(config_dir)
         .arg(update_plugins)
         .status_checked()?;
@@ -116,8 +129,7 @@ pub fn upgrade_vim(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Vim");
     upgrade(
-        ctx.run_type()
-            .execute(&vim)
+        ctx.execute(&vim)
             .args(["-u"])
             .arg(vimrc)
             .args(["-U", "NONE", "-V1", "-nNesS"])
@@ -132,8 +144,7 @@ pub fn upgrade_neovim(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Neovim");
     upgrade(
-        ctx.run_type()
-            .execute(nvim)
+        ctx.execute(nvim)
             .args(["-u"])
             .arg(nvimrc)
             .args(["--headless", "-V1", "-nS"])
@@ -147,5 +158,5 @@ pub fn run_voom(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("voom");
 
-    ctx.run_type().execute(voom).arg("update").status_checked()
+    ctx.execute(voom).arg("update").status_checked()
 }

src/steps/zsh.rs

@@ -23,10 +23,7 @@ pub fn run_zr(ctx: &ExecutionContext) -> Result<()> {
     print_separator("zr");
 
     let cmd = format!("source {} && zr --update", zshrc().display());
-    ctx.run_type()
-        .execute(zsh)
-        .args(["-l", "-c", cmd.as_str()])
-        .status_checked()
+    ctx.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
 }
 
 fn zdotdir() -> PathBuf {
@@ -44,8 +41,7 @@ pub fn run_antidote(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("antidote");
 
-    ctx.run_type()
-        .execute(zsh)
+    ctx.execute(zsh)
         .arg("-c")
         .arg(format!("source {} && antidote update", antidote.display()))
         .status_checked()
@@ -57,7 +53,7 @@ pub fn run_antibody(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("antibody");
 
-    ctx.run_type().execute(antibody).arg("update").status_checked()
+    ctx.execute(antibody).arg("update").status_checked()
 }
 
 pub fn run_antigen(ctx: &ExecutionContext) -> Result<()> {
@@ -70,10 +66,7 @@ pub fn run_antigen(ctx: &ExecutionContext) -> Result<()> {
     print_separator("antigen");
 
     let cmd = format!("source {} && (antigen selfupdate ; antigen update)", zshrc.display());
-    ctx.run_type()
-        .execute(zsh)
-        .args(["-l", "-c", cmd.as_str()])
-        .status_checked()
+    ctx.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn run_zgenom(ctx: &ExecutionContext) -> Result<()> {
@@ -86,10 +79,7 @@ pub fn run_zgenom(ctx: &ExecutionContext) -> Result<()> {
     print_separator("zgenom");
 
     let cmd = format!("source {} && zgenom selfupdate && zgenom update", zshrc.display());
-    ctx.run_type()
-        .execute(zsh)
-        .args(["-l", "-c", cmd.as_str()])
-        .status_checked()
+    ctx.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn run_zplug(ctx: &ExecutionContext) -> Result<()> {
@@ -102,10 +92,7 @@ pub fn run_zplug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("zplug");
 
-    ctx.run_type()
-        .execute(zsh)
-        .args(["-i", "-c", "zplug update"])
-        .status_checked()
+    ctx.execute(zsh).args(["-i", "-c", "zplug update"]).status_checked()
 }
 
 pub fn run_zinit(ctx: &ExecutionContext) -> Result<()> {
@@ -119,10 +106,7 @@ pub fn run_zinit(ctx: &ExecutionContext) -> Result<()> {
     print_separator("zinit");
 
     let cmd = format!("source {} && zinit self-update && zinit update --all", zshrc.display());
-    ctx.run_type()
-        .execute(zsh)
-        .args(["-i", "-c", cmd.as_str()])
-        .status_checked()
+    ctx.execute(zsh).args(["-i", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn run_zi(ctx: &ExecutionContext) -> Result<()> {
@@ -134,7 +118,7 @@ pub fn run_zi(ctx: &ExecutionContext) -> Result<()> {
     print_separator("zi");
 
     let cmd = format!("source {} && zi self-update && zi update --all", zshrc.display());
-    ctx.run_type().execute(zsh).args(["-i", "-c", &cmd]).status_checked()
+    ctx.execute(zsh).args(["-i", "-c", &cmd]).status_checked()
 }
 
 pub fn run_zim(ctx: &ExecutionContext) -> Result<()> {
@@ -152,8 +136,7 @@ pub fn run_zim(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("zim");
 
-    ctx.run_type()
-        .execute(zsh)
+    ctx.execute(zsh)
         .args(["-i", "-c", "zimfw upgrade && zimfw update"])
         .status_checked()
 }
@@ -219,8 +202,7 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
     }
 
     custom_repos.remove(&oh_my_zsh);
-    ctx.run_type()
-        .execute("zsh")
+    ctx.execute("zsh")
         .arg(oh_my_zsh.join("tools/upgrade.sh"))
         // oh-my-zsh returns 80 when it is already updated and no changes pulled
         // in this update.

src/sudo.rs

@@ -2,12 +2,23 @@ use std::ffi::OsStr;
 use std::path::Path;
 use std::path::PathBuf;
 
+#[cfg(windows)]
+use color_eyre::eyre;
+#[cfg(windows)]
+use color_eyre::eyre::eyre;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
+use rust_i18n::t;
 use serde::Deserialize;
-use strum::AsRefStr;
+use strum::Display;
+use thiserror::Error;
+#[cfg(windows)]
+use tracing::{debug, warn};
+#[cfg(windows)]
+use windows::Win32::Foundation::ERROR_FILE_NOT_FOUND;
 
 use crate::command::CommandExt;
+use crate::error::UnsupportedSudo;
 use crate::execution_context::ExecutionContext;
 use crate::executor::Executor;
 use crate::terminal::print_separator;
@@ -16,41 +27,241 @@ use crate::utils::which;
 #[derive(Clone, Debug)]
 pub struct Sudo {
     /// The path to the `sudo` binary.
-    path: PathBuf,
+    path: Option<PathBuf>,
     /// The type of program being used as `sudo`.
     kind: SudoKind,
 }
 
-impl Sudo {
-    /// Get the `sudo` binary or the `gsudo` binary in the case of `gsudo`
-    /// masquerading as the `sudo` binary.
-    fn determine_sudo_variant(sudo_p: PathBuf) -> (PathBuf, SudoKind) {
-        match which("gsudo") {
-            Some(gsudo_p) => {
-                match std::fs::canonicalize(&gsudo_p).unwrap() == std::fs::canonicalize(&sudo_p).unwrap() {
-                    true => (gsudo_p, SudoKind::Gsudo),
-                    false => (sudo_p, SudoKind::Sudo),
-                }
+#[derive(Error, Debug)]
+pub enum SudoCreateError {
+    CannotFindBinary,
+    #[cfg(windows)]
+    WinSudoDisabled,
+    #[cfg(windows)]
+    WinSudoNewWindowMode,
+}
+
+impl std::fmt::Display for SudoCreateError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SudoCreateError::CannotFindBinary => {
+                write!(f, "{}", t!("Cannot find sudo binary"))
+            }
+            #[cfg(windows)]
+            SudoCreateError::WinSudoDisabled => {
+                write!(f, "{}", t!("Found Windows Sudo, but it is disabled"))
+            }
+            #[cfg(windows)]
+            SudoCreateError::WinSudoNewWindowMode => {
+                write!(
+                    f,
+                    "{}",
+                    t!("Found Windows Sudo, but it is using 'In a new window' mode")
+                )
             }
-            None => (sudo_p, SudoKind::Sudo),
         }
     }
+}
 
+#[derive(Clone, Debug, Default)]
+pub enum SudoPreserveEnv<'a> {
+    /// Preserve all environment variables.
+    All,
+    /// Preserve only the specified environment variables.
+    Some(&'a [&'a str]),
+    /// Preserve no environment variables.
+    #[default]
+    None,
+}
+
+/// Generic sudo options, translated into flags to pass to `sudo`.
+/// NOTE: Depending on the sudo kind, OS and system config, some options might be specified by
+/// default or unsupported.
+#[derive(Clone, Debug, Default)]
+pub struct SudoExecuteOpts<'a> {
+    /// Run the command inside a login shell.
+    pub login_shell: bool,
+    /// Preserve environment variables across the sudo call.
+    pub preserve_env: SudoPreserveEnv<'a>,
+    /// Set the HOME environment variable to the target user's home directory.
+    pub set_home: bool,
+    /// Run the command as a user other than the root user.
+    pub user: Option<&'a str>,
+}
+
+impl<'a> SudoExecuteOpts<'a> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Run the command inside a login shell.
+    #[allow(unused)]
+    pub fn login_shell(mut self) -> Self {
+        self.login_shell = true;
+        self
+    }
+
+    /// Preserve all environment variables across the sudo call.
+    #[allow(unused)]
+    pub fn preserve_env(mut self) -> Self {
+        self.preserve_env = SudoPreserveEnv::All;
+        self
+    }
+
+    /// Preserve only the specified environment variables across the sudo call.
+    #[allow(unused)]
+    pub fn preserve_env_list(mut self, vars: &'a [&'a str]) -> Self {
+        self.preserve_env = SudoPreserveEnv::Some(vars);
+        self
+    }
+
+    /// Set the HOME environment variable to the target user's home directory.
+    #[allow(unused)]
+    pub fn set_home(mut self) -> Self {
+        self.set_home = true;
+        self
+    }
+
+    /// Run the command as a user other than the root user.
+    #[allow(unused)]
+    pub fn user(mut self, user: &'a str) -> Self {
+        self.user = Some(user);
+        self
+    }
+}
+
+#[cfg(not(windows))]
+const DETECT_ORDER: [SudoKind; 5] = [
+    SudoKind::Doas,
+    SudoKind::Sudo,
+    SudoKind::Pkexec,
+    SudoKind::Run0,
+    SudoKind::Please,
+];
+
+// NOTE: keep WinSudo last, allows short-circuit error return in Sudo::detect() to work
+#[cfg(windows)]
+const DETECT_ORDER: [SudoKind; 2] = [SudoKind::Gsudo, SudoKind::WinSudo];
+
+impl Sudo {
     /// Get the `sudo` binary for this platform.
-    pub fn detect() -> Option<Self> {
-        which("doas")
-            .map(|p| (p, SudoKind::Doas))
-            .or_else(|| which("sudo").map(Self::determine_sudo_variant))
-            .or_else(|| which("gsudo").map(|p| (p, SudoKind::Gsudo)))
-            .or_else(|| which("pkexec").map(|p| (p, SudoKind::Pkexec)))
-            .or_else(|| which("run0").map(|p| (p, SudoKind::Run0)))
-            .or_else(|| which("please").map(|p| (p, SudoKind::Please)))
-            .map(|(path, kind)| Self { path, kind })
+    pub fn detect() -> Result<Self, SudoCreateError> {
+        use SudoCreateError::*;
+
+        for kind in DETECT_ORDER {
+            match Self::new(kind) {
+                Ok(sudo) => return Ok(sudo),
+                Err(CannotFindBinary) => continue,
+                #[cfg(windows)]
+                Err(e @ (WinSudoDisabled | WinSudoNewWindowMode)) => {
+                    // we can return directly here since WinSudo is detected last
+                    return Err(e);
+                }
+            }
+        }
+        Err(CannotFindBinary)
     }
 
     /// Create Sudo from SudoKind, if found in the system
-    pub fn new(kind: SudoKind) -> Option<Self> {
-        which(kind.as_ref()).map(|path| Self { path, kind })
+    pub fn new(kind: SudoKind) -> Result<Self, SudoCreateError> {
+        // no actual binary for null sudo
+        if let SudoKind::Null = kind {
+            return Ok(Self { path: None, kind });
+        }
+
+        match kind.which() {
+            Some(path) => {
+                let sudo = Self { path: Some(path), kind };
+
+                #[cfg(windows)]
+                if let SudoKind::WinSudo = kind {
+                    // Windows Sudo might be disabled, causing it to error on use.
+                    //
+                    // It checks two registry keys to determine its mode:
+                    // a "policy" (HLKM\SOFTWARE\Policies\Microsoft\Windows\Sudo\Enabled)
+                    // and a "setting" (HLKM\SOFTWARE\Microsoft\Windows\CurrentVersion\Sudo\Enabled).
+                    //
+                    // Both keys are u32's, with these meanings:
+                    // 0 - Disabled
+                    // 1 - ForceNewWindow
+                    // 2 - DisableInput
+                    // 3 - Normal
+                    //
+                    // Setting the sudo option in Settings changes the setting key, the policy key
+                    // sets an upper limit on the setting key: mode = min(policy, setting).
+                    // The default for the policy key is 3 (all modes allowed), and the default for
+                    // the setting key is 0 (disabled).
+                    //
+                    // See https://github.com/microsoft/sudo/blob/9f50d79704a9d4d468bc59f725993714762981ca/sudo/src/helpers.rs#L442
+
+                    #[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
+                    enum SudoMode {
+                        Disabled = 0,
+                        ForceNewWindow = 1,
+                        DisableInput = 2,
+                        Normal = 3,
+                    }
+
+                    impl TryFrom<u32> for SudoMode {
+                        type Error = eyre::Error;
+
+                        fn try_from(value: u32) -> Result<Self> {
+                            match value {
+                                0 => Ok(SudoMode::Disabled),
+                                1 => Ok(SudoMode::ForceNewWindow),
+                                2 => Ok(SudoMode::DisableInput),
+                                3 => Ok(SudoMode::Normal),
+                                _ => Err(eyre!("invalid integer SudoMode: {value}")),
+                            }
+                        }
+                    }
+
+                    fn get_mode(key: &str, on_missing: SudoMode) -> SudoMode {
+                        match windows_registry::LOCAL_MACHINE
+                            .open(key)
+                            .and_then(|k| k.get_u32("Enabled"))
+                        {
+                            Ok(v) => v.min(3).try_into().unwrap(),
+                            Err(e) if e.code() == ERROR_FILE_NOT_FOUND.to_hresult() => on_missing,
+                            Err(e) => {
+                                // warn, but treat as normal (using sudo should error)
+                                warn!(r"Error reading registry key HKLM\{key}\Enabled: {e}");
+                                SudoMode::Normal
+                            }
+                        }
+                    }
+
+                    // default to normal if key missing
+                    let policy_mode = get_mode(r"SOFTWARE\Policies\Microsoft\Windows\Sudo", SudoMode::Normal);
+                    debug!("Windows Sudo policy mode: {policy_mode:?}");
+                    // default to disabled if key missing
+                    let setting_mode = get_mode(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Sudo", SudoMode::Disabled);
+                    debug!("Windows Sudo setting mode: {setting_mode:?}");
+
+                    let sudo_mode = policy_mode.min(setting_mode);
+                    debug!("Windows Sudo mode: {sudo_mode:?}");
+
+                    if sudo_mode == SudoMode::Disabled {
+                        return Err(SudoCreateError::WinSudoDisabled);
+                    } else if sudo_mode == SudoMode::ForceNewWindow {
+                        return Err(SudoCreateError::WinSudoNewWindowMode);
+                    }
+                    // Normal mode is best, but DisableInput doesn't seem to cause issues
+                }
+
+                Ok(sudo)
+            }
+            None => Err(SudoCreateError::CannotFindBinary),
+        }
+    }
+
+    /// Gets the path to the `sudo` binary. Do not use this to execute `sudo` directly - either use
+    /// [`Sudo::elevate`], or if you need to specify arguments to `sudo`, use [`Sudo::elevate_opts`].
+    /// This way, sudo options can be specified generically and the actual arguments customized
+    /// depending on the sudo kind.
+    #[allow(unused)]
+    pub fn path(&self) -> Option<&Path> {
+        self.path.as_deref()
     }
 
     /// Elevate permissions with `sudo`.
@@ -60,8 +271,15 @@ impl Sudo {
     ///
     /// See: https://github.com/topgrade-rs/topgrade/issues/205
     pub fn elevate(&self, ctx: &ExecutionContext) -> Result<()> {
+        // skip if using null sudo
+        if let SudoKind::Null = self.kind {
+            return Ok(());
+        }
+
         print_separator("Sudo");
-        let mut cmd = ctx.run_type().execute(self);
+
+        // self.path is only None for null sudo, which we've handled above
+        let mut cmd = ctx.execute(self.path.as_deref().unwrap());
         match self.kind {
             SudoKind::Doas => {
                 // `doas` doesn't have anything like `sudo -v` to cache credentials,
@@ -79,12 +297,19 @@ impl Sudo {
                 //   command.  Not all security policies support cached credentials.
                 cmd.arg("-v");
             }
+            SudoKind::WinSudo => {
+                // Windows `sudo` doesn't cache credentials, so we just execute a
+                // dummy command - the easiest on Windows is `rem` in cmd.
+                // See: https://learn.microsoft.com/en-us/windows/advanced-settings/sudo/
+                cmd.args(["cmd.exe", "/c", "rem"]);
+            }
             SudoKind::Gsudo => {
                 // `gsudo` doesn't have anything like `sudo -v` to cache credentials,
-                // so we just execute a dummy `echo` command so we have something
-                // unobtrusive to run.
+                // so we just execute a dummy command - the easiest on Windows is
+                // `rem` in cmd. `-d` tells it to run the command directly, without
+                // going through a shell (which could be powershell) first.
                 // See: https://gerardog.github.io/gsudo/docs/usage
-                cmd.arg("echo");
+                cmd.args(["-d", "cmd.exe", "/c", "rem"]);
             }
             SudoKind::Pkexec => {
                 // I don't think this does anything; `pkexec` usually asks for
@@ -109,42 +334,233 @@ impl Sudo {
                 //   Warm the access token and exit.
                 cmd.arg("-w");
             }
+            SudoKind::Null => unreachable!(),
         }
         cmd.status_checked().wrap_err("Failed to elevate permissions")
     }
 
     /// Execute a command with `sudo`.
-    pub fn execute_elevated(&self, ctx: &ExecutionContext, command: &Path, interactive: bool) -> Executor {
-        let mut cmd = ctx.run_type().execute(self);
+    pub fn execute<S: AsRef<OsStr>>(&self, ctx: &ExecutionContext, command: S) -> Result<Executor> {
+        self.execute_opts(ctx, command, SudoExecuteOpts::new())
+    }
 
-        if let SudoKind::Sudo = self.kind {
-            cmd.arg("--preserve-env=DIFFPROG");
+    /// Execute a command with `sudo`, with custom options.
+    pub fn execute_opts<S: AsRef<OsStr>>(
+        &self,
+        ctx: &ExecutionContext,
+        command: S,
+        opts: SudoExecuteOpts,
+    ) -> Result<Executor> {
+        // null sudo is very different, do separately
+        if let SudoKind::Null = self.kind {
+            if opts.login_shell {
+                // TODO: emulate running in a login shell with su/runuser
+                return Err(UnsupportedSudo {
+                    sudo_kind: self.kind,
+                    option: "login_shell",
+                }
+                .into());
+            }
+            if opts.user.is_some() {
+                // TODO: emulate running as a different user with su/runuser
+                return Err(UnsupportedSudo {
+                    sudo_kind: self.kind,
+                    option: "user",
+                }
+                .into());
+            }
+
+            // NOTE: we ignore preserve_env and set_home, using
+            // no sudo effectively preserves these by default
+
+            // run command directly
+            return Ok(ctx.execute(command));
         }
 
-        if interactive {
-            cmd.arg("-i");
+        // self.path is only None for null sudo, which we've handled above
+        let mut cmd = ctx.execute(self.path.as_ref().unwrap());
+
+        if opts.login_shell {
+            match self.kind {
+                SudoKind::Sudo => {
+                    cmd.arg("-i");
+                }
+                SudoKind::Gsudo => {
+                    // By default, gsudo runs all commands inside a shell. If login_shell
+                    // is *not* specified, we add `-d` to run outside of a shell - see below.
+                }
+                SudoKind::Doas | SudoKind::WinSudo | SudoKind::Pkexec | SudoKind::Run0 | SudoKind::Please => {
+                    return Err(UnsupportedSudo {
+                        sudo_kind: self.kind,
+                        option: "login_shell",
+                    }
+                    .into());
+                }
+                SudoKind::Null => unreachable!(),
+            }
+        } else if let SudoKind::Gsudo = self.kind {
+            // The `-d` (direct) flag disables shell detection, running the command directly
+            // rather than through the current shell.
+            // Additionally, if the current shell is pwsh >= 7.3.0, then not including this
+            // gives errors if the command to run has spaces in it: see
+            // https://github.com/gerardog/gsudo/issues/297
+            cmd.arg("-d");
+        }
+
+        match opts.preserve_env {
+            SudoPreserveEnv::All => match self.kind {
+                SudoKind::Sudo => {
+                    cmd.arg("-E");
+                }
+                SudoKind::Gsudo => {
+                    cmd.arg("--copyEV");
+                }
+                SudoKind::Doas | SudoKind::WinSudo | SudoKind::Pkexec | SudoKind::Run0 | SudoKind::Please => {
+                    return Err(UnsupportedSudo {
+                        sudo_kind: self.kind,
+                        option: "preserve_env",
+                    }
+                    .into());
+                }
+                SudoKind::Null => unreachable!(),
+            },
+            SudoPreserveEnv::Some(vars) => match self.kind {
+                SudoKind::Sudo => {
+                    cmd.arg(format!("--preserve-env={}", vars.join(",")));
+                }
+                SudoKind::Run0 => {
+                    for env in vars {
+                        cmd.arg(format!("--setenv={}", env));
+                    }
+                }
+                SudoKind::Please => {
+                    cmd.arg("-a");
+                    cmd.arg(vars.join(","));
+                }
+                SudoKind::Doas | SudoKind::WinSudo | SudoKind::Gsudo | SudoKind::Pkexec => {
+                    return Err(UnsupportedSudo {
+                        sudo_kind: self.kind,
+                        option: "preserve_env_list",
+                    }
+                    .into());
+                }
+                SudoKind::Null => unreachable!(),
+            },
+            SudoPreserveEnv::None => {}
+        }
+
+        if opts.set_home {
+            match self.kind {
+                SudoKind::Sudo => {
+                    cmd.arg("-H");
+                }
+                SudoKind::Doas
+                | SudoKind::WinSudo
+                | SudoKind::Gsudo
+                | SudoKind::Pkexec
+                | SudoKind::Run0
+                | SudoKind::Please => {
+                    return Err(UnsupportedSudo {
+                        sudo_kind: self.kind,
+                        option: "set_home",
+                    }
+                    .into());
+                }
+                SudoKind::Null => unreachable!(),
+            }
+        }
+
+        if let Some(user) = opts.user {
+            match self.kind {
+                SudoKind::Sudo => {
+                    cmd.args(["-u", user]);
+                }
+                SudoKind::Doas | SudoKind::Gsudo | SudoKind::Run0 | SudoKind::Please => {
+                    cmd.args(["-u", user]);
+                }
+                SudoKind::Pkexec => {
+                    cmd.args(["--user", user]);
+                }
+                SudoKind::WinSudo => {
+                    // Windows sudo is the only one that doesn't have a `-u` flag
+                    return Err(UnsupportedSudo {
+                        sudo_kind: self.kind,
+                        option: "user",
+                    }
+                    .into());
+                }
+                SudoKind::Null => unreachable!(),
+            }
         }
 
         cmd.arg(command);
 
-        cmd
+        Ok(cmd)
     }
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, AsRefStr)]
+// On unix we use `SudoKind::Sudo`, and on windows `SudoKind::WinSudo`.
+// We always define both though, so that we don't have to put
+// #[cfg(...)] everywhere.
+
+#[derive(Clone, Copy, Debug, Display, Deserialize)]
 #[serde(rename_all = "lowercase")]
 #[strum(serialize_all = "lowercase")]
 pub enum SudoKind {
-    Doas,
+    // On unix, "sudo" in the config file means Sudo
+    #[cfg(not(windows))]
     Sudo,
+    // and WinSudo is skipped, making it unused.
+    #[cfg(not(windows))]
+    #[expect(unused, reason = "WinSudo is windows-only")]
+    #[serde(skip)]
+    WinSudo,
+
+    // On unix, Sudo is skipped and unused
+    #[cfg(windows)]
+    #[expect(unused, reason = "Sudo is unix-only")]
+    #[serde(skip)]
+    Sudo,
+    // and "sudo" in the config file means WinSudo.
+    #[cfg(windows)]
+    #[serde(rename = "sudo")]
+    WinSudo,
+
+    Doas,
     Gsudo,
     Pkexec,
     Run0,
     Please,
+    /// A "no-op" sudo, used when topgrade itself is running as root
+    Null,
 }
 
-impl AsRef<OsStr> for Sudo {
-    fn as_ref(&self) -> &OsStr {
-        self.path.as_ref()
+impl SudoKind {
+    /// Get the name of the "sudo" binary.
+    ///
+    /// For `SudoKind::WinSudo`, returns the full hardcoded path
+    /// instead to ensure we find Windows Sudo rather than gsudo
+    /// masquerading as sudo.
+    ///
+    /// Only returns `None` for `SudoKind::Null`.
+    fn binary_name(self) -> Option<&'static str> {
+        match self {
+            SudoKind::Doas => Some("doas"),
+            SudoKind::Sudo => Some("sudo"),
+            SudoKind::WinSudo => Some(r"C:\Windows\System32\sudo.exe"),
+            SudoKind::Gsudo => Some("gsudo"),
+            SudoKind::Pkexec => Some("pkexec"),
+            SudoKind::Run0 => Some("run0"),
+            SudoKind::Please => Some("please"),
+            SudoKind::Null => None,
+        }
+    }
+
+    /// Find the full path to the "sudo" binary, if it exists on the system.
+    fn which(self) -> Option<PathBuf> {
+        match self.binary_name() {
+            Some(name) => which(name),
+            None => None,
+        }
     }
 }

src/terminal.rs

@@ -2,14 +2,13 @@ use std::cmp::{max, min};
 use std::env;
 use std::io::{self, Write};
 use std::process::Command;
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 use std::time::Duration;
 
 use chrono::{Local, Timelike};
 use color_eyre::eyre;
 use color_eyre::eyre::Context;
 use console::{style, Key, Term};
-use lazy_static::lazy_static;
 use notify_rust::{Notification, Timeout};
 use rust_i18n::t;
 use tracing::{debug, error};
@@ -17,11 +16,9 @@ use tracing::{debug, error};
 use which_crate::which;
 
 use crate::command::CommandExt;
-use crate::report::StepResult;
+use crate::runner::StepResult;
 
-lazy_static! {
-    static ref TERMINAL: Mutex<Terminal> = Mutex::new(Terminal::new());
-}
+static TERMINAL: LazyLock<Mutex<Terminal>> = LazyLock::new(|| Mutex::new(Terminal::new()));
 
 #[cfg(unix)]
 pub fn shell() -> String {
@@ -176,6 +173,11 @@ impl Terminal {
                     StepResult::Success => format!("{}", style(t!("OK")).bold().green()),
                     StepResult::Failure => format!("{}", style(t!("FAILED")).bold().red()),
                     StepResult::Ignored => format!("{}", style(t!("IGNORED")).bold().yellow()),
+                    StepResult::SkippedMissingSudo => format!(
+                        "{}: {}",
+                        style(t!("SKIPPED")).bold().yellow(),
+                        t!("Could not find sudo")
+                    ),
                     StepResult::Skipped(reason) => format!("{}: {}", style(t!("SKIPPED")).bold().blue(), reason),
                 }
             ))

src/utils.rs

@@ -112,6 +112,29 @@ pub fn require<T: AsRef<OsStr> + Debug>(binary_name: T) -> Result<PathBuf> {
     }
 }
 
+pub fn require_one<T: AsRef<OsStr> + Debug>(binary_names: impl IntoIterator<Item = T>) -> Result<PathBuf> {
+    let mut failed_bins = Vec::new();
+    for bin in binary_names {
+        match require(&bin) {
+            Ok(path) => return Ok(path),
+            Err(_) => failed_bins.push(bin),
+        }
+    }
+
+    Err(SkipStep(format!(
+        "{}",
+        t!(
+            "Cannot find any of {binary_names} in PATH",
+            binary_names = failed_bins
+                .iter()
+                .map(|bin| format!("{:?}", bin))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    ))
+    .into())
+}
+
 #[allow(dead_code)]
 pub fn require_option<T>(option: Option<T>, cause: String) -> Result<T> {
     if let Some(value) = option {
@@ -128,7 +151,7 @@ pub fn string_prepend_str(string: &mut String, s: &str) {
     *string = new_string;
 }
 
-#[cfg(target_family = "unix")]
+#[cfg(unix)]
 pub fn hostname() -> Result<String> {
     match nix::unistd::gethostname() {
         Ok(os_str) => Ok(os_str
@@ -138,7 +161,7 @@ pub fn hostname() -> Result<String> {
     }
 }
 
-#[cfg(target_family = "windows")]
+#[cfg(windows)]
 pub fn hostname() -> Result<String> {
     Command::new("hostname")
         .output_checked_utf8()
@@ -146,6 +169,22 @@ pub fn hostname() -> Result<String> {
         .map(|output| output.stdout.trim().to_owned())
 }
 
+#[cfg(unix)]
+pub fn is_elevated() -> bool {
+    let euid = nix::unistd::Uid::effective();
+    debug!("Running with euid: {euid}");
+    euid.is_root()
+}
+
+#[cfg(windows)]
+pub fn is_elevated() -> bool {
+    let elevated = is_elevated::is_elevated();
+    if elevated {
+        debug!("Detected elevated process");
+    }
+    elevated
+}
+
 pub mod merge_strategies {
     use merge::Merge;
 
@@ -156,7 +195,7 @@ pub mod merge_strategies {
         if let Some(left_vec) = left {
             if let Some(mut right_vec) = right {
                 right_vec.append(left_vec);
-                let _ = std::mem::replace(left, Some(right_vec));
+                let _ = left.replace(right_vec);
             }
         } else {
             *left = right;
@@ -199,17 +238,11 @@ pub mod merge_strategies {
     }
 }
 
-// Skip causes
-// TODO: Put them in a better place when we have more of them
-pub fn get_require_sudo_string() -> String {
-    t!("Require sudo or counterpart but not found, skip").to_string()
-}
-
 /// Return `Err(SkipStep)` if `python` is a Python 2 or shim.
 ///
 /// # Shim
 /// On Windows, if you install `python` through `winget`, an actual `python`
-/// is installed as well as a `python3` shim. Shim is invokable, but when you
+/// is installed as well as a `python3` shim. Shim is invocable, but when you
 /// execute it, the Microsoft App Store will be launched instead of a Python
 /// shell.
 ///
@@ -282,3 +315,15 @@ pub fn install_color_eyre() -> Result<()> {
         .display_location_section(true)
         .install()
 }
+
+/// Macro to construct an error message for when the output of a command is unexpected.
+#[macro_export]
+macro_rules! output_changed_message {
+    ($command:expr, $message:expr) => {
+        format!(
+            "The output of `{}` changed: {}. This is not your fault, this is an issue in Topgrade. Please open an issue at: https://github.com/topgrade-rs/topgrade/issues/new?template=bug_report.md",
+            $command,
+            $message,
+        )
+    };
+}

translate.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+## Translate the given string into $langs using translate-shell, outputting to the yaml structure expected for locales/app.yml
+
+langs="en lt es fr zh_CN zh_TW de"
+
+printf "\"%s\":\n" "$@"
+for lang in $langs; do
+  result=$(trans -brief -no-auto -s en -t "${lang/_/-/}" "$@")
+  printf "  %s: \"%s\"\n" "$lang" "$result"
+done