CD pipeline cleanup (#116)

* Update README.md

* Update release-cross.yml

* Update release.yml

* style(self_update): Run cargo fmt (#108)

The commit 9105a8aac is not formatted, which breaks the CI check.

Co-authored-by: Thomas Schönauer <37108907+DottoDev@users.noreply.github.com>

* Cleanup CI/CD pipeline (#115)

Co-authored-by: pan93412 <pan93412@gmail.com>

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: GitHub Discussions
-    url: https://github.com/topgrade-rs/topgrade/discussions
-    about: Please ask and answer questions here.

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

@@ -4,88 +4,52 @@ on:
     branches:
       - main
 
-name: CI
 
-env:
+name: Check and Lint
-  RUST_VER: '1.60.0'
-  CROSS_VER: '0.2.4'
-  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-20.04
+    runs-on: ubuntu-latest
     steps:
-      - name: Checkout code
+      - uses: actions/checkout@v2
-        uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
-
-      - name: Setup Rust
-        uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: '${{ env.RUST_VER }}'
+          profile: minimal
-          components: rustfmt
+          toolchain: stable
+          override: true
+      - run: rustup component add rustfmt
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
 
-      - name: Run cargo fmt
+  clippy:
-        env:
+    name: Clippy
-          TERM: xterm-256color
+    runs-on: ubuntu-latest
-        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:
-      - name: Checkout code
+      - uses: actions/checkout@v2
-        uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
-
-      - name: Setup Rust
-        uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: '${{ env.RUST_VER }}'
+          toolchain: stable
           components: clippy
-
+          override: true
-      - name: Setup Rust Cache
+      - uses: actions-rs/clippy-check@v1
-        uses: Swatinem/rust-cache@v2
         with:
-          prefix-key: ${{ matrix.target }}
+          token: ${{ secrets.GITHUB_TOKEN }}
-
+          args: --all-features
-      - name: Setup cross
+          name: Clippy Output
-        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: stable
+          toolchain: nightly-2022-08-03
           override: true
 
   publish:

.github/workflows/release-cross.yml

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

.github/workflows/update_homebrew.yml

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

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

Cargo.toml

@@ -3,10 +3,9 @@ name = "topgrade"
 description = "Upgrade all the things"
 categories = ["os"]
 keywords = ["upgrade", "update"]
-license = "GPL-3.0"
+license-file = "LICENSE"
-# license-file = "LICENSE"
 repository = "https://github.com/topgrade-rs/topgrade"
-version = "10.2.5"
+version = "10.1.0"
 authors = ["Roey Darwish Dror <roey.ghost@gmail.com>", "Thomas Schönauer <t.schoenauer@hgs-wt.at>"]
 exclude = ["doc/screenshot.gif"]
 edition = "2021"
@@ -21,55 +20,43 @@ path = "src/main.rs"
 ##name = "topgrade_lib"
 
 [dependencies]
-home = "~0.5"
+home = "0.5"
-directories = "~4.0"
+directories = "4.0"
-serde = { version = "~1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 toml = "0.5"
-which_crate = { version = "~4.1", package = "which" }
+which_crate = { version = "4.1", package = "which" }
-shellexpand = "~2.1"
+shellexpand = "2.1"
-clap = { version = "~3.1", features = ["cargo", "derive"] }
+clap = { version = "3.1", features = ["cargo", "derive"] }
-clap_complete = "~3.1"
+log = "0.4"
-clap_mangen = "~0.1"
+walkdir = "2.3"
-walkdir = "~2.3"
+console = "0.15"
-console = "~0.15"
+lazy_static = "1.4"
-lazy_static = "~1.4"
+chrono = "0.4"
-chrono = "~0.4"
+pretty_env_logger = "0.4"
-glob = "~0.3"
+glob = "0.3"
-strum = { version = "~0.24", features = ["derive"] }
+strum = { version = "0.24", features = ["derive"] }
-thiserror = "~1.0"
+thiserror = "1.0"
-tempfile = "~3.2"
+anyhow = "1.0"
-cfg-if = "~1.0"
+tempfile = "3.2"
-tokio = { version = "~1.18", features = ["process", "rt-multi-thread"] }
+cfg-if = "1.0"
-futures = "~0.3"
+tokio = { version = "1.5", features = ["process", "rt-multi-thread"] }
-regex = "~1.5"
+futures = "0.3"
-semver = "~1.0"
+regex = "1.5"
-shell-words = "~1.1"
+sys-info = "0.9"
-color-eyre = "~0.6"
+semver = "1.0"
-tracing = { version = "~0.1", features = ["attributes", "log"] }
-tracing-subscriber = { version = "~0.3", features = ["env-filter", "time"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
-notify-rust = "~4.5"
+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"
-nix = "~0.24"
+rust-ini = "0.18"
-rust-ini = "~0.18"
+self_update_crate = { version = "0.30", default-features = false, optional = true, package = "self_update", features = ["archive-tar", "compression-flate2", "rustls"] }
-self_update_crate = { version = "~0.30", default-features = false, optional = true, package = "self_update", features = ["archive-tar", "compression-flate2", "rustls"] }
 
 [target.'cfg(windows)'.dependencies]
-self_update_crate = { version = "~0.30", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
+self_update_crate = { version = "0.30", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
-winapi = "~0.3"
+winapi = "0.3"
-parselnk = "~0.1"
+parselnk = "0.1"
 
 [profile.release]
 lto = true

Cross.toml

@@ -1,4 +0,0 @@
-# Workaround for: https://github.com/cross-rs/cross/issues/1100
-# TODO: Remove this file altogether once a new version of cross (after v0.2.4) is released.
-[target.x86_64-unknown-freebsd.env]
-passthrough = ["AR_x86_64_unknown_freebsd=x86_64-unknown-freebsd12-ar"]

README.md

@@ -1,12 +1,12 @@
 <div align="center">
-  <h1>
+  <img alt="Topgrade" src="doc/topgrade.png" width="850px">
-    <img alt="Topgrade" src="doc/topgrade_transparent.png" width="850px">
-  </h1>
   
-  <a href="https://github.com/topgrade-rs/topgrade/releases"><img alt="GitHub Release" src="https://img.shields.io/github/release/topgrade-rs/topgrade.svg"></a>
+  <!--
+  <a href="https://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://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>
@@ -22,55 +22,48 @@ To remedy this, **Topgrade** detects which tools you use and runs the appropriat
 
 ## Installation
 
-[![Packaging status](https://repology.org/badge/vertical-allrepos/topgrade.svg)](https://repology.org/project/topgrade/versions)
+- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade) package.
+- NixOS: _topgrade_ package in `nixpkgs`.
+- macOS: [Homebrew](https://formulae.brew.sh/formula/topgrade) or [MacPorts](https://ports.macports.org/port/topgrade/).
 
-- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade)
+Other systems users can either use `cargo install` or use the compiled binaries from the release page.
-- 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/)
-
-Other systems users can either use `cargo install` or the compiled binaries from the release page.
 The compiled binaries contain a self-upgrading feature.
 
-Topgrade requires Rust 1.60 or above.
+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/) .
 
 ## Usage
 
 Just run `topgrade`.
-
+See [the wiki](https://github.com/r-darwish/topgrade/wiki/Step-list) for the list of things Topgrade supports.
-Visit the documentation at [topgrade-rs.github.io](https://topgrade-rs.github.io/) for more information.
-
-> **Warning**
-> Work in Progress
 
 ## Customization
 
 See `config.example.toml` for an example configuration file.
 
-### Configuration Path
+### Configuration path
 
-The configuration should be placed in the following paths depending on the operating system:
+The configuration should be placed in the following paths depending by the operating system:
 
 - **Windows** - `%APPDATA%/topgrade.toml`
 - **macOS** and **other Unix systems** - `${XDG_CONFIG_HOME:-~/.config}/topgrade.toml`
 
-## 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 provide a solution.
+Open a new Issue describing your problem and if possible with a possible 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?
 
@@ -80,10 +73,17 @@ Just fork the repository and start coding.
 
 - 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.
+- Make a Pull Request to the dev branch for new features or to the bug-fixes branch for bug fixes.
 
-## Roadmap
+## Remote execution
 
-- [ ] Add a proper testing framework to the code base.
+You can specify a key called `remote_topgrades` in the configuration file.
-- [ ] Add unit tests for package managers.
+This key should contain a list of hostnames that have Topgrade installed on them.
-- [ ] Split up code into more maintainable parts, eg. putting every linux package manager in a own submodule of linux.rs.
+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
+
+- Add a proper testing framework to the code base.
+- Add unit tests for package managers.
+- Split up code into more maintainable parts, eg. putting every linux package manager in a own submodule of linux.rs.

SECURITY.md

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

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

@@ -13,10 +13,6 @@
 # Do not ask to retry failed steps (default: false)
 #no_retry = true
 
-# 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
 
@@ -44,9 +40,6 @@
 # Skip sending a notification at the end of a run
 #skip_notify = true
 
-# Skip the preamble displayed when topgrade is run
-#display_preamble = false
-
 [git]
 #max_concurrency = 5
 # Additional git repositories to pull
@@ -77,15 +70,12 @@
 #autoremove = true
 
 [linux]
-# Arch Package Manager to use. Allowed values: autodetect, aura, garuda_update, pacman, pamac, paru, pikaur, trizen, yay.
+# Arch Package Manager to use. Allowed values: autodetect, trizen, aura, paru, yay, pikaur, pacman, pamac.
 #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 = ""
@@ -95,18 +85,11 @@
 #emerge_update_flags = "-uDNa --with-bdeps=y world"
 #redhat_distro_sync = false
 #rpm_ostree = false
-#nix_arguments = "--flake"
-
-[python]
-#enable_pip_review = true   ###disabled by default
-#enable_pipupgrade = true   ###disabled by default
 
 [windows]
 # Manually select Windows updates
 #accept_all_updates = false
 #open_remotes_in_new_terminal = true
-#wsl_update_pre_release = true
-#wsl_update_use_web_download = true
 
 # Causes Topgrade to rename itself during the run to allow package managers
 # to upgrade it. Use this only if you installed Topgrade by using a package

src/command.rs

@@ -1,244 +0,0 @@
-//! 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/config.rs

@@ -5,21 +5,17 @@ use std::path::PathBuf;
 use std::process::Command;
 use std::{env, fs};
 
+use anyhow::Result;
 use clap::{ArgEnum, Parser};
-use clap_complete::Shell;
-use color_eyre::eyre;
-use color_eyre::eyre::Context;
-use color_eyre::eyre::Result;
 use directories::BaseDirs;
+use log::debug;
 use regex::Regex;
 use serde::Deserialize;
 use strum::{EnumIter, EnumString, EnumVariantNames, IntoEnumIterator};
-use tracing::debug;
+use sys_info::hostname;
 use which_crate::which;
 
-use crate::command::CommandExt;
+use super::utils::editor;
-
-use super::utils::{editor, hostname};
 
 pub static EXAMPLE_CONFIG: &str = include_str!("../config.example.toml");
 
@@ -71,13 +67,12 @@ type Commands = BTreeMap<String, String>;
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
 pub enum Step {
-    AM,
     Asdf,
     Atom,
-    Bin,
     BrewCask,
     BrewFormula,
     Bun,
+    Bin,
     Cargo,
     Chezmoi,
     Chocolatey,
@@ -88,9 +83,8 @@ pub enum Step {
     Containers,
     CustomCommands,
     DebGet,
-    Deno,
     Distrobox,
-    DkpPacman,
+    Deno,
     Dotnet,
     Emacs,
     Firmware,
@@ -102,17 +96,14 @@ pub enum Step {
     Ghcup,
     GithubCliExtensions,
     GitRepos,
-    GnomeShellExtensions,
     Go,
     Guix,
     Haxelib,
-    Helm,
+    GnomeShellExtensions,
     HomeManager,
     Jetpack,
     Julia,
-    Juliaup,
     Kakoune,
-    Helix,
     Krew,
     Macports,
     Mas,
@@ -124,13 +115,10 @@ pub enum Step {
     Pacdef,
     Pacstall,
     Pearl,
-    Pip3,
-    PipReview,
-    Pipupgrade,
     Pipx,
+    Pip3,
     Pkg,
     Pkgin,
-    Pnpm,
     Powershell,
     Protonup,
     Raco,
@@ -138,7 +126,6 @@ pub enum Step {
     Remotes,
     Restarts,
     Rtcl,
-    RubyGems,
     Rustup,
     Scoop,
     Sdkman,
@@ -158,9 +145,7 @@ pub enum Step {
     Vim,
     Winget,
     Wsl,
-    WslUpdate,
     Yadm,
-    Yarn,
 }
 
 #[derive(Deserialize, Default, Debug)]
@@ -187,15 +172,6 @@ pub struct Windows {
     self_rename: Option<bool>,
     open_remotes_in_new_terminal: Option<bool>,
     enable_winget: Option<bool>,
-    wsl_update_pre_release: Option<bool>,
-    wsl_update_use_web_download: Option<bool>,
-}
-
-#[derive(Deserialize, Default, Debug)]
-#[serde(deny_unknown_fields)]
-pub struct Python {
-    enable_pip_review: Option<bool>,
-    enable_pipupgrade: Option<bool>,
 }
 
 #[derive(Deserialize, Default, Debug)]
@@ -245,14 +221,13 @@ pub struct Brew {
 #[serde(rename_all = "snake_case")]
 pub enum ArchPackageManager {
     Autodetect,
-    Aura,
-    GarudaUpdate,
-    Pacman,
-    Pamac,
-    Paru,
-    Pikaur,
     Trizen,
+    Paru,
     Yay,
+    Pacman,
+    Pikaur,
+    Pamac,
+    Aura,
 }
 
 #[derive(Deserialize, Default, Debug)]
@@ -263,12 +238,10 @@ pub struct Linux {
     aura_pacman_arguments: Option<String>,
     arch_package_manager: Option<ArchPackageManager>,
     show_arch_news: Option<bool>,
-    garuda_update_arguments: Option<String>,
     trizen_arguments: Option<String>,
     pikaur_arguments: Option<String>,
     pamac_arguments: Option<String>,
     dnf_arguments: Option<String>,
-    nix_arguments: Option<String>,
     apt_arguments: Option<String>,
     enable_tlmgr: Option<bool>,
     redhat_distro_sync: Option<bool>,
@@ -293,7 +266,6 @@ pub struct Vim {
 #[serde(deny_unknown_fields)]
 /// Configuration file
 pub struct ConfigFile {
-    pre_sudo: Option<bool>,
     pre_commands: Option<Commands>,
     post_commands: Option<Commands>,
     commands: Option<Commands>,
@@ -308,12 +280,10 @@ pub struct ConfigFile {
     tmux_arguments: Option<String>,
     set_title: Option<bool>,
     display_time: Option<bool>,
-    display_preamble: Option<bool>,
     assume_yes: Option<bool>,
     yay_arguments: Option<String>,
     aura_aur_arguments: Option<String>,
     aura_pacman_arguments: Option<String>,
-    python: Option<Python>,
     no_retry: Option<bool>,
     run_in_tmux: Option<bool>,
     cleanup: Option<bool>,
@@ -378,12 +348,12 @@ impl ConfigFile {
         };
 
         let contents = fs::read_to_string(&config_path).map_err(|e| {
-            tracing::error!("Unable to read {}", config_path.display());
+            log::error!("Unable to read {}", config_path.display());
             e
         })?;
 
         let mut result: Self = toml::from_str(&contents).map_err(|e| {
-            tracing::error!("Failed to deserialize {}", config_path.display());
+            log::error!("Failed to deserialize {}", config_path.display());
             e
         })?;
 
@@ -419,8 +389,9 @@ impl ConfigFile {
         Command::new(command)
             .args(args)
             .arg(config_path)
-            .status_checked()
+            .spawn()
-            .context("Failed to open configuration file editor")
+            .and_then(|mut p| p.wait())?;
+        Ok(())
     }
 }
 
@@ -453,22 +424,22 @@ pub struct CommandLineArgs {
     no_retry: bool,
 
     /// Do not perform upgrades for the given steps
-    #[clap(long = "disable", value_name = "STEP", arg_enum, multiple_values = true)]
+    #[clap(long = "disable", arg_enum, multiple_values = true)]
     disable: Vec<Step>,
 
     /// Perform only the specified steps (experimental)
-    #[clap(long = "only", value_name = "STEP", arg_enum, multiple_values = true)]
+    #[clap(long = "only", arg_enum, multiple_values = true)]
     only: Vec<Step>,
 
     /// Run only specific custom commands
-    #[clap(long = "custom-commands", value_name = "NAME", multiple_values = true)]
+    #[clap(long = "custom-commands")]
     custom_commands: Vec<String>,
 
     /// Set environment variables
-    #[clap(long = "env", value_name = "NAME=VALUE", multiple_values = true)]
+    #[clap(long = "env", multiple_values = true)]
     env: Vec<String>,
 
-    /// Output debug logs. Alias for `--log-filter debug`.
+    /// Output logs
     #[clap(short = 'v', long = "verbose")]
     pub verbose: bool,
 
@@ -481,14 +452,7 @@ pub struct CommandLineArgs {
     skip_notify: bool,
 
     /// Say yes to package manager's prompt
-    #[clap(
+    #[clap(short = 'y', long = "yes", arg_enum, multiple_values = true, min_values = 0)]
-        short = 'y',
-        long = "yes",
-        value_name = "STEP",
-        arg_enum,
-        multiple_values = true,
-        min_values = 0
-    )]
     yes: Option<Vec<Step>>,
 
     /// Don't pull the predefined git repos
@@ -496,30 +460,16 @@ pub struct CommandLineArgs {
     disable_predefined_git_repos: bool,
 
     /// Alternative configuration file
-    #[clap(long = "config", value_name = "PATH")]
+    #[clap(long = "config")]
     config: Option<PathBuf>,
 
     /// A regular expression for restricting remote host execution
-    #[clap(long = "remote-host-limit", value_name = "REGEX")]
+    #[clap(long = "remote-host-limit")]
     remote_host_limit: Option<Regex>,
 
     /// Show the reason for skipped steps
     #[clap(long = "show-skipped")]
     show_skipped: bool,
-
-    /// Tracing filter directives.
-    ///
-    /// See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/struct.EnvFilter.html
-    #[clap(long, default_value = "info")]
-    pub log_filter: String,
-
-    /// Print completion script for the given shell and exit
-    #[clap(long, arg_enum, hide = true)]
-    pub gen_completion: Option<Shell>,
-
-    /// Print roff manpage and exit
-    #[clap(long, hide = true)]
-    pub gen_manpage: bool,
 }
 
 impl CommandLineArgs {
@@ -534,14 +484,6 @@ impl CommandLineArgs {
     pub fn env_variables(&self) -> &Vec<String> {
         &self.env
     }
-
-    pub fn tracing_filter_directives(&self) -> String {
-        if self.verbose {
-            "debug".into()
-        } else {
-            self.log_filter.clone()
-        }
-    }
 }
 
 /// Represents the application configuration
@@ -565,11 +507,11 @@ impl Config {
             ConfigFile::read(base_dirs, opt.config.clone()).unwrap_or_else(|e| {
                 // Inform the user about errors when loading the configuration,
                 // but fallback to the default config to at least attempt to do something
-                tracing::error!("failed to load configuration: {}", e);
+                log::error!("failed to load configuration: {}", e);
                 ConfigFile::default()
             })
         } else {
-            tracing::debug!("Configuration directory {} does not exist", config_directory.display());
+            log::debug!("Configuration directory {} does not exist", config_directory.display());
             ConfigFile::default()
         };
 
@@ -684,16 +626,8 @@ impl Config {
     }
 
     /// Extra Tmux arguments
-    pub fn tmux_arguments(&self) -> eyre::Result<Vec<String>> {
+    pub fn tmux_arguments(&self) -> &Option<String> {
-        let args = &self.config_file.tmux_arguments.as_deref().unwrap_or_default();
+        &self.config_file.tmux_arguments
-        shell_words::split(args)
-            // The only time the parse failed is in case of a missing close quote.
-            // The error message looks like this:
-            //     Error: Failed to parse `tmux_arguments`: `'foo`
-            //
-            //     Caused by:
-            //         missing closing quote
-            .with_context(|| format!("Failed to parse `tmux_arguments`: `{args}`"))
     }
 
     /// Prompt for a key before exiting
@@ -757,24 +691,6 @@ impl Config {
             .unwrap_or(false)
     }
 
-    // Should wsl --update should use the --pre-release flag
-    pub fn wsl_update_pre_release(&self) -> bool {
-        self.config_file
-            .windows
-            .as_ref()
-            .and_then(|w| w.wsl_update_pre_release)
-            .unwrap_or(false)
-    }
-
-    // Should wsl --update use the --web-download flag
-    pub fn wsl_update_use_web_download(&self) -> bool {
-        self.config_file
-            .windows
-            .as_ref()
-            .and_then(|w| w.wsl_update_use_web_download)
-            .unwrap_or(false)
-    }
-
     /// Whether Brew cask should be greedy
     pub fn brew_cask_greedy(&self) -> bool {
         self.config_file
@@ -816,15 +732,6 @@ impl Config {
         self.config_file.notify_each_step.unwrap_or(false)
     }
 
-    /// Extra garuda-update arguments
-    pub fn garuda_update_arguments(&self) -> &str {
-        self.config_file
-            .linux
-            .as_ref()
-            .and_then(|s| s.garuda_update_arguments.as_deref())
-            .unwrap_or("")
-    }
-
     /// Extra trizen arguments
     pub fn trizen_arguments(&self) -> &str {
         self.config_file
@@ -912,14 +819,6 @@ impl Config {
             .and_then(|linux| linux.dnf_arguments.as_deref())
     }
 
-    /// Extra nix arguments
-    pub fn nix_arguments(&self) -> Option<&str> {
-        self.config_file
-            .linux
-            .as_ref()
-            .and_then(|linux| linux.nix_arguments.as_deref())
-    }
-
     /// Distrobox use root
     pub fn distrobox_root(&self) -> bool {
         self.config_file
@@ -984,7 +883,7 @@ impl Config {
             .linux
             .as_ref()
             .and_then(|linux| linux.rpm_ostree)
-            .unwrap_or(true)
+            .unwrap_or(false)
     }
 
     /// Should we ignore failures for this step
@@ -1017,12 +916,6 @@ impl Config {
             .unwrap_or(false)
     }
 
-    /// If `true`, `sudo` should be called after `pre_commands` in order to elevate at the
-    /// start of the session (and not in the middle).
-    pub fn pre_sudo(&self) -> bool {
-        self.config_file.pre_sudo.unwrap_or(false)
-    }
-
     #[cfg(target_os = "linux")]
     pub fn npm_use_sudo(&self) -> bool {
         self.config_file
@@ -1088,31 +981,10 @@ impl Config {
             .unwrap_or(false);
     }
 
-    pub fn enable_pipupgrade(&self) -> bool {
-        return self
-            .config_file
-            .python
-            .as_ref()
-            .and_then(|python| python.enable_pipupgrade)
-            .unwrap_or(false);
-    }
-    pub fn enable_pip_review(&self) -> bool {
-        return self
-            .config_file
-            .python
-            .as_ref()
-            .and_then(|python| python.enable_pip_review)
-            .unwrap_or(false);
-    }
-
     pub fn display_time(&self) -> bool {
         self.config_file.display_time.unwrap_or(true)
     }
 
-    pub fn display_preamble(&self) -> bool {
-        self.config_file.display_preamble.unwrap_or(true)
-    }
-
     pub fn should_run_custom_command(&self, name: &str) -> bool {
         if self.opt.custom_commands.is_empty() {
             return true;

src/ctrlc/interrupted.rs

@@ -1,7 +1,10 @@
+use lazy_static::lazy_static;
 use std::sync::atomic::{AtomicBool, Ordering};
 
-/// A global variable telling whether the application has been interrupted.
+lazy_static! {
-static INTERRUPTED: AtomicBool = AtomicBool::new(false);
+    /// A global variable telling whether the application has been interrupted.
+    static ref INTERRUPTED: AtomicBool = AtomicBool::new(false);
+}
 
 /// Tells whether the program has been interrupted
 pub fn interrupted() -> bool {

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) } {
-        tracing::error!("Cannot set a control C handler")
+        log::error!("Cannot set a control C handler")
     }
 }

src/error.rs

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

src/execution_context.rs

@@ -1,47 +1,51 @@
 #![allow(dead_code)]
 use crate::executor::RunType;
 use crate::git::Git;
-use crate::sudo::Sudo;
 use crate::utils::require_option;
 use crate::{config::Config, executor::Executor};
-use color_eyre::eyre::Result;
+use anyhow::Result;
 use directories::BaseDirs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
-use std::sync::Mutex;
 
 pub struct ExecutionContext<'a> {
     run_type: RunType,
-    sudo: Option<Sudo>,
+    sudo: &'a Option<PathBuf>,
     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: Option<Sudo>,
+        sudo: &'a Option<PathBuf>,
         git: &'a Git,
         config: &'a Config,
         base_dirs: &'a BaseDirs,
-    ) -> Self {
+    ) -> ExecutionContext<'a> {
-        Self {
+        ExecutionContext {
             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())?;
-        Ok(sudo.execute_elevated(self, command, interactive))
+        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)
     }
 
     pub fn run_type(&self) -> RunType {
@@ -52,8 +56,8 @@ impl<'a> ExecutionContext<'a> {
         self.git
     }
 
-    pub fn sudo(&self) -> &Option<Sudo> {
+    pub fn sudo(&self) -> &Option<PathBuf> {
-        &self.sudo
+        self.sudo
     }
 
     pub fn config(&self) -> &Config {
@@ -63,12 +67,4 @@ impl<'a> ExecutionContext<'a> {
     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,14 +1,11 @@
 //! 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, Output};
+use std::process::{Child, Command, ExitStatus};
-
-use color_eyre::eyre;
-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)]
@@ -59,16 +56,6 @@ 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 {
@@ -152,7 +139,7 @@ impl Executor {
         let result = match self {
             Executor::Wet(c) => {
                 debug!("Running {:?}", c);
-                c.spawn_checked().map(ExecutorChild::Wet)?
+                c.spawn().map(ExecutorChild::Wet)?
             }
             Executor::Dry(c) => {
                 c.dry_run();
@@ -166,7 +153,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_checked()?)),
+            Executor::Wet(c) => Ok(ExecutorOutput::Wet(c.output()?)),
             Executor::Dry(c) => {
                 c.dry_run();
                 Ok(ExecutorOutput::Dry)
@@ -174,28 +161,23 @@ impl Executor {
         }
     }
 
-    /// An extension of `status_checked` that allows you to set a sequence of codes
+    /// 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
     /// that can indicate success of a script
     #[allow(dead_code)]
-    pub fn status_checked_with_codes(&mut self, codes: &[i32]) -> Result<()> {
+    pub fn check_run_with_codes(&mut self, codes: &[i32]) -> Result<()> {
-        match self {
+        self.spawn()?.wait()?.check_with_codes(codes)
-            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(Output),
+    Wet(std::process::Output),
     Dry,
 }
 
@@ -212,12 +194,11 @@ impl DryCommand {
         print!(
             "Dry running: {} {}",
             self.program.to_string_lossy(),
-            shell_words::join(
+            self.args
-                self.args
+                .iter()
-                    .iter()
+                .map(|a| String::from(a.to_string_lossy()))
-                    .map(|a| String::from(a.to_string_lossy()))
+                .collect::<Vec<String>>()
-                    .collect::<Vec<String>>()
+                .join(" ")
-            )
         );
         match &self.directory {
             Some(dir) => println!(" in {}", dir.to_string_lossy()),
@@ -232,33 +213,78 @@ pub enum ExecutorChild {
     Dry,
 }
 
-impl CommandExt for Executor {
+impl ExecutorChild {
-    type Child = 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,
+        };
 
-    // TODO: It might be nice to make `output_checked_with` return something that has a
+        Ok(result)
-    // variant for wet/dry runs.
+    }
-
+}
-    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> eyre::Result<Output> {
+
-        match self {
+/// The Result of wait. Contains an actual `std::process::ExitStatus` if executed by a wet command.
-            Executor::Wet(c) => c.output_checked_with(succeeded),
+pub enum ExecutorExitStatus {
-            Executor::Dry(c) => {
+    Wet(ExitStatus),
-                c.dry_run();
+    Dry,
-                Err(DryRun().into())
+}
-            }
+
-        }
+impl CheckWithCodes for ExecutorExitStatus {
-    }
+    fn check_with_codes(self, codes: &[i32]) -> Result<()> {
-
+        match self {
-    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> eyre::Result<()> {
+            ExecutorExitStatus::Wet(e) => e.check_with_codes(codes),
-        match self {
+            ExecutorExitStatus::Dry => Ok(()),
-            Executor::Wet(c) => c.status_checked_with(succeeded),
+        }
-            Executor::Dry(c) => {
+    }
-                c.dry_run();
+}
-                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 spawn_checked(&mut self) -> eyre::Result<Self::Child> {
+    fn string_output(&mut self) -> Result<String>;
-        self.spawn()
+}
+
+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());
+        }
+        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)?)
     }
 }

src/main.rs

@@ -3,14 +3,13 @@
 use std::env;
 use std::io;
 use std::process::exit;
-use std::time::Duration;
 
-use clap::CommandFactory;
+use anyhow::{anyhow, Result};
 use clap::{crate_version, Parser};
-use color_eyre::eyre::Context;
-use color_eyre::eyre::{eyre, Result};
 use console::Key;
-use tracing::debug;
+use log::debug;
+use log::LevelFilter;
+use pretty_env_logger::formatted_timed_builder;
 
 use self::config::{CommandLineArgs, Config, Step};
 use self::error::StepFailed;
@@ -19,7 +18,6 @@ use self::error::Upgraded;
 use self::steps::{remote::*, *};
 use self::terminal::*;
 
-mod command;
 mod config;
 mod ctrlc;
 mod error;
@@ -32,32 +30,16 @@ mod self_renamer;
 #[cfg(feature = "self-update")]
 mod self_update;
 mod steps;
-mod sudo;
 mod terminal;
 mod utils;
 
 fn run() -> Result<()> {
-    color_eyre::install()?;
     ctrlc::set_handler();
 
-    let base_dirs = directories::BaseDirs::new().ok_or_else(|| eyre!("No base directories"))?;
+    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 std::io::stdout());
-        return Ok(());
-    }
-
-    if opt.gen_manpage {
-        let man = clap_mangen::Man::new(CommandLineArgs::command());
-        man.render(&mut std::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();
@@ -65,6 +47,14 @@ 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)?;
         return Ok(());
@@ -86,28 +76,20 @@ fn run() -> Result<()> {
     debug!("Binary path: {:?}", std::env::current_exe());
     debug!("Self Update: {:?}", cfg!(feature = "self-update"));
 
-    if config.display_preamble() || !config.skip_notify() {
-        print_warning("Due to a design issue with notify-send it could be that topgrade hangs when it's finished.
-If this is the case on your system add the --skip-notify flag to the topgrade command or set skip_notify = true in the config file.
-If you don't want this message to appear any longer set display_preamble = false in the config file.
-For more information about this issue see https://askubuntu.com/questions/110969/notify-send-ignores-timeout and https://github.com/topgrade-rs/topgrade/issues/288.");
-    }
-
     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 sudo = sudo::Sudo::detect();
+    let sudo = utils::sudo();
     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, &base_dirs);
 
     let mut runner = runner::Runner::new(&ctx);
 
@@ -141,24 +123,15 @@ For more information about this issue see https://askubuntu.com/questions/110969
         }
     }
 
-    if config.pre_sudo() {
-        if let Some(sudo) = ctx.sudo() {
-            sudo.elevate(&ctx)?;
-        }
-    }
-
     let powershell = powershell::Powershell::new();
     let should_run_powershell = powershell.profile().is_some() && config.should_run(Step::Powershell);
 
     #[cfg(windows)]
     runner.execute(Step::Wsl, "WSL", || windows::run_wsl_topgrade(&ctx))?;
 
-    #[cfg(windows)]
-    runner.execute(Step::WslUpdate, "WSL", || windows::update_wsl(&ctx))?;
-
     if let Some(topgrades) = config.remote_topgrades() {
         for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(t)) {
-            runner.execute(Step::Remotes, format!("Remote ({remote_topgrade})"), || {
+            runner.execute(Step::Remotes, format!("Remote ({})", remote_topgrade), || {
                 remote::ssh::ssh_step(&ctx, remote_topgrade)
             })?;
         }
@@ -174,7 +147,7 @@ For more information about this issue see https://askubuntu.com/questions/110969
                 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))?;
@@ -228,17 +201,17 @@ For more information about this issue see https://askubuntu.com/questions/110969
 
     #[cfg(target_os = "dragonfly")]
     runner.execute(Step::Pkg, "DragonFly BSD Packages", || {
-        dragonfly::upgrade_packages(ctx.sudo().as_ref(), run_type)
+        dragonfly::upgrade_packages(sudo.as_ref(), run_type)
     })?;
 
     #[cfg(target_os = "freebsd")]
     runner.execute(Step::Pkg, "FreeBSD Packages", || {
-        freebsd::upgrade_packages(&ctx, ctx.sudo().as_ref(), run_type)
+        freebsd::upgrade_packages(sudo.as_ref(), run_type)
     })?;
 
     #[cfg(target_os = "openbsd")]
     runner.execute(Step::Pkg, "OpenBSD Packages", || {
-        openbsd::upgrade_packages(ctx.sudo().as_ref(), run_type)
+        openbsd::upgrade_packages(sudo.as_ref(), run_type)
     })?;
 
     #[cfg(target_os = "android")]
@@ -323,7 +296,7 @@ For more information about this issue see https://askubuntu.com/questions/110969
         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(run_type))?;
+        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))?;
@@ -350,21 +323,17 @@ For more information about this issue see https://askubuntu.com/questions/110969
     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::Juliaup, "juliaup", || generic::run_juliaup(&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-global-update", || go::run_go_global_update(run_type))?;
+    runner.execute(Step::Go, "Go", || generic::run_go(run_type))?;
-    runner.execute(Step::Go, "gup", || go::run_go_gup(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(&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::PipReview, "pip-review", || generic::run_pip_review_update(&ctx))?;
-    runner.execute(Step::Pipupgrade, "pipupgrade", || generic::run_pipupgrade_update(&ctx))?;
     runner.execute(Step::Ghcup, "ghcup", || generic::run_ghcup_update(run_type))?;
     runner.execute(Step::Stack, "stack", || generic::run_stack_update(run_type))?;
     runner.execute(Step::Tlmgr, "tlmgr", || generic::run_tlmgr_update(&ctx))?;
@@ -380,17 +349,13 @@ For more information about this issue see https://askubuntu.com/questions/110969
     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::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::Node, "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(run_type))?;
-    runner.execute(Step::Helm, "helm", || generic::run_helm_repo_update(run_type))?;
     runner.execute(Step::Gem, "gem", || generic::run_gem(&base_dirs, run_type))?;
-    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))?;
@@ -408,16 +373,14 @@ For more information about this issue see https://askubuntu.com/questions/110969
 
     #[cfg(target_os = "linux")]
     {
-        runner.execute(Step::AM, "am", || linux::update_am(&ctx))?;
         runner.execute(Step::DebGet, "deb-get", || linux::run_deb_get(&ctx))?;
         runner.execute(Step::Toolbx, "toolbx", || toolbx::run_toolbx(&ctx))?;
         runner.execute(Step::Flatpak, "Flatpak", || linux::flatpak_update(&ctx))?;
-        runner.execute(Step::Snap, "snap", || linux::run_snap(ctx.sudo().as_ref(), run_type))?;
+        runner.execute(Step::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))?;
-        runner.execute(Step::DkpPacman, "dkp-pacman", || linux::run_dkp_pacman_update(&ctx))?;
     }
 
     if let Some(commands) = config.commands() {
@@ -433,11 +396,11 @@ For more information about this issue see https://askubuntu.com/questions/110969
     #[cfg(target_os = "linux")]
     {
         runner.execute(Step::System, "pihole", || {
-            linux::run_pihole_update(ctx.sudo().as_ref(), run_type)
+            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(ctx.sudo().as_ref(), run_type)
+            linux::run_needrestart(sudo.as_ref(), run_type)
         })?;
     }
 
@@ -450,12 +413,12 @@ For more information about this issue see https://askubuntu.com/questions/110969
 
     #[cfg(target_os = "freebsd")]
     runner.execute(Step::System, "FreeBSD Upgrade", || {
-        freebsd::upgrade_freebsd(ctx.sudo().as_ref(), run_type)
+        freebsd::upgrade_freebsd(sudo.as_ref(), run_type)
     })?;
 
     #[cfg(target_os = "openbsd")]
     runner.execute(Step::System, "OpenBSD Upgrade", || {
-        openbsd::upgrade_openbsd(ctx.sudo().as_ref(), run_type)
+        openbsd::upgrade_openbsd(sudo.as_ref(), run_type)
     })?;
 
     #[cfg(windows)]
@@ -487,10 +450,10 @@ For more information about this issue see https://askubuntu.com/questions/110969
         }
 
         #[cfg(target_os = "freebsd")]
-        freebsd::audit_packages(ctx.sudo().as_ref()).ok();
+        freebsd::audit_packages(&sudo).ok();
 
         #[cfg(target_os = "dragonfly")]
-        dragonfly::audit_packages(ctx.sudo().as_ref()).ok();
+        dragonfly::audit_packages(&sudo).ok();
     }
 
     let mut post_command_failed = false;
@@ -507,10 +470,10 @@ For more information about this issue see https://askubuntu.com/questions/110969
         loop {
             match get_key() {
                 Ok(Key::Char('s')) | Ok(Key::Char('S')) => {
-                    run_shell().context("Failed to execute shell")?;
+                    run_shell();
                 }
                 Ok(Key::Char('r')) | Ok(Key::Char('R')) => {
-                    reboot().context("Failed to reboot")?;
+                    reboot();
                 }
                 Ok(Key::Char('q')) | Ok(Key::Char('Q')) => (),
                 _ => {
@@ -529,8 +492,8 @@ For more information about this issue see https://askubuntu.com/questions/110969
                 "Topgrade finished {}",
                 if failed { "with errors" } else { "successfully" }
             ),
-            Some(Duration::from_secs(10)),
+            None,
-        )
+        );
     }
 
     if failed {
@@ -560,35 +523,9 @@ fn main() {
                     .is_some());
 
             if !skip_print {
-                // The `Debug` implementation of `eyre::Result` prints a multi-line
+                println!("Error: {}", error);
-                // error message that includes all the 'causes' added with
-                // `.with_context(...)` calls.
-                println!("Error: {error:?}");
             }
             exit(1);
         }
     }
 }
-
-pub fn install_tracing(filter_directives: &str) -> Result<()> {
-    use tracing_subscriber::fmt;
-    use tracing_subscriber::fmt::format::FmtSpan;
-    use tracing_subscriber::layer::SubscriberExt;
-    use tracing_subscriber::util::SubscriberInitExt;
-    use tracing_subscriber::EnvFilter;
-
-    let env_filter = EnvFilter::try_new(filter_directives)
-        .or_else(|_| EnvFilter::try_from_default_env())
-        .or_else(|_| EnvFilter::try_new("info"))?;
-
-    let fmt_layer = fmt::layer()
-        .with_target(false)
-        .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
-        .without_time();
-
-    let registry = tracing_subscriber::registry();
-
-    registry.with(env_filter).with(fmt_layer).init();
-
-    Ok(())
-}

src/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), "{key} already reported");
+            debug_assert!(!self.data.iter().any(|(k, _)| k == &key), "{} already reported", key);
             self.data.push((key, success));
         }
     }

src/runner.rs

@@ -2,12 +2,11 @@ use crate::ctrlc;
 use crate::error::{DryRun, SkipStep};
 use crate::execution_context::ExecutionContext;
 use crate::report::{Report, StepResult};
-use crate::terminal::print_error;
 use crate::{config::Step, terminal::should_retry};
-use color_eyre::eyre::Result;
+use anyhow::Result;
+use log::debug;
 use std::borrow::Cow;
 use std::fmt::Debug;
-use tracing::debug;
 
 pub struct Runner<'a> {
     ctx: &'a ExecutionContext<'a>,
@@ -56,12 +55,7 @@ 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 = if should_ask {
+                    let should_retry = should_ask && should_retry(interrupted, key.as_ref())?;
-                        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 color_eyre::eyre::Result;
+use anyhow::Result;
+use log::{debug, error};
 use std::{env::current_exe, fs, path::PathBuf};
-use tracing::{debug, error};
 
 pub struct SelfRenamer {
     exe_path: PathBuf,

src/self_update.rs

@@ -1,15 +1,13 @@
-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");
@@ -20,7 +18,11 @@ pub fn self_update() -> Result<()> {
         .repo_owner("topgrade-rs")
         .repo_name("topgrade")
         .target(target)
-        .bin_name(if cfg!(windows) { "topgrade.exe" } else { "topgrade" })
+        .bin_name(if cfg!(windows) {
+            "topgrade-rs.exe"
+        } else {
+            "topgrade-rs"
+        })
         .show_output(false)
         .show_download_progress(true)
         .current_version(self_update_crate::cargo_crate_version!())
@@ -51,8 +53,7 @@ pub fn self_update() -> Result<()> {
 
             #[cfg(windows)]
             {
-                #[allow(clippy::disallowed_methods)]
+                let status = command.spawn().and_then(|mut c| c.wait())?;
-                let status = command.status()?;
                 bail!(Upgraded(status));
             }
         }

src/steps/containers.rs

@@ -1,15 +1,12 @@
-use std::path::Path;
+use anyhow::Result;
-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::executor::CommandExt;
 use crate::terminal::print_separator;
 use crate::{execution_context::ExecutionContext, utils::require};
+use log::{debug, error, warn};
+use std::path::Path;
+use std::process::Command;
 
 // 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
@@ -27,10 +24,11 @@ fn list_containers(crt: &Path) -> Result<Vec<String>> {
     );
     let output = Command::new(crt)
         .args(["image", "ls", "--format", "{{.Repository}}:{{.Tag}}"])
-        .output_checked_with_utf8(|_| Ok(()))?;
+        .output()?;
+    let output_str = String::from_utf8(output.stdout)?;
 
     let mut retval = vec![];
-    for line in output.stdout.lines() {
+    for line in output_str.lines() {
         if line.starts_with("localhost") {
             // Don't know how to update self-built containers
             debug!("Skipping self-built container '{}'", line);
@@ -62,7 +60,7 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Containers");
     let mut success = true;
-    let containers = list_containers(&crt).context("Failed to list Docker containers")?;
+    let containers = list_containers(&crt)?;
     debug!("Containers to inspect: {:?}", containers);
 
     for container in containers.iter() {
@@ -70,7 +68,7 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
         let args = vec!["pull", &container[..]];
         let mut exec = ctx.run_type().execute(&crt);
 
-        if let Err(e) = exec.args(&args).status_checked() {
+        if let Err(e) = exec.args(&args).check_run() {
             error!("Pulling container '{}' failed: {}", container, e);
 
             // Find out if this is 'skippable'
@@ -79,10 +77,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.output_checked_utf8() {
+            if match exec.check_output() {
-                Ok(s) => s.stdout.contains(NONEXISTENT_REPO) || s.stderr.contains(NONEXISTENT_REPO),
+                Ok(s) => s.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,
                 },
             } {
@@ -97,12 +95,7 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
     if ctx.config().cleanup() {
         // Remove dangling images
         debug!("Removing dangling images");
-        if let Err(e) = ctx
+        if let Err(e) = ctx.run_type().execute(&crt).args(["image", "prune", "-f"]).check_run() {
-            .run_type()
-            .execute(&crt)
-            .args(["image", "prune", "-f"])
-            .status_checked()
-        {
             error!("Removing dangling images failed: {}", e);
             success = false;
         }
@@ -111,6 +104,6 @@ pub fn run_containers(ctx: &ExecutionContext) -> Result<()> {
     if success {
         Ok(())
     } else {
-        Err(eyre!(error::StepFailed))
+        Err(anyhow::anyhow!(error::StepFailed))
     }
 }

src/steps/emacs.rs

@@ -2,10 +2,9 @@
 use std::env;
 use std::path::{Path, PathBuf};
 
-use color_eyre::eyre::Result;
+use anyhow::Result;
 use directories::BaseDirs;
 
-use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
 use crate::utils::{require, require_option, PathExt};
@@ -74,7 +73,7 @@ impl Emacs {
 
         command.args(["upgrade"]);
 
-        command.status_checked()
+        command.check_run()
     }
 
     pub fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
@@ -88,7 +87,7 @@ impl Emacs {
 
         print_separator("Emacs");
 
-        let mut command = ctx.run_type().execute(emacs);
+        let mut command = ctx.run_type().execute(&emacs);
 
         command
             .args(["--batch", "--debug-init", "-l"])
@@ -106,6 +105,6 @@ impl Emacs {
         #[cfg(not(unix))]
         command.arg(EMACS_UPGRADE);
 
-        command.status_checked()
+        command.check_run()
     }
 }

src/steps/generic.rs

@@ -5,20 +5,17 @@ use std::process::Command;
 use std::{env, path::Path};
 use std::{fs, io::Write};
 
-use color_eyre::eyre::eyre;
+use anyhow::Result;
-use color_eyre::eyre::Context;
-use color_eyre::eyre::Result;
 use directories::BaseDirs;
+use log::debug;
 use tempfile::tempfile_in;
-use tracing::{debug, error};
 
-use crate::command::{CommandExt, Utf8Output};
 use crate::execution_context::ExecutionContext;
-use crate::executor::{ExecutorOutput, RunType};
+use crate::executor::{CommandExt, ExecutorOutput, RunType};
 use crate::terminal::{print_separator, shell};
-use crate::utils::{self, require, require_option, which, PathExt};
+use crate::utils::{self, require_option, PathExt};
 use crate::{
-    error::{SkipStep, StepFailed, TopgradeError},
+    error::{SkipStep, TopgradeError},
     terminal::print_warning,
 };
 
@@ -56,23 +53,37 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(cargo_update)
         .args(["install-update", "--git", "--all"])
-        .status_checked()
+        .check_run()
 }
 
 pub fn run_flutter_upgrade(run_type: RunType) -> Result<()> {
     let flutter = utils::require("flutter")?;
 
     print_separator("Flutter");
-    run_type.execute(flutter).arg("upgrade").status_checked()
+    run_type.execute(&flutter).arg("upgrade").check_run()
+}
+
+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();
+
+    let go_global_update = utils::require("go-global-update")
+        .unwrap_or_else(|_| PathBuf::from(gopath).join("bin/go-global-update"))
+        .require()?;
+
+    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("Gems");
+    print_separator("RubyGems");
 
-    let mut command = run_type.execute(gem);
+    let mut command = run_type.execute(&gem);
     command.arg("update");
 
     if env::var_os("RBENV_SHELL").is_none() {
@@ -80,35 +91,14 @@ pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
         command.arg("--user-install");
     }
 
-    command.status_checked()
+    command.check_run()
-}
-
-pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
-    ctx.base_dirs().home_dir().join(".gem").require()?;
-
-    print_separator("RubyGems");
-    if let Some(sudo) = &ctx.sudo() {
-        if !std::path::Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
-            ctx.run_type()
-                .execute(sudo)
-                .arg("-EH")
-                .arg(require("gem")?)
-                .args(["update", "--system"])
-                .status_checked()?;
-        }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
-
-    Ok(())
 }
 
 pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
     let haxelib = utils::require("haxelib")?;
 
     let haxelib_dir =
-        PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output_checked()?.stdout)?.trim())
+        PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output()?.stdout)?.trim()).require()?;
-            .require()?;
 
     let directory_writable = tempfile_in(&haxelib_dir).is_ok();
     debug!("{:?} writable: {}", haxelib_dir, directory_writable);
@@ -125,7 +115,7 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
         c
     };
 
-    command.arg("update").status_checked()
+    command.arg("update").check_run()
 }
 
 pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
@@ -133,10 +123,7 @@ pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Sheldon");
 
-    ctx.run_type()
+    ctx.run_type().execute(&sheldon).args(["lock", "--update"]).check_run()
-        .execute(sheldon)
-        .args(["lock", "--update"])
-        .status_checked()
 }
 
 pub fn run_fossil(run_type: RunType) -> Result<()> {
@@ -144,7 +131,7 @@ pub fn run_fossil(run_type: RunType) -> Result<()> {
 
     print_separator("Fossil");
 
-    run_type.execute(fossil).args(["all", "sync"]).status_checked()
+    run_type.execute(&fossil).args(["all", "sync"]).check_run()
 }
 
 pub fn run_micro(run_type: RunType) -> Result<()> {
@@ -152,17 +139,13 @@ pub fn run_micro(run_type: RunType) -> Result<()> {
 
     print_separator("micro");
 
-    let stdout = run_type
+    let stdout = run_type.execute(&micro).args(["-plugin", "update"]).string_output()?;
-        .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(eyre!("micro output does not indicate success: {}", stdout))
+        Err(anyhow::anyhow!("micro output does not indicate success: {}", stdout))
     }
 }
 
@@ -177,10 +160,7 @@ pub fn run_apm(run_type: RunType) -> Result<()> {
 
     print_separator("Atom Package Manager");
 
-    run_type
+    run_type.execute(&apm).args(["upgrade", "--confirm=false"]).check_run()
-        .execute(apm)
-        .args(["upgrade", "--confirm=false"])
-        .status_checked()
 }
 
 pub fn run_rustup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -189,22 +169,10 @@ pub fn run_rustup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     print_separator("rustup");
 
     if rustup.canonicalize()?.is_descendant_of(base_dirs.home_dir()) {
-        run_type.execute(&rustup).args(["self", "update"]).status_checked()?;
+        run_type.execute(&rustup).args(["self", "update"]).check_run()?;
     }
 
-    run_type.execute(&rustup).arg("update").status_checked()
+    run_type.execute(&rustup).arg("update").check_run()
-}
-
-pub fn run_juliaup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
-    let juliaup = utils::require("juliaup")?;
-
-    print_separator("juliaup");
-
-    if juliaup.canonicalize()?.is_descendant_of(base_dirs.home_dir()) {
-        run_type.execute(&juliaup).args(["self", "update"]).status_checked()?;
-    }
-
-    run_type.execute(&juliaup).arg("update").status_checked()
 }
 
 pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
@@ -213,8 +181,8 @@ pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
     print_separator("choosenim");
     let run_type = ctx.run_type();
 
-    run_type.execute(&choosenim).args(["update", "self"]).status_checked()?;
+    run_type.execute(&choosenim).args(["update", "self"]).check_run()?;
-    run_type.execute(&choosenim).args(["update", "stable"]).status_checked()
+    run_type.execute(&choosenim).args(["update", "stable"]).check_run()
 }
 
 pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
@@ -222,22 +190,18 @@ pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
 
     print_separator("Krew");
 
-    run_type.execute(krew).args(["upgrade"]).status_checked()
+    run_type.execute(&krew).args(["upgrade"]).check_run()
 }
 
 pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
     let gcloud = utils::require("gcloud")?;
 
-    if gcloud.starts_with("/snap") {
+    print_separator("gcloud");
-        Ok(())
-    } else {
-        print_separator("gcloud");
 
-        run_type
+    run_type
-            .execute(gcloud)
+        .execute(&gcloud)
-            .args(["components", "update", "--quiet"])
+        .args(["components", "update", "--quiet"])
-            .status_checked()
+        .check_run()
-    }
 }
 
 pub fn run_jetpack(run_type: RunType) -> Result<()> {
@@ -245,7 +209,7 @@ pub fn run_jetpack(run_type: RunType) -> Result<()> {
 
     print_separator("Jetpack");
 
-    run_type.execute(jetpack).args(["global", "update"]).status_checked()
+    run_type.execute(&jetpack).args(["global", "update"]).check_run()
 }
 
 pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
@@ -253,7 +217,7 @@ pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("rtcl");
 
-    ctx.run_type().execute(rupdate).status_checked()
+    ctx.run_type().execute(&rupdate).check_run()
 }
 
 pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
@@ -261,44 +225,28 @@ pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("OCaml Package Manager");
 
-    ctx.run_type().execute(&opam).arg("update").status_checked()?;
+    ctx.run_type().execute(&opam).arg("update").check_run()?;
-    ctx.run_type().execute(&opam).arg("upgrade").status_checked()?;
+    ctx.run_type().execute(&opam).arg("upgrade").check_run()?;
 
     if ctx.config().cleanup() {
-        ctx.run_type().execute(&opam).arg("clean").status_checked()?;
+        ctx.run_type().execute(&opam).arg("clean").check_run()?;
     }
 
     Ok(())
 }
 
-pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
+pub fn run_vcpkg_update(run_type: RunType) -> Result<()> {
     let vcpkg = utils::require("vcpkg")?;
     print_separator("vcpkg");
 
-    #[cfg(unix)]
+    run_type.execute(&vcpkg).args(["upgrade", "--no-dry-run"]).check_run()
-    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 mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
-        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")?;
     print_separator("pipx");
 
-    run_type.execute(pipx).arg("upgrade-all").status_checked()
+    run_type.execute(&pipx).arg("upgrade-all").check_run()
 }
 
 pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
@@ -306,25 +254,26 @@ pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
 
     let output = Command::new("conda")
         .args(["config", "--show", "auto_activate_base"])
-        .output_checked_utf8()?;
+        .output()?;
-    debug!("Conda output: {}", output.stdout);
+    let string_output = String::from_utf8(output.stdout)?;
-    if output.stdout.contains("False") {
+    debug!("Conda output: {}", string_output);
+    if string_output.contains("False") {
         return Err(SkipStep("auto_activate_base is set to False".to_string()).into());
     }
 
     print_separator("Conda");
 
     ctx.run_type()
-        .execute(conda)
+        .execute(&conda)
         .args(["update", "--all", "-y"])
-        .status_checked()
+        .check_run()
 }
 
 pub fn run_pip3_update(run_type: RunType) -> Result<()> {
     let python3 = utils::require("python3")?;
     Command::new(&python3)
         .args(["-m", "pip"])
-        .output_checked_utf8()
+        .check_output()
         .map_err(|_| SkipStep("pip does not exists".to_string()))?;
 
     print_separator("pip3");
@@ -336,44 +285,11 @@ pub fn run_pip3_update(run_type: RunType) -> Result<()> {
     run_type
         .execute(&python3)
         .args(["-m", "pip", "install", "--upgrade", "--user", "pip"])
-        .status_checked()
+        .check_run()
-}
-
-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_pipupgrade_update(ctx: &ExecutionContext) -> Result<()> {
-    let pipupgrade = require("pipupgrade")?;
-
-    print_separator("Pipupgrade");
-    if !ctx.config().enable_pip_review() {
-        print_warning(
-            "Pipupgrade is disabled by default. Enable it by setting enable_pipupgrade=true in the configuration.",
-        );
-        return Err(SkipStep(String::from("Pipupgrade is disabled by default")).into());
-    }
-    ctx.run_type().execute(pipupgrade).status_checked()?;
-
-    Ok(())
 }
 
 pub fn run_stack_update(run_type: RunType) -> Result<()> {
-    if utils::require("ghcup").is_ok() {
+    if let Ok(_) = utils::require("ghcup") {
         // `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' !!!
@@ -383,14 +299,14 @@ pub fn run_stack_update(run_type: RunType) -> Result<()> {
     let stack = utils::require("stack")?;
     print_separator("stack");
 
-    run_type.execute(stack).arg("upgrade").status_checked()
+    run_type.execute(&stack).arg("upgrade").check_run()
 }
 
 pub fn run_ghcup_update(run_type: RunType) -> Result<()> {
     let ghcup = utils::require("ghcup")?;
     print_separator("ghcup");
 
-    run_type.execute(ghcup).arg("upgrade").status_checked()
+    run_type.execute(&ghcup).arg("upgrade").check_run()
 }
 
 pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
@@ -406,11 +322,13 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
     let kpsewhich = utils::require("kpsewhich")?;
     let tlmgr_directory = {
         let mut d = PathBuf::from(
-            &Command::new(kpsewhich)
+            std::str::from_utf8(
-                .arg("-var-value=SELFAUTOPARENT")
+                &Command::new(&kpsewhich)
-                .output_checked_utf8()?
+                    .arg("-var-value=SELFAUTOPARENT")
-                .stdout
+                    .output()?
-                .trim(),
+                    .stdout,
+            )?
+            .trim(),
         );
         d.push("tlpkg");
         d
@@ -433,7 +351,7 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
     };
     command.args(["update", "--self", "--all"]);
 
-    command.status_checked()
+    command.check_run()
 }
 
 pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -442,7 +360,7 @@ pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()>
 
     print_separator("chezmoi");
 
-    run_type.execute(chezmoi).arg("update").status_checked()
+    run_type.execute(&chezmoi).arg("update").check_run()
 }
 
 pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -456,27 +374,27 @@ pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()>
         .arg("--directory")
         .arg(base_dirs.home_dir())
         .arg("checkout")
-        .status_checked()?;
+        .check_run()?;
     run_type
         .execute(&myrepos)
         .arg("--directory")
         .arg(base_dirs.home_dir())
         .arg("update")
-        .status_checked()
+        .check_run()
 }
 
 pub fn run_custom_command(name: &str, command: &str, ctx: &ExecutionContext) -> Result<()> {
     print_separator(name);
-    ctx.run_type().execute(shell()).arg("-c").arg(command).status_checked()
+    ctx.run_type().execute(shell()).arg("-c").arg(command).check_run()
 }
 
 pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
     let composer = utils::require("composer")?;
     let composer_home = Command::new(&composer)
         .args(["global", "config", "--absolute", "--quiet", "home"])
-        .output_checked_utf8()
+        .check_output()
-        .map_err(|e| (SkipStep(format!("Error getting the composer directory: {e}"))))
+        .map_err(|e| (SkipStep(format!("Error getting the composer directory: {}", e))))
-        .map(|s| PathBuf::from(s.stdout.trim()))?
+        .map(|s| PathBuf::from(s.trim()))?
         .require()?;
 
     if !composer_home.is_descendant_of(ctx.base_dirs().home_dir()) {
@@ -503,22 +421,26 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
                         .execute(ctx.sudo().as_ref().unwrap())
                         .arg(&composer)
                         .arg("self-update")
-                        .status_checked()?;
+                        .check_run()?;
                 }
             } else {
-                ctx.run_type().execute(&composer).arg("self-update").status_checked()?;
+                ctx.run_type().execute(&composer).arg("self-update").check_run()?;
             }
         }
     }
 
-    let output = ctx.run_type().execute(&composer).args(["global", "update"]).output()?;
+    let output = Command::new(&composer).args(["global", "update"]).output()?;
-    if let ExecutorOutput::Wet(output) = output {
+    let status = output.status;
-        let output: Utf8Output = output.try_into()?;
+    if !status.success() {
-        print!("{}\n{}", output.stdout, output.stderr);
+        return Err(TopgradeError::ProcessFailed(status).into());
-        if output.stdout.contains("valet") || output.stderr.contains("valet") {
+    }
-            if let Some(valet) = utils::which("valet") {
+    let stdout = String::from_utf8(output.stdout)?;
-                ctx.run_type().execute(valet).arg("install").status_checked()?;
+    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()?;
         }
     }
 
@@ -528,27 +450,18 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
 pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let dotnet = utils::require("dotnet")?;
 
-    //Skip when the `dotnet tool list` subcommand fails. (This is expected when a dotnet runtime is installed but no SDK.)
+    let output = Command::new(dotnet).args(["tool", "list", "--global"]).output()?;
-    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())
-        }
-    };
 
-    if !output.stdout.starts_with("Package Id") {
+    if !output.status.success() {
+        return Err(SkipStep(format!("dotnet failed with exit code {:?}", output.status)).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.stdout.lines().skip(2).filter(|line| !line.is_empty()).peekable();
+    let mut packages = output.split('\n').skip(2).filter(|line| !line.is_empty()).peekable();
 
     if packages.peek().is_none() {
         return Err(SkipStep(String::from("No dotnet global tools installed")).into());
@@ -559,60 +472,39 @@ 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"])
-            .status_checked()
+            .check_run()?;
-            .with_context(|| format!("Failed to update .NET package {package_name}"))?;
     }
 
     Ok(())
 }
 
-pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
-    utils::require("helix")?;
-
-    print_separator("Helix");
-
-    ctx.run_type()
-        .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?)
-        .args(["helix", "--grammar", "fetch"])
-        .status_checked()
-        .with_context(|| "Failed to download helix grammars!")?;
-
-    ctx.run_type()
-        .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?)
-        .args(["helix", "--grammar", "build"])
-        .status_checked()
-        .with_context(|| "Failed to build helix grammars!")?;
-
-    Ok(())
-}
-
 pub fn run_raco_update(run_type: RunType) -> Result<()> {
     let raco = utils::require("raco")?;
 
     print_separator("Racket Package Manager");
 
-    run_type.execute(raco).args(["pkg", "update", "--all"]).status_checked()
+    run_type.execute(&raco).args(["pkg", "update", "--all"]).check_run()
 }
 
 pub fn bin_update(ctx: &ExecutionContext) -> Result<()> {
     let bin = utils::require("bin")?;
 
     print_separator("Bin");
-    ctx.run_type().execute(bin).arg("update").status_checked()
+    ctx.run_type().execute(&bin).arg("update").check_run()
 }
 
 pub fn spicetify_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let spicetify = utils::require("spicetify")?;
 
     print_separator("Spicetify");
-    ctx.run_type().execute(spicetify).arg("upgrade").status_checked()
+    ctx.run_type().execute(&spicetify).arg("upgrade").check_run()
 }
 
 pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let gh = utils::require("gh")?;
-    let result = Command::new(&gh).args(["extensions", "list"]).output_checked_utf8();
+    let result = Command::new(&gh).args(["extensions", "list"]).check_output();
     if result.is_err() {
         debug!("GH result {:?}", result);
         return Err(SkipStep(String::from("GH failed")).into());
@@ -622,7 +514,7 @@ pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(&gh)
         .args(["extension", "upgrade", "--all"])
-        .status_checked()
+        .check_run()
 }
 
 pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
@@ -631,33 +523,7 @@ pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Julia Packages");
 
     ctx.run_type()
-        .execute(julia)
+        .execute(&julia)
         .args(["-e", "using Pkg; Pkg.update()"])
-        .status_checked()
+        .check_run()
-}
-
-pub fn run_helm_repo_update(run_type: RunType) -> Result<()> {
-    let helm = utils::require("helm")?;
-
-    print_separator("Helm");
-
-    let no_repo = "no repositories found";
-    let mut success = true;
-    let mut exec = 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))
-    }
 }

src/steps/git.rs

@@ -3,18 +3,17 @@ use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, Stdio};
 
-use color_eyre::eyre::{eyre, Result};
+use anyhow::{anyhow, 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::RunType;
+use crate::executor::{CommandExt, RunType};
 use crate::terminal::print_separator;
 use crate::utils::{which, PathExt};
 use crate::{error::SkipStep, terminal::print_warning};
@@ -34,10 +33,10 @@ pub struct Repositories<'a> {
     bad_patterns: Vec<String>,
 }
 
-fn output_checked_utf8(output: Output) -> Result<()> {
+fn check_output(output: Output) -> Result<()> {
     if !(output.status.success()) {
         let stderr = String::from_utf8(output.stderr).unwrap();
-        Err(eyre!(stderr))
+        Err(anyhow!(stderr))
     } else {
         Ok(())
     }
@@ -67,11 +66,11 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
         .stdin(Stdio::null())
         .output()
         .await?;
-    let result = output_checked_utf8(pull_output).and_then(|_| output_checked_utf8(submodule_output));
+    let result = check_output(pull_output).and_then(|_| check_output(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);
 
@@ -87,9 +86,12 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
                         "log",
                         "--no-decorate",
                         "--oneline",
-                        &format!("{before}..{after}"),
+                        &format!("{}..{}", before, after),
                     ])
-                    .status_checked()?;
+                    .spawn()
+                    .unwrap()
+                    .wait()
+                    .unwrap();
                 println!();
             }
             _ => {
@@ -106,8 +108,8 @@ fn get_head_revision(git: &Path, repo: &str) -> Option<String> {
         .stdin(Stdio::null())
         .current_dir(repo)
         .args(["rev-parse", "HEAD"])
-        .output_checked_utf8()
+        .check_output()
-        .map(|output| output.stdout.trim().to_string())
+        .map(|output| output.trim().to_string())
         .map_err(|e| {
             error!("Error getting revision for {}: {}", repo, e);
 
@@ -121,8 +123,8 @@ fn has_remotes(git: &Path, repo: &str) -> Option<bool> {
         .stdin(Stdio::null())
         .current_dir(repo)
         .args(["remote", "show"])
-        .output_checked_utf8()
+        .check_output()
-        .map(|output| output.stdout.lines().count() > 0)
+        .map(|output| output.lines().count() > 0)
         .map_err(|e| {
             error!("Error getting remotes for {}: {}", repo, e);
             e
@@ -164,9 +166,9 @@ impl Git {
                         .stdin(Stdio::null())
                         .current_dir(path)
                         .args(["rev-parse", "--show-toplevel"])
-                        .output_checked_utf8()
+                        .check_output()
                         .ok()
-                        .map(|output| output.stdout.trim().to_string());
+                        .map(|output| output.trim().to_string());
                     return output;
                 }
             }
@@ -187,7 +189,7 @@ impl Git {
         repositories
             .bad_patterns
             .iter()
-            .for_each(|pattern| print_warning(format!("Path {pattern} did not contain any git repositories")));
+            .for_each(|pattern| print_warning(format!("Path {} did not contain any git repositories", pattern)));
         self.multi_pull(repositories, ctx)
     }
 

src/steps/go.rs

@@ -1,45 +0,0 @@
-use std::path::PathBuf;
-use std::process::Command;
-
-use color_eyre::eyre::Result;
-
-use crate::command::CommandExt;
-use crate::executor::RunType;
-use crate::terminal::print_separator;
-use crate::utils;
-use crate::utils::PathExt;
-
-/// <https://github.com/Gelio/go-global-update>
-pub fn run_go_global_update(run_type: RunType) -> Result<()> {
-    let go_global_update = require_go_bin("go-global-update")?;
-
-    print_separator("go-global-update");
-
-    run_type.execute(go_global_update).status_checked()
-}
-
-/// <https://github.com/nao1215/gup>
-pub fn run_go_gup(run_type: RunType) -> Result<()> {
-    let gup = require_go_bin("gup")?;
-
-    print_separator("gup");
-
-    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,8 +1,10 @@
+use crate::error::TopgradeError;
 use crate::terminal::print_separator;
 use crate::utils::require;
-use color_eyre::eyre::Result;
+use anyhow::Result;
 
 use crate::execution_context::ExecutionContext;
+use crate::executor::ExecutorOutput;
 
 const UPGRADE_KAK: &str = include_str!("upgrade.kak");
 
@@ -11,13 +13,19 @@ pub fn upgrade_kak_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Kakoune");
 
-    // TODO: Why supress output for this command?
+    let mut command = ctx.run_type().execute(&kak);
-    ctx.run_type()
+    command.args(["-ui", "dummy", "-e", UPGRADE_KAK]);
-        .execute(kak)
-        .args(["-ui", "dummy", "-e", UPGRADE_KAK])
-        .output()?;
 
-    println!("Plugins upgraded");
+    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")
+        }
+    }
 
     Ok(())
 }

src/steps/mod.rs

@@ -2,7 +2,6 @@ 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,104 +1,66 @@
-use std::fmt::Display;
+#![allow(unused_imports)]
-#[cfg(target_os = "linux")]
+
-use std::os::unix::fs::MetadataExt;
+#[cfg(unix)]
+use std::os::unix::prelude::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-use crate::utils::require_option;
+use anyhow::Result;
-use color_eyre::eyre::Result;
+use directories::BaseDirs;
-#[cfg(target_os = "linux")]
+use log::debug;
+#[cfg(unix)]
 use nix::unistd::Uid;
 use semver::Version;
-use tracing::debug;
 
-use crate::command::CommandExt;
+use crate::executor::{CommandExt, RunType};
 use crate::terminal::print_separator;
 use crate::utils::{require, PathExt};
 use crate::{error::SkipStep, execution_context::ExecutionContext};
 
-enum NPMVariant {
-    Npm,
-    Pnpm,
-}
-
-impl NPMVariant {
-    const fn short_name(&self) -> &str {
-        match self {
-            NPMVariant::Npm => "npm",
-            NPMVariant::Pnpm => "pnpm",
-        }
-    }
-
-    const fn is_npm(&self) -> bool {
-        matches!(self, NPMVariant::Npm)
-    }
-}
-
-impl Display for NPMVariant {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.short_name())
-    }
-}
-
 #[allow(clippy::upper_case_acronyms)]
 struct NPM {
     command: PathBuf,
-    variant: NPMVariant,
 }
 
 impl NPM {
-    fn new(command: PathBuf, variant: NPMVariant) -> Self {
+    fn new(command: PathBuf) -> Self {
-        Self { command, variant }
+        Self { command }
-    }
-
-    /// Is the “NPM” version larger than 8.11.0?
-    fn is_npm_8(&self) -> bool {
-        let v = self.version();
-
-        self.variant.is_npm() && matches!(v, Ok(v) if v >= Version::new(8, 11, 0))
-    }
-
-    /// Get the most suitable “global location” argument
-    /// of this NPM instance.
-    ///
-    /// If the “NPM” version is larger than 8.11.0, we use
-    /// `--location=global`; otherwise, use `-g`.
-    fn global_location_arg(&self) -> &str {
-        if self.is_npm_8() {
-            "--location=global"
-        } else {
-            "-g"
-        }
     }
 
     #[cfg(target_os = "linux")]
     fn root(&self) -> Result<PathBuf> {
-        let args = ["root", self.global_location_arg()];
+        let version = self.version()?;
+        let args = if version < Version::new(8, 11, 0) {
+            ["root", "-g"]
+        } else {
+            ["root", "--location=global"]
+        };
         Command::new(&self.command)
             .args(args)
-            .output_checked_utf8()
+            .check_output()
-            .map(|s| PathBuf::from(s.stdout.trim()))
+            .map(|s| PathBuf::from(s.trim()))
     }
 
     fn version(&self) -> Result<Version> {
         let version_str = Command::new(&self.command)
             .args(["--version"])
-            .output_checked_utf8()
+            .check_output()
-            .map(|s| s.stdout.trim().to_owned());
+            .map(|s| s.trim().to_owned());
         Version::parse(&version_str?).map_err(|err| err.into())
     }
 
-    fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
+    fn upgrade(&self, run_type: RunType, use_sudo: bool) -> Result<()> {
-        let args = ["update", self.global_location_arg()];
+        print_separator("Node Package Manager");
-        if use_sudo {
+        let version = self.version()?;
-            let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?;
+        let args = if version < Version::new(8, 11, 0) {
-            ctx.run_type()
+            ["update", "-g"]
-                .execute(sudo)
-                .arg(&self.command)
-                .args(args)
-                .status_checked()?;
         } else {
-            ctx.run_type().execute(&self.command).args(args).status_checked()?;
+            ["update", "--location=global"]
+        };
+        if use_sudo {
+            run_type.execute("sudo").args(args).check_run()?;
+        } else {
+            run_type.execute(&self.command).args(args).check_run()?;
         }
 
         Ok(())
@@ -108,7 +70,7 @@ impl NPM {
     pub fn should_use_sudo(&self) -> Result<bool> {
         let npm_root = self.root()?;
         if !npm_root.exists() {
-            return Err(SkipStep(format!("{} root at {} doesn't exist", self.variant, npm_root.display())).into());
+            return Err(SkipStep(format!("NPM root at {} doesn't exist", npm_root.display(),)).into());
         }
 
         let metadata = std::fs::metadata(&npm_root)?;
@@ -131,38 +93,27 @@ impl Yarn {
         }
     }
 
-    fn has_global_subcmd(&self) -> bool {
-        // Get the version of Yarn. After Yarn 2.x (berry),
-        // “yarn global” has been replaced with “yarn dlx”.
-        //
-        // 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"]).output_checked_utf8();
-
-        matches!(version, Ok(ver) if ver.stdout.starts_with('1') || ver.stdout.starts_with('0'))
-    }
-
     #[cfg(target_os = "linux")]
     fn root(&self) -> Result<PathBuf> {
         let args = ["global", "dir"];
         Command::new(&self.command)
             .args(args)
-            .output_checked_utf8()
+            .check_output()
-            .map(|s| PathBuf::from(s.stdout.trim()))
+            .map(|s| PathBuf::from(s.trim()))
     }
 
-    fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
+    fn upgrade(&self, run_type: RunType, use_sudo: bool) -> Result<()> {
+        print_separator("Yarn Package Manager");
         let args = ["global", "upgrade"];
 
         if use_sudo {
-            let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?;
+            run_type
-            ctx.run_type()
+                .execute("sudo")
-                .execute(sudo)
                 .arg(self.yarn.as_ref().unwrap_or(&self.command))
                 .args(args)
-                .status_checked()?;
+                .check_run()?;
         } else {
-            ctx.run_type().execute(&self.command).args(args).status_checked()?;
+            run_type.execute(&self.command).args(args).check_run()?;
         }
 
         Ok(())
@@ -172,7 +123,7 @@ impl Yarn {
     pub fn should_use_sudo(&self) -> Result<bool> {
         let yarn_root = self.root()?;
         if !yarn_root.exists() {
-            return Err(SkipStep(format!("Yarn root at {} doesn't exist", yarn_root.display(),)).into());
+            return Err(SkipStep(format!("NPM root at {} doesn't exist", yarn_root.display(),)).into());
         }
 
         let metadata = std::fs::metadata(&yarn_root)?;
@@ -211,55 +162,30 @@ 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))?;
+    let npm = require("pnpm").or_else(|_| require("npm")).map(NPM::new)?;
-
-    print_separator("Node Package Manager");
 
     #[cfg(target_os = "linux")]
     {
-        npm.upgrade(ctx, should_use_sudo(&npm, ctx)?)
+        npm.upgrade(ctx.run_type(), should_use_sudo(&npm, ctx)?)
     }
 
     #[cfg(not(target_os = "linux"))]
     {
-        npm.upgrade(ctx, false)
+        npm.upgrade(ctx.run_type(), false)
-    }
-}
-
-pub fn run_pnpm_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let pnpm = require("pnpm").map(|b| NPM::new(b, NPMVariant::Pnpm))?;
-
-    print_separator("Node Package Manager");
-
-    #[cfg(target_os = "linux")]
-    {
-        pnpm.upgrade(ctx, should_use_sudo(&pnpm, ctx)?)
-    }
-
-    #[cfg(not(target_os = "linux"))]
-    {
-        pnpm.upgrade(ctx, false)
     }
 }
 
 pub fn run_yarn_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let yarn = require("yarn").map(Yarn::new)?;
 
-    if !yarn.has_global_subcmd() {
-        debug!("Yarn is 2.x or above, skipping global upgrade");
-        return Ok(());
-    }
-
-    print_separator("Yarn Package Manager");
-
     #[cfg(target_os = "linux")]
     {
-        yarn.upgrade(ctx, should_use_sudo_yarn(&yarn, ctx)?)
+        yarn.upgrade(ctx.run_type(), should_use_sudo_yarn(&yarn, ctx)?)
     }
 
     #[cfg(not(target_os = "linux"))]
     {
-        yarn.upgrade(ctx, false)
+        yarn.upgrade(ctx.run_type(), false)
     }
 }
 
@@ -273,5 +199,5 @@ pub fn deno_upgrade(ctx: &ExecutionContext) -> Result<()> {
     }
 
     print_separator("Deno");
-    ctx.run_type().execute(&deno).arg("upgrade").status_checked()
+    ctx.run_type().execute(&deno).arg("upgrade").check_run()
 }

src/steps/os/android.rs

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

src/steps/os/archlinux.rs

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

src/steps/os/dragonfly.rs

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

src/steps/os/freebsd.rs

@@ -1,41 +1,32 @@
-use crate::command::CommandExt;
-use crate::execution_context::ExecutionContext;
 use crate::executor::RunType;
-use crate::sudo::Sudo;
 use crate::terminal::print_separator;
 use crate::utils::require_option;
-use crate::Step;
+use anyhow::Result;
-use color_eyre::eyre::Result;
+use std::path::PathBuf;
 use std::process::Command;
 
-pub fn upgrade_freebsd(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
+pub fn upgrade_freebsd(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     let sudo = require_option(sudo, String::from("No sudo detected"))?;
     print_separator("FreeBSD Update");
     run_type
         .execute(sudo)
-        .args(["/usr/sbin/freebsd-update", "fetch", "install"])
+        .args(&["/usr/sbin/freebsd-update", "fetch", "install"])
-        .status_checked()
+        .check_run()
 }
 
-pub fn upgrade_packages(ctx: &ExecutionContext, sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
+pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     let sudo = require_option(sudo, String::from("No sudo detected"))?;
     print_separator("FreeBSD Packages");
-
+    run_type.execute(sudo).args(&["/usr/sbin/pkg", "upgrade"]).check_run()
-    let mut command = 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<&Sudo>) -> Result<()> {
+pub fn audit_packages(sudo: &Option<PathBuf>) -> Result<()> {
     if let Some(sudo) = sudo {
         println!();
         Command::new(sudo)
-            .args(["/usr/sbin/pkg", "audit", "-Fr"])
+            .args(&["/usr/sbin/pkg", "audit", "-Fr"])
-            .status_checked()?;
+            .spawn()?
+            .wait()?;
     }
     Ok(())
 }

src/steps/os/linux.rs

@@ -1,16 +1,14 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use color_eyre::eyre::Result;
+use anyhow::Result;
 use ini::Ini;
-use tracing::{debug, warn};
+use log::{debug, warn};
 
-use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
+use crate::executor::{CommandExt, RunType};
 use crate::steps::os::archlinux;
-use crate::sudo::Sudo;
 use crate::terminal::{print_separator, print_warning};
 use crate::utils::{require, require_option, which, PathExt};
 use crate::Step;
@@ -29,9 +27,7 @@ pub enum Distribution {
     Debian,
     Gentoo,
     OpenMandriva,
-    PCLinuxOS,
     Suse,
-    SuseMicro,
     Void,
     Solus,
     Exherbo,
@@ -57,10 +53,8 @@ impl Distribution {
             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(id_like) = id_like {
                     if id_like.contains(&"debian") || id_like.contains(&"ubuntu") {
@@ -107,7 +101,6 @@ impl Distribution {
             Distribution::Debian => upgrade_debian(ctx),
             Distribution::Gentoo => upgrade_gentoo(ctx),
             Distribution::Suse => upgrade_suse(ctx),
-            Distribution::SuseMicro => upgrade_suse_micro(ctx),
             Distribution::Void => upgrade_void(ctx),
             Distribution::Solus => upgrade_solus(ctx),
             Distribution::Exherbo => upgrade_exherbo(ctx),
@@ -115,7 +108,6 @@ impl Distribution {
             Distribution::KDENeon => upgrade_neon(ctx),
             Distribution::Bedrock => update_bedrock(ctx),
             Distribution::OpenMandriva => upgrade_openmandriva(ctx),
-            Distribution::PCLinuxOS => upgrade_pclinuxos(ctx),
         }
     }
 
@@ -135,10 +127,11 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
 
     ctx.run_type().execute(sudo).args(["brl", "update"]);
 
-    let output = Command::new("brl").arg("list").output_checked_utf8()?;
+    let output = Command::new("brl").arg("list").output()?;
     debug!("brl list: {:?} {:?}", output.stdout, output.stderr);
 
-    for distribution in output.stdout.trim().lines() {
+    let parsed_output = String::from_utf8(output.stdout).unwrap();
+    for distribution in parsed_output.trim().split('\n') {
         debug!("Bedrock distribution {}", distribution);
         match distribution {
             "arch" => archlinux::upgrade_arch_linux(ctx)?,
@@ -155,7 +148,7 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn is_wsl() -> Result<bool> {
-    let output = Command::new("uname").arg("-r").output_checked_utf8()?.stdout;
+    let output = Command::new("uname").arg("-r").check_output()?;
     debug!("Uname output: {}", output);
     Ok(output.contains("microsoft"))
 }
@@ -164,8 +157,8 @@ fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> {
     let apk = require("apk")?;
     let sudo = ctx.sudo().as_ref().unwrap();
 
-    ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
+    ctx.run_type().execute(sudo).arg(&apk).arg("update").check_run()?;
-    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
+    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").check_run()
 }
 
 fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
@@ -173,7 +166,7 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().rpm_ostree() {
             let mut command = ctx.run_type().execute(ostree);
             command.arg("upgrade");
-            return command.status_checked();
+            return command.check_run();
         }
     };
 
@@ -195,16 +188,17 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
             command.arg("-y");
         }
 
-        command.status_checked()?;
+        command.check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
+
     Ok(())
 }
 
 fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
+        ctx.run_type().execute(sudo).args(["brl", "update"]).check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -214,27 +208,12 @@ fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
+        ctx.run_type().execute(sudo).args(["zypper", "refresh"]).check_run()?;
-            .execute(sudo)
-            .args(["zypper", "refresh"])
-            .status_checked()?;
 
         ctx.run_type()
             .execute(sudo)
             .args(["zypper", "dist-upgrade"])
-            .status_checked()?;
+            .check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
-
-    Ok(())
-}
-fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["transactional-update", "dup"])
-            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -256,34 +235,7 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
             command.arg("-y");
         }
 
-        command.status_checked()?;
+        command.check_run()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
-
-    Ok(())
-}
-fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
-        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()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -298,14 +250,14 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().yes(Step::System) {
             command.arg("-y");
         }
-        command.status_checked()?;
+        command.check_run()?;
 
         let mut command = ctx.run_type().execute(sudo);
         command.args(["xbps-install", "-u"]);
         if ctx.config().yes(Step::System) {
             command.arg("-y");
         }
-        command.status_checked()?;
+        command.check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -318,11 +270,7 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
 
     if let Some(sudo) = &ctx.sudo() {
         if let Some(layman) = which("layman") {
-            run_type
+            run_type.execute(sudo).arg(layman).args(["-s", "ALL"]).check_run()?;
-                .execute(sudo)
-                .arg(layman)
-                .args(["-s", "ALL"])
-                .status_checked()?;
         }
 
         println!("Syncing portage");
@@ -335,10 +283,10 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
                     .map(|s| s.split_whitespace().collect())
                     .unwrap_or_else(|| vec!["-q"]),
             )
-            .status_checked()?;
+            .check_run()?;
 
         if let Some(eix_update) = which("eix-update") {
-            run_type.execute(sudo).arg(eix_update).status_checked()?;
+            run_type.execute(sudo).arg(eix_update).check_run()?;
         }
 
         run_type
@@ -350,7 +298,7 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
                     .map(|s| s.split_whitespace().collect())
                     .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
             )
-            .status_checked()?;
+            .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -361,18 +309,12 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
 fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = &ctx.sudo() {
         let apt = which("apt-fast")
-            .or_else(|| {
+            .or_else(|| which("nala"))
-                if Path::new("/usr/bin/nala").exists() {
-                    Some(Path::new("/usr/bin/nala").to_path_buf())
-                } else {
-                    None
-                }
-            })
             .unwrap_or_else(|| PathBuf::from("apt-get"));
 
         let is_nala = apt.ends_with("nala");
         if !is_nala {
-            ctx.run_type().execute(sudo).arg(&apt).arg("update").status_checked()?;
+            ctx.run_type().execute(sudo).arg(&apt).arg("update").check_run()?;
         }
 
         let mut command = ctx.run_type().execute(sudo);
@@ -388,17 +330,17 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
         if let Some(args) = ctx.config().apt_arguments() {
             command.args(args.split_whitespace());
         }
-        command.status_checked()?;
+        command.check_run()?;
 
         if ctx.config().cleanup() {
-            ctx.run_type().execute(sudo).arg(&apt).arg("clean").status_checked()?;
+            ctx.run_type().execute(sudo).arg(&apt).arg("clean").check_run()?;
 
             let mut command = ctx.run_type().execute(sudo);
             command.arg(&apt).arg("autoremove");
             if ctx.config().yes(Step::System) {
                 command.arg("-y");
             }
-            command.status_checked()?;
+            command.check_run()?;
         }
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -412,11 +354,11 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("deb-get");
 
-    ctx.execute_elevated(&deb_get, false)?.arg("update").status_checked()?;
+    ctx.execute_elevated(&deb_get, false)?.arg("update").check_run()?;
-    ctx.execute_elevated(&deb_get, false)?.arg("upgrade").status_checked()?;
+    ctx.execute_elevated(&deb_get, false)?.arg("upgrade").check_run()?;
 
     if ctx.config().cleanup() {
-        ctx.execute_elevated(&deb_get, false)?.arg("clean").status_checked()?;
+        ctx.execute_elevated(&deb_get, false)?.arg("clean").check_run()?;
     }
 
     Ok(())
@@ -424,10 +366,7 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
+        ctx.run_type().execute(sudo).args(["eopkg", "upgrade"]).check_run()?;
-            .execute(sudo)
-            .args(["eopkg", "upgrade"])
-            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -435,25 +374,15 @@ fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
-pub fn update_am(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["am", "-u"]).status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping AM Step");
-    }
-
-    Ok(())
-}
-
 pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
     let pacdef = require("pacdef")?;
 
     print_separator("pacdef");
 
-    ctx.run_type().execute(&pacdef).arg("sync").status_checked()?;
+    ctx.run_type().execute(&pacdef).arg("sync").check_run()?;
 
     println!();
-    ctx.run_type().execute(&pacdef).arg("review").status_checked()
+    ctx.run_type().execute(&pacdef).arg("review").check_run()
 }
 
 pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
@@ -461,24 +390,13 @@ pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Pacstall");
 
-    let mut update_cmd = ctx.run_type().execute(&pacstall);
+    ctx.run_type().execute(&pacstall).arg("-U").check_run()?;
-    let mut upgrade_cmd = ctx.run_type().execute(pacstall);
+    ctx.run_type().execute(pacstall).arg("-Up").check_run()
-
-    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()
 }
 
 fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = &ctx.sudo() {
-        ctx.run_type()
+        ctx.run_type().execute(sudo).args(["swupd", "update"]).check_run()?;
-            .execute(sudo)
-            .args(["swupd", "update"])
-            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -488,29 +406,26 @@ fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
+        ctx.run_type().execute(sudo).args(["cave", "sync"]).check_run()?;
 
         ctx.run_type()
             .execute(sudo)
             .args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
-            .status_checked()?;
+            .check_run()?;
 
         if ctx.config().cleanup() {
-            ctx.run_type()
+            ctx.run_type().execute(sudo).args(["cave", "purge", "-x"]).check_run()?;
-                .execute(sudo)
-                .args(["cave", "purge", "-x"])
-                .status_checked()?;
         }
 
         ctx.run_type()
             .execute(sudo)
             .args(["cave", "fix-linkage", "-x", "--", "-Cs"])
-            .status_checked()?;
+            .check_run()?;
 
         ctx.run_type()
             .execute(sudo)
             .args(["eclectic", "config", "interactive"])
-            .status_checked()?;
+            .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -520,19 +435,16 @@ fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        let mut command = ctx.run_type().execute(sudo);
+        ctx.run_type()
-        command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]);
+            .execute(sudo)
-
+            .args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"])
-        if let Some(args) = ctx.config().nix_arguments() {
+            .check_run()?;
-            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"])
-                .status_checked()?;
+                .check_run()?;
         }
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -550,11 +462,7 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = &ctx.sudo() {
         let pkcon = which("pkcon").unwrap();
         // pkcon ignores update with update and refresh provided together
-        ctx.run_type()
+        ctx.run_type().execute(sudo).arg(&pkcon).arg("refresh").check_run()?;
-            .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) {
@@ -564,13 +472,13 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
             cmd.arg("--autoremove");
         }
         // from pkcon man, exit code 5 is 'Nothing useful was done.'
-        cmd.status_checked_with_codes(&[5])?;
+        cmd.check_run_with_codes(&[5])?;
     }
 
     Ok(())
 }
 
-pub fn run_needrestart(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
+pub fn run_needrestart(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     let sudo = require_option(sudo, String::from("sudo is not installed"))?;
     let needrestart = require("needrestart")?;
     let distribution = Distribution::detect()?;
@@ -581,7 +489,7 @@ pub fn run_needrestart(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
 
     print_separator("Check for needed restarts");
 
-    run_type.execute(sudo).arg(needrestart).status_checked()?;
+    run_type.execute(sudo).arg(needrestart).check_run()?;
 
     Ok(())
 }
@@ -598,7 +506,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(&fwupdmgr)
         .arg("refresh")
-        .status_checked_with_codes(&[2])?;
+        .check_run_with_codes(&[2])?;
 
     let mut updmgr = ctx.run_type().execute(&fwupdmgr);
 
@@ -610,7 +518,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     } else {
         updmgr.arg("get-updates");
     }
-    updmgr.status_checked_with_codes(&[2])
+    updmgr.check_run_with_codes(&[2])
 }
 
 pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
@@ -625,14 +533,14 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
     if yes {
         update_args.push("-y");
     }
-    run_type.execute(&flatpak).args(&update_args).status_checked()?;
+    run_type.execute(&flatpak).args(&update_args).check_run()?;
 
     if cleanup {
         let mut cleanup_args = vec!["uninstall", "--user", "--unused"];
         if yes {
             cleanup_args.push("-y");
         }
-        run_type.execute(&flatpak).args(&cleanup_args).status_checked()?;
+        run_type.execute(&flatpak).args(&cleanup_args).check_run()?;
     }
 
     print_separator("Flatpak System Packages");
@@ -641,41 +549,33 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
         if yes {
             update_args.push("-y");
         }
-        run_type
+        run_type.execute(sudo).arg(&flatpak).args(&update_args).check_run()?;
-            .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
+            run_type.execute(sudo).arg(flatpak).args(&cleanup_args).check_run()?;
-                .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).status_checked()?;
+        run_type.execute(&flatpak).args(&update_args).check_run()?;
         if cleanup {
             let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
             if yes {
                 cleanup_args.push("-y");
             }
-            run_type.execute(flatpak).args(&cleanup_args).status_checked()?;
+            run_type.execute(flatpak).args(&cleanup_args).check_run()?;
         }
     }
 
     Ok(())
 }
 
-pub fn run_snap(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
+pub fn run_snap(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     let sudo = require_option(sudo, String::from("sudo is not installed"))?;
     let snap = require("snap")?;
 
@@ -684,17 +584,17 @@ pub fn run_snap(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
     }
     print_separator("snap");
 
-    run_type.execute(sudo).arg(snap).arg("refresh").status_checked()
+    run_type.execute(sudo).arg(snap).arg("refresh").check_run()
 }
 
-pub fn run_pihole_update(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
+pub fn run_pihole_update(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     let sudo = require_option(sudo, String::from("sudo is not installed"))?;
     let pihole = require("pihole")?;
     Path::new("/opt/pihole/update.sh").require()?;
 
     print_separator("pihole");
 
-    run_type.execute(sudo).arg(pihole).arg("-up").status_checked()
+    run_type.execute(sudo).arg(pihole).arg("-up").check_run()
 }
 
 pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
@@ -702,17 +602,15 @@ pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("protonup");
 
-    ctx.run_type().execute(protonup).status_checked()?;
+    ctx.run_type().execute(protonup).check_run()?;
     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)) => {
@@ -728,30 +626,7 @@ pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
         (r, true) => r.arg("--root"),
         (r, false) => r,
     }
-    .status_checked()
+    .check_run()
-}
-
-pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
-    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<()> {
@@ -762,14 +637,14 @@ pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
 
     if let Ok(etc_update) = require("etc-update") {
         print_separator("Configuration update");
-        ctx.run_type().execute(sudo).arg(etc_update).status_checked()?;
+        ctx.run_type().execute(sudo).arg(etc_update).check_run()?;
     } 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)?.status_checked()?;
+        ctx.execute_elevated(&pacdiff, false)?.check_run()?;
     }
 
     Ok(())

src/steps/os/macos.rs

@@ -1,30 +1,26 @@
-use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
+use crate::executor::{CommandExt, RunType};
 use crate::terminal::{print_separator, prompt_yesno};
-use crate::{utils::require, Step};
+use crate::{error::TopgradeError, utils::require, Step};
-use color_eyre::eyre::Result;
+use anyhow::Result;
+use log::debug;
 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();
     print_separator("MacPorts");
+    ctx.run_type().execute(sudo).args(&["port", "selfupdate"]).check_run()?;
     ctx.run_type()
         .execute(sudo)
-        .args(["port", "selfupdate"])
+        .args(&["port", "-u", "upgrade", "outdated"])
-        .status_checked()?;
+        .check_run()?;
-    ctx.run_type()
-        .execute(sudo)
-        .args(["port", "-u", "upgrade", "outdated"])
-        .status_checked()?;
     if ctx.config().cleanup() {
         ctx.run_type()
             .execute(sudo)
-            .args(["port", "-N", "reclaim"])
+            .args(&["port", "-N", "reclaim"])
-            .status_checked()?;
+            .check_run()?;
     }
 
     Ok(())
@@ -34,7 +30,7 @@ pub fn run_mas(run_type: RunType) -> Result<()> {
     let mas = require("mas")?;
     print_separator("macOS App Store");
 
-    run_type.execute(mas).arg("upgrade").status_checked()
+    run_type.execute(mas).arg("upgrade").check_run()
 }
 
 pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
@@ -56,21 +52,26 @@ pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
     }
 
     let mut command = ctx.run_type().execute("softwareupdate");
-    command.args(["--install", "--all"]);
+    command.args(&["--install", "--all"]);
 
     if should_ask {
         command.arg("--no-scan");
     }
 
-    command.status_checked()
+    command.check_run()
 }
 
 fn system_update_available() -> Result<bool> {
-    let output = Command::new("softwareupdate").arg("--list").output_checked_utf8()?;
+    let output = Command::new("softwareupdate").arg("--list").output()?;
-
     debug!("{:?}", output);
 
-    Ok(!output.stderr.contains("No new software available"))
+    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"))
 }
 
 pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
@@ -80,14 +81,14 @@ pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
 
     for application in (fs::read_dir("/Applications")?).flatten() {
         let probe = Command::new(&sparkle)
-            .args(["--probe", "--application"])
+            .args(&["--probe", "--application"])
             .arg(application.path())
-            .output_checked_utf8();
+            .check_output();
         if probe.is_ok() {
             let mut command = ctx.run_type().execute(&sparkle);
-            command.args(["bundle", "--check-immediately", "--application"]);
+            command.args(&["bundle", "--check-immediately", "--application"]);
             command.arg(application.path());
-            command.status_checked()?;
+            command.spawn()?.wait()?;
         }
     }
     Ok(())

src/steps/os/openbsd.rs

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

src/steps/os/os_release/debian

@@ -1,9 +1,8 @@
-PRETTY_NAME="Debian GNU/Linux 11 (bullseye)"
+PRETTY_NAME="Debian GNU/Linux 8 (jessie)"
 NAME="Debian GNU/Linux"
-VERSION_ID="11"
+VERSION_ID="8"
-VERSION="11 (bullseye)"
+VERSION="8 (jessie)"
-VERSION_CODENAME=bullseye
 ID=debian
-HOME_URL="https://www.debian.org/"
+HOME_URL="http://www.debian.org/"
-SUPPORT_URL="https://www.debian.org/support"
+SUPPORT_URL="http://www.debian.org/support"
 BUG_REPORT_URL="https://bugs.debian.org/"

src/steps/os/os_release/pclinuxos

@@ -1,9 +0,0 @@
-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/unix.rs

@@ -1,43 +1,33 @@
+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 crate::command::CommandExt;
-use crate::Step;
-use color_eyre::eyre::Result;
-use directories::BaseDirs;
-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;
-use crate::executor::RunType;
-use crate::terminal::print_separator;
-#[cfg(not(any(target_os = "android", target_os = "macos")))]
-use crate::utils::require_option;
-use crate::utils::{require, PathExt};
-
-#[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 {
@@ -87,42 +77,30 @@ impl BrewVariant {
     }
 }
 
-pub fn run_fisher(run_type: RunType) -> Result<()> {
+pub fn run_fisher(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     let fish = require("fish")?;
 
-    Command::new(&fish)
+    if env::var("fisher_path").is_err() {
-        .args(["-c", "type -t fisher"])
+        base_dirs
-        .output_checked_utf8()
+            .home_dir()
-        .map(|_| ())
+            .join(".config/fish/functions/fisher.fish")
-        .map_err(|_| SkipStep("`fisher` is not defined in `fish`".to_owned()))?;
+            .require()?;
-
+    }
-    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
         .execute(&fish)
         .args(["-c", "fisher --version"])
-        .output_checked_utf8()?
+        .check_output()?;
-        .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"]).status_checked()
+        run_type.execute(&fish).args(["-c", "fisher"]).check_run()
     } else {
         // v4
-        run_type.execute(&fish).args(["-c", "fisher update"]).status_checked()
+        run_type.execute(&fish).args(["-c", "fisher update"]).check_run()
     }
 }
 
@@ -134,7 +112,7 @@ pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute("bash")
         .args(["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
-        .status_checked()
+        .check_run()
 }
 
 pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
@@ -146,27 +124,25 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("oh-my-fish");
 
-    ctx.run_type().execute(fish).args(["-c", "omf update"]).status_checked()
+    ctx.run_type().execute(&fish).args(["-c", "omf update"]).check_run()
 }
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
     let pkgin = require("pkgin")?;
 
-    print_separator("Pkgin");
-
     let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
     command.arg(&pkgin).arg("update");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
-    command.status_checked()?;
+    command.check_run()?;
 
     let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
     command.arg(&pkgin).arg("upgrade");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
-    command.status_checked()
+    command.check_run()
 }
 
 pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
@@ -178,10 +154,7 @@ pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("fish-plug");
 
-    ctx.run_type()
+    ctx.run_type().execute(&fish).args(["-c", "plug update"]).check_run()
-        .execute(fish)
-        .args(["-c", "plug update"])
-        .status_checked()
 }
 
 /// Upgrades `fundle` and `fundle` plugins.
@@ -198,7 +171,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(fish)
         .args(["-c", "fundle self-update && fundle update"])
-        .status_checked()
+        .check_run()
 }
 
 #[cfg(not(any(target_os = "android", target_os = "macos")))]
@@ -219,10 +192,10 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
             "--method",
             "org.freedesktop.DBus.ListActivatableNames",
         ])
-        .output_checked_utf8()?;
+        .check_output()?;
 
     debug!("Checking for gnome extensions: {}", output);
-    if !output.stdout.contains("org.gnome.Shell.Extensions") {
+    if !output.contains("org.gnome.Shell.Extensions") {
         return Err(SkipStep(String::from("Gnome shell extensions are unregistered in DBus")).into());
     }
 
@@ -240,10 +213,9 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
             "--method",
             "org.gnome.Shell.Extensions.CheckForUpdates",
         ])
-        .status_checked()
+        .check_run()
 }
 
-#[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())?;
@@ -258,18 +230,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").status_checked()?;
+    variant.execute(run_type).arg("update").check_run()?;
     variant
         .execute(run_type)
         .args(["upgrade", "--ignore-pinned", "--formula"])
-        .status_checked()?;
+        .check_run()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").status_checked()?;
+        variant.execute(run_type).arg("cleanup").check_run()?;
     }
 
     if ctx.config().brew_autoremove() {
-        variant.execute(run_type).arg("autoremove").status_checked()?;
+        variant.execute(run_type).arg("autoremove").check_run()?;
     }
 
     Ok(())
@@ -286,28 +258,28 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
 
     let cask_upgrade_exists = variant
         .execute(RunType::Wet)
-        .args(["--repository", "buo/cask-upgrade"])
+        .args(&["--repository", "buo/cask-upgrade"])
-        .output_checked_utf8()
+        .check_output()
-        .map(|p| Path::new(p.stdout.trim()).exists())?;
+        .map(|p| Path::new(p.trim()).exists())?;
 
     let mut brew_args = vec![];
 
     if cask_upgrade_exists {
-        brew_args.extend(["cu", "-y"]);
+        brew_args.extend(&["cu", "-y"]);
         if ctx.config().brew_cask_greedy() {
             brew_args.push("-a");
         }
     } else {
-        brew_args.extend(["upgrade", "--cask"]);
+        brew_args.extend(&["upgrade", "--cask"]);
         if ctx.config().brew_cask_greedy() {
             brew_args.push("--greedy");
         }
     }
 
-    variant.execute(run_type).args(&brew_args).status_checked()?;
+    variant.execute(run_type).args(&brew_args).check_run()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").status_checked()?;
+        variant.execute(run_type).arg("cleanup").check_run()?;
     }
 
     Ok(())
@@ -318,7 +290,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
 
     let run_type = ctx.run_type();
 
-    let output = Command::new(&guix).arg("pull").output_checked_utf8();
+    let output = Command::new(&guix).arg("pull").check_output();
     debug!("guix pull output: {:?}", output);
     let should_upgrade = output.is_ok();
     debug!("Can Upgrade Guix: {:?}", should_upgrade);
@@ -326,7 +298,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Guix");
 
     if should_upgrade {
-        return run_type.execute(&guix).args(["package", "-u"]).status_checked();
+        return run_type.execute(&guix).args(["package", "-u"]).check_run();
     }
     Err(SkipStep(String::from("Guix Pull Failed, Skipping")).into())
 }
@@ -342,7 +314,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"]).output_checked_utf8();
+    let output = Command::new(&nix_env).args(["--query", "nix"]).check_output();
     debug!("nix-env output: {:?}", output);
     let should_self_upgrade = output.is_ok();
 
@@ -374,13 +346,13 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
 
     if should_self_upgrade {
         if multi_user {
-            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").status_checked()?;
+            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").check_run()?;
         } else {
-            run_type.execute(&nix).arg("upgrade-nix").status_checked()?;
+            run_type.execute(&nix).arg("upgrade-nix").check_run()?;
         }
     }
 
-    run_type.execute(nix_channel).arg("--update").status_checked()?;
+    run_type.execute(&nix_channel).arg("--update").check_run()?;
 
     if std::path::Path::new(&manifest_json_path).exists() {
         run_type
@@ -388,9 +360,9 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
             .arg("profile")
             .arg("upgrade")
             .arg(".*")
-            .status_checked()
+            .check_run()
     } else {
-        run_type.execute(&nix_env).arg("--upgrade").status_checked()
+        run_type.execute(&nix_env).arg("--upgrade").check_run()
     }
 }
 
@@ -399,40 +371,42 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("yadm");
 
-    ctx.run_type().execute(yadm).arg("pull").status_checked()
+    ctx.run_type().execute(&yadm).arg("pull").check_run()
 }
 
 pub fn run_asdf(run_type: RunType) -> Result<()> {
     let asdf = require("asdf")?;
 
     print_separator("asdf");
-    run_type.execute(&asdf).arg("update").status_checked_with_codes(&[42])?;
+    let exit_status = run_type.execute(&asdf).arg("update").spawn()?.wait()?;
 
-    run_type
+    if let ExecutorExitStatus::Wet(e) = exit_status {
-        .execute(&asdf)
+        if !(e.success() || e.code().map(|c| c == 42).unwrap_or(false)) {
-        .args(["plugin", "update", "--all"])
+            return Err(TopgradeError::ProcessFailed(e).into());
-        .status_checked()
+        }
+    }
+    run_type.execute(&asdf).args(["plugin", "update", "--all"]).check_run()
 }
 
 pub fn run_home_manager(run_type: RunType) -> Result<()> {
     let home_manager = require("home-manager")?;
 
     print_separator("home-manager");
-    run_type.execute(home_manager).arg("switch").status_checked()
+    run_type.execute(&home_manager).arg("switch").check_run()
 }
 
 pub fn run_tldr(run_type: RunType) -> Result<()> {
     let tldr = require("tldr")?;
 
     print_separator("TLDR");
-    run_type.execute(tldr).arg("--update").status_checked()
+    run_type.execute(&tldr).arg("--update").check_run()
 }
 
 pub fn run_pearl(run_type: RunType) -> Result<()> {
     let pearl = require("pearl")?;
     print_separator("pearl");
 
-    run_type.execute(pearl).arg("update").status_checked()
+    run_type.execute(&pearl).arg("update").check_run()
 }
 
 pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Result<()> {
@@ -466,33 +440,27 @@ pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Res
         run_type
             .execute(&bash)
             .args(["-c", cmd_selfupdate.as_str()])
-            .status_checked()?;
+            .check_run()?;
     }
 
     let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
-    run_type
+    run_type.execute(&bash).args(["-c", cmd_update.as_str()]).check_run()?;
-        .execute(&bash)
-        .args(["-c", cmd_update.as_str()])
-        .status_checked()?;
 
     let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
-    run_type
+    run_type.execute(&bash).args(["-c", cmd_upgrade.as_str()]).check_run()?;
-        .execute(&bash)
-        .args(["-c", cmd_upgrade.as_str()])
-        .status_checked()?;
 
     if cleanup {
         let cmd_flush_archives = format!("source {} && sdk flush archives", &sdkman_init_path);
         run_type
             .execute(&bash)
             .args(["-c", cmd_flush_archives.as_str()])
-            .status_checked()?;
+            .check_run()?;
 
         let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
         run_type
             .execute(&bash)
             .args(["-c", cmd_flush_temp.as_str()])
-            .status_checked()?;
+            .check_run()?;
     }
 
     Ok(())
@@ -503,7 +471,7 @@ pub fn run_bun(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Bun");
 
-    ctx.run_type().execute(bun).arg("upgrade").status_checked()
+    ctx.run_type().execute(&bun).arg("upgrade").check_run()
 }
 
 /// Update dotfiles with `rcm(7)`.
@@ -513,10 +481,10 @@ pub fn run_rcm(ctx: &ExecutionContext) -> Result<()> {
     let rcup = require("rcup")?;
 
     print_separator("rcm");
-    ctx.run_type().execute(rcup).arg("-v").status_checked()
+    ctx.run_type().execute(rcup).arg("-v").check_run()
 }
 
-pub fn reboot() -> Result<()> {
+pub fn reboot() {
     print!("Rebooting...");
-    Command::new("sudo").arg("reboot").status_checked()
+    Command::new("sudo").arg("reboot").spawn().unwrap().wait().unwrap();
 }

src/steps/os/windows.rs

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

src/steps/powershell.rs

@@ -3,10 +3,10 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 
-use color_eyre::eyre::Result;
+use anyhow::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"])
-                .output_checked_utf8()
+                .check_output()
-                .map(|output| PathBuf::from(output.stdout.trim()))
+                .map(|output| PathBuf::from(output.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)
+        Command::new(&powershell)
-            .args([
+            .args(&[
                 "-NoProfile",
                 "-Command",
-                &format!("Get-Module -ListAvailable {command}"),
+                &format!("Get-Module -ListAvailable {}", command),
             ])
-            .output_checked_utf8()
+            .check_output()
-            .map(|result| !result.stdout.is_empty())
+            .map(|result| !result.is_empty())
             .unwrap_or(false)
     }
 
@@ -79,9 +79,8 @@ impl Powershell {
         println!("Updating modules...");
         ctx.run_type()
             .execute(powershell)
-            // This probably doesn't need `shell_words::join`.
             .args(["-NoProfile", "-Command", &cmd.join(" ")])
-            .status_checked()
+            .check_run()
     }
 
     #[cfg(windows)]
@@ -100,14 +99,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 +118,6 @@ impl Powershell {
                     }
                 ),
             ])
-            .status_checked()
+            .check_run()
     }
 }

src/steps/remote/ssh.rs

@@ -1,8 +1,6 @@
-use color_eyre::eyre::Result;
+use anyhow::Result;
 
-use crate::{
+use crate::{error::SkipStep, execution_context::ExecutionContext, terminal::print_separator, utils};
-    command::CommandExt, error::SkipStep, execution_context::ExecutionContext, terminal::print_separator, utils,
-};
 
 fn prepare_async_ssh_command(args: &mut Vec<&str>) {
     args.insert(0, "ssh");
@@ -19,14 +17,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, hostname, &shell_words::join(args))?;
+            crate::tmux::run_command(ctx, &args.join(" "))?;
             Err(SkipStep(String::from("Remote Topgrade launched in Tmux")).into())
         }
 
@@ -43,12 +41,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})"));
+        print_separator(format!("Remote ({})", hostname));
-        println!("Connecting to {hostname}...");
+        println!("Connecting to {}...", hostname);
 
-        ctx.run_type().execute(ssh).args(&args).status_checked()
+        ctx.run_type().execute(&ssh).args(&args).check_run()
     }
 }

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 color_eyre::eyre::Result;
+use anyhow::Result;
+use log::{debug, error};
 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,11 +61,10 @@ impl Vagrant {
         let output = Command::new(&self.path)
             .arg("status")
             .current_dir(directory)
-            .output_checked_utf8()?;
+            .check_output()?;
         debug!("Vagrant output in {}: {}", directory, output);
 
         let boxes = output
-            .stdout
             .split('\n')
             .skip(2)
             .take_while(|line| !(line.is_empty() || line.starts_with('\r')))
@@ -116,7 +115,7 @@ impl<'a> TemporaryPowerOn<'a> {
             .execute(vagrant)
             .args([subcommand, &vagrant_box.name])
             .current_dir(vagrant_box.path.clone())
-            .status_checked()?;
+            .check_run()?;
         Ok(TemporaryPowerOn {
             vagrant,
             vagrant_box,
@@ -143,7 +142,7 @@ impl<'a> Drop for TemporaryPowerOn<'a> {
             .execute(self.vagrant)
             .args([subcommand, &self.vagrant_box.name])
             .current_dir(self.vagrant_box.path.clone())
-            .status_checked()
+            .check_run()
             .ok();
     }
 }
@@ -183,7 +182,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)?);
@@ -200,7 +199,7 @@ pub fn topgrade_vagrant_box(ctx: &ExecutionContext, vagrant_box: &VagrantBox) ->
         .execute(&vagrant.path)
         .current_dir(&vagrant_box.path)
         .args(["ssh", "-c", &command])
-        .status_checked()
+        .check_run()
 }
 
 pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
@@ -209,12 +208,12 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
 
     let outdated = Command::new(&vagrant)
         .args(["box", "outdated", "--global"])
-        .output_checked_utf8()?;
+        .check_output()?;
 
     let re = Regex::new(r"\* '(.*?)' for '(.*?)' is outdated").unwrap();
 
     let mut found = false;
-    for ele in re.captures_iter(&outdated.stdout) {
+    for ele in re.captures_iter(&outdated) {
         found = true;
         let _ = ctx
             .run_type()
@@ -223,16 +222,13 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
             .arg(ele.get(1).unwrap().as_str())
             .arg("--provider")
             .arg(ele.get(2).unwrap().as_str())
-            .status_checked();
+            .check_run();
     }
 
     if !found {
         println!("No outdated boxes")
     } else {
-        ctx.run_type()
+        ctx.run_type().execute(&vagrant).args(["box", "prune"]).check_run()?;
-            .execute(&vagrant)
-            .args(["box", "prune"])
-            .status_checked()?;
     }
 
     Ok(())

src/steps/tmux.rs

@@ -1,22 +1,16 @@
-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 directories::BaseDirs;
-
-use crate::command::CommandExt;
 use crate::executor::RunType;
 use crate::terminal::print_separator;
 use crate::{
     execution_context::ExecutionContext,
-    utils::{which, PathExt},
+    utils::{which, Check, PathExt},
 };
-
+use anyhow::Result;
-#[cfg(unix)]
+use directories::BaseDirs;
-use std::os::unix::process::CommandExt as _;
+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
@@ -26,7 +20,7 @@ pub fn run_tpm(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     print_separator("tmux plugins");
 
-    run_type.execute(tpm).arg("all").status_checked()
+    run_type.execute(&tpm).arg("all").check_run()
 }
 
 struct Tmux {
@@ -35,10 +29,12 @@ struct Tmux {
 }
 
 impl Tmux {
-    fn new(args: Vec<String>) -> Self {
+    fn new(args: &Option<String>) -> Self {
         Self {
             tmux: which("tmux").expect("Could not find tmux"),
-            args: if args.is_empty() { None } else { Some(args) },
+            args: args
+                .as_ref()
+                .map(|args| args.split_whitespace().map(String::from).collect()),
         }
     }
 
@@ -50,130 +46,73 @@ impl Tmux {
         command
     }
 
-    fn has_session(&self, session_name: &str) -> Result<bool> {
+    fn has_session(&self, session_name: &str) -> Result<bool, io::Error> {
         Ok(self
             .build()
             .args(["has-session", "-t", session_name])
-            .output_checked_with(|_| Ok(()))?
+            .output()?
             .status
             .success())
     }
 
-    /// Create a new tmux session with the given name, running the given command.
+    fn new_session(&self, session_name: &str) -> Result<bool, io::Error> {
-    /// The command is passed to `sh` (see "shell-command arguments are sh(1) commands" in the
+        Ok(self
-    /// `tmux(1)` man page).
-    fn new_session(&self, session_name: &str, window_name: &str, command: &str) -> Result<()> {
-        let _ = self
             .build()
-            // `-d`: initial size comes from the global `default-size` option (instead
+            .args(["new-session", "-d", "-s", session_name, "-n", "dummy"])
-            //       of passing `-x` and `-y` arguments.
+            .spawn()?
-            //       (What do those even do?)
+            .wait()?
-            // `-s`: session name
+            .success())
-            // `-n`: window name (always `topgrade`)
+    }
-            .args(["new-session", "-d", "-s", session_name, "-n", window_name, command])
+
-            .output_checked()?;
+    fn run_in_session(&self, command: &str) -> Result<()> {
+        self.build()
+            .args(["new-window", "-t", "topgrade", command])
+            .spawn()?
+            .wait()?
+            .check()?;
+
         Ok(())
     }
-
-    /// 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!()
-    }
-
-    /// 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>) -> Result<()> {
+pub fn run_in_tmux(args: &Option<String>) -> ! {
     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)
+        command.join(" ")
     };
 
     let tmux = Tmux::new(args);
 
-    // Find an unused session and run `topgrade` in it with the current command's arguments.
+    if !tmux.has_session("topgrade").expect("Error detecting a tmux session") {
-    let session_name = "topgrade";
+        tmux.new_session("topgrade").expect("Error creating a tmux session");
-    let window_name = "topgrade";
+    }
-    let session = tmux.new_unique_session(session_name, window_name, &command)?;
+
+    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");
 
-    // 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-session", "-t", &session]).exec();
+        let err = tmux.build().args(["attach", "-t", "topgrade"]).exec();
-        Err(eyre!("{err}")).context("Failed to `execvp(3)` tmux")
+        panic!("{:?}", err);
     } else {
         println!("Topgrade launched in a new tmux session");
-        Ok(())
+        exit(0);
     }
 }
 
-pub fn run_command(ctx: &ExecutionContext, window_name: &str, command: &str) -> Result<()> {
+pub fn run_command(ctx: &ExecutionContext, command: &str) -> Result<()> {
-    let tmux = Tmux::new(ctx.config().tmux_arguments()?);
+    Tmux::new(ctx.config().tmux_arguments())
-
+        .build()
-    match ctx.get_tmux_session() {
+        .args(["new-window", "-a", "-t", "topgrade:1", command])
-        Some(session_name) => {
+        .env_remove("TMUX")
-            let indices = tmux.window_indices(&session_name)?;
+        .spawn()?
-            let last_window = indices
+        .wait()?
-                .iter()
+        .check()
-                .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,20 +1,17 @@
-use color_eyre::eyre::Result;
+use anyhow::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)
+    let output = Command::new(toolbx).args(["list", "--containers"]).output()?;
-        .args(["list", "--containers"])
+    let output_str = String::from_utf8(output.stdout)?;
-        .output_checked_utf8()?;
 
-    let proc: Vec<String> = output
+    let proc: Vec<String> = output_str
-        .stdout
         .lines()
         // Skip the first line since that contains only status information
         .skip(1)
@@ -42,7 +39,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",
@@ -57,7 +54,7 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
             args.push("--yes");
         }
 
-        ctx.run_type().execute(&toolbx).args(&args).status_checked()?;
+        let _output = ctx.run_type().execute(&toolbx).args(&args).check_run();
     }
 
     Ok(())

src/steps/upgrade.vim

@@ -33,29 +33,15 @@ if exists(":PaqUpdate")
     PaqUpdate
 endif
 
-if exists(":Lazy")
+if exists(":CocUpdateSync")
-    echo "Lazy Update"
+    echo "CocUpdateSync"
-    +Lazy! sync
+    CocUpdateSync
 endif
 
-function! UpdateCoCAndTS()
-    if exists(":CocUpdateSync")
-        echo "CocUpdateSync"
-        CocUpdateSync
-    endif
-
-    if exists(":TSUpdateSync")
-        echo "TreeSitter Update"
-        TSUpdate
-    endif
-
-    quitall
-endfunction
-
 if exists(':PackerSync')
-    echo "Packer"
+  echo "Packer"
-    autocmd User PackerComplete * call UpdateCoCAndTS()
+  autocmd User PackerComplete quitall
-    PackerSync
+  PackerSync
 else
-    call UpdateCoCAndTS()
+  quitall
 endif

src/steps/vim.rs

@@ -1,20 +1,19 @@
-use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
-use color_eyre::eyre::Result;
+use anyhow::Result;
 
-use crate::executor::{Executor, ExecutorOutput, RunType};
+use crate::executor::{CommandExt, Executor, ExecutorOutput, RunType};
 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");
 
@@ -64,7 +63,7 @@ fn upgrade(command: &mut Executor, ctx: &ExecutionContext) -> Result<()> {
         }
 
         if !status.success() {
-            return Err(TopgradeError::ProcessFailed(command.get_program(), status).into());
+            return Err(TopgradeError::ProcessFailed(status).into());
         } else {
             println!("Plugins upgraded")
         }
@@ -85,22 +84,22 @@ pub fn upgrade_ultimate_vimrc(ctx: &ExecutionContext) -> Result<()> {
         .execute(&git)
         .current_dir(&config_dir)
         .args(["reset", "--hard"])
-        .status_checked()?;
+        .check_run()?;
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
         .args(["clean", "-d", "--force"])
-        .status_checked()?;
+        .check_run()?;
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
         .args(["pull", "--rebase"])
-        .status_checked()?;
+        .check_run()?;
     ctx.run_type()
         .execute(python)
         .current_dir(config_dir)
         .arg(update_plugins)
-        .status_checked()?;
+        .check_run()?;
 
     Ok(())
 }
@@ -108,8 +107,8 @@ pub fn upgrade_ultimate_vimrc(ctx: &ExecutionContext) -> Result<()> {
 pub fn upgrade_vim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()> {
     let vim = require("vim")?;
 
-    let output = Command::new(&vim).arg("--version").output_checked_utf8()?;
+    let output = Command::new(&vim).arg("--version").check_output()?;
-    if !output.stdout.starts_with("VIM") {
+    if !output.starts_with("VIM") {
         return Err(SkipStep(String::from("vim binary might be actually nvim")).into());
     }
 
@@ -119,9 +118,9 @@ pub fn upgrade_vim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()> {
     upgrade(
         ctx.run_type()
             .execute(&vim)
-            .args(["-u"])
+            .args(&["-u"])
             .arg(vimrc)
-            .args(["-U", "NONE", "-V1", "-nNesS"])
+            .args(&["-U", "NONE", "-V1", "-nNesS"])
             .arg(upgrade_script()?.path()),
         ctx,
     )
@@ -134,10 +133,10 @@ pub fn upgrade_neovim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()
     print_separator("Neovim");
     upgrade(
         ctx.run_type()
-            .execute(nvim)
+            .execute(&nvim)
-            .args(["-u"])
+            .args(&["-u"])
             .arg(nvimrc)
-            .args(["--headless", "-V1", "-nS"])
+            .args(&["--headless", "-V1", "-nS"])
             .arg(upgrade_script()?.path()),
         ctx,
     )
@@ -148,5 +147,5 @@ pub fn run_voom(_base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     print_separator("voom");
 
-    run_type.execute(voom).arg("update").status_checked()
+    run_type.execute(voom).arg("update").check_run()
 }

src/steps/zsh.rs

@@ -1,18 +1,15 @@
-use std::env;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-
-use color_eyre::eyre::Result;
-use directories::BaseDirs;
-use tracing::debug;
-use walkdir::WalkDir;
-
-use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::RunType;
+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;
 
 pub fn run_zr(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     let zsh = require("zsh")?;
@@ -22,7 +19,7 @@ pub fn run_zr(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     print_separator("zr");
 
     let cmd = format!("source {} && zr --update", zshrc(base_dirs).display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
+    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).check_run()
 }
 
 pub fn zshrc(base_dirs: &BaseDirs) -> PathBuf {
@@ -37,7 +34,7 @@ pub fn run_antibody(run_type: RunType) -> Result<()> {
 
     print_separator("antibody");
 
-    run_type.execute(antibody).arg("update").status_checked()
+    run_type.execute(antibody).arg("update").check_run()
 }
 
 pub fn run_antigen(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -51,7 +48,7 @@ pub fn run_antigen(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     print_separator("antigen");
 
     let cmd = format!("source {} && (antigen selfupdate ; antigen update)", zshrc.display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
+    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).check_run()
 }
 
 pub fn run_zgenom(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -65,7 +62,7 @@ pub fn run_zgenom(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     print_separator("zgenom");
 
     let cmd = format!("source {} && zgenom selfupdate && zgenom update", zshrc.display());
-    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
+    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).check_run()
 }
 
 pub fn run_zplug(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -79,10 +76,7 @@ pub fn run_zplug(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     print_separator("zplug");
 
-    run_type
+    run_type.execute(zsh).args(["-i", "-c", "zplug update"]).check_run()
-        .execute(zsh)
-        .args(["-i", "-c", "zplug update"])
-        .status_checked()
 }
 
 pub fn run_zinit(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -97,7 +91,7 @@ pub fn run_zinit(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     print_separator("zinit");
 
     let cmd = format!("source {} && zinit self-update && zinit update --all", zshrc.display(),);
-    run_type.execute(zsh).args(["-i", "-c", cmd.as_str()]).status_checked()
+    run_type.execute(zsh).args(["-i", "-c", cmd.as_str()]).check_run()
 }
 
 pub fn run_zi(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -109,7 +103,7 @@ pub fn run_zi(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     print_separator("zi");
 
     let cmd = format!("source {} && zi self-update && zi update --all", zshrc.display(),);
-    run_type.execute(zsh).args(["-i", "-c", &cmd]).status_checked()
+    run_type.execute(zsh).args(["-i", "-c", &cmd]).check_run()
 }
 
 pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -117,10 +111,8 @@ pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     env::var("ZIM_HOME")
         .or_else(|_| {
             Command::new("zsh")
-                // TODO: Should these be quoted?
                 .args(["-c", "[[ -n ${ZIM_HOME} ]] && print -n ${ZIM_HOME}"])
-                .output_checked_utf8()
+                .check_output()
-                .map(|o| o.stdout)
         })
         .map(PathBuf::from)
         .unwrap_or_else(|_| base_dirs.home_dir().join(".zim"))
@@ -131,7 +123,7 @@ pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     run_type
         .execute(zsh)
         .args(["-i", "-c", "zimfw upgrade && zimfw update"])
-        .status_checked()
+        .check_run()
 }
 
 pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
@@ -143,10 +135,8 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
     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"])
-                .output_checked_utf8()
+                .check_output()
-                .map(|o| o.stdout)
         })
         .map(PathBuf::from)
         .unwrap_or_else(|e| {
@@ -178,5 +168,5 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
         .execute("zsh")
         .env("ZSH", &oh_my_zsh)
         .arg(&oh_my_zsh.join("tools/upgrade.sh"))
-        .status_checked_with_codes(&[80])
+        .check_run_with_codes(&[80])
 }

src/sudo.rs

@@ -1,108 +0,0 @@
-use std::ffi::OsStr;
-use std::path::Path;
-use std::path::PathBuf;
-
-use color_eyre::eyre::Context;
-use color_eyre::eyre::Result;
-
-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("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 })
-    }
-
-    /// 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::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)]
-enum SudoKind {
-    Doas,
-    Sudo,
-    Gsudo,
-    Pkexec,
-}
-
-impl AsRef<OsStr> for Sudo {
-    fn as_ref(&self) -> &OsStr {
-        self.path.as_ref()
-    }
-}

src/terminal.rs

@@ -8,22 +8,18 @@ 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::terminal;
-#[cfg(target_os = "linux")]
 use crate::utils::which;
+
 lazy_static! {
     static ref TERMINAL: Mutex<Terminal> = Mutex::new(Terminal::new());
 }
@@ -38,8 +34,13 @@ pub fn shell() -> &'static str {
     which("pwsh").map(|_| "pwsh").unwrap_or("powershell")
 }
 
-pub fn run_shell() -> eyre::Result<()> {
+pub fn run_shell() {
-    Command::new(shell()).env("IN_TOPGRADE", "1").status_checked()
+    Command::new(shell())
+        .env("IN_TOPGRADE", "1")
+        .spawn()
+        .unwrap()
+        .wait()
+        .unwrap();
 }
 
 struct Terminal {
@@ -60,7 +61,7 @@ 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,
@@ -105,9 +106,7 @@ impl Terminal {
                     }
                     command.args(["-a", "Topgrade", "Topgrade"]);
                     command.arg(message.as_ref());
-                    if let Err(err) = command.output_checked() {
+                    command.output().ok();
-                        terminal::print_warning("Sending notification failed with {err:?}");
-                    }
                 }
             }
         }
@@ -143,7 +142,7 @@ impl Terminal {
                     .write_fmt(format_args!(
                         "{}\n",
                         style(format_args!(
-                            "\n── {} {:─^border$}",
+                            "\n―― {} {:―^border$}",
                             message,
                             "",
                             border = max(
@@ -159,24 +158,11 @@ impl Terminal {
                     .ok();
             }
             None => {
-                self.term.write_fmt(format_args!("―― {message} ――\n")).ok();
+                self.term.write_fmt(format_args!("―― {} ――\n", message)).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();
@@ -215,7 +201,7 @@ impl Terminal {
         self.term
             .write_fmt(format_args!(
                 "{}",
-                style(format!("{question} (y)es/(N)o",)).yellow().bold()
+                style(format!("{} (y)es/(N)o", question,)).yellow().bold()
             ))
             .ok();
 
@@ -228,7 +214,7 @@ impl Terminal {
         }
     }
     #[allow(unused_variables)]
-    fn should_retry(&mut self, interrupted: bool, step_name: &str) -> eyre::Result<bool> {
+    fn should_retry(&mut self, interrupted: bool, step_name: &str) -> Result<bool, io::Error> {
         if self.width.is_none() {
             return Ok(false);
         }
@@ -237,35 +223,31 @@ impl Terminal {
             self.term.set_title("Topgrade - Awaiting user");
         }
 
-        if self.desktop_notification {
+        self.notify_desktop(&format!("{} failed", step_name), None);
-            self.notify_desktop(format!("{step_name} failed"), None);
-        }
 
-        let prompt_inner = style(format!("{}Retry? (y)es/(N)o/(s)hell/(q)uit", self.prefix))
+        self.term
-            .yellow()
+            .write_fmt(format_args!(
-            .bold();
+                "\n{}",
-
+                style(format!("{}Retry? (y)es/(N)o/(s)hell/(q)uit", self.prefix))
-        self.term.write_fmt(format_args!("\n{prompt_inner}")).ok();
+                    .yellow()
+                    .bold()
+            ))
+            .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");
-                    if let Err(err) = run_shell().context("Failed to run shell") {
+                    run_shell();
-                        self.term.write_fmt(format_args!("{err:?}\n{prompt_inner}")).ok();
+                    break Ok(true);
-                    } 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')) => {
+                Ok(Key::Char('q')) | Ok(Key::Char('Q')) => return Err(io::Error::from(io::ErrorKind::Interrupted)),
-                    return Err(io::Error::from(io::ErrorKind::Interrupted)).context("Quit from user input")
-                }
                 _ => (),
             }
         };
@@ -286,7 +268,7 @@ impl Default for Terminal {
     }
 }
 
-pub fn should_retry(interrupted: bool, step_name: &str) -> eyre::Result<bool> {
+pub fn should_retry(interrupted: bool, step_name: &str) -> Result<bool, io::Error> {
     TERMINAL.lock().unwrap().should_retry(interrupted, step_name)
 }
 
@@ -294,11 +276,6 @@ 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,11 +1,46 @@
-use crate::error::SkipStep;
+use crate::error::{SkipStep, TopgradeError};
-use color_eyre::eyre::Result;
+use anyhow::Result;
 
+use log::{debug, error};
 use std::env;
 use std::ffi::OsStr;
 use std::fmt::Debug;
 use std::path::{Path, PathBuf};
-use tracing::{debug, error};
+use std::process::{ExitStatus, Output};
+
+pub trait Check {
+    fn check(self) -> Result<()>;
+}
+
+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())
+        }
+    }
+}
 
 pub trait PathExt
 where
@@ -67,6 +102,13 @@ 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" }))
@@ -100,55 +142,3 @@ pub fn require_option<T>(option: Option<T>, cause: String) -> Result<T> {
         Err(SkipStep(cause).into())
     }
 }
-
-/* 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> {
-    use crate::command::CommandExt;
-    use std::process::Command;
-
-    Command::new("hostname")
-        .output_checked_utf8()
-        .map_err(|err| SkipStep(format!("Failed to get hostname: {err}")).into())
-        .map(|output| output.stdout.trim().to_owned())
-}

topgrade.8

@@ -0,0 +1,80 @@
+.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>