chore: prepare for v15.0.0 (#843)

* feat: new step Lensfun's database update

* refactor: take 1 as a success exit code

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,32 +2,91 @@
 name: Bug report
 about: Topgrade is misbehaving
 title: ''
-labels: ''
+labels: 'C-bug'
 assignees: ''
 
 ---
 
-<!-- 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. -->
+<!--
+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!
 
-## What did you expect to happen?
-
-
-## What actually happened?
-
-
-## Additional Details
-- Which operating system or Linux distribution are you using?
-- How did you install Topgrade?
-- Which version are you running? <!-- Check with `topgrade -V` -->
+Questions labeled with `Optional` can be skipped.
+-->
 
 <!-- 
-Run `topgrade --dry-run` to see which commands Topgrade is running.
-If the command seems wrong and you know why please tell us so.
-If the command seems fine try to run it yourself and tell us if you got a different result from Topgrade.
+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
+- [ ] No
+
+## Did you run topgrade through `Remote Execution`
+
+- [ ] Yes
+- [ ] No
+
+If yes, does the issue still occur when you run topgrade directlly in your
+remote host
+
+- [ ] Yes
+- [ ] No
+
+## Configuration file (Optional)
+<!-- 
+Paste your configuration file inside the code block if you think this issue is 
+related to configuration.
+-->
+
+```toml
+
+```
+
+## Additional Details
+- Operation System/Version
+  <!-- For example, Fedora Linux 38 -->
+
+- Installation
+  <!-- 
+  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
 -->
 
 <details>
-<!-- Paste the output of the problematic command with `-v` into the pre-tags -->
 <pre>
 
 </pre>

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,16 +2,20 @@
 name: Feature request
 about: Can you please support...?
 title: ''
-labels: ''
+labels: 'C-feature request'
 assignees: ''
 
 ---
 
 ## I want to suggest a new step
-### Which tool is this about? Where is its repository?
-### Which operating systems are supported by this tool?
-### What should Topgrade do to figure out if the tool needs to be invoked?
-### Which exact commands should Topgrade run?
+
+* Which tool is this about? Where is its repository?
+* Which operating systems are supported by this tool?
+* What should Topgrade do to figure out if the tool needs to be invoked?
+* Which exact commands should Topgrade run?
+* Does it have a `--dry-run` option? i.e., print what should be done and exit
+* Does it need the user to confirm the execution? And does it provide a `--yes`
+  option to skip this step?
 
 ## I want to suggest some general feature
 Topgrade should...

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,12 +1,18 @@
-## Standards checklist:
+## What does this PR do
+
+
+## Standards checklist
 
 - [ ] The PR title is descriptive.
-- [ ] The code compiles (`cargo build`)
-- [ ] The code passes rustfmt (`cargo fmt`)
-- [ ] The code passes clippy (`cargo clippy`)
-- [ ] The code passes tests (`cargo test`)
+- [ ] I have read `CONTRIBUTING.md`
 - [ ] *Optional:* I have tested the code myself
-    - [ ] I also tested that Topgrade skips the step where needed
+ 
+## 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 
+  the underlying command
 
 If you developed a feature or a bug fix for someone else and you do not have the
 means to test it, please tag this person here.

.github/dependabot.yml

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,21 @@
+name: Check config file creation if not exists
+
+on:
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+
+jobs:
+  TestConfig:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - run: |
+          CONFIG_PATH=~/.config/topgrade.toml;
+          if [ -f "$CONFIG_PATH" ]; then rm $CONFIG_PATH; fi
+          cargo build; 
+          TOPGRADE_SKIP_BRKC_NOTIFY=true ./target/debug/topgrade --dry-run --only system;
+          stat $CONFIG_PATH;

.github/workflows/check_security_vulnerability.yml

@@ -0,0 +1,32 @@
+# 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: Check Security Vulnerability
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  lint:
+    name: DevSkim
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Run DevSkim scanner
+        uses: microsoft/DevSkim-Action@v1
+
+      - name: Upload DevSkim scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: devskim-results.sarif

.github/workflows/check_semver.yml

@@ -8,7 +8,7 @@ jobs:
   prepare:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2022-08-03

.github/workflows/ci.yml

@@ -7,17 +7,17 @@ on:
 name: CI
 
 env:
-  RUST_VER: '1.68.0'
+  RUST_VER: 'stable'
   CROSS_VER: '0.2.5'
   CARGO_NET_RETRY: 3
 
 jobs:
   fmt:
     name: Rustfmt
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@master
@@ -42,32 +42,36 @@ jobs:
           - target: x86_64-linux-android
             target_name: Android
             use_cross: true
-            os: ubuntu-20.04
+            os: ubuntu-latest
 
           - target: x86_64-unknown-freebsd
             target_name: FreeBSD
             use_cross: true
-            os: ubuntu-20.04
+            os: ubuntu-latest
 
           - target: x86_64-unknown-linux-gnu
             target_name: Linux
-            os: ubuntu-20.04
+            os: ubuntu-latest
 
           - target: x86_64-apple-darwin
-            target_name: macOS
-            os: macos-11
+            target_name: macOS-x86_64
+            os: macos-13
+
+          - target: aarch64-apple-darwin
+            target_name: macOS-aarch64
+            os: macos-latest
 
           - target: x86_64-unknown-netbsd
             target_name: NetBSD
             use_cross: true
-            os: ubuntu-20.04
+            os: ubuntu-latest
 
           - target: x86_64-pc-windows-msvc
             target_name: Windows
-            os: windows-2019
+            os: windows-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@master
@@ -84,8 +88,13 @@ jobs:
         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
 
-      - name: Run cargo check
+      - name: Run cargo/cross check
         run: ${{ matrix.use_cross == true && 'cross' || 'cargo' }} check --locked --target ${{ matrix.target }}
 
-      - name: Run cargo clippy
+      - name: Run cargo/cross clippy
         run: ${{ matrix.use_cross == true && 'cross' || 'cargo' }} 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 }} 

.github/workflows/create_release_assets.yml

@@ -13,40 +13,31 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [ ubuntu-latest, macos-latest, windows-latest ]
+        platform: [ ubuntu-latest, macos-latest, macos-13, windows-latest ]
     runs-on: ${{ matrix.platform }}
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+
+      - name: setup Rust
+        uses: dtolnay/rust-toolchain@stable
         with: 
-          toolchain: stable
-          profile: minimal
-          override: true
           components: rustfmt, clippy
-      - uses: actions-rs/cargo@v1.0.1
-        name: Check format
-        with:
-          command: fmt
-          args: --all -- --check
-      - uses: actions-rs/cargo@v1.0.1
-        name: Run clippy
-        with:
-          command: clippy
-          args: --all-targets --locked -- -D warnings
-      - uses: actions-rs/cargo@v1.0.1
-        name: Run clippy (All features)
-        with:
-          command: clippy
-          args: --all-targets --locked --all-features -- -D warnings
-      - uses: actions-rs/cargo@v1.0.1
-        name: Run tests
-        with:
-          command: test
-      - uses: actions-rs/cargo@v1.0.1
-        name: Build
-        with:
-          command: build
-          args: --release --all-features
+
+      - name: Check format
+        run: cargo fmt --all -- --check
+
+      - name: Run clippy
+        run: cargo clippy --all-targets --locked -- -D warnings
+
+      - name: Run clippy (All features)
+        run: cargo clippy --all-targets --locked --all-features -- -D warnings
+
+      - name: Run tests
+        run: cargo test
+
+      - name: Build in Release profile with all features enabled
+        run: cargo build --release --all-features
+
       - name: Rename Release (Unix)
         run: |
           cargo install default-target
@@ -59,6 +50,7 @@ jobs:
           ls .
         if: ${{ matrix.platform != 'windows-latest' }}
         shell: bash
+
       - name: Rename Release (Windows)
         run: |
           cargo install default-target
@@ -71,7 +63,8 @@ jobs:
           ls .
         if: ${{ matrix.platform == 'windows-latest' }}
         shell: bash
+
       - name: Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           files: assets/*

.github/workflows/create_release_assets_cross.yml

@@ -0,0 +1,68 @@
+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: setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with: 
+          components: rustfmt, clippy
+
+      - 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 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: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: assets/*

.github/workflows/release-cross.yml

@@ -1,70 +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@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          default: true
-          override: true
-          target: ${{ matrix.target }}
-          components: rustfmt, clippy
-      - uses: actions-rs/cargo@v1.0.1
-        name: Check format
-        with:
-          use-cross: true
-          command: fmt
-          args: --all -- --check
-      - uses: actions-rs/cargo@v1.0.1
-        name: Run clippy
-        with:
-          command: clippy
-          use-cross: true
-          args: --all-targets --locked --target ${{matrix.target}} -- -D warnings
-      - uses: actions-rs/cargo@v1.0.1
-        name: Run clippy (All features)
-        with:
-          command: clippy
-          use-cross: true
-          args:  --locked --all-features --target ${{matrix.target}} -- -D warnings
-      - uses: actions-rs/cargo@v1.0.1
-        name: Run tests
-        with:
-          command: test
-          use-cross: true
-          args: --target ${{matrix.target}}
-      - uses: actions-rs/cargo@v1.0.1
-        name: Build
-        with:
-          command: build
-          use-cross: true
-          args: --release --all-features --target ${{matrix.target}}
-      - name: Rename Release
-        run: |
-          mkdir 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: Release
-        uses: softprops/action-gh-release@v1
-        with:
-          files: assets/*

.github/workflows/release_to_crates_io.yml

@@ -4,7 +4,7 @@ on:
   #   types:
   #     - completed
   release:
-    types: [published, edited]
+    types: [published]
 
 name: Publish to crates.io on release
 
@@ -12,7 +12,7 @@ jobs:
   prepare:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
@@ -21,7 +21,7 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: katyo/publish-crates@v1
+      - uses: katyo/publish-crates@v2
         with:
           dry-run: true
           check-repo: ${{ github.event_name == 'push' }}

.github/workflows/release_to_homebrew.yml

@@ -19,7 +19,7 @@ jobs:
       uses: Homebrew/actions/setup-homebrew@master
     - name: Cache Homebrew Bundler RubyGems
       id: cache
-      uses: actions/cache@v1
+      uses: actions/cache@v4
       with:
         path: ${{ steps.set-up-homebrew.outputs.gems-path }}
         key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
@@ -29,7 +29,8 @@ jobs:
       if: steps.cache.outputs.cache-hit != 'true'
       run: brew install-bundler-gems
     - name: Bump formulae
-      uses: Homebrew/actions/bump-formulae@master
+      uses: Homebrew/actions/bump-packages@master
+      continue-on-error: true
       with:
         # Custom GitHub access token with only the 'public_repo' scope enabled
         token: ${{secrets.HOMEBREW_ACCESS_TOKEN}}

.github/workflows/release_to_pypi.yml

@@ -0,0 +1,99 @@
+name: Update PyPi
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, x86, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          sccache: 'true'
+          manylinux: auto
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: dist
+
+  macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    if: "startsWith(github.ref, 'refs/tags/')"
+    needs: [linux, windows, macos, sdist]
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels
+      - name: Publish to PyPI
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        with:
+          command: upload
+          args: --skip-existing *

.github/workflows/release_to_winget.yml

@@ -0,0 +1,13 @@
+name: Publish to WinGet
+on:
+  release:
+    types: [released]
+jobs:
+  publish:
+    runs-on: windows-latest
+    steps:
+      - uses: vedantmgoyal2009/winget-releaser@v2
+        with:
+          identifier: topgrade-rs.topgrade
+          max-versions-to-keep: 5 # keep only latest 5 versions
+          token: ${{ secrets.WINGET_TOKEN }}

.github/workflows/test.yaml

@@ -1,59 +0,0 @@
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-env:
-  CARGO_TERM_COLOR: always
-
-name: Test with Code Coverage
-
-jobs:
-  test:
-    name: Test
-    env:
-      PROJECT_NAME_UNDERSCORE: topgrade
-      CARGO_INCREMENTAL: 0
-      RUSTFLAGS: -Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort
-      RUSTDOCFLAGS: -Cpanic=abort
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-          override: true
-      - name: Cache dependencies
-        uses: actions/cache@v2
-        env:
-          cache-name: cache-dependencies
-        with:
-          path: |
-            ~/.cargo/.crates.toml
-            ~/.cargo/.crates2.json
-            ~/.cargo/bin
-            ~/.cargo/registry/index
-            ~/.cargo/registry/cache
-            target
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('Cargo.lock') }}
-      - name: Generate test result and coverage report
-        run: |
-          cargo install cargo2junit grcov;
-          cargo test $CARGO_OPTIONS -- -Z unstable-options --format json | cargo2junit > results.xml;
-          zip -0 ccov.zip `find . \( -name "$PROJECT_NAME_UNDERSCORE*.gc*" \) -print`;
-          grcov ccov.zip -s . -t lcov --llvm --ignore-not-existing --ignore "/*" --ignore "tests/*" -o lcov.info;
-      - name: Upload test results
-        uses: EnricoMi/publish-unit-test-result-action@v1
-        with:
-          check_name: Test Results
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          files: results.xml
-      - name: Upload to CodeCov
-        uses: codecov/codecov-action@v1
-        with:
-          # required for private repositories:
-          # token: ${{ secrets.CODECOV_TOKEN }}
-          files: ./lcov.info
-          fail_ci_if_error: true

.gitignore

@@ -1,4 +1,20 @@
+# JetBrains IDEs
+.idea/
 
-/target
+# Visual Studio
+.vs/
+
+# Visual Studio Code
+.vscode/
+
+# Generic build outputs
 /build
+
+# Specific for some languages like Rust
+/target
+
+# LLVM profiling output
+*.profraw
+
+# Backup files for any .rs files in the project
 **/*.rs.bk

.vscode/launch.json

@@ -1,38 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Topgrade",
-            "console": "integratedTerminal",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=topgrade-rs",
-                    "--package=topgrade-rs"
-                ],
-                "filter": {
-                    "name": "topgrade-rs",
-                    "kind": "bin"
-                }
-            },
-            "args": [
-                "--only",
-                "${input:step}",
-                "-v"
-            ],
-            "cwd": "${workspaceFolder}"
-        },
-    ],
-    "inputs": [
-        {
-            "type": "promptString",
-            "id": "step",
-            "description": "step name",
-        }
-    ]
-}

.vscode/tasks.json

@@ -1,14 +0,0 @@
-{
-	"version": "2.0.0",
-	"tasks": [
-		{
-			"type": "cargo",
-			"command": "clippy",
-			"problemMatcher": [
-				"$rustc"
-			],
-			"group": "test",
-			"label": "rust: cargo clippy"
-		}
-	]
-}

.vscode/topgrade.code-snippets

@@ -1,50 +0,0 @@
-{
-	// Place your topgrade workspace snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and 
-	// description. Add comma separated ids of the languages where the snippet is applicable in the scope field. If scope 
-	// is left empty or omitted, the snippet gets applied to all languages. The prefix is what is 
-	// used to trigger the snippet and the body will be expanded and inserted. Possible variables are: 
-	// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. 
-	// Placeholders with the same ids are connected.
-	// Example:
-	// "Print to console": {
-	// 	"scope": "javascript,typescript",
-	// 	"prefix": "log",
-	// 	"body": [
-	// 		"console.log('$1');",
-	// 		"$2"
-	// 	],
-	// 	"description": "Log output to console"
-	// }
-	"Skip Step": {
-		"scope": "rust",
-		"prefix": "skipstep",
-		"body": [
-			"return Err(SkipStep(format!(\"$1\")).into());"
-		]
-	},
-	"Step": {
-		"scope": "rust",
-		"prefix": "step",
-		"body": [
-			"pub fn $1(ctx: &ExecutionContext) -> Result<()> {",
-			"    $0",
-			"    Ok(())",
-			"}"
-		]
-	},
-	"Require Binary": {
-		"scope": "rust",
-		"prefix": "req",
-		"description": "Require a binary to be installed",
-		"body": [
-			"let ${1:binary} = require(\"${1:binary}\")?;"
-		]
-	},
-	"macos": {
-		"scope": "rust",
-		"prefix": "macos",
-		"body": [
-			"#[cfg(target_os = \"macos\")]"
-		]
-	}
-}

BREAKINGCHANGES.md

@@ -0,0 +1,9 @@
+# Git: Pull Repos
+
+1. The output of "Pulling <repository path>" has been moved behind the
+   --verbose flag / [misc] configuration block.
+
+# Configuration
+
+1. The `enable_winget` configuration entry in the `windows` section has been
+   removed because it will not cause any issues and will be enabled by default.

CONTRIBUTING.md

@@ -0,0 +1,152 @@
+## Contributing to `topgrade`
+
+Thank you for your interest in contributing to `topgrade`!
+We welcome and encourage contributions of all kinds, such as:
+
+1. Issue reports or feature requests
+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.
+
+## Adding a new `step`
+
+In `topgrade`'s term, package manager is called `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)
+
+   ```rust
+   pub enum Step {
+       // Existed steps
+       // ...
+
+       // Your new step here!
+       // You may want it to be sorted alphabetically because that looks great:)
+       Xxx,
+   }
+   ```
+
+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).
+
+   Then you implement the update function, and put it in the file where it belongs.
+
+   ```rust
+   pub fn run_xxx(ctx: &ExecutionContext) -> Result<()> {
+       // Check if this step is installed, if not, then this update will be skipped.
+       let xxx = require("xxx")?;
+
+       // Print the separator
+       print_separator("xxx");
+
+       // Invoke the new step to get things updated!
+       ctx.run_type()
+          .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)).
+
+   Update function would usually do 3 things:
+   1. Check if the step is installed
+   2. Output the Separator
+   3. Invoke the step
+
+   Still, this is sufficient for most tools, but you may need some extra stuff
+   with complicated `step`.
+
+3. Finally, invoke that update function in `main.rs`
+
+   ```rust
+   runner.execute(Step::Xxx, "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
+   like this:
+
+   ```
+   #[cfg(target_os = "linux")]
+   {
+       // Xxx is Linux-only
+       runner.execute(Step::Xxx, "xxx", || ItsModule::run_xxx(&ctx))?;
+   }
+   ```
+
+   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))
+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),
+and have some basic documentations guiding user how to use these options.
+
+## 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:
+
+```md
+1. The configuration location has been updated to x.
+
+2. The step x has been removed.
+
+3. ...
+```
+
+[bc_dev]: https://github.com/topgrade-rs/topgrade/blob/main/BREAKINGCHANGES_dev.md
+
+## Before you submit your PR
+
+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.
+
+## Some tips
+
+1. Locale
+
+   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:
+
+   ```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 `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

@@ -5,9 +5,9 @@ categories = ["os"]
 keywords = ["upgrade", "update"]
 license = "GPL-3.0"
 repository = "https://github.com/topgrade-rs/topgrade"
-version = "11.0.0"
+version = "15.0.0"
 authors = ["Roey Darwish Dror <roey.ghost@gmail.com>", "Thomas Schönauer <t.schoenauer@hgs-wt.at>"]
-exclude = ["doc/screenshot.gif"]
+exclude = ["doc/screenshot.gif", "BREAKINGCHANGES_dev.md"]
 edition = "2021"
 
 readme = "README.md"
@@ -22,34 +22,35 @@ path = "src/main.rs"
 [dependencies]
 home = "~0.5"
 etcetera = "~0.8"
-once_cell = "~1.17"
+once_cell = "~1.19"
 serde = { version = "~1.0", features = ["derive"] }
-toml = "0.5"
-which_crate = { version = "~4.1", package = "which" }
-shellexpand = "~2.1"
-clap = { version = "~3.1", features = ["cargo", "derive"] }
-clap_complete = "~3.1"
-clap_mangen = "~0.1"
-walkdir = "~2.3"
+toml = "0.8"
+which_crate = { version = "~6.0", package = "which" }
+shellexpand = "~3.1"
+clap = { version = "~4.5", features = ["cargo", "derive"] }
+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.24", features = ["derive"] }
+strum = { version = "~0.26", features = ["derive"] }
 thiserror = "~1.0"
-tempfile = "~3.2"
+tempfile = "~3.10"
 cfg-if = "~1.0"
-tokio = { version = "~1.18", features = ["process", "rt-multi-thread"] }
+tokio = { version = "~1.38", features = ["process", "rt-multi-thread"] }
 futures = "~0.3"
-regex = "~1.5"
+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"] }
-
-[target.'cfg(target_os = "macos")'.dependencies]
-notify-rust = "~4.5"
+merge = "~0.1"
+regex-split = "~0.1"
+notify-rust = "~4.11"
+wildmatch = "2.3.0"
 
 [package.metadata.generate-rpm]
 assets = [{ source = "target/release/topgrade", dest = "/usr/bin/topgrade" }]
@@ -61,13 +62,12 @@ git = "*"
 depends = "$auto,git"
 
 [target.'cfg(unix)'.dependencies]
-libc = "~0.2"
-nix = "~0.24"
-rust-ini = "~0.18"
-self_update_crate = { version = "~0.30", default-features = false, optional = true, package = "self_update", features = ["archive-tar", "compression-flate2", "rustls"] }
+nix = { version = "~0.29", features = ["hostname", "signal", "user"] }
+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.30", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
+self_update_crate = { version = "~0.40", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
 winapi = "~0.3"
 parselnk = "~0.1"
 

README.md

@@ -8,13 +8,9 @@
   <a href="https://aur.archlinux.org/packages/topgrade"><img alt="AUR" src="https://img.shields.io/aur/version/topgrade.svg"></a>
   <a href="https://formulae.brew.sh/formula/topgrade"><img alt="Homebrew" src="https://img.shields.io/homebrew/v/topgrade.svg"></a>
 
-  <img alt="Demo" src="doc/screenshot.gif" width="550px">
+  <img alt="Demo" src="doc/topgrade_demo.gif">
 </div>
 
-## Maintainers Wanted
-
-I currently have not enough time to maintain this project on the level required and which the project deserves. For this reason I'm asking the community to help supporting the project, to help and work on resolving issues and create new features. Thanks for all your help.
-
 
 ## Introduction
 
@@ -33,32 +29,48 @@ To remedy this, **Topgrade** detects which tools you use and runs the appropriat
 - 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: [Scoop](https://github.com/ScoopInstaller/Main/blob/master/bucket/topgrade.json)
+- Windows: [Scoop][scoop] or [Winget][winget]
+- PyPi: [pip](https://pypi.org/project/topgrade/)
+
+[scoop]: https://scoop.sh/#/apps?q=topgrade
+[winget]: https://winstall.app/apps/topgrade-rs.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.
 
-Topgrade requires Rust 1.60 or above.
+> Currently, Topgrade requires Rust 1.65 or above. In general, Topgrade tracks 
+> the latest stable toolchain.
 
 ## Usage
 
 Just run `topgrade`.
 
-Visit the documentation at [topgrade-rs.github.io](https://topgrade-rs.github.io/) for more information.
-
-> **Warning**
-> Work in Progress
-
 ## 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 
+it when updated to a major release.
+
+> Got a question? Feel free to open an issue or discussion!
+
 ### Configuration Path
 
-The configuration should be placed in the following paths depending on the operating system:
+#### `CONFIG_DIR` on each platform
+- **Windows**: `%APPDATA%`
+- **macOS** and **other Unix systems**: `${XDG_CONFIG_HOME:-~/.config}`
 
-- **Windows** - `%APPDATA%/topgrade.toml`
-- **macOS** and **other Unix systems** - `${XDG_CONFIG_HOME:-~/.config}/topgrade.toml`
+`topgrade` will look for the configuration file in the following places, in order of priority:
+
+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.
+
+On the first run(no configuration file exists), `topgrade` will create a configuration file at `CONFIG_DIR/topgrade.toml` for you.
 
 ### Custom Commands
 
@@ -92,8 +104,8 @@ Just fork the repository and start coding.
 
 ### Contribution Guidelines
 
-- Check if your code passes `cargo fmt` and `cargo clippy`.
-- Check if your code is self explanatory, if not it should be documented by comments.
+See [CONTRIBUTING.md](https://github.com/topgrade-rs/topgrade/blob/master/CONTRIBUTING.md)
+
 ## Roadmap
 
 - [ ] Add a proper testing framework to the code base.

RELEASE_PROCEDURE.md

@@ -0,0 +1,65 @@
+> 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.
+
+   1. bumps the version number.
+
+      > If there are breaking changes, the major version number should be increased.
+
+   2. Overwrite [`BREAKINGCHANGES`][breaking_changes] with 
+      [`BREAKINGCHANGES_dev`][breaking_changes_dev], and create a new dev file:
+
+      ```sh'
+      $ cd topgrade
+      $ cp BREAKINGCHANGES_dev.md BREAKINGCHANGES.md
+      $ touch BREAKINGCHANGES_dev.md
+      ```
+
+      [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
+
+
+
+
+

config.example.toml

@@ -1,5 +1,18 @@
-# Don't ask for confirmations
-#assume_yes = true
+# Include any additional configuration file(s)
+# [include] sections are processed in the order you write them
+# Files in $CONFIG_DIR/topgrade.d/ are automatically included before this file
+[include]
+# paths = ["/etc/topgrade.toml"]
+
+
+[misc]
+# 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)
+# pre_sudo = false
+
+# Sudo command to be used
+# sudo_command = "sudo"
 
 # Disable specific steps - same options as the command line flag
 # disable = ["system", "emacs"]
@@ -7,54 +20,158 @@
 # Ignore failures for these steps
 # ignore_failures = ["powershell"]
 
-# Run specific steps - same options as the command line flag
-#only = ["system", "emacs"]
-
-# Do not ask to retry failed steps (default: false)
-#no_retry = true
-
-# Sudo command to be used
-#sudo_command = "sudo"
-
-# Run `sudo -v` to cache credentials at the start of the run; this avoids a
-# blocking password prompt in the middle of a possibly-unattended run.
-#pre_sudo = false
-
-# Run inside tmux
-#run_in_tmux = true
-
 # List of remote machines with Topgrade installed on them
 # remote_topgrades = ["toothless", "pi", "parnas"]
 
-# Arguments to pass SSH when upgrading remote systems
-#ssh_arguments = "-o ConnectTimeout=2"
-
 # Path to Topgrade executable on remote machines
 # remote_topgrade_path = ".cargo/bin/topgrade"
 
+# Arguments to pass to SSH when upgrading remote systems
+# ssh_arguments = "-o ConnectTimeout=2"
+
 # Arguments to pass tmux when pulling Repositories
 # tmux_arguments = "-S /var/tmux.sock"
 
-# Do not set the terminal title
-#set_title = false
+# Do not set the terminal title (default: true)
+# set_title = true
 
-# Display the time in step titles
+# Display the time in step titles (default: true)
 # display_time = true
 
-# Cleanup temporary or old files
+# Don't ask for confirmations (no default value)
+# assume_yes = true
+
+# Do not ask to retry failed steps (default: false)
+# no_retry = true
+
+# Run inside tmux (default: false)
+# run_in_tmux = true
+
+# Cleanup temporary or old files (default: false)
 # cleanup = true
 
-# Skip sending a notification at the end of a run
+# Send a notification for every step (default: false)
+# notify_each_step = false
+
+# Skip sending a notification at the end of a run (default: false)
 # skip_notify = true
 
-# Skip the preamble displayed when topgrade is run
-#display_preamble = false
+# The Bash-it branch to update (default: "stable")
+# bashit_branch = "stable"
 
-# Whether to self update (this is ignored if the binary has been built without self update support, available also via setting the environment variable TOPGRADE_NO_SELF_UPGRADE)
+# Run specific steps - same options as the command line flag
+# only = ["system", "emacs"]
+
+# Whether to self update
+#
+# this will be ignored if the binary is built without self update support
+#
+# available also via setting the environment variable TOPGRADE_NO_SELF_UPGRADE)
 # no_self_update = true
 
+# Extra tracing filter directives
+# These are prepended to the `--log-filter` argument
+# See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives
+# log_filters = ["topgrade::command=debug", "warn"]
+
+
+# Commands to run before anything
+[pre_commands]
+# "Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
+
+
+# Commands to run after anything
+[post_commands]
+# "Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
+
+
+# Custom commands
+[commands]
+# "Python Environment" = "~/dev/.env/bin/pip install -i https://pypi.python.org/simple -U --upgrade-strategy eager jupyter"
+# "Custom command using interactive shell (unix)" = "-i vim_upgrade"
+
+
+[python]
+# enable_pip_review = true                         ###disabled by default
+# enable_pip_review_local = true                   ###disabled by default
+# enable_pipupgrade = true                         ###disabled by default
+# pipupgrade_arguments = "-y -u --pip-path pip"    ###disabled by default
+
+
+[composer]
+# self_update = true
+
+
+[brew]
+# For the BrewCask step
+# If `Repo Cask Upgrade` exists, then use the `-a` option.
+# Otherwise, use the `--greedy` option.
+# greedy_cask = true
+
+# For the BrewCask step
+# If `Repo Cask Upgrade` does not exist, then use the `--greedy_latest` option.
+# NOTE: the above entry `greedy_cask` contains this entry, though you can enable
+# both of them, they won't clash with each other.
+# greedy_latest = true
+
+# For the BrewFormula step
+# Execute `brew autoremove` after the step.
+# autoremove = true
+
+# For the BrewFormula step
+# Upgrade formulae built from the HEAD branch; `brew upgrade --fetch-HEAD`
+# fetch_head = true
+
+
+[linux]
+# Arch Package Manager to use.
+# Allowed values:
+#   autodetect, aura, garuda_update, pacman, pamac, paru, pikaur, trizen, yay
+# arch_package_manager = "pacman"
+
+# Arguments to pass yay (or paru) when updating packages
+# yay_arguments = "--nodevel"
+
+# Arguments to pass dnf when updating packages
+# dnf_arguments = "--refresh"
+
+# aura_aur_arguments = "-kx"
+
+# aura_pacman_arguments = ""
+# garuda_update_arguments = ""
+
+# show_arch_news = true
+
+# trizen_arguments = "--devel"
+
+# pikaur_arguments = ""
+
+# pamac_arguments = "--no-devel"
+
+# enable_tlmgr = true
+
+# emerge_sync_flags = "-q"
+
+# emerge_update_flags = "-uDNa --with-bdeps=y world"
+
+# redhat_distro_sync = false
+
+# suse_dup = false
+
+# rpm_ostree = false
+
+# nix_arguments = "--flake"
+
+# nix_env_arguments = "--prebuilt-only"
+
+# Extra Home Manager arguments
+# home_manager_arguments = ["--flake", "file"]
+
+
 [git]
+# How many repos to pull at max in parallel
 # max_concurrency = 5
+
 # Additional git repositories to pull
 # repos = [
 #     "~/src/*/",
@@ -67,52 +184,15 @@
 # Arguments to pass Git when pulling Repositories
 # arguments = "--rebase --autostash"
 
-[composer]
-#self_update = true
-
-# Commands to run before anything
-[pre_commands]
-#"Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
-
-# Custom commands
-[commands]
-#"Python Environment" = "~/dev/.env/bin/pip install -i https://pypi.python.org/simple -U --upgrade-strategy eager jupyter"
-#"Custom command using interactive shell (unix)" = "-i vim_upgrade"
-
-[brew]
-#greedy_cask = true
-#autoremove = true
-
-[linux]
-# Arch Package Manager to use. Allowed values: autodetect, aura, garuda_update, pacman, pamac, paru, pikaur, trizen, yay.
-#arch_package_manager = "pacman"
-# Arguments to pass yay (or paru) when updating packages
-#yay_arguments = "--nodevel"
-# Arguments to pass dnf when updating packages
-#dnf_arguments = "--refresh"
-#aura_aur_arguments = "-kx"
-#aura_pacman_arguments = ""
-#garuda_update_arguments = ""
-#show_arch_news = true
-#trizen_arguments = "--devel"
-#pikaur_arguments = ""
-#pamac_arguments = "--no-devel"
-#enable_tlmgr = true
-#emerge_sync_flags = "-q"
-#emerge_update_flags = "-uDNa --with-bdeps=y world"
-#redhat_distro_sync = false
-#rpm_ostree = false
-#nix_arguments = "--flake"
-
-[python]
-#enable_pip_review = true   ###disabled by default
-#enable_pipupgrade = true   ###disabled by default
 
 [windows]
 # Manually select Windows updates
 # accept_all_updates = false
+
 # open_remotes_in_new_terminal = true
+
 # wsl_update_pre_release = true
+
 # wsl_update_use_web_download = true
 
 # Causes Topgrade to rename itself during the run to allow package managers
@@ -120,18 +200,54 @@
 # manager such as Scoop or Cargo
 # self_rename = true
 
+
 [npm]
 # Use sudo if the NPM directory isn't owned by the current user
 # use_sudo = true
 
+
+[yarn]
+# Run `yarn global upgrade` with `sudo`
+# use_sudo = true
+
+
+[vim]
+# For `vim-plug`, execute `PlugUpdate!` instead of `PlugUpdate`
+# force_plug_update = true
+
+
 [firmware]
 # Offer to update firmware; if false just check for and display available updates
 # upgrade = true
 
+
+[vagrant]
+# Vagrant directories
+# directories = []
+
+# power on vagrant boxes if needed
+# power_on = true
+
+# Always suspend vagrant boxes instead of powering off
+# always_suspend = true
+
+
 [flatpak]
 # Use sudo for updating the system-wide installation
 # use_sudo = true
 
+
 [distrobox]
 # use_root = false
+
 # containers = ["archlinux-latest"]
+[containers]
+# Specify the containers to ignore while updating (Wildcard supported)
+# ignored_containers = ["ghcr.io/rancher-sandbox/rancher-desktop/rdx-proxy:latest", "docker.io*"]
+
+[lensfun]
+# If disabled, Topgrade invokes `lensfun‑update‑data` without root priviledge, 
+# 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)
+# use_sudo = false

pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "topgrade"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]
+
+
+[tool.maturin]
+bindings = "bin"

src/breaking_changes.rs

@@ -0,0 +1,167 @@
+//! Inform the users of the breaking changes introduced in this major release.
+//!
+//! Print the breaking changes and possibly a migration guide when:
+//!     1. The Topgrade being executed is a new major release
+//!     2. This is the first launch of that major release
+
+use crate::terminal::print_separator;
+#[cfg(windows)]
+use crate::WINDOWS_DIRS;
+#[cfg(unix)]
+use crate::XDG_DIRS;
+use color_eyre::eyre::Result;
+use etcetera::base_strategy::BaseStrategy;
+use std::{
+    env::var,
+    fs::{read_to_string, OpenOptions},
+    io::Write,
+    path::PathBuf,
+    str::FromStr,
+};
+
+/// Version string x.y.z
+static VERSION_STR: &str = env!("CARGO_PKG_VERSION");
+
+/// Version info
+#[derive(Debug)]
+pub(crate) struct Version {
+    _major: u64,
+    minor: u64,
+    patch: u64,
+}
+
+impl FromStr for Version {
+    type Err = std::convert::Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        const NOT_SEMVER: &str = "Topgrade version is not semantic";
+        const NOT_NUMBER: &str = "Topgrade version is not dot-separated numbers";
+
+        let mut iter = s.split('.').take(3);
+        let major = iter.next().expect(NOT_SEMVER).parse().expect(NOT_NUMBER);
+        let minor = iter.next().expect(NOT_SEMVER).parse().expect(NOT_NUMBER);
+        let patch = iter.next().expect(NOT_SEMVER).parse().expect(NOT_NUMBER);
+
+        // They cannot be all 0s
+        assert!(
+            !(major == 0 && minor == 0 && patch == 0),
+            "Version numbers can not be all 0s"
+        );
+
+        Ok(Self {
+            _major: major,
+            minor,
+            patch,
+        })
+    }
+}
+
+impl Version {
+    /// True if this version is a new major release.
+    pub(crate) fn is_new_major_release(&self) -> bool {
+        // We have already checked that they cannot all be zeros, so `self.major`
+        // is guaranteed to be non-zero.
+        self.minor == 0 && self.patch == 0
+    }
+}
+
+/// Topgrade's breaking changes
+///
+/// We store them in the compiled binary.
+pub(crate) static BREAKINGCHANGES: &str = include_str!("../BREAKINGCHANGES.md");
+
+/// Return platform's data directory.
+fn data_dir() -> PathBuf {
+    #[cfg(unix)]
+    return XDG_DIRS.data_dir();
+
+    #[cfg(windows)]
+    return WINDOWS_DIRS.data_dir();
+}
+
+/// Return Topgrade's keep file path.
+///
+/// keep file is a file under the data directory containing a major version
+/// number, it will be created on first run and is used to check if an execution
+/// of Topgrade is the first run of a major release, for more details, see
+/// `first_run_of_major_release()`.
+fn keep_file_path() -> PathBuf {
+    let keep_file = "topgrade_keep";
+    data_dir().join(keep_file)
+}
+
+/// If environment variable `TOPGRADE_SKIP_BRKC_NOTIFY` is set to `true`, then
+/// we won't notify the user of the breaking changes.
+pub(crate) fn should_skip() -> bool {
+    if let Ok(var) = var("TOPGRADE_SKIP_BRKC_NOTIFY") {
+        return var.as_str() == "true";
+    }
+
+    false
+}
+
+/// True if this is the first execution of a major release.
+pub(crate) fn first_run_of_major_release() -> Result<bool> {
+    let version = VERSION_STR.parse::<Version>().expect("should be a valid version");
+    let keep_file = keep_file_path();
+
+    // disable this lint here as the current code has better readability
+    #[allow(clippy::collapsible_if)]
+    if version.is_new_major_release() {
+        if !keep_file.exists() || read_to_string(&keep_file)? != VERSION_STR {
+            return Ok(true);
+        }
+    }
+
+    Ok(false)
+}
+
+/// Print breaking changes to the user.
+pub(crate) fn print_breaking_changes() {
+    let header = format!("Topgrade {VERSION_STR} Breaking Changes");
+    print_separator(header);
+    let contents = if BREAKINGCHANGES.is_empty() {
+        "No Breaking changes"
+    } else {
+        BREAKINGCHANGES
+    };
+    println!("{contents}\n");
+}
+
+/// This function will be ONLY executed when the user has confirmed the breaking
+/// changes, once confirmed, we write the keep file, which means the first run
+/// of this major release is finished.
+pub(crate) fn write_keep_file() -> Result<()> {
+    std::fs::create_dir_all(data_dir())?;
+    let keep_file = keep_file_path();
+
+    let mut file = OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(keep_file)?;
+    let _ = file.write(VERSION_STR.as_bytes())?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn is_new_major_release_works() {
+        let first_major_release: Version = "1.0.0".parse().unwrap();
+        let under_dev: Version = "0.1.0".parse().unwrap();
+
+        assert!(first_major_release.is_new_major_release());
+        assert!(!under_dev.is_new_major_release());
+    }
+
+    #[test]
+    #[should_panic(expected = "Version numbers can not be all 0s")]
+    fn invalid_version() {
+        let all_0 = "0.0.0";
+        all_0.parse::<Version>().unwrap();
+    }
+}

src/command.rs

@@ -10,6 +10,8 @@ use color_eyre::eyre::Context;
 
 use crate::error::TopgradeError;
 
+use tracing::debug;
+
 /// Like [`Output`], but UTF-8 decoded.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Utf8Output {
@@ -183,7 +185,7 @@ impl CommandExt for Command {
             let err = TopgradeError::ProcessFailedWithOutput(program, output.status, stderr.into_owned());
 
             let ret = Err(err).with_context(|| message);
-            tracing::debug!("Command failed: {ret:?}");
+            debug!("Command failed: {ret:?}");
             ret
         }
     }
@@ -203,7 +205,7 @@ impl CommandExt for Command {
             let (program, _) = get_program_and_args(self);
             let err = TopgradeError::ProcessFailed(program, status);
             let ret = Err(err).with_context(|| format!("Command failed: `{command}`"));
-            tracing::debug!("Command failed: {ret:?}");
+            debug!("Command failed: {ret:?}");
             ret
         }
     }
@@ -239,6 +241,6 @@ fn format_program_and_args(cmd: &Command) -> String {
 
 fn log(cmd: &Command) -> String {
     let command = format_program_and_args(cmd);
-    tracing::debug!("Executing command `{command}`");
+    debug!("Executing command `{command}`");
     command
 }

src/ctrlc/unix.rs

@@ -1,6 +1,6 @@
 //! SIGINT handling in Unix systems.
 use crate::ctrlc::interrupted::set_interrupted;
-use nix::sys::signal;
+use nix::sys::signal::{sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal};
 
 /// Handle SIGINT. Set the interruption flag.
 extern "C" fn handle_sigint(_: i32) {
@@ -10,12 +10,8 @@ extern "C" fn handle_sigint(_: i32) {
 /// Set the necessary signal handlers.
 /// The function panics on failure.
 pub fn set_handler() {
-    let sig_action = signal::SigAction::new(
-        signal::SigHandler::Handler(handle_sigint),
-        signal::SaFlags::empty(),
-        signal::SigSet::empty(),
-    );
+    let sig_action = SigAction::new(SigHandler::Handler(handle_sigint), SaFlags::empty(), SigSet::empty());
     unsafe {
-        signal::sigaction(signal::SIGINT, &sig_action).unwrap();
+        sigaction(Signal::SIGINT, &sig_action).unwrap();
     }
 }

src/ctrlc/windows.rs

@@ -1,5 +1,6 @@
 //! 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;
@@ -16,6 +17,6 @@ extern "system" fn handler(ctrl_type: DWORD) -> BOOL {
 
 pub fn set_handler() {
     if 0 == unsafe { SetConsoleCtrlHandler(Some(handler), TRUE) } {
-        tracing::error!("Cannot set a control C handler")
+        error!("Cannot set a control C handler")
     }
 }

src/error.rs

@@ -10,14 +10,14 @@ pub enum TopgradeError {
     #[error("`{0}` failed: {1}")]
     ProcessFailedWithOutput(String, ExitStatus, String),
 
-    #[error("Sudo is required for this step")]
-    #[allow(dead_code)]
-    SudoRequired,
-
     #[error("Unknown Linux Distribution")]
     #[cfg(target_os = "linux")]
     UnknownLinuxDistribution,
 
+    #[error("File \"/etc/os-release\" does not exist or is empty")]
+    #[cfg(target_os = "linux")]
+    EmptyOSReleaseFile,
+
     #[error("Failed getting the system package manager")]
     #[cfg(target_os = "linux")]
     FailedGettingPackageManager,

src/execution_context.rs

@@ -1,37 +1,39 @@
 #![allow(dead_code)]
 use crate::executor::RunType;
-use crate::git::Git;
 use crate::sudo::Sudo;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::{config::Config, executor::Executor};
 use color_eyre::eyre::Result;
+use std::env::var;
 use std::path::Path;
 use std::sync::Mutex;
 
 pub struct ExecutionContext<'a> {
     run_type: RunType,
     sudo: Option<Sudo>,
-    git: &'a Git,
     config: &'a Config,
     /// Name of a tmux session to execute commands in, if any.
     /// This is used in `./steps/remote/ssh.rs`, where we want to run `topgrade` in a new
     /// tmux window for each remote.
     tmux_session: Mutex<Option<String>>,
+    /// True if topgrade is running under ssh.
+    under_ssh: bool,
 }
 
 impl<'a> ExecutionContext<'a> {
-    pub fn new(run_type: RunType, sudo: Option<Sudo>, git: &'a Git, config: &'a Config) -> Self {
+    pub fn new(run_type: RunType, sudo: Option<Sudo>, config: &'a Config) -> Self {
+        let under_ssh = var("SSH_CLIENT").is_ok() || var("SSH_TTY").is_ok();
         Self {
             run_type,
             sudo,
-            git,
             config,
             tmux_session: Mutex::new(None),
+            under_ssh,
         }
     }
 
     pub fn execute_elevated(&self, command: &Path, interactive: bool) -> Result<Executor> {
-        let sudo = require_option(self.sudo.clone(), "Sudo is required for this operation".into())?;
+        let sudo = require_option(self.sudo.as_ref(), REQUIRE_SUDO.to_string())?;
         Ok(sudo.execute_elevated(self, command, interactive))
     }
 
@@ -39,10 +41,6 @@ impl<'a> ExecutionContext<'a> {
         self.run_type
     }
 
-    pub fn git(&self) -> &Git {
-        self.git
-    }
-
     pub fn sudo(&self) -> &Option<Sudo> {
         &self.sudo
     }
@@ -51,6 +49,10 @@ impl<'a> ExecutionContext<'a> {
         self.config
     }
 
+    pub fn under_ssh(&self) -> bool {
+        self.under_ssh
+    }
+
     pub fn set_tmux_session(&self, session_name: String) {
         self.tmux_session.lock().unwrap().replace(session_name);
     }

src/executor.rs

@@ -3,7 +3,6 @@ use std::ffi::{OsStr, OsString};
 use std::path::Path;
 use std::process::{Child, Command, ExitStatus, Output};
 
-use color_eyre::eyre;
 use color_eyre::eyre::Result;
 use tracing::debug;
 
@@ -228,6 +227,7 @@ impl DryCommand {
 
 /// The Result of spawn. Contains an actual `std::process::Child` if executed by a wet command.
 pub enum ExecutorChild {
+    #[allow(unused)] // this type has not been used
     Wet(Child),
     Dry,
 }
@@ -238,7 +238,7 @@ impl CommandExt for Executor {
     // TODO: It might be nice to make `output_checked_with` return something that has a
     // variant for wet/dry runs.
 
-    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> eyre::Result<Output> {
+    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> Result<Output> {
         match self {
             Executor::Wet(c) => c.output_checked_with(succeeded),
             Executor::Dry(c) => {
@@ -248,7 +248,7 @@ impl CommandExt for Executor {
         }
     }
 
-    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> eyre::Result<()> {
+    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> Result<()> {
         match self {
             Executor::Wet(c) => c.status_checked_with(succeeded),
             Executor::Dry(c) => {
@@ -258,7 +258,7 @@ impl CommandExt for Executor {
         }
     }
 
-    fn spawn_checked(&mut self) -> eyre::Result<Self::Child> {
+    fn spawn_checked(&mut self) -> Result<Self::Child> {
         self.spawn()
     }
 }

src/main.rs

@@ -6,14 +6,17 @@ use std::path::PathBuf;
 use std::process::exit;
 use std::time::Duration;
 
+use crate::breaking_changes::{first_run_of_major_release, print_breaking_changes, should_skip, write_keep_file};
 use clap::CommandFactory;
 use clap::{crate_version, Parser};
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
 use console::Key;
+use etcetera::base_strategy::BaseStrategy;
 #[cfg(windows)]
 use etcetera::base_strategy::Windows;
-use etcetera::base_strategy::{BaseStrategy, Xdg};
+#[cfg(unix)]
+use etcetera::base_strategy::Xdg;
 use once_cell::sync::Lazy;
 use tracing::debug;
 
@@ -24,6 +27,9 @@ use self::error::Upgraded;
 use self::steps::{remote::*, *};
 use self::terminal::*;
 
+use self::utils::{hostname, install_color_eyre, install_tracing, update_tracing};
+
+mod breaking_changes;
 mod command;
 mod config;
 mod ctrlc;
@@ -41,31 +47,43 @@ mod sudo;
 mod terminal;
 mod utils;
 
-pub static HOME_DIR: Lazy<PathBuf> = Lazy::new(|| home::home_dir().expect("No home directory"));
-pub static XDG_DIRS: Lazy<Xdg> = Lazy::new(|| Xdg::new().expect("No home directory"));
+pub(crate) static HOME_DIR: Lazy<PathBuf> = Lazy::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"));
+
 #[cfg(windows)]
-pub static WINDOWS_DIRS: Lazy<Windows> = Lazy::new(|| Windows::new().expect("No home directory"));
+pub(crate) static WINDOWS_DIRS: Lazy<Windows> = Lazy::new(|| Windows::new().expect("No home directory"));
 
 fn run() -> Result<()> {
-    color_eyre::install()?;
+    install_color_eyre()?;
     ctrlc::set_handler();
 
     let opt = CommandLineArgs::parse();
+    // Set up the logger with the filter directives from:
+    //     1. CLI option `--log-filter`
+    //     2. `debug` if the `--verbose` option is present
+    // We do this because we need our logger to work while loading the
+    // configuration file.
+    //
+    // When the configuration file is loaded, update the logger with the full
+    // filter directives.
+    //
+    // For more info, see the comments in `CommandLineArgs::tracing_filter_directives()`
+    // and `Config::tracing_filter_directives()`.
+    let reload_handle = install_tracing(&opt.tracing_filter_directives())?;
 
     if let Some(shell) = opt.gen_completion {
         let cmd = &mut CommandLineArgs::command();
-        clap_complete::generate(shell, cmd, clap::crate_name!(), &mut std::io::stdout());
+        clap_complete::generate(shell, cmd, clap::crate_name!(), &mut io::stdout());
         return Ok(());
     }
 
     if opt.gen_manpage {
         let man = clap_mangen::Man::new(CommandLineArgs::command());
-        man.render(&mut std::io::stdout())?;
+        man.render(&mut io::stdout())?;
         return Ok(());
     }
 
-    install_tracing(&opt.tracing_filter_directives())?;
-
     for env in opt.env_variables() {
         let mut splitted = env.split('=');
         let var = splitted.next().unwrap();
@@ -79,30 +97,23 @@ fn run() -> Result<()> {
     };
 
     if opt.show_config_reference() {
-        print!("{}", crate::config::EXAMPLE_CONFIG);
+        print!("{}", config::EXAMPLE_CONFIG);
         return Ok(());
     }
 
     let config = Config::load(opt)?;
-    terminal::set_title(config.set_title());
-    terminal::display_time(config.display_time());
-    terminal::set_desktop_notifications(config.notify_each_step());
+    // Update the logger with the full filter directives.
+    update_tracing(&reload_handle, &config.tracing_filter_directives())?;
+    set_title(config.set_title());
+    display_time(config.display_time());
+    set_desktop_notifications(config.notify_each_step());
 
     debug!("Version: {}", crate_version!());
     debug!("OS: {}", env!("TARGET"));
     debug!("{:?}", std::env::args());
     debug!("Binary path: {:?}", std::env::current_exe());
-    debug!("Self Update: {:?}", cfg!(feature = "self-update"));
-
-    #[cfg(target_os = "linux")]
-    {
-        if config.display_preamble() && terminal::supports_notify_send() && !config.skip_notify() {
-            print_warning("Due to a design issue with notify-send it could be that topgrade hangs when it's finished.
-If this is the case on your system add the --skip-notify flag to the topgrade command or set skip_notify = true in the config file.
-If you don't want this message to appear any longer set display_preamble = false in the config file.
-For more information about this issue see https://askubuntu.com/questions/110969/notify-send-ignores-timeout and https://github.com/topgrade-rs/topgrade/issues/288.");
-        }
-    }
+    debug!("self-update Feature Enabled: {:?}", cfg!(feature = "self-update"));
+    debug!("Configuration: {:?}", config);
 
     if config.run_in_tmux() && env::var("TOPGRADE_INSIDE_TMUX").is_err() {
         #[cfg(unix)]
@@ -112,32 +123,42 @@ For more information about this issue see https://askubuntu.com/questions/110969
         }
     }
 
-    let git = git::Git::new();
-    let mut git_repos = git::Repositories::new(&git);
+    let powershell = powershell::Powershell::new();
+    let should_run_powershell = powershell.profile().is_some() && config.should_run(Step::Powershell);
+    let emacs = emacs::Emacs::new();
+    #[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, &git, &config);
-
+    let ctx = execution_context::ExecutionContext::new(run_type, sudo, &config);
     let mut runner = runner::Runner::new(&ctx);
 
+    // If
+    //
+    // 1. the breaking changes notification shouldnot 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?")? {
+            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 config_self_upgrade = env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !config.no_self_update();
+        let should_self_update = env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !config.no_self_update();
 
-        if !run_type.dry() && config_self_upgrade {
-            let result = self_update::self_update();
-
-            if let Err(e) = &result {
-                #[cfg(windows)]
-                {
-                    if e.downcast_ref::<Upgraded>().is_some() {
-                        return result;
-                    }
-                }
-                print_warning(format!("Self update error: {e}"));
-            }
+        if should_self_update {
+            runner.execute(Step::SelfUpdate, "Self Update", || self_update::self_update(&ctx))?;
         }
     }
 
@@ -160,28 +181,30 @@ For more information about this issue see https://askubuntu.com/questions/110969
         }
     }
 
-    let powershell = powershell::Powershell::new();
-    let should_run_powershell = powershell.profile().is_some() && config.should_run(Step::Powershell);
-
-    #[cfg(windows)]
-    runner.execute(Step::Wsl, "WSL", || windows::run_wsl_topgrade(&ctx))?;
-
-    #[cfg(windows)]
-    runner.execute(Step::WslUpdate, "WSL", || windows::update_wsl(&ctx))?;
-
     if let Some(topgrades) = config.remote_topgrades() {
-        for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(t)) {
+        for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(hostname(), t)) {
             runner.execute(Step::Remotes, format!("Remote ({remote_topgrade})"), || {
-                remote::ssh::ssh_step(&ctx, remote_topgrade)
+                ssh::ssh_step(&ctx, remote_topgrade)
             })?;
         }
     }
 
-    #[cfg(target_os = "linux")]
-    let distribution = linux::Distribution::detect();
-
-    #[cfg(target_os = r#"linux"#)]
+    #[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))?;
+    }
+
+    #[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))?;
@@ -192,16 +215,27 @@ For more information about this issue see https://askubuntu.com/questions/110969
         }
         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)
         })?;
-    }
-
-    #[cfg(windows)]
-    {
-        runner.execute(Step::Chocolatey, "Chocolatey", || windows::run_chocolatey(&ctx))?;
-        runner.execute(Step::Scoop, "Scoop", || windows::run_scoop(config.cleanup(), run_type))?;
-        runner.execute(Step::Winget, "Winget", || windows::run_winget(&ctx))?;
+        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))?;
     }
 
     #[cfg(target_os = "macos")]
@@ -225,132 +259,77 @@ For more information about this issue see https://askubuntu.com/questions/110969
             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(run_type))?;
-        runner.execute(Step::Asdf, "asdf", || unix::run_asdf(run_type))?;
+        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::Bun, "bun", || unix::run_bun(&ctx))?;
-    }
-
-    #[cfg(target_os = "dragonfly")]
-    runner.execute(Step::Pkg, "DragonFly BSD Packages", || {
-        dragonfly::upgrade_packages(ctx.sudo().as_ref(), run_type)
-    })?;
-
-    #[cfg(target_os = "freebsd")]
-    runner.execute(Step::Pkg, "FreeBSD Packages", || {
-        freebsd::upgrade_packages(&ctx, ctx.sudo().as_ref(), run_type)
-    })?;
-
-    #[cfg(target_os = "openbsd")]
-    runner.execute(Step::Pkg, "OpenBSD Packages", || {
-        openbsd::upgrade_packages(ctx.sudo().as_ref(), run_type)
-    })?;
-
-    #[cfg(target_os = "android")]
-    runner.execute(Step::Pkg, "Termux Packages", || android::upgrade_packages(&ctx))?;
-
-    let emacs = emacs::Emacs::new();
-    if config.use_predefined_git_repos() {
-        if config.should_run(Step::Emacs) {
-            if !emacs.is_doom() {
-                if let Some(directory) = emacs.directory() {
-                    git_repos.insert_if_repo(directory);
-                }
-            }
-            git_repos.insert_if_repo(HOME_DIR.join(".doom.d"));
-        }
-
-        if config.should_run(Step::Vim) {
-            git_repos.insert_if_repo(HOME_DIR.join(".vim"));
-            git_repos.insert_if_repo(HOME_DIR.join(".config/nvim"));
-        }
-
-        git_repos.insert_if_repo(HOME_DIR.join(".ideavimrc"));
-        git_repos.insert_if_repo(HOME_DIR.join(".intellimacs"));
-
-        if config.should_run(Step::Rcm) {
-            git_repos.insert_if_repo(HOME_DIR.join(".dotfiles"));
-        }
-
-        #[cfg(unix)]
-        {
-            git_repos.insert_if_repo(zsh::zshrc());
-            if config.should_run(Step::Tmux) {
-                git_repos.insert_if_repo(HOME_DIR.join(".tmux"));
-            }
-            git_repos.insert_if_repo(HOME_DIR.join(".config/fish"));
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("openbox"));
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("bspwm"));
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("i3"));
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("sway"));
-        }
-
-        #[cfg(windows)]
-        git_repos.insert_if_repo(
-            WINDOWS_DIRS
-                .cache_dir()
-                .join("Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState"),
-        );
-
-        #[cfg(windows)]
-        windows::insert_startup_scripts(&mut git_repos).ok();
-
-        if let Some(profile) = powershell.profile() {
-            git_repos.insert_if_repo(profile);
-        }
-    }
-
-    if config.should_run(Step::GitRepos) {
-        if let Some(custom_git_repos) = config.git_repos() {
-            for git_repo in custom_git_repos {
-                git_repos.glob_insert(git_repo);
-            }
-        }
-        runner.execute(Step::GitRepos, "Git repositories", || {
-            git.multi_pull_step(&git_repos, &ctx)
-        })?;
-    }
-
-    if should_run_powershell {
-        runner.execute(Step::Powershell, "Powershell Modules Update", || {
-            powershell.update_modules(&ctx)
-        })?;
-    }
-
-    #[cfg(unix)]
-    {
-        runner.execute(Step::Shell, "zr", || zsh::run_zr(run_type))?;
-        runner.execute(Step::Shell, "antibody", || zsh::run_antibody(run_type))?;
+        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(run_type))?;
-        runner.execute(Step::Shell, "zgenom", || zsh::run_zgenom(run_type))?;
-        runner.execute(Step::Shell, "zplug", || zsh::run_zplug(run_type))?;
-        runner.execute(Step::Shell, "zinit", || zsh::run_zinit(run_type))?;
-        runner.execute(Step::Shell, "zi", || zsh::run_zi(run_type))?;
-        runner.execute(Step::Shell, "zim", || zsh::run_zim(run_type))?;
+        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, "fisher", || unix::run_fisher(run_type))?;
+        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(run_type))?;
-        runner.execute(Step::Tldr, "TLDR", || unix::run_tldr(run_type))?;
-        runner.execute(Step::Pearl, "pearl", || unix::run_pearl(run_type))?;
+        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::Sdkman, "SDKMAN!", || unix::run_sdkman(config.cleanup(), run_type))?;
+        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(
@@ -359,35 +338,48 @@ For more information about this issue see https://askubuntu.com/questions/110969
         target_os = "netbsd",
         target_os = "dragonfly"
     )))]
-    runner.execute(Step::Atom, "apm", || generic::run_apm(run_type))?;
-    runner.execute(Step::Fossil, "fossil", || generic::run_fossil(run_type))?;
+    {
+        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(run_type))?;
+    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(run_type))?;
-    runner.execute(Step::Go, "go-global-update", || go::run_go_global_update(run_type))?;
-    runner.execute(Step::Go, "gup", || go::run_go_gup(run_type))?;
+    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(run_type))?;
+    runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(&ctx))?;
+    runner.execute(Step::Vscode, "Visual Studio Code extensions", || {
+        generic::run_vscode_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::Pip3, "pip3", || generic::run_pip3_update(run_type))?;
+    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(run_type))?;
-    runner.execute(Step::Stack, "stack", || generic::run_stack_update(run_type))?;
+    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(run_type))?;
-    runner.execute(Step::Chezmoi, "chezmoi", || generic::run_chezmoi_update(run_type))?;
-    runner.execute(Step::Jetpack, "jetpack", || generic::run_jetpack(run_type))?;
+    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(run_type))?;
+    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))?;
@@ -396,37 +388,38 @@ For more information about this issue see https://askubuntu.com/questions/110969
     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(run_type))?;
-    runner.execute(Step::Helm, "helm", || generic::run_helm_repo_update(run_type))?;
-    runner.execute(Step::Gem, "gem", || generic::run_gem(run_type))?;
+    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(run_type)
-    })?;
-    runner.execute(Step::Micro, "micro", || generic::run_micro(run_type))?;
-    runner.execute(Step::Raco, "raco", || generic::run_raco_update(run_type))?;
+    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)
+    })?;
 
-    #[cfg(target_os = "linux")]
-    {
-        runner.execute(Step::AM, "am", || linux::update_am(&ctx))?;
-        runner.execute(Step::DebGet, "deb-get", || linux::run_deb_get(&ctx))?;
-        runner.execute(Step::Toolbx, "toolbx", || toolbx::run_toolbx(&ctx))?;
-        runner.execute(Step::Flatpak, "Flatpak", || linux::flatpak_update(&ctx))?;
-        runner.execute(Step::Snap, "snap", || linux::run_snap(ctx.sudo().as_ref(), run_type))?;
-        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))?;
+    if should_run_powershell {
+        runner.execute(Step::Powershell, "Powershell Modules Update", || {
+            powershell.update_modules(&ctx)
+        })?;
     }
 
     if let Some(commands) = config.commands() {
@@ -439,37 +432,6 @@ For more information about this issue see https://askubuntu.com/questions/110969
         }
     }
 
-    #[cfg(target_os = "linux")]
-    {
-        runner.execute(Step::System, "pihole", || {
-            linux::run_pihole_update(ctx.sudo().as_ref(), run_type)
-        })?;
-        runner.execute(Step::Firmware, "Firmware upgrades", || linux::run_fwupdmgr(&ctx))?;
-        runner.execute(Step::Restarts, "Restarts", || {
-            linux::run_needrestart(ctx.sudo().as_ref(), run_type)
-        })?;
-    }
-
-    #[cfg(target_os = "macos")]
-    {
-        runner.execute(Step::Sparkle, "Sparkle", || macos::run_sparkle(&ctx))?;
-        runner.execute(Step::Mas, "App Store", || macos::run_mas(run_type))?;
-        runner.execute(Step::System, "System upgrade", || macos::upgrade_macos(&ctx))?;
-    }
-
-    #[cfg(target_os = "freebsd")]
-    runner.execute(Step::System, "FreeBSD Upgrade", || {
-        freebsd::upgrade_freebsd(ctx.sudo().as_ref(), run_type)
-    })?;
-
-    #[cfg(target_os = "openbsd")]
-    runner.execute(Step::System, "OpenBSD Upgrade", || {
-        openbsd::upgrade_openbsd(ctx.sudo().as_ref(), run_type)
-    })?;
-
-    #[cfg(windows)]
-    runner.execute(Step::System, "Windows update", || windows::windows_update(&ctx))?;
-
     if config.should_run(Step::Vagrant) {
         if let Ok(boxes) = vagrant::collect_boxes(&ctx) {
             for vagrant_box in boxes {
@@ -494,12 +456,6 @@ For more information about this issue see https://askubuntu.com/questions/110969
                 distribution.show_summary();
             }
         }
-
-        #[cfg(target_os = "freebsd")]
-        freebsd::audit_packages(ctx.sudo().as_ref()).ok();
-
-        #[cfg(target_os = "dragonfly")]
-        dragonfly::audit_packages(ctx.sudo().as_ref()).ok();
     }
 
     let mut post_command_failed = false;
@@ -533,7 +489,7 @@ For more information about this issue see https://askubuntu.com/questions/110969
     let failed = post_command_failed || runner.report().data().iter().any(|(_, result)| result.failed());
 
     if !config.skip_notify() {
-        terminal::notify_desktop(
+        notify_desktop(
             format!(
                 "Topgrade finished {}",
                 if failed { "with errors" } else { "successfully" }
@@ -578,26 +534,3 @@ fn main() {
         }
     }
 }
-
-pub fn install_tracing(filter_directives: &str) -> Result<()> {
-    use tracing_subscriber::fmt;
-    use tracing_subscriber::fmt::format::FmtSpan;
-    use tracing_subscriber::layer::SubscriberExt;
-    use tracing_subscriber::util::SubscriberInitExt;
-    use tracing_subscriber::EnvFilter;
-
-    let env_filter = EnvFilter::try_new(filter_directives)
-        .or_else(|_| EnvFilter::try_from_default_env())
-        .or_else(|_| EnvFilter::try_new("info"))?;
-
-    let fmt_layer = fmt::layer()
-        .with_target(false)
-        .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
-        .without_time();
-
-    let registry = tracing_subscriber::registry();
-
-    registry.with(env_filter).with(fmt_layer).init();
-
-    Ok(())
-}

src/runner.rs

@@ -34,6 +34,14 @@ impl<'a> Runner<'a> {
         let key = key.into();
         debug!("Step {:?}", key);
 
+        // alter the `func` to put it in a span
+        let func = || {
+            let span =
+                tracing::span!(parent: tracing::Span::none(), tracing::Level::TRACE, "step", step = ?step, key = %key);
+            let _guard = span.enter();
+            func()
+        };
+
         loop {
             match func() {
                 Ok(()) => {

src/self_renamer.rs

@@ -1,5 +1,3 @@
-#![cfg(windows)]
-
 use color_eyre::eyre::Result;
 use std::{env::current_exe, fs, path::PathBuf};
 use tracing::{debug, error};

src/self_update.rs

@@ -3,6 +3,7 @@ use std::env;
 use std::os::unix::process::CommandExt as _;
 use std::process::Command;
 
+use crate::config::Step;
 use color_eyre::eyre::{bail, Result};
 use self_update_crate::backends::github::Update;
 use self_update_crate::update::UpdateStatus;
@@ -11,8 +12,16 @@ use super::terminal::*;
 #[cfg(windows)]
 use crate::error::Upgraded;
 
-pub fn self_update() -> Result<()> {
+use crate::execution_context::ExecutionContext;
+
+pub fn self_update(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Self update");
+
+    if ctx.run_type().dry() {
+        println!("Would self-update");
+        Ok(())
+    } else {
+        let assume_yes = ctx.config().yes(Step::SelfUpdate);
         let current_exe = env::current_exe();
 
         let target = self_update_crate::get_target();
@@ -21,10 +30,10 @@ pub fn self_update() -> Result<()> {
             .repo_name("topgrade")
             .target(target)
             .bin_name(if cfg!(windows) { "topgrade.exe" } else { "topgrade" })
-        .show_output(false)
+            .show_output(true)
             .show_download_progress(true)
             .current_version(self_update_crate::cargo_crate_version!())
-        .no_confirm(true)
+            .no_confirm(assume_yes)
             .build()?
             .update_extended()?;
 
@@ -39,7 +48,7 @@ pub fn self_update() -> Result<()> {
 
         {
             if result.updated() {
-            print_warning("Respawning...");
+                print_info("Respawning...");
                 let mut command = Command::new(current_exe?);
                 command.args(env::args().skip(1)).env("TOPGRADE_NO_SELF_UPGRADE", "");
 
@@ -60,3 +69,4 @@ pub fn self_update() -> Result<()> {
 
         Ok(())
     }
+}

src/steps/containers.rs

@@ -1,3 +1,4 @@
+use std::fmt::{Display, Formatter};
 use std::path::Path;
 use std::process::Command;
 
@@ -5,6 +6,7 @@ use color_eyre::eyre::eyre;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
 use tracing::{debug, error, warn};
+use wildmatch::WildMatch;
 
 use crate::command::CommandExt;
 use crate::error::{self, TopgradeError};
@@ -18,15 +20,51 @@ use crate::{execution_context::ExecutionContext, utils::require};
 // themselves or when using docker-compose.
 const NONEXISTENT_REPO: &str = "repository does not exist";
 
+/// Uniquely identifies a `Container`.
+#[derive(Debug)]
+struct Container {
+    /// `Repository` and `Tag`
+    ///
+    /// format: `Repository:Tag`, e.g., `nixos/nix:latest`.
+    repo_tag: String,
+    /// Platform
+    ///
+    /// format: `OS/Architecture`, e.g., `linux/amd64`.
+    platform: String,
+}
+
+impl Container {
+    /// Construct a new `Container`.
+    fn new(repo_tag: String, platform: String) -> Self {
+        Self { repo_tag, platform }
+    }
+}
+
+impl Display for Container {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        // e.g., "`fedora:latest` for `linux/amd64`"
+        write!(f, "`{}` for `{}`", self.repo_tag, self.platform)
+    }
+}
+
 /// Returns a Vector of all containers, with Strings in the format
 /// "REGISTRY/[PATH/]CONTAINER_NAME:TAG"
-fn list_containers(crt: &Path) -> Result<Vec<String>> {
+///
+/// Containers specified in `ignored_containers` will be filtered out.
+fn list_containers(crt: &Path, ignored_containers: Option<&Vec<String>>) -> Result<Vec<Container>> {
+    let ignored_containers = ignored_containers.map(|patterns| {
+        patterns
+            .iter()
+            .map(|pattern| WildMatch::new(pattern))
+            .collect::<Vec<WildMatch>>()
+    });
+
     debug!(
-        "Querying '{} image ls --format \"{{{{.Repository}}}}:{{{{.Tag}}}}\"' for containers",
+        "Querying '{} image ls --format \"{{{{.Repository}}}}:{{{{.Tag}}}}/{{{{.ID}}}}\"' for containers",
         crt.display()
     );
     let output = Command::new(crt)
-        .args(["image", "ls", "--format", "{{.Repository}}:{{.Tag}}"])
+        .args(["image", "ls", "--format", "{{.Repository}}:{{.Tag}} {{.ID}}"])
         .output_checked_with_utf8(|_| Ok(()))?;
 
     let mut retval = vec![];
@@ -49,7 +87,33 @@ fn list_containers(crt: &Path) -> Result<Vec<String>> {
         }
 
         debug!("Using container '{}'", line);
-        retval.push(String::from(line));
+
+        // 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);
+        let (repo_tag, image_id) = (split_res[0], split_res[1]);
+
+        if let Some(ref ignored_containers) = ignored_containers {
+            if ignored_containers.iter().any(|pattern| pattern.matches(repo_tag)) {
+                debug!("Skipping ignored container '{}'", line);
+                continue;
+            }
+        }
+
+        debug!(
+            "Querying '{} image inspect --format \"{{{{.Os}}}}/{{{{.Architecture}}}}\"' for container {}",
+            crt.display(),
+            image_id
+        );
+        let inspect_output = Command::new(crt)
+            .args(["image", "inspect", image_id, "--format", "{{.Os}}/{{.Architecture}}"])
+            .output_checked_with_utf8(|_| Ok(()))?;
+        let mut platform = inspect_output.stdout;
+        // truncate the tailing new line character
+        platform.truncate(platform.len() - 1);
+        assert!(platform.contains('/'));
+
+        retval.push(Container::new(repo_tag.to_string(), platform));
     }
 
     Ok(retval)
@@ -62,12 +126,18 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Containers");
     let mut success = true;
-    let containers = list_containers(&crt).context("Failed to list Docker containers")?;
+    let containers =
+        list_containers(&crt, ctx.config().containers_ignored_tags()).context("Failed to list Docker containers")?;
     debug!("Containers to inspect: {:?}", containers);
 
     for container in containers.iter() {
         debug!("Pulling container '{}'", container);
-        let args = vec!["pull", &container[..]];
+        let args = vec![
+            "pull",
+            container.repo_tag.as_str(),
+            "--platform",
+            container.platform.as_str(),
+        ];
         let mut exec = ctx.run_type().execute(&crt);
 
         if let Err(e) = exec.args(&args).status_checked() {

src/steps/emacs.rs

@@ -1,4 +1,4 @@
-#[cfg(any(windows))]
+#[cfg(windows)]
 use std::env;
 use std::path::{Path, PathBuf};
 

src/steps/generic.rs

@@ -8,14 +8,15 @@ use std::{fs, io::Write};
 use color_eyre::eyre::eyre;
 use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
+use semver::Version;
 use tempfile::tempfile_in;
 use tracing::{debug, error};
 
 use crate::command::{CommandExt, Utf8Output};
 use crate::execution_context::ExecutionContext;
-use crate::executor::{ExecutorOutput, RunType};
+use crate::executor::ExecutorOutput;
 use crate::terminal::{print_separator, shell};
-use crate::utils::{self, require, require_option, which, PathExt};
+use crate::utils::{self, check_is_python_2_or_shim, require, require_option, which, PathExt, REQUIRE_SUDO};
 use crate::Step;
 use crate::HOME_DIR;
 use crate::{
@@ -23,12 +24,24 @@ use crate::{
     terminal::print_warning,
 };
 
+#[cfg(target_os = "linux")]
+pub fn is_wsl() -> Result<bool> {
+    let output = Command::new("uname").arg("-r").output_checked_utf8()?.stdout;
+    debug!("Uname output: {}", output);
+    Ok(output.contains("microsoft"))
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn is_wsl() -> Result<bool> {
+    Ok(false)
+}
+
 pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     let cargo_dir = env::var_os("CARGO_HOME")
         .map(PathBuf::from)
         .unwrap_or_else(|| HOME_DIR.join(".cargo"))
         .require()?;
-    utils::require("cargo").or_else(|_| {
+    require("cargo").or_else(|_| {
         require_option(
             cargo_dir.join("bin/cargo").if_exists(),
             String::from("No cargo detected"),
@@ -42,7 +55,7 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     }
 
     print_separator("Cargo");
-    let cargo_update = utils::require("cargo-install-update")
+    let cargo_update = require("cargo-install-update")
         .ok()
         .or_else(|| cargo_dir.join("bin/cargo-install-update").if_exists());
     let cargo_update = match cargo_update {
@@ -60,7 +73,7 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
         .status_checked()?;
 
     if ctx.config().cleanup() {
-        let cargo_cache = utils::require("cargo-cache")
+        let cargo_cache = require("cargo-cache")
             .ok()
             .or_else(|| cargo_dir.join("bin/cargo-cache").if_exists());
         match cargo_cache {
@@ -77,20 +90,20 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
-pub fn run_flutter_upgrade(run_type: RunType) -> Result<()> {
-    let flutter = utils::require("flutter")?;
+pub fn run_flutter_upgrade(ctx: &ExecutionContext) -> Result<()> {
+    let flutter = require("flutter")?;
 
     print_separator("Flutter");
-    run_type.execute(flutter).arg("upgrade").status_checked()
+    ctx.run_type().execute(flutter).arg("upgrade").status_checked()
 }
 
-pub fn run_gem(run_type: RunType) -> Result<()> {
-    let gem = utils::require("gem")?;
+pub fn run_gem(ctx: &ExecutionContext) -> Result<()> {
+    let gem = require("gem")?;
     HOME_DIR.join(".gem").require()?;
 
     print_separator("Gems");
 
-    let mut command = run_type.execute(gem);
+    let mut command = ctx.run_type().execute(gem);
     command.arg("update");
 
     if env::var_os("RBENV_SHELL").is_none() {
@@ -107,13 +120,17 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("RubyGems");
     let gem_path_str = gem.as_os_str();
-    if gem_path_str.to_str().unwrap().contains("asdf") {
+    if gem_path_str.to_str().unwrap().contains("asdf")
+        || gem_path_str.to_str().unwrap().contains(".rbenv")
+        || gem_path_str.to_str().unwrap().contains(".rvm")
+    {
         ctx.run_type()
             .execute(gem)
             .args(["update", "--system"])
             .status_checked()?;
-    } else if let Some(sudo) = &ctx.sudo() {
-        if !std::path::Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
+    } else {
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        if !Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
             ctx.run_type()
                 .execute(sudo)
                 .arg("-EH")
@@ -121,14 +138,13 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
                 .args(["update", "--system"])
                 .status_checked()?;
         }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
     }
+
     Ok(())
 }
 
 pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
-    let haxelib = utils::require("haxelib")?;
+    let haxelib = require("haxelib")?;
 
     let haxelib_dir =
         PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output_checked()?.stdout)?.trim())
@@ -142,9 +158,8 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
     let mut command = if directory_writable {
         ctx.run_type().execute(&haxelib)
     } else {
-        let mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
         c.arg(&haxelib);
         c
     };
@@ -153,7 +168,7 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
-    let sheldon = utils::require("sheldon")?;
+    let sheldon = require("sheldon")?;
 
     print_separator("Sheldon");
 
@@ -163,20 +178,21 @@ pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
         .status_checked()
 }
 
-pub fn run_fossil(run_type: RunType) -> Result<()> {
-    let fossil = utils::require("fossil")?;
+pub fn run_fossil(ctx: &ExecutionContext) -> Result<()> {
+    let fossil = require("fossil")?;
 
     print_separator("Fossil");
 
-    run_type.execute(fossil).args(["all", "sync"]).status_checked()
+    ctx.run_type().execute(fossil).args(["all", "sync"]).status_checked()
 }
 
-pub fn run_micro(run_type: RunType) -> Result<()> {
-    let micro = utils::require("micro")?;
+pub fn run_micro(ctx: &ExecutionContext) -> Result<()> {
+    let micro = require("micro")?;
 
     print_separator("micro");
 
-    let stdout = run_type
+    let stdout = ctx
+        .run_type()
         .execute(micro)
         .args(["-plugin", "update"])
         .output_checked_utf8()?
@@ -196,38 +212,59 @@ pub fn run_micro(run_type: RunType) -> Result<()> {
     target_os = "netbsd",
     target_os = "dragonfly"
 )))]
-pub fn run_apm(run_type: RunType) -> Result<()> {
-    let apm = utils::require("apm")?;
+pub fn run_apm(ctx: &ExecutionContext) -> Result<()> {
+    let apm = require("apm")?;
 
     print_separator("Atom Package Manager");
 
-    run_type
+    ctx.run_type()
         .execute(apm)
         .args(["upgrade", "--confirm=false"])
         .status_checked()
 }
 
 pub fn run_rustup(ctx: &ExecutionContext) -> Result<()> {
-    let rustup = utils::require("rustup")?;
+    let rustup = require("rustup")?;
 
     print_separator("rustup");
     ctx.run_type().execute(rustup).arg("update").status_checked()
 }
 
-pub fn run_juliaup(run_type: RunType) -> Result<()> {
-    let juliaup = utils::require("juliaup")?;
+pub fn run_rye(ctx: &ExecutionContext) -> Result<()> {
+    let rye = require("rye")?;
+
+    print_separator("Rye");
+    ctx.run_type().execute(rye).args(["self", "update"]).status_checked()
+}
+
+pub fn run_elan(ctx: &ExecutionContext) -> Result<()> {
+    let elan = require("elan")?;
+
+    print_separator("elan");
+    ctx.run_type()
+        .execute(&elan)
+        .args(["self", "update"])
+        .status_checked()?;
+    ctx.run_type().execute(&elan).arg("update").status_checked()
+}
+
+pub fn run_juliaup(ctx: &ExecutionContext) -> Result<()> {
+    let juliaup = require("juliaup")?;
 
     print_separator("juliaup");
 
     if juliaup.canonicalize()?.is_descendant_of(&HOME_DIR) {
-        run_type.execute(&juliaup).args(["self", "update"]).status_checked()?;
+        ctx.run_type()
+            .execute(&juliaup)
+            .args(["self", "update"])
+            .status_checked()?;
     }
 
-    run_type.execute(&juliaup).arg("update").status_checked()
+    ctx.run_type().execute(&juliaup).arg("update").status_checked()
 }
 
 pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
-    let choosenim = utils::require("choosenim")?;
+    let choosenim = require("choosenim")?;
 
     print_separator("choosenim");
     let run_type = ctx.run_type();
@@ -236,39 +273,42 @@ pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
     run_type.execute(&choosenim).args(["update", "stable"]).status_checked()
 }
 
-pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
-    let krew = utils::require("kubectl-krew")?;
+pub fn run_krew_upgrade(ctx: &ExecutionContext) -> Result<()> {
+    let krew = require("kubectl-krew")?;
 
     print_separator("Krew");
 
-    run_type.execute(krew).args(["upgrade"]).status_checked()
+    ctx.run_type().execute(krew).args(["upgrade"]).status_checked()
 }
 
-pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
-    let gcloud = utils::require("gcloud")?;
+pub fn run_gcloud_components_update(ctx: &ExecutionContext) -> Result<()> {
+    let gcloud = require("gcloud")?;
 
     if gcloud.starts_with("/snap") {
         Ok(())
     } else {
         print_separator("gcloud");
 
-        run_type
+        ctx.run_type()
             .execute(gcloud)
             .args(["components", "update", "--quiet"])
             .status_checked()
     }
 }
 
-pub fn run_jetpack(run_type: RunType) -> Result<()> {
-    let jetpack = utils::require("jetpack")?;
+pub fn run_jetpack(ctx: &ExecutionContext) -> Result<()> {
+    let jetpack = require("jetpack")?;
 
     print_separator("Jetpack");
 
-    run_type.execute(jetpack).args(["global", "update"]).status_checked()
+    ctx.run_type()
+        .execute(jetpack)
+        .args(["global", "update"])
+        .status_checked()
 }
 
 pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
-    let rupdate = utils::require("rupdate")?;
+    let rupdate = require("rupdate")?;
 
     print_separator("rtcl");
 
@@ -276,12 +316,18 @@ pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
-    let opam = utils::require("opam")?;
+    let opam = require("opam")?;
 
     print_separator("OCaml Package Manager");
 
     ctx.run_type().execute(&opam).arg("update").status_checked()?;
-    ctx.run_type().execute(&opam).arg("upgrade").status_checked()?;
+
+    let mut command = ctx.run_type().execute(&opam);
+    command.arg("upgrade");
+    if ctx.config().yes(Step::Opam) {
+        command.arg("--yes");
+    }
+    command.status_checked()?;
 
     if ctx.config().cleanup() {
         ctx.run_type().execute(&opam).arg("clean").status_checked()?;
@@ -291,7 +337,7 @@ pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
-    let vcpkg = utils::require("vcpkg")?;
+    let vcpkg = require("vcpkg")?;
     print_separator("vcpkg");
 
     #[cfg(unix)]
@@ -303,9 +349,8 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
     let mut command = if is_root_install {
         ctx.run_type().execute(&vcpkg)
     } else {
-        let mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
         c.arg(&vcpkg);
         c
     };
@@ -313,17 +358,63 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
     command.args(["upgrade", "--no-dry-run"]).status_checked()
 }
 
-pub fn run_pipx_update(run_type: RunType) -> Result<()> {
-    let pipx = utils::require("pipx")?;
+pub fn run_vscode_extensions_update(ctx: &ExecutionContext) -> Result<()> {
+    // Calling vscode in WSL may install a server instead of updating extensions (https://github.com/topgrade-rs/topgrade/issues/594#issuecomment-1782157367)
+    if is_wsl()? {
+        return Err(SkipStep(String::from("Should not run in WSL")).into());
+    }
+
+    let vscode = require("code")?;
+
+    // Vscode has update command only since 1.86 version ("january 2024" update), disable the update for prior versions
+    // Use command `code --version` which returns 3 lines: version, git commit, instruction set. We parse only the first one
+    let version: Result<Version> = match Command::new(&vscode)
+        .arg("--version")
+        .output_checked_utf8()?
+        .stdout
+        .lines()
+        .next()
+    {
+        Some(item) => Version::parse(item).map_err(|err| err.into()),
+        _ => return Err(SkipStep(String::from("Cannot find vscode version")).into()),
+    };
+
+    if !matches!(version, Ok(version) if version >= Version::new(1, 86, 0)) {
+        return Err(SkipStep(String::from("Too old vscode version to have update extensions command")).into());
+    }
+
+    print_separator("Visual Studio Code extensions");
+
+    ctx.run_type()
+        .execute(vscode)
+        .arg("--update-extensions")
+        .status_checked()
+}
+
+pub fn run_pipx_update(ctx: &ExecutionContext) -> Result<()> {
+    let pipx = require("pipx")?;
     print_separator("pipx");
 
-    run_type.execute(pipx).arg("upgrade-all").status_checked()
+    let mut command_args = vec!["upgrade-all", "--include-injected"];
+
+    // pipx version 1.4.0 introduced a new command argument `pipx upgrade-all --quiet`
+    // (see https://pipx.pypa.io/stable/docs/#pipx-upgrade-all)
+    let version_str = Command::new(&pipx)
+        .args(["--version"])
+        .output_checked_utf8()
+        .map(|s| s.stdout.trim().to_owned());
+    let version = Version::parse(&version_str?);
+    if matches!(version, Ok(version) if version >= Version::new(1, 4, 0)) {
+        command_args.push("--quiet")
+    }
+
+    ctx.run_type().execute(pipx).args(command_args).status_checked()
 }
 
 pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
-    let conda = utils::require("conda")?;
+    let conda = require("conda")?;
 
-    let output = Command::new("conda")
+    let output = Command::new(&conda)
         .args(["config", "--show", "auto_activate_base"])
         .output_checked_utf8()?;
     debug!("Conda output: {}", output.stdout);
@@ -334,7 +425,7 @@ pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Conda");
 
     let mut command = ctx.run_type().execute(conda);
-    command.args(["update", "--all"]);
+    command.args(["update", "--all", "-n", "base"]);
     if ctx.config().yes(Step::Conda) {
         command.arg("--yes");
     }
@@ -342,9 +433,9 @@ pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
-    let mamba = utils::require("mamba")?;
+    let mamba = require("mamba")?;
 
-    let output = Command::new("mamba")
+    let output = Command::new(&mamba)
         .args(["config", "--show", "auto_activate_base"])
         .output_checked_utf8()?;
     debug!("Mamba output: {}", output.stdout);
@@ -355,42 +446,96 @@ pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Mamba");
 
     let mut command = ctx.run_type().execute(mamba);
-    command.args(["update", "--all"]);
+    command.args(["update", "--all", "-n", "base"]);
     if ctx.config().yes(Step::Mamba) {
         command.arg("--yes");
     }
     command.status_checked()
 }
 
-pub fn run_pip3_update(run_type: RunType) -> Result<()> {
-    let python3 = utils::require("python3")?;
+pub fn run_miktex_packages_update(ctx: &ExecutionContext) -> Result<()> {
+    let miktex = require("miktex")?;
+    print_separator("miktex");
+
+    ctx.run_type()
+        .execute(miktex)
+        .args(["packages", "update"])
+        .status_checked()
+}
+
+pub fn run_pip3_update(ctx: &ExecutionContext) -> Result<()> {
+    let py = require("python").and_then(check_is_python_2_or_shim);
+    let py3 = require("python3").and_then(check_is_python_2_or_shim);
+
+    let python3 = match (py, py3) {
+        // prefer `python` if it is available and is a valid Python 3.
+        (Ok(py), _) => py,
+        (Err(_), Ok(py3)) => py3,
+        (Err(py_err), Err(py3_err)) => {
+            return Err(SkipStep(format!("Skip due to following reasons: {} {}", py_err, py3_err)).into());
+        }
+    };
+
     Command::new(&python3)
         .args(["-m", "pip"])
         .output_checked_utf8()
-        .map_err(|_| SkipStep("pip does not exists".to_string()))?;
+        .map_err(|_| SkipStep("pip does not exist".to_string()))?;
 
-    let check_externally_managed = "import sysconfig; from os import path; print('Y') if path.isfile(path.join(sysconfig.get_path('stdlib'), 'EXTERNALLY-MANAGED')) else print('N')";
-    Command::new(&python3)
-        .args(["-c", check_externally_managed])
+    let check_extern_managed_script = "import sysconfig; from os import path; print('Y') if path.isfile(path.join(sysconfig.get_path('stdlib'), 'EXTERNALLY-MANAGED')) else print('N')";
+    let output = Command::new(&python3)
+        .args(["-c", check_extern_managed_script])
+        .output_checked_utf8()?;
+    let stdout = output.stdout.trim();
+    let extern_managed = match stdout {
+        "N" => false,
+        "Y" => true,
+        _ => unreachable!("unexpected output from `check_extern_managed_script`"),
+    };
+
+    let allow_break_sys_pkg = match Command::new(&python3)
+        .args(["-m", "pip", "config", "get", "global.break-system-packages"])
         .output_checked_utf8()
-        .map_err(|_| SkipStep("pip may be externally managed".to_string()))
-        .and_then(|output| match output.stdout.trim() {
-            "N" => Ok(()),
-            "Y" => Err(SkipStep("pip is externally managed".to_string())),
-            _ => {
-                print_warning("Unexpected output when checking EXTERNALLY-MANAGED");
-                print_warning(output.stdout.trim());
-                Err(SkipStep("pip may be externally managed".to_string()))
+    {
+        Ok(output) => {
+            let stdout = output.stdout.trim();
+            stdout
+                .parse::<bool>()
+                .expect("unexpected output that is not `true` or `false`")
+        }
+        // it can fail because this key may not be set
+        //
+        // ```sh
+        // $ pip --version
+        // pip 23.0.1 from /usr/lib/python3/dist-packages/pip (python 3.11)
+        //
+        // $ pip config get global.break-system-packages
+        // ERROR: No such key - global.break-system-packages
+        //
+        // $ echo $?
+        // 1
+        // ```
+        Err(_) => false,
+    };
+
+    debug!("pip3 externally managed: {} ", extern_managed);
+    debug!("pip3 global.break-system-packages: {}", allow_break_sys_pkg);
+
+    // Even though pip3 is externally managed, we should still update it if
+    // `global.break-system-packages` is true.
+    if extern_managed && !allow_break_sys_pkg {
+        return Err(SkipStep(
+            "Skip pip3 update as it is externally managed and global.break-system-packages is not true".to_string(),
+        )
+        .into());
     }
-        })?;
 
     print_separator("pip3");
-    if std::env::var("VIRTUAL_ENV").is_ok() {
-        print_warning("This step is will be skipped when running inside a virtual environment");
+    if env::var("VIRTUAL_ENV").is_ok() {
+        print_warning("This step is skipped when running inside a virtual environment");
         return Err(SkipStep("Does not run inside a virtual environment".to_string()).into());
     }
 
-    run_type
+    ctx.run_type()
         .execute(&python3)
         .args(["-m", "pip", "install", "--upgrade", "--user", "pip"])
         .status_checked()
@@ -414,40 +559,64 @@ pub fn run_pip_review_update(ctx: &ExecutionContext) -> Result<()> {
 
     Ok(())
 }
+
+pub fn run_pip_review_local_update(ctx: &ExecutionContext) -> Result<()> {
+    let pip_review = require("pip-review")?;
+
+    print_separator("pip-review (local)");
+
+    if !ctx.config().enable_pip_review_local() {
+        print_warning(
+            "Pip-review (local) is disabled by default. Enable it by setting enable_pip_review_local=true in the configuration.",
+        );
+        return Err(SkipStep(String::from("Pip-review (local) is disabled by default")).into());
+    }
+    ctx.run_type()
+        .execute(pip_review)
+        .arg("--local")
+        .arg("--auto")
+        .status_checked_with_codes(&[1])?;
+
+    Ok(())
+}
+
 pub fn run_pipupgrade_update(ctx: &ExecutionContext) -> Result<()> {
     let pipupgrade = require("pipupgrade")?;
 
     print_separator("Pipupgrade");
-    if !ctx.config().enable_pip_review() {
+    if !ctx.config().enable_pipupgrade() {
         print_warning(
             "Pipupgrade is disabled by default. Enable it by setting enable_pipupgrade=true in the configuration.",
         );
         return Err(SkipStep(String::from("Pipupgrade is disabled by default")).into());
     }
-    ctx.run_type().execute(pipupgrade).status_checked()?;
+    ctx.run_type()
+        .execute(pipupgrade)
+        .args(ctx.config().pipupgrade_arguments().split_whitespace())
+        .status_checked()?;
 
     Ok(())
 }
 
-pub fn run_stack_update(run_type: RunType) -> Result<()> {
-    if utils::require("ghcup").is_ok() {
+pub fn run_stack_update(ctx: &ExecutionContext) -> Result<()> {
+    if require("ghcup").is_ok() {
         // `ghcup` is present and probably(?) being used to install `stack`.
         // Don't upgrade `stack`, let `ghcup` handle it. Per `ghcup install stack`:
         // !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
         return Ok(());
     }
 
-    let stack = utils::require("stack")?;
+    let stack = require("stack")?;
     print_separator("stack");
 
-    run_type.execute(stack).arg("upgrade").status_checked()
+    ctx.run_type().execute(stack).arg("upgrade").status_checked()
 }
 
-pub fn run_ghcup_update(run_type: RunType) -> Result<()> {
-    let ghcup = utils::require("ghcup")?;
+pub fn run_ghcup_update(ctx: &ExecutionContext) -> Result<()> {
+    let ghcup = require("ghcup")?;
     print_separator("ghcup");
 
-    run_type.execute(ghcup).arg("upgrade").status_checked()
+    ctx.run_type().execute(ghcup).arg("upgrade").status_checked()
 }
 
 pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
@@ -459,8 +628,8 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
         }
     }
 
-    let tlmgr = utils::require("tlmgr")?;
-    let kpsewhich = utils::require("kpsewhich")?;
+    let tlmgr = require("tlmgr")?;
+    let kpsewhich = require("kpsewhich")?;
     let tlmgr_directory = {
         let mut d = PathBuf::from(
             &Command::new(kpsewhich)
@@ -482,9 +651,8 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
     let mut command = if directory_writable {
         ctx.run_type().execute(&tlmgr)
     } else {
-        let mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
         c.arg(&tlmgr);
         c
     };
@@ -493,28 +661,28 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
     command.status_checked()
 }
 
-pub fn run_chezmoi_update(run_type: RunType) -> Result<()> {
-    let chezmoi = utils::require("chezmoi")?;
+pub fn run_chezmoi_update(ctx: &ExecutionContext) -> Result<()> {
+    let chezmoi = require("chezmoi")?;
     HOME_DIR.join(".local/share/chezmoi").require()?;
 
     print_separator("chezmoi");
 
-    run_type.execute(chezmoi).arg("update").status_checked()
+    ctx.run_type().execute(chezmoi).arg("update").status_checked()
 }
 
-pub fn run_myrepos_update(run_type: RunType) -> Result<()> {
-    let myrepos = utils::require("mr")?;
+pub fn run_myrepos_update(ctx: &ExecutionContext) -> Result<()> {
+    let myrepos = require("mr")?;
     HOME_DIR.join(".mrconfig").require()?;
 
     print_separator("myrepos");
 
-    run_type
+    ctx.run_type()
         .execute(&myrepos)
         .arg("--directory")
         .arg(&*HOME_DIR)
         .arg("checkout")
         .status_checked()?;
-    run_type
+    ctx.run_type()
         .execute(&myrepos)
         .arg("--directory")
         .arg(&*HOME_DIR)
@@ -536,7 +704,7 @@ pub fn run_custom_command(name: &str, command: &str, ctx: &ExecutionContext) ->
 }
 
 pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
-    let composer = utils::require("composer")?;
+    let composer = require("composer")?;
     let composer_home = Command::new(&composer)
         .args(["global", "config", "--absolute", "--quiet", "home"])
         .output_checked_utf8()
@@ -546,7 +714,7 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
 
     if !composer_home.is_descendant_of(&HOME_DIR) {
         return Err(SkipStep(format!(
-            "Composer directory {} isn't a decandent of the user's home directory",
+            "Composer directory {} isn't a descendant of the user's home directory",
             composer_home.display()
         ))
         .into());
@@ -564,8 +732,9 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
                 };
 
                 if has_update {
+                    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
                     ctx.run_type()
-                        .execute(ctx.sudo().as_ref().unwrap())
+                        .execute(sudo)
                         .arg(&composer)
                         .arg("self-update")
                         .status_checked()?;
@@ -581,7 +750,7 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
         let output: Utf8Output = output.try_into()?;
         print!("{}\n{}", output.stdout, output.stderr);
         if output.stdout.contains("valet") || output.stderr.contains("valet") {
-            if let Some(valet) = utils::which("valet") {
+            if let Some(valet) = which("valet") {
                 ctx.run_type().execute(valet).arg("install").status_checked()?;
             }
         }
@@ -591,13 +760,18 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let dotnet = utils::require("dotnet")?;
+    let dotnet = require("dotnet")?;
 
-    //Skip when the `dotnet tool list` subcommand fails. (This is expected when a dotnet runtime is installed but no SDK.)
+    // Skip when the `dotnet tool list` subcommand fails.
+    // (This is expected when a dotnet runtime is installed but no SDK.)
     let output = match ctx
         .run_type()
         .execute(&dotnet)
         .args(["tool", "list", "--global"])
+        // dotnet will print a greeting message on its first run, from this question:
+        // https://stackoverflow.com/q/70493706/14092446
+        // Setting `DOTNET_NOLOGO` to `true` should disable it
+        .env("DOTNET_NOLOGO", "true")
         .output_checked_utf8()
     {
         Ok(output) => output,
@@ -605,15 +779,31 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
             return Err(SkipStep(String::from(
                 "Error running `dotnet tool list`. This is expected when a dotnet runtime is installed but no SDK.",
             ))
-            .into())
+            .into());
         }
     };
 
-    if !output.stdout.starts_with("Package Id") {
-        return Err(SkipStep(String::from("dotnet did not output packages")).into());
+    let mut in_header = true;
+    let mut packages = output
+        .stdout
+        .lines()
+        // Skip the header:
+        //
+        // Package Id      Version      Commands
+        // -------------------------------------
+        .skip_while(|line| {
+            // The .NET SDK respects locale, so the header can be printed
+            // in languages other than English. The separator should hopefully
+            // always be at least 10 -'s long.
+            if in_header && line.starts_with("----------") {
+                in_header = false;
+                true
+            } else {
+                in_header
             }
-
-    let mut packages = output.stdout.lines().skip(2).filter(|line| !line.is_empty()).peekable();
+        })
+        .filter(|line| !line.is_empty())
+        .peekable();
 
     if packages.peek().is_none() {
         return Err(SkipStep(String::from("No dotnet global tools installed")).into());
@@ -634,49 +824,53 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
-    utils::require("helix")?;
+    let helix = require("helix").or(require("hx"))?;
 
     print_separator("Helix");
 
     ctx.run_type()
-        .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?)
-        .args(["helix", "--grammar", "fetch"])
+        .execute(&helix)
+        .args(["--grammar", "fetch"])
         .status_checked()
         .with_context(|| "Failed to download helix grammars!")?;
 
     ctx.run_type()
-        .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?)
-        .args(["helix", "--grammar", "build"])
+        .execute(&helix)
+        .args(["--grammar", "build"])
         .status_checked()
         .with_context(|| "Failed to build helix grammars!")?;
 
     Ok(())
 }
 
-pub fn run_raco_update(run_type: RunType) -> Result<()> {
-    let raco = utils::require("raco")?;
+pub fn run_raco_update(ctx: &ExecutionContext) -> Result<()> {
+    let raco = require("raco")?;
 
     print_separator("Racket Package Manager");
 
-    run_type.execute(raco).args(["pkg", "update", "--all"]).status_checked()
+    ctx.run_type()
+        .execute(raco)
+        .args(["pkg", "update", "--all"])
+        .status_checked()
 }
 
 pub fn bin_update(ctx: &ExecutionContext) -> Result<()> {
-    let bin = utils::require("bin")?;
+    let bin = require("bin")?;
 
     print_separator("Bin");
     ctx.run_type().execute(bin).arg("update").status_checked()
 }
 
 pub fn spicetify_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let spicetify = utils::require("spicetify")?;
+    // As of 04-07-2023 NixOS packages Spicetify with the `spicetify-cli` binary name
+    let spicetify = require("spicetify").or(require("spicetify-cli"))?;
 
     print_separator("Spicetify");
     ctx.run_type().execute(spicetify).arg("upgrade").status_checked()
 }
 
 pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let gh = utils::require("gh")?;
+    let gh = require("gh")?;
     let result = Command::new(&gh).args(["extensions", "list"]).output_checked_utf8();
     if result.is_err() {
         debug!("GH result {:?}", result);
@@ -691,7 +885,7 @@ pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
-    let julia = utils::require("julia")?;
+    let julia = require("julia")?;
 
     print_separator("Julia Packages");
 
@@ -701,14 +895,14 @@ pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
         .status_checked()
 }
 
-pub fn run_helm_repo_update(run_type: RunType) -> Result<()> {
-    let helm = utils::require("helm")?;
+pub fn run_helm_repo_update(ctx: &ExecutionContext) -> Result<()> {
+    let helm = require("helm")?;
 
     print_separator("Helm");
 
     let no_repo = "no repositories found";
     let mut success = true;
-    let mut exec = run_type.execute(helm);
+    let mut exec = ctx.run_type().execute(helm);
     if let Err(e) = exec.arg("repo").arg("update").status_checked() {
         error!("Updating repositories failed: {}", e);
         success = match exec.output_checked_utf8() {
@@ -726,3 +920,85 @@ pub fn run_helm_repo_update(run_type: RunType) -> Result<()> {
         Err(eyre!(StepFailed))
     }
 }
+
+pub fn run_stew(ctx: &ExecutionContext) -> Result<()> {
+    let stew = require("stew")?;
+
+    print_separator("stew");
+    ctx.run_type().execute(stew).args(["upgrade", "--all"]).status_checked()
+}
+
+pub fn run_bob(ctx: &ExecutionContext) -> Result<()> {
+    let bob = require("bob")?;
+
+    print_separator("Bob");
+
+    ctx.run_type().execute(bob).args(["update", "--all"]).status_checked()
+}
+
+pub fn run_certbot(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let certbot = require("certbot")?;
+
+    print_separator("Certbot");
+
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.arg(certbot);
+    cmd.arg("renew");
+
+    cmd.status_checked()
+}
+
+/// Run `$ freshclam` to update ClamAV signature database
+///
+/// doc: https://docs.clamav.net/manual/Usage/SignatureManagement.html#freshclam
+pub fn run_freshclam(ctx: &ExecutionContext) -> Result<()> {
+    let freshclam = require("freshclam")?;
+    print_separator("Update ClamAV Database(FreshClam)");
+    ctx.run_type().execute(freshclam).status_checked()
+}
+
+/// Involve `pio upgrade` to update PlatformIO core.
+pub fn run_platform_io(ctx: &ExecutionContext) -> Result<()> {
+    // We use the full path because by default the binary is not in `PATH`:
+    // https://github.com/topgrade-rs/topgrade/issues/754#issuecomment-2020537559
+    #[cfg(unix)]
+    fn bin_path() -> PathBuf {
+        HOME_DIR.join(".platformio/penv/bin/pio")
+    }
+    #[cfg(windows)]
+    fn bin_path() -> PathBuf {
+        HOME_DIR.join(".platformio/penv/Scripts/pio.exe")
+    }
+
+    let bin_path = require(bin_path())?;
+
+    print_separator("PlatformIO Core");
+
+    ctx.run_type().execute(bin_path).arg("upgrade").status_checked()
+}
+
+/// Run `lensfun-update-data` to update lensfun database.
+///
+/// `sudo` will be used if `use_sudo` configuration entry is set to true.
+pub fn run_lensfun_update_data(ctx: &ExecutionContext) -> Result<()> {
+    const SEPARATOR: &str = "Lensfun's database update";
+    let lensfun_update_data = require("lensfun-update-data")?;
+    const EXIT_CODE_WHEN_NO_UPDATE: i32 = 1;
+
+    if ctx.config().lensfun_use_sudo() {
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        print_separator(SEPARATOR);
+        ctx.run_type()
+            .execute(sudo)
+            .arg(lensfun_update_data)
+            // `lensfun-update-data` returns 1 when there is no update available
+            // which should be considered success
+            .status_checked_with_codes(&[EXIT_CODE_WHEN_NO_UPDATE])
+    } else {
+        print_separator(SEPARATOR);
+        ctx.run_type()
+            .execute(lensfun_update_data)
+            .status_checked_with_codes(&[EXIT_CODE_WHEN_NO_UPDATE])
+    }
+}

src/steps/git.rs

@@ -3,139 +3,173 @@ use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, Stdio};
 
+use color_eyre::eyre::Context;
 use color_eyre::eyre::{eyre, Result};
 use console::style;
-use futures::stream::{iter, FuturesUnordered};
-use futures::StreamExt;
+use futures::stream::{iter, FuturesUnordered, StreamExt};
 use glob::{glob_with, MatchOptions};
 use tokio::process::Command as AsyncCommand;
 use tokio::runtime;
 use tracing::{debug, error};
 
 use crate::command::CommandExt;
+use crate::config::Step;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
+use crate::steps::emacs::Emacs;
 use crate::terminal::print_separator;
-use crate::utils::{which, PathExt};
-use crate::{error::SkipStep, terminal::print_warning};
+use crate::utils::{require, PathExt};
+use crate::{error::SkipStep, terminal::print_warning, HOME_DIR};
+use etcetera::base_strategy::BaseStrategy;
+
+#[cfg(unix)]
+use crate::XDG_DIRS;
+
+#[cfg(windows)]
+use crate::WINDOWS_DIRS;
+
+pub fn run_git_pull(ctx: &ExecutionContext) -> Result<()> {
+    let mut repos = RepoStep::try_new()?;
+    let config = ctx.config();
+
+    // handle built-in repos
+    if config.use_predefined_git_repos() {
+        // should be executed on all the platforms
+        {
+            if config.should_run(Step::Emacs) {
+                let emacs = Emacs::new();
+                if !emacs.is_doom() {
+                    if let Some(directory) = emacs.directory() {
+                        repos.insert_if_repo(directory);
+                    }
+                }
+                repos.insert_if_repo(HOME_DIR.join(".doom.d"));
+            }
+
+            if config.should_run(Step::Vim) {
+                repos.insert_if_repo(HOME_DIR.join(".vim"));
+                repos.insert_if_repo(HOME_DIR.join(".config/nvim"));
+            }
+
+            repos.insert_if_repo(HOME_DIR.join(".ideavimrc"));
+            repos.insert_if_repo(HOME_DIR.join(".intellimacs"));
+
+            if config.should_run(Step::Rcm) {
+                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);
+            }
+        }
+
+        #[cfg(unix)]
+        {
+            repos.insert_if_repo(crate::steps::zsh::zshrc());
+            if config.should_run(Step::Tmux) {
+                repos.insert_if_repo(HOME_DIR.join(".tmux"));
+            }
+            repos.insert_if_repo(HOME_DIR.join(".config/fish"));
+            repos.insert_if_repo(XDG_DIRS.config_dir().join("openbox"));
+            repos.insert_if_repo(XDG_DIRS.config_dir().join("bspwm"));
+            repos.insert_if_repo(XDG_DIRS.config_dir().join("i3"));
+            repos.insert_if_repo(XDG_DIRS.config_dir().join("sway"));
+        }
+
+        #[cfg(windows)]
+        {
+            repos.insert_if_repo(
+                WINDOWS_DIRS
+                    .cache_dir()
+                    .join("Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState"),
+            );
+
+            super::os::windows::insert_startup_scripts(&mut repos).ok();
+        }
+    }
+
+    // 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);
+        }
+    }
+
+    // Warn the user about the bad patterns.
+    //
+    // NOTE: this should be executed **before** skipping the Git step or the
+    // user won't receive this warning in the cases where all the paths configured
+    // are bad patterns.
+    repos
+        .bad_patterns
+        .iter()
+        .for_each(|pattern| print_warning(format!("Path {pattern} did not contain any git repositories")));
+
+    if repos.is_repos_empty() {
+        return Err(SkipStep(String::from("No repositories to pull")).into());
+    }
+
+    print_separator("Git repositories");
+
+    repos.pull_repos(ctx)
+}
 
 #[cfg(windows)]
 static PATH_PREFIX: &str = "\\\\?\\";
 
-#[derive(Debug)]
-pub struct Git {
-    git: Option<PathBuf>,
-}
-
-pub struct Repositories<'a> {
-    git: &'a Git,
-    repositories: HashSet<String>,
+pub struct RepoStep {
+    git: PathBuf,
+    repos: HashSet<PathBuf>,
     glob_match_options: MatchOptions,
     bad_patterns: Vec<String>,
 }
 
+#[track_caller]
 fn output_checked_utf8(output: Output) -> Result<()> {
     if !(output.status.success()) {
-        let stderr = String::from_utf8(output.stderr).unwrap();
-        Err(eyre!(stderr))
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stderr = stderr.trim();
+        Err(eyre!("{stderr}"))
     } else {
         Ok(())
     }
 }
 
-async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -> Result<()> {
-    let path = repo.to_string();
-    let before_revision = get_head_revision(git, &repo);
-
-    println!("{} {}", style("Pulling").cyan().bold(), path);
-
-    let mut command = AsyncCommand::new(git);
-
-    command
-        .stdin(Stdio::null())
-        .current_dir(&repo)
-        .args(["pull", "--ff-only"]);
-
-    if let Some(extra_arguments) = ctx.config().git_arguments() {
-        command.args(extra_arguments.split_whitespace());
-    }
-
-    let pull_output = command.output().await?;
-    let submodule_output = AsyncCommand::new(git)
-        .args(["submodule", "update", "--recursive"])
-        .current_dir(&repo)
-        .stdin(Stdio::null())
-        .output()
-        .await?;
-    let result = output_checked_utf8(pull_output).and_then(|_| output_checked_utf8(submodule_output));
-
-    if let Err(message) = &result {
-        println!("{} pulling {}", style("Failed").red().bold(), &repo);
-        print!("{message}");
-    } else {
-        let after_revision = get_head_revision(git, &repo);
-
-        match (&before_revision, &after_revision) {
-            (Some(before), Some(after)) if before != after => {
-                println!("{} {}:", style("Changed").yellow().bold(), &repo);
-
+fn get_head_revision<P: AsRef<Path>>(git: &Path, repo: P) -> Option<String> {
     Command::new(git)
         .stdin(Stdio::null())
-                    .current_dir(&repo)
-                    .args([
-                        "--no-pager",
-                        "log",
-                        "--no-decorate",
-                        "--oneline",
-                        &format!("{before}..{after}"),
-                    ])
-                    .status_checked()?;
-                println!();
-            }
-            _ => {
-                println!("{} {}", style("Up-to-date").green().bold(), &repo);
-            }
-        }
-    }
-
-    result.map(|_| ())
-}
-
-fn get_head_revision(git: &Path, repo: &str) -> Option<String> {
-    Command::new(git)
-        .stdin(Stdio::null())
-        .current_dir(repo)
+        .current_dir(repo.as_ref())
         .args(["rev-parse", "HEAD"])
         .output_checked_utf8()
         .map(|output| output.stdout.trim().to_string())
         .map_err(|e| {
-            error!("Error getting revision for {}: {}", repo, e);
+            error!("Error getting revision for {}: {}", repo.as_ref().display(), e);
 
             e
         })
         .ok()
 }
 
-fn has_remotes(git: &Path, repo: &str) -> Option<bool> {
-    Command::new(git)
-        .stdin(Stdio::null())
-        .current_dir(repo)
-        .args(["remote", "show"])
-        .output_checked_utf8()
-        .map(|output| output.stdout.lines().count() > 0)
-        .map_err(|e| {
-            error!("Error getting remotes for {}: {}", repo, e);
-            e
+impl RepoStep {
+    /// Try to create a `RepoStep`, fail if `git` is not found.
+    pub fn try_new() -> Result<Self> {
+        let git = require("git")?;
+        let mut glob_match_options = MatchOptions::new();
+
+        if cfg!(windows) {
+            glob_match_options.case_sensitive = false;
+        }
+
+        Ok(Self {
+            git,
+            repos: HashSet::new(),
+            bad_patterns: Vec::new(),
+            glob_match_options,
         })
-        .ok()
     }
 
-impl Git {
-    pub fn new() -> Self {
-        Self { git: which("git") }
-    }
-
-    pub fn get_repo_root<P: AsRef<Path>>(&self, path: P) -> Option<String> {
+    /// Try to get the root of the repo specified in `path`.
+    pub fn get_repo_root<P: AsRef<Path>>(&self, path: P) -> Option<PathBuf> {
         match path.as_ref().canonicalize() {
             Ok(mut path) => {
                 debug_assert!(path.exists());
@@ -159,105 +193,56 @@ impl Git {
                     path_string
                 };
 
-                if let Some(git) = &self.git {
-                    let output = Command::new(git)
+                let output = Command::new(&self.git)
                     .stdin(Stdio::null())
                     .current_dir(path)
                     .args(["rev-parse", "--show-toplevel"])
                     .output_checked_utf8()
                     .ok()
-                        .map(|output| output.stdout.trim().to_string());
+                    // trim the last newline char
+                    .map(|output| PathBuf::from(output.stdout.trim()));
+
                 return output;
             }
-            }
             Err(e) => match e.kind() {
-                io::ErrorKind::NotFound => debug!("{} does not exists", path.as_ref().display()),
+                io::ErrorKind::NotFound => debug!("{} does not exist", path.as_ref().display()),
                 _ => error!("Error looking for {}: {}", path.as_ref().display(), e),
             },
         }
 
         None
     }
-    pub fn multi_pull_step(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
-        if repositories.repositories.is_empty() {
-            return Err(SkipStep(String::from("No repositories to pull")).into());
-        }
-
-        print_separator("Git repositories");
-        repositories
-            .bad_patterns
-            .iter()
-            .for_each(|pattern| print_warning(format!("Path {pattern} did not contain any git repositories")));
-        self.multi_pull(repositories, ctx)
-    }
-
-    pub fn multi_pull(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
-        let git = self.git.as_ref().unwrap();
-
-        if let RunType::Dry = ctx.run_type() {
-            repositories
-                .repositories
-                .iter()
-                .for_each(|repo| println!("Would pull {}", &repo));
-
-            return Ok(());
-        }
-
-        let futures_iterator = repositories
-            .repositories
-            .iter()
-            .filter(|repo| match has_remotes(git, repo) {
-                Some(false) => {
-                    println!(
-                        "{} {} because it has no remotes",
-                        style("Skipping").yellow().bold(),
-                        repo
-                    );
-                    false
-                }
-                _ => true, // repo has remotes or command to check for remotes has failed. proceed to pull anyway.
-            })
-            .map(|repo| pull_repository(repo.clone(), git, ctx));
-
-        let stream_of_futures = if let Some(limit) = ctx.config().git_concurrency_limit() {
-            iter(futures_iterator).buffer_unordered(limit).boxed()
-        } else {
-            futures_iterator.collect::<FuturesUnordered<_>>().boxed()
-        };
-
-        let basic_rt = runtime::Runtime::new()?;
-        let results = basic_rt.block_on(async { stream_of_futures.collect::<Vec<Result<()>>>().await });
-
-        let error = results.into_iter().find(|r| r.is_err());
-        error.unwrap_or(Ok(()))
-    }
-}
-
-impl<'a> Repositories<'a> {
-    pub fn new(git: &'a Git) -> Self {
-        let mut glob_match_options = MatchOptions::new();
-
-        if cfg!(windows) {
-            glob_match_options.case_sensitive = false;
-        }
-
-        Self {
-            git,
-            repositories: HashSet::new(),
-            bad_patterns: Vec::new(),
-            glob_match_options,
-        }
-    }
 
+    /// Check if `path` is a git repo, if yes, add it to `self.repos`.
+    ///
+    /// Return the check result.
     pub fn insert_if_repo<P: AsRef<Path>>(&mut self, path: P) -> bool {
-        if let Some(repo) = self.git.get_repo_root(path) {
-            self.repositories.insert(repo);
+        if let Some(repo) = self.get_repo_root(path) {
+            self.repos.insert(repo);
             true
         } else {
             false
         }
     }
 
+    /// Check if `repo` has a remote.
+    fn has_remotes<P: AsRef<Path>>(&self, repo: P) -> Option<bool> {
+        let mut cmd = Command::new(&self.git);
+        cmd.stdin(Stdio::null())
+            .current_dir(repo.as_ref())
+            .args(["remote", "show"]);
+
+        let res = cmd.output_checked_utf8();
+
+        res.map(|output| output.stdout.lines().count() > 0)
+            .map_err(|e| {
+                error!("Error getting remotes for {}: {}", repo.as_ref().display(), e);
+                e
+            })
+            .ok()
+    }
+
+    /// Similar to `insert_if_repo`, with glob support.
     pub fn glob_insert(&mut self, pattern: &str) {
         if let Ok(glob) = glob_with(pattern, self.glob_match_options) {
             let mut last_git_repo: Option<PathBuf> = None;
@@ -267,7 +252,7 @@ impl<'a> Repositories<'a> {
                         if let Some(last_git_repo) = &last_git_repo {
                             if path.is_descendant_of(last_git_repo) {
                                 debug!(
-                                    "Skipping {} because it's a decendant of last known repo {}",
+                                    "Skipping {} because it's a descendant of last known repo {}",
                                     path.display(),
                                     last_git_repo.display()
                                 );
@@ -292,14 +277,130 @@ impl<'a> Repositories<'a> {
         }
     }
 
-    #[cfg(unix)]
-    pub fn is_empty(&self) -> bool {
-        self.repositories.is_empty()
+    /// True if `self.repos` is empty.
+    pub fn is_repos_empty(&self) -> bool {
+        self.repos.is_empty()
     }
 
+    /// Remove `path` from `self.repos`.
+    ///
+    // `cfg(unix)` because it is only used in the oh-my-zsh step.
     #[cfg(unix)]
-    pub fn remove(&mut self, path: &str) {
-        let _removed = self.repositories.remove(path);
+    pub fn remove<P: AsRef<Path>>(&mut self, path: P) {
+        let _removed = self.repos.remove(path.as_ref());
         debug_assert!(_removed);
     }
+
+    /// Try to pull a repo.
+    async fn pull_repo<P: AsRef<Path>>(&self, ctx: &ExecutionContext<'_>, repo: P) -> Result<()> {
+        let before_revision = get_head_revision(&self.git, &repo);
+
+        if ctx.config().verbose() {
+            println!("{} {}", style("Pulling").cyan().bold(), repo.as_ref().display());
+        }
+
+        let mut command = AsyncCommand::new(&self.git);
+
+        command
+            .stdin(Stdio::null())
+            .current_dir(&repo)
+            .args(["pull", "--ff-only"]);
+
+        if let Some(extra_arguments) = ctx.config().git_arguments() {
+            command.args(extra_arguments.split_whitespace());
+        }
+
+        let pull_output = command.output().await?;
+        let submodule_output = AsyncCommand::new(&self.git)
+            .args(["submodule", "update", "--recursive"])
+            .current_dir(&repo)
+            .stdin(Stdio::null())
+            .output()
+            .await?;
+        let result = output_checked_utf8(pull_output)
+            .and_then(|_| output_checked_utf8(submodule_output))
+            .wrap_err_with(|| format!("Failed to pull {}", repo.as_ref().display()));
+
+        if result.is_err() {
+            println!("{} pulling {}", style("Failed").red().bold(), repo.as_ref().display());
+        } else {
+            let after_revision = get_head_revision(&self.git, repo.as_ref());
+
+            match (&before_revision, &after_revision) {
+                (Some(before), Some(after)) if before != after => {
+                    println!("{} {}", style("Changed").yellow().bold(), repo.as_ref().display());
+
+                    Command::new(&self.git)
+                        .stdin(Stdio::null())
+                        .current_dir(&repo)
+                        .args([
+                            "--no-pager",
+                            "log",
+                            "--no-decorate",
+                            "--oneline",
+                            &format!("{before}..{after}"),
+                        ])
+                        .status_checked()?;
+                    println!();
+                }
+                _ => {
+                    if ctx.config().verbose() {
+                        println!("{} {}", style("Up-to-date").green().bold(), repo.as_ref().display());
+                    }
+                }
+            }
+        }
+
+        result.map(|_| ())
+    }
+
+    /// Pull the repositories specified in `self.repos`.
+    ///
+    /// # NOTE
+    /// This function will create an async runtime and do the real job so the
+    /// function itself is not async.
+    fn pull_repos(&self, ctx: &ExecutionContext) -> Result<()> {
+        if ctx.run_type().dry() {
+            self.repos
+                .iter()
+                .for_each(|repo| println!("Would pull {}", repo.display()));
+
+            return Ok(());
+        }
+
+        if !ctx.config().verbose() {
+            println!(
+                "\n{} updated repositories will be shown...\n",
+                style("Only").green().bold()
+            );
+        }
+
+        let futures_iterator = self
+            .repos
+            .iter()
+            .filter(|repo| match self.has_remotes(repo) {
+                Some(false) => {
+                    println!(
+                        "{} {} because it has no remotes",
+                        style("Skipping").yellow().bold(),
+                        repo.display()
+                    );
+                    false
+                }
+                _ => true, // repo has remotes or command to check for remotes has failed. proceed to pull anyway.
+            })
+            .map(|repo| self.pull_repo(ctx, repo));
+
+        let stream_of_futures = if let Some(limit) = ctx.config().git_concurrency_limit() {
+            iter(futures_iterator).buffer_unordered(limit).boxed()
+        } else {
+            futures_iterator.collect::<FuturesUnordered<_>>().boxed()
+        };
+
+        let basic_rt = runtime::Runtime::new()?;
+        let results = basic_rt.block_on(async { stream_of_futures.collect::<Vec<Result<()>>>().await });
+
+        let error = results.into_iter().find(|r| r.is_err());
+        error.unwrap_or(Ok(()))
+    }
 }

src/steps/go.rs

@@ -4,27 +4,27 @@ use std::process::Command;
 use color_eyre::eyre::Result;
 
 use crate::command::CommandExt;
-use crate::executor::RunType;
+use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
 use crate::utils;
 use crate::utils::PathExt;
 
 /// <https://github.com/Gelio/go-global-update>
-pub fn run_go_global_update(run_type: RunType) -> Result<()> {
+pub fn run_go_global_update(ctx: &ExecutionContext) -> Result<()> {
     let go_global_update = require_go_bin("go-global-update")?;
 
     print_separator("go-global-update");
 
-    run_type.execute(go_global_update).status_checked()
+    ctx.run_type().execute(go_global_update).status_checked()
 }
 
 /// <https://github.com/nao1215/gup>
-pub fn run_go_gup(run_type: RunType) -> Result<()> {
+pub fn run_go_gup(ctx: &ExecutionContext) -> Result<()> {
     let gup = require_go_bin("gup")?;
 
     print_separator("gup");
 
-    run_type.execute(gup).arg("update").status_checked()
+    ctx.run_type().execute(gup).arg("update").status_checked()
 }
 
 /// Get the path of a Go binary.

src/steps/node.rs

@@ -4,7 +4,7 @@ use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::HOME_DIR;
 use color_eyre::eyre::Result;
 #[cfg(target_os = "linux")]
@@ -92,7 +92,7 @@ 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(), String::from("sudo is not installed"))?;
+            let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
             ctx.run_type()
                 .execute(sudo)
                 .arg(&self.command)
@@ -156,7 +156,7 @@ impl Yarn {
         let args = ["global", "upgrade"];
 
         if use_sudo {
-            let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?;
+            let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
             ctx.run_type()
                 .execute(sudo)
                 .arg(self.yarn.as_ref().unwrap_or(&self.command))
@@ -230,7 +230,7 @@ pub fn run_npm_upgrade(ctx: &ExecutionContext) -> Result<()> {
 pub fn run_pnpm_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let pnpm = require("pnpm").map(|b| NPM::new(b, NPMVariant::Pnpm))?;
 
-    print_separator("Node Package Manager");
+    print_separator("Performant Node Package Manager");
 
     #[cfg(target_os = "linux")]
     {

src/steps/os/archlinux.rs

@@ -277,7 +277,7 @@ impl Aura {
 
 impl ArchPackageManager for Aura {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let sudo = which("sudo").unwrap_or_else(PathBuf::new);
+        let sudo = which("sudo").unwrap_or_default();
         let mut aur_update = ctx.run_type().execute(&sudo);
 
         if sudo.ends_with("sudo") {

src/steps/os/dragonfly.rs

@@ -1,26 +1,34 @@
 use crate::command::CommandExt;
-use crate::executor::RunType;
-use crate::sudo::Sudo;
+use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
+use crate::Step;
 use color_eyre::eyre::Result;
 use std::process::Command;
 
-pub fn upgrade_packages(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("DragonFly BSD Packages");
-    run_type
-        .execute(sudo)
-        .args(["/usr/local/sbin/pkg", "upgrade"])
-        .status_checked()
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.args(["/usr/local/sbin/pkg", "upgrade"]);
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-y");
+    }
+    cmd.status_checked()
 }
 
-pub fn audit_packages(sudo: Option<&Sudo>) -> Result<()> {
-    if let Some(sudo) = sudo {
-        println!();
-        Command::new(sudo)
+pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+
+    print_separator("DragonFly BSD Audit");
+
+    #[allow(clippy::disallowed_methods)]
+    if !Command::new(sudo)
         .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
-            .status_checked()?;
+        .status()?
+        .success()
+    {
+        println!("The package audit was successful, but vulnerable packages still remain on the system");
     }
     Ok(())
 }

src/steps/os/freebsd.rs

@@ -1,27 +1,25 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
-use crate::sudo::Sudo;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::Step;
 use color_eyre::eyre::Result;
 use std::process::Command;
 
-pub fn upgrade_freebsd(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("FreeBSD Update");
-    run_type
+    ctx.run_type()
         .execute(sudo)
         .args(["/usr/sbin/freebsd-update", "fetch", "install"])
         .status_checked()
 }
 
-pub fn upgrade_packages(ctx: &ExecutionContext, sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("FreeBSD Packages");
 
-    let mut command = run_type.execute(sudo);
+    let mut command = ctx.run_type().execute(sudo);
 
     command.args(["/usr/sbin/pkg", "upgrade"]);
     if ctx.config().yes(Step::System) {
@@ -30,12 +28,13 @@ pub fn upgrade_packages(ctx: &ExecutionContext, sudo: Option<&Sudo>, run_type: R
     command.status_checked()
 }
 
-pub fn audit_packages(sudo: Option<&Sudo>) -> Result<()> {
-    if let Some(sudo) = sudo {
-        println!();
+pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+
+    print_separator("FreeBSD Audit");
+
     Command::new(sudo)
         .args(["/usr/sbin/pkg", "audit", "-Fr"])
         .status_checked()?;
-    }
     Ok(())
 }

src/steps/os/linux.rs

@@ -8,12 +8,11 @@ use tracing::{debug, warn};
 use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
+use crate::steps::generic::is_wsl;
 use crate::steps::os::archlinux;
-use crate::sudo::Sudo;
-use crate::terminal::{print_separator, print_warning};
-use crate::utils::{require, require_option, which, PathExt};
-use crate::Step;
+use crate::terminal::{print_separator, prompt_yesno};
+use crate::utils::{require, require_option, which, PathExt, REQUIRE_SUDO};
+use crate::{Step, HOME_DIR};
 
 static OS_RELEASE_PATH: &str = "/etc/os-release";
 
@@ -21,51 +20,61 @@ static OS_RELEASE_PATH: &str = "/etc/os-release";
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum Distribution {
     Alpine,
+    Wolfi,
     Arch,
     Bedrock,
     CentOS,
+    Chimera,
     ClearLinux,
     Fedora,
-    FedoraSilverblue,
+    FedoraImmutable,
     Debian,
     Gentoo,
     OpenMandriva,
+    OpenSuseTumbleweed,
     PCLinuxOS,
     Suse,
     SuseMicro,
+    Vanilla,
     Void,
     Solus,
     Exherbo,
     NixOS,
     KDENeon,
+    Nobara,
 }
 
 impl Distribution {
-    fn parse_os_release(os_release: &ini::Ini) -> Result<Self> {
+    fn parse_os_release(os_release: &Ini) -> Result<Self> {
         let section = os_release.general_section();
         let id = section.get("ID");
-        let variant: Option<Vec<&str>> = section.get("VARIANT").map(|s| s.split_whitespace().collect());
+        let name = section.get("NAME");
+        let variant = section.get("VARIANT");
         let id_like: Option<Vec<&str>> = section.get("ID_LIKE").map(|s| s.split_whitespace().collect());
 
         Ok(match id {
             Some("alpine") => Distribution::Alpine,
+            Some("chimera") => Distribution::Chimera,
+            Some("wolfi") => Distribution::Wolfi,
             Some("centos") | Some("rhel") | Some("ol") => Distribution::CentOS,
             Some("clear-linux-os") => Distribution::ClearLinux,
-            Some("fedora") | Some("nobara") => {
-                if let Some(variant) = variant {
-                    if variant.contains(&"Silverblue") {
-                        return Ok(Distribution::FedoraSilverblue);
-                    } else {
-                        return Ok(Distribution::Fedora);
-                    };
-                } else {
-                    return Ok(Distribution::Fedora);
+            Some("fedora") => {
+                return if let Some(variant) = variant {
+                    match variant {
+                        "Silverblue" | "Kinoite" | "Sericea" | "Onyx" | "IoT Edition" | "Sway Atomic" => {
+                            Ok(Distribution::FedoraImmutable)
                         }
+                        _ => Ok(Distribution::Fedora),
+                    }
+                } else {
+                    Ok(Distribution::Fedora)
+                };
             }
 
+            Some("nobara") => Distribution::Nobara,
             Some("void") => Distribution::Void,
-            Some("debian") | Some("pureos") => Distribution::Debian,
-            Some("arch") | Some("anarchy") | Some("manjaro-arm") | Some("garuda") | Some("artix") => Distribution::Arch,
+            Some("debian") | Some("pureos") | Some("Deepin") | Some("linuxmint") => Distribution::Debian,
+            Some("arch") | Some("manjaro-arm") | Some("garuda") | Some("artix") => Distribution::Arch,
             Some("solus") => Distribution::Solus,
             Some("gentoo") => Distribution::Gentoo,
             Some("exherbo") => Distribution::Exherbo,
@@ -75,13 +84,23 @@ impl Distribution {
             Some("openmandriva") => Distribution::OpenMandriva,
             Some("pclinuxos") => Distribution::PCLinuxOS,
             _ => {
+                if let Some(name) = name {
+                    if name.contains("Vanilla") {
+                        return Ok(Distribution::Vanilla);
+                    }
+                }
                 if let Some(id_like) = id_like {
                     if id_like.contains(&"debian") || id_like.contains(&"ubuntu") {
                         return Ok(Distribution::Debian);
                     } else if id_like.contains(&"centos") {
                         return Ok(Distribution::CentOS);
                     } else if id_like.contains(&"suse") {
-                        return Ok(Distribution::Suse);
+                        let id_variant = id.unwrap_or_default();
+                        return if id_variant.contains("tumbleweed") {
+                            Ok(Distribution::OpenSuseTumbleweed)
+                        } else {
+                            Ok(Distribution::Suse)
+                        };
                     } else if id_like.contains(&"arch") || id_like.contains(&"archlinux") {
                         return Ok(Distribution::Arch);
                     } else if id_like.contains(&"alpine") {
@@ -103,10 +122,14 @@ impl Distribution {
         if PathBuf::from(OS_RELEASE_PATH).exists() {
             let os_release = Ini::load_from_file(OS_RELEASE_PATH)?;
 
+            if os_release.general_section().is_empty() {
+                return Err(TopgradeError::EmptyOSReleaseFile.into());
+            }
+
             return Self::parse_os_release(&os_release);
         }
 
-        Err(TopgradeError::UnknownLinuxDistribution.into())
+        Err(TopgradeError::EmptyOSReleaseFile.into())
     }
 
     pub fn upgrade(self, ctx: &ExecutionContext) -> Result<()> {
@@ -114,14 +137,18 @@ impl Distribution {
 
         match self {
             Distribution::Alpine => upgrade_alpine_linux(ctx),
+            Distribution::Chimera => upgrade_chimera_linux(ctx),
+            Distribution::Wolfi => upgrade_wolfi_linux(ctx),
             Distribution::Arch => archlinux::upgrade_arch_linux(ctx),
             Distribution::CentOS | Distribution::Fedora => upgrade_redhat(ctx),
-            Distribution::FedoraSilverblue => upgrade_fedora_silverblue(ctx),
+            Distribution::FedoraImmutable => upgrade_fedora_immutable(ctx),
             Distribution::ClearLinux => upgrade_clearlinux(ctx),
             Distribution::Debian => upgrade_debian(ctx),
             Distribution::Gentoo => upgrade_gentoo(ctx),
             Distribution::Suse => upgrade_suse(ctx),
             Distribution::SuseMicro => upgrade_suse_micro(ctx),
+            Distribution::OpenSuseTumbleweed => upgrade_opensuse_tumbleweed(ctx),
+            Distribution::Vanilla => upgrade_vanilla(ctx),
             Distribution::Void => upgrade_void(ctx),
             Distribution::Solus => upgrade_solus(ctx),
             Distribution::Exherbo => upgrade_exherbo(ctx),
@@ -130,6 +157,7 @@ impl Distribution {
             Distribution::Bedrock => update_bedrock(ctx),
             Distribution::OpenMandriva => upgrade_openmandriva(ctx),
             Distribution::PCLinuxOS => upgrade_pclinuxos(ctx),
+            Distribution::Nobara => upgrade_nobara(ctx),
         }
     }
 
@@ -145,7 +173,7 @@ impl Distribution {
 }
 
 fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("Sudo required"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
     ctx.run_type().execute(sudo).args(["brl", "update"]);
 
@@ -156,7 +184,7 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
         debug!("Bedrock distribution {}", distribution);
         match distribution {
             "arch" => archlinux::upgrade_arch_linux(ctx)?,
-            "debian" | "ubuntu" => upgrade_debian(ctx)?,
+            "debian" | "ubuntu" | "linuxmint" => upgrade_debian(ctx)?,
             "centos" | "fedora" => upgrade_redhat(ctx)?,
             "bedrock" => upgrade_bedrock_strata(ctx)?,
             _ => {
@@ -168,15 +196,25 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
-fn is_wsl() -> Result<bool> {
-    let output = Command::new("uname").arg("-r").output_checked_utf8()?.stdout;
-    debug!("Uname output: {}", output);
-    Ok(output.contains("microsoft"))
-}
-
 fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> {
     let apk = require("apk")?;
-    let sudo = ctx.sudo().as_ref().unwrap();
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+
+    ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
+    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
+}
+
+fn upgrade_chimera_linux(ctx: &ExecutionContext) -> Result<()> {
+    let apk = require("apk")?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+
+    ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
+    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
+}
+
+fn upgrade_wolfi_linux(ctx: &ExecutionContext) -> Result<()> {
+    let apk = require("apk")?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
     ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
     ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
@@ -191,7 +229,7 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
         }
     };
 
-    if let Some(sudo) = &ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let mut command = ctx.run_type().execute(sudo);
     command
         .arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf()))
@@ -210,13 +248,44 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
     }
 
     command.status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
     Ok(())
 }
 
-fn upgrade_fedora_silverblue(ctx: &ExecutionContext) -> Result<()> {
+fn upgrade_nobara(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let pkg_manager = require("dnf")?;
+
+    let mut update_command = ctx.run_type().execute(sudo);
+    update_command.arg(&pkg_manager);
+
+    if ctx.config().yes(Step::System) {
+        update_command.arg("-y");
+    }
+
+    update_command.arg("update");
+    // See https://nobaraproject.org/docs/upgrade-troubleshooting/how-do-i-update-the-system/
+    update_command.args([
+        "rpmfusion-nonfree-release",
+        "rpmfusion-free-release",
+        "fedora-repos",
+        "nobara-repos",
+    ]);
+    update_command.arg("--refresh").status_checked()?;
+
+    let mut upgrade_command = ctx.run_type().execute(sudo);
+    upgrade_command.arg(&pkg_manager);
+
+    if ctx.config().yes(Step::System) {
+        upgrade_command.arg("-y");
+    }
+
+    upgrade_command.arg("distro-sync");
+
+    upgrade_command.status_checked()?;
+    Ok(())
+}
+
+fn upgrade_fedora_immutable(ctx: &ExecutionContext) -> Result<()> {
     let ostree = require("rpm-ostree")?;
     let mut command = ctx.run_type().execute(ostree);
     command.arg("upgrade");
@@ -225,47 +294,68 @@ fn upgrade_fedora_silverblue(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
 
 fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     ctx.run_type()
         .execute(sudo)
         .args(["zypper", "refresh"])
         .status_checked()?;
 
-        ctx.run_type()
-            .execute(sudo)
-            .args(["zypper", "dist-upgrade"])
-            .status_checked()?;
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.arg("zypper");
+    cmd.arg(if ctx.config().suse_dup() {
+        "dist-upgrade"
     } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+        "update"
+    });
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-y");
     }
 
+    cmd.status_checked()?;
+
     Ok(())
 }
-fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
+
+fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     ctx.run_type()
         .execute(sudo)
-            .args(["transactional-update", "dup"])
+        .args(["zypper", "refresh"])
         .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.args(["zypper", "dist-upgrade"]);
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-y");
     }
 
+    cmd.status_checked()?;
+
+    Ok(())
+}
+
+fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.arg("transactional-update");
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-n");
+    }
+
+    cmd.arg("dup").status_checked()?;
+
     Ok(())
 }
 
 fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let mut command = ctx.run_type().execute(sudo);
 
     command.arg(&which("dnf").unwrap()).arg("upgrade");
@@ -279,14 +369,12 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
     }
 
     command.status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
+
 fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let mut command_update = ctx.run_type().execute(sudo);
 
     command_update.arg(&which("apt-get").unwrap()).arg("update");
@@ -301,20 +389,39 @@ fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
 
     command_update.status_checked()?;
 
-        ctx.run_type()
-            .execute(sudo)
-            .arg(&which("apt-get").unwrap())
-            .arg("dist-upgrade")
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.arg(&which("apt-get").unwrap());
+    cmd.arg("dist-upgrade");
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-y");
     }
+    cmd.status_checked()?;
+
+    Ok(())
+}
+
+fn upgrade_vanilla(ctx: &ExecutionContext) -> Result<()> {
+    let apx = require("apx")?;
+
+    let mut update = ctx.run_type().execute(&apx);
+    update.args(["update", "--all"]);
+    if ctx.config().yes(Step::System) {
+        update.arg("-y");
+    }
+    update.status_checked()?;
+
+    let mut upgrade = ctx.run_type().execute(&apx);
+    update.args(["upgrade", "--all"]);
+    if ctx.config().yes(Step::System) {
+        upgrade.arg("-y");
+    }
+    upgrade.status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let mut command = ctx.run_type().execute(sudo);
     command.args(["xbps-install", "-Su", "xbps"]);
     if ctx.config().yes(Step::System) {
@@ -328,9 +435,6 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
         command.arg("-y");
     }
     command.status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
@@ -338,7 +442,7 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
 fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
     let run_type = ctx.run_type();
 
-    if let Some(sudo) = &ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     if let Some(layman) = which("layman") {
         run_type
             .execute(sudo)
@@ -373,15 +477,11 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
                 .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
         )
         .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
 
 fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
     let apt = which("apt-fast")
         .or_else(|| {
             if which("mist").is_some() {
@@ -399,9 +499,26 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
         })
         .unwrap_or_else(|| PathBuf::from("apt-get"));
 
+    let is_mist = apt.ends_with("mist");
     let is_nala = apt.ends_with("nala");
+
+    // MIST does not require `sudo`
+    if is_mist {
+        ctx.run_type().execute(&apt).arg("update").status_checked()?;
+        ctx.run_type().execute(&apt).arg("upgrade").status_checked()?;
+
+        // Simply return as MIST does not have `clean` and `autoremove`
+        // subcommands, neither the `-y` option (for now maybe?).
+        return Ok(());
+    }
+
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     if !is_nala {
-            ctx.run_type().execute(sudo).arg(&apt).arg("update").status_checked()?;
+        ctx.run_type()
+            .execute(sudo)
+            .arg(&apt)
+            .arg("update")
+            .status_checked_with_codes(&[0, 100])?;
     }
 
     let mut command = ctx.run_type().execute(sudo);
@@ -429,9 +546,6 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
         }
         command.status_checked()?;
     }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
@@ -441,38 +555,50 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("deb-get");
 
-    ctx.execute_elevated(&deb_get, false)?.arg("update").status_checked()?;
-    ctx.execute_elevated(&deb_get, false)?.arg("upgrade").status_checked()?;
+    ctx.run_type().execute(&deb_get).arg("update").status_checked()?;
+    ctx.run_type().execute(&deb_get).arg("upgrade").status_checked()?;
 
     if ctx.config().cleanup() {
-        ctx.execute_elevated(&deb_get, false)?.arg("clean").status_checked()?;
+        ctx.run_type().execute(&deb_get).arg("clean").status_checked()?;
     }
 
     Ok(())
 }
 
 fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["eopkg", "upgrade"])
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.arg("eopkg");
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-y");
     }
+    cmd.arg("upgrade").status_checked()?;
 
     Ok(())
 }
 
-pub fn update_am(ctx: &ExecutionContext) -> Result<()> {
+pub fn run_am(ctx: &ExecutionContext) -> Result<()> {
     let am = require("am")?;
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).arg(am).arg("-u").status_checked()?;
+
+    print_separator("AM");
+
+    let mut am = ctx.run_type().execute(am);
+
+    if ctx.config().yes(Step::AM) {
+        am.arg("-U");
     } else {
-        print_warning("No sudo detected. Skipping AM Step");
+        am.arg("-u");
     }
 
-    Ok(())
+    am.status_checked()
+}
+
+pub fn run_appman(ctx: &ExecutionContext) -> Result<()> {
+    let appman = require("appman")?;
+
+    print_separator("appman");
+
+    ctx.run_type().execute(appman).arg("-u").status_checked()
 }
 
 pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
@@ -485,10 +611,12 @@ pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
     let new_version = string.contains("version: 1");
 
     if new_version {
-        ctx.run_type()
-            .execute(&pacdef)
-            .args(["package", "sync"])
-            .status_checked()?;
+        let mut cmd = ctx.run_type().execute(&pacdef);
+        cmd.args(["package", "sync"]);
+        if ctx.config().yes(Step::System) {
+            cmd.arg("--noconfirm");
+        }
+        cmd.status_checked()?;
 
         println!();
         ctx.run_type()
@@ -496,7 +624,13 @@ pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
             .args(["package", "review"])
             .status_checked()?;
     } else {
-        ctx.run_type().execute(&pacdef).arg("sync").status_checked()?;
+        let mut cmd = ctx.run_type().execute(&pacdef);
+        cmd.arg("sync");
+        if ctx.config().yes(Step::System) {
+            cmd.arg("--noconfirm");
+        }
+
+        cmd.status_checked()?;
 
         println!();
         ctx.run_type().execute(&pacdef).arg("review").status_checked()?;
@@ -521,21 +655,39 @@ pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
     upgrade_cmd.arg("-Up").status_checked()
 }
 
-fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
+pub fn run_packer_nu(ctx: &ExecutionContext) -> Result<()> {
+    let nu = require("nu")?;
+    let packer_home = HOME_DIR.join(".local/share/nushell/packer");
+
+    packer_home.clone().require()?;
+
+    print_separator("packer.nu");
+
     ctx.run_type()
-            .execute(sudo)
-            .args(["swupd", "update"])
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+        .execute(nu)
+        .env("PWD", "/")
+        .env("NU_PACKER_HOME", packer_home)
+        .args([
+            "-c",
+            "use ~/.local/share/nushell/packer/start/packer.nu/api_layer/packer.nu; packer update",
+        ])
+        .status_checked()
 }
 
+fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut cmd = ctx.run_type().execute(sudo);
+    cmd.args(["swupd", "update"]);
+    if ctx.config().yes(Step::System) {
+        cmd.arg("--assume=yes");
+    }
+    cmd.status_checked()?;
+
     Ok(())
 }
 
 fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
 
     ctx.run_type()
@@ -559,15 +711,12 @@ fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
         .execute(sudo)
         .args(["eclectic", "config", "interactive"])
         .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
 
 fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let mut command = ctx.run_type().execute(sudo);
     command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]);
 
@@ -582,9 +731,6 @@ fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
             .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
             .status_checked()?;
     }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
 
     Ok(())
 }
@@ -595,7 +741,8 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
     // in theory rpm based distributions use pkcon as well, though that
     // seems rare
     // if that comes up we need to create a Distribution::PackageKit or some such
-    if let Some(sudo) = &ctx.sudo() {
+
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let pkcon = which("pkcon").unwrap();
     // pkcon ignores update with update and refresh provided together
     ctx.run_type()
@@ -613,23 +760,60 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
     }
     // from pkcon man, exit code 5 is 'Nothing useful was done.'
     cmd.status_checked_with_codes(&[5])?;
+
+    Ok(())
+}
+
+/// `needrestart` should be skipped if:
+///
+/// 1. This is a redhat-based distribution
+/// 2. This is a debian-based distribution and it is using `nala` as the `apt`
+///    alternative
+fn should_skip_needrestart() -> Result<()> {
+    let distribution = Distribution::detect()?;
+    let msg = "needrestart will be ran by the package manager";
+
+    if distribution.redhat_based() {
+        return Err(SkipStep(String::from(msg)).into());
+    }
+
+    if matches!(distribution, Distribution::Debian) {
+        let apt = which("apt-fast")
+            .or_else(|| {
+                if which("mist").is_some() {
+                    Some(PathBuf::from("mist"))
+                } else {
+                    None
+                }
+            })
+            .or_else(|| {
+                if Path::new("/usr/bin/nala").exists() {
+                    Some(Path::new("/usr/bin/nala").to_path_buf())
+                } else {
+                    None
+                }
+            })
+            .unwrap_or_else(|| PathBuf::from("apt-get"));
+
+        let is_nala = apt.ends_with("nala");
+
+        if is_nala {
+            return Err(SkipStep(String::from(msg)).into());
+        }
     }
 
     Ok(())
 }
 
-pub fn run_needrestart(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("sudo is not installed"))?;
+pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let needrestart = require("needrestart")?;
-    let distribution = Distribution::detect()?;
 
-    if distribution.redhat_based() {
-        return Err(SkipStep(String::from("needrestart will be ran by the package manager")).into());
-    }
+    should_skip_needrestart()?;
 
     print_separator("Check for needed restarts");
 
-    run_type.execute(sudo).arg(needrestart).status_checked()?;
+    ctx.run_type().execute(sudo).arg(needrestart).status_checked()?;
 
     Ok(())
 }
@@ -661,9 +845,9 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     updmgr.status_checked_with_codes(&[2])
 }
 
-pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
+pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
     let flatpak = require("flatpak")?;
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let cleanup = ctx.config().cleanup();
     let yes = ctx.config().yes(Step::Flatpak);
     let run_type = ctx.run_type();
@@ -723,8 +907,8 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
-pub fn run_snap(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("sudo is not installed"))?;
+pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let snap = require("snap")?;
 
     if !PathBuf::from("/var/snapd.socket").exists() && !PathBuf::from("/run/snapd.socket").exists() {
@@ -732,17 +916,17 @@ pub fn run_snap(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
     }
     print_separator("snap");
 
-    run_type.execute(sudo).arg(snap).arg("refresh").status_checked()
+    ctx.run_type().execute(sudo).arg(snap).arg("refresh").status_checked()
 }
 
-pub fn run_pihole_update(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("sudo is not installed"))?;
+pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let pihole = require("pihole")?;
     Path::new("/opt/pihole/update.sh").require()?;
 
     print_separator("pihole");
 
-    run_type.execute(sudo).arg(pihole).arg("-up").status_checked()
+    ctx.run_type().execute(sudo).arg(pihole).arg("-up").status_checked()
 }
 
 pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
@@ -750,7 +934,12 @@ pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("protonup");
 
-    ctx.run_type().execute(protonup).status_checked()?;
+    let mut cmd = ctx.run_type().execute(protonup);
+    if ctx.config().yes(Step::Protonup) {
+        cmd.arg("--yes");
+    }
+    cmd.status_checked()?;
+
     Ok(())
 }
 
@@ -780,7 +969,7 @@ pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let dkp_pacman = require("dkp-pacman")?;
 
     print_separator("Devkitpro pacman");
@@ -803,7 +992,7 @@ pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     if ctx.config().yes(Step::ConfigUpdate) {
         return Err(SkipStep("Skipped in --yes".to_string()).into());
     }
@@ -823,6 +1012,80 @@ pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
+pub fn run_lure_update(ctx: &ExecutionContext) -> Result<()> {
+    let lure = require("lure")?;
+
+    print_separator("LURE");
+
+    let mut exe = ctx.run_type().execute(lure);
+
+    if ctx.config().yes(Step::Lure) {
+        exe.args(["-i=false", "up"]);
+    } else {
+        exe.arg("up");
+    }
+
+    exe.status_checked()
+}
+
+pub fn run_waydroid(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let waydroid = require("waydroid")?;
+    let status = ctx.run_type().execute(&waydroid).arg("status").output_checked_utf8()?;
+    // example output of `waydroid status`:
+    //
+    // ```sh
+    // $ waydroid status
+    // Session:        RUNNING
+    // Container:      RUNNING
+    // Vendor type:    MAINLINE
+    // IP address:     192.168.240.112
+    // Session user:   w568w(1000)
+    // Wayland display:        wayland-0
+    // ```
+    //
+    // ```sh
+    // $ waydroid status
+    // Session:        STOPPED
+    // Vendor type:    MAINLINE
+    // ```
+    let session = status
+        .stdout
+        .lines()
+        .find(|line| line.contains("Session:"))
+        .expect("the output of `waydroid status` should contain `Session:`");
+    let is_container_running = session.contains("RUNNING");
+    let assume_yes = ctx.config().yes(Step::Waydroid);
+
+    print_separator("Waydroid");
+
+    if is_container_running && !assume_yes {
+        let update_allowed =
+            prompt_yesno("Going to execute `waydroid upgrade`, which would STOP the running container, is this ok?")?;
+        if !update_allowed {
+            return Err(SkipStep("Skip the Waydroid step because the user don't want to proceed".to_string()).into());
+        }
+    }
+    ctx.run_type()
+        .execute(sudo)
+        .arg(&waydroid)
+        .arg("upgrade")
+        .status_checked()
+}
+
+pub fn run_auto_cpufreq(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let auto_cpu_freq = require("auto-cpufreq")?;
+
+    print_separator("auto-cpufreq");
+
+    ctx.run_type()
+        .execute(sudo)
+        .arg(auto_cpu_freq)
+        .arg("--update")
+        .status_checked()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -835,6 +1098,11 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_wolfi() {
+        test_template(include_str!("os_release/wolfi"), Distribution::Wolfi);
+    }
+
     #[test]
     fn test_arch_linux() {
         test_template(include_str!("os_release/arch"), Distribution::Arch);
@@ -887,8 +1155,19 @@ mod tests {
     }
 
     #[test]
-    fn test_antergos() {
-        test_template(include_str!("os_release/antergos"), Distribution::Arch);
+    fn test_fedora_immutable() {
+        test_template(
+            include_str!("os_release/fedorasilverblue"),
+            Distribution::FedoraImmutable,
+        );
+        test_template(include_str!("os_release/fedorakinoite"), Distribution::FedoraImmutable);
+        test_template(include_str!("os_release/fedoraonyx"), Distribution::FedoraImmutable);
+        test_template(include_str!("os_release/fedorasericea"), Distribution::FedoraImmutable);
+        test_template(include_str!("os_release/fedoraiot"), Distribution::FedoraImmutable);
+        test_template(
+            include_str!("os_release/fedoraswayatomic"),
+            Distribution::FedoraImmutable,
+        );
     }
 
     #[test]
@@ -901,11 +1180,6 @@ mod tests {
         test_template(include_str!("os_release/manjaro-arm"), Distribution::Arch);
     }
 
-    #[test]
-    fn test_anarchy() {
-        test_template(include_str!("os_release/anarchy"), Distribution::Arch);
-    }
-
     #[test]
     fn test_gentoo() {
         test_template(include_str!("os_release/gentoo"), Distribution::Gentoo);
@@ -950,4 +1224,24 @@ mod tests {
     fn test_pureos() {
         test_template(include_str!("os_release/pureos"), Distribution::Debian);
     }
+
+    #[test]
+    fn test_deepin() {
+        test_template(include_str!("os_release/deepin"), Distribution::Debian);
+    }
+
+    #[test]
+    fn test_vanilla() {
+        test_template(include_str!("os_release/vanilla"), Distribution::Vanilla);
+    }
+
+    #[test]
+    fn test_solus() {
+        test_template(include_str!("os_release/solus"), Distribution::Solus);
+    }
+
+    #[test]
+    fn test_nobara() {
+        test_template(include_str!("os_release/nobara"), Distribution::Nobara);
+    }
 }

src/steps/os/macos.rs

@@ -1,16 +1,18 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
 use crate::terminal::{print_separator, prompt_yesno};
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::{utils::require, Step};
 use color_eyre::eyre::Result;
+use std::collections::HashSet;
 use std::fs;
 use std::process::Command;
 use tracing::debug;
 
 pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
     require("port")?;
-    let sudo = ctx.sudo().as_ref().unwrap();
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+
     print_separator("MacPorts");
     ctx.run_type()
         .execute(sudo)
@@ -30,17 +32,17 @@ pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
-pub fn run_mas(run_type: RunType) -> Result<()> {
+pub fn run_mas(ctx: &ExecutionContext) -> Result<()> {
     let mas = require("mas")?;
     print_separator("macOS App Store");
 
-    run_type.execute(mas).arg("upgrade").status_checked()
+    ctx.run_type().execute(mas).arg("upgrade").status_checked()
 }
 
 pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
     print_separator("macOS system update");
 
-    let should_ask = !(ctx.config().yes(Step::System)) || (ctx.config().dry_run());
+    let should_ask = !(ctx.config().yes(Step::System) || ctx.config().dry_run());
     if should_ask {
         println!("Finding available software");
         if system_update_available()? {
@@ -92,3 +94,148 @@ pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
     }
     Ok(())
 }
+
+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 releases = ctx
+        .run_type()
+        .execute(&xcodes)
+        .args(["update"])
+        .output_checked_utf8()?
+        .stdout;
+
+    let releases_installed: Vec<String> = releases
+        .lines()
+        .filter(|r| r.contains("(Installed)"))
+        .map(String::from)
+        .collect();
+
+    if releases_installed.is_empty() {
+        println!("No Xcode releases installed.");
+        return Ok(());
+    }
+
+    let (installed_gm, installed_beta, installed_regular) =
+        releases_installed
+            .iter()
+            .fold((false, false, false), |(gm, beta, regular), release| {
+                (
+                    gm || release.contains("GM") || release.contains("Release Candidate"),
+                    beta || release.contains("Beta"),
+                    regular
+                        || !(release.contains("GM")
+                            || release.contains("Release Candidate")
+                            || release.contains("Beta")),
+                )
+            });
+
+    let releases_gm = releases
+        .lines()
+        .filter(|&r| r.matches("GM").count() > 0 || r.matches("Release Candidate").count() > 0)
+        .map(String::from)
+        .collect();
+    let releases_beta = releases
+        .lines()
+        .filter(|&r| r.matches("Beta").count() > 0)
+        .map(String::from)
+        .collect();
+    let releases_regular = releases
+        .lines()
+        .filter(|&r| {
+            r.matches("GM").count() == 0
+                && r.matches("Release Candidate").count() == 0
+                && r.matches("Beta").count() == 0
+        })
+        .map(String::from)
+        .collect();
+
+    if installed_gm {
+        process_xcodes_releases(releases_gm, should_ask, ctx)?;
+    }
+    if installed_beta {
+        process_xcodes_releases(releases_beta, should_ask, ctx)?;
+    }
+    if installed_regular {
+        process_xcodes_releases(releases_regular, should_ask, ctx)?;
+    }
+
+    let releases_new = ctx
+        .run_type()
+        .execute(&xcodes)
+        .args(["list"])
+        .output_checked_utf8()?
+        .stdout;
+
+    let releases_gm_new_installed: HashSet<_> = releases_new
+        .lines()
+        .filter(|release| {
+            release.contains("(Installed)") && (release.contains("GM") || release.contains("Release Candidate"))
+        })
+        .collect();
+    let releases_beta_new_installed: HashSet<_> = releases_new
+        .lines()
+        .filter(|release| release.contains("(Installed)") && release.contains("Beta"))
+        .collect();
+    let releases_regular_new_installed: HashSet<_> = releases_new
+        .lines()
+        .filter(|release| {
+            release.contains("(Installed)")
+                && !(release.contains("GM") || release.contains("Release Candidate") || release.contains("Beta"))
+        })
+        .collect();
+
+    for releases_new_installed in [
+        releases_gm_new_installed,
+        releases_beta_new_installed,
+        releases_regular_new_installed,
+    ] {
+        if should_ask && releases_new_installed.len() == 2 {
+            let answer_uninstall = prompt_yesno("Would you like to move the former Xcode release to the trash?")?;
+            if answer_uninstall {
+                let _ = ctx
+                    .run_type()
+                    .execute(&xcodes)
+                    .args([
+                        "uninstall",
+                        releases_new_installed.iter().next().cloned().unwrap_or_default(),
+                    ])
+                    .status_checked();
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn process_xcodes_releases(releases_filtered: Vec<String>, should_ask: bool, ctx: &ExecutionContext) -> Result<()> {
+    let xcodes = require("xcodes")?;
+
+    if releases_filtered
+        .last()
+        .map(|s| !s.contains("(Installed)"))
+        .unwrap_or(true)
+        && !releases_filtered.is_empty()
+    {
+        println!(
+            "New Xcode release detected: {}",
+            releases_filtered.last().cloned().unwrap_or_default()
+        );
+        if should_ask {
+            let answer_install = prompt_yesno("Would you like to install it?")?;
+            if answer_install {
+                let _ = ctx
+                    .run_type()
+                    .execute(xcodes)
+                    .args(["install", &releases_filtered.last().cloned().unwrap_or_default()])
+                    .status_checked();
+            }
+            println!();
+        }
+    }
+
+    Ok(())
+}

src/steps/os/openbsd.rs

@@ -1,23 +1,33 @@
-use crate::executor::RunType;
+use crate::command::CommandExt;
+use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use color_eyre::eyre::Result;
-use std::path::PathBuf;
 
-pub fn upgrade_openbsd(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("OpenBSD Update");
-    run_type
+    ctx.run_type()
         .execute(sudo)
-        .args(&["/usr/sbin/sysupgrade", "-n"])
+        .args(["/usr/sbin/sysupgrade", "-n"])
         .status_checked()
 }
 
-pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("OpenBSD Packages");
-    run_type
+
+    if ctx.config().cleanup() {
+        ctx.run_type()
             .execute(sudo)
-        .args(&["/usr/sbin/pkg_add", "-u"])
-        .status_checked()
+            .args(["/usr/sbin/pkg_delete", "-ac"])
+            .status_checked()?;
+    }
+
+    ctx.run_type()
+        .execute(sudo)
+        .args(["/usr/sbin/pkg_add", "-u"])
+        .status_checked()?;
+
+    Ok(())
 }

src/steps/os/os_release/anarchy

@@ -1,6 +0,0 @@
-NAME="Anarchy Linux"
-PRETTY_NAME="Anarchy Linux"
-ID=anarchy
-ID_LIKE=anarchylinux
-ANSI_COLOR="0;36"
-HOME_URL="https://anarchylinux.org/"

src/steps/os/os_release/antergos

@@ -1,10 +0,0 @@
-NAME="Antergos Linux"
-VERSION="18.7-ISO-Rolling"
-ID="antergos"
-ID_LIKE="arch"
-PRETTY_NAME="Antergos Linux"
-CPE_NAME="cpe:/o:antergosproject:antergos:18.7"
-ANSI_COLOR="1;34;40"
-HOME_URL="antergos.com"
-SUPPORT_URL="forum.antergos.com"
-BUG_REPORT_URL="@antergos"

src/steps/os/os_release/deepin

@@ -0,0 +1,8 @@
+PRETTY_NAME="Deepin 20.9"
+NAME="Deepin"
+VERSION_ID="20.9"
+VERSION="20.9"
+VERSION_CODENAME="apricot"
+ID=Deepin
+HOME_URL="https://www.deepin.org/"
+BUG_REPORT_URL="https://bbs.deepin.org/"

src/steps/os/os_release/fedoraiot

@@ -0,0 +1,22 @@
+NAME="Fedora Linux"
+VERSION="39.20240415.0 (IoT Edition)"
+ID=fedora
+VERSION_ID=39
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f39"
+PRETTY_NAME="Fedora Linux 39.20240415.0 (IoT Edition)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=fedora-logo-icon
+CPE_NAME="cpe:/o:fedoraproject:fedora:39"
+HOME_URL="https://fedoraproject.org/"
+DOCUMENTATION_URL="https://docs.fedoraproject.org/en-US/fedora/f39/system-administrators-guide/"
+SUPPORT_URL="https://ask.fedoraproject.org/"
+BUG_REPORT_URL="https://bugzilla.redhat.com/"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=39
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=39
+SUPPORT_END=2024-11-12
+VARIANT="IoT Edition"
+VARIANT_ID=iot
+OSTREE_VERSION='39.20240415.0'

src/steps/os/os_release/fedorakinoite

@@ -0,0 +1,23 @@
+NAME="Fedora Linux"
+VERSION="39.20240105.0 (Kinoite)"
+ID=fedora
+VERSION_ID=39
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f39"
+PRETTY_NAME="Fedora Linux 39.20240105.0 (Kinoite)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=fedora-logo-icon
+CPE_NAME="cpe:/o:fedoraproject:fedora:39"
+DEFAULT_HOSTNAME="fedora"
+HOME_URL="https://kinoite.fedoraproject.org"
+DOCUMENTATION_URL="https://docs.fedoraproject.org/en-US/fedora-kinoite/"
+SUPPORT_URL="https://ask.fedoraproject.org/"
+BUG_REPORT_URL="https://pagure.io/fedora-kde/SIG/issues"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=39
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=39
+SUPPORT_END=2024-11-12
+VARIANT="Kinoite"
+VARIANT_ID=kinoite
+OSTREE_VERSION='39.20240105.0'

src/steps/os/os_release/fedoraonyx

@@ -0,0 +1,22 @@
+NAME="Fedora Linux"
+VERSION="39 (Onyx)"
+ID=fedora
+VERSION_ID=39
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f39"
+PRETTY_NAME="Fedora Linux 39 (Onyx)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=fedora-logo-icon
+CPE_NAME="cpe:/o:fedoraproject:fedora:39"
+DEFAULT_HOSTNAME="fedora"
+HOME_URL="https://fedoraproject.org/onyx/"
+DOCUMENTATION_URL="https://docs.fedoraproject.org/en-US/fedora-onyx/"
+SUPPORT_URL="https://ask.fedoraproject.org/"
+BUG_REPORT_URL="https://bugzilla.redhat.com/"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=39
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=39
+SUPPORT_END=2024-05-14
+VARIANT="Onyx"
+VARIANT_ID=onyx

src/steps/os/os_release/fedorasericea

@@ -0,0 +1,22 @@
+NAME="Fedora Linux"
+VERSION="39 (Sericea)"
+ID=fedora
+VERSION_ID=39
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f39"
+PRETTY_NAME="Fedora Linux 39 (Sericea)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=fedora-logo-icon
+CPE_NAME="cpe:/o:fedoraproject:fedora:39"
+DEFAULT_HOSTNAME="fedora"
+HOME_URL="https://fedoraproject.org/sericea/"
+DOCUMENTATION_URL="https://docs.fedoraproject.org/en-US/fedora-sericea/"
+SUPPORT_URL="https://ask.fedoraproject.org/"
+BUG_REPORT_URL="https://gitlab.com/fedora/sigs/sway/SIG/-/issues"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=39
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=39
+SUPPORT_END=2024-05-14
+VARIANT="Sericea"
+VARIANT_ID=sericea

src/steps/os/os_release/fedorasilverblue

@@ -0,0 +1,22 @@
+NAME="Fedora Linux"
+VERSION="39 (Silverblue)"
+ID=fedora
+VERSION_ID=39
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f39"
+PRETTY_NAME="Fedora Linux 39 (Silverblue)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=fedora-logo-icon
+CPE_NAME="cpe:/o:fedoraproject:fedora:39"
+DEFAULT_HOSTNAME="fedora"
+HOME_URL="https://silverblue.fedoraproject.org"
+DOCUMENTATION_URL="https://docs.fedoraproject.org/en-US/fedora-silverblue/"
+SUPPORT_URL="https://ask.fedoraproject.org/"
+BUG_REPORT_URL="https://github.com/fedora-silverblue/issue-tracker/issues"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=39
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=39
+SUPPORT_END=2024-05-14
+VARIANT="Silverblue"
+VARIANT_ID=silverblue

src/steps/os/os_release/fedoraswayatomic

@@ -0,0 +1,23 @@
+NAME="Fedora Linux"
+VERSION="40.20240426.0 (Sway Atomic)"
+ID=fedora
+VERSION_ID=40
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f40"
+PRETTY_NAME="Fedora Linux 40.20240426.0 (Sway Atomic)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=fedora-logo-icon
+CPE_NAME="cpe:/o:fedoraproject:fedora:40"
+DEFAULT_HOSTNAME="fedora"
+HOME_URL="https://fedoraproject.org/atomic-desktops/sway/"
+DOCUMENTATION_URL="https://docs.fedoraproject.org/en-US/fedora-sericea/"
+SUPPORT_URL="https://ask.fedoraproject.org/"
+BUG_REPORT_URL="https://gitlab.com/fedora/sigs/sway/SIG/-/issues"
+REDHAT_BUGZILLA_PRODUCT="Fedora"
+REDHAT_BUGZILLA_PRODUCT_VERSION=40
+REDHAT_SUPPORT_PRODUCT="Fedora"
+REDHAT_SUPPORT_PRODUCT_VERSION=40
+SUPPORT_END=2025-05-13
+VARIANT="Sway Atomic"
+VARIANT_ID=sway-atomic
+OSTREE_VERSION='40.20240426.0'

src/steps/os/os_release/nobara

@@ -0,0 +1,23 @@
+NAME="Nobara Linux"
+VERSION="39 (GNOME Edition)"
+ID=nobara
+ID_LIKE="rhel centos fedora"
+VERSION_ID=39
+VERSION_CODENAME=""
+PLATFORM_ID="platform:f39"
+PRETTY_NAME="Nobara Linux 39 (GNOME Edition)"
+ANSI_COLOR="0;38;2;60;110;180"
+LOGO=nobara-logo-icon
+CPE_NAME="cpe:/o:nobaraproject:nobara:39"
+DEFAULT_HOSTNAME="nobara"
+HOME_URL="https://nobaraproject.org/"
+DOCUMENTATION_URL="https://www.nobaraproject.org/"
+SUPPORT_URL="https://www.nobaraproject.org/"
+BUG_REPORT_URL="https://gitlab.com/gloriouseggroll/nobara-images"
+REDHAT_BUGZILLA_PRODUCT="Nobara"
+REDHAT_BUGZILLA_PRODUCT_VERSION=39
+REDHAT_SUPPORT_PRODUCT="Nobara"
+REDHAT_SUPPORT_PRODUCT_VERSION=39
+SUPPORT_END=2024-05-14
+VARIANT="GNOME Edition"
+VARIANT_ID=gnome

src/steps/os/os_release/solus

@@ -0,0 +1,11 @@
+NAME="Solus"
+VERSION="4.4"
+ID="solus"
+VERSION_CODENAME=harmony
+VERSION_ID="4.4"
+PRETTY_NAME="Solus 4.4 Harmony"
+ANSI_COLOR="1;34"
+HOME_URL="https://getsol.us"
+SUPPORT_URL="https://help.getsol.us/docs/user/contributing/getting-involved"
+BUG_REPORT_URL="https://dev.getsol.us/"
+LOGO="distributor-logo-solus"

src/steps/os/os_release/vanilla

@@ -0,0 +1,12 @@
+PRETTY_NAME="VanillaOS 22.10 all"
+NAME="VanillaOS"
+VERSION_ID="22.10"
+VERSION="22.10 all"
+VERSION_CODENAME="kinetic"
+ID=ubuntu
+ID_LIKE=debian
+HOME_URL="https://github.com/vanilla-os"
+SUPPORT_URL="https://github.com/vanilla-os"
+BUG_REPORT_URL="https://github.com/vanilla-os"
+PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
+UBUNTU_CODENAME="kinetic"

src/steps/os/os_release/wolfi

@@ -0,0 +1,5 @@
+ID=wolfi
+NAME="Wolfi"
+PRETTY_NAME="Wolfi"
+VERSION_ID="20230201"
+HOME_URL="https://wolfi.dev"

src/steps/os/unix.rs

@@ -1,25 +1,30 @@
+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, path::Path};
+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 home;
 use ini::Ini;
 use tracing::debug;
 
+#[cfg(target_os = "linux")]
+use super::linux::Distribution;
 use crate::error::SkipStep;
 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::terminal::print_separator;
-#[cfg(not(any(target_os = "android", target_os = "macos")))]
-use crate::utils::require_option;
-use crate::utils::{require, PathExt};
+use crate::utils::{require, require_option, PathExt, REQUIRE_SUDO};
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 const INTEL_BREW: &str = "/usr/local/bin/brew";
@@ -86,7 +91,7 @@ impl BrewVariant {
     }
 }
 
-pub fn run_fisher(run_type: RunType) -> Result<()> {
+pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
     let fish = require("fish")?;
 
     Command::new(&fish)
@@ -109,7 +114,8 @@ pub fn run_fisher(run_type: RunType) -> Result<()> {
 
     print_separator("Fisher");
 
-    let version_str = run_type
+    let version_str = ctx
+        .run_type()
         .execute(&fish)
         .args(["-c", "fisher --version"])
         .output_checked_utf8()?
@@ -118,10 +124,13 @@ pub fn run_fisher(run_type: RunType) -> Result<()> {
 
     if version_str.starts_with("fisher version 3.") {
         // v3 - see https://github.com/topgrade-rs/topgrade/pull/37#issuecomment-1283844506
-        run_type.execute(&fish).args(["-c", "fisher"]).status_checked()
+        ctx.run_type().execute(&fish).args(["-c", "fisher"]).status_checked()
     } else {
         // v4
-        run_type.execute(&fish).args(["-c", "fisher update"]).status_checked()
+        ctx.run_type()
+            .execute(&fish)
+            .args(["-c", "fisher update"])
+            .status_checked()
     }
 }
 
@@ -136,6 +145,27 @@ pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
         .status_checked()
 }
 
+pub fn run_oh_my_bash(ctx: &ExecutionContext) -> Result<()> {
+    require("bash")?;
+    let oh_my_bash = var("OSH")
+        // default to `~/.oh-my-bash`
+        .unwrap_or(
+            HOME_DIR
+                .join(".oh-my-bash")
+                .to_str()
+                .expect("should be UTF-8 encoded")
+                .to_string(),
+        )
+        .require()?;
+
+    print_separator("oh-my-bash");
+
+    let mut update_script = oh_my_bash;
+    update_script.push_str("/tools/upgrade.sh");
+
+    ctx.run_type().execute("bash").arg(update_script).status_checked()
+}
+
 pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
     let fish = require("fish")?;
     HOME_DIR.join(".local/share/omf/pkg/omf/functions/omf.fish").require()?;
@@ -147,17 +177,18 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
     let pkgin = require("pkgin")?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
     print_separator("Pkgin");
 
-    let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
+    let mut command = ctx.run_type().execute(sudo);
     command.arg(&pkgin).arg("update");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
     command.status_checked()?;
 
-    let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
+    let mut command = ctx.run_type().execute(sudo);
     command.arg(&pkgin).arg("upgrade");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
@@ -200,7 +231,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
 pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
     let gdbus = require("gdbus")?;
     require_option(
-        env::var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
+        var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
         "Desktop doest not appear to be gnome".to_string(),
     )?;
     let output = Command::new("gdbus")
@@ -254,10 +285,15 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
     let run_type = ctx.run_type();
 
     variant.execute(run_type).arg("update").status_checked()?;
-    variant
-        .execute(run_type)
-        .args(["upgrade", "--ignore-pinned", "--formula"])
-        .status_checked()?;
+
+    let mut command = variant.execute(run_type);
+    command.args(["upgrade", "--formula"]);
+
+    if ctx.config().brew_fetch_head() {
+        command.arg("--fetch-HEAD");
+    }
+
+    command.status_checked()?;
 
     if ctx.config().cleanup() {
         variant.execute(run_type).arg("cleanup").status_checked()?;
@@ -297,6 +333,9 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
         if ctx.config().brew_cask_greedy() {
             brew_args.push("--greedy");
         }
+        if ctx.config().brew_greedy_latest() {
+            brew_args.push("--greedy-latest");
+        }
     }
 
     variant.execute(run_type).args(&brew_args).status_checked()?;
@@ -338,27 +377,11 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     debug!("nix profile: {:?}", profile_path);
     let manifest_json_path = profile_path.join("manifest.json");
 
-    let output = Command::new(&nix_env).args(["--query", "nix"]).output_checked_utf8();
-    debug!("nix-env output: {:?}", output);
-    let should_self_upgrade = output.is_ok();
-
     print_separator("Nix");
 
-    let multi_user = fs::metadata(&nix)?.uid() == 0;
-    debug!("Multi user nix: {}", multi_user);
-
-    #[cfg(target_os = "linux")]
-    {
-        use super::linux::Distribution;
-
-        if let Ok(Distribution::NixOS) = Distribution::detect() {
-            return Err(SkipStep(String::from("Nix on NixOS must be upgraded via nixos-rebuild switch")).into());
-        }
-    }
-
     #[cfg(target_os = "macos")]
     {
-        if let Ok(..) = require("darwin-rebuild") {
+        if require("darwin-rebuild").is_ok() {
             return Err(SkipStep(String::from(
                 "Nix-darwin on macOS must be upgraded via darwin-rebuild switch",
             ))
@@ -367,29 +390,144 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     }
 
     let run_type = ctx.run_type();
-
-    if should_self_upgrade {
-        if multi_user {
-            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").status_checked()?;
-        } else {
-            run_type.execute(&nix).arg("upgrade-nix").status_checked()?;
-        }
-    }
-
     run_type.execute(nix_channel).arg("--update").status_checked()?;
 
-    if std::path::Path::new(&manifest_json_path).exists() {
+    if Path::new(&manifest_json_path).exists() {
         run_type
-            .execute(&nix)
+            .execute(nix)
+            .args(nix_args())
             .arg("profile")
             .arg("upgrade")
             .arg(".*")
+            .arg("--verbose")
             .status_checked()
     } else {
-        run_type.execute(&nix_env).arg("--upgrade").status_checked()
+        let mut command = run_type.execute(nix_env);
+        command.arg("--upgrade");
+        if let Some(args) = ctx.config().nix_env_arguments() {
+            command.args(args.split_whitespace());
+        };
+        command.status_checked()
     }
 }
 
+pub fn run_nix_self_upgrade(ctx: &ExecutionContext) -> Result<()> {
+    let nix = require("nix")?;
+
+    // Should we attempt to upgrade Nix with `nix upgrade-nix`?
+    #[allow(unused_mut)]
+    let mut should_self_upgrade = cfg!(target_os = "macos");
+
+    #[cfg(target_os = "linux")]
+    {
+        // We can't use `nix upgrade-nix` on NixOS.
+        if let Ok(Distribution::NixOS) = Distribution::detect() {
+            should_self_upgrade = false;
+        }
+    }
+
+    if !should_self_upgrade {
+        return Err(SkipStep(String::from(
+            "`nix upgrade-nix` can only be used on macOS or non-NixOS Linux",
+        ))
+        .into());
+    }
+
+    if nix_profile_dir(&nix)?.is_none() {
+        return Err(SkipStep(String::from(
+            "`nix upgrade-nix` cannot be run when Nix is installed in a profile",
+        ))
+        .into());
+    }
+
+    print_separator("Nix (self-upgrade)");
+
+    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)?
+            .args(nix_args)
+            .arg("upgrade-nix")
+            .status_checked()
+    } else {
+        ctx.run_type()
+            .execute(&nix)
+            .args(nix_args)
+            .arg("upgrade-nix")
+            .status_checked()
+    }
+}
+
+/// If we try to `nix upgrade-nix` but Nix is installed with `nix profile`, we'll get a `does not
+/// appear to be part of a Nix profile` error.
+///
+/// We duplicate some of the `nix` logic here to avoid this.
+/// See: <https://github.com/NixOS/nix/blob/f0180487a0e4c0091b46cb1469c44144f5400240/src/nix/upgrade-nix.cc#L102-L139>
+///
+/// See: <https://github.com/NixOS/nix/issues/5473>
+fn nix_profile_dir(nix: &Path) -> Result<Option<PathBuf>> {
+    // NOTE: `nix` uses the location of the `nix-env` binary for this but we're using the `nix`
+    // binary; should be the same.
+    let nix_bin_dir = nix.parent();
+    if nix_bin_dir.and_then(|p| p.file_name()) != Some(OsStr::new("bin")) {
+        debug!("Nix is not installed in a `bin` directory: {nix_bin_dir:?}");
+        return Ok(None);
+    }
+
+    let nix_dir = nix_bin_dir
+        .and_then(|bin_dir| bin_dir.parent())
+        .ok_or_else(|| eyre!("Unable to find Nix install directory from Nix binary {nix:?}"))?;
+
+    debug!("Found Nix in {nix_dir:?}");
+
+    let mut profile_dir = nix_dir.to_path_buf();
+    while profile_dir.is_symlink() {
+        profile_dir = profile_dir
+            .parent()
+            .ok_or_else(|| eyre!("Path has no parent: {profile_dir:?}"))?
+            .join(
+                profile_dir
+                    .read_link()
+                    .wrap_err_with(|| format!("Failed to read symlink {profile_dir:?}"))?,
+            );
+
+        // NOTE: `nix` uses a hand-rolled canonicalize function, Rust just uses `realpath`.
+        if profile_dir
+            .canonicalize()
+            .wrap_err_with(|| format!("Failed to canonicalize {profile_dir:?}"))?
+            .components()
+            .any(|component| component == Component::Normal(OsStr::new("profiles")))
+        {
+            break;
+        }
+    }
+
+    debug!("Found Nix profile {profile_dir:?}");
+
+    let user_env = profile_dir
+        .canonicalize()
+        .wrap_err_with(|| format!("Failed to canonicalize {profile_dir:?}"))?;
+
+    Ok(
+        if user_env
+            .file_name()
+            .and_then(|name| name.to_str())
+            .map(|name| name.ends_with("user-environment"))
+            .unwrap_or(false)
+        {
+            Some(profile_dir)
+        } else {
+            None
+        },
+    )
+}
+
+fn nix_args() -> [&'static str; 2] {
+    ["--extra-experimental-features", "nix-command"]
+}
+
 pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
     let yadm = require("yadm")?;
 
@@ -398,43 +536,86 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type().execute(yadm).arg("pull").status_checked()
 }
 
-pub fn run_asdf(run_type: RunType) -> Result<()> {
+pub fn run_asdf(ctx: &ExecutionContext) -> Result<()> {
     let asdf = require("asdf")?;
 
     print_separator("asdf");
-    run_type.execute(&asdf).arg("update").status_checked_with_codes(&[42])?;
+    ctx.run_type()
+        .execute(&asdf)
+        .arg("update")
+        .status_checked_with_codes(&[42])?;
 
-    run_type
+    ctx.run_type()
         .execute(&asdf)
         .args(["plugin", "update", "--all"])
         .status_checked()
 }
 
-pub fn run_home_manager(run_type: RunType) -> Result<()> {
+pub fn run_mise(ctx: &ExecutionContext) -> Result<()> {
+    let mise = require("mise")?;
+
+    print_separator("mise");
+
+    ctx.run_type().execute(&mise).arg("upgrade").status_checked()?;
+
+    ctx.run_type()
+        .execute(&mise)
+        .args(["plugins", "update"])
+        .status_checked()
+}
+
+pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
     let home_manager = require("home-manager")?;
 
     print_separator("home-manager");
-    run_type.execute(home_manager).arg("switch").status_checked()
+
+    let mut cmd = ctx.run_type().execute(home_manager);
+    cmd.arg("switch");
+
+    if let Some(extra_args) = ctx.config().home_manager() {
+        cmd.args(extra_args);
     }
 
-pub fn run_tldr(run_type: RunType) -> Result<()> {
+    cmd.status_checked()
+}
+
+pub fn run_tldr(ctx: &ExecutionContext) -> Result<()> {
     let tldr = require("tldr")?;
 
     print_separator("TLDR");
-    run_type.execute(tldr).arg("--update").status_checked()
+    ctx.run_type().execute(tldr).arg("--update").status_checked()
 }
 
-pub fn run_pearl(run_type: RunType) -> Result<()> {
+pub fn run_pearl(ctx: &ExecutionContext) -> Result<()> {
     let pearl = require("pearl")?;
     print_separator("pearl");
 
-    run_type.execute(pearl).arg("update").status_checked()
+    ctx.run_type().execute(pearl).arg("update").status_checked()
 }
 
-pub fn run_sdkman(cleanup: bool, run_type: RunType) -> Result<()> {
+pub fn run_pyenv(ctx: &ExecutionContext) -> Result<()> {
+    let pyenv = require("pyenv")?;
+    print_separator("pyenv");
+
+    let pyenv_dir = var("PYENV_ROOT")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| HOME_DIR.join(".pyenv"));
+
+    if !pyenv_dir.exists() {
+        return Err(SkipStep("Pyenv is installed, but $PYENV_ROOT is not set correctly".to_string()).into());
+    }
+
+    if !pyenv_dir.join(".git").exists() {
+        return Err(SkipStep("pyenv is not a git repository".to_string()).into());
+    }
+
+    ctx.run_type().execute(pyenv).arg("update").status_checked()
+}
+
+pub fn run_sdkman(ctx: &ExecutionContext) -> Result<()> {
     let bash = require("bash")?;
 
-    let sdkman_init_path = env::var("SDKMAN_DIR")
+    let sdkman_init_path = var("SDKMAN_DIR")
         .map(PathBuf::from)
         .unwrap_or_else(|_| HOME_DIR.join(".sdkman"))
         .join("bin")
@@ -444,7 +625,7 @@ pub fn run_sdkman(cleanup: bool, run_type: RunType) -> Result<()> {
 
     print_separator("SDKMAN!");
 
-    let sdkman_config_path = env::var("SDKMAN_DIR")
+    let sdkman_config_path = var("SDKMAN_DIR")
         .map(PathBuf::from)
         .unwrap_or_else(|_| HOME_DIR.join(".sdkman"))
         .join("etc")
@@ -459,33 +640,33 @@ pub fn run_sdkman(cleanup: bool, run_type: RunType) -> Result<()> {
 
     if selfupdate_enabled == "true" {
         let cmd_selfupdate = format!("source {} && sdk selfupdate", &sdkman_init_path);
-        run_type
+        ctx.run_type()
             .execute(&bash)
             .args(["-c", cmd_selfupdate.as_str()])
             .status_checked()?;
     }
 
     let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
-    run_type
+    ctx.run_type()
         .execute(&bash)
         .args(["-c", cmd_update.as_str()])
         .status_checked()?;
 
     let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
-    run_type
+    ctx.run_type()
         .execute(&bash)
         .args(["-c", cmd_upgrade.as_str()])
         .status_checked()?;
 
-    if cleanup {
+    if ctx.config().cleanup() {
         let cmd_flush_archives = format!("source {} && sdk flush archives", &sdkman_init_path);
-        run_type
+        ctx.run_type()
             .execute(&bash)
             .args(["-c", cmd_flush_archives.as_str()])
             .status_checked()?;
 
         let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
-        run_type
+        ctx.run_type()
             .execute(&bash)
             .args(["-c", cmd_flush_temp.as_str()])
             .status_checked()?;
@@ -502,6 +683,24 @@ pub fn run_bun(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type().execute(bun).arg("upgrade").status_checked()
 }
 
+pub fn run_bun_packages(ctx: &ExecutionContext) -> Result<()> {
+    let bun = require("bun")?;
+
+    print_separator("Bun Packages");
+
+    let mut package_json: PathBuf = var("BUN_INSTALL")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| HOME_DIR.join(".bun"));
+    package_json.push("install/global/package.json");
+
+    if !package_json.exists() {
+        println!("No global packages installed");
+        return Ok(());
+    }
+
+    ctx.run_type().execute(bun).args(["-g", "update"]).status_checked()
+}
+
 /// Update dotfiles with `rcm(7)`.
 ///
 /// See: <https://github.com/thoughtbot/rcm>
@@ -512,6 +711,13 @@ pub fn run_rcm(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type().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()
+}
+
 pub fn reboot() -> Result<()> {
     print!("Rebooting...");
     Command::new("sudo").arg("reboot").status_checked()

src/steps/os/windows.rs

@@ -1,4 +1,3 @@
-use std::convert::TryFrom;
 use std::path::Path;
 use std::{ffi::OsStr, process::Command};
 
@@ -8,10 +7,9 @@ use tracing::debug;
 
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
 use crate::terminal::{print_separator, print_warning};
-use crate::utils::require;
-use crate::{error::SkipStep, steps::git::Repositories};
+use crate::utils::{require, which};
+use crate::{error::SkipStep, steps::git::RepoStep};
 use crate::{powershell, Step};
 
 pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {
@@ -43,33 +41,32 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("winget");
 
-    if !ctx.config().enable_winget() {
-        print_warning("Winget is disabled by default. Enable it by setting enable_winget=true in the [windows] section in the configuration.");
-        return Err(SkipStep(String::from("Winget is disabled by default")).into());
-    }
-
     ctx.run_type()
         .execute(winget)
         .args(["upgrade", "--all"])
         .status_checked()
 }
 
-pub fn run_scoop(cleanup: bool, run_type: RunType) -> Result<()> {
+pub fn run_scoop(ctx: &ExecutionContext) -> Result<()> {
     let scoop = require("scoop")?;
 
     print_separator("Scoop");
 
-    run_type.execute(&scoop).args(["update"]).status_checked()?;
-    run_type.execute(&scoop).args(["update", "*"]).status_checked()?;
+    ctx.run_type().execute(&scoop).args(["update"]).status_checked()?;
+    ctx.run_type().execute(&scoop).args(["update", "*"]).status_checked()?;
 
-    if cleanup {
-        run_type.execute(&scoop).args(["cleanup", "*"]).status_checked()?;
+    if ctx.config().cleanup() {
+        ctx.run_type().execute(&scoop).args(["cleanup", "*"]).status_checked()?;
     }
 
     Ok(())
 }
 
 pub fn update_wsl(ctx: &ExecutionContext) -> Result<()> {
+    if !is_wsl_installed()? {
+        return Err(SkipStep("WSL not installed".to_string()).into());
+    }
+
     let wsl = require("wsl")?;
 
     print_separator("Update WSL");
@@ -88,6 +85,30 @@ pub fn update_wsl(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
+/// 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
+/// installed by default.
+///
+/// If the command is installed and the user hasn't installed any Linux distros
+/// on it, command `wsl -l` would print a help message and exit with failure, we
+/// use this to check whether WSL is install or not.
+fn is_wsl_installed() -> Result<bool> {
+    if let Some(wsl) = which("wsl") {
+        // Don't use `output_checked` as an execution failure log is not wanted
+        #[allow(clippy::disallowed_methods)]
+        let output = Command::new(wsl).arg("-l").output()?;
+        let status = output.status;
+
+        if status.success() {
+            return Ok(true);
+        }
+    }
+
+    Ok(false)
+}
+
 fn get_wsl_distributions(wsl: &Path) -> Result<Vec<String>> {
     let output = Command::new(wsl).args(["--list", "-q"]).output_checked_utf8()?.stdout;
     Ok(output
@@ -101,12 +122,45 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
     let topgrade = Command::new(wsl)
         .args(["-d", dist, "bash", "-lc", "which topgrade"])
         .output_checked_utf8()
-        .map_err(|_| SkipStep(String::from("Could not find Topgrade installed in WSL")))?;
+        .map_err(|_| SkipStep(String::from("Could not find Topgrade installed in WSL")))?
+        .stdout // The normal output from `which topgrade` appends a newline, so we trim it here.
+        .trim_end()
+        .to_owned();
 
     let mut command = ctx.run_type().execute(wsl);
+
+    // The `arg` method automatically quotes its arguments.
+    // This means we can't append additional arguments to `topgrade` in WSL
+    // by calling `arg` successively.
+    //
+    // For example:
+    //
+    // ```rust
+    // command
+    //  .args(["-d", dist, "bash", "-c"])
+    //  .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'`
+    //
+    // Adding the following:
+    //
+    // ```rust
+    // command.arg("-v");
+    // ```
+    //
+    // appends the next argument like so:
+    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -c 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade' -v`
+    // which means `-v` isn't passed to `topgrade`.
+    let mut args = String::new();
+    if ctx.config().verbose() {
+        args.push_str("-v");
+    }
+
     command
         .args(["-d", dist, "bash", "-c"])
-        .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade}"));
+        .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade} {args}"));
 
     if ctx.config().yes(Step::Wsl) {
         command.arg("-y");
@@ -116,6 +170,10 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
 }
 
 pub fn run_wsl_topgrade(ctx: &ExecutionContext) -> Result<()> {
+    if !is_wsl_installed()? {
+        return Err(SkipStep("WSL not installed".to_string()).into());
+    }
+
     let wsl = require("wsl")?;
     let wsl_distributions = get_wsl_distributions(&wsl)?;
     let mut ran = false;
@@ -143,20 +201,17 @@ pub fn run_wsl_topgrade(ctx: &ExecutionContext) -> Result<()> {
 pub fn windows_update(ctx: &ExecutionContext) -> Result<()> {
     let powershell = powershell::Powershell::windows_powershell();
 
+    print_separator("Windows Update");
+
     if powershell.supports_windows_update() {
-        print_separator("Windows Update");
-        return powershell.windows_update(ctx);
+        powershell.windows_update(ctx)
+    } else {
+        print_warning(
+            "Consider installing PSWindowsUpdate as the use of Windows Update via USOClient is not supported.",
+        );
+
+        Err(SkipStep("USOClient not supported.".to_string()).into())
     }
-
-    let usoclient = require("UsoClient")?;
-
-    print_separator("Windows Update");
-    println!("Running Windows Update. Check the control panel for progress.");
-    ctx.run_type()
-        .execute(&usoclient)
-        .arg("ScanInstallWait")
-        .status_checked()?;
-    ctx.run_type().execute(&usoclient).arg("StartInstall").status_checked()
 }
 
 pub fn reboot() -> Result<()> {
@@ -165,7 +220,7 @@ pub fn reboot() -> Result<()> {
     Command::new("shutdown").args(["/R", "/T", "0"]).status_checked()
 }
 
-pub fn insert_startup_scripts(git_repos: &mut Repositories) -> Result<()> {
+pub fn insert_startup_scripts(git_repos: &mut RepoStep) -> Result<()> {
     let startup_dir = crate::WINDOWS_DIRS
         .data_dir()
         .join("Microsoft\\Windows\\Start Menu\\Programs\\Startup");

src/steps/powershell.rs

@@ -111,7 +111,7 @@ impl Powershell {
                 "-NoProfile",
                 "-Command",
                 &format!(
-                    "Import-Module PSWindowsUpdate; Install-WindowsUpdate -MicrosoftUpdate {} -Verbose",
+                    "Start-Process powershell -Verb runAs -ArgumentList 'Import-Module PSWindowsUpdate; Install-WindowsUpdate -MicrosoftUpdate {} -Verbose'",
                     if ctx.config().accept_all_windows_updates() {
                         "-AcceptAll"
                     } else {

src/steps/tmux.rs

@@ -7,7 +7,6 @@ use color_eyre::eyre::Context;
 use color_eyre::eyre::Result;
 
 use crate::command::CommandExt;
-use crate::executor::RunType;
 use crate::terminal::print_separator;
 use crate::HOME_DIR;
 use crate::{
@@ -18,12 +17,19 @@ use crate::{
 #[cfg(unix)]
 use std::os::unix::process::CommandExt as _;
 
-pub fn run_tpm(run_type: RunType) -> Result<()> {
-    let tpm = HOME_DIR.join(".tmux/plugins/tpm/bin/update_plugins").require()?;
+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"),
+    }
+    .require()?;
 
     print_separator("tmux plugins");
 
-    run_type.execute(tpm).arg("all").status_checked()
+    ctx.run_type().execute(tpm).arg("all").status_checked()
 }
 
 struct Tmux {

src/steps/toolbx.rs

@@ -52,6 +52,8 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
             topgrade_path,
             "--only",
             "system",
+            "--no-self-update",
+            "--skip-notify",
         ];
         if ctx.config().yes(Step::Toolbx) {
             args.push("--yes");

src/steps/upgrade.vim

@@ -1,3 +1,19 @@
+" AstroUpdate calls a plugin manager - Lazy as of this writing. So we check for it before
+" others. Add to init.lua:
+" updater = {
+"   skip_prompts = true,
+" },
+if exists(":AstroUpdate")
+   echo "AstroUpdate"
+   AstroUpdate
+   quitall
+endif
+
+if exists(":MasonUpdate")
+	echo "MasonUpdate"
+	MasonUpdate
+endif
+
 if exists(":NeoBundleUpdate")
     echo "NeoBundle"
     NeoBundleUpdate
@@ -38,11 +54,6 @@ if exists(":Lazy")
     Lazy! sync | qa
 endif
 
-if exists(":AstroUpdate")
-   echo "AstroUpdate"
-   AstroUpdate
-endif
-
 if exists(':PackerSync')
     echo "Packer"
     autocmd User PackerComplete quitall

src/steps/vim.rs

@@ -4,7 +4,7 @@ use crate::HOME_DIR;
 use color_eyre::eyre::Result;
 use etcetera::base_strategy::BaseStrategy;
 
-use crate::executor::{Executor, ExecutorOutput, RunType};
+use crate::executor::{Executor, ExecutorOutput};
 use crate::terminal::print_separator;
 use crate::{
     execution_context::ExecutionContext,
@@ -57,8 +57,8 @@ fn upgrade(command: &mut Executor, ctx: &ExecutionContext) -> Result<()> {
         let status = output.status;
 
         if !status.success() || ctx.config().verbose() {
-            io::stdout().write(&output.stdout).ok();
-            io::stderr().write(&output.stderr).ok();
+            io::stdout().write_all(&output.stdout).ok();
+            io::stderr().write_all(&output.stderr).ok();
         }
 
         if !status.success() {
@@ -141,10 +141,10 @@ pub fn upgrade_neovim(ctx: &ExecutionContext) -> Result<()> {
     )
 }
 
-pub fn run_voom(run_type: RunType) -> Result<()> {
+pub fn run_voom(ctx: &ExecutionContext) -> Result<()> {
     let voom = require("voom")?;
 
     print_separator("voom");
 
-    run_type.execute(voom).arg("update").status_checked()
+    ctx.run_type().execute(voom).arg("update").status_checked()
 }

src/steps/zsh.rs

@@ -8,13 +8,14 @@ use walkdir::WalkDir;
 
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
-use crate::git::Repositories;
+use crate::git::RepoStep;
 use crate::terminal::print_separator;
 use crate::utils::{require, PathExt};
 use crate::HOME_DIR;
+use crate::XDG_DIRS;
+use etcetera::base_strategy::BaseStrategy;
 
-pub fn run_zr(run_type: RunType) -> Result<()> {
+pub fn run_zr(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
 
     require("zr")?;
@@ -22,7 +23,10 @@ pub fn run_zr(run_type: RunType) -> Result<()> {
     print_separator("zr");
 
     let cmd = format!("source {} && zr --update", zshrc().display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-l", "-c", cmd.as_str()])
+        .status_checked()
 }
 
 fn zdotdir() -> PathBuf {
@@ -49,16 +53,16 @@ pub fn run_antidote(ctx: &ExecutionContext) -> Result<()> {
         .status_checked()
 }
 
-pub fn run_antibody(run_type: RunType) -> Result<()> {
+pub fn run_antibody(ctx: &ExecutionContext) -> Result<()> {
     require("zsh")?;
     let antibody = require("antibody")?;
 
     print_separator("antibody");
 
-    run_type.execute(antibody).arg("update").status_checked()
+    ctx.run_type().execute(antibody).arg("update").status_checked()
 }
 
-pub fn run_antigen(run_type: RunType) -> Result<()> {
+pub fn run_antigen(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     let zshrc = zshrc().require()?;
     env::var("ADOTDIR")
@@ -69,10 +73,13 @@ pub fn run_antigen(run_type: RunType) -> Result<()> {
     print_separator("antigen");
 
     let cmd = format!("source {} && (antigen selfupdate ; antigen update)", zshrc.display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-l", "-c", cmd.as_str()])
+        .status_checked()
 }
 
-pub fn run_zgenom(run_type: RunType) -> Result<()> {
+pub fn run_zgenom(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     let zshrc = zshrc().require()?;
     env::var("ZGEN_SOURCE")
@@ -83,10 +90,13 @@ pub fn run_zgenom(run_type: RunType) -> Result<()> {
     print_separator("zgenom");
 
     let cmd = format!("source {} && zgenom selfupdate && zgenom update", zshrc.display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-l", "-c", cmd.as_str()])
+        .status_checked()
 }
 
-pub fn run_zplug(run_type: RunType) -> Result<()> {
+pub fn run_zplug(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     zshrc().require()?;
 
@@ -97,28 +107,31 @@ pub fn run_zplug(run_type: RunType) -> Result<()> {
 
     print_separator("zplug");
 
-    run_type
+    ctx.run_type()
         .execute(zsh)
         .args(["-i", "-c", "zplug update"])
         .status_checked()
 }
 
-pub fn run_zinit(run_type: RunType) -> Result<()> {
+pub fn run_zinit(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     let zshrc = zshrc().require()?;
 
     env::var("ZINIT_HOME")
         .map(PathBuf::from)
-        .unwrap_or_else(|_| HOME_DIR.join(".zinit"))
+        .unwrap_or_else(|_| XDG_DIRS.data_dir().join("zinit"))
         .require()?;
 
     print_separator("zinit");
 
-    let cmd = format!("source {} && zinit self-update && zinit update --all", zshrc.display(),);
-    run_type.execute(zsh).args(["-i", "-c", cmd.as_str()]).status_checked()
+    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()
 }
 
-pub fn run_zi(run_type: RunType) -> Result<()> {
+pub fn run_zi(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     let zshrc = zshrc().require()?;
 
@@ -126,11 +139,11 @@ pub fn run_zi(run_type: RunType) -> Result<()> {
 
     print_separator("zi");
 
-    let cmd = format!("source {} && zi self-update && zi update --all", zshrc.display(),);
-    run_type.execute(zsh).args(["-i", "-c", &cmd]).status_checked()
+    let cmd = format!("source {} && zi self-update && zi update --all", zshrc.display());
+    ctx.run_type().execute(zsh).args(["-i", "-c", &cmd]).status_checked()
 }
 
-pub fn run_zim(run_type: RunType) -> Result<()> {
+pub fn run_zim(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     env::var("ZIM_HOME")
         .or_else(|_| {
@@ -146,7 +159,7 @@ pub fn run_zim(run_type: RunType) -> Result<()> {
 
     print_separator("zim");
 
-    run_type
+    ctx.run_type()
         .execute(zsh)
         .args(["-i", "-c", "zimfw upgrade && zimfw update"])
         .status_checked()
@@ -154,7 +167,34 @@ pub fn run_zim(run_type: RunType) -> Result<()> {
 
 pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
     require("zsh")?;
-    let oh_my_zsh = HOME_DIR.join(".oh-my-zsh").require()?;
+
+    // When updating `oh-my-zsh` on a remote machine through topgrade, the
+    // following processes will be created:
+    //
+    // SSH -> ZSH -> ZSH ($SHELL) -> topgrade -> ZSH
+    //
+    // The first ZSH process, won't source zshrc (as it is a login shell),
+    // and thus it won't have the ZSH environment variable, as a result, the
+    // children processes won't get it either, so we source the zshrc and set
+    // the ZSH variable for topgrade here.
+    if ctx.under_ssh() {
+        let res_env_zsh = Command::new("zsh")
+            .args(["-ic", "print -rn -- ${ZSH:?}"])
+            .output_checked_utf8();
+
+        // this command will fail if `ZSH` is not set
+        if let Ok(output) = res_env_zsh {
+            let env_zsh = output.stdout;
+            debug!("Oh-my-zsh: under SSH, setting ZSH={}", env_zsh);
+            env::set_var("ZSH", env_zsh);
+        }
+    }
+
+    let oh_my_zsh = env::var("ZSH")
+        .map(PathBuf::from)
+        // default to `~/.oh-my-zsh`
+        .unwrap_or(HOME_DIR.join(".oh-my-zsh"))
+        .require()?;
 
     print_separator("oh-my-zsh");
 
@@ -179,22 +219,20 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
 
     debug!("oh-my-zsh custom dir: {}", custom_dir.display());
 
-    let mut custom_repos = Repositories::new(ctx.git());
+    let mut custom_repos = RepoStep::try_new()?;
 
     for entry in WalkDir::new(custom_dir).max_depth(2) {
         let entry = entry?;
         custom_repos.insert_if_repo(entry.path());
     }
 
-    custom_repos.remove(&oh_my_zsh.to_string_lossy());
-    if !custom_repos.is_empty() {
-        println!("Pulling custom plugins and themes");
-        ctx.git().multi_pull(&custom_repos, ctx)?;
-    }
-
+    custom_repos.remove(&oh_my_zsh);
     ctx.run_type()
         .execute("zsh")
-        .env("ZSH", &oh_my_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.
+        // See this comment: https://github.com/r-darwish/topgrade/issues/569#issuecomment-736756731
+        // for more information.
         .status_checked_with_codes(&[80])
 }

src/sudo.rs

@@ -26,10 +26,10 @@ impl Sudo {
     pub fn detect() -> Option<Self> {
         which("doas")
             .map(|p| (p, SudoKind::Doas))
-            .or_else(|| which("please").map(|p| (p, SudoKind::Please)))
             .or_else(|| which("sudo").map(|p| (p, SudoKind::Sudo)))
             .or_else(|| which("gsudo").map(|p| (p, SudoKind::Gsudo)))
             .or_else(|| which("pkexec").map(|p| (p, SudoKind::Pkexec)))
+            .or_else(|| which("please").map(|p| (p, SudoKind::Please)))
             .map(|(path, kind)| Self { path, kind })
     }
 
@@ -55,12 +55,6 @@ impl Sudo {
                 // See: https://man.openbsd.org/doas
                 cmd.arg("echo");
             }
-            SudoKind::Please => {
-                // From `man please`
-                //   -w, --warm
-                //   Warm the access token and exit.
-                cmd.arg("-w");
-            }
             SudoKind::Sudo => {
                 // From `man sudo` on macOS:
                 //   -v, --validate
@@ -85,6 +79,12 @@ impl Sudo {
                 // See: https://linux.die.net/man/1/pkexec
                 cmd.arg("echo");
             }
+            SudoKind::Please => {
+                // From `man please`
+                //   -w, --warm
+                //   Warm the access token and exit.
+                cmd.arg("-w");
+            }
         }
         cmd.status_checked().wrap_err("Failed to elevate permissions")
     }
@@ -112,10 +112,10 @@ impl Sudo {
 #[strum(serialize_all = "lowercase")]
 pub enum SudoKind {
     Doas,
-    Please,
     Sudo,
     Gsudo,
     Pkexec,
+    Please,
 }
 
 impl AsRef<OsStr> for Sudo {

src/terminal.rs

@@ -1,8 +1,6 @@
 use std::cmp::{max, min};
 use std::env;
 use std::io::{self, Write};
-#[cfg(target_os = "linux")]
-use std::path::PathBuf;
 use std::process::Command;
 use std::sync::Mutex;
 use std::time::Duration;
@@ -12,7 +10,6 @@ use color_eyre::eyre;
 use color_eyre::eyre::Context;
 use console::{style, Key, Term};
 use lazy_static::lazy_static;
-#[cfg(target_os = "macos")]
 use notify_rust::{Notification, Timeout};
 use tracing::{debug, error};
 #[cfg(windows)]
@@ -20,10 +17,7 @@ use which_crate::which;
 
 use crate::command::CommandExt;
 use crate::report::StepResult;
-#[cfg(target_os = "linux")]
-use crate::terminal;
-#[cfg(target_os = "linux")]
-use crate::utils::which;
+
 lazy_static! {
     static ref TERMINAL: Mutex<Terminal> = Mutex::new(Terminal::new());
 }
@@ -49,8 +43,6 @@ struct Terminal {
     set_title: bool,
     display_time: bool,
     desktop_notification: bool,
-    #[cfg(target_os = "linux")]
-    notify_send: Option<PathBuf>,
 }
 
 impl Terminal {
@@ -65,8 +57,6 @@ impl Terminal {
             set_title: true,
             display_time: true,
             desktop_notification: false,
-            #[cfg(target_os = "linux")]
-            notify_send: which("notify-send"),
         }
     }
 
@@ -82,13 +72,11 @@ impl Terminal {
         self.display_time = display_time
     }
 
-    #[allow(unused_variables)]
     fn notify_desktop<P: AsRef<str>>(&self, message: P, timeout: Option<Duration>) {
         debug!("Desktop notification: {}", message.as_ref());
-        cfg_if::cfg_if! {
-            if #[cfg(target_os = "macos")] {
         let mut notification = Notification::new();
-                notification.summary("Topgrade")
+        notification
+            .summary("Topgrade")
             .body(message.as_ref())
             .appname("topgrade");
 
@@ -96,21 +84,6 @@ impl Terminal {
             notification.timeout(Timeout::Milliseconds(timeout.as_millis() as u32));
         }
         notification.show().ok();
-            } else if #[cfg(target_os = "linux")] {
-                if let Some(ns) = self.notify_send.as_ref() {
-                    let mut command = Command::new(ns);
-                    if let Some(timeout) = timeout {
-                        command.arg("-t");
-                        command.arg(format!("{}", timeout.as_millis()));
-                    }
-                    command.args(["-a", "Topgrade", "Topgrade"]);
-                    command.arg(message.as_ref());
-                    if let Err(err) = command.output_checked() {
-                        terminal::print_warning("Sending notification failed with {err:?}");
-                    }
-                }
-            }
-        }
     }
 
     fn print_separator<P: AsRef<str>>(&mut self, message: P) {
@@ -345,8 +318,3 @@ pub fn notify_desktop<P: AsRef<str>>(message: P, timeout: Option<Duration>) {
 pub fn display_time(display_time: bool) {
     TERMINAL.lock().unwrap().display_time(display_time);
 }
-
-#[cfg(target_os = "linux")]
-pub fn supports_notify_send() -> bool {
-    TERMINAL.lock().unwrap().notify_send.is_some()
-}

src/utils.rs

@@ -1,11 +1,21 @@
-use crate::error::SkipStep;
-use color_eyre::eyre::Result;
-
 use std::env;
 use std::ffi::OsStr;
 use std::fmt::Debug;
 use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use color_eyre::eyre::Result;
+
 use tracing::{debug, error};
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::reload::{Handle, Layer};
+use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::{fmt, Registry};
+use tracing_subscriber::{registry, EnvFilter};
+
+use crate::command::CommandExt;
+use crate::config::DEFAULT_LOG_LEVEL;
+use crate::error::SkipStep;
 
 pub trait PathExt
 where
@@ -101,54 +111,162 @@ pub fn require_option<T>(option: Option<T>, cause: String) -> Result<T> {
     }
 }
 
-/* sys-info-rs
- *
- * Copyright (c) 2015 Siyu Wang
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+pub fn string_prepend_str(string: &mut String, s: &str) {
+    let mut new_string = String::with_capacity(string.len() + s.len());
+    new_string.push_str(s);
+    new_string.push_str(string);
+    *string = new_string;
+}
+
 #[cfg(target_family = "unix")]
 pub fn hostname() -> Result<String> {
-    use std::ffi;
-    extern crate libc;
-
-    unsafe {
-        let buf_size = libc::sysconf(libc::_SC_HOST_NAME_MAX) as usize;
-        let mut buf = Vec::<u8>::with_capacity(buf_size + 1);
-
-        if libc::gethostname(buf.as_mut_ptr() as *mut libc::c_char, buf_size) < 0 {
-            return Err(SkipStep(format!("Failed to get hostname: {}", std::io::Error::last_os_error())).into());
-        }
-        let hostname_len = libc::strnlen(buf.as_ptr() as *const libc::c_char, buf_size);
-        buf.set_len(hostname_len);
-
-        Ok(ffi::CString::new(buf).unwrap().into_string().unwrap())
+    match nix::unistd::gethostname() {
+        Ok(os_str) => Ok(os_str
+            .into_string()
+            .map_err(|_| SkipStep("Failed to get a UTF-8 encoded hostname".into()))?),
+        Err(e) => Err(e.into()),
     }
 }
 
 #[cfg(target_family = "windows")]
 pub fn hostname() -> Result<String> {
-    use crate::command::CommandExt;
-    use std::process::Command;
-
     Command::new("hostname")
         .output_checked_utf8()
         .map_err(|err| SkipStep(format!("Failed to get hostname: {err}")).into())
         .map(|output| output.stdout.trim().to_owned())
 }
+
+pub mod merge_strategies {
+    use merge::Merge;
+
+    use crate::config::Commands;
+
+    /// Prepends right to left (both Option<Vec<T>>)
+    pub fn vec_prepend_opt<T>(left: &mut Option<Vec<T>>, right: Option<Vec<T>>) {
+        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));
+            }
+        } else {
+            *left = right;
+        }
+    }
+
+    /// Appends an Option<String> to another Option<String>
+    pub fn string_append_opt(left: &mut Option<String>, right: Option<String>) {
+        if let Some(left_str) = left {
+            if let Some(right_str) = right {
+                left_str.push(' ');
+                left_str.push_str(&right_str);
+            }
+        } else {
+            *left = right;
+        }
+    }
+
+    pub fn inner_merge_opt<T>(left: &mut Option<T>, right: Option<T>)
+    where
+        T: Merge,
+    {
+        if let Some(ref mut left_inner) = left {
+            if let Some(right_inner) = right {
+                left_inner.merge(right_inner);
+            }
+        } else {
+            *left = right;
+        }
+    }
+
+    pub fn commands_merge_opt(left: &mut Option<Commands>, right: Option<Commands>) {
+        if let Some(ref mut left_inner) = left {
+            if let Some(right_inner) = right {
+                left_inner.extend(right_inner);
+            }
+        } else {
+            *left = right;
+        }
+    }
+}
+
+// Skip causes
+// TODO: Put them in a better place when we have more of them
+pub const REQUIRE_SUDO: &str = "Require sudo or counterpart but not found, skip";
+
+/// 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
+/// execute it, the Microsoft App Store will be launched instead of a Python
+/// shell.
+///
+/// We do this check through `python -V`, a shim will just give `Python` with
+/// no version number.
+pub fn check_is_python_2_or_shim(python: PathBuf) -> Result<PathBuf> {
+    let output = Command::new(&python).arg("-V").output_checked_utf8()?;
+    // "Python x.x.x\n"
+    let stdout = output.stdout;
+    // ["Python"] or ["Python", "x.x.x"], the newline char is trimmed.
+    let mut split = stdout.split_whitespace();
+
+    if let Some(version) = split.nth(1) {
+        let major_version = version
+            .split('.')
+            .next()
+            .expect("Should have a major version number")
+            .parse::<u32>()
+            .expect("Major version should be a valid number");
+        if major_version == 2 {
+            return Err(SkipStep(format!("{} is a Python 2, skip.", python.display())).into());
+        }
+    } else {
+        // No version number, is a shim
+        return Err(SkipStep(format!("{} is a Python shim, skip.", python.display())).into());
+    }
+
+    Ok(python)
+}
+
+/// Set up the tracing logger
+///
+/// # Return value
+/// A reload handle will be returned so that we can change the log level at
+/// runtime.
+pub fn install_tracing(filter_directives: &str) -> Result<Handle<EnvFilter, Registry>> {
+    let env_filter = EnvFilter::try_new(filter_directives)
+        .or_else(|_| EnvFilter::try_from_default_env())
+        .or_else(|_| EnvFilter::try_new(DEFAULT_LOG_LEVEL))?;
+
+    let fmt_layer = fmt::layer().with_target(false).without_time();
+
+    let (filter, reload_handle) = Layer::new(env_filter);
+
+    registry().with(filter).with(fmt_layer).init();
+
+    Ok(reload_handle)
+}
+
+/// Update the tracing logger with new `filter_directives`.
+pub fn update_tracing(reload_handle: &Handle<EnvFilter, Registry>, filter_directives: &str) -> Result<()> {
+    let new = EnvFilter::try_new(filter_directives)
+        .or_else(|_| EnvFilter::try_from_default_env())
+        .or_else(|_| EnvFilter::try_new(DEFAULT_LOG_LEVEL))?;
+    reload_handle.modify(|old| *old = new)?;
+
+    Ok(())
+}
+
+/// Set up the error handler crate
+pub fn install_color_eyre() -> Result<()> {
+    color_eyre::config::HookBuilder::new()
+        // Don't display the backtrace reminder by default:
+        //   Backtrace omitted. Run with RUST_BACKTRACE=1 environment variable to display it.
+        //   Run with RUST_BACKTRACE=full to include source snippets.
+        .display_env_section(false)
+        // Display location information by default:
+        //   Location:
+        //      src/steps.rs:92
+        .display_location_section(true)
+        .install()
+}