v12 Cargo files update (#441)

Revert "fix: fix mist (#464)"

This reverts commit 282e336ac4.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,32 +2,79 @@
 name: Bug report
 about: Topgrade is misbehaving
 title: ''
-labels: ''
+labels: '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
+
+## 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/PULL_REQUEST_TEMPLATE.md

@@ -1,6 +1,7 @@
 ## Standards checklist:
 
 - [ ] The PR title is descriptive.
+- [ ] I have read `CONTRIBUTING.md`
 - [ ] The code compiles (`cargo build`)
 - [ ] The code passes rustfmt (`cargo fmt`)
 - [ ] The code passes clippy (`cargo clippy`)

.github/workflows/check-and-lint.yaml

@@ -4,52 +4,88 @@ on:
     branches:
       - main
 
+name: CI
 
-name: Check and Lint
+env:
+  RUST_VER: '1.68.0'
+  CROSS_VER: '0.2.5'
+  CARGO_NET_RETRY: 3
 
 jobs:
-  check:
-    name: Check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
-
   fmt:
     name: Rustfmt
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - name: Checkout code
+        uses: actions/checkout@v3
 
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: '${{ env.RUST_VER }}'
+          components: rustfmt
+
+      - name: Run cargo fmt
+        env:
+          TERM: xterm-256color
+        run: |
+          cargo fmt --all -- --check
+
+  main:
+    needs: fmt
+    name: ${{ matrix.target_name }} (check, clippy)
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: x86_64-linux-android
+            target_name: Android
+            use_cross: true
+            os: ubuntu-20.04
+
+          - target: x86_64-unknown-freebsd
+            target_name: FreeBSD
+            use_cross: true
+            os: ubuntu-20.04
+
+          - target: x86_64-unknown-linux-gnu
+            target_name: Linux
+            os: ubuntu-20.04
+
+          - target: x86_64-apple-darwin
+            target_name: macOS
+            os: macos-11
+
+          - target: x86_64-unknown-netbsd
+            target_name: NetBSD
+            use_cross: true
+            os: ubuntu-20.04
+
+          - target: x86_64-pc-windows-msvc
+            target_name: Windows
+            os: windows-2019
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: stable
+          toolchain: '${{ env.RUST_VER }}'
           components: clippy
-          override: true
-      - uses: actions-rs/clippy-check@v1
+
+      - name: Setup Rust Cache
+        uses: Swatinem/rust-cache@v2
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
-          name: Clippy Output
+          prefix-key: ${{ matrix.target }}
+
+      - name: Setup cross
+        if: matrix.use_cross == true
+        run: curl -fL --retry 3 https://github.com/cross-rs/cross/releases/download/v${{ env.CROSS_VER }}/cross-x86_64-unknown-linux-musl.tar.gz | tar vxz -C /usr/local/bin
+
+      - name: Run cargo check
+        run: ${{ matrix.use_cross == true && 'cross' || 'cargo' }} check --locked --target ${{ matrix.target }}
+
+      - name: Run cargo clippy
+        run: ${{ matrix.use_cross == true && 'cross' || 'cargo' }} clippy --locked --target ${{ matrix.target }} --all-features -- -D warnings

.github/workflows/crates-publish.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2022-08-03
+          toolchain: stable
           override: true
 
   publish:

.github/workflows/release-cross.yml

@@ -19,7 +19,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.57.0
+          toolchain: stable
           profile: minimal
           default: true
           override: true

.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.57.0
+          toolchain: stable
           profile: minimal
           override: true
           components: rustfmt, clippy

.github/workflows/test.yaml

@@ -57,3 +57,10 @@ jobs:
           # token: ${{ secrets.CODECOV_TOKEN }}
           files: ./lcov.info
           fail_ci_if_error: true
+      - name: Test creation of config file
+        run: |
+          CONFIG_PATH=~/.config/topgrade.toml;
+          if [ -f "$CONFIG_PATH" ]; then rm $CONFIG_PATH; fi
+          cargo build; 
+          ./target/debug/topgrade --dry-run --only system;
+          stat $CONFIG_PATH;

.github/workflows/update_homebrew.yml

@@ -0,0 +1,38 @@
+name: Publish to Homebrew
+
+on:
+  # workflow_run:
+  #   workflows: ["Check SemVer compliance"]
+  #   types:
+  #     - completed
+  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  homebrew-publish:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Set up Homebrew
+      id: set-up-homebrew
+      uses: Homebrew/actions/setup-homebrew@master
+    - name: Cache Homebrew Bundler RubyGems
+      id: cache
+      uses: actions/cache@v1
+      with:
+        path: ${{ steps.set-up-homebrew.outputs.gems-path }}
+        key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+        restore-keys: ${{ runner.os }}-rubygems-
+
+    - name: Install Homebrew Bundler RubyGems
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: brew install-bundler-gems
+    - name: Bump formulae
+      uses: Homebrew/actions/bump-formulae@master
+      with:
+        # Custom GitHub access token with only the 'public_repo' scope enabled
+        token: ${{secrets.HOMEBREW_ACCESS_TOKEN}}
+        # Bump only these formulae if outdated
+        formulae: |
+          topgrade

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+open an issue on GitHub .
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1,134 @@
+## 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)
+
+## 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.
+
+## 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

@@ -3,9 +3,9 @@ name = "topgrade"
 description = "Upgrade all the things"
 categories = ["os"]
 keywords = ["upgrade", "update"]
-license-file = "LICENSE"
+license = "GPL-3.0"
 repository = "https://github.com/topgrade-rs/topgrade"
-version = "10.1.0"
+version = "12.0.0"
 authors = ["Roey Darwish Dror <roey.ghost@gmail.com>", "Thomas Schönauer <t.schoenauer@hgs-wt.at>"]
 exclude = ["doc/screenshot.gif"]
 edition = "2021"
@@ -21,35 +21,47 @@ path = "src/main.rs"
 
 [dependencies]
 home = "~0.5"
-directories = "~4.0"
+etcetera = "~0.8"
+once_cell = "~1.17"
 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"] }
-log = "~0.4"
+clap_complete = "~3.1"
+clap_mangen = "~0.1"
 walkdir = "~2.3"
 console = "~0.15"
 lazy_static = "~1.4"
 chrono = "~0.4"
-pretty_env_logger = "~0.4"
 glob = "~0.3"
 strum = { version = "~0.24", features = ["derive"] }
 thiserror = "~1.0"
-anyhow = "~1.0"
 tempfile = "~3.2"
 cfg-if = "~1.0"
-tokio = { version = "~1.5", features = ["process", "rt-multi-thread"] }
+tokio = { version = "~1.18", features = ["process", "rt-multi-thread"] }
 futures = "~0.3"
-regex = "~1.5"
-sys-info = "~0.9"
+regex = "~1.7"
 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"] }
+merge = "~0.1"
+regex-split = "~0.1"
+notify-rust = "~4.8"
 
-[target.'cfg(target_os = "macos")'.dependencies]
-notify-rust = "~4.5"
+[package.metadata.generate-rpm]
+assets = [{source = "target/release/topgrade", dest="/usr/bin/topgrade"}]
+
+[package.metadata.generate-rpm.requires]
+git = "*"
+
+[package.metadata.deb]
+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"] }

README.md

@@ -1,16 +1,21 @@
 <div align="center">
-  <img alt="Topgrade" src="doc/topgrade.png" width="850px">
+  <h1>
+    <img alt="Topgrade" src="doc/topgrade_transparent.png" width="850px">
+  </h1>
   
-  <!--
-  <a href="https://github.com/topgrade-rs/topgrade/releases"><img alt="GitHub Release" src="https://img.shields.io/github/release/r-darwish/topgrade.svg"></a>
+  <a href="https://github.com/topgrade-rs/topgrade/releases"><img alt="GitHub Release" src="https://img.shields.io/github/release/topgrade-rs/topgrade.svg"></a>
   <a href="https://crates.io/crates/topgrade"><img alt="crates.io" src="https://img.shields.io/crates/v/topgrade.svg"></a>
   <a href="https://aur.archlinux.org/packages/topgrade"><img alt="AUR" src="https://img.shields.io/aur/version/topgrade.svg"></a>
   <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">
 </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
 
 > **Note**
@@ -22,48 +27,72 @@ To remedy this, **Topgrade** detects which tools you use and runs the appropriat
 
 ## Installation
 
-- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade) package.
-- NixOS: _topgrade_ package in `nixpkgs`.
-- macOS: [Homebrew](https://formulae.brew.sh/formula/topgrade) or [MacPorts](https://ports.macports.org/port/topgrade/).
+[![Packaging status](https://repology.org/badge/vertical-allrepos/topgrade.svg)](https://repology.org/project/topgrade/versions)
 
-Other systems users can either use `cargo install` or use the compiled binaries from the release page.
+- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade)
+- NixOS: [Nixpkgs](https://search.nixos.org/packages?show=topgrade)
+- Void Linux: [XBPS](https://voidlinux.org/packages/?arch=x86_64&q=topgrade)
+- macOS: [Homebrew](https://formulae.brew.sh/formula/topgrade) or [MacPorts](https://ports.macports.org/port/topgrade/)
+- Windows: [Scoop](https://github.com/ScoopInstaller/Main/blob/master/bucket/topgrade.json)
+
+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.51 or above.
-
-## Documentation
-
-> **Warning**
-> Work in Progress
-
-You can visit the documentation at [topgrade-rs.github.io](https://topgrade-rs.github.io/) .
+Topgrade requires Rust 1.60 or above.
 
 ## Usage
 
 Just run `topgrade`.
-See [the documentation](https://topgrade-rs.github.io/) for the list of things Topgrade supports.
 
-## Customization
+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.
 
-### Configuration path
+### Configuration Path
 
-The configuration should be placed in the following paths depending by 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
+
+Custom commands can be defined in the config file which can be run before, during, or after the inbuilt commands, as required.
+By default, the custom commands are run using a new shell according to the `$SHELL` environment variable on unix (falls back to `sh`) or `pwsh` on windows (falls back to `powershell`).
+
+On unix, if you want to run your command using an interactive shell, for example to source your shell's rc files, you can add `-i` at the start of your custom command.
+But note that this requires the command to exit the shell correctly or else the shell will hang indefinitely.
+
+## Remote Execution
+
+You can specify a key called `remote_topgrades` in the configuration file.
+This key should contain a list of hostnames that have Topgrade installed on them.
+Topgrade will use `ssh` to run `topgrade` on remote hosts before acting locally.
+To limit the execution only to specific hosts use the `--remote-host-limit` parameter.
 
 ## Contribution
 
 ### Problems or missing features?
 
-Open a new Issue describing your problem and if possible with a possible solution.
+Open a new issue describing your problem and if possible provide a solution.
 
 ### Missing a feature or found an unsupported tool/distro?
 
 Just let us now what you are missing by opening an issue.
-For tools please open an Issue describing the tool, which platforms it supports and if possible, give us an example of its usage.
+For tools, please open an issue describing the tool, which platforms it supports and if possible, give us an example of its usage.
 
 ### Want to contribute to the code?
 
@@ -71,18 +100,9 @@ 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.
-- Make a Pull Request to the dev branch for new features or to the bug-fixes branch for bug fixes.
+See [CONTRIBUTING.md](https://github.com/topgrade-rs/topgrade/blob/master/CONTRIBUTING.md)
 
-## Remote execution
-
-You can specify a key called `remote_topgrades` in the configuration file.
-This key should contain a list of hostnames that have Topgrade installed on them.
-Topgrade will use `ssh` to run `topgrade` on remote hosts before acting locally.
-To limit the execution only to specific hosts use the `--remote-host-limit` parameter.
-
-## ToDo
+## Roadmap
 
 - [ ] Add a proper testing framework to the code base.
 - [ ] Add unit tests for package managers.

SECURITY.md

@@ -0,0 +1,11 @@
+# Security Policy
+
+## Supported Versions
+
+We only support the latest major version and each subversion.
+
+| Version  | Supported          |
+| -------- | ------------------ |
+| 10.0.x   | :white_check_mark: |
+| < 10.0   | :x:                |
+

clippy.toml

@@ -0,0 +1,5 @@
+disallowed-methods = [
+    { path = "std::process::Command::output", reason = "Use `output_checked[_with][_utf8]`" },
+    { path = "std::process::Command::spawn", reason = "Use `spawn_checked`" },
+    { path = "std::process::Command::status", reason = "Use `status_checked`" },
+]

config.example.toml

@@ -1,3 +1,10 @@
+# Include any additional configuration file(s)
+# [include] sections are processed in the order you write them
+# Files in $CONFIG_DIR/topgrade/topgrade.d/ are automatically included at the beginning of this file
+[include]
+#paths = ["/etc/topgrade.toml"]
+
+[misc]
 # Don't ask for confirmations
 #assume_yes = true
 
@@ -13,6 +20,13 @@
 # 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
 
@@ -40,6 +54,9 @@
 # Skip sending a notification at the end of a run
 #skip_notify = true
 
+# 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)
+#no_self_update = true
+
 [git]
 #max_concurrency = 5
 # Additional git repositories to pull
@@ -64,18 +81,22 @@
 # 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, trizen, aura, paru, yay, pikaur, pacman, pamac.
+# 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 = ""
@@ -84,12 +105,22 @@
 #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"
+
+[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
 
 [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
 # to upgrade it. Use this only if you installed Topgrade by using a package

src/command.rs

@@ -0,0 +1,244 @@
+//! Utilities for running commands and providing user-friendly error messages.
+
+use std::fmt::Display;
+use std::process::Child;
+use std::process::{Command, ExitStatus, Output};
+
+use color_eyre::eyre;
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Context;
+
+use crate::error::TopgradeError;
+
+/// Like [`Output`], but UTF-8 decoded.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Utf8Output {
+    pub status: ExitStatus,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+impl TryFrom<Output> for Utf8Output {
+    type Error = eyre::Error;
+
+    fn try_from(Output { status, stdout, stderr }: Output) -> Result<Self, Self::Error> {
+        let stdout = String::from_utf8(stdout).map_err(|err| {
+            eyre!(
+                "Stdout contained invalid UTF-8: {}",
+                String::from_utf8_lossy(err.as_bytes())
+            )
+        })?;
+        let stderr = String::from_utf8(stderr).map_err(|err| {
+            eyre!(
+                "Stderr contained invalid UTF-8: {}",
+                String::from_utf8_lossy(err.as_bytes())
+            )
+        })?;
+
+        Ok(Utf8Output { status, stdout, stderr })
+    }
+}
+
+impl TryFrom<&Output> for Utf8Output {
+    type Error = eyre::Error;
+
+    fn try_from(Output { status, stdout, stderr }: &Output) -> Result<Self, Self::Error> {
+        let stdout = String::from_utf8(stdout.to_vec()).map_err(|err| {
+            eyre!(
+                "Stdout contained invalid UTF-8: {}",
+                String::from_utf8_lossy(err.as_bytes())
+            )
+        })?;
+        let stderr = String::from_utf8(stderr.to_vec()).map_err(|err| {
+            eyre!(
+                "Stderr contained invalid UTF-8: {}",
+                String::from_utf8_lossy(err.as_bytes())
+            )
+        })?;
+        let status = *status;
+
+        Ok(Utf8Output { status, stdout, stderr })
+    }
+}
+
+impl Display for Utf8Output {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.stdout)
+    }
+}
+
+/// Extension trait for [`Command`], adding helpers to gather output while checking the exit
+/// status.
+///
+/// These also give us significantly better error messages, which include:
+///
+/// 1. The command and arguments that were executed, escaped with familiar `sh` syntax.
+/// 2. The exit status of the command or the signal that killed it.
+/// 3. If we were capturing the output of the command, rather than forwarding it to the user's
+///    stdout/stderr, the error message includes the command's stdout and stderr output.
+///
+/// Additionally, executing commands with these methods will log the command at debug-level,
+/// useful when gathering error reports.
+pub trait CommandExt {
+    type Child;
+
+    /// Like [`Command::output`], but checks the exit status and provides nice error messages.
+    ///
+    /// Returns an `Err` if the command failed to execute or returned a non-zero exit code.
+    #[track_caller]
+    fn output_checked(&mut self) -> eyre::Result<Output> {
+        self.output_checked_with(|output: &Output| if output.status.success() { Ok(()) } else { Err(()) })
+    }
+
+    /// Like [`output_checked`], but also decodes Stdout and Stderr as UTF-8.
+    ///
+    /// Returns an `Err` if the command failed to execute, returned a non-zero exit code, or if the
+    /// output contains invalid UTF-8.
+    #[track_caller]
+    fn output_checked_utf8(&mut self) -> eyre::Result<Utf8Output> {
+        let output = self.output_checked()?;
+        output.try_into()
+    }
+
+    /// Like [`output_checked`] but a closure determines if the command failed instead of
+    /// [`ExitStatus::success`].
+    ///
+    /// Returns an `Err` if the command failed to execute or if `succeeded` returns an `Err`.
+    /// (This lets the caller substitute their own notion of "success" instead of assuming
+    /// non-zero exit codes indicate success.)
+    #[track_caller]
+    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> eyre::Result<Output>;
+
+    /// Like [`output_checked_with`], but also decodes Stdout and Stderr as UTF-8.
+    ///
+    /// Returns an `Err` if the command failed to execute, if `succeeded` returns an `Err`, or if
+    /// the output contains invalid UTF-8.
+    #[track_caller]
+    fn output_checked_with_utf8(
+        &mut self,
+        succeeded: impl Fn(&Utf8Output) -> Result<(), ()>,
+    ) -> eyre::Result<Utf8Output> {
+        // This decodes the Stdout and Stderr as UTF-8 twice...
+        let output =
+            self.output_checked_with(|output| output.try_into().map_err(|_| ()).and_then(|o| succeeded(&o)))?;
+        output.try_into()
+    }
+
+    /// Like [`Command::status`], but gives a nice error message if the status is unsuccessful
+    /// rather than returning the [`ExitStatus`].
+    ///
+    /// Returns `Ok` if the command executes successfully, returns `Err` if the command fails to
+    /// execute or returns a non-zero exit code.
+    #[track_caller]
+    fn status_checked(&mut self) -> eyre::Result<()> {
+        self.status_checked_with(|status| if status.success() { Ok(()) } else { Err(()) })
+    }
+
+    /// Like [`status_checked`], but gives a nice error message if the status is unsuccessful
+    /// rather than returning the [`ExitStatus`].
+    ///
+    /// Returns `Ok` if the command executes successfully, returns `Err` if the command fails to
+    /// execute or if `succeeded` returns an `Err`.
+    /// (This lets the caller substitute their own notion of "success" instead of assuming
+    /// non-zero exit codes indicate success.)
+    #[track_caller]
+    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> eyre::Result<()>;
+
+    /// Like [`Command::spawn`], but gives a nice error message if the command fails to
+    /// execute.
+    #[track_caller]
+    fn spawn_checked(&mut self) -> eyre::Result<Self::Child>;
+}
+
+impl CommandExt for Command {
+    type Child = Child;
+
+    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> eyre::Result<Output> {
+        let command = log(self);
+
+        // This is where we implement `output_checked`, which is what we prefer to use instead of
+        // `output`, so we allow `Command::output` here.
+        #[allow(clippy::disallowed_methods)]
+        let output = self
+            .output()
+            .with_context(|| format!("Failed to execute `{command}`"))?;
+
+        if succeeded(&output).is_ok() {
+            Ok(output)
+        } else {
+            let mut message = format!("Command failed: `{command}`");
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            let stdout = String::from_utf8_lossy(&output.stdout);
+
+            let stdout_trimmed = stdout.trim();
+            if !stdout_trimmed.is_empty() {
+                message.push_str(&format!("\n\nStdout:\n{stdout_trimmed}"));
+            }
+            let stderr_trimmed = stderr.trim();
+            if !stderr_trimmed.is_empty() {
+                message.push_str(&format!("\n\nStderr:\n{stderr_trimmed}"));
+            }
+
+            let (program, _) = get_program_and_args(self);
+            let err = TopgradeError::ProcessFailedWithOutput(program, output.status, stderr.into_owned());
+
+            let ret = Err(err).with_context(|| message);
+            tracing::debug!("Command failed: {ret:?}");
+            ret
+        }
+    }
+
+    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> eyre::Result<()> {
+        let command = log(self);
+        let message = format!("Failed to execute `{command}`");
+
+        // This is where we implement `status_checked`, which is what we prefer to use instead of
+        // `status`, so we allow `Command::status` here.
+        #[allow(clippy::disallowed_methods)]
+        let status = self.status().with_context(|| message.clone())?;
+
+        if succeeded(status).is_ok() {
+            Ok(())
+        } else {
+            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:?}");
+            ret
+        }
+    }
+
+    fn spawn_checked(&mut self) -> eyre::Result<Self::Child> {
+        let command = log(self);
+        let message = format!("Failed to execute `{command}`");
+
+        // This is where we implement `spawn_checked`, which is what we prefer to use instead of
+        // `spawn`, so we allow `Command::spawn` here.
+        #[allow(clippy::disallowed_methods)]
+        {
+            self.spawn().with_context(|| message.clone())
+        }
+    }
+}
+
+fn get_program_and_args(cmd: &Command) -> (String, String) {
+    // We're not doing anything weird with commands that are invalid UTF-8 so this is fine.
+    let program = cmd.get_program().to_string_lossy().into_owned();
+    let args = shell_words::join(cmd.get_args().map(|arg| arg.to_string_lossy()));
+    (program, args)
+}
+
+fn format_program_and_args(cmd: &Command) -> String {
+    let (program, args) = get_program_and_args(cmd);
+    if args.is_empty() {
+        program
+    } else {
+        format!("{program} {args}")
+    }
+}
+
+fn log(cmd: &Command) -> String {
+    let command = format_program_and_args(cmd);
+    tracing::debug!("Executing command `{command}`");
+    command
+}

src/ctrlc/windows.rs

@@ -16,6 +16,6 @@ extern "system" fn handler(ctrl_type: DWORD) -> BOOL {
 
 pub fn set_handler() {
     if 0 == unsafe { SetConsoleCtrlHandler(Some(handler), TRUE) } {
-        log::error!("Cannot set a control C handler")
+        tracing::error!("Cannot set a control C handler")
     }
 }

src/error.rs

@@ -4,15 +4,11 @@ use thiserror::Error;
 
 #[derive(Error, Debug, PartialEq, Eq)]
 pub enum TopgradeError {
-    #[error("{0}")]
-    ProcessFailed(ExitStatus),
+    #[error("`{0}` failed: {1}")]
+    ProcessFailed(String, ExitStatus),
 
-    #[error("{0}: {1}")]
-    ProcessFailedWithOutput(ExitStatus, String),
-
-    #[error("Sudo is required for this step")]
-    #[allow(dead_code)]
-    SudoRequired,
+    #[error("`{0}` failed: {1}")]
+    ProcessFailedWithOutput(String, ExitStatus, String),
 
     #[error("Unknown Linux Distribution")]
     #[cfg(target_os = "linux")]

src/execution_context.rs

@@ -1,51 +1,38 @@
 #![allow(dead_code)]
 use crate::executor::RunType;
 use crate::git::Git;
-use crate::utils::require_option;
+use crate::sudo::Sudo;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::{config::Config, executor::Executor};
-use anyhow::Result;
-use directories::BaseDirs;
-use std::path::{Path, PathBuf};
+use color_eyre::eyre::Result;
+use std::path::Path;
+use std::sync::Mutex;
 
 pub struct ExecutionContext<'a> {
     run_type: RunType,
-    sudo: &'a Option<PathBuf>,
+    sudo: Option<Sudo>,
     git: &'a Git,
     config: &'a Config,
-    base_dirs: &'a BaseDirs,
+    /// 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>>,
 }
 
 impl<'a> ExecutionContext<'a> {
-    pub fn new(
-        run_type: RunType,
-        sudo: &'a Option<PathBuf>,
-        git: &'a Git,
-        config: &'a Config,
-        base_dirs: &'a BaseDirs,
-    ) -> ExecutionContext<'a> {
-        ExecutionContext {
+    pub fn new(run_type: RunType, sudo: Option<Sudo>, git: &'a Git, config: &'a Config) -> Self {
+        Self {
             run_type,
             sudo,
             git,
             config,
-            base_dirs,
+            tmux_session: Mutex::new(None),
         }
     }
 
     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 mut cmd = self.run_type.execute(&sudo);
-
-        if sudo.ends_with("sudo") {
-            cmd.arg("--preserve-env=DIFFPROG");
-        }
-
-        if interactive {
-            cmd.arg("-i");
-        }
-
-        cmd.arg(command);
-        Ok(cmd)
+        let sudo = require_option(self.sudo.as_ref(), REQUIRE_SUDO.to_string())?;
+        Ok(sudo.execute_elevated(self, command, interactive))
     }
 
     pub fn run_type(&self) -> RunType {
@@ -56,15 +43,19 @@ impl<'a> ExecutionContext<'a> {
         self.git
     }
 
-    pub fn sudo(&self) -> &Option<PathBuf> {
-        self.sudo
+    pub fn sudo(&self) -> &Option<Sudo> {
+        &self.sudo
     }
 
     pub fn config(&self) -> &Config {
         self.config
     }
 
-    pub fn base_dirs(&self) -> &BaseDirs {
-        self.base_dirs
+    pub fn set_tmux_session(&self, session_name: String) {
+        self.tmux_session.lock().unwrap().replace(session_name);
+    }
+
+    pub fn get_tmux_session(&self) -> Option<String> {
+        self.tmux_session.lock().unwrap().clone()
     }
 }

src/executor.rs

@@ -1,11 +1,13 @@
 //! Utilities for command execution
-use crate::error::{DryRun, TopgradeError};
-use crate::utils::{Check, CheckWithCodes};
-use anyhow::Result;
-use log::{debug, trace};
 use std::ffi::{OsStr, OsString};
 use std::path::Path;
-use std::process::{Child, Command, ExitStatus};
+use std::process::{Child, Command, ExitStatus, Output};
+
+use color_eyre::eyre::Result;
+use tracing::debug;
+
+use crate::command::CommandExt;
+use crate::error::DryRun;
 
 /// An enum telling whether Topgrade should perform dry runs or actually perform the steps.
 #[derive(Clone, Copy, Debug)]
@@ -56,6 +58,16 @@ pub enum Executor {
 }
 
 impl Executor {
+    /// Get the name of the program being run.
+    ///
+    /// Will give weird results for non-UTF-8 programs; see `to_string_lossy()`.
+    pub fn get_program(&self) -> String {
+        match self {
+            Executor::Wet(c) => c.get_program().to_string_lossy().into_owned(),
+            Executor::Dry(c) => c.program.to_string_lossy().into_owned(),
+        }
+    }
+
     /// See `std::process::Command::arg`
     pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Executor {
         match self {
@@ -139,7 +151,7 @@ impl Executor {
         let result = match self {
             Executor::Wet(c) => {
                 debug!("Running {:?}", c);
-                c.spawn().map(ExecutorChild::Wet)?
+                c.spawn_checked().map(ExecutorChild::Wet)?
             }
             Executor::Dry(c) => {
                 c.dry_run();
@@ -153,7 +165,7 @@ impl Executor {
     /// See `std::process::Command::output`
     pub fn output(&mut self) -> Result<ExecutorOutput> {
         match self {
-            Executor::Wet(c) => Ok(ExecutorOutput::Wet(c.output()?)),
+            Executor::Wet(c) => Ok(ExecutorOutput::Wet(c.output_checked()?)),
             Executor::Dry(c) => {
                 c.dry_run();
                 Ok(ExecutorOutput::Dry)
@@ -161,23 +173,28 @@ impl Executor {
         }
     }
 
-    /// A convinence method for `spawn().wait().check()`.
-    /// Returns an error if something went wrong during the execution or if the
-    /// process exited with failure.
-    pub fn check_run(&mut self) -> Result<()> {
-        self.spawn()?.wait()?.check()
-    }
-
-    /// An extension of `check_run` that allows you to set a sequence of codes
+    /// An extension of `status_checked` that allows you to set a sequence of codes
     /// that can indicate success of a script
     #[allow(dead_code)]
-    pub fn check_run_with_codes(&mut self, codes: &[i32]) -> Result<()> {
-        self.spawn()?.wait()?.check_with_codes(codes)
+    pub fn status_checked_with_codes(&mut self, codes: &[i32]) -> Result<()> {
+        match self {
+            Executor::Wet(c) => c.status_checked_with(|status| {
+                if status.success() || status.code().as_ref().map(|c| codes.contains(c)).unwrap_or(false) {
+                    Ok(())
+                } else {
+                    Err(())
+                }
+            }),
+            Executor::Dry(c) => {
+                c.dry_run();
+                Ok(())
+            }
+        }
     }
 }
 
 pub enum ExecutorOutput {
-    Wet(std::process::Output),
+    Wet(Output),
     Dry,
 }
 
@@ -214,78 +231,33 @@ pub enum ExecutorChild {
     Dry,
 }
 
-impl ExecutorChild {
-    /// See `std::process::Child::wait`
-    pub fn wait(&mut self) -> Result<ExecutorExitStatus> {
-        let result = match self {
-            ExecutorChild::Wet(c) => c.wait().map(ExecutorExitStatus::Wet)?,
-            ExecutorChild::Dry => ExecutorExitStatus::Dry,
-        };
-
-        Ok(result)
-    }
-}
-
-/// The Result of wait. Contains an actual `std::process::ExitStatus` if executed by a wet command.
-pub enum ExecutorExitStatus {
-    Wet(ExitStatus),
-    Dry,
-}
-
-impl CheckWithCodes for ExecutorExitStatus {
-    fn check_with_codes(self, codes: &[i32]) -> Result<()> {
-        match self {
-            ExecutorExitStatus::Wet(e) => e.check_with_codes(codes),
-            ExecutorExitStatus::Dry => Ok(()),
-        }
-    }
-}
-
-/// Extension methods for `std::process::Command`
-pub trait CommandExt {
-    /// Run the command, wait for it to complete, check the return code and decode the output as UTF-8.
-    fn check_output(&mut self) -> Result<String>;
-    fn string_output(&mut self) -> Result<String>;
-}
-
-impl CommandExt for Command {
-    fn check_output(&mut self) -> Result<String> {
-        let output = self.output()?;
-        trace!("Output of {:?}: {:?}", self, output);
-        let status = output.status;
-        if !status.success() {
-            let stderr = String::from_utf8(output.stderr).unwrap_or_default();
-            return Err(TopgradeError::ProcessFailedWithOutput(status, stderr).into());
-        }
-        Ok(String::from_utf8(output.stdout)?)
-    }
-
-    fn string_output(&mut self) -> Result<String> {
-        let output = self.output()?;
-        trace!("Output of {:?}: {:?}", self, output);
-        Ok(String::from_utf8(output.stdout)?)
-    }
-}
-
 impl CommandExt for Executor {
-    fn check_output(&mut self) -> Result<String> {
-        let output = match self.output()? {
-            ExecutorOutput::Wet(output) => output,
-            ExecutorOutput::Dry => return Err(DryRun().into()),
-        };
-        let status = output.status;
-        if !status.success() {
-            let stderr = String::from_utf8(output.stderr).unwrap_or_default();
-            return Err(TopgradeError::ProcessFailedWithOutput(status, stderr).into());
+    type Child = ExecutorChild;
+
+    // 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<(), ()>) -> Result<Output> {
+        match self {
+            Executor::Wet(c) => c.output_checked_with(succeeded),
+            Executor::Dry(c) => {
+                c.dry_run();
+                Err(DryRun().into())
+            }
         }
-        Ok(String::from_utf8(output.stdout)?)
     }
 
-    fn string_output(&mut self) -> Result<String> {
-        let output = match self.output()? {
-            ExecutorOutput::Wet(output) => output,
-            ExecutorOutput::Dry => return Err(DryRun().into()),
-        };
-        Ok(String::from_utf8(output.stdout)?)
+    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) => {
+                c.dry_run();
+                Ok(())
+            }
+        }
+    }
+
+    fn spawn_checked(&mut self) -> Result<Self::Child> {
+        self.spawn()
     }
 }

src/main.rs

@@ -2,14 +2,20 @@
 
 use std::env;
 use std::io;
+use std::path::PathBuf;
 use std::process::exit;
+use std::time::Duration;
 
-use anyhow::{anyhow, Result};
+use clap::CommandFactory;
 use clap::{crate_version, Parser};
+use color_eyre::eyre::Context;
+use color_eyre::eyre::Result;
 use console::Key;
-use log::debug;
-use log::LevelFilter;
-use pretty_env_logger::formatted_timed_builder;
+#[cfg(windows)]
+use etcetera::base_strategy::Windows;
+use etcetera::base_strategy::{BaseStrategy, Xdg};
+use once_cell::sync::Lazy;
+use tracing::debug;
 
 use self::config::{CommandLineArgs, Config, Step};
 use self::error::StepFailed;
@@ -18,6 +24,7 @@ use self::error::Upgraded;
 use self::steps::{remote::*, *};
 use self::terminal::*;
 
+mod command;
 mod config;
 mod ctrlc;
 mod error;
@@ -30,16 +37,35 @@ mod self_renamer;
 #[cfg(feature = "self-update")]
 mod self_update;
 mod steps;
+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"));
+#[cfg(windows)]
+pub static WINDOWS_DIRS: Lazy<Windows> = Lazy::new(|| Windows::new().expect("No home directory"));
+
 fn run() -> Result<()> {
+    color_eyre::install()?;
     ctrlc::set_handler();
 
-    let base_dirs = directories::BaseDirs::new().ok_or_else(|| anyhow!("No base directories"))?;
-
     let opt = CommandLineArgs::parse();
 
+    if let Some(shell) = opt.gen_completion {
+        let cmd = &mut CommandLineArgs::command();
+        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 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();
@@ -47,28 +73,20 @@ fn run() -> Result<()> {
         env::set_var(var, value);
     }
 
-    let mut builder = formatted_timed_builder();
-
-    if opt.verbose {
-        builder.filter(Some("topgrade"), LevelFilter::Trace);
-    }
-
-    builder.init();
-
     if opt.edit_config() {
-        Config::edit(&base_dirs)?;
+        Config::edit()?;
         return Ok(());
     };
 
     if opt.show_config_reference() {
-        print!("{}", crate::config::EXAMPLE_CONFIG);
+        print!("{}", config::EXAMPLE_CONFIG);
         return Ok(());
     }
 
-    let config = Config::load(&base_dirs, opt)?;
-    terminal::set_title(config.set_title());
-    terminal::display_time(config.display_time());
-    terminal::set_desktop_notifications(config.notify_each_step());
+    let config = Config::load(opt)?;
+    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"));
@@ -79,23 +97,29 @@ fn run() -> Result<()> {
     if config.run_in_tmux() && env::var("TOPGRADE_INSIDE_TMUX").is_err() {
         #[cfg(unix)]
         {
-            tmux::run_in_tmux(config.tmux_arguments()?);
+            tmux::run_in_tmux(config.tmux_arguments()?)?;
+            return Ok(());
         }
     }
 
     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 = utils::sudo();
+    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, &base_dirs);
-
+    let ctx = execution_context::ExecutionContext::new(run_type, sudo, &git, &config);
     let mut runner = runner::Runner::new(&ctx);
 
     #[cfg(feature = "self-update")]
     {
-        if !run_type.dry() && env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() {
+        let config_self_upgrade = 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 {
@@ -105,7 +129,7 @@ fn run() -> Result<()> {
                         return result;
                     }
                 }
-                print_warning(format!("Self update error: {}", e));
+                print_warning(format!("Self update error: {e}"));
             }
         }
     }
@@ -123,31 +147,42 @@ fn run() -> Result<()> {
         }
     }
 
-    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))?;
+    if config.pre_sudo() {
+        if let Some(sudo) = ctx.sudo() {
+            sudo.elevate(&ctx)?;
+        }
+    }
 
     if let Some(topgrades) = config.remote_topgrades() {
         for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(t)) {
-            runner.execute(Step::Remotes, format!("Remote ({})", remote_topgrade), || {
-                remote::ssh::ssh_step(&ctx, remote_topgrade)
+            runner.execute(Step::Remotes, format!("Remote ({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))?;
             }
             Err(e) => {
-                println!("Error detecting current distribution: {}", e);
+                println!("Error detecting current distribution: {e}");
             }
         }
         runner.execute(Step::ConfigUpdate, "config-update", || linux::run_config_update(&ctx))?;
@@ -155,13 +190,21 @@ fn run() -> Result<()> {
         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::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::Flatpak, "Flatpak", || linux::run_flatpak(&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))?;
     }
 
     #[cfg(target_os = "macos")]
@@ -185,6 +228,35 @@ fn run() -> Result<()> {
             unix::run_brew_cask(&ctx, unix::BrewVariant::Path)
         })?;
         runner.execute(Step::Macports, "MacPorts", || macos::run_macports(&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)
+        })?;
+        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))?;
+        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)]
@@ -192,32 +264,107 @@ fn run() -> Result<()> {
         runner.execute(Step::Yadm, "yadm", || unix::run_yadm(&ctx))?;
         runner.execute(Step::Nix, "nix", || unix::run_nix(&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::Pkgin, "pkgin", || unix::run_pkgin(&ctx))?;
         runner.execute(Step::Bun, "bun", || unix::run_bun(&ctx))?;
+        runner.execute(Step::Shell, "zr", || zsh::run_zr(&ctx))?;
+        runner.execute(Step::Shell, "antibody", || zsh::run_antibody(&ctx))?;
+        runner.execute(Step::Shell, "antidote", || zsh::run_antidote(&ctx))?;
+        runner.execute(Step::Shell, "antigen", || zsh::run_antigen(&ctx))?;
+        runner.execute(Step::Shell, "zgenom", || zsh::run_zgenom(&ctx))?;
+        runner.execute(Step::Shell, "zplug", || zsh::run_zplug(&ctx))?;
+        runner.execute(Step::Shell, "zinit", || zsh::run_zinit(&ctx))?;
+        runner.execute(Step::Shell, "zi", || zsh::run_zi(&ctx))?;
+        runner.execute(Step::Shell, "zim", || zsh::run_zim(&ctx))?;
+        runner.execute(Step::Shell, "oh-my-zsh", || zsh::run_oh_my_zsh(&ctx))?;
+        runner.execute(Step::Shell, "oh-my-bash", || unix::run_oh_my_bash(&ctx))?;
+        runner.execute(Step::Shell, "fisher", || unix::run_fisher(&ctx))?;
+        runner.execute(Step::Shell, "bash-it", || unix::run_bashit(&ctx))?;
+        runner.execute(Step::Shell, "oh-my-fish", || unix::run_oh_my_fish(&ctx))?;
+        runner.execute(Step::Shell, "fish-plug", || unix::run_fish_plug(&ctx))?;
+        runner.execute(Step::Shell, "fundle", || unix::run_fundle(&ctx))?;
+        runner.execute(Step::Tmux, "tmux", || tmux::run_tpm(&ctx))?;
+        runner.execute(Step::Tldr, "TLDR", || unix::run_tldr(&ctx))?;
+        runner.execute(Step::Pearl, "pearl", || unix::run_pearl(&ctx))?;
+        #[cfg(not(any(target_os = "macos", target_os = "android")))]
+        runner.execute(Step::GnomeShellExtensions, "Gnome Shell Extensions", || {
+            unix::upgrade_gnome_extensions(&ctx)
+        })?;
+        runner.execute(Step::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(target_os = "dragonfly")]
-    runner.execute(Step::Pkg, "DragonFly BSD Packages", || {
-        dragonfly::upgrade_packages(sudo.as_ref(), run_type)
+    #[cfg(not(any(
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    )))]
+    {
+        runner.execute(Step::Atom, "apm", || generic::run_apm(&ctx))?;
+    }
+
+    // The following update function should be executed on all OSes.
+    runner.execute(Step::Fossil, "fossil", || generic::run_fossil(&ctx))?;
+    runner.execute(Step::Rustup, "rustup", || generic::run_rustup(&ctx))?;
+    runner.execute(Step::Juliaup, "juliaup", || generic::run_juliaup(&ctx))?;
+    runner.execute(Step::Dotnet, ".NET", || generic::run_dotnet_upgrade(&ctx))?;
+    runner.execute(Step::Choosenim, "choosenim", || generic::run_choosenim(&ctx))?;
+    runner.execute(Step::Cargo, "cargo", || generic::run_cargo_update(&ctx))?;
+    runner.execute(Step::Flutter, "Flutter", || generic::run_flutter_upgrade(&ctx))?;
+    runner.execute(Step::Go, "go-global-update", || go::run_go_global_update(&ctx))?;
+    runner.execute(Step::Go, "gup", || go::run_go_gup(&ctx))?;
+    runner.execute(Step::Emacs, "Emacs", || emacs.upgrade(&ctx))?;
+    runner.execute(Step::Opam, "opam", || generic::run_opam_update(&ctx))?;
+    runner.execute(Step::Vcpkg, "vcpkg", || generic::run_vcpkg_update(&ctx))?;
+    runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(&ctx))?;
+    runner.execute(Step::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(&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)
     })?;
-
-    #[cfg(target_os = "freebsd")]
-    runner.execute(Step::Pkg, "FreeBSD Packages", || {
-        freebsd::upgrade_packages(sudo.as_ref(), run_type)
+    runner.execute(Step::Pipupgrade, "pipupgrade", || generic::run_pipupgrade_update(&ctx))?;
+    runner.execute(Step::Ghcup, "ghcup", || generic::run_ghcup_update(&ctx))?;
+    runner.execute(Step::Stack, "stack", || generic::run_stack_update(&ctx))?;
+    runner.execute(Step::Tlmgr, "tlmgr", || generic::run_tlmgr_update(&ctx))?;
+    runner.execute(Step::Myrepos, "myrepos", || generic::run_myrepos_update(&ctx))?;
+    runner.execute(Step::Chezmoi, "chezmoi", || generic::run_chezmoi_update(&ctx))?;
+    runner.execute(Step::Jetpack, "jetpack", || generic::run_jetpack(&ctx))?;
+    runner.execute(Step::Vim, "vim", || vim::upgrade_vim(&ctx))?;
+    runner.execute(Step::Vim, "Neovim", || vim::upgrade_neovim(&ctx))?;
+    runner.execute(Step::Vim, "The Ultimate vimrc", || vim::upgrade_ultimate_vimrc(&ctx))?;
+    runner.execute(Step::Vim, "voom", || vim::run_voom(&ctx))?;
+    runner.execute(Step::Kakoune, "Kakoune", || kakoune::upgrade_kak_plug(&ctx))?;
+    runner.execute(Step::Helix, "helix", || generic::run_helix_grammars(&ctx))?;
+    runner.execute(Step::Node, "npm", || node::run_npm_upgrade(&ctx))?;
+    runner.execute(Step::Yarn, "yarn", || node::run_yarn_upgrade(&ctx))?;
+    runner.execute(Step::Pnpm, "pnpm", || node::run_pnpm_upgrade(&ctx))?;
+    runner.execute(Step::Containers, "Containers", || containers::run_containers(&ctx))?;
+    runner.execute(Step::Deno, "deno", || node::deno_upgrade(&ctx))?;
+    runner.execute(Step::Composer, "composer", || generic::run_composer_update(&ctx))?;
+    runner.execute(Step::Krew, "krew", || generic::run_krew_upgrade(&ctx))?;
+    runner.execute(Step::Helm, "helm", || generic::run_helm_repo_update(&ctx))?;
+    runner.execute(Step::Gem, "gem", || generic::run_gem(&ctx))?;
+    runner.execute(Step::RubyGems, "rubygems", || generic::run_rubygems(&ctx))?;
+    runner.execute(Step::Julia, "julia", || generic::update_julia_packages(&ctx))?;
+    runner.execute(Step::Haxelib, "haxelib", || generic::run_haxelib_update(&ctx))?;
+    runner.execute(Step::Sheldon, "sheldon", || generic::run_sheldon(&ctx))?;
+    runner.execute(Step::Stew, "stew", || generic::run_stew(&ctx))?;
+    runner.execute(Step::Rtcl, "rtcl", || generic::run_rtcl(&ctx))?;
+    runner.execute(Step::Bin, "bin", || generic::bin_update(&ctx))?;
+    runner.execute(Step::Gcloud, "gcloud", || generic::run_gcloud_components_update(&ctx))?;
+    runner.execute(Step::Micro, "micro", || generic::run_micro(&ctx))?;
+    runner.execute(Step::Raco, "raco", || generic::run_raco_update(&ctx))?;
+    runner.execute(Step::Spicetify, "spicetify", || generic::spicetify_upgrade(&ctx))?;
+    runner.execute(Step::GithubCliExtensions, "GitHub CLI Extensions", || {
+        generic::run_ghcli_extensions_upgrade(&ctx)
     })?;
+    runner.execute(Step::Bob, "Bob", || generic::run_bob(&ctx))?;
 
-    #[cfg(target_os = "openbsd")]
-    runner.execute(Step::Pkg, "OpenBSD Packages", || {
-        openbsd::upgrade_packages(sudo.as_ref(), run_type)
-    })?;
-
-    #[cfg(target_os = "android")]
-    runner.execute(Step::Pkg, "Termux Packages", || android::upgrade_packages(&ctx))?;
-
-    let emacs = emacs::Emacs::new(&base_dirs);
     if config.use_predefined_git_repos() {
         if config.should_run(Step::Emacs) {
             if !emacs.is_doom() {
@@ -225,43 +372,43 @@ fn run() -> Result<()> {
                     git_repos.insert_if_repo(directory);
                 }
             }
-            git_repos.insert_if_repo(base_dirs.home_dir().join(".doom.d"));
+            git_repos.insert_if_repo(HOME_DIR.join(".doom.d"));
         }
 
         if config.should_run(Step::Vim) {
-            git_repos.insert_if_repo(base_dirs.home_dir().join(".vim"));
-            git_repos.insert_if_repo(base_dirs.home_dir().join(".config/nvim"));
+            git_repos.insert_if_repo(HOME_DIR.join(".vim"));
+            git_repos.insert_if_repo(HOME_DIR.join(".config/nvim"));
         }
 
-        git_repos.insert_if_repo(base_dirs.home_dir().join(".ideavimrc"));
-        git_repos.insert_if_repo(base_dirs.home_dir().join(".intellimacs"));
+        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(base_dirs.home_dir().join(".dotfiles"));
+            git_repos.insert_if_repo(HOME_DIR.join(".dotfiles"));
         }
 
         #[cfg(unix)]
         {
-            git_repos.insert_if_repo(zsh::zshrc(&base_dirs));
+            git_repos.insert_if_repo(zsh::zshrc());
             if config.should_run(Step::Tmux) {
-                git_repos.insert_if_repo(base_dirs.home_dir().join(".tmux"));
+                git_repos.insert_if_repo(HOME_DIR.join(".tmux"));
             }
-            git_repos.insert_if_repo(base_dirs.home_dir().join(".config/fish"));
-            git_repos.insert_if_repo(base_dirs.config_dir().join("openbox"));
-            git_repos.insert_if_repo(base_dirs.config_dir().join("bspwm"));
-            git_repos.insert_if_repo(base_dirs.config_dir().join("i3"));
-            git_repos.insert_if_repo(base_dirs.config_dir().join("sway"));
+            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(
-            base_dirs
-                .data_local_dir()
+            WINDOWS_DIRS
+                .cache_dir()
                 .join("Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState"),
         );
 
         #[cfg(windows)]
-        windows::insert_startup_scripts(&ctx, &mut git_repos).ok();
+        windows::insert_startup_scripts(&mut git_repos).ok();
 
         if let Some(profile) = powershell.profile() {
             git_repos.insert_if_repo(profile);
@@ -285,105 +432,6 @@ fn run() -> Result<()> {
         })?;
     }
 
-    #[cfg(unix)]
-    {
-        runner.execute(Step::Shell, "zr", || zsh::run_zr(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "antibody", || zsh::run_antibody(run_type))?;
-        runner.execute(Step::Shell, "antigen", || zsh::run_antigen(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "zgenom", || zsh::run_zgenom(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "zplug", || zsh::run_zplug(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "zinit", || zsh::run_zinit(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "zi", || zsh::run_zi(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "zim", || zsh::run_zim(&base_dirs, run_type))?;
-        runner.execute(Step::Shell, "oh-my-zsh", || zsh::run_oh_my_zsh(&ctx))?;
-        runner.execute(Step::Shell, "fisher", || unix::run_fisher(&base_dirs, run_type))?;
-        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(&base_dirs, run_type))?;
-        runner.execute(Step::Tldr, "TLDR", || unix::run_tldr(run_type))?;
-        runner.execute(Step::Pearl, "pearl", || unix::run_pearl(run_type))?;
-        #[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(&base_dirs, config.cleanup(), run_type)
-        })?;
-        runner.execute(Step::Rcm, "rcm", || unix::run_rcm(&ctx))?;
-    }
-
-    #[cfg(not(any(
-        target_os = "freebsd",
-        target_os = "openbsd",
-        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::Rustup, "rustup", || generic::run_rustup(&base_dirs, run_type))?;
-    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", || generic::run_go(run_type))?;
-    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(run_type))?;
-    runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(run_type))?;
-    runner.execute(Step::Conda, "conda", || generic::run_conda_update(&ctx))?;
-    runner.execute(Step::Pip3, "pip3", || generic::run_pip3_update(run_type))?;
-    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::Tlmgr, "tlmgr", || generic::run_tlmgr_update(&ctx))?;
-    runner.execute(Step::Myrepos, "myrepos", || {
-        generic::run_myrepos_update(&base_dirs, run_type)
-    })?;
-    runner.execute(Step::Chezmoi, "chezmoi", || {
-        generic::run_chezmoi_update(&base_dirs, run_type)
-    })?;
-    runner.execute(Step::Jetpack, "jetpack", || generic::run_jetpack(run_type))?;
-    runner.execute(Step::Vim, "vim", || vim::upgrade_vim(&base_dirs, &ctx))?;
-    runner.execute(Step::Vim, "Neovim", || vim::upgrade_neovim(&base_dirs, &ctx))?;
-    runner.execute(Step::Vim, "The Ultimate vimrc", || vim::upgrade_ultimate_vimrc(&ctx))?;
-    runner.execute(Step::Vim, "voom", || vim::run_voom(&base_dirs, run_type))?;
-    runner.execute(Step::Kakoune, "Kakoune", || kakoune::upgrade_kak_plug(&ctx))?;
-    runner.execute(Step::Node, "npm", || node::run_npm_upgrade(&ctx))?;
-    runner.execute(Step::Node, "yarn", || node::run_yarn_upgrade(&ctx))?;
-    runner.execute(Step::Node, "pnpm", || node::run_pnpm_upgrade(&ctx))?;
-    runner.execute(Step::Containers, "Containers", || containers::run_containers(&ctx))?;
-    runner.execute(Step::Deno, "deno", || node::deno_upgrade(&ctx))?;
-    runner.execute(Step::Composer, "composer", || generic::run_composer_update(&ctx))?;
-    runner.execute(Step::Krew, "krew", || generic::run_krew_upgrade(run_type))?;
-    runner.execute(Step::Gem, "gem", || generic::run_gem(&base_dirs, run_type))?;
-    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::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::Spicetify, "spicetify", || generic::spicetify_upgrade(&ctx))?;
-    runner.execute(Step::GithubCliExtensions, "GitHub CLI Extensions", || {
-        generic::run_ghcli_extensions_upgrade(&ctx)
-    })?;
-
-    #[cfg(target_os = "linux")]
-    {
-        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(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))?;
-    }
-
     if let Some(commands) = config.commands() {
         for (name, command) in commands {
             if config.should_run_custom_command(name) {
@@ -394,37 +442,6 @@ fn run() -> Result<()> {
         }
     }
 
-    #[cfg(target_os = "linux")]
-    {
-        runner.execute(Step::System, "pihole", || {
-            linux::run_pihole_update(sudo.as_ref(), run_type)
-        })?;
-        runner.execute(Step::Firmware, "Firmware upgrades", || linux::run_fwupdmgr(&ctx))?;
-        runner.execute(Step::Restarts, "Restarts", || {
-            linux::run_needrestart(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(sudo.as_ref(), run_type)
-    })?;
-
-    #[cfg(target_os = "openbsd")]
-    runner.execute(Step::System, "OpenBSD Upgrade", || {
-        openbsd::upgrade_openbsd(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 {
@@ -449,12 +466,6 @@ fn run() -> Result<()> {
                 distribution.show_summary();
             }
         }
-
-        #[cfg(target_os = "freebsd")]
-        freebsd::audit_packages(&sudo).ok();
-
-        #[cfg(target_os = "dragonfly")]
-        dragonfly::audit_packages(&sudo).ok();
     }
 
     let mut post_command_failed = false;
@@ -471,10 +482,10 @@ fn run() -> Result<()> {
         loop {
             match get_key() {
                 Ok(Key::Char('s')) | Ok(Key::Char('S')) => {
-                    run_shell();
+                    run_shell().context("Failed to execute shell")?;
                 }
                 Ok(Key::Char('r')) | Ok(Key::Char('R')) => {
-                    reboot();
+                    reboot().context("Failed to reboot")?;
                 }
                 Ok(Key::Char('q')) | Ok(Key::Char('Q')) => (),
                 _ => {
@@ -488,13 +499,13 @@ fn run() -> Result<()> {
     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" }
             ),
-            None,
-        );
+            Some(Duration::from_secs(10)),
+        )
     }
 
     if failed {
@@ -524,12 +535,35 @@ fn main() {
                     .is_some());
 
             if !skip_print {
-                // The `Debug` implementation of `anyhow::Result` prints a multi-line
+                // The `Debug` implementation of `eyre::Result` prints a multi-line
                 // error message that includes all the 'causes' added with
                 // `.with_context(...)` calls.
-                println!("Error: {:?}", error);
+                println!("Error: {error:?}");
             }
             exit(1);
         }
     }
 }
+
+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/report.rs

@@ -34,7 +34,7 @@ impl<'a> Report<'a> {
         if let Some((key, success)) = result {
             let key = key.into();
 
-            debug_assert!(!self.data.iter().any(|(k, _)| k == &key), "{} already reported", key);
+            debug_assert!(!self.data.iter().any(|(k, _)| k == &key), "{key} already reported");
             self.data.push((key, success));
         }
     }

src/runner.rs

@@ -2,11 +2,12 @@ use crate::ctrlc;
 use crate::error::{DryRun, SkipStep};
 use crate::execution_context::ExecutionContext;
 use crate::report::{Report, StepResult};
+use crate::terminal::print_error;
 use crate::{config::Step, terminal::should_retry};
-use anyhow::Result;
-use log::debug;
+use color_eyre::eyre::Result;
 use std::borrow::Cow;
 use std::fmt::Debug;
+use tracing::debug;
 
 pub struct Runner<'a> {
     ctx: &'a ExecutionContext<'a>,
@@ -55,7 +56,12 @@ impl<'a> Runner<'a> {
 
                     let ignore_failure = self.ctx.config().ignore_failure(step);
                     let should_ask = interrupted || !(self.ctx.config().no_retry() || ignore_failure);
-                    let should_retry = should_ask && should_retry(interrupted, key.as_ref())?;
+                    let should_retry = if should_ask {
+                        print_error(&key, format!("{e:?}"));
+                        should_retry(interrupted, key.as_ref())?
+                    } else {
+                        false
+                    };
 
                     if !should_retry {
                         self.report.push_result(Some((

src/self_renamer.rs

@@ -1,8 +1,8 @@
 #![cfg(windows)]
 
-use anyhow::Result;
-use log::{debug, error};
+use color_eyre::eyre::Result;
 use std::{env::current_exe, fs, path::PathBuf};
+use tracing::{debug, error};
 
 pub struct SelfRenamer {
     exe_path: PathBuf,

src/self_update.rs

@@ -1,13 +1,15 @@
+use std::env;
+#[cfg(unix)]
+use std::os::unix::process::CommandExt as _;
+use std::process::Command;
+
+use color_eyre::eyre::{bail, Result};
+use self_update_crate::backends::github::Update;
+use self_update_crate::update::UpdateStatus;
+
 use super::terminal::*;
 #[cfg(windows)]
 use crate::error::Upgraded;
-use anyhow::{bail, Result};
-use self_update_crate::backends::github::Update;
-use self_update_crate::update::UpdateStatus;
-use std::env;
-#[cfg(unix)]
-use std::os::unix::process::CommandExt;
-use std::process::Command;
 
 pub fn self_update() -> Result<()> {
     print_separator("Self update");
@@ -18,11 +20,7 @@ pub fn self_update() -> Result<()> {
         .repo_owner("topgrade-rs")
         .repo_name("topgrade")
         .target(target)
-        .bin_name(if cfg!(windows) {
-            "topgrade-rs.exe"
-        } else {
-            "topgrade-rs"
-        })
+        .bin_name(if cfg!(windows) { "topgrade.exe" } else { "topgrade" })
         .show_output(false)
         .show_download_progress(true)
         .current_version(self_update_crate::cargo_crate_version!())
@@ -33,7 +31,7 @@ pub fn self_update() -> Result<()> {
     if let UpdateStatus::Updated(release) = &result {
         println!("\nTopgrade upgraded to {}:\n", release.version);
         if let Some(body) = &release.body {
-            println!("{}", body);
+            println!("{body}");
         }
     } else {
         println!("Topgrade is up-to-date");
@@ -53,7 +51,8 @@ pub fn self_update() -> Result<()> {
 
             #[cfg(windows)]
             {
-                let status = command.spawn().and_then(|mut c| c.wait())?;
+                #[allow(clippy::disallowed_methods)]
+                let status = command.status()?;
                 bail!(Upgraded(status));
             }
         }

src/steps/containers.rs

@@ -1,13 +1,17 @@
-use anyhow::Result;
-
-use crate::error::{self, TopgradeError};
-use crate::executor::CommandExt;
-use crate::terminal::print_separator;
-use crate::{execution_context::ExecutionContext, utils::require};
-use log::{debug, error, warn};
+use std::fmt::{Display, Formatter};
 use std::path::Path;
 use std::process::Command;
 
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Context;
+use color_eyre::eyre::Result;
+use tracing::{debug, error, warn};
+
+use crate::command::CommandExt;
+use crate::error::{self, TopgradeError};
+use crate::terminal::print_separator;
+use crate::{execution_context::ExecutionContext, utils::require};
+
 // A string found in the output of docker for containers that weren't found in
 // the docker registry. We use this to gracefully handle and skip containers
 // that cannot be pulled, likely because they don't exist in the registry in
@@ -15,20 +19,46 @@ use std::process::Command;
 // 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>> {
+fn list_containers(crt: &Path) -> Result<Vec<Container>> {
     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}}"])
-        .output()?;
-    let output_str = String::from_utf8(output.stdout)?;
+        .args(["image", "ls", "--format", "{{.Repository}}:{{.Tag}} {{.ID}}"])
+        .output_checked_with_utf8(|_| Ok(()))?;
 
     let mut retval = vec![];
-    for line in output_str.lines() {
+    for line in output.stdout.lines() {
         if line.starts_with("localhost") {
             // Don't know how to update self-built containers
             debug!("Skipping self-built container '{}'", line);
@@ -47,7 +77,26 @@ 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]);
+
+        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)
@@ -60,15 +109,20 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Containers");
     let mut success = true;
-    let containers = list_containers(&crt)?;
+    let containers = list_containers(&crt).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).check_run() {
+        if let Err(e) = exec.args(&args).status_checked() {
             error!("Pulling container '{}' failed: {}", container, e);
 
             // Find out if this is 'skippable'
@@ -77,10 +131,10 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
             // practical consequence that all containers, whether self-built, created by
             // docker-compose or pulled from the docker hub, look exactly the same to us. We can
             // only find out what went wrong by manually parsing the output of the command...
-            if match exec.check_output() {
-                Ok(s) => s.contains(NONEXISTENT_REPO),
+            if match exec.output_checked_utf8() {
+                Ok(s) => s.stdout.contains(NONEXISTENT_REPO) || s.stderr.contains(NONEXISTENT_REPO),
                 Err(e) => match e.downcast_ref::<TopgradeError>() {
-                    Some(TopgradeError::ProcessFailedWithOutput(_, stderr)) => stderr.contains(NONEXISTENT_REPO),
+                    Some(TopgradeError::ProcessFailedWithOutput(_, _, stderr)) => stderr.contains(NONEXISTENT_REPO),
                     _ => false,
                 },
             } {
@@ -95,7 +149,12 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
     if ctx.config().cleanup() {
         // Remove dangling images
         debug!("Removing dangling images");
-        if let Err(e) = ctx.run_type().execute(&crt).args(["image", "prune", "-f"]).check_run() {
+        if let Err(e) = ctx
+            .run_type()
+            .execute(&crt)
+            .args(["image", "prune", "-f"])
+            .status_checked()
+        {
             error!("Removing dangling images failed: {}", e);
             success = false;
         }
@@ -104,6 +163,6 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
     if success {
         Ok(())
     } else {
-        Err(anyhow::anyhow!(error::StepFailed))
+        Err(eyre!(error::StepFailed))
     }
 }

src/steps/emacs.rs

@@ -1,10 +1,11 @@
-#[cfg(any(windows, target_os = "macos"))]
+#[cfg(any(windows))]
 use std::env;
 use std::path::{Path, PathBuf};
 
-use anyhow::Result;
-use directories::BaseDirs;
+use color_eyre::eyre::Result;
+use etcetera::base_strategy::BaseStrategy;
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
 use crate::utils::{require, require_option, PathExt};
@@ -22,20 +23,12 @@ pub struct Emacs {
 }
 
 impl Emacs {
-    fn directory_path(base_dirs: &BaseDirs) -> Option<PathBuf> {
+    fn directory_path() -> Option<PathBuf> {
         #[cfg(unix)]
-        cfg_if::cfg_if! {
-            if #[cfg(target_os = "macos")] {
-                let emacs_xdg_dir = env::var("XDG_CONFIG_HOME")
-                    .ok()
-                    .and_then(|config| PathBuf::from(config).join("emacs").if_exists())
-                    .or_else(|| base_dirs.home_dir().join(".config/emacs").if_exists());
-            } else {
-                let emacs_xdg_dir = base_dirs.config_dir().join("emacs").if_exists();
-            }
-        }
-        #[cfg(unix)]
-        return base_dirs.home_dir().join(".emacs.d").if_exists().or(emacs_xdg_dir);
+        return {
+            let emacs_xdg_dir = crate::XDG_DIRS.config_dir().join("emacs").if_exists();
+            crate::HOME_DIR.join(".emacs.d").if_exists().or(emacs_xdg_dir)
+        };
 
         #[cfg(windows)]
         return env::var("HOME")
@@ -46,11 +39,11 @@ impl Emacs {
                     .if_exists()
                     .or_else(|| PathBuf::from(&home).join(".config\\emacs").if_exists())
             })
-            .or_else(|| base_dirs.data_dir().join(".emacs.d").if_exists());
+            .or_else(|| crate::WINDOWS_DIRS.data_dir().join(".emacs.d").if_exists());
     }
 
-    pub fn new(base_dirs: &BaseDirs) -> Self {
-        let directory = Emacs::directory_path(base_dirs);
+    pub fn new() -> Self {
+        let directory = Emacs::directory_path();
         let doom = directory.as_ref().and_then(|d| d.join(DOOM_PATH).if_exists());
         Self { directory, doom }
     }
@@ -73,7 +66,7 @@ impl Emacs {
 
         command.args(["upgrade"]);
 
-        command.check_run()
+        command.status_checked()
     }
 
     pub fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
@@ -105,6 +98,6 @@ impl Emacs {
         #[cfg(not(unix))]
         command.arg(EMACS_UPGRADE);
 
-        command.check_run()
+        command.status_checked()
     }
 }

src/steps/generic.rs

@@ -5,26 +5,30 @@ use std::process::Command;
 use std::{env, path::Path};
 use std::{fs, io::Write};
 
-use anyhow::Result;
-use directories::BaseDirs;
-use log::debug;
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Context;
+use color_eyre::eyre::Result;
 use tempfile::tempfile_in;
+use tracing::{debug, error};
 
+use crate::command::{CommandExt, Utf8Output};
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, ExecutorOutput, RunType};
+use crate::executor::ExecutorOutput;
 use crate::terminal::{print_separator, shell};
-use crate::utils::{self, require_option, 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::{
-    error::{SkipStep, TopgradeError},
+    error::{SkipStep, StepFailed, TopgradeError},
     terminal::print_warning,
 };
 
 pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     let cargo_dir = env::var_os("CARGO_HOME")
         .map(PathBuf::from)
-        .unwrap_or_else(|| ctx.base_dirs().home_dir().join(".cargo"))
+        .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"),
@@ -38,7 +42,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 {
@@ -53,37 +57,40 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(cargo_update)
         .args(["install-update", "--git", "--all"])
-        .check_run()
+        .status_checked()?;
+
+    if ctx.config().cleanup() {
+        let cargo_cache = require("cargo-cache")
+            .ok()
+            .or_else(|| cargo_dir.join("bin/cargo-cache").if_exists());
+        match cargo_cache {
+            Some(e) => {
+                ctx.run_type().execute(e).args(["-a"]).status_checked()?;
+            }
+            None => {
+                let message = String::from("cargo-cache isn't installed so Topgrade can't cleanup cargo packages.\nInstall cargo-cache by running `cargo install cargo-cache`");
+                print_warning(message);
+            }
+        }
+    }
+
+    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").check_run()
+    ctx.run_type().execute(flutter).arg("upgrade").status_checked()
 }
 
-pub fn run_go(run_type: RunType) -> Result<()> {
-    let go = utils::require("go")?;
-    let go_output = run_type.execute(go).args(["env", "GOPATH"]).check_output()?;
-    let gopath = go_output.trim();
+pub fn run_gem(ctx: &ExecutionContext) -> Result<()> {
+    let gem = require("gem")?;
+    HOME_DIR.join(".gem").require()?;
 
-    let go_global_update = utils::require("go-global-update")
-        .unwrap_or_else(|_| PathBuf::from(gopath).join("bin/go-global-update"))
-        .require()?;
+    print_separator("Gems");
 
-    print_separator("Go");
-
-    run_type.execute(go_global_update).check_run()
-}
-
-pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
-    let gem = utils::require("gem")?;
-    base_dirs.home_dir().join(".gem").require()?;
-
-    print_separator("RubyGems");
-
-    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() {
@@ -91,14 +98,41 @@ pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
         command.arg("--user-install");
     }
 
-    command.check_run()
+    command.status_checked()
+}
+
+pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
+    HOME_DIR.join(".gem").require()?;
+    let gem = require("gem")?;
+
+    print_separator("RubyGems");
+    let gem_path_str = gem.as_os_str();
+    if gem_path_str.to_str().unwrap().contains("asdf") {
+        ctx.run_type()
+            .execute(gem)
+            .args(["update", "--system"])
+            .status_checked()?;
+    } 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")
+                .arg(gem)
+                .args(["update", "--system"])
+                .status_checked()?;
+        }
+    }
+
+    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()?.stdout)?.trim()).require()?;
+        PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output_checked()?.stdout)?.trim())
+            .require()?;
 
     let directory_writable = tempfile_in(&haxelib_dir).is_ok();
     debug!("{:?} writable: {}", haxelib_dir, directory_writable);
@@ -108,44 +142,51 @@ 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
     };
 
-    command.arg("update").check_run()
+    command.arg("update").status_checked()
 }
 
 pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
-    let sheldon = utils::require("sheldon")?;
+    let sheldon = require("sheldon")?;
 
     print_separator("Sheldon");
 
-    ctx.run_type().execute(sheldon).args(["lock", "--update"]).check_run()
+    ctx.run_type()
+        .execute(sheldon)
+        .args(["lock", "--update"])
+        .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"]).check_run()
+    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.execute(micro).args(["-plugin", "update"]).string_output()?;
+    let stdout = ctx
+        .run_type()
+        .execute(micro)
+        .args(["-plugin", "update"])
+        .output_checked_utf8()?
+        .stdout;
     std::io::stdout().write_all(stdout.as_bytes())?;
 
     if stdout.contains("Nothing to install / update") || stdout.contains("One or more plugins installed") {
         Ok(())
     } else {
-        Err(anyhow::anyhow!("micro output does not indicate success: {}", stdout))
+        Err(eyre!("micro output does not indicate success: {}", stdout))
     }
 }
 
@@ -155,158 +196,295 @@ 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.execute(apm).args(["upgrade", "--confirm=false"]).check_run()
+    ctx.run_type()
+        .execute(apm)
+        .args(["upgrade", "--confirm=false"])
+        .status_checked()
 }
 
-pub fn run_rustup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
-    let rustup = utils::require("rustup")?;
+pub fn run_rustup(ctx: &ExecutionContext) -> Result<()> {
+    let rustup = require("rustup")?;
 
     print_separator("rustup");
+    ctx.run_type().execute(rustup).arg("update").status_checked()
+}
 
-    if rustup.canonicalize()?.is_descendant_of(base_dirs.home_dir()) {
-        run_type.execute(&rustup).args(["self", "update"]).check_run()?;
+pub fn run_juliaup(ctx: &ExecutionContext) -> Result<()> {
+    let juliaup = require("juliaup")?;
+
+    print_separator("juliaup");
+
+    if juliaup.canonicalize()?.is_descendant_of(&HOME_DIR) {
+        ctx.run_type()
+            .execute(&juliaup)
+            .args(["self", "update"])
+            .status_checked()?;
     }
 
-    run_type.execute(&rustup).arg("update").check_run()
+    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();
 
-    run_type.execute(&choosenim).args(["update", "self"]).check_run()?;
-    run_type.execute(&choosenim).args(["update", "stable"]).check_run()
+    run_type.execute(&choosenim).args(["update", "self"]).status_checked()?;
+    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"]).check_run()
+    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"])
-        .check_run()
+            .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"]).check_run()
+    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");
 
-    ctx.run_type().execute(rupdate).check_run()
+    ctx.run_type().execute(rupdate).status_checked()
 }
 
 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").check_run()?;
-    ctx.run_type().execute(&opam).arg("upgrade").check_run()?;
+    ctx.run_type().execute(&opam).arg("update").status_checked()?;
+    ctx.run_type().execute(&opam).arg("upgrade").status_checked()?;
 
     if ctx.config().cleanup() {
-        ctx.run_type().execute(&opam).arg("clean").check_run()?;
+        ctx.run_type().execute(&opam).arg("clean").status_checked()?;
     }
 
     Ok(())
 }
 
-pub fn run_vcpkg_update(run_type: RunType) -> Result<()> {
-    let vcpkg = utils::require("vcpkg")?;
+pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
+    let vcpkg = require("vcpkg")?;
     print_separator("vcpkg");
 
-    run_type.execute(vcpkg).args(["upgrade", "--no-dry-run"]).check_run()
+    #[cfg(unix)]
+    let is_root_install = !&vcpkg.starts_with("/home");
+
+    #[cfg(not(unix))]
+    let is_root_install = false;
+
+    let mut command = if is_root_install {
+        ctx.run_type().execute(&vcpkg)
+    } else {
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
+        c.arg(&vcpkg);
+        c
+    };
+
+    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_pipx_update(ctx: &ExecutionContext) -> Result<()> {
+    let pipx = require("pipx")?;
     print_separator("pipx");
 
-    run_type.execute(pipx).arg("upgrade-all").check_run()
+    ctx.run_type().execute(pipx).arg("upgrade-all").status_checked()
 }
 
 pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
-    let conda = utils::require("conda")?;
+    let conda = require("conda")?;
 
     let output = Command::new("conda")
         .args(["config", "--show", "auto_activate_base"])
-        .output()?;
-    let string_output = String::from_utf8(output.stdout)?;
-    debug!("Conda output: {}", string_output);
-    if string_output.contains("False") {
+        .output_checked_utf8()?;
+    debug!("Conda output: {}", output.stdout);
+    if output.stdout.contains("False") {
         return Err(SkipStep("auto_activate_base is set to False".to_string()).into());
     }
 
     print_separator("Conda");
 
-    ctx.run_type()
-        .execute(conda)
-        .args(["update", "--all", "-y"])
-        .check_run()
+    let mut command = ctx.run_type().execute(conda);
+    command.args(["update", "--all"]);
+    if ctx.config().yes(Step::Conda) {
+        command.arg("--yes");
+    }
+    command.status_checked()
 }
 
-pub fn run_pip3_update(run_type: RunType) -> Result<()> {
-    let python3 = utils::require("python3")?;
+pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
+    let mamba = require("mamba")?;
+
+    let output = Command::new("mamba")
+        .args(["config", "--show", "auto_activate_base"])
+        .output_checked_utf8()?;
+    debug!("Mamba output: {}", output.stdout);
+    if output.stdout.contains("False") {
+        return Err(SkipStep("auto_activate_base is set to False".to_string()).into());
+    }
+
+    print_separator("Mamba");
+
+    let mut command = ctx.run_type().execute(mamba);
+    command.args(["update", "--all"]);
+    if ctx.config().yes(Step::Mamba) {
+        command.arg("--yes");
+    }
+    command.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"])
-        .check_output()
+        .output_checked_utf8()
         .map_err(|_| SkipStep("pip does not exists".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])
+        .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()))
+            }
+        })?;
+
     print_separator("pip3");
-    if std::env::var("VIRTUAL_ENV").is_ok() {
+    if env::var("VIRTUAL_ENV").is_ok() {
         print_warning("This step is will be 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"])
-        .check_run()
+        .status_checked()
 }
 
-pub fn run_stack_update(run_type: RunType) -> Result<()> {
-    if utils::require("ghcup").is_ok() {
+pub fn run_pip_review_update(ctx: &ExecutionContext) -> Result<()> {
+    let pip_review = require("pip-review")?;
+
+    print_separator("pip-review");
+
+    if !ctx.config().enable_pip_review() {
+        print_warning(
+            "Pip-review is disabled by default. Enable it by setting enable_pip_review=true in the configuration.",
+        );
+        return Err(SkipStep(String::from("Pip-review is disabled by default")).into());
+    }
+    ctx.run_type()
+        .execute(pip_review)
+        .arg("--auto")
+        .status_checked_with_codes(&[1])?;
+
+    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_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)
+        .args(ctx.config().pipupgrade_arguments().split_whitespace())
+        .status_checked()?;
+
+    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").check_run()
+    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").check_run()
+    ctx.run_type().execute(ghcup).arg("upgrade").status_checked()
 }
 
 pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
@@ -318,16 +496,14 @@ 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(
-            std::str::from_utf8(
             &Command::new(kpsewhich)
                 .arg("-var-value=SELFAUTOPARENT")
-                    .output()?
-                    .stdout,
-            )?
+                .output_checked_utf8()?
+                .stdout
                 .trim(),
         );
         d.push("tlpkg");
@@ -343,61 +519,68 @@ 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
     };
     command.args(["update", "--self", "--all"]);
 
-    command.check_run()
+    command.status_checked()
 }
 
-pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
-    let chezmoi = utils::require("chezmoi")?;
-    base_dirs.home_dir().join(".local/share/chezmoi").require()?;
+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").check_run()
+    ctx.run_type().execute(chezmoi).arg("update").status_checked()
 }
 
-pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
-    let myrepos = utils::require("mr")?;
-    base_dirs.home_dir().join(".mrconfig").require()?;
+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(base_dirs.home_dir())
+        .arg(&*HOME_DIR)
         .arg("checkout")
-        .check_run()?;
-    run_type
+        .status_checked()?;
+    ctx.run_type()
         .execute(&myrepos)
         .arg("--directory")
-        .arg(base_dirs.home_dir())
+        .arg(&*HOME_DIR)
         .arg("update")
-        .check_run()
+        .status_checked()
 }
 
 pub fn run_custom_command(name: &str, command: &str, ctx: &ExecutionContext) -> Result<()> {
     print_separator(name);
-    ctx.run_type().execute(shell()).arg("-c").arg(command).check_run()
+    let mut exec = ctx.run_type().execute(shell());
+    #[cfg(unix)]
+    let command = if let Some(command) = command.strip_prefix("-i ") {
+        exec.arg("-i");
+        command
+    } else {
+        command
+    };
+    exec.arg("-c").arg(command).status_checked()
 }
 
 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"])
-        .check_output()
-        .map_err(|e| (SkipStep(format!("Error getting the composer directory: {}", e))))
-        .map(|s| PathBuf::from(s.trim()))?
+        .output_checked_utf8()
+        .map_err(|e| (SkipStep(format!("Error getting the composer directory: {e}"))))
+        .map(|s| PathBuf::from(s.stdout.trim()))?
         .require()?;
 
-    if !composer_home.is_descendant_of(ctx.base_dirs().home_dir()) {
+    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_home.display()
@@ -417,30 +600,27 @@ 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")
-                        .check_run()?;
+                        .status_checked()?;
                 }
             } else {
-                ctx.run_type().execute(&composer).arg("self-update").check_run()?;
+                ctx.run_type().execute(&composer).arg("self-update").status_checked()?;
             }
         }
     }
 
-    let output = Command::new(&composer).args(["global", "update"]).output()?;
-    let status = output.status;
-    if !status.success() {
-        return Err(TopgradeError::ProcessFailed(status).into());
+    let output = ctx.run_type().execute(&composer).args(["global", "update"]).output()?;
+    if let ExecutorOutput::Wet(output) = output {
+        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) = which("valet") {
+                ctx.run_type().execute(valet).arg("install").status_checked()?;
             }
-    let stdout = String::from_utf8(output.stdout)?;
-    let stderr = String::from_utf8(output.stderr)?;
-    print!("{}\n{}", stdout, stderr);
-
-    if stdout.contains("valet") || stderr.contains("valet") {
-        if let Some(valet) = utils::which("valet") {
-            ctx.run_type().execute(valet).arg("install").check_run()?;
         }
     }
 
@@ -448,20 +628,39 @@ 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")?;
 
-    let output = Command::new(dotnet).args(["tool", "list", "--global"]).output()?;
-
-    if !output.status.success() {
-        return Err(SkipStep(format!("dotnet failed with exit code {:?}", output.status)).into());
+    // 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"])
+        .output_checked_utf8()
+    {
+        Ok(output) => output,
+        Err(_) => {
+            return Err(SkipStep(String::from(
+                "Error running `dotnet tool list`. This is expected when a dotnet runtime is installed but no SDK.",
+            ))
+            .into())
         }
+    };
 
-    let output = String::from_utf8(output.stdout)?;
-    if !output.starts_with("Package Id") {
-        return Err(SkipStep(String::from("dotnet did not output packages")).into());
-    }
-
-    let mut packages = output.split('\n').skip(2).filter(|line| !line.is_empty()).peekable();
+    let mut packages = output
+        .stdout
+        .lines()
+        // Skip the header:
+        //
+        // Package Id      Version      Commands
+        // -------------------------------------
+        //
+        // One thing to note is that .NET SDK respect locale, which means this
+        // header can be printed in languages other than English, do NOT use it
+        // to do any check.
+        .skip(2)
+        .filter(|line| !line.is_empty())
+        .peekable();
 
     if packages.peek().is_none() {
         return Err(SkipStep(String::from("No dotnet global tools installed")).into());
@@ -472,39 +671,64 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
     for package in packages {
         let package_name = package.split_whitespace().next().unwrap();
         ctx.run_type()
-            .execute("dotnet")
+            .execute(&dotnet)
             .args(["tool", "update", package_name, "--global"])
-            .check_run()?;
+            .status_checked()
+            .with_context(|| format!("Failed to update .NET package {package_name}"))?;
     }
 
     Ok(())
 }
 
-pub fn run_raco_update(run_type: RunType) -> Result<()> {
-    let raco = utils::require("raco")?;
+pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
+    require("helix")?;
+
+    print_separator("Helix");
+
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["helix", "--grammar", "fetch"])
+        .status_checked()
+        .with_context(|| "Failed to download helix grammars!")?;
+
+    ctx.run_type()
+        .execute(sudo)
+        .args(["helix", "--grammar", "build"])
+        .status_checked()
+        .with_context(|| "Failed to build helix grammars!")?;
+
+    Ok(())
+}
+
+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"]).check_run()
+    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").check_run()
+    ctx.run_type().execute(bin).arg("update").status_checked()
 }
 
 pub fn spicetify_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let spicetify = utils::require("spicetify")?;
+    let spicetify = require("spicetify")?;
 
     print_separator("Spicetify");
-    ctx.run_type().execute(spicetify).arg("upgrade").check_run()
+    ctx.run_type().execute(spicetify).arg("upgrade").status_checked()
 }
 
 pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let gh = utils::require("gh")?;
-    let result = Command::new(&gh).args(["extensions", "list"]).check_output();
+    let gh = require("gh")?;
+    let result = Command::new(&gh).args(["extensions", "list"]).output_checked_utf8();
     if result.is_err() {
         debug!("GH result {:?}", result);
         return Err(SkipStep(String::from("GH failed")).into());
@@ -514,16 +738,57 @@ pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(&gh)
         .args(["extension", "upgrade", "--all"])
-        .check_run()
+        .status_checked()
 }
 
 pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
-    let julia = utils::require("julia")?;
+    let julia = require("julia")?;
 
     print_separator("Julia Packages");
 
     ctx.run_type()
         .execute(julia)
         .args(["-e", "using Pkg; Pkg.update()"])
-        .check_run()
+        .status_checked()
+}
+
+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 = 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() {
+            Ok(s) => s.stdout.contains(no_repo) || s.stderr.contains(no_repo),
+            Err(e) => match e.downcast_ref::<TopgradeError>() {
+                Some(TopgradeError::ProcessFailedWithOutput(_, _, stderr)) => stderr.contains(no_repo),
+                _ => false,
+            },
+        };
+    }
+
+    if success {
+        Ok(())
+    } else {
+        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()
 }

src/steps/git.rs

@@ -3,17 +3,17 @@ use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, Stdio};
 
-use anyhow::{anyhow, Result};
+use color_eyre::eyre::{eyre, Result};
 use console::style;
 use futures::stream::{iter, FuturesUnordered};
 use futures::StreamExt;
 use glob::{glob_with, MatchOptions};
-use log::{debug, error};
 use tokio::process::Command as AsyncCommand;
 use tokio::runtime;
+use tracing::{debug, error};
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
 use crate::terminal::print_separator;
 use crate::utils::{which, PathExt};
 use crate::{error::SkipStep, terminal::print_warning};
@@ -33,10 +33,10 @@ pub struct Repositories<'a> {
     bad_patterns: Vec<String>,
 }
 
-fn check_output(output: Output) -> Result<()> {
+fn output_checked_utf8(output: Output) -> Result<()> {
     if !(output.status.success()) {
         let stderr = String::from_utf8(output.stderr).unwrap();
-        Err(anyhow!(stderr))
+        Err(eyre!(stderr))
     } else {
         Ok(())
     }
@@ -66,11 +66,11 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
         .stdin(Stdio::null())
         .output()
         .await?;
-    let result = check_output(pull_output).and_then(|_| check_output(submodule_output));
+    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);
+        print!("{message}");
     } else {
         let after_revision = get_head_revision(git, &repo);
 
@@ -86,12 +86,9 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
                         "log",
                         "--no-decorate",
                         "--oneline",
-                        &format!("{}..{}", before, after),
+                        &format!("{before}..{after}"),
                     ])
-                    .spawn()
-                    .unwrap()
-                    .wait()
-                    .unwrap();
+                    .status_checked()?;
                 println!();
             }
             _ => {
@@ -108,8 +105,8 @@ fn get_head_revision(git: &Path, repo: &str) -> Option<String> {
         .stdin(Stdio::null())
         .current_dir(repo)
         .args(["rev-parse", "HEAD"])
-        .check_output()
-        .map(|output| output.trim().to_string())
+        .output_checked_utf8()
+        .map(|output| output.stdout.trim().to_string())
         .map_err(|e| {
             error!("Error getting revision for {}: {}", repo, e);
 
@@ -123,8 +120,8 @@ fn has_remotes(git: &Path, repo: &str) -> Option<bool> {
         .stdin(Stdio::null())
         .current_dir(repo)
         .args(["remote", "show"])
-        .check_output()
-        .map(|output| output.lines().count() > 0)
+        .output_checked_utf8()
+        .map(|output| output.stdout.lines().count() > 0)
         .map_err(|e| {
             error!("Error getting remotes for {}: {}", repo, e);
             e
@@ -166,9 +163,9 @@ impl Git {
                         .stdin(Stdio::null())
                         .current_dir(path)
                         .args(["rev-parse", "--show-toplevel"])
-                        .check_output()
+                        .output_checked_utf8()
                         .ok()
-                        .map(|output| output.trim().to_string());
+                        .map(|output| output.stdout.trim().to_string());
                     return output;
                 }
             }
@@ -181,22 +178,28 @@ impl Git {
         None
     }
     pub fn multi_pull_step(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
+        // 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.
+        repositories
+            .bad_patterns
+            .iter()
+            .for_each(|pattern| print_warning(format!("Path {pattern} did not contain any git repositories")));
+
         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 {} did not contain any git repositories", pattern)));
         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() {
+        if ctx.run_type().dry() {
             repositories
                 .repositories
                 .iter()

src/steps/go.rs

@@ -0,0 +1,45 @@
+use std::path::PathBuf;
+use std::process::Command;
+
+use color_eyre::eyre::Result;
+
+use crate::command::CommandExt;
+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(ctx: &ExecutionContext) -> Result<()> {
+    let go_global_update = require_go_bin("go-global-update")?;
+
+    print_separator("go-global-update");
+
+    ctx.run_type().execute(go_global_update).status_checked()
+}
+
+/// <https://github.com/nao1215/gup>
+pub fn run_go_gup(ctx: &ExecutionContext) -> Result<()> {
+    let gup = require_go_bin("gup")?;
+
+    print_separator("gup");
+
+    ctx.run_type().execute(gup).arg("update").status_checked()
+}
+
+/// Get the path of a Go binary.
+fn require_go_bin(name: &str) -> Result<PathBuf> {
+    utils::require(name).or_else(|_| {
+        let go = utils::require("go")?;
+        // TODO: Does this work? `go help gopath` says that:
+        // > The GOPATH environment variable lists places to look for Go code.
+        // > On Unix, the value is a colon-separated string.
+        // > On Windows, the value is a semicolon-separated string.
+        // > On Plan 9, the value is a list.
+        // Should we also fallback to the env variable?
+        let gopath_output = Command::new(go).args(["env", "GOPATH"]).output_checked_utf8()?;
+        let gopath = gopath_output.stdout.trim();
+
+        PathBuf::from(gopath).join("bin").join(name).require()
+    })
+}

src/steps/kakoune.rs

@@ -1,10 +1,8 @@
-use crate::error::TopgradeError;
 use crate::terminal::print_separator;
 use crate::utils::require;
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
 use crate::execution_context::ExecutionContext;
-use crate::executor::ExecutorOutput;
 
 const UPGRADE_KAK: &str = include_str!("upgrade.kak");
 
@@ -13,19 +11,13 @@ pub fn upgrade_kak_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Kakoune");
 
-    let mut command = ctx.run_type().execute(kak);
-    command.args(["-ui", "dummy", "-e", UPGRADE_KAK]);
+    // TODO: Why supress output for this command?
+    ctx.run_type()
+        .execute(kak)
+        .args(["-ui", "dummy", "-e", UPGRADE_KAK])
+        .output()?;
 
-    let output = command.output()?;
-
-    if let ExecutorOutput::Wet(output) = output {
-        let status = output.status;
-        if !status.success() {
-            return Err(TopgradeError::ProcessFailed(status).into());
-        } else {
-            println!("Plugins upgraded")
-        }
-    }
+    println!("Plugins upgraded");
 
     Ok(())
 }

src/steps/mod.rs

@@ -2,6 +2,7 @@ pub mod containers;
 pub mod emacs;
 pub mod generic;
 pub mod git;
+pub mod go;
 pub mod kakoune;
 pub mod node;
 pub mod os;

src/steps/node.rs

@@ -1,19 +1,18 @@
-#![allow(unused_imports)]
-
 use std::fmt::Display;
-#[cfg(unix)]
-use std::os::unix::prelude::MetadataExt;
+#[cfg(target_os = "linux")]
+use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-use anyhow::Result;
-use directories::BaseDirs;
-use log::debug;
-#[cfg(unix)]
+use crate::utils::{require_option, REQUIRE_SUDO};
+use crate::HOME_DIR;
+use color_eyre::eyre::Result;
+#[cfg(target_os = "linux")]
 use nix::unistd::Uid;
 use semver::Version;
+use tracing::debug;
 
-use crate::executor::{CommandExt, RunType};
+use crate::command::CommandExt;
 use crate::terminal::print_separator;
 use crate::utils::{require, PathExt};
 use crate::{error::SkipStep, execution_context::ExecutionContext};
@@ -24,13 +23,6 @@ enum NPMVariant {
 }
 
 impl NPMVariant {
-    const fn long_name(&self) -> &str {
-        match self {
-            NPMVariant::Npm => "Node Package Manager",
-            NPMVariant::Pnpm => "PNPM",
-        }
-    }
-
     const fn short_name(&self) -> &str {
         match self {
             NPMVariant::Npm => "npm",
@@ -85,25 +77,29 @@ impl NPM {
         let args = ["root", self.global_location_arg()];
         Command::new(&self.command)
             .args(args)
-            .check_output()
-            .map(|s| PathBuf::from(s.trim()))
+            .output_checked_utf8()
+            .map(|s| PathBuf::from(s.stdout.trim()))
     }
 
     fn version(&self) -> Result<Version> {
         let version_str = Command::new(&self.command)
             .args(["--version"])
-            .check_output()
-            .map(|s| s.trim().to_owned());
+            .output_checked_utf8()
+            .map(|s| s.stdout.trim().to_owned());
         Version::parse(&version_str?).map_err(|err| err.into())
     }
 
-    fn upgrade(&self, run_type: RunType, use_sudo: bool) -> Result<()> {
-        print_separator(self.variant.long_name());
+    fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
         let args = ["update", self.global_location_arg()];
         if use_sudo {
-            run_type.execute("sudo").args(args).check_run()?;
+            let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
+            ctx.run_type()
+                .execute(sudo)
+                .arg(&self.command)
+                .args(args)
+                .status_checked()?;
         } else {
-            run_type.execute(&self.command).args(args).check_run()?;
+            ctx.run_type().execute(&self.command).args(args).status_checked()?;
         }
 
         Ok(())
@@ -142,9 +138,9 @@ impl Yarn {
         //
         // As “yarn dlx” don't need to “upgrade”, we
         // ignore the whole task if Yarn is 2.x or above.
-        let version = Command::new(&self.command).args(["--version"]).check_output();
+        let version = Command::new(&self.command).args(["--version"]).output_checked_utf8();
 
-        matches!(version, Ok(ver) if ver.starts_with('1') || ver.starts_with('0'))
+        matches!(version, Ok(ver) if ver.stdout.starts_with('1') || ver.stdout.starts_with('0'))
     }
 
     #[cfg(target_os = "linux")]
@@ -152,22 +148,22 @@ impl Yarn {
         let args = ["global", "dir"];
         Command::new(&self.command)
             .args(args)
-            .check_output()
-            .map(|s| PathBuf::from(s.trim()))
+            .output_checked_utf8()
+            .map(|s| PathBuf::from(s.stdout.trim()))
     }
 
-    fn upgrade(&self, run_type: RunType, use_sudo: bool) -> Result<()> {
-        print_separator("Yarn Package Manager");
+    fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
         let args = ["global", "upgrade"];
 
         if use_sudo {
-            run_type
-                .execute("sudo")
+            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))
                 .args(args)
-                .check_run()?;
+                .status_checked()?;
         } else {
-            run_type.execute(&self.command).args(args).check_run()?;
+            ctx.run_type().execute(&self.command).args(args).status_checked()?;
         }
 
         Ok(())
@@ -218,28 +214,32 @@ fn should_use_sudo_yarn(yarn: &Yarn, ctx: &ExecutionContext) -> Result<bool> {
 pub fn run_npm_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let npm = require("npm").map(|b| NPM::new(b, NPMVariant::Npm))?;
 
+    print_separator("Node Package Manager");
+
     #[cfg(target_os = "linux")]
     {
-        npm.upgrade(ctx.run_type(), should_use_sudo(&npm, ctx)?)
+        npm.upgrade(ctx, should_use_sudo(&npm, ctx)?)
     }
 
     #[cfg(not(target_os = "linux"))]
     {
-        npm.upgrade(ctx.run_type(), false)
+        npm.upgrade(ctx, false)
     }
 }
 
 pub fn run_pnpm_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let pnpm = require("pnpm").map(|b| NPM::new(b, NPMVariant::Pnpm))?;
 
+    print_separator("Performant Node Package Manager");
+
     #[cfg(target_os = "linux")]
     {
-        pnpm.upgrade(ctx.run_type(), should_use_sudo(&pnpm, ctx)?)
+        pnpm.upgrade(ctx, should_use_sudo(&pnpm, ctx)?)
     }
 
     #[cfg(not(target_os = "linux"))]
     {
-        pnpm.upgrade(ctx.run_type(), false)
+        pnpm.upgrade(ctx, false)
     }
 }
 
@@ -251,20 +251,22 @@ pub fn run_yarn_upgrade(ctx: &ExecutionContext) -> Result<()> {
         return Ok(());
     }
 
+    print_separator("Yarn Package Manager");
+
     #[cfg(target_os = "linux")]
     {
-        yarn.upgrade(ctx.run_type(), should_use_sudo_yarn(&yarn, ctx)?)
+        yarn.upgrade(ctx, should_use_sudo_yarn(&yarn, ctx)?)
     }
 
     #[cfg(not(target_os = "linux"))]
     {
-        yarn.upgrade(ctx.run_type(), false)
+        yarn.upgrade(ctx, false)
     }
 }
 
 pub fn deno_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let deno = require("deno")?;
-    let deno_dir = ctx.base_dirs().home_dir().join(".deno");
+    let deno_dir = HOME_DIR.join(".deno");
 
     if !deno.canonicalize()?.is_descendant_of(&deno_dir) {
         let skip_reason = SkipStep("Deno installed outside of .deno directory".to_string());
@@ -272,5 +274,5 @@ pub fn deno_upgrade(ctx: &ExecutionContext) -> Result<()> {
     }
 
     print_separator("Deno");
-    ctx.run_type().execute(&deno).arg("upgrade").check_run()
+    ctx.run_type().execute(&deno).arg("upgrade").status_checked()
 }

src/steps/os/android.rs

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

src/steps/os/archlinux.rs

@@ -1,13 +1,15 @@
 use std::env::var_os;
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
-use std::process::Command;
 
-use anyhow::Result;
+use color_eyre::eyre;
+use color_eyre::eyre::Result;
 use walkdir::WalkDir;
 
+use crate::command::CommandExt;
 use crate::error::TopgradeError;
 use crate::execution_context::ExecutionContext;
+use crate::sudo::Sudo;
 use crate::utils::which;
 use crate::{config, Step};
 
@@ -29,11 +31,10 @@ pub struct YayParu {
 impl ArchPackageManager for YayParu {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().show_arch_news() {
-            Command::new(&self.executable)
+            ctx.run_type()
+                .execute(&self.executable)
                 .arg("-Pw")
-                .spawn()
-                .and_then(|mut p| p.wait())
-                .ok();
+                .status_checked_with_codes(&[1, 0])?;
         }
 
         let mut command = ctx.run_type().execute(&self.executable);
@@ -48,7 +49,7 @@ impl ArchPackageManager for YayParu {
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -56,7 +57,7 @@ impl ArchPackageManager for YayParu {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -72,6 +73,37 @@ impl YayParu {
     }
 }
 
+pub struct GarudaUpdate {
+    executable: PathBuf,
+}
+
+impl ArchPackageManager for GarudaUpdate {
+    fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
+        let mut command = ctx.run_type().execute(&self.executable);
+
+        command
+            .env("PATH", get_execution_path())
+            .env("UPDATE_AUR", "1")
+            .env("SKIP_MIRRORLIST", "1");
+
+        if ctx.config().yes(Step::System) {
+            command.env("PACMAN_NOCONFIRM", "1");
+        }
+        command.args(ctx.config().garuda_update_arguments().split_whitespace());
+        command.status_checked()?;
+
+        Ok(())
+    }
+}
+
+impl GarudaUpdate {
+    fn get() -> Option<Self> {
+        Some(Self {
+            executable: which("garuda-update")?,
+        })
+    }
+}
+
 pub struct Trizen {
     executable: PathBuf,
 }
@@ -88,7 +120,7 @@ impl ArchPackageManager for Trizen {
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -96,7 +128,7 @@ impl ArchPackageManager for Trizen {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -112,7 +144,7 @@ impl Trizen {
 }
 
 pub struct Pacman {
-    sudo: PathBuf,
+    sudo: Sudo,
     executable: PathBuf,
 }
 
@@ -126,7 +158,7 @@ impl ArchPackageManager for Pacman {
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.sudo);
@@ -134,7 +166,7 @@ impl ArchPackageManager for Pacman {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -175,7 +207,7 @@ impl ArchPackageManager for Pikaur {
             command.arg("--noconfirm");
         }
 
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -183,7 +215,7 @@ impl ArchPackageManager for Pikaur {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -214,7 +246,7 @@ impl ArchPackageManager for Pamac {
             command.arg("--no-confirm");
         }
 
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -222,7 +254,7 @@ impl ArchPackageManager for Pamac {
             if ctx.config().yes(Step::System) {
                 command.arg("--no-confirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -231,7 +263,7 @@ impl ArchPackageManager for Pamac {
 
 pub struct Aura {
     executable: PathBuf,
-    sudo: PathBuf,
+    sudo: Sudo,
 }
 
 impl Aura {
@@ -245,7 +277,7 @@ impl Aura {
 
 impl ArchPackageManager for Aura {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
-        let sudo = which("sudo").unwrap_or(PathBuf::new());
+        let sudo = which("sudo").unwrap_or_else(PathBuf::new);
         let mut aur_update = ctx.run_type().execute(&sudo);
 
         if sudo.ends_with("sudo") {
@@ -257,7 +289,7 @@ impl ArchPackageManager for Aura {
                 aur_update.arg("--noconfirm");
             }
 
-            aur_update.check_run()?;
+            aur_update.status_checked()?;
         } else {
             println!("Aura requires sudo installed to work with AUR packages")
         }
@@ -270,7 +302,7 @@ impl ArchPackageManager for Aura {
         if ctx.config().yes(Step::System) {
             pacman_update.arg("--noconfirm");
         }
-        pacman_update.check_run()?;
+        pacman_update.status_checked()?;
 
         Ok(())
     }
@@ -284,14 +316,16 @@ pub fn get_arch_package_manager(ctx: &ExecutionContext) -> Option<Box<dyn ArchPa
     let pacman = which("powerpill").unwrap_or_else(|| PathBuf::from("pacman"));
 
     match ctx.config().arch_package_manager() {
-        config::ArchPackageManager::Autodetect => YayParu::get("paru", &pacman)
+        config::ArchPackageManager::Autodetect => GarudaUpdate::get()
             .map(box_package_manager)
+            .or_else(|| YayParu::get("paru", &pacman).map(box_package_manager))
             .or_else(|| YayParu::get("yay", &pacman).map(box_package_manager))
             .or_else(|| Trizen::get().map(box_package_manager))
             .or_else(|| Pikaur::get().map(box_package_manager))
             .or_else(|| Pamac::get().map(box_package_manager))
             .or_else(|| Pacman::get(ctx).map(box_package_manager))
             .or_else(|| Aura::get(ctx).map(box_package_manager)),
+        config::ArchPackageManager::GarudaUpdate => GarudaUpdate::get().map(box_package_manager),
         config::ArchPackageManager::Trizen => Trizen::get().map(box_package_manager),
         config::ArchPackageManager::Paru => YayParu::get("paru", &pacman).map(box_package_manager),
         config::ArchPackageManager::Yay => YayParu::get("yay", &pacman).map(box_package_manager),
@@ -304,7 +338,7 @@ pub fn get_arch_package_manager(ctx: &ExecutionContext) -> Option<Box<dyn ArchPa
 
 pub fn upgrade_arch_linux(ctx: &ExecutionContext) -> Result<()> {
     let package_manager =
-        get_arch_package_manager(ctx).ok_or_else(|| anyhow::Error::from(TopgradeError::FailedGettingPackageManager))?;
+        get_arch_package_manager(ctx).ok_or_else(|| eyre::Report::from(TopgradeError::FailedGettingPackageManager))?;
     package_manager.upgrade(ctx)
 }
 

src/steps/os/dragonfly.rs

@@ -1,26 +1,23 @@
-use crate::executor::RunType;
+use crate::command::CommandExt;
+use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
-use anyhow::Result;
-use std::path::PathBuf;
+use crate::utils::{require_option, REQUIRE_SUDO};
+use color_eyre::eyre::Result;
 use std::process::Command;
 
-pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
-    let sudo = require_option(sudo, String::from("No sudo detected"))?;
-    print_separator("DrgaonFly BSD Packages");
-    run_type
-        .execute(sudo)
-        .args(&["/usr/local/sbin/pkg", "upgrade"])
-        .check_run()
+pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    print_separator("DragonFly BSD Packages");
+    ctx.execute(sudo)
+        .args(["/usr/local/sbin/pkg", "upgrade"])
+        .status_checked()
 }
 
-pub fn audit_packages(sudo: &Option<PathBuf>) -> Result<()> {
-    if let Some(sudo) = sudo {
+pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     println!();
     Command::new(sudo)
-            .args(&["/usr/local/sbin/pkg", "audit", "-Fr"])
-            .spawn()?
-            .wait()?;
-    }
+        .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
+        .status_checked()?;
     Ok(())
 }

src/steps/os/freebsd.rs

@@ -1,32 +1,38 @@
-use crate::executor::RunType;
+use crate::command::CommandExt;
+use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
-use anyhow::Result;
-use std::path::PathBuf;
+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<&PathBuf>, 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"])
-        .check_run()
+        .args(["/usr/sbin/freebsd-update", "fetch", "install"])
+        .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("FreeBSD Packages");
-    run_type.execute(sudo).args(&["/usr/sbin/pkg", "upgrade"]).check_run()
+
+    let mut command = ctx.run_type().execute(sudo);
+
+    command.args(["/usr/sbin/pkg", "upgrade"]);
+    if ctx.config().yes(Step::System) {
+        command.arg("-y");
+    }
+    command.status_checked()
 }
 
-pub fn audit_packages(sudo: &Option<PathBuf>) -> Result<()> {
-    if let Some(sudo) = sudo {
+pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     println!();
     Command::new(sudo)
-            .args(&["/usr/sbin/pkg", "audit", "-Fr"])
-            .spawn()?
-            .wait()?;
-    }
+        .args(["/usr/sbin/pkg", "audit", "-Fr"])
+        .status_checked()?;
     Ok(())
 }

src/steps/os/linux.rs

@@ -1,17 +1,17 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use anyhow::Result;
+use color_eyre::eyre::Result;
 use ini::Ini;
-use log::{debug, warn};
+use tracing::{debug, warn};
 
+use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
 use crate::steps::os::archlinux;
-use crate::terminal::{print_separator, print_warning};
-use crate::utils::{require, require_option, which, PathExt};
-use crate::Step;
+use crate::terminal::print_separator;
+use crate::utils::{require, require_option, which, PathExt, REQUIRE_SUDO};
+use crate::{Step, HOME_DIR};
 
 static OS_RELEASE_PATH: &str = "/etc/os-release";
 
@@ -24,10 +24,15 @@ pub enum Distribution {
     CentOS,
     ClearLinux,
     Fedora,
+    FedoraSilverblue,
     Debian,
     Gentoo,
     OpenMandriva,
+    OpenSuseTumbleweed,
+    PCLinuxOS,
     Suse,
+    SuseMicro,
+    Vanilla,
     Void,
     Solus,
     Exherbo,
@@ -36,33 +41,58 @@ pub enum Distribution {
 }
 
 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 name = section.get("NAME");
+        let variant: Option<Vec<&str>> = section.get("VARIANT").map(|s| s.split_whitespace().collect());
         let id_like: Option<Vec<&str>> = section.get("ID_LIKE").map(|s| s.split_whitespace().collect());
 
         Ok(match id {
             Some("alpine") => Distribution::Alpine,
             Some("centos") | Some("rhel") | Some("ol") => Distribution::CentOS,
             Some("clear-linux-os") => Distribution::ClearLinux,
-            Some("fedora") | Some("nobara") => Distribution::Fedora,
+            Some("fedora") | Some("nobara") => {
+                return if let Some(variant) = variant {
+                    if variant.contains(&"Silverblue") {
+                        Ok(Distribution::FedoraSilverblue)
+                    } else {
+                        Ok(Distribution::Fedora)
+                    }
+                } else {
+                    Ok(Distribution::Fedora)
+                }
+            }
+
             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") => 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,
             Some("nixos") => Distribution::NixOS,
+            Some("opensuse-microos") => Distribution::SuseMicro,
             Some("neon") => Distribution::KDENeon,
             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") {
@@ -97,10 +127,14 @@ impl Distribution {
             Distribution::Alpine => upgrade_alpine_linux(ctx),
             Distribution::Arch => archlinux::upgrade_arch_linux(ctx),
             Distribution::CentOS | Distribution::Fedora => upgrade_redhat(ctx),
+            Distribution::FedoraSilverblue => upgrade_fedora_silverblue(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),
@@ -108,6 +142,7 @@ impl Distribution {
             Distribution::KDENeon => upgrade_neon(ctx),
             Distribution::Bedrock => update_bedrock(ctx),
             Distribution::OpenMandriva => upgrade_openmandriva(ctx),
+            Distribution::PCLinuxOS => upgrade_pclinuxos(ctx),
         }
     }
 
@@ -123,15 +158,14 @@ 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"]);
 
-    let output = Command::new("brl").arg("list").output()?;
+    let output = Command::new("brl").arg("list").output_checked_utf8()?;
     debug!("brl list: {:?} {:?}", output.stdout, output.stderr);
 
-    let parsed_output = String::from_utf8(output.stdout).unwrap();
-    for distribution in parsed_output.trim().split('\n') {
+    for distribution in output.stdout.trim().lines() {
         debug!("Bedrock distribution {}", distribution);
         match distribution {
             "arch" => archlinux::upgrade_arch_linux(ctx)?,
@@ -148,17 +182,17 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn is_wsl() -> Result<bool> {
-    let output = Command::new("uname").arg("-r").check_output()?;
+    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").check_run()?;
-    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").check_run()
+    ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
+    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
 }
 
 fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
@@ -166,11 +200,11 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().rpm_ostree() {
             let mut command = ctx.run_type().execute(ostree);
             command.arg("upgrade");
-            return command.check_run();
+            return command.status_checked();
         }
     };
 
-    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()))
@@ -188,41 +222,73 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
         command.arg("-y");
     }
 
-        command.check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    command.status_checked()?;
+    Ok(())
+}
 
+fn upgrade_fedora_silverblue(ctx: &ExecutionContext) -> Result<()> {
+    let ostree = require("rpm-ostree")?;
+    let mut command = ctx.run_type().execute(ostree);
+    command.arg("upgrade");
+    command.status_checked()?;
     Ok(())
 }
 
 fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["brl", "update"]).check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["zypper", "refresh"]).check_run()?;
+    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"])
-            .check_run()?;
+        .arg("zypper")
+        .arg(if ctx.config().suse_dup() {
+            "dist-upgrade"
         } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+            "update"
+        })
+        .status_checked()?;
+
+    Ok(())
+}
+
+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(["zypper", "refresh"])
+        .status_checked()?;
+
+    ctx.run_type()
+        .execute(sudo)
+        .arg("zypper")
+        .arg("dist-upgrade")
+        .status_checked()?;
+
+    Ok(())
+}
+
+fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["transactional-update", "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");
@@ -235,32 +301,70 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
         command.arg("-y");
     }
 
-        command.check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    command.status_checked()?;
+
+    Ok(())
+}
+fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
+    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");
+
+    if let Some(args) = ctx.config().dnf_arguments() {
+        command_update.args(args.split_whitespace());
     }
 
+    if ctx.config().yes(Step::System) {
+        command_update.arg("-y");
+    }
+
+    command_update.status_checked()?;
+
+    ctx.run_type()
+        .execute(sudo)
+        .arg(&which("apt-get").unwrap())
+        .arg("dist-upgrade")
+        .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) {
         command.arg("-y");
     }
-        command.check_run()?;
+    command.status_checked()?;
 
     let mut command = ctx.run_type().execute(sudo);
     command.args(["xbps-install", "-u"]);
     if ctx.config().yes(Step::System) {
         command.arg("-y");
     }
-        command.check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    command.status_checked()?;
 
     Ok(())
 }
@@ -268,9 +372,13 @@ 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).arg(layman).args(["-s", "ALL"]).check_run()?;
+        run_type
+            .execute(sudo)
+            .arg(layman)
+            .args(["-s", "ALL"])
+            .status_checked()?;
     }
 
     println!("Syncing portage");
@@ -283,10 +391,10 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
                 .map(|s| s.split_whitespace().collect())
                 .unwrap_or_else(|| vec!["-q"]),
         )
-            .check_run()?;
+        .status_checked()?;
 
     if let Some(eix_update) = which("eix-update") {
-            run_type.execute(sudo).arg(eix_update).check_run()?;
+        run_type.execute(sudo).arg(eix_update).status_checked()?;
     }
 
     run_type
@@ -298,23 +406,49 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
                 .map(|s| s.split_whitespace().collect())
                 .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
         )
-            .check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
     let apt = which("apt-fast")
-            .or_else(|| which("nala"))
+        .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_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").check_run()?;
+        ctx.run_type()
+            .execute(sudo)
+            .arg(&apt)
+            .arg("update")
+            .status_checked_with_codes(&[0, 100])?;
     }
 
     let mut command = ctx.run_type().execute(sudo);
@@ -330,20 +464,17 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
     if let Some(args) = ctx.config().apt_arguments() {
         command.args(args.split_whitespace());
     }
-        command.check_run()?;
+    command.status_checked()?;
 
     if ctx.config().cleanup() {
-            ctx.run_type().execute(sudo).arg(&apt).arg("clean").check_run()?;
+        ctx.run_type().execute(sudo).arg(&apt).arg("clean").status_checked()?;
 
         let mut command = ctx.run_type().execute(sudo);
         command.arg(&apt).arg("autoremove");
         if ctx.config().yes(Step::System) {
             command.arg("-y");
         }
-            command.check_run()?;
-        }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+        command.status_checked()?;
     }
 
     Ok(())
@@ -354,35 +485,77 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("deb-get");
 
-    ctx.execute_elevated(&deb_get, false)?.arg("update").check_run()?;
-    ctx.execute_elevated(&deb_get, false)?.arg("upgrade").check_run()?;
+    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").check_run()?;
+        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"]).check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["eopkg", "upgrade"])
+        .status_checked()?;
 
     Ok(())
 }
 
+pub fn run_am(ctx: &ExecutionContext) -> Result<()> {
+    let am = require("am")?;
+
+    print_separator("AM");
+
+    let mut am = ctx.run_type().execute(am);
+
+    if ctx.config().yes(Step::AM) {
+        am.arg("-U");
+    } else {
+        am.arg("-u");
+    }
+
+    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<()> {
     let pacdef = require("pacdef")?;
 
     print_separator("pacdef");
 
-    ctx.run_type().execute(&pacdef).arg("sync").check_run()?;
+    let output = ctx.run_type().execute(&pacdef).arg("version").output_checked()?;
+    let string = String::from_utf8(output.stdout)?;
+    let new_version = string.contains("version: 1");
+
+    if new_version {
+        ctx.run_type()
+            .execute(&pacdef)
+            .args(["package", "sync"])
+            .status_checked()?;
 
         println!();
-    ctx.run_type().execute(&pacdef).arg("review").check_run()
+        ctx.run_type()
+            .execute(&pacdef)
+            .args(["package", "review"])
+            .status_checked()?;
+    } else {
+        ctx.run_type().execute(&pacdef).arg("sync").status_checked()?;
+
+        println!();
+        ctx.run_type().execute(&pacdef).arg("review").status_checked()?;
+    }
+    Ok(())
 }
 
 pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
@@ -390,64 +563,91 @@ pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Pacstall");
 
-    ctx.run_type().execute(&pacstall).arg("-U").check_run()?;
-    ctx.run_type().execute(pacstall).arg("-Up").check_run()
+    let mut update_cmd = ctx.run_type().execute(&pacstall);
+    let mut upgrade_cmd = ctx.run_type().execute(pacstall);
+
+    if ctx.config().yes(Step::Pacstall) {
+        update_cmd.arg("-P");
+        upgrade_cmd.arg("-P");
+    }
+
+    update_cmd.arg("-U").status_checked()?;
+    upgrade_cmd.arg("-Up").status_checked()
+}
+
+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(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<()> {
-    if let Some(sudo) = &ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["swupd", "update"]).check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["swupd", "update"])
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["cave", "sync"]).check_run()?;
+    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()
         .execute(sudo)
         .args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
-            .check_run()?;
+        .status_checked()?;
 
     if ctx.config().cleanup() {
-            ctx.run_type().execute(sudo).args(["cave", "purge", "-x"]).check_run()?;
+        ctx.run_type()
+            .execute(sudo)
+            .args(["cave", "purge", "-x"])
+            .status_checked()?;
     }
 
     ctx.run_type()
         .execute(sudo)
         .args(["cave", "fix-linkage", "-x", "--", "-Cs"])
-            .check_run()?;
+        .status_checked()?;
 
     ctx.run_type()
         .execute(sudo)
         .args(["eclectic", "config", "interactive"])
-            .check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"])
-            .check_run()?;
+    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"]);
+
+    if let Some(args) = ctx.config().nix_arguments() {
+        command.args(args.split_whitespace());
+    }
+    command.status_checked()?;
 
     if ctx.config().cleanup() {
         ctx.run_type()
             .execute(sudo)
             .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
-                .check_run()?;
-        }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+            .status_checked()?;
     }
 
     Ok(())
@@ -459,10 +659,15 @@ 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().execute(sudo).arg(&pkcon).arg("refresh").check_run()?;
+    ctx.run_type()
+        .execute(sudo)
+        .arg(&pkcon)
+        .arg("refresh")
+        .status_checked()?;
     let mut exe = ctx.run_type().execute(sudo);
     let cmd = exe.arg(&pkcon).arg("update");
     if ctx.config().yes(Step::System) {
@@ -472,14 +677,13 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
         cmd.arg("--autoremove");
     }
     // from pkcon man, exit code 5 is 'Nothing useful was done.'
-        cmd.check_run_with_codes(&[5])?;
-    }
+    cmd.status_checked_with_codes(&[5])?;
 
     Ok(())
 }
 
-pub fn run_needrestart(sudo: Option<&PathBuf>, 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()?;
 
@@ -489,7 +693,7 @@ pub fn run_needrestart(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()>
 
     print_separator("Check for needed restarts");
 
-    run_type.execute(sudo).arg(needrestart).check_run()?;
+    ctx.run_type().execute(sudo).arg(needrestart).status_checked()?;
 
     Ok(())
 }
@@ -506,7 +710,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(&fwupdmgr)
         .arg("refresh")
-        .check_run_with_codes(&[2])?;
+        .status_checked_with_codes(&[2])?;
 
     let mut updmgr = ctx.run_type().execute(&fwupdmgr);
 
@@ -518,12 +722,12 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     } else {
         updmgr.arg("get-updates");
     }
-    updmgr.check_run_with_codes(&[2])
+    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();
@@ -533,14 +737,14 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
     if yes {
         update_args.push("-y");
     }
-    run_type.execute(&flatpak).args(&update_args).check_run()?;
+    run_type.execute(&flatpak).args(&update_args).status_checked()?;
 
     if cleanup {
         let mut cleanup_args = vec!["uninstall", "--user", "--unused"];
         if yes {
             cleanup_args.push("-y");
         }
-        run_type.execute(&flatpak).args(&cleanup_args).check_run()?;
+        run_type.execute(&flatpak).args(&cleanup_args).status_checked()?;
     }
 
     print_separator("Flatpak System Packages");
@@ -549,34 +753,42 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
         if yes {
             update_args.push("-y");
         }
-        run_type.execute(sudo).arg(&flatpak).args(&update_args).check_run()?;
+        run_type
+            .execute(sudo)
+            .arg(&flatpak)
+            .args(&update_args)
+            .status_checked()?;
         if cleanup {
             let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
             if yes {
                 cleanup_args.push("-y");
             }
-            run_type.execute(sudo).arg(flatpak).args(&cleanup_args).check_run()?;
+            run_type
+                .execute(sudo)
+                .arg(flatpak)
+                .args(&cleanup_args)
+                .status_checked()?;
         }
     } else {
         let mut update_args = vec!["update", "--system"];
         if yes {
             update_args.push("-y");
         }
-        run_type.execute(&flatpak).args(&update_args).check_run()?;
+        run_type.execute(&flatpak).args(&update_args).status_checked()?;
         if cleanup {
             let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
             if yes {
                 cleanup_args.push("-y");
             }
-            run_type.execute(flatpak).args(&cleanup_args).check_run()?;
+            run_type.execute(flatpak).args(&cleanup_args).status_checked()?;
         }
     }
 
     Ok(())
 }
 
-pub fn run_snap(sudo: Option<&PathBuf>, 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() {
@@ -584,17 +796,17 @@ pub fn run_snap(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     }
     print_separator("snap");
 
-    run_type.execute(sudo).arg(snap).arg("refresh").check_run()
+    ctx.run_type().execute(sudo).arg(snap).arg("refresh").status_checked()
 }
 
-pub fn run_pihole_update(sudo: Option<&PathBuf>, 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").check_run()
+    ctx.run_type().execute(sudo).arg(pihole).arg("-up").status_checked()
 }
 
 pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
@@ -602,15 +814,17 @@ pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("protonup");
 
-    ctx.run_type().execute(protonup).check_run()?;
+    ctx.run_type().execute(protonup).status_checked()?;
     Ok(())
 }
 
 pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
+    let distrobox = require("distrobox")?;
+
     print_separator("Distrobox");
     match (
         match (
-            ctx.run_type().execute("distrobox").arg("upgrade"),
+            ctx.run_type().execute(distrobox).arg("upgrade"),
             ctx.config().distrobox_containers(),
         ) {
             (r, Some(c)) => {
@@ -626,25 +840,48 @@ pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
         (r, true) => r.arg("--root"),
         (r, false) => r,
     }
-    .check_run()
+    .status_checked()
+}
+
+pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let dkp_pacman = require("dkp-pacman")?;
+
+    print_separator("Devkitpro pacman");
+
+    ctx.run_type()
+        .execute(sudo)
+        .arg(&dkp_pacman)
+        .arg("-Syu")
+        .status_checked()?;
+
+    if ctx.config().cleanup() {
+        ctx.run_type()
+            .execute(sudo)
+            .arg(&dkp_pacman)
+            .arg("-Scc")
+            .status_checked()?;
+    }
+
+    Ok(())
 }
 
 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());
     }
 
     if let Ok(etc_update) = require("etc-update") {
         print_separator("Configuration update");
-        ctx.run_type().execute(sudo).arg(etc_update).check_run()?;
+        ctx.run_type().execute(sudo).arg(etc_update).status_checked()?;
     } else if let Ok(pacdiff) = require("pacdiff") {
         if std::env::var("DIFFPROG").is_err() {
             require("vim")?;
         }
 
         print_separator("Configuration update");
-        ctx.execute_elevated(&pacdiff, false)?.check_run()?;
+        ctx.execute_elevated(&pacdiff, false)?.status_checked()?;
     }
 
     Ok(())
@@ -713,11 +950,6 @@ mod tests {
         test_template(include_str!("os_release/fedora"), Distribution::Fedora);
     }
 
-    #[test]
-    fn test_antergos() {
-        test_template(include_str!("os_release/antergos"), Distribution::Arch);
-    }
-
     #[test]
     fn test_manjaro() {
         test_template(include_str!("os_release/manjaro"), Distribution::Arch);
@@ -728,11 +960,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);
@@ -777,4 +1004,14 @@ 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);
+    }
 }

src/steps/os/macos.rs

@@ -1,36 +1,41 @@
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
 use crate::terminal::{print_separator, prompt_yesno};
-use crate::{error::TopgradeError, utils::require, Step};
-use anyhow::Result;
-use log::debug;
+use crate::utils::{require_option, REQUIRE_SUDO};
+use crate::{utils::require, Step};
+use color_eyre::eyre::Result;
 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).args(["port", "selfupdate"]).check_run()?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["port", "selfupdate"])
+        .status_checked()?;
     ctx.run_type()
         .execute(sudo)
         .args(["port", "-u", "upgrade", "outdated"])
-        .check_run()?;
+        .status_checked()?;
     if ctx.config().cleanup() {
         ctx.run_type()
             .execute(sudo)
             .args(["port", "-N", "reclaim"])
-            .check_run()?;
+            .status_checked()?;
     }
 
     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").check_run()
+    ctx.run_type().execute(mas).arg("upgrade").status_checked()
 }
 
 pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
@@ -58,20 +63,15 @@ pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
         command.arg("--no-scan");
     }
 
-    command.check_run()
+    command.status_checked()
 }
 
 fn system_update_available() -> Result<bool> {
-    let output = Command::new("softwareupdate").arg("--list").output()?;
+    let output = Command::new("softwareupdate").arg("--list").output_checked_utf8()?;
+
     debug!("{:?}", output);
 
-    let status = output.status;
-    if !status.success() {
-        return Err(TopgradeError::ProcessFailed(status).into());
-    }
-    let string_output = String::from_utf8(output.stderr)?;
-    debug!("{:?}", string_output);
-    Ok(!string_output.contains("No new software available"))
+    Ok(!output.stderr.contains("No new software available"))
 }
 
 pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
@@ -83,12 +83,12 @@ pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
         let probe = Command::new(&sparkle)
             .args(["--probe", "--application"])
             .arg(application.path())
-            .check_output();
+            .output_checked_utf8();
         if probe.is_ok() {
             let mut command = ctx.run_type().execute(&sparkle);
             command.args(["bundle", "--check-immediately", "--application"]);
             command.arg(application.path());
-            command.spawn()?.wait()?;
+            command.status_checked()?;
         }
     }
     Ok(())

src/steps/os/openbsd.rs

@@ -1,17 +1,23 @@
-use crate::executor::RunType;
+use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
-use anyhow::Result;
+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.execute(sudo).args(&["/usr/sbin/sysupgrade", "-n"]).check_run()
+    ctx.run_type()
+        .execute(sudo)
+        .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.execute(sudo).args(&["/usr/sbin/pkg_add", "-u"]).check_run()
+    ctx.run_type()
+        .execute(sudo)
+        .args(&["/usr/sbin/pkg_add", "-u"])
+        .status_checked()
 }

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/pclinuxos

@@ -0,0 +1,9 @@
+NAME="PCLinuxOS"
+VERSION="2022"
+ID=pclinuxos
+VERSION_ID=2022
+ID_LIKE="mandriva"
+PRETTY_NAME="PCLinuxOS 2022"
+ANSI_COLOR="1;37"
+HOME_URL="http://www.pclinuxos.com/"
+SUPPORT_URL="http://www.pclinuxos.com/"

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/unix.rs

@@ -1,33 +1,41 @@
-use crate::error::{SkipStep, TopgradeError};
-use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, Executor, ExecutorExitStatus, RunType};
-use crate::terminal::print_separator;
-#[cfg(not(target_os = "macos"))]
-use crate::utils::require_option;
-use crate::utils::{require, PathExt};
-use crate::Step;
-use anyhow::Result;
-use directories::BaseDirs;
-use home;
-use ini::Ini;
-use log::debug;
 use std::fs;
 use std::os::unix::fs::MetadataExt;
 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::Result;
+use home;
+use ini::Ini;
+use tracing::debug;
+
+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;
+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";
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 const ARM_BREW: &str = "/opt/homebrew/bin/brew";
 
 #[derive(Copy, Clone, Debug)]
 #[allow(dead_code)]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 pub enum BrewVariant {
     Path,
     MacIntel,
     MacArm,
 }
 
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 impl BrewVariant {
     fn binary_name(self) -> &'static str {
         match self {
@@ -77,84 +85,123 @@ impl BrewVariant {
     }
 }
 
-pub fn run_fisher(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
     let fish = require("fish")?;
 
-    if env::var("fisher_path").is_err() {
-        base_dirs
-            .home_dir()
-            .join(".config/fish/functions/fisher.fish")
-            .require()?;
-    }
+    Command::new(&fish)
+        .args(["-c", "type -t fisher"])
+        .output_checked_utf8()
+        .map(|_| ())
+        .map_err(|_| SkipStep("`fisher` is not defined in `fish`".to_owned()))?;
+
+    Command::new(&fish)
+        .args(["-c", "echo \"$__fish_config_dir/fish_plugins\""])
+        .output_checked_utf8()
+        .and_then(|output| Path::new(&output.stdout.trim()).require().map(|_| ()))
+        .map_err(|err| SkipStep(format!("`fish_plugins` path doesn't exist: {err}")))?;
+
+    Command::new(&fish)
+        .args(["-c", "fish_update_completions"])
+        .output_checked_utf8()
+        .map(|_| ())
+        .map_err(|_| SkipStep("`fish_update_completions` is not available".to_owned()))?;
 
     print_separator("Fisher");
 
-    let version_str = run_type
+    let version_str = ctx
+        .run_type()
         .execute(&fish)
         .args(["-c", "fisher --version"])
-        .check_output()?;
+        .output_checked_utf8()?
+        .stdout;
     debug!("Fisher version: {}", version_str);
 
     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"]).check_run()
+        ctx.run_type().execute(&fish).args(["-c", "fisher"]).status_checked()
     } else {
         // v4
-        run_type.execute(&fish).args(["-c", "fisher update"]).check_run()
+        ctx.run_type()
+            .execute(&fish)
+            .args(["-c", "fisher update"])
+            .status_checked()
     }
 }
 
 pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
-    ctx.base_dirs().home_dir().join(".bash_it").require()?;
+    HOME_DIR.join(".bash_it").require()?;
 
     print_separator("Bash-it");
 
     ctx.run_type()
         .execute("bash")
         .args(["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
-        .check_run()
+        .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")?;
-    ctx.base_dirs()
-        .home_dir()
-        .join(".local/share/omf/pkg/omf/functions/omf.fish")
-        .require()?;
+    HOME_DIR.join(".local/share/omf/pkg/omf/functions/omf.fish").require()?;
 
     print_separator("oh-my-fish");
 
-    ctx.run_type().execute(fish).args(["-c", "omf update"]).check_run()
+    ctx.run_type().execute(fish).args(["-c", "omf update"]).status_checked()
 }
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
     let pkgin = require("pkgin")?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
-    let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
+    print_separator("Pkgin");
+
+    let mut command = ctx.run_type().execute(sudo);
     command.arg(&pkgin).arg("update");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
-    command.check_run()?;
+    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");
     }
-    command.check_run()
+    command.status_checked()
 }
 
 pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
     let fish = require("fish")?;
-    ctx.base_dirs()
-        .home_dir()
+    HOME_DIR
         .join(".local/share/fish/plug/kidonng/fish-plug/functions/plug.fish")
         .require()?;
 
     print_separator("fish-plug");
 
-    ctx.run_type().execute(fish).args(["-c", "plug update"]).check_run()
+    ctx.run_type()
+        .execute(fish)
+        .args(["-c", "plug update"])
+        .status_checked()
 }
 
 /// Upgrades `fundle` and `fundle` plugins.
@@ -164,21 +211,21 @@ pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
 /// See: <https://github.com/danhper/fundle>
 pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
     let fish = require("fish")?;
-    ctx.base_dirs().home_dir().join(".config/fish/fundle").require()?;
+    HOME_DIR.join(".config/fish/fundle").require()?;
 
     print_separator("fundle");
 
     ctx.run_type()
         .execute(fish)
         .args(["-c", "fundle self-update && fundle update"])
-        .check_run()
+        .status_checked()
 }
 
 #[cfg(not(any(target_os = "android", target_os = "macos")))]
 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")
@@ -192,10 +239,10 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
             "--method",
             "org.freedesktop.DBus.ListActivatableNames",
         ])
-        .check_output()?;
+        .output_checked_utf8()?;
 
     debug!("Checking for gnome extensions: {}", output);
-    if !output.contains("org.gnome.Shell.Extensions") {
+    if !output.stdout.contains("org.gnome.Shell.Extensions") {
         return Err(SkipStep(String::from("Gnome shell extensions are unregistered in DBus")).into());
     }
 
@@ -213,9 +260,10 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
             "--method",
             "org.gnome.Shell.Extensions.CheckForUpdates",
         ])
-        .check_run()
+        .status_checked()
 }
 
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()> {
     #[allow(unused_variables)]
     let binary_name = require(variant.binary_name())?;
@@ -230,18 +278,18 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
     print_separator(variant.step_title());
     let run_type = ctx.run_type();
 
-    variant.execute(run_type).arg("update").check_run()?;
+    variant.execute(run_type).arg("update").status_checked()?;
     variant
         .execute(run_type)
         .args(["upgrade", "--ignore-pinned", "--formula"])
-        .check_run()?;
+        .status_checked()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").check_run()?;
+        variant.execute(run_type).arg("cleanup").status_checked()?;
     }
 
     if ctx.config().brew_autoremove() {
-        variant.execute(run_type).arg("autoremove").check_run()?;
+        variant.execute(run_type).arg("autoremove").status_checked()?;
     }
 
     Ok(())
@@ -259,8 +307,8 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
     let cask_upgrade_exists = variant
         .execute(RunType::Wet)
         .args(["--repository", "buo/cask-upgrade"])
-        .check_output()
-        .map(|p| Path::new(p.trim()).exists())?;
+        .output_checked_utf8()
+        .map(|p| Path::new(p.stdout.trim()).exists())?;
 
     let mut brew_args = vec![];
 
@@ -276,10 +324,10 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
         }
     }
 
-    variant.execute(run_type).args(&brew_args).check_run()?;
+    variant.execute(run_type).args(&brew_args).status_checked()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").check_run()?;
+        variant.execute(run_type).arg("cleanup").status_checked()?;
     }
 
     Ok(())
@@ -290,7 +338,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
 
     let run_type = ctx.run_type();
 
-    let output = Command::new(&guix).arg("pull").check_output();
+    let output = Command::new(&guix).arg("pull").output_checked_utf8();
     debug!("guix pull output: {:?}", output);
     let should_upgrade = output.is_ok();
     debug!("Can Upgrade Guix: {:?}", should_upgrade);
@@ -298,7 +346,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Guix");
 
     if should_upgrade {
-        return run_type.execute(&guix).args(["package", "-u"]).check_run();
+        return run_type.execute(&guix).args(["package", "-u"]).status_checked();
     }
     Err(SkipStep(String::from("Guix Pull Failed, Skipping")).into())
 }
@@ -307,6 +355,7 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     let nix = require("nix")?;
     let nix_channel = require("nix-channel")?;
     let nix_env = require("nix-env")?;
+    // TODO: Is None possible here?
     let profile_path = match home::home_dir() {
         Some(home) => Path::new(&home).join(".nix-profile"),
         None => Path::new("/nix/var/nix/profiles/per-user/default").into(),
@@ -314,7 +363,7 @@ 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"]).check_output();
+    let output = Command::new(&nix_env).args(["--query", "nix"]).output_checked_utf8();
     debug!("nix-env output: {:?}", output);
     let should_self_upgrade = output.is_ok();
 
@@ -346,23 +395,23 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
 
     if should_self_upgrade {
         if multi_user {
-            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").check_run()?;
+            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").status_checked()?;
         } else {
-            run_type.execute(&nix).arg("upgrade-nix").check_run()?;
+            run_type.execute(&nix).arg("upgrade-nix").status_checked()?;
         }
     }
 
-    run_type.execute(nix_channel).arg("--update").check_run()?;
+    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)
             .arg("profile")
             .arg("upgrade")
             .arg(".*")
-            .check_run()
+            .status_checked()
     } else {
-        run_type.execute(&nix_env).arg("--upgrade").check_run()
+        run_type.execute(&nix_env).arg("--upgrade").status_checked()
     }
 }
 
@@ -371,50 +420,51 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("yadm");
 
-    ctx.run_type().execute(yadm).arg("pull").check_run()
+    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");
-    let exit_status = run_type.execute(&asdf).arg("update").spawn()?.wait()?;
+    ctx.run_type()
+        .execute(&asdf)
+        .arg("update")
+        .status_checked_with_codes(&[42])?;
 
-    if let ExecutorExitStatus::Wet(e) = exit_status {
-        if !(e.success() || e.code().map(|c| c == 42).unwrap_or(false)) {
-            return Err(TopgradeError::ProcessFailed(e).into());
-        }
-    }
-    run_type.execute(&asdf).args(["plugin", "update", "--all"]).check_run()
+    ctx.run_type()
+        .execute(&asdf)
+        .args(["plugin", "update", "--all"])
+        .status_checked()
 }
 
-pub fn run_home_manager(run_type: RunType) -> Result<()> {
+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").check_run()
+    ctx.run_type().execute(home_manager).arg("switch").status_checked()
 }
 
-pub fn run_tldr(run_type: RunType) -> Result<()> {
+pub fn run_tldr(ctx: &ExecutionContext) -> Result<()> {
     let tldr = require("tldr")?;
 
     print_separator("TLDR");
-    run_type.execute(tldr).arg("--update").check_run()
+    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").check_run()
+    ctx.run_type().execute(pearl).arg("update").status_checked()
 }
 
-pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Result<()> {
+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(|_| base_dirs.home_dir().join(".sdkman"))
+        .unwrap_or_else(|_| HOME_DIR.join(".sdkman"))
         .join("bin")
         .join("sdkman-init.sh")
         .require()
@@ -422,9 +472,9 @@ pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Res
 
     print_separator("SDKMAN!");
 
-    let sdkman_config_path = env::var("SDKMAN_DIR")
+    let sdkman_config_path = var("SDKMAN_DIR")
         .map(PathBuf::from)
-        .unwrap_or_else(|_| base_dirs.home_dir().join(".sdkman"))
+        .unwrap_or_else(|_| HOME_DIR.join(".sdkman"))
         .join("etc")
         .join("config")
         .require()?;
@@ -437,30 +487,36 @@ pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Res
 
     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()])
-            .check_run()?;
+            .status_checked()?;
     }
 
     let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
-    run_type.execute(&bash).args(["-c", cmd_update.as_str()]).check_run()?;
+    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.execute(&bash).args(["-c", cmd_upgrade.as_str()]).check_run()?;
+    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()])
-            .check_run()?;
+            .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()])
-            .check_run()?;
+            .status_checked()?;
     }
 
     Ok(())
@@ -471,7 +527,7 @@ pub fn run_bun(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Bun");
 
-    ctx.run_type().execute(bun).arg("upgrade").check_run()
+    ctx.run_type().execute(bun).arg("upgrade").status_checked()
 }
 
 /// Update dotfiles with `rcm(7)`.
@@ -481,10 +537,17 @@ pub fn run_rcm(ctx: &ExecutionContext) -> Result<()> {
     let rcup = require("rcup")?;
 
     print_separator("rcm");
-    ctx.run_type().execute(rcup).arg("-v").check_run()
+    ctx.run_type().execute(rcup).arg("-v").status_checked()
 }
 
-pub fn reboot() {
-    print!("Rebooting...");
-    Command::new("sudo").arg("reboot").spawn().unwrap().wait().unwrap();
+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

@@ -2,11 +2,12 @@ use std::convert::TryFrom;
 use std::path::Path;
 use std::{ffi::OsStr, process::Command};
 
-use anyhow::Result;
-use log::debug;
+use color_eyre::eyre::Result;
+use etcetera::base_strategy::BaseStrategy;
+use tracing::debug;
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
 use crate::terminal::{print_separator, print_warning};
 use crate::utils::require;
 use crate::{error::SkipStep, steps::git::Repositories};
@@ -18,23 +19,22 @@ pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Chocolatey");
 
-    let mut cmd = &choco;
-    let mut args = vec!["upgrade", "all"];
-
-    if let Some(sudo) = ctx.sudo() {
-        cmd = sudo;
-        args.insert(0, "choco");
+    let mut command = match ctx.sudo() {
+        Some(sudo) => {
+            let mut command = ctx.run_type().execute(sudo);
+            command.arg(choco);
+            command
         }
+        None => ctx.run_type().execute(choco),
+    };
 
-    let mut command = ctx.run_type().execute(&cmd);
-
-    command.args(&args);
+    command.args(["upgrade", "all"]);
 
     if yes {
         command.arg("--yes");
     }
 
-    command.check_run()
+    command.status_checked()
 }
 
 pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
@@ -47,49 +47,71 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
         return Err(SkipStep(String::from("Winget is disabled by default")).into());
     }
 
-    ctx.run_type().execute(&winget).args(&["upgrade", "--all"]).check_run()
+    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"]).check_run()?;
-    run_type.execute(&scoop).args(&["update", "*"]).check_run()?;
+    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", "*"]).check_run()?;
+    if ctx.config().cleanup() {
+        ctx.run_type().execute(&scoop).args(["cleanup", "*"]).status_checked()?;
     }
 
     Ok(())
 }
 
+pub fn update_wsl(ctx: &ExecutionContext) -> Result<()> {
+    let wsl = require("wsl")?;
+
+    print_separator("Update WSL");
+
+    let mut wsl_command = ctx.run_type().execute(wsl);
+    wsl_command.args(["--update"]);
+
+    if ctx.config().wsl_update_pre_release() {
+        wsl_command.args(["--pre-release"]);
+    }
+
+    if ctx.config().wsl_update_use_web_download() {
+        wsl_command.args(["--web-download"]);
+    }
+    wsl_command.status_checked()?;
+    Ok(())
+}
+
 fn get_wsl_distributions(wsl: &Path) -> Result<Vec<String>> {
-    let output = Command::new(wsl).args(&["--list", "-q"]).check_output()?;
+    let output = Command::new(wsl).args(["--list", "-q"]).output_checked_utf8()?.stdout;
     Ok(output
         .lines()
         .filter(|s| !s.is_empty())
-        .map(|x| x.replace('\u{0}', "").replace('\r', ""))
+        .map(|x| x.replace(['\u{0}', '\r'], ""))
         .collect())
 }
 
 fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> Result<()> {
-    let topgrade = Command::new(&wsl)
-        .args(&["-d", dist, "bash", "-lc", "which topgrade"])
-        .check_output()
+    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")))?;
 
-    let mut command = ctx.run_type().execute(&wsl);
+    let mut command = ctx.run_type().execute(wsl);
     command
-        .args(&["-d", dist, "bash", "-c"])
-        .arg(format!("TOPGRADE_PREFIX={} exec {}", dist, topgrade));
+        .args(["-d", dist, "bash", "-c"])
+        .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade}"));
 
     if ctx.config().yes(Step::Wsl) {
         command.arg("-y");
     }
 
-    command.check_run()
+    command.status_checked()
 }
 
 pub fn run_wsl_topgrade(ctx: &ExecutionContext) -> Result<()> {
@@ -129,17 +151,21 @@ pub fn windows_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Windows Update");
     println!("Running Windows Update. Check the control panel for progress.");
-    ctx.run_type().execute(&usoclient).arg("ScanInstallWait").check_run()?;
-    ctx.run_type().execute(&usoclient).arg("StartInstall").check_run()
+    ctx.run_type()
+        .execute(&usoclient)
+        .arg("ScanInstallWait")
+        .status_checked()?;
+    ctx.run_type().execute(&usoclient).arg("StartInstall").status_checked()
 }
 
-pub fn reboot() {
-    Command::new("shutdown").args(&["/R", "/T", "0"]).spawn().ok();
+pub fn reboot() -> Result<()> {
+    // If this works, it won't return, but if it doesn't work, it may return a useful error
+    // message.
+    Command::new("shutdown").args(["/R", "/T", "0"]).status_checked()
 }
 
-pub fn insert_startup_scripts(ctx: &ExecutionContext, git_repos: &mut Repositories) -> Result<()> {
-    let startup_dir = ctx
-        .base_dirs()
+pub fn insert_startup_scripts(git_repos: &mut Repositories) -> Result<()> {
+    let startup_dir = crate::WINDOWS_DIRS
         .data_dir()
         .join("Microsoft\\Windows\\Start Menu\\Programs\\Startup");
     for entry in std::fs::read_dir(&startup_dir)?.flatten() {

src/steps/powershell.rs

@@ -3,10 +3,10 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::CommandExt;
 use crate::terminal::{is_dumb, print_separator};
 use crate::utils::{require_option, which, PathExt};
 use crate::Step;
@@ -27,8 +27,8 @@ impl Powershell {
         let profile = path.as_ref().and_then(|path| {
             Command::new(path)
                 .args(["-NoProfile", "-Command", "Split-Path $profile"])
-                .check_output()
-                .map(|output| PathBuf::from(output.trim()))
+                .output_checked_utf8()
+                .map(|output| PathBuf::from(output.stdout.trim()))
                 .and_then(|p| p.require())
                 .ok()
         });
@@ -46,14 +46,14 @@ impl Powershell {
 
     #[cfg(windows)]
     pub fn has_module(powershell: &Path, command: &str) -> bool {
-        Command::new(&powershell)
-            .args(&[
+        Command::new(powershell)
+            .args([
                 "-NoProfile",
                 "-Command",
-                &format!("Get-Module -ListAvailable {}", command),
+                &format!("Get-Module -ListAvailable {command}"),
             ])
-            .check_output()
-            .map(|result| !result.is_empty())
+            .output_checked_utf8()
+            .map(|result| !result.stdout.is_empty())
             .unwrap_or(false)
     }
 
@@ -81,7 +81,7 @@ impl Powershell {
             .execute(powershell)
             // This probably doesn't need `shell_words::join`.
             .args(["-NoProfile", "-Command", &cmd.join(" ")])
-            .check_run()
+            .status_checked()
     }
 
     #[cfg(windows)]
@@ -100,14 +100,14 @@ impl Powershell {
 
         let mut command = if let Some(sudo) = ctx.sudo() {
             let mut command = ctx.run_type().execute(sudo);
-            command.arg(&powershell);
+            command.arg(powershell);
             command
         } else {
-            ctx.run_type().execute(&powershell)
+            ctx.run_type().execute(powershell)
         };
 
         command
-            .args(&[
+            .args([
                 "-NoProfile",
                 "-Command",
                 &format!(
@@ -119,6 +119,6 @@ impl Powershell {
                     }
                 ),
             ])
-            .check_run()
+            .status_checked()
     }
 }

src/steps/remote/ssh.rs

@@ -1,6 +1,8 @@
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
-use crate::{error::SkipStep, execution_context::ExecutionContext, terminal::print_separator, utils};
+use crate::{
+    command::CommandExt, error::SkipStep, execution_context::ExecutionContext, terminal::print_separator, utils,
+};
 
 fn prepare_async_ssh_command(args: &mut Vec<&str>) {
     args.insert(0, "ssh");
@@ -17,14 +19,14 @@ pub fn ssh_step(ctx: &ExecutionContext, hostname: &str) -> Result<()> {
         args.extend(ssh_arguments.split_whitespace());
     }
 
-    let env = format!("TOPGRADE_PREFIX={}", hostname);
+    let env = format!("TOPGRADE_PREFIX={hostname}");
     args.extend(["env", &env, "$SHELL", "-lc", topgrade]);
 
     if ctx.config().run_in_tmux() && !ctx.run_type().dry() {
         #[cfg(unix)]
         {
             prepare_async_ssh_command(&mut args);
-            crate::tmux::run_command(ctx, &shell_words::join(args))?;
+            crate::tmux::run_command(ctx, hostname, &shell_words::join(args))?;
             Err(SkipStep(String::from("Remote Topgrade launched in Tmux")).into())
         }
 
@@ -41,12 +43,12 @@ pub fn ssh_step(ctx: &ExecutionContext, hostname: &str) -> Result<()> {
             args.extend(ssh_arguments.split_whitespace());
         }
 
-        let env = format!("TOPGRADE_PREFIX={}", hostname);
+        let env = format!("TOPGRADE_PREFIX={hostname}");
         args.extend(["env", &env, "$SHELL", "-lc", topgrade]);
 
-        print_separator(format!("Remote ({})", hostname));
-        println!("Connecting to {}...", hostname);
+        print_separator(format!("Remote ({hostname})"));
+        println!("Connecting to {hostname}...");
 
-        ctx.run_type().execute(ssh).args(&args).check_run()
+        ctx.run_type().execute(ssh).args(&args).status_checked()
     }
 }

src/steps/remote/vagrant.rs

@@ -2,13 +2,13 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::{fmt::Display, rc::Rc, str::FromStr};
 
-use anyhow::Result;
-use log::{debug, error};
+use color_eyre::eyre::Result;
 use regex::Regex;
 use strum::EnumString;
+use tracing::{debug, error};
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::CommandExt;
 use crate::terminal::print_separator;
 use crate::{error::SkipStep, utils, Step};
 
@@ -61,10 +61,11 @@ impl Vagrant {
         let output = Command::new(&self.path)
             .arg("status")
             .current_dir(directory)
-            .check_output()?;
+            .output_checked_utf8()?;
         debug!("Vagrant output in {}: {}", directory, output);
 
         let boxes = output
+            .stdout
             .split('\n')
             .skip(2)
             .take_while(|line| !(line.is_empty() || line.starts_with('\r')))
@@ -115,7 +116,7 @@ impl<'a> TemporaryPowerOn<'a> {
             .execute(vagrant)
             .args([subcommand, &vagrant_box.name])
             .current_dir(vagrant_box.path.clone())
-            .check_run()?;
+            .status_checked()?;
         Ok(TemporaryPowerOn {
             vagrant,
             vagrant_box,
@@ -142,7 +143,7 @@ impl<'a> Drop for TemporaryPowerOn<'a> {
             .execute(self.vagrant)
             .args([subcommand, &self.vagrant_box.name])
             .current_dir(self.vagrant_box.path.clone())
-            .check_run()
+            .status_checked()
             .ok();
     }
 }
@@ -182,7 +183,7 @@ pub fn topgrade_vagrant_box(ctx: &ExecutionContext, vagrant_box: &VagrantBox) ->
     let mut _poweron = None;
     if !vagrant_box.initial_status.powered_on() {
         if !(ctx.config().vagrant_power_on().unwrap_or(true)) {
-            return Err(SkipStep(format!("Skipping powered off box {}", vagrant_box)).into());
+            return Err(SkipStep(format!("Skipping powered off box {vagrant_box}")).into());
         } else {
             print_separator(seperator);
             _poweron = Some(vagrant.temporary_power_on(vagrant_box, ctx)?);
@@ -199,7 +200,7 @@ pub fn topgrade_vagrant_box(ctx: &ExecutionContext, vagrant_box: &VagrantBox) ->
         .execute(&vagrant.path)
         .current_dir(&vagrant_box.path)
         .args(["ssh", "-c", &command])
-        .check_run()
+        .status_checked()
 }
 
 pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
@@ -208,12 +209,12 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
 
     let outdated = Command::new(&vagrant)
         .args(["box", "outdated", "--global"])
-        .check_output()?;
+        .output_checked_utf8()?;
 
     let re = Regex::new(r"\* '(.*?)' for '(.*?)' is outdated").unwrap();
 
     let mut found = false;
-    for ele in re.captures_iter(&outdated) {
+    for ele in re.captures_iter(&outdated.stdout) {
         found = true;
         let _ = ctx
             .run_type()
@@ -222,13 +223,16 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
             .arg(ele.get(1).unwrap().as_str())
             .arg("--provider")
             .arg(ele.get(2).unwrap().as_str())
-            .check_run();
+            .status_checked();
     }
 
     if !found {
         println!("No outdated boxes")
     } else {
-        ctx.run_type().execute(&vagrant).args(["box", "prune"]).check_run()?;
+        ctx.run_type()
+            .execute(&vagrant)
+            .args(["box", "prune"])
+            .status_checked()?;
     }
 
     Ok(())

src/steps/tmux.rs

@@ -1,26 +1,28 @@
-use crate::executor::RunType;
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Context;
+use color_eyre::eyre::Result;
+
+use crate::command::CommandExt;
 use crate::terminal::print_separator;
+use crate::HOME_DIR;
 use crate::{
     execution_context::ExecutionContext,
-    utils::{which, Check, PathExt},
+    utils::{which, PathExt},
 };
-use anyhow::Result;
-use directories::BaseDirs;
-use std::env;
-use std::io;
-use std::os::unix::process::CommandExt;
-use std::path::PathBuf;
-use std::process::{exit, Command};
 
-pub fn run_tpm(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
-    let tpm = base_dirs
-        .home_dir()
-        .join(".tmux/plugins/tpm/bin/update_plugins")
-        .require()?;
+#[cfg(unix)]
+use std::os::unix::process::CommandExt as _;
+
+pub fn run_tpm(ctx: &ExecutionContext) -> Result<()> {
+    let tpm = HOME_DIR.join(".tmux/plugins/tpm/bin/update_plugins").require()?;
 
     print_separator("tmux plugins");
 
-    run_type.execute(tpm).arg("all").check_run()
+    ctx.run_type().execute(tpm).arg("all").status_checked()
 }
 
 struct Tmux {
@@ -44,73 +46,130 @@ impl Tmux {
         command
     }
 
-    fn has_session(&self, session_name: &str) -> Result<bool, io::Error> {
+    fn has_session(&self, session_name: &str) -> Result<bool> {
         Ok(self
             .build()
             .args(["has-session", "-t", session_name])
-            .output()?
+            .output_checked_with(|_| Ok(()))?
             .status
             .success())
     }
 
-    fn new_session(&self, session_name: &str) -> Result<bool, io::Error> {
-        Ok(self
+    /// Create a new tmux session with the given name, running the given command.
+    /// The command is passed to `sh` (see "shell-command arguments are sh(1) commands" in the
+    /// `tmux(1)` man page).
+    fn new_session(&self, session_name: &str, window_name: &str, command: &str) -> Result<()> {
+        let _ = self
             .build()
-            .args(["new-session", "-d", "-s", session_name, "-n", "dummy"])
-            .spawn()?
-            .wait()?
-            .success())
+            // `-d`: initial size comes from the global `default-size` option (instead
+            //       of passing `-x` and `-y` arguments.
+            //       (What do those even do?)
+            // `-s`: session name
+            // `-n`: window name (always `topgrade`)
+            .args(["new-session", "-d", "-s", session_name, "-n", window_name, command])
+            .output_checked()?;
+        Ok(())
     }
 
-    fn run_in_session(&self, command: &str) -> Result<()> {
-        self.build()
-            .args(["new-window", "-t", "topgrade", command])
-            .spawn()?
-            .wait()?
-            .check()?;
+    /// Like [`new_session`] but it appends a digit to the session name (if necessary) to
+    /// avoid duplicate session names.
+    ///
+    /// The session name is returned.
+    fn new_unique_session(&self, session_name: &str, window_name: &str, command: &str) -> Result<String> {
+        let mut session = session_name.to_owned();
+        for i in 1.. {
+            if !self
+                .has_session(&session)
+                .context("Error determining if a tmux session exists")?
+            {
+                self.new_session(&session, window_name, command)
+                    .context("Error running Topgrade in tmux")?;
+                return Ok(session);
+            }
+            session = format!("{session_name}-{i}");
+        }
+        unreachable!()
+    }
 
-        Ok(())
+    /// Create a new window in the given tmux session, running the given command.
+    fn new_window(&self, session_name: &str, window_name: &str, command: &str) -> Result<()> {
+        self.build()
+            // `-d`: initial size comes from the global `default-size` option (instead
+            //       of passing `-x` and `-y` arguments.
+            //       (What do those even do?)
+            // `-s`: session name
+            // `-n`: window name
+            .args([
+                "new-window",
+                "-a",
+                "-t",
+                &format!("{session_name}:{window_name}"),
+                "-n",
+                window_name,
+                command,
+            ])
+            .env_remove("TMUX")
+            .status_checked()
+    }
+
+    fn window_indices(&self, session_name: &str) -> Result<Vec<usize>> {
+        self.build()
+            .args(["list-windows", "-F", "#{window_index}", "-t", session_name])
+            .output_checked_utf8()?
+            .stdout
+            .lines()
+            .map(|l| l.parse())
+            .collect::<Result<Vec<usize>, _>>()
+            .context("Failed to compute tmux windows")
     }
 }
 
-pub fn run_in_tmux(args: Vec<String>) -> ! {
+pub fn run_in_tmux(args: Vec<String>) -> Result<()> {
     let command = {
         let mut command = vec![
             String::from("env"),
             String::from("TOPGRADE_KEEP_END=1"),
             String::from("TOPGRADE_INSIDE_TMUX=1"),
         ];
+        // TODO: Should we use `topgrade` instead of the first argument here, which may be
+        // a local path?
         command.extend(env::args());
         shell_words::join(command)
     };
 
-    let tmux = Tmux::new(args.clone());
+    let tmux = Tmux::new(args);
 
-    if !tmux.has_session("topgrade").expect("Error detecting a tmux session") {
-        tmux.new_session("topgrade").expect("Error creating a tmux session");
-    }
-
-    tmux.run_in_session(&command).expect("Error running Topgrade in tmux");
-    tmux.build()
-        .args(["kill-window", "-t", "topgrade:dummy"])
-        .output()
-        .expect("Error killing the dummy tmux window");
+    // Find an unused session and run `topgrade` in it with the current command's arguments.
+    let session_name = "topgrade";
+    let window_name = "topgrade";
+    let session = tmux.new_unique_session(session_name, window_name, &command)?;
 
+    // Only attach to the newly-created session if we're not currently in a tmux session.
     if env::var("TMUX").is_err() {
-        let err = tmux.build().args(["attach", "-t", "topgrade"]).exec();
-        panic!("{:?}", err);
+        let err = tmux.build().args(["attach-session", "-t", &session]).exec();
+        Err(eyre!("{err}")).context("Failed to `execvp(3)` tmux")
     } else {
         println!("Topgrade launched in a new tmux session");
-        exit(0);
+        Ok(())
     }
 }
 
-pub fn run_command(ctx: &ExecutionContext, command: &str) -> Result<()> {
-    Tmux::new(ctx.config().tmux_arguments()?)
-        .build()
-        .args(["new-window", "-a", "-t", "topgrade:1", command])
-        .env_remove("TMUX")
-        .spawn()?
-        .wait()?
-        .check()
+pub fn run_command(ctx: &ExecutionContext, window_name: &str, command: &str) -> Result<()> {
+    let tmux = Tmux::new(ctx.config().tmux_arguments()?);
+
+    match ctx.get_tmux_session() {
+        Some(session_name) => {
+            let indices = tmux.window_indices(&session_name)?;
+            let last_window = indices
+                .iter()
+                .last()
+                .ok_or_else(|| eyre!("tmux session {session_name} has no windows"))?;
+            tmux.new_window(&session_name, &format!("{last_window}"), command)?;
+        }
+        None => {
+            let name = tmux.new_unique_session("topgrade", window_name, command)?;
+            ctx.set_tmux_session(name);
+        }
+    }
+    Ok(())
 }

src/steps/toolbx.rs

@@ -1,17 +1,20 @@
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
+use crate::command::CommandExt;
 use crate::config::Step;
 use crate::terminal::print_separator;
 use crate::{execution_context::ExecutionContext, utils::require};
-use log::debug;
 use std::path::Path;
 use std::{path::PathBuf, process::Command};
+use tracing::debug;
 
 fn list_toolboxes(toolbx: &Path) -> Result<Vec<String>> {
-    let output = Command::new(toolbx).args(["list", "--containers"]).output()?;
-    let output_str = String::from_utf8(output.stdout)?;
+    let output = Command::new(toolbx)
+        .args(["list", "--containers"])
+        .output_checked_utf8()?;
 
-    let proc: Vec<String> = output_str
+    let proc: Vec<String> = output
+        .stdout
         .lines()
         // Skip the first line since that contains only status information
         .skip(1)
@@ -39,7 +42,7 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
     let topgrade_path = topgrade_path.to_str().unwrap();
 
     for tb in toolboxes.iter() {
-        let topgrade_prefix = format!("TOPGRADE_PREFIX='Toolbx {}'", tb);
+        let topgrade_prefix = format!("TOPGRADE_PREFIX='Toolbx {tb}'");
         let mut args = vec![
             "run",
             "-c",
@@ -54,7 +57,7 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
             args.push("--yes");
         }
 
-        let _output = ctx.run_type().execute(&toolbx).args(&args).check_run();
+        ctx.run_type().execute(&toolbx).args(&args).status_checked()?;
     }
 
     Ok(())

src/steps/upgrade.vim

@@ -1,3 +1,14 @@
+" 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(":NeoBundleUpdate")
     echo "NeoBundle"
     NeoBundleUpdate
@@ -33,9 +44,9 @@ if exists(":PaqUpdate")
     PaqUpdate
 endif
 
-if exists(":CocUpdateSync")
-    echo "CocUpdateSync"
-    CocUpdateSync
+if exists(":Lazy")
+    echo "Lazy Update"
+    Lazy! sync | qa
 endif
 
 if exists(':PackerSync')

src/steps/vim.rs

@@ -1,38 +1,37 @@
+use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
-use anyhow::Result;
+use crate::HOME_DIR;
+use color_eyre::eyre::Result;
+use etcetera::base_strategy::BaseStrategy;
 
-use crate::executor::{CommandExt, Executor, ExecutorOutput, RunType};
+use crate::executor::{Executor, ExecutorOutput};
 use crate::terminal::print_separator;
 use crate::{
     execution_context::ExecutionContext,
     utils::{require, PathExt},
 };
-use directories::BaseDirs;
-use log::debug;
 use std::path::PathBuf;
 use std::{
     io::{self, Write},
     process::Command,
 };
+use tracing::debug;
 
 const UPGRADE_VIM: &str = include_str!("upgrade.vim");
 
-pub fn vimrc(base_dirs: &BaseDirs) -> Result<PathBuf> {
-    base_dirs
-        .home_dir()
+pub fn vimrc() -> Result<PathBuf> {
+    HOME_DIR
         .join(".vimrc")
         .require()
-        .or_else(|_| base_dirs.home_dir().join(".vim/vimrc").require())
+        .or_else(|_| HOME_DIR.join(".vim/vimrc").require())
 }
 
-fn nvimrc(base_dirs: &BaseDirs) -> Result<PathBuf> {
+fn nvimrc() -> Result<PathBuf> {
     #[cfg(unix)]
-        let base_dir =
-        // Bypass directories crate as nvim doesn't use the macOS-specific directories.
-        std::env::var_os("XDG_CONFIG_HOME").map_or_else(|| base_dirs.home_dir().join(".config"), PathBuf::from);
+    let base_dir = crate::XDG_DIRS.config_dir();
 
     #[cfg(windows)]
-    let base_dir = base_dirs.cache_dir();
+    let base_dir = crate::WINDOWS_DIRS.cache_dir();
 
     base_dir
         .join("nvim/init.vim")
@@ -63,7 +62,7 @@ fn upgrade(command: &mut Executor, ctx: &ExecutionContext) -> Result<()> {
         }
 
         if !status.success() {
-            return Err(TopgradeError::ProcessFailed(status).into());
+            return Err(TopgradeError::ProcessFailed(command.get_program(), status).into());
         } else {
             println!("Plugins upgraded")
         }
@@ -73,7 +72,7 @@ fn upgrade(command: &mut Executor, ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn upgrade_ultimate_vimrc(ctx: &ExecutionContext) -> Result<()> {
-    let config_dir = ctx.base_dirs().home_dir().join(".vim_runtime").require()?;
+    let config_dir = HOME_DIR.join(".vim_runtime").require()?;
     let git = require("git")?;
     let python = require("python3")?;
     let update_plugins = config_dir.join("update_plugins.py").require()?;
@@ -84,35 +83,35 @@ pub fn upgrade_ultimate_vimrc(ctx: &ExecutionContext) -> Result<()> {
         .execute(&git)
         .current_dir(&config_dir)
         .args(["reset", "--hard"])
-        .check_run()?;
+        .status_checked()?;
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
         .args(["clean", "-d", "--force"])
-        .check_run()?;
+        .status_checked()?;
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
         .args(["pull", "--rebase"])
-        .check_run()?;
+        .status_checked()?;
     ctx.run_type()
         .execute(python)
         .current_dir(config_dir)
         .arg(update_plugins)
-        .check_run()?;
+        .status_checked()?;
 
     Ok(())
 }
 
-pub fn upgrade_vim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()> {
+pub fn upgrade_vim(ctx: &ExecutionContext) -> Result<()> {
     let vim = require("vim")?;
 
-    let output = Command::new(&vim).arg("--version").check_output()?;
-    if !output.starts_with("VIM") {
+    let output = Command::new(&vim).arg("--version").output_checked_utf8()?;
+    if !output.stdout.starts_with("VIM") {
         return Err(SkipStep(String::from("vim binary might be actually nvim")).into());
     }
 
-    let vimrc = vimrc(base_dirs)?;
+    let vimrc = vimrc()?;
 
     print_separator("Vim");
     upgrade(
@@ -126,9 +125,9 @@ pub fn upgrade_vim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()> {
     )
 }
 
-pub fn upgrade_neovim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()> {
+pub fn upgrade_neovim(ctx: &ExecutionContext) -> Result<()> {
     let nvim = require("nvim")?;
-    let nvimrc = nvimrc(base_dirs)?;
+    let nvimrc = nvimrc()?;
 
     print_separator("Neovim");
     upgrade(
@@ -142,10 +141,10 @@ pub fn upgrade_neovim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()
     )
 }
 
-pub fn run_voom(_base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_voom(ctx: &ExecutionContext) -> Result<()> {
     let voom = require("voom")?;
 
     print_separator("voom");
 
-    run_type.execute(voom).arg("update").check_run()
+    ctx.run_type().execute(voom).arg("update").status_checked()
 }

src/steps/zsh.rs

@@ -1,142 +1,185 @@
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+
+use color_eyre::eyre::Result;
+use tracing::debug;
+use walkdir::WalkDir;
+
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
 use crate::git::Repositories;
 use crate::terminal::print_separator;
 use crate::utils::{require, PathExt};
-use anyhow::Result;
-use directories::BaseDirs;
-use log::debug;
-use std::env;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use walkdir::WalkDir;
+use crate::HOME_DIR;
 
-pub fn run_zr(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_zr(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
 
     require("zr")?;
 
     print_separator("zr");
 
-    let cmd = format!("source {} && zr --update", zshrc(base_dirs).display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).check_run()
+    let cmd = format!("source {} && zr --update", zshrc().display());
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-l", "-c", cmd.as_str()])
+        .status_checked()
 }
 
-pub fn zshrc(base_dirs: &BaseDirs) -> PathBuf {
+fn zdotdir() -> PathBuf {
     env::var("ZDOTDIR")
-        .map(|p| Path::new(&p).join(".zshrc"))
-        .unwrap_or_else(|_| base_dirs.home_dir().join(".zshrc"))
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| HOME_DIR.clone())
 }
 
-pub fn run_antibody(run_type: RunType) -> Result<()> {
+pub fn zshrc() -> PathBuf {
+    zdotdir().join(".zshrc")
+}
+
+pub fn run_antidote(ctx: &ExecutionContext) -> Result<()> {
+    let zsh = require("zsh")?;
+    let mut antidote = zdotdir().join(".antidote").require()?;
+    antidote.push("antidote.zsh");
+
+    print_separator("antidote");
+
+    ctx.run_type()
+        .execute(zsh)
+        .arg("-c")
+        .arg(format!("source {} && antidote update", antidote.display()))
+        .status_checked()
+}
+
+pub fn run_antibody(ctx: &ExecutionContext) -> Result<()> {
     require("zsh")?;
     let antibody = require("antibody")?;
 
     print_separator("antibody");
 
-    run_type.execute(antibody).arg("update").check_run()
+    ctx.run_type().execute(antibody).arg("update").status_checked()
 }
 
-pub fn run_antigen(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_antigen(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
-    let zshrc = zshrc(base_dirs).require()?;
+    let zshrc = zshrc().require()?;
     env::var("ADOTDIR")
         .map(PathBuf::from)
-        .unwrap_or_else(|_| base_dirs.home_dir().join("antigen.zsh"))
+        .unwrap_or_else(|_| HOME_DIR.join("antigen.zsh"))
         .require()?;
 
     print_separator("antigen");
 
     let cmd = format!("source {} && (antigen selfupdate ; antigen update)", zshrc.display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).check_run()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-l", "-c", cmd.as_str()])
+        .status_checked()
 }
 
-pub fn run_zgenom(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_zgenom(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
-    let zshrc = zshrc(base_dirs).require()?;
+    let zshrc = zshrc().require()?;
     env::var("ZGEN_SOURCE")
         .map(PathBuf::from)
-        .unwrap_or_else(|_| base_dirs.home_dir().join(".zgenom"))
+        .unwrap_or_else(|_| HOME_DIR.join(".zgenom"))
         .require()?;
 
     print_separator("zgenom");
 
     let cmd = format!("source {} && zgenom selfupdate && zgenom update", zshrc.display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).check_run()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-l", "-c", cmd.as_str()])
+        .status_checked()
 }
 
-pub fn run_zplug(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_zplug(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
-    zshrc(base_dirs).require()?;
+    zshrc().require()?;
 
     env::var("ZPLUG_HOME")
         .map(PathBuf::from)
-        .unwrap_or_else(|_| base_dirs.home_dir().join(".zplug"))
+        .unwrap_or_else(|_| HOME_DIR.join(".zplug"))
         .require()?;
 
     print_separator("zplug");
 
-    run_type.execute(zsh).args(["-i", "-c", "zplug update"]).check_run()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-i", "-c", "zplug update"])
+        .status_checked()
 }
 
-pub fn run_zinit(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_zinit(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
-    let zshrc = zshrc(base_dirs).require()?;
+    let zshrc = zshrc().require()?;
 
     env::var("ZINIT_HOME")
         .map(PathBuf::from)
-        .unwrap_or_else(|_| base_dirs.home_dir().join(".zinit"))
+        .unwrap_or_else(|_| HOME_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()]).check_run()
+    ctx.run_type()
+        .execute(zsh)
+        .args(["-i", "-c", cmd.as_str()])
+        .status_checked()
 }
 
-pub fn run_zi(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_zi(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
-    let zshrc = zshrc(base_dirs).require()?;
+    let zshrc = zshrc().require()?;
 
-    base_dirs.home_dir().join(".zi").require()?;
+    HOME_DIR.join(".zi").require()?;
 
     print_separator("zi");
 
     let cmd = format!("source {} && zi self-update && zi update --all", zshrc.display(),);
-    run_type.execute(zsh).args(["-i", "-c", &cmd]).check_run()
+    ctx.run_type().execute(zsh).args(["-i", "-c", &cmd]).status_checked()
 }
 
-pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_zim(ctx: &ExecutionContext) -> Result<()> {
     let zsh = require("zsh")?;
     env::var("ZIM_HOME")
         .or_else(|_| {
             Command::new("zsh")
+                // TODO: Should these be quoted?
                 .args(["-c", "[[ -n ${ZIM_HOME} ]] && print -n ${ZIM_HOME}"])
-                .check_output()
+                .output_checked_utf8()
+                .map(|o| o.stdout)
         })
         .map(PathBuf::from)
-        .unwrap_or_else(|_| base_dirs.home_dir().join(".zim"))
+        .unwrap_or_else(|_| HOME_DIR.join(".zim"))
         .require()?;
 
     print_separator("zim");
 
-    run_type
+    ctx.run_type()
         .execute(zsh)
         .args(["-i", "-c", "zimfw upgrade && zimfw update"])
-        .check_run()
+        .status_checked()
 }
 
 pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
     require("zsh")?;
-    let oh_my_zsh = ctx.base_dirs().home_dir().join(".oh-my-zsh").require()?;
+    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");
 
     let custom_dir = env::var::<_>("ZSH_CUSTOM")
         .or_else(|_| {
             Command::new("zsh")
+                // TODO: Should these be quoted?
                 .args(["-c", "test $ZSH_CUSTOM && echo -n $ZSH_CUSTOM"])
-                .check_output()
+                .output_checked_utf8()
+                .map(|o| o.stdout)
         })
         .map(PathBuf::from)
         .unwrap_or_else(|e| {
@@ -166,7 +209,10 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
 
     ctx.run_type()
         .execute("zsh")
-        .env("ZSH", &oh_my_zsh)
         .arg(&oh_my_zsh.join("tools/upgrade.sh"))
-        .check_run_with_codes(&[80])
+        // 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

@@ -0,0 +1,125 @@
+use std::ffi::OsStr;
+use std::path::Path;
+use std::path::PathBuf;
+
+use color_eyre::eyre::Context;
+use color_eyre::eyre::Result;
+use serde::Deserialize;
+use strum::AsRefStr;
+
+use crate::command::CommandExt;
+use crate::execution_context::ExecutionContext;
+use crate::executor::Executor;
+use crate::terminal::print_separator;
+use crate::utils::which;
+
+#[derive(Clone, Debug)]
+pub struct Sudo {
+    /// The path to the `sudo` binary.
+    path: PathBuf,
+    /// The type of program being used as `sudo`.
+    kind: SudoKind,
+}
+
+impl Sudo {
+    /// Get the `sudo` binary for this platform.
+    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)))
+            .map(|(path, kind)| Self { path, kind })
+    }
+
+    /// Create Sudo from SudoKind, if found in the system
+    pub fn new(kind: SudoKind) -> Option<Self> {
+        which(kind.as_ref()).map(|path| Self { path, kind })
+    }
+
+    /// Elevate permissions with `sudo`.
+    ///
+    /// This helps prevent blocking `sudo` prompts from stopping the run in the middle of a
+    /// step.
+    ///
+    /// See: https://github.com/topgrade-rs/topgrade/issues/205
+    pub fn elevate(&self, ctx: &ExecutionContext) -> Result<()> {
+        print_separator("Sudo");
+        let mut cmd = ctx.run_type().execute(self);
+        match self.kind {
+            SudoKind::Doas => {
+                // `doas` doesn't have anything like `sudo -v` to cache credentials,
+                // so we just execute a dummy `echo` command so we have something
+                // unobtrusive to run.
+                // 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
+                //   Update the user's cached credentials, authenticating the user
+                //   if necessary.  For the sudoers plugin, this extends the sudo
+                //   timeout for another 5 minutes by default, but does not run a
+                //   command.  Not all security policies support cached credentials.
+                cmd.arg("-v");
+            }
+            SudoKind::Gsudo => {
+                // Shows current user, cache and console status.
+                // See: https://gerardog.github.io/gsudo/docs/usage
+                cmd.arg("status");
+            }
+            SudoKind::Pkexec => {
+                // I don't think this does anything; `pkexec` usually asks for
+                // authentication every time, although it can be configured
+                // differently.
+                //
+                // See the note for `doas` above.
+                //
+                // See: https://linux.die.net/man/1/pkexec
+                cmd.arg("echo");
+            }
+        }
+        cmd.status_checked().wrap_err("Failed to elevate permissions")
+    }
+
+    /// Execute a command with `sudo`.
+    pub fn execute_elevated(&self, ctx: &ExecutionContext, command: &Path, interactive: bool) -> Executor {
+        let mut cmd = ctx.run_type().execute(self);
+
+        if let SudoKind::Sudo = self.kind {
+            cmd.arg("--preserve-env=DIFFPROG");
+        }
+
+        if interactive {
+            cmd.arg("-i");
+        }
+
+        cmd.arg(command);
+
+        cmd
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, AsRefStr)]
+#[serde(rename_all = "lowercase")]
+#[strum(serialize_all = "lowercase")]
+pub enum SudoKind {
+    Doas,
+    Please,
+    Sudo,
+    Gsudo,
+    Pkexec,
+}
+
+impl AsRef<OsStr> for Sudo {
+    fn as_ref(&self) -> &OsStr {
+        self.path.as_ref()
+    }
+}

src/terminal.rs

@@ -1,24 +1,22 @@
 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;
 
 use chrono::{Local, Timelike};
+use color_eyre::eyre;
+use color_eyre::eyre::Context;
 use console::{style, Key, Term};
 use lazy_static::lazy_static;
-use log::{debug, error};
-#[cfg(target_os = "macos")]
 use notify_rust::{Notification, Timeout};
+use tracing::{debug, error};
 #[cfg(windows)]
 use which_crate::which;
 
+use crate::command::CommandExt;
 use crate::report::StepResult;
-#[cfg(target_os = "linux")]
-use crate::utils::which;
 
 lazy_static! {
     static ref TERMINAL: Mutex<Terminal> = Mutex::new(Terminal::new());
@@ -34,13 +32,8 @@ pub fn shell() -> &'static str {
     which("pwsh").map(|_| "pwsh").unwrap_or("powershell")
 }
 
-pub fn run_shell() {
-    Command::new(shell())
-        .env("IN_TOPGRADE", "1")
-        .spawn()
-        .unwrap()
-        .wait()
-        .unwrap();
+pub fn run_shell() -> eyre::Result<()> {
+    Command::new(shell()).env("IN_TOPGRADE", "1").status_checked()
 }
 
 struct Terminal {
@@ -50,8 +43,6 @@ struct Terminal {
     set_title: bool,
     display_time: bool,
     desktop_notification: bool,
-    #[cfg(target_os = "linux")]
-    notify_send: Option<PathBuf>,
 }
 
 impl Terminal {
@@ -61,13 +52,11 @@ impl Terminal {
             width: term.size_checked().map(|(_, w)| w),
             term,
             prefix: env::var("TOPGRADE_PREFIX")
-                .map(|prefix| format!("({}) ", prefix))
+                .map(|prefix| format!("({prefix}) "))
                 .unwrap_or_else(|_| String::new()),
             set_title: true,
             display_time: true,
             desktop_notification: false,
-            #[cfg(target_os = "linux")]
-            notify_send: which("notify-send"),
         }
     }
 
@@ -83,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");
 
@@ -97,19 +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());
-                    command.output().ok();
-                }
-            }
-        }
     }
 
     fn print_separator<P: AsRef<str>>(&mut self, message: P) {
@@ -142,7 +116,7 @@ impl Terminal {
                     .write_fmt(format_args!(
                         "{}\n",
                         style(format_args!(
-                            "\n―― {} {:―^border$}",
+                            "\n── {} {:─^border$}",
                             message,
                             "",
                             border = max(
@@ -158,11 +132,24 @@ impl Terminal {
                     .ok();
             }
             None => {
-                self.term.write_fmt(format_args!("―― {} ――\n", message)).ok();
+                self.term.write_fmt(format_args!("―― {message} ――\n")).ok();
             }
         }
     }
 
+    #[allow(dead_code)]
+    fn print_error<P: AsRef<str>, Q: AsRef<str>>(&mut self, key: Q, message: P) {
+        let key = key.as_ref();
+        let message = message.as_ref();
+        self.term
+            .write_fmt(format_args!(
+                "{} {}",
+                style(format!("{key} failed:")).red().bold(),
+                message
+            ))
+            .ok();
+    }
+
     #[allow(dead_code)]
     fn print_warning<P: AsRef<str>>(&mut self, message: P) {
         let message = message.as_ref();
@@ -201,7 +188,7 @@ impl Terminal {
         self.term
             .write_fmt(format_args!(
                 "{}",
-                style(format!("{} (y)es/(N)o", question,)).yellow().bold()
+                style(format!("{question} (y)es/(N)o",)).yellow().bold()
             ))
             .ok();
 
@@ -214,7 +201,7 @@ impl Terminal {
         }
     }
     #[allow(unused_variables)]
-    fn should_retry(&mut self, interrupted: bool, step_name: &str) -> Result<bool, io::Error> {
+    fn should_retry(&mut self, interrupted: bool, step_name: &str) -> eyre::Result<bool> {
         if self.width.is_none() {
             return Ok(false);
         }
@@ -223,31 +210,35 @@ impl Terminal {
             self.term.set_title("Topgrade - Awaiting user");
         }
 
-        self.notify_desktop(format!("{} failed", step_name), None);
+        if self.desktop_notification {
+            self.notify_desktop(format!("{step_name} failed"), None);
+        }
 
-        self.term
-            .write_fmt(format_args!(
-                "\n{}",
-                style(format!("{}Retry? (y)es/(N)o/(s)hell/(q)uit", self.prefix))
+        let prompt_inner = style(format!("{}Retry? (y)es/(N)o/(s)hell/(q)uit", self.prefix))
             .yellow()
-                    .bold()
-            ))
-            .ok();
+            .bold();
+
+        self.term.write_fmt(format_args!("\n{prompt_inner}")).ok();
 
         let answer = loop {
             match self.term.read_key() {
                 Ok(Key::Char('y')) | Ok(Key::Char('Y')) => break Ok(true),
                 Ok(Key::Char('s')) | Ok(Key::Char('S')) => {
                     println!("\n\nDropping you to shell. Fix what you need and then exit the shell.\n");
-                    run_shell();
+                    if let Err(err) = run_shell().context("Failed to run shell") {
+                        self.term.write_fmt(format_args!("{err:?}\n{prompt_inner}")).ok();
+                    } else {
                         break Ok(true);
                     }
+                }
                 Ok(Key::Char('n')) | Ok(Key::Char('N')) | Ok(Key::Enter) => break Ok(false),
                 Err(e) => {
                     error!("Error reading from terminal: {}", e);
                     break Ok(false);
                 }
-                Ok(Key::Char('q')) | Ok(Key::Char('Q')) => return Err(io::Error::from(io::ErrorKind::Interrupted)),
+                Ok(Key::Char('q')) | Ok(Key::Char('Q')) => {
+                    return Err(io::Error::from(io::ErrorKind::Interrupted)).context("Quit from user input")
+                }
                 _ => (),
             }
         };
@@ -268,7 +259,7 @@ impl Default for Terminal {
     }
 }
 
-pub fn should_retry(interrupted: bool, step_name: &str) -> Result<bool, io::Error> {
+pub fn should_retry(interrupted: bool, step_name: &str) -> eyre::Result<bool> {
     TERMINAL.lock().unwrap().should_retry(interrupted, step_name)
 }
 
@@ -276,6 +267,11 @@ pub fn print_separator<P: AsRef<str>>(message: P) {
     TERMINAL.lock().unwrap().print_separator(message)
 }
 
+#[allow(dead_code)]
+pub fn print_error<P: AsRef<str>, Q: AsRef<str>>(key: Q, message: P) {
+    TERMINAL.lock().unwrap().print_error(key, message)
+}
+
 #[allow(dead_code)]
 pub fn print_warning<P: AsRef<str>>(message: P) {
     TERMINAL.lock().unwrap().print_warning(message)

src/utils.rs

@@ -1,46 +1,14 @@
-use crate::error::{SkipStep, TopgradeError};
-use anyhow::Result;
-
-use log::{debug, error};
 use std::env;
 use std::ffi::OsStr;
 use std::fmt::Debug;
 use std::path::{Path, PathBuf};
-use std::process::{ExitStatus, Output};
+use std::process::Command;
 
-pub trait Check {
-    fn check(self) -> Result<()>;
-}
+use color_eyre::eyre::Result;
+use tracing::{debug, error};
 
-impl Check for Output {
-    fn check(self) -> Result<()> {
-        self.status.check()
-    }
-}
-
-pub trait CheckWithCodes {
-    fn check_with_codes(self, codes: &[i32]) -> Result<()>;
-}
-
-// Anything that implements CheckWithCodes also implements check
-// if check_with_codes is given an empty array of codes to check
-impl<T: CheckWithCodes> Check for T {
-    fn check(self) -> Result<()> {
-        self.check_with_codes(&[])
-    }
-}
-
-impl CheckWithCodes for ExitStatus {
-    fn check_with_codes(self, codes: &[i32]) -> Result<()> {
-        // Set the default to be -1 because the option represents a signal termination
-        let code = self.code().unwrap_or(-1);
-        if self.success() || codes.contains(&code) {
-            Ok(())
-        } else {
-            Err(TopgradeError::ProcessFailed(self).into())
-        }
-    }
-}
+use crate::command::CommandExt;
+use crate::error::SkipStep;
 
 pub trait PathExt
 where
@@ -102,13 +70,6 @@ pub fn which<T: AsRef<OsStr> + Debug>(binary_name: T) -> Option<PathBuf> {
     }
 }
 
-pub fn sudo() -> Option<PathBuf> {
-    which("doas")
-        .or_else(|| which("sudo"))
-        .or_else(|| which("gsudo"))
-        .or_else(|| which("pkexec"))
-}
-
 pub fn editor() -> Vec<String> {
     env::var("EDITOR")
         .unwrap_or_else(|_| String::from(if cfg!(windows) { "notepad" } else { "vi" }))
@@ -142,3 +103,151 @@ pub fn require_option<T>(option: Option<T>, cause: String) -> Result<T> {
         Err(SkipStep(cause).into())
     }
 }
+
+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;
+}
+
+/* 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.
+ */
+#[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())
+    }
+}
+
+#[cfg(target_family = "windows")]
+pub fn hostname() -> Result<String> {
+    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)
+}

topgrade.8

@@ -1,80 +0,0 @@
-.hy
-.TH "topgrade" "8"
-.SH NAME
-.PP
-Topgrade \- Upgrade everything
-.SH SYNOPSIS
-.PP
-topgrade [\fIoptions\f[]]
-.SH DESCRIPTION
-.PP
-Keeping your system up to date usually involves invoking multiple package managers.
-This results in big, non-portable shell one-liners saved in your shell.
-To remedy this, \fBTopgrade\fR detects which tools you use and runs the appropriate commands to update them.
-.SH OPTIONS
-.TP
-.B \-\-only <only>
-Run only specific steps
-.RS
-.RE
-.TP
-.B \-\-disable <disable>
-Disable specific steps
-.RS
-.RE
-.TP
-.B \-c, \-\-cleanup
-Cleanup temporary or old files
-.RS
-.RE
-.TP
-.B \-n, \-\-dry\-run
-List the commands that would be run
-.RS
-.RE
-.TP
-.B \-\-edit\-config
-Edit the configuration file
-.RS
-.RE
-.TP
-.B \-h, \-\-help
-Print help information
-.RS
-.RE
-.TP
-.B \-k, \-\-keep
-Prompt for a key before exiting
-.RS
-.RE
-.TP
-.B \-\-no\-retry
-Do not ask to retry failed steps
-.RS
-.RE
-.TP
-.B \-t, \-\-tmux
-Run inside tmux
-.RS
-.RE
-.TP
-.B \-V, \-\-version
-Print version information
-.RS
-.RE
-.TP
-.B \-v, \-\-verbose
-Output logs
-.RS
-.RE
-.B \-y, \-\-yes
-Skip package manager's prompts (experimental)
-.SH ARGUMENT FORMAT
-Options can be given in any order.
-A list of steps must be provided as a list of separate arguments, i.e. 'topgrade --only system shell'.
-.SH BUGS
-For a list of bugs see <\fIhttps://github.com/r-darwish/topgrade/issues\fR>.
-.SH AUTHOR
-\fBTopgrade\fR is maintained by Roey Dror (\[aq]r\-darwish\[aq]) and many other contributors.
-You can view the full list at
-<\fIhttps://github.com/r-darwish/topgrade/graphs/contributors\fR>