Fix compilation on DragonFly BSD (#210)

* Adds freebsd yes flag support

* Fixes freebsd update functions

* Missing semicolon

* Adds Step dependency to freebsd.rs

* Change freebsd to status_checked

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+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/build-and-test.yml

@@ -1,24 +0,0 @@
-name: Cargo Build & Test
-
-on:
-  push:
-  pull_request:
-
-env: 
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build_and_test:
-    name: Rust project - latest
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        toolchain:
-          - stable
-          - beta
-          - nightly
-    steps:
-      - uses: actions/checkout@v3
-      - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }}
-      - run: cargo build --verbose
-      - run: cargo test --verbose

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

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

.github/workflows/check-semver.yml

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

.github/workflows/crates-publish.yml

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

.github/workflows/release-cross.yml

@@ -0,0 +1,70 @@
+name: Publish release files for non-cd-native environments
+
+on:
+  # workflow_run:
+  #   workflows: ["Check SemVer compliance"]
+  #   types:
+  #     - completed
+  release:
+    types: [ created ]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [ "aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "x86_64-unknown-linux-musl", "aarch64-unknown-linux-musl", "x86_64-unknown-freebsd",  ]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+          override: true
+          target: ${{ matrix.target }}
+          components: rustfmt, clippy
+      - uses: actions-rs/cargo@v1.0.1
+        name: Check format
+        with:
+          use-cross: true
+          command: fmt
+          args: --all -- --check
+      - uses: actions-rs/cargo@v1.0.1
+        name: Run clippy
+        with:
+          command: clippy
+          use-cross: true
+          args: --all-targets --locked --target ${{matrix.target}} -- -D warnings
+      - uses: actions-rs/cargo@v1.0.1
+        name: Run clippy (All features)
+        with:
+          command: clippy
+          use-cross: true
+          args:  --locked --all-features --target ${{matrix.target}} -- -D warnings
+      - uses: actions-rs/cargo@v1.0.1
+        name: Run tests
+        with:
+          command: test
+          use-cross: true
+          args: --target ${{matrix.target}}
+      - uses: actions-rs/cargo@v1.0.1
+        name: Build
+        with:
+          command: build
+          use-cross: true
+          args: --release --all-features --target ${{matrix.target}}
+      - name: Rename Release
+        run: |
+          mkdir assets
+          FILENAME=topgrade-${{github.event.release.tag_name}}-${{matrix.target}}
+          mv target/${{matrix.target}}/release/topgrade assets
+          cd assets
+          tar --format=ustar -czf $FILENAME.tar.gz topgrade
+          rm topgrade
+          ls .
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: assets/*

.github/workflows/release-packaging.yaml

@@ -1,28 +0,0 @@
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-
-name: Release Packaging
-
-jobs:
-  release:
-    name: Release Packaging
-    env:
-      PROJECT_NAME_UNDERSCORE: topgrade-rs
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Release Build
-        run: cargo build --release
-      - name: 'Upload Artifact'
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ env.PROJECT_NAME_UNDERSCORE }}
-          path: target/release/${{ env.PROJECT_NAME_UNDERSCORE }}

.github/workflows/release.yml

@@ -0,0 +1,77 @@
+name: Publish release files for CD native environments
+
+on:
+  # workflow_run:
+  #   workflows: ["Check SemVer compliance"]
+  #   types:
+  #     - completed
+  release:
+    types: [ created ]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ ubuntu-latest, macos-latest, windows-latest ]
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+          components: rustfmt, clippy
+      - uses: actions-rs/cargo@v1.0.1
+        name: Check format
+        with:
+          command: fmt
+          args: --all -- --check
+      - uses: actions-rs/cargo@v1.0.1
+        name: Run clippy
+        with:
+          command: clippy
+          args: --all-targets --locked -- -D warnings
+      - uses: actions-rs/cargo@v1.0.1
+        name: Run clippy (All features)
+        with:
+          command: clippy
+          args: --all-targets --locked --all-features -- -D warnings
+      - uses: actions-rs/cargo@v1.0.1
+        name: Run tests
+        with:
+          command: test
+      - uses: actions-rs/cargo@v1.0.1
+        name: Build
+        with:
+          command: build
+          args: --release --all-features
+      - name: Rename Release (Unix)
+        run: |
+          cargo install default-target
+          mkdir assets
+          FILENAME=topgrade-${{github.event.release.tag_name}}-$(default-target)
+          mv target/release/topgrade assets
+          cd assets
+          tar --format=ustar -czf $FILENAME.tar.gz topgrade
+          rm topgrade
+          ls .
+        if: ${{ matrix.platform != 'windows-latest' }}
+        shell: bash
+      - name: Rename Release (Windows)
+        run: |
+          cargo install default-target
+          mkdir assets
+          FILENAME=topgrade-${{github.event.release.tag_name}}-$(default-target)
+          mv target/release/topgrade.exe assets/topgrade.exe
+          cd assets
+          powershell Compress-Archive -Path * -Destination ${FILENAME}.zip
+          rm topgrade.exe
+          ls .
+        if: ${{ matrix.platform == 'windows-latest' }}
+        shell: bash
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: assets/*

.github/workflows/rust-ubuntu.yml

@@ -1,24 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "master", "dev" ]
-  pull_request:
-    branches: [ "master", "dev" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Build
-      run: cargo build --verbose
-    - name: Fmt
-      run: cargo fmt --check --all
-    - name: Run tests
-      run: cargo test --verbose

.github/workflows/test.yaml

@@ -1,10 +1,12 @@
-
 on:
   pull_request:
   push:
     branches:
       - main
 
+env:
+  CARGO_TERM_COLOR: always
+
 name: Test with Code Coverage
 
 jobs:

.github/workflows/update_aur.yml

@@ -0,0 +1,22 @@
+name: Publish to AUR
+
+on:
+  # workflow_run:
+  #   workflows: ["Check SemVer compliance"]
+  #   types:
+  #     - completed
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  aur-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Publish AUR package
+        uses: ATiltedTree/create-aur-release@v1
+        with:
+          package_name: topgrade
+          commit_username: "Thomas Schönauer"
+          commit_email: t.schoenauer@hgs-wt.at
+          ssh_private_key: ${{ secrets.AUR_SSH_PRIVATE_KEY }}

.github/workflows/update_homebrew.yml

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

.gitignore

@@ -1,3 +1,4 @@
 
 /target
+/build
 **/*.rs.bk

.vscode/launch.json

@@ -12,11 +12,11 @@
             "cargo": {
                 "args": [
                     "build",
-                    "--bin=topgrade",
-                    "--package=topgrade"
+                    "--bin=topgrade-rs",
+                    "--package=topgrade-rs"
                 ],
                 "filter": {
-                    "name": "topgrade",
+                    "name": "topgrade-rs",
                     "kind": "bin"
                 }
             },

CODE_OF_CONDUCT.md

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

Cargo.toml

@@ -1,54 +1,73 @@
 [package]
-name = "topgrade-rs"
-description = "Upgrade all the things, successor of topgrade"
+name = "topgrade"
+description = "Upgrade all the things"
 categories = ["os"]
 keywords = ["upgrade", "update"]
-license-file = "LICENSE"
+license = "GPL-3.0"
+# license-file = "LICENSE"
 repository = "https://github.com/topgrade-rs/topgrade"
-version = "9.1.0"
+version = "10.2.0"
 authors = ["Roey Darwish Dror <roey.ghost@gmail.com>", "Thomas Schönauer <t.schoenauer@hgs-wt.at>"]
 exclude = ["doc/screenshot.gif"]
-edition = "2018"
+edition = "2021"
 
 readme = "README.md"
 
+[[bin]]
+name = "topgrade"
+path = "src/main.rs"
+
+##[lib]
+##name = "topgrade_lib"
+
 [dependencies]
-directories = "4.0"
-serde = { version = "1.0", features = ["derive"] }
+home = "~0.5"
+directories = "~4.0"
+serde = { version = "~1.0", features = ["derive"] }
 toml = "0.5"
-which_crate = { version = "4.1", package = "which" }
-shellexpand = "2.1"
-clap = { version = "3.1", features = ["cargo", "derive"] }
-log = "0.4"
-walkdir = "2.3"
-console = "0.15"
-lazy_static = "1.4"
-chrono = "0.4"
-pretty_env_logger = "0.4"
-glob = "0.3"
-strum = { version = "0.24", features = ["derive"] }
-thiserror = "1.0"
-anyhow = "1.0"
-tempfile = "3.2"
-cfg-if = "1.0"
-tokio = { version = "1.5", features = ["process", "rt-multi-thread"] }
-futures = "0.3"
-regex = "1.5"
-sys-info = "0.9"
-semver = "1.0"
+which_crate = { version = "~4.1", package = "which" }
+shellexpand = "~2.1"
+clap = { version = "~3.1", features = ["cargo", "derive"] }
+walkdir = "~2.3"
+console = "~0.15"
+lazy_static = "~1.4"
+chrono = "~0.4"
+glob = "~0.3"
+strum = { version = "~0.24", features = ["derive"] }
+thiserror = "~1.0"
+tempfile = "~3.2"
+cfg-if = "~1.0"
+tokio = { version = "~1.5", features = ["process", "rt-multi-thread"] }
+futures = "~0.3"
+regex = "~1.5"
+semver = "~1.0"
+shell-words = "~1.1"
+color-eyre = "0.6.2"
+tracing = { version = "0.1.37", features = ["attributes", "log"] }
+tracing-subscriber = { version = "0.3.16", 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]
-nix = "0.24"
-rust-ini = "0.18"
-self_update_crate = { version = "0.30", default-features = false, optional = true, package = "self_update", features = ["archive-tar", "compression-flate2", "rustls"] }
+libc = "~0.2"
+nix = "~0.24"
+rust-ini = "~0.18"
+self_update_crate = { version = "~0.30", default-features = false, optional = true, package = "self_update", features = ["archive-tar", "compression-flate2", "rustls"] }
 
 [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"] }
-winapi = "0.3"
-parselnk = "0.1"
+self_update_crate = { version = "~0.30", default-features = false, optional = true, package = "self_update", features = ["archive-zip", "compression-zip-deflate", "rustls"] }
+winapi = "~0.3"
+parselnk = "~0.1"
 
 [profile.release]
 lto = true

Cross.toml

@@ -0,0 +1,4 @@
+# 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,50 +1,89 @@
-![Topgrade](doc/topgrade.png)
-<!---
-![GitHub release](https://img.shields.io/github/release/r-darwish/topgrade.svg)
-[![Crates.io](https://img.shields.io/crates/v/topgrade.svg)](https://crates.io/crates/topgrade)
-[![AUR](https://img.shields.io/aur/version/topgrade.svg)](https://aur.archlinux.org/packages/topgrade/)
-![homebrew](https://img.shields.io/homebrew/v/topgrade.svg) -->
---->
+<div align="center">
+  <h1>
+    <img alt="Topgrade" src="doc/topgrade_transparent.png" width="850px">
+  </h1>
   
-![Demo](doc/screenshot.gif)
+  <a href="https://github.com/topgrade-rs/topgrade/releases"><img alt="GitHub Release" src="https://img.shields.io/github/release/topgrade-rs/topgrade.svg"></a>
+  <a href="https://crates.io/crates/topgrade"><img alt="crates.io" src="https://img.shields.io/crates/v/topgrade.svg"></a>
+  <a href="https://aur.archlinux.org/packages/topgrade"><img alt="AUR" src="https://img.shields.io/aur/version/topgrade.svg"></a>
+  <a href="https://formulae.brew.sh/formula/topgrade"><img alt="Homebrew" src="https://img.shields.io/homebrew/v/topgrade.svg"></a>
 
-## Fork
-This is a fork of [topgrade by r-darwish](https://github.com/r-darwish/topgrade) to keep it maintained.
+  <img alt="Demo" src="doc/screenshot.gif" width="550px">
+</div>
   
+## Introduction
+
+> **Note**
+> This is a fork of [topgrade by r-darwish](https://github.com/r-darwish/topgrade) to keep it maintained.
 
 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, _topgrade_ detects which tools you use and runs the appropriate commands to update them.
+To remedy this, **Topgrade** detects which tools you use and runs the appropriate commands to update them.
 
 ## Installation
-- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade/) package.
-- NixOS: _topgrade_ package in `nixpkgs`.
-- macOS: [Homebrew](https://brew.sh/) or [MacPorts](https://www.macports.org/install.php).
 
-Other systems users can either use `cargo install` or use the compiled binaries from the release page.
+[![Packaging status](https://repology.org/badge/vertical-allrepos/topgrade.svg)](https://repology.org/project/topgrade/versions)
+
+- Arch Linux: [AUR](https://aur.archlinux.org/packages/topgrade)
+- NixOS: [Nixpkgs](https://search.nixos.org/packages?show=topgrade)
+- Void Linux: [XBPS](https://voidlinux.org/packages/?arch=x86_64&q=topgrade)
+- macOS: [Homebrew](https://formulae.brew.sh/formula/topgrade) or [MacPorts](https://ports.macports.org/port/topgrade/)
+
+Other systems users can either use `cargo install` or the compiled binaries from the release page.
 The compiled binaries contain a self-upgrading feature.
 
-Topgrade requires Rust 1.51 or above.
-
-## Documentation[WIP]
-You can visit the documentation at [topgrade-rs.github.io](https://topgrade-rs.github.io/) .
+Topgrade requires Rust 1.60 or above.
 
 ## Usage
+
 Just run `topgrade`.
-See [the 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 by the operating system:
+The configuration should be placed in the following paths depending on the operating system:
 
-* **Windows** - `%APPDATA%/topgrade.toml`
-* **macOS** and **other Unix systems** - `${XDG_CONFIG_HOME:-~/.config}/topgrade.toml`
+- **Windows** - `%APPDATA%/topgrade.toml`
+- **macOS** and **other Unix systems** - `${XDG_CONFIG_HOME:-~/.config}/topgrade.toml`
+
+## Remote Execution
 
-## 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.
+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.
+
+### 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.
+
+### Want to contribute to the code?
+
+Just fork the repository and start coding.
+
+### Contribution Guidelines
+
+- Check if your code passes `cargo fmt` and `cargo clippy`.
+- Check if your code is self explanatory, if not it should be documented by comments.
+- Make a pull request to the `dev` branch for new features or to the `bug-fixes` branch for bug fixes.
+
+## Roadmap
+
+- [ ] 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

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

build-all.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env sh
+build_function() {
+    rustup update
+    cargo install cross
+
+
+    echo -n "Building x86_64-linux-gnu"
+    cross build --release --target x86_64-unknown-linux-gnu
+    echo -n "Building x86_64-linux-musl"
+    cross build --release --target x86_64-unknown-linux-musl
+    echo -n "Building x86_64-freebsd"
+    cross build --release --target x86_64-unknown-freebsd
+    echo -n "Building aarch64-linux-gnu"
+    cross build --release --target aarch64-unknown-linux-gnu
+    echo -n "Building aarch64-linux-musl"
+    cross build --release --target aarch64-unknown-linux-musl
+    echo -n "Building x86_64-windows-gnu"
+    cross build --release --target x86_64-pc-windows-gnu
+}
+
+package_function() {
+
+    cd build
+    mkdir x86_64-unknown-linux-gnu/
+    mkdir x86_64-unknown-linux-musl/
+    mkdir x86_64-unknown-freebsd/
+    mkdir x86_64-pc-windows-gnu/
+    mkdir aarch64-unknown-linux-gnu/
+    mkdir aarch64-unknown-linux-musl/
+
+    cp ../target/x86_64-unknown-linux-gnu/release/topgrade      x86_64-unknown-linux-gnu/
+    cp ../target/x86_64-unknown-linux-musl/release/topgrade     x86_64-unknown-linux-musl/
+    cp ../target/x86_64-unknown-freebsd/release/topgrade        x86_64-unknown-freebsd/topgrade
+    cp ../target/aarch64-unknown-linux-gnu/release/topgrade     aarch64-unknown-linux-gnu/topgrade
+    cp ../target/aarch64-unknown-linux-musl/release/topgrade    aarch64-unknown-linux-musl/topgrade
+    cp ../target/x86_64-pc-windows-gnu/release/topgrade.exe     x86_64-pc-windows-gnu/topgrade.exe
+
+    cd x86_64-unknown-linux-gnu/
+    tar -czf ../topgrade-${ans}-x86_64-linux-gnu.tar.gz topgrade
+    cd ..
+
+    cd x86_64-unknown-linux-musl
+    tar -czf ../topgrade-${ans}-x86_64-linux-musl.tar.gz  topgrade
+    cd ..
+
+    cd x86_64-unknown-freebsd/
+    tar -czf ../topgrade-${ans}-x86_64-freebsd.tar.gz     topgrade
+    cd ..
+
+    cd aarch64-unknown-linux-gnu/
+    tar -czf ../topgrade-${ans}-aarch64-linux-gnu.tar.gz  topgrade
+    cd ..
+
+    cd aarch64-unknown-linux-musl/
+    tar -czf ../topgrade-${ans}-aarch64-linux-musl.tar.gz topgrade
+    cd ..
+
+    cd x86_64-pc-windows-gnu/
+    zip -q ../topgrade-${ans}-x86_64-windows.zip           topgrade.exe
+    cd ..
+    cd ..
+
+}
+
+print_checksums() {
+
+
+    cd build/
+    sha256sum topgrade-${ans}-*
+    cd ../
+}
+
+while true; do
+
+echo "You should always have a look on scripts you download from the internet."
+read -p "Do you still want to proceed? (y/n) " yn
+
+echo -n "Input version number: "
+read ans
+mkdir build
+
+case $yn in
+	y ) build_function
+        package_function
+        print_checksums
+		break;;
+	n ) echo exiting...;
+		exit;;
+	* ) echo invalid response;;
+esac
+
+done

clippy.toml

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

config.example.toml

@@ -70,10 +70,12 @@
 #autoremove = true
 
 [linux]
-# Arch Package Manager to use. Allowed values: autodetect, trizen, paru, yay, pikaur, pacman, pamac.
+# 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"
+#aura_aur_arguments = "-kx"
+#aura_pacman_arguments = ""
 #show_arch_news = true
 #trizen_arguments = "--devel"
 #pikaur_arguments = ""
@@ -105,3 +107,7 @@
 [flatpak]
 # Use sudo for updating the system-wide installation
 #use_sudo = true
+
+[distrobox]
+#use_root = false
+#containers = ["archlinux-latest"]

src/command.rs

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

src/config.rs

@@ -5,17 +5,20 @@ use std::path::PathBuf;
 use std::process::Command;
 use std::{env, fs};
 
-use anyhow::Result;
 use clap::{ArgEnum, Parser};
+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 sys_info::hostname;
+use tracing::debug;
 use which_crate::which;
 
-use super::utils::editor;
+use crate::command::CommandExt;
+
+use super::utils::{editor, hostname};
 
 pub static EXAMPLE_CONFIG: &str = include_str!("../config.example.toml");
 
@@ -83,6 +86,7 @@ pub enum Step {
     Containers,
     CustomCommands,
     DebGet,
+    Distrobox,
     Deno,
     Dotnet,
     Emacs,
@@ -92,6 +96,7 @@ pub enum Step {
     Fossil,
     Gcloud,
     Gem,
+    Ghcup,
     GithubCliExtensions,
     GitRepos,
     Go,
@@ -120,6 +125,7 @@ pub enum Step {
     Powershell,
     Protonup,
     Raco,
+    Rcm,
     Remotes,
     Restarts,
     Rtcl,
@@ -171,6 +177,14 @@ pub struct Windows {
     enable_winget: Option<bool>,
 }
 
+#[derive(Deserialize, Default, Debug)]
+#[serde(deny_unknown_fields)]
+#[allow(clippy::upper_case_acronyms)]
+pub struct Distrobox {
+    use_root: Option<bool>,
+    containers: Option<Vec<String>>,
+}
+
 #[derive(Deserialize, Default, Debug)]
 #[serde(deny_unknown_fields)]
 #[allow(clippy::upper_case_acronyms)]
@@ -216,12 +230,15 @@ pub enum ArchPackageManager {
     Pacman,
     Pikaur,
     Pamac,
+    Aura,
 }
 
 #[derive(Deserialize, Default, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct Linux {
     yay_arguments: Option<String>,
+    aura_aur_arguments: Option<String>,
+    aura_pacman_arguments: Option<String>,
     arch_package_manager: Option<ArchPackageManager>,
     show_arch_news: Option<bool>,
     trizen_arguments: Option<String>,
@@ -268,6 +285,8 @@ pub struct ConfigFile {
     display_time: Option<bool>,
     assume_yes: Option<bool>,
     yay_arguments: Option<String>,
+    aura_aur_arguments: Option<String>,
+    aura_pacman_arguments: Option<String>,
     no_retry: Option<bool>,
     run_in_tmux: Option<bool>,
     cleanup: Option<bool>,
@@ -287,6 +306,7 @@ pub struct ConfigFile {
     firmware: Option<Firmware>,
     vagrant: Option<Vagrant>,
     flatpak: Option<Flatpak>,
+    distrobox: Option<Distrobox>,
 }
 
 fn config_directory(base_dirs: &BaseDirs) -> PathBuf {
@@ -331,12 +351,12 @@ impl ConfigFile {
         };
 
         let contents = fs::read_to_string(&config_path).map_err(|e| {
-            log::error!("Unable to read {}", config_path.display());
+            tracing::error!("Unable to read {}", config_path.display());
             e
         })?;
 
         let mut result: Self = toml::from_str(&contents).map_err(|e| {
-            log::error!("Failed to deserialize {}", config_path.display());
+            tracing::error!("Failed to deserialize {}", config_path.display());
             e
         })?;
 
@@ -372,9 +392,8 @@ impl ConfigFile {
         Command::new(command)
             .args(args)
             .arg(config_path)
-            .spawn()
-            .and_then(|mut p| p.wait())?;
-        Ok(())
+            .status_checked()
+            .context("Failed to open configuration file editor")
     }
 }
 
@@ -407,22 +426,22 @@ pub struct CommandLineArgs {
     no_retry: bool,
 
     /// Do not perform upgrades for the given steps
-    #[clap(long = "disable", arg_enum, multiple_values = true)]
+    #[clap(long = "disable", value_name = "STEP", arg_enum, multiple_values = true)]
     disable: Vec<Step>,
 
     /// Perform only the specified steps (experimental)
-    #[clap(long = "only", arg_enum, multiple_values = true)]
+    #[clap(long = "only", value_name = "STEP", arg_enum, multiple_values = true)]
     only: Vec<Step>,
 
     /// Run only specific custom commands
-    #[clap(long = "custom-commands")]
+    #[clap(long = "custom-commands", value_name = "NAME", multiple_values = true)]
     custom_commands: Vec<String>,
 
     /// Set environment variables
-    #[clap(long = "env", multiple_values = true)]
+    #[clap(long = "env", value_name = "NAME=VALUE", multiple_values = true)]
     env: Vec<String>,
 
-    /// Output logs
+    /// Output debug logs. Alias for `--log-filter debug`.
     #[clap(short = 'v', long = "verbose")]
     pub verbose: bool,
 
@@ -435,7 +454,14 @@ pub struct CommandLineArgs {
     skip_notify: bool,
 
     /// Say yes to package manager's prompt
-    #[clap(short = 'y', long = "yes", arg_enum, multiple_values = true, min_values = 0)]
+    #[clap(
+        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
@@ -443,16 +469,22 @@ pub struct CommandLineArgs {
     disable_predefined_git_repos: bool,
 
     /// Alternative configuration file
-    #[clap(long = "config")]
+    #[clap(long = "config", value_name = "PATH")]
     config: Option<PathBuf>,
 
     /// A regular expression for restricting remote host execution
-    #[clap(long = "remote-host-limit")]
+    #[clap(long = "remote-host-limit", value_name = "REGEX")]
     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,
 }
 
 impl CommandLineArgs {
@@ -467,6 +499,14 @@ 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
@@ -490,11 +530,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
-                log::error!("failed to load configuration: {}", e);
+                tracing::error!("failed to load configuration: {}", e);
                 ConfigFile::default()
             })
         } else {
-            log::debug!("Configuration directory {} does not exist", config_directory.display());
+            tracing::debug!("Configuration directory {} does not exist", config_directory.display());
             ConfigFile::default()
         };
 
@@ -609,9 +649,16 @@ impl Config {
     }
 
     /// Extra Tmux arguments
-
-    pub fn tmux_arguments(&self) -> &Option<String> {
-        &self.config_file.tmux_arguments
+    pub fn tmux_arguments(&self) -> eyre::Result<Vec<String>> {
+        let args = &self.config_file.tmux_arguments.as_deref().unwrap_or_default();
+        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
@@ -764,9 +811,27 @@ impl Config {
 
     /// Extra yay arguments
     pub fn yay_arguments(&self) -> &str {
-        get_deprecated!(self.config_file, yay_arguments, linux, yay_arguments)
-            .as_deref()
-            .unwrap_or("--devel")
+        self.config_file
+            .linux
+            .as_ref()
+            .and_then(|s| s.yay_arguments.as_deref())
+            .unwrap_or("")
+    }
+
+    /// Extra aura arguments for AUR and pacman
+    pub fn aura_aur_arguments(&self) -> &str {
+        self.config_file
+            .linux
+            .as_ref()
+            .and_then(|s| s.aura_aur_arguments.as_deref())
+            .unwrap_or("")
+    }
+    pub fn aura_pacman_arguments(&self) -> &str {
+        self.config_file
+            .linux
+            .as_ref()
+            .and_then(|s| s.aura_pacman_arguments.as_deref())
+            .unwrap_or("")
     }
 
     /// Extra apt arguments
@@ -785,6 +850,20 @@ impl Config {
             .and_then(|linux| linux.dnf_arguments.as_deref())
     }
 
+    /// Distrobox use root
+    pub fn distrobox_root(&self) -> bool {
+        self.config_file
+            .distrobox
+            .as_ref()
+            .and_then(|r| r.use_root)
+            .unwrap_or(false)
+    }
+
+    /// Distrobox containers
+    pub fn distrobox_containers(&self) -> Option<&Vec<String>> {
+        self.config_file.distrobox.as_ref().and_then(|r| r.containers.as_ref())
+    }
+
     /// Concurrency limit for git
     pub fn git_concurrency_limit(&self) -> Option<usize> {
         self.config_file.git.as_ref().and_then(|git| git.max_concurrency)

src/ctrlc/interrupted.rs

@@ -1,10 +1,7 @@
-use lazy_static::lazy_static;
 use std::sync::atomic::{AtomicBool, Ordering};
 
-lazy_static! {
-    /// A global variable telling whether the application has been interrupted.
-    static ref INTERRUPTED: AtomicBool = AtomicBool::new(false);
-}
+/// A global variable telling whether the application has been interrupted.
+static 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) } {
-        log::error!("Cannot set a control C handler")
+        tracing::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}")]
-    ProcessFailed(ExitStatus),
+    #[error("`{0}` failed: {1}")]
+    ProcessFailed(String, ExitStatus),
 
-    #[error("{0}: {1}")]
-    ProcessFailedWithOutput(ExitStatus, String),
+    #[error("`{0}` failed: {1}")]
+    ProcessFailedWithOutput(String, ExitStatus, String),
 
     #[error("Sudo is required for this step")]
     #[allow(dead_code)]

src/execution_context.rs

@@ -3,9 +3,10 @@ use crate::executor::RunType;
 use crate::git::Git;
 use crate::utils::require_option;
 use crate::{config::Config, executor::Executor};
-use anyhow::Result;
+use color_eyre::eyre::Result;
 use directories::BaseDirs;
 use std::path::{Path, PathBuf};
+use std::sync::Mutex;
 
 pub struct ExecutionContext<'a> {
     run_type: RunType,
@@ -13,6 +14,10 @@ pub struct ExecutionContext<'a> {
     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> {
@@ -22,13 +27,14 @@ impl<'a> ExecutionContext<'a> {
         git: &'a Git,
         config: &'a Config,
         base_dirs: &'a BaseDirs,
-    ) -> ExecutionContext<'a> {
-        ExecutionContext {
+    ) -> Self {
+        Self {
             run_type,
             sudo,
             git,
             config,
             base_dirs,
+            tmux_session: Mutex::new(None),
         }
     }
 
@@ -67,4 +73,12 @@ 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,11 +1,14 @@
 //! Utilities for command execution
-use crate::error::{DryRun, TopgradeError};
-use crate::utils::{Check, CheckWithCodes};
-use anyhow::Result;
-use log::{debug, trace};
 use std::ffi::{OsStr, OsString};
 use std::path::Path;
-use std::process::{Child, Command, ExitStatus};
+use std::process::{Child, Command, ExitStatus, Output};
+
+use color_eyre::eyre;
+use color_eyre::eyre::Result;
+use tracing::debug;
+
+use crate::command::CommandExt;
+use crate::error::DryRun;
 
 /// An enum telling whether Topgrade should perform dry runs or actually perform the steps.
 #[derive(Clone, Copy, Debug)]
@@ -56,6 +59,16 @@ pub enum Executor {
 }
 
 impl Executor {
+    /// Get the name of the program being run.
+    ///
+    /// Will give weird results for non-UTF-8 programs; see `to_string_lossy()`.
+    pub fn get_program(&self) -> String {
+        match self {
+            Executor::Wet(c) => c.get_program().to_string_lossy().into_owned(),
+            Executor::Dry(c) => c.program.to_string_lossy().into_owned(),
+        }
+    }
+
     /// See `std::process::Command::arg`
     pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Executor {
         match self {
@@ -139,7 +152,7 @@ impl Executor {
         let result = match self {
             Executor::Wet(c) => {
                 debug!("Running {:?}", c);
-                c.spawn().map(ExecutorChild::Wet)?
+                c.spawn_checked().map(ExecutorChild::Wet)?
             }
             Executor::Dry(c) => {
                 c.dry_run();
@@ -153,7 +166,7 @@ impl Executor {
     /// See `std::process::Command::output`
     pub fn output(&mut self) -> Result<ExecutorOutput> {
         match self {
-            Executor::Wet(c) => Ok(ExecutorOutput::Wet(c.output()?)),
+            Executor::Wet(c) => Ok(ExecutorOutput::Wet(c.output_checked()?)),
             Executor::Dry(c) => {
                 c.dry_run();
                 Ok(ExecutorOutput::Dry)
@@ -161,23 +174,28 @@ impl Executor {
         }
     }
 
-    /// A convinence method for `spawn().wait().check()`.
-    /// Returns an error if something went wrong during the execution or if the
-    /// process exited with failure.
-    pub fn check_run(&mut self) -> Result<()> {
-        self.spawn()?.wait()?.check()
-    }
-
-    /// An extension of `check_run` that allows you to set a sequence of codes
+    /// An extension of `status_checked` that allows you to set a sequence of codes
     /// that can indicate success of a script
-    #[allow(dead_code)]
-    pub fn check_run_with_codes(&mut self, codes: &[i32]) -> Result<()> {
-        self.spawn()?.wait()?.check_with_codes(codes)
+    #[cfg_attr(windows, allow(dead_code))]
+    pub fn status_checked_with_codes(&mut self, codes: &[i32]) -> Result<()> {
+        match self {
+            Executor::Wet(c) => c.status_checked_with(|status| {
+                if status.success() || status.code().as_ref().map(|c| codes.contains(c)).unwrap_or(false) {
+                    Ok(())
+                } else {
+                    Err(())
+                }
+            }),
+            Executor::Dry(c) => {
+                c.dry_run();
+                Ok(())
+            }
+        }
     }
 }
 
 pub enum ExecutorOutput {
-    Wet(std::process::Output),
+    Wet(Output),
     Dry,
 }
 
@@ -194,11 +212,12 @@ impl DryCommand {
         print!(
             "Dry running: {} {}",
             self.program.to_string_lossy(),
-            self.args
-                .iter()
-                .map(|a| String::from(a.to_string_lossy()))
-                .collect::<Vec<String>>()
-                .join(" ")
+            shell_words::join(
+                self.args
+                    .iter()
+                    .map(|a| String::from(a.to_string_lossy()))
+                    .collect::<Vec<String>>()
+            )
         );
         match &self.directory {
             Some(dir) => println!(" in {}", dir.to_string_lossy()),
@@ -213,78 +232,33 @@ pub enum ExecutorChild {
     Dry,
 }
 
-impl ExecutorChild {
-    /// See `std::process::Child::wait`
-    pub fn wait(&mut self) -> Result<ExecutorExitStatus> {
-        let result = match self {
-            ExecutorChild::Wet(c) => c.wait().map(ExecutorExitStatus::Wet)?,
-            ExecutorChild::Dry => ExecutorExitStatus::Dry,
-        };
-
-        Ok(result)
-    }
-}
-
-/// The Result of wait. Contains an actual `std::process::ExitStatus` if executed by a wet command.
-pub enum ExecutorExitStatus {
-    Wet(ExitStatus),
-    Dry,
-}
-
-impl CheckWithCodes for ExecutorExitStatus {
-    fn check_with_codes(self, codes: &[i32]) -> Result<()> {
-        match self {
-            ExecutorExitStatus::Wet(e) => e.check_with_codes(codes),
-            ExecutorExitStatus::Dry => Ok(()),
-        }
-    }
-}
-
-/// Extension methods for `std::process::Command`
-pub trait CommandExt {
-    /// Run the command, wait for it to complete, check the return code and decode the output as UTF-8.
-    fn check_output(&mut self) -> Result<String>;
-    fn string_output(&mut self) -> Result<String>;
-}
-
-impl CommandExt for Command {
-    fn check_output(&mut self) -> Result<String> {
-        let output = self.output()?;
-        trace!("Output of {:?}: {:?}", self, output);
-        let status = output.status;
-        if !status.success() {
-            let stderr = String::from_utf8(output.stderr).unwrap_or_default();
-            return Err(TopgradeError::ProcessFailedWithOutput(status, stderr).into());
-        }
-        Ok(String::from_utf8(output.stdout)?)
-    }
-
-    fn string_output(&mut self) -> Result<String> {
-        let output = self.output()?;
-        trace!("Output of {:?}: {:?}", self, output);
-        Ok(String::from_utf8(output.stdout)?)
-    }
-}
-
 impl CommandExt for Executor {
-    fn check_output(&mut self) -> Result<String> {
-        let output = match self.output()? {
-            ExecutorOutput::Wet(output) => output,
-            ExecutorOutput::Dry => return Err(DryRun().into()),
-        };
-        let status = output.status;
-        if !status.success() {
-            let stderr = String::from_utf8(output.stderr).unwrap_or_default();
-            return Err(TopgradeError::ProcessFailedWithOutput(status, stderr).into());
+    type Child = ExecutorChild;
+
+    // TODO: It might be nice to make `output_checked_with` return something that has a
+    // variant for wet/dry runs.
+
+    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> eyre::Result<Output> {
+        match self {
+            Executor::Wet(c) => c.output_checked_with(succeeded),
+            Executor::Dry(c) => {
+                c.dry_run();
+                Err(DryRun().into())
+            }
         }
-        Ok(String::from_utf8(output.stdout)?)
     }
 
-    fn string_output(&mut self) -> Result<String> {
-        let output = match self.output()? {
-            ExecutorOutput::Wet(output) => output,
-            ExecutorOutput::Dry => return Err(DryRun().into()),
-        };
-        Ok(String::from_utf8(output.stdout)?)
+    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> eyre::Result<()> {
+        match self {
+            Executor::Wet(c) => c.status_checked_with(succeeded),
+            Executor::Dry(c) => {
+                c.dry_run();
+                Ok(())
+            }
+        }
+    }
+
+    fn spawn_checked(&mut self) -> eyre::Result<Self::Child> {
+        self.spawn()
     }
 }

src/lib.rs

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

src/main.rs

@@ -4,12 +4,11 @@ use std::env;
 use std::io;
 use std::process::exit;
 
-use anyhow::{anyhow, Result};
 use clap::{crate_version, Parser};
+use color_eyre::eyre::Context;
+use color_eyre::eyre::{eyre, Result};
 use console::Key;
-use log::debug;
-use log::LevelFilter;
-use pretty_env_logger::formatted_timed_builder;
+use tracing::debug;
 
 use self::config::{CommandLineArgs, Config, Step};
 use self::error::StepFailed;
@@ -18,6 +17,7 @@ use self::error::Upgraded;
 use self::steps::{remote::*, *};
 use self::terminal::*;
 
+mod command;
 mod config;
 mod ctrlc;
 mod error;
@@ -34,12 +34,15 @@ mod terminal;
 mod utils;
 
 fn run() -> Result<()> {
+    color_eyre::install()?;
     ctrlc::set_handler();
 
-    let base_dirs = directories::BaseDirs::new().ok_or_else(|| anyhow!("No base directories"))?;
+    let base_dirs = directories::BaseDirs::new().ok_or_else(|| eyre!("No base directories"))?;
 
     let opt = CommandLineArgs::parse();
 
+    install_tracing(&opt.tracing_filter_directives())?;
+
     for env in opt.env_variables() {
         let mut splitted = env.split('=');
         let var = splitted.next().unwrap();
@@ -47,14 +50,6 @@ 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(());
@@ -79,7 +74,8 @@ fn run() -> Result<()> {
     if config.run_in_tmux() && env::var("TOPGRADE_INSIDE_TMUX").is_err() {
         #[cfg(unix)]
         {
-            tmux::run_in_tmux(config.tmux_arguments());
+            tmux::run_in_tmux(config.tmux_arguments()?)?;
+            return Ok(());
         }
     }
 
@@ -140,7 +136,7 @@ fn run() -> Result<()> {
     #[cfg(target_os = "linux")]
     let distribution = linux::Distribution::detect();
 
-    #[cfg(target_os = "linux")]
+    #[cfg(target_os = r#"linux"#)]
     {
         match &distribution {
             Ok(distribution) => {
@@ -206,7 +202,12 @@ fn run() -> Result<()> {
 
     #[cfg(target_os = "freebsd")]
     runner.execute(Step::Pkg, "FreeBSD Packages", || {
-        freebsd::upgrade_packages(sudo.as_ref(), run_type)
+        freebsd::upgrade_packages(&ctx, sudo.as_ref(), run_type)
+    })?;
+
+    #[cfg(target_os = "openbsd")]
+    runner.execute(Step::Pkg, "OpenBSD Packages", || {
+        openbsd::upgrade_packages(sudo.as_ref(), run_type)
     })?;
 
     #[cfg(target_os = "android")]
@@ -231,6 +232,10 @@ fn run() -> Result<()> {
         git_repos.insert_if_repo(base_dirs.home_dir().join(".ideavimrc"));
         git_repos.insert_if_repo(base_dirs.home_dir().join(".intellimacs"));
 
+        if config.should_run(Step::Rcm) {
+            git_repos.insert_if_repo(base_dirs.home_dir().join(".dotfiles"));
+        }
+
         #[cfg(unix)]
         {
             git_repos.insert_if_repo(zsh::zshrc(&base_dirs));
@@ -287,10 +292,11 @@ fn run() -> Result<()> {
         runner.execute(Step::Shell, "zi", || zsh::run_zi(&base_dirs, run_type))?;
         runner.execute(Step::Shell, "zim", || zsh::run_zim(&base_dirs, run_type))?;
         runner.execute(Step::Shell, "oh-my-zsh", || zsh::run_oh_my_zsh(&ctx))?;
-        runner.execute(Step::Shell, "fisher", || unix::run_fisher(&base_dirs, run_type))?;
+        runner.execute(Step::Shell, "fisher", || unix::run_fisher(run_type))?;
         runner.execute(Step::Shell, "bash-it", || unix::run_bashit(&ctx))?;
         runner.execute(Step::Shell, "oh-my-fish", || unix::run_oh_my_fish(&ctx))?;
         runner.execute(Step::Shell, "fish-plug", || unix::run_fish_plug(&ctx))?;
+        runner.execute(Step::Shell, "fundle", || unix::run_fundle(&ctx))?;
         runner.execute(Step::Tmux, "tmux", || tmux::run_tpm(&base_dirs, run_type))?;
         runner.execute(Step::Tldr, "TLDR", || unix::run_tldr(run_type))?;
         runner.execute(Step::Pearl, "pearl", || unix::run_pearl(run_type))?;
@@ -301,6 +307,7 @@ fn run() -> Result<()> {
         runner.execute(Step::Sdkman, "SDKMAN!", || {
             unix::run_sdkman(&base_dirs, config.cleanup(), run_type)
         })?;
+        runner.execute(Step::Rcm, "rcm", || unix::run_rcm(&ctx))?;
     }
 
     #[cfg(not(any(
@@ -316,13 +323,15 @@ fn run() -> Result<()> {
     runner.execute(Step::Choosenim, "choosenim", || generic::run_choosenim(&ctx))?;
     runner.execute(Step::Cargo, "cargo", || generic::run_cargo_update(&ctx))?;
     runner.execute(Step::Flutter, "Flutter", || generic::run_flutter_upgrade(run_type))?;
-    runner.execute(Step::Go, "Go", || generic::run_go(run_type))?;
+    runner.execute(Step::Go, "go-global-update", || go::run_go_global_update(run_type))?;
+    runner.execute(Step::Go, "gup", || go::run_go_gup(run_type))?;
     runner.execute(Step::Emacs, "Emacs", || emacs.upgrade(&ctx))?;
     runner.execute(Step::Opam, "opam", || generic::run_opam_update(&ctx))?;
     runner.execute(Step::Vcpkg, "vcpkg", || generic::run_vcpkg_update(run_type))?;
     runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(run_type))?;
     runner.execute(Step::Conda, "conda", || generic::run_conda_update(&ctx))?;
     runner.execute(Step::Pip3, "pip3", || generic::run_pip3_update(run_type))?;
+    runner.execute(Step::Ghcup, "ghcup", || generic::run_ghcup_update(run_type))?;
     runner.execute(Step::Stack, "stack", || generic::run_stack_update(run_type))?;
     runner.execute(Step::Tlmgr, "tlmgr", || generic::run_tlmgr_update(&ctx))?;
     runner.execute(Step::Myrepos, "myrepos", || {
@@ -339,6 +348,7 @@ fn run() -> Result<()> {
     runner.execute(Step::Kakoune, "Kakoune", || kakoune::upgrade_kak_plug(&ctx))?;
     runner.execute(Step::Node, "npm", || node::run_npm_upgrade(&ctx))?;
     runner.execute(Step::Node, "yarn", || node::run_yarn_upgrade(&ctx))?;
+    runner.execute(Step::Node, "pnpm", || node::run_pnpm_upgrade(&ctx))?;
     runner.execute(Step::Containers, "Containers", || containers::run_containers(&ctx))?;
     runner.execute(Step::Deno, "deno", || node::deno_upgrade(&ctx))?;
     runner.execute(Step::Composer, "composer", || generic::run_composer_update(&ctx))?;
@@ -368,6 +378,7 @@ fn run() -> Result<()> {
         runner.execute(Step::Pacstall, "pacstall", || linux::run_pacstall(&ctx))?;
         runner.execute(Step::Pacdef, "pacdef", || linux::run_pacdef(&ctx))?;
         runner.execute(Step::Protonup, "protonup", || linux::run_protonup_update(&ctx))?;
+        runner.execute(Step::Distrobox, "distrobox", || linux::run_distrobox_update(&ctx))?;
     }
 
     if let Some(commands) = config.commands() {
@@ -403,6 +414,11 @@ fn run() -> Result<()> {
         freebsd::upgrade_freebsd(sudo.as_ref(), run_type)
     })?;
 
+    #[cfg(target_os = "openbsd")]
+    runner.execute(Step::System, "OpenBSD Upgrade", || {
+        openbsd::upgrade_openbsd(sudo.as_ref(), run_type)
+    })?;
+
     #[cfg(windows)]
     runner.execute(Step::System, "Windows update", || windows::windows_update(&ctx))?;
 
@@ -452,10 +468,10 @@ fn run() -> Result<()> {
         loop {
             match get_key() {
                 Ok(Key::Char('s')) | Ok(Key::Char('S')) => {
-                    run_shell();
+                    run_shell().context("Failed to execute shell")?;
                 }
                 Ok(Key::Char('r')) | Ok(Key::Char('R')) => {
-                    reboot();
+                    reboot().context("Failed to reboot")?;
                 }
                 Ok(Key::Char('q')) | Ok(Key::Char('Q')) => (),
                 _ => {
@@ -505,9 +521,35 @@ fn main() {
                     .is_some());
 
             if !skip_print {
-                println!("Error: {}", error);
+                // The `Debug` implementation of `eyre::Result` prints a multi-line
+                // error message that includes all the 'causes' added with
+                // `.with_context(...)` calls.
+                println!("Error: {:?}", error);
             }
             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/runner.rs

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

src/self_renamer.rs

@@ -1,8 +1,8 @@
 #![cfg(windows)]
 
-use anyhow::Result;
-use log::{debug, error};
+use color_eyre::eyre::Result;
 use std::{env::current_exe, fs, path::PathBuf};
+use tracing::{debug, error};
 
 pub struct SelfRenamer {
     exe_path: PathBuf,
@@ -31,7 +31,7 @@ impl Drop for SelfRenamer {
         }
 
         match fs::rename(&self.temp_path, &self.exe_path) {
-            Ok(_) => debug!("Moved topgrade back from {:?} to {:?}", self.temp_path, self.exe_path),
+            Ok(_) => debug!("Moved Topgrade back from {:?} to {:?}", self.temp_path, self.exe_path),
             Err(e) => error!(
                 "Could not move Topgrade from {} back to {}: {}",
                 self.temp_path.display(),

src/self_update.rs

@@ -1,13 +1,15 @@
+use std::env;
+#[cfg(unix)]
+use std::os::unix::process::CommandExt as _;
+use std::process::Command;
+
+use color_eyre::eyre::{bail, Result};
+use self_update_crate::backends::github::Update;
+use self_update_crate::update::UpdateStatus;
+
 use super::terminal::*;
 #[cfg(windows)]
 use crate::error::Upgraded;
-use anyhow::{bail, Result};
-use self_update_crate::backends::github::Update;
-use self_update_crate::update::UpdateStatus;
-use std::env;
-#[cfg(unix)]
-use std::os::unix::process::CommandExt;
-use std::process::Command;
 
 pub fn self_update() -> Result<()> {
     print_separator("Self update");
@@ -15,7 +17,7 @@ pub fn self_update() -> Result<()> {
 
     let target = self_update_crate::get_target();
     let result = Update::configure()
-        .repo_owner("r-darwish")
+        .repo_owner("topgrade-rs")
         .repo_name("topgrade")
         .target(target)
         .bin_name(if cfg!(windows) { "topgrade.exe" } else { "topgrade" })
@@ -49,7 +51,8 @@ pub fn self_update() -> Result<()> {
 
             #[cfg(windows)]
             {
-                let status = command.spawn().and_then(|mut c| c.wait())?;
+                #[allow(clippy::disallowed_methods)]
+                let status = command.status()?;
                 bail!(Upgraded(status));
             }
         }

src/steps/containers.rs

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

src/steps/emacs.rs

@@ -2,9 +2,10 @@
 use std::env;
 use std::path::{Path, PathBuf};
 
-use anyhow::Result;
+use color_eyre::eyre::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};
@@ -71,9 +72,9 @@ impl Emacs {
             command.arg("--force");
         }
 
-        command.args(&["upgrade"]);
+        command.args(["upgrade"]);
 
-        command.check_run()
+        command.status_checked()
     }
 
     pub fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
@@ -87,10 +88,10 @@ 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"])
+            .args(["--batch", "--debug-init", "-l"])
             .arg(init_file)
             .arg("--eval");
 
@@ -105,6 +106,6 @@ impl Emacs {
         #[cfg(not(unix))]
         command.arg(EMACS_UPGRADE);
 
-        command.check_run()
+        command.status_checked()
     }
 }

src/steps/generic.rs

@@ -5,13 +5,16 @@ use std::process::Command;
 use std::{env, path::Path};
 use std::{fs, io::Write};
 
-use anyhow::Result;
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Context;
+use color_eyre::eyre::Result;
 use directories::BaseDirs;
-use log::debug;
 use tempfile::tempfile_in;
+use tracing::debug;
 
+use crate::command::{CommandExt, Utf8Output};
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, ExecutorOutput, RunType};
+use crate::executor::{ExecutorOutput, RunType};
 use crate::terminal::{print_separator, shell};
 use crate::utils::{self, require_option, PathExt};
 use crate::{
@@ -52,29 +55,15 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
 
     ctx.run_type()
         .execute(cargo_update)
-        .args(&["install-update", "--git", "--all"])
-        .check_run()
+        .args(["install-update", "--git", "--all"])
+        .status_checked()
 }
 
 pub fn run_flutter_upgrade(run_type: RunType) -> Result<()> {
     let flutter = utils::require("flutter")?;
 
     print_separator("Flutter");
-    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()
+    run_type.execute(flutter).arg("upgrade").status_checked()
 }
 
 pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -83,7 +72,7 @@ pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     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() {
@@ -91,14 +80,15 @@ pub fn run_gem(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
         command.arg("--user-install");
     }
 
-    command.check_run()
+    command.status_checked()
 }
 
 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()?.stdout)?.trim()).require()?;
+        PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output_checked()?.stdout)?.trim())
+            .require()?;
 
     let directory_writable = tempfile_in(&haxelib_dir).is_ok();
     debug!("{:?} writable: {}", haxelib_dir, directory_writable);
@@ -115,7 +105,7 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
         c
     };
 
-    command.arg("update").check_run()
+    command.arg("update").status_checked()
 }
 
 pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
@@ -123,7 +113,10 @@ pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Sheldon");
 
-    ctx.run_type().execute(&sheldon).args(&["lock", "--update"]).check_run()
+    ctx.run_type()
+        .execute(sheldon)
+        .args(["lock", "--update"])
+        .status_checked()
 }
 
 pub fn run_fossil(run_type: RunType) -> Result<()> {
@@ -131,7 +124,7 @@ pub fn run_fossil(run_type: RunType) -> Result<()> {
 
     print_separator("Fossil");
 
-    run_type.execute(&fossil).args(&["all", "sync"]).check_run()
+    run_type.execute(fossil).args(["all", "sync"]).status_checked()
 }
 
 pub fn run_micro(run_type: RunType) -> Result<()> {
@@ -139,13 +132,17 @@ pub fn run_micro(run_type: RunType) -> Result<()> {
 
     print_separator("micro");
 
-    let stdout = run_type.execute(&micro).args(&["-plugin", "update"]).string_output()?;
+    let stdout = run_type
+        .execute(micro)
+        .args(["-plugin", "update"])
+        .output_checked_utf8()?
+        .stdout;
     std::io::stdout().write_all(stdout.as_bytes())?;
 
     if stdout.contains("Nothing to install / update") || stdout.contains("One or more plugins installed") {
         Ok(())
     } else {
-        Err(anyhow::anyhow!("micro output does not indicate success: {}", stdout))
+        Err(eyre!("micro output does not indicate success: {}", stdout))
     }
 }
 
@@ -160,7 +157,10 @@ pub fn run_apm(run_type: RunType) -> Result<()> {
 
     print_separator("Atom Package Manager");
 
-    run_type.execute(&apm).args(&["upgrade", "--confirm=false"]).check_run()
+    run_type
+        .execute(apm)
+        .args(["upgrade", "--confirm=false"])
+        .status_checked()
 }
 
 pub fn run_rustup(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -169,10 +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"]).check_run()?;
+        run_type.execute(&rustup).args(["self", "update"]).status_checked()?;
     }
 
-    run_type.execute(&rustup).arg("update").check_run()
+    run_type.execute(&rustup).arg("update").status_checked()
 }
 
 pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
@@ -181,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"]).check_run()?;
-    run_type.execute(&choosenim).args(&["update", "stable"]).check_run()
+    run_type.execute(&choosenim).args(["update", "self"]).status_checked()?;
+    run_type.execute(&choosenim).args(["update", "stable"]).status_checked()
 }
 
 pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
@@ -190,18 +190,22 @@ pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
 
     print_separator("Krew");
 
-    run_type.execute(&krew).args(&["upgrade"]).check_run()
+    run_type.execute(krew).args(["upgrade"]).status_checked()
 }
 
 pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
     let gcloud = utils::require("gcloud")?;
 
-    print_separator("gcloud");
+    if gcloud.starts_with("/snap") {
+        Ok(())
+    } else {
+        print_separator("gcloud");
 
-    run_type
-        .execute(&gcloud)
-        .args(&["components", "update", "--quiet"])
-        .check_run()
+        run_type
+            .execute(gcloud)
+            .args(["components", "update", "--quiet"])
+            .status_checked()
+    }
 }
 
 pub fn run_jetpack(run_type: RunType) -> Result<()> {
@@ -209,7 +213,7 @@ pub fn run_jetpack(run_type: RunType) -> Result<()> {
 
     print_separator("Jetpack");
 
-    run_type.execute(&jetpack).args(&["global", "update"]).check_run()
+    run_type.execute(jetpack).args(["global", "update"]).status_checked()
 }
 
 pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
@@ -217,7 +221,7 @@ pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("rtcl");
 
-    ctx.run_type().execute(&rupdate).check_run()
+    ctx.run_type().execute(rupdate).status_checked()
 }
 
 pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
@@ -225,11 +229,11 @@ pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("OCaml Package Manager");
 
-    ctx.run_type().execute(&opam).arg("update").check_run()?;
-    ctx.run_type().execute(&opam).arg("upgrade").check_run()?;
+    ctx.run_type().execute(&opam).arg("update").status_checked()?;
+    ctx.run_type().execute(&opam).arg("upgrade").status_checked()?;
 
     if ctx.config().cleanup() {
-        ctx.run_type().execute(&opam).arg("clean").check_run()?;
+        ctx.run_type().execute(&opam).arg("clean").status_checked()?;
     }
 
     Ok(())
@@ -239,41 +243,43 @@ pub fn run_vcpkg_update(run_type: RunType) -> Result<()> {
     let vcpkg = utils::require("vcpkg")?;
     print_separator("vcpkg");
 
-    run_type.execute(&vcpkg).args(&["upgrade", "--no-dry-run"]).check_run()
+    run_type
+        .execute(vcpkg)
+        .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").check_run()
+    run_type.execute(pipx).arg("upgrade-all").status_checked()
 }
 
 pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
     let conda = utils::require("conda")?;
 
     let output = Command::new("conda")
-        .args(&["config", "--show", "auto_activate_base"])
-        .output()?;
-    let string_output = String::from_utf8(output.stdout)?;
-    debug!("Conda output: {}", string_output);
-    if string_output.contains("False") {
+        .args(["config", "--show", "auto_activate_base"])
+        .output_checked_utf8()?;
+    debug!("Conda output: {}", output.stdout);
+    if output.stdout.contains("False") {
         return Err(SkipStep("auto_activate_base is set to False".to_string()).into());
     }
 
     print_separator("Conda");
 
     ctx.run_type()
-        .execute(&conda)
-        .args(&["update", "--all", "-y"])
-        .check_run()
+        .execute(conda)
+        .args(["update", "--all", "-y"])
+        .status_checked()
 }
 
 pub fn run_pip3_update(run_type: RunType) -> Result<()> {
     let python3 = utils::require("python3")?;
     Command::new(&python3)
-        .args(&["-m", "pip"])
-        .check_output()
+        .args(["-m", "pip"])
+        .output_checked_utf8()
         .map_err(|_| SkipStep("pip does not exists".to_string()))?;
 
     print_separator("pip3");
@@ -284,15 +290,29 @@ pub fn run_pip3_update(run_type: RunType) -> Result<()> {
 
     run_type
         .execute(&python3)
-        .args(&["-m", "pip", "install", "--upgrade", "--user", "pip"])
-        .check_run()
+        .args(["-m", "pip", "install", "--upgrade", "--user", "pip"])
+        .status_checked()
 }
 
 pub fn run_stack_update(run_type: RunType) -> Result<()> {
+    if utils::require("ghcup").is_ok() {
+        // `ghcup` is present and probably(?) being used to install `stack`.
+        // Don't upgrade `stack`, let `ghcup` handle it. Per `ghcup install stack`:
+        // !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
+        return Ok(());
+    }
+
     let stack = utils::require("stack")?;
     print_separator("stack");
 
-    run_type.execute(&stack).arg("upgrade").check_run()
+    run_type.execute(stack).arg("upgrade").status_checked()
+}
+
+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()
 }
 
 pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
@@ -308,13 +328,11 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
     let kpsewhich = utils::require("kpsewhich")?;
     let tlmgr_directory = {
         let mut d = PathBuf::from(
-            std::str::from_utf8(
-                &Command::new(&kpsewhich)
-                    .arg("-var-value=SELFAUTOPARENT")
-                    .output()?
-                    .stdout,
-            )?
-            .trim(),
+            &Command::new(kpsewhich)
+                .arg("-var-value=SELFAUTOPARENT")
+                .output_checked_utf8()?
+                .stdout
+                .trim(),
         );
         d.push("tlpkg");
         d
@@ -335,9 +353,9 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
         c.arg(&tlmgr);
         c
     };
-    command.args(&["update", "--self", "--all"]);
+    command.args(["update", "--self", "--all"]);
 
-    command.check_run()
+    command.status_checked()
 }
 
 pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -346,7 +364,7 @@ pub fn run_chezmoi_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()>
 
     print_separator("chezmoi");
 
-    run_type.execute(&chezmoi).arg("update").check_run()
+    run_type.execute(chezmoi).arg("update").status_checked()
 }
 
 pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -360,27 +378,27 @@ pub fn run_myrepos_update(base_dirs: &BaseDirs, run_type: RunType) -> Result<()>
         .arg("--directory")
         .arg(base_dirs.home_dir())
         .arg("checkout")
-        .check_run()?;
+        .status_checked()?;
     run_type
         .execute(&myrepos)
         .arg("--directory")
         .arg(base_dirs.home_dir())
         .arg("update")
-        .check_run()
+        .status_checked()
 }
 
 pub fn run_custom_command(name: &str, command: &str, ctx: &ExecutionContext) -> Result<()> {
     print_separator(name);
-    ctx.run_type().execute(shell()).arg("-c").arg(command).check_run()
+    ctx.run_type().execute(shell()).arg("-c").arg(command).status_checked()
 }
 
 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"])
-        .check_output()
+        .args(["global", "config", "--absolute", "--quiet", "home"])
+        .output_checked_utf8()
         .map_err(|e| (SkipStep(format!("Error getting the composer directory: {}", e))))
-        .map(|s| PathBuf::from(s.trim()))?
+        .map(|s| PathBuf::from(s.stdout.trim()))?
         .require()?;
 
     if !composer_home.is_descendant_of(ctx.base_dirs().home_dir()) {
@@ -407,26 +425,22 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
                         .execute(ctx.sudo().as_ref().unwrap())
                         .arg(&composer)
                         .arg("self-update")
-                        .check_run()?;
+                        .status_checked()?;
                 }
             } else {
-                ctx.run_type().execute(&composer).arg("self-update").check_run()?;
+                ctx.run_type().execute(&composer).arg("self-update").status_checked()?;
             }
         }
     }
 
-    let output = Command::new(&composer).args(&["global", "update"]).output()?;
-    let status = output.status;
-    if !status.success() {
-        return Err(TopgradeError::ProcessFailed(status).into());
-    }
-    let stdout = String::from_utf8(output.stdout)?;
-    let stderr = String::from_utf8(output.stderr)?;
-    print!("{}\n{}", stdout, stderr);
-
-    if stdout.contains("valet") || stderr.contains("valet") {
-        if let Some(valet) = utils::which("valet") {
-            ctx.run_type().execute(&valet).arg("install").check_run()?;
+    let output = ctx.run_type().execute(&composer).args(["global", "update"]).output()?;
+    if let ExecutorOutput::Wet(output) = output {
+        let output: Utf8Output = output.try_into()?;
+        print!("{}\n{}", output.stdout, output.stderr);
+        if output.stdout.contains("valet") || output.stderr.contains("valet") {
+            if let Some(valet) = utils::which("valet") {
+                ctx.run_type().execute(valet).arg("install").status_checked()?;
+            }
         }
     }
 
@@ -436,18 +450,15 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
 pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let dotnet = utils::require("dotnet")?;
 
-    let output = Command::new(dotnet).args(&["tool", "list", "--global"]).output()?;
+    let output = Command::new(dotnet)
+        .args(["tool", "list", "--global"])
+        .output_checked_utf8()?;
 
-    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") {
+    if !output.stdout.starts_with("Package Id") {
         return Err(SkipStep(String::from("dotnet did not output packages")).into());
     }
 
-    let mut packages = output.split('\n').skip(2).filter(|line| !line.is_empty()).peekable();
+    let mut packages = output.stdout.lines().skip(2).filter(|line| !line.is_empty()).peekable();
 
     if packages.peek().is_none() {
         return Err(SkipStep(String::from("No dotnet global tools installed")).into());
@@ -459,8 +470,9 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
         let package_name = package.split_whitespace().next().unwrap();
         ctx.run_type()
             .execute("dotnet")
-            .args(&["tool", "update", package_name, "--global"])
-            .check_run()?;
+            .args(["tool", "update", package_name, "--global"])
+            .status_checked()
+            .with_context(|| format!("Failed to update .NET package {package_name}"))?;
     }
 
     Ok(())
@@ -471,26 +483,26 @@ pub fn run_raco_update(run_type: RunType) -> Result<()> {
 
     print_separator("Racket Package Manager");
 
-    run_type.execute(&raco).args(&["pkg", "update", "--all"]).check_run()
+    run_type.execute(raco).args(["pkg", "update", "--all"]).status_checked()
 }
 
 pub fn bin_update(ctx: &ExecutionContext) -> Result<()> {
     let bin = utils::require("bin")?;
 
     print_separator("Bin");
-    ctx.run_type().execute(&bin).arg("update").check_run()
+    ctx.run_type().execute(bin).arg("update").status_checked()
 }
 
 pub fn spicetify_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let spicetify = utils::require("spicetify")?;
 
     print_separator("Spicetify");
-    ctx.run_type().execute(&spicetify).arg("upgrade").check_run()
+    ctx.run_type().execute(spicetify).arg("upgrade").status_checked()
 }
 
 pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
     let gh = utils::require("gh")?;
-    let result = Command::new(&gh).args(&["extensions", "list"]).check_output();
+    let result = Command::new(&gh).args(["extensions", "list"]).output_checked_utf8();
     if result.is_err() {
         debug!("GH result {:?}", result);
         return Err(SkipStep(String::from("GH failed")).into());
@@ -499,8 +511,8 @@ pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
     print_separator("GitHub CLI Extensions");
     ctx.run_type()
         .execute(&gh)
-        .args(&["extension", "upgrade", "--all"])
-        .check_run()
+        .args(["extension", "upgrade", "--all"])
+        .status_checked()
 }
 
 pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
@@ -509,7 +521,7 @@ pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Julia Packages");
 
     ctx.run_type()
-        .execute(&julia)
-        .args(&["-e", "using Pkg; Pkg.update()"])
-        .check_run()
+        .execute(julia)
+        .args(["-e", "using Pkg; Pkg.update()"])
+        .status_checked()
 }

src/steps/git.rs

@@ -3,17 +3,18 @@ use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, Stdio};
 
-use anyhow::{anyhow, Result};
+use color_eyre::eyre::{eyre, Result};
 use console::style;
 use futures::stream::{iter, FuturesUnordered};
 use futures::StreamExt;
 use glob::{glob_with, MatchOptions};
-use log::{debug, error};
 use tokio::process::Command as AsyncCommand;
 use tokio::runtime;
+use tracing::{debug, error};
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
+use crate::executor::RunType;
 use crate::terminal::print_separator;
 use crate::utils::{which, PathExt};
 use crate::{error::SkipStep, terminal::print_warning};
@@ -33,10 +34,10 @@ pub struct Repositories<'a> {
     bad_patterns: Vec<String>,
 }
 
-fn check_output(output: Output) -> Result<()> {
+fn output_checked_utf8(output: Output) -> Result<()> {
     if !(output.status.success()) {
         let stderr = String::from_utf8(output.stderr).unwrap();
-        Err(anyhow!(stderr))
+        Err(eyre!(stderr))
     } else {
         Ok(())
     }
@@ -53,7 +54,7 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
     command
         .stdin(Stdio::null())
         .current_dir(&repo)
-        .args(&["pull", "--ff-only"]);
+        .args(["pull", "--ff-only"]);
 
     if let Some(extra_arguments) = ctx.config().git_arguments() {
         command.args(extra_arguments.split_whitespace());
@@ -61,12 +62,12 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
 
     let pull_output = command.output().await?;
     let submodule_output = AsyncCommand::new(git)
-        .args(&["submodule", "update", "--recursive"])
+        .args(["submodule", "update", "--recursive"])
         .current_dir(&repo)
         .stdin(Stdio::null())
         .output()
         .await?;
-    let result = check_output(pull_output).and_then(|_| check_output(submodule_output));
+    let result = output_checked_utf8(pull_output).and_then(|_| output_checked_utf8(submodule_output));
 
     if let Err(message) = &result {
         println!("{} pulling {}", style("Failed").red().bold(), &repo);
@@ -78,20 +79,17 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
             (Some(before), Some(after)) if before != after => {
                 println!("{} {}:", style("Changed").yellow().bold(), &repo);
 
-                Command::new(&git)
+                Command::new(git)
                     .stdin(Stdio::null())
                     .current_dir(&repo)
-                    .args(&[
+                    .args([
                         "--no-pager",
                         "log",
                         "--no-decorate",
                         "--oneline",
                         &format!("{}..{}", before, after),
                     ])
-                    .spawn()
-                    .unwrap()
-                    .wait()
-                    .unwrap();
+                    .status_checked()?;
                 println!();
             }
             _ => {
@@ -107,9 +105,9 @@ fn get_head_revision(git: &Path, repo: &str) -> Option<String> {
     Command::new(git)
         .stdin(Stdio::null())
         .current_dir(repo)
-        .args(&["rev-parse", "HEAD"])
-        .check_output()
-        .map(|output| output.trim().to_string())
+        .args(["rev-parse", "HEAD"])
+        .output_checked_utf8()
+        .map(|output| output.stdout.trim().to_string())
         .map_err(|e| {
             error!("Error getting revision for {}: {}", repo, e);
 
@@ -122,9 +120,9 @@ fn has_remotes(git: &Path, repo: &str) -> Option<bool> {
     Command::new(git)
         .stdin(Stdio::null())
         .current_dir(repo)
-        .args(&["remote", "show"])
-        .check_output()
-        .map(|output| output.lines().count() > 0)
+        .args(["remote", "show"])
+        .output_checked_utf8()
+        .map(|output| output.stdout.lines().count() > 0)
         .map_err(|e| {
             error!("Error getting remotes for {}: {}", repo, e);
             e
@@ -162,13 +160,13 @@ impl Git {
                 };
 
                 if let Some(git) = &self.git {
-                    let output = Command::new(&git)
+                    let output = Command::new(git)
                         .stdin(Stdio::null())
                         .current_dir(path)
-                        .args(&["rev-parse", "--show-toplevel"])
-                        .check_output()
+                        .args(["rev-parse", "--show-toplevel"])
+                        .output_checked_utf8()
                         .ok()
-                        .map(|output| output.trim().to_string());
+                        .map(|output| output.stdout.trim().to_string());
                     return output;
                 }
             }

src/steps/go.rs

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

src/steps/mod.rs

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

src/steps/node.rs

@@ -1,66 +1,103 @@
-#![allow(unused_imports)]
-
-#[cfg(unix)]
-use std::os::unix::prelude::MetadataExt;
+use std::fmt::Display;
+#[cfg(target_os = "linux")]
+use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-use anyhow::Result;
-use directories::BaseDirs;
-use log::debug;
-#[cfg(unix)]
+use crate::utils::require_option;
+use color_eyre::eyre::Result;
+#[cfg(target_os = "linux")]
 use nix::unistd::Uid;
 use semver::Version;
+use tracing::debug;
 
-use crate::executor::{CommandExt, RunType};
+use crate::command::CommandExt;
+use crate::executor::RunType;
 use crate::terminal::print_separator;
+use crate::utils::sudo;
 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) -> Self {
-        Self { command }
+    fn new(command: PathBuf, variant: NPMVariant) -> Self {
+        Self { command, variant }
+    }
+
+    /// 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 version = self.version()?;
-        let args = if version < Version::new(8, 11, 0) {
-            ["root", "-g"]
-        } else {
-            ["root", "--location=global"]
-        };
+        let args = ["root", self.global_location_arg()];
         Command::new(&self.command)
             .args(args)
-            .check_output()
-            .map(|s| PathBuf::from(s.trim()))
+            .output_checked_utf8()
+            .map(|s| PathBuf::from(s.stdout.trim()))
     }
 
     fn version(&self) -> Result<Version> {
         let version_str = Command::new(&self.command)
-            .args(&["--version"])
-            .check_output()
-            .map(|s| s.trim().to_owned());
+            .args(["--version"])
+            .output_checked_utf8()
+            .map(|s| s.stdout.trim().to_owned());
         Version::parse(&version_str?).map_err(|err| err.into())
     }
 
     fn upgrade(&self, run_type: RunType, use_sudo: bool) -> Result<()> {
-        print_separator("Node Package Manager");
-        let version = self.version()?;
-        let args = if version < Version::new(8, 11, 0) {
-            ["update", "-g"]
-        } else {
-            ["update", "--location=global"]
-        };
+        let args = ["update", self.global_location_arg()];
         if use_sudo {
-            run_type.execute("sudo").args(args).check_run()?;
+            let sudo_option = sudo();
+            let sudo = require_option(sudo_option, String::from("sudo is not installed"))?;
+            run_type.execute(sudo).arg(&self.command).args(args).status_checked()?;
         } else {
-            run_type.execute(&self.command).args(args).check_run()?;
+            run_type.execute(&self.command).args(args).status_checked()?;
         }
 
         Ok(())
@@ -70,7 +107,7 @@ impl NPM {
     pub fn should_use_sudo(&self) -> Result<bool> {
         let npm_root = self.root()?;
         if !npm_root.exists() {
-            return Err(SkipStep(format!("NPM root at {} doesn't exist", npm_root.display(),)).into());
+            return Err(SkipStep(format!("{} root at {} doesn't exist", self.variant, npm_root.display())).into());
         }
 
         let metadata = std::fs::metadata(&npm_root)?;
@@ -93,17 +130,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)
-            .check_output()
-            .map(|s| PathBuf::from(s.trim()))
+            .output_checked_utf8()
+            .map(|s| PathBuf::from(s.stdout.trim()))
     }
 
     fn upgrade(&self, run_type: RunType, use_sudo: bool) -> Result<()> {
-        print_separator("Yarn Package Manager");
         let args = ["global", "upgrade"];
 
         if use_sudo {
@@ -111,9 +158,9 @@ impl Yarn {
                 .execute("sudo")
                 .arg(self.yarn.as_ref().unwrap_or(&self.command))
                 .args(args)
-                .check_run()?;
+                .status_checked()?;
         } else {
-            run_type.execute(&self.command).args(args).check_run()?;
+            run_type.execute(&self.command).args(args).status_checked()?;
         }
 
         Ok(())
@@ -123,7 +170,7 @@ impl Yarn {
     pub fn should_use_sudo(&self) -> Result<bool> {
         let yarn_root = self.root()?;
         if !yarn_root.exists() {
-            return Err(SkipStep(format!("NPM root at {} doesn't exist", yarn_root.display(),)).into());
+            return Err(SkipStep(format!("Yarn root at {} doesn't exist", yarn_root.display(),)).into());
         }
 
         let metadata = std::fs::metadata(&yarn_root)?;
@@ -162,7 +209,9 @@ fn should_use_sudo_yarn(yarn: &Yarn, ctx: &ExecutionContext) -> Result<bool> {
 }
 
 pub fn run_npm_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let npm = require("pnpm").or_else(|_| require("npm")).map(NPM::new)?;
+    let npm = require("npm").map(|b| NPM::new(b, NPMVariant::Npm))?;
+
+    print_separator("Node Package Manager");
 
     #[cfg(target_os = "linux")]
     {
@@ -175,9 +224,32 @@ pub fn run_npm_upgrade(ctx: &ExecutionContext) -> Result<()> {
     }
 }
 
+pub fn run_pnpm_upgrade(ctx: &ExecutionContext) -> Result<()> {
+    let pnpm = require("pnpm").map(|b| NPM::new(b, NPMVariant::Pnpm))?;
+
+    print_separator("Node Package Manager");
+
+    #[cfg(target_os = "linux")]
+    {
+        pnpm.upgrade(ctx.run_type(), should_use_sudo(&pnpm, ctx)?)
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    {
+        pnpm.upgrade(ctx.run_type(), 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.run_type(), should_use_sudo_yarn(&yarn, ctx)?)
@@ -199,5 +271,5 @@ pub fn deno_upgrade(ctx: &ExecutionContext) -> Result<()> {
     }
 
     print_separator("Deno");
-    ctx.run_type().execute(&deno).arg("upgrade").check_run()
+    ctx.run_type().execute(&deno).arg("upgrade").status_checked()
 }

src/steps/os/android.rs

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

src/steps/os/archlinux.rs

@@ -3,9 +3,11 @@ use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use anyhow::Result;
+use color_eyre::eyre;
+use color_eyre::eyre::Result;
 use walkdir::WalkDir;
 
+use crate::command::CommandExt;
 use crate::error::TopgradeError;
 use crate::execution_context::ExecutionContext;
 use crate::utils::which;
@@ -29,11 +31,7 @@ pub struct YayParu {
 impl ArchPackageManager for YayParu {
     fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().show_arch_news() {
-            Command::new(&self.executable)
-                .arg("-Pw")
-                .spawn()
-                .and_then(|mut p| p.wait())
-                .ok();
+            Command::new(&self.executable).arg("-Pw").status_checked()?;
         }
 
         let mut command = ctx.run_type().execute(&self.executable);
@@ -48,7 +46,7 @@ impl ArchPackageManager for YayParu {
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -56,7 +54,7 @@ impl ArchPackageManager for YayParu {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -88,7 +86,7 @@ impl ArchPackageManager for Trizen {
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -96,7 +94,7 @@ impl ArchPackageManager for Trizen {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -126,7 +124,7 @@ impl ArchPackageManager for Pacman {
         if ctx.config().yes(Step::System) {
             command.arg("--noconfirm");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.sudo);
@@ -134,7 +132,7 @@ impl ArchPackageManager for Pacman {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -175,7 +173,7 @@ impl ArchPackageManager for Pikaur {
             command.arg("--noconfirm");
         }
 
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -183,7 +181,7 @@ impl ArchPackageManager for Pikaur {
             if ctx.config().yes(Step::System) {
                 command.arg("--noconfirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
@@ -214,7 +212,7 @@ impl ArchPackageManager for Pamac {
             command.arg("--no-confirm");
         }
 
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
             let mut command = ctx.run_type().execute(&self.executable);
@@ -222,13 +220,60 @@ impl ArchPackageManager for Pamac {
             if ctx.config().yes(Step::System) {
                 command.arg("--no-confirm");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
 
         Ok(())
     }
 }
 
+pub struct Aura {
+    executable: PathBuf,
+    sudo: PathBuf,
+}
+
+impl Aura {
+    fn get(ctx: &ExecutionContext) -> Option<Self> {
+        Some(Self {
+            executable: which("aura")?,
+            sudo: ctx.sudo().to_owned()?,
+        })
+    }
+}
+
+impl ArchPackageManager for Aura {
+    fn upgrade(&self, ctx: &ExecutionContext) -> Result<()> {
+        let sudo = which("sudo").unwrap_or_else(PathBuf::new);
+        let mut aur_update = ctx.run_type().execute(&sudo);
+
+        if sudo.ends_with("sudo") {
+            aur_update
+                .arg(&self.executable)
+                .arg("-Au")
+                .args(ctx.config().aura_aur_arguments().split_whitespace());
+            if ctx.config().yes(Step::System) {
+                aur_update.arg("--noconfirm");
+            }
+
+            aur_update.status_checked()?;
+        } else {
+            println!("Aura requires sudo installed to work with AUR packages")
+        }
+
+        let mut pacman_update = ctx.run_type().execute(&self.sudo);
+        pacman_update
+            .arg(&self.executable)
+            .arg("-Syu")
+            .args(ctx.config().aura_pacman_arguments().split_whitespace());
+        if ctx.config().yes(Step::System) {
+            pacman_update.arg("--noconfirm");
+        }
+        pacman_update.status_checked()?;
+
+        Ok(())
+    }
+}
+
 fn box_package_manager<P: 'static + ArchPackageManager>(package_manager: P) -> Box<dyn ArchPackageManager> {
     Box::new(package_manager) as Box<dyn ArchPackageManager>
 }
@@ -243,19 +288,21 @@ pub fn get_arch_package_manager(ctx: &ExecutionContext) -> Option<Box<dyn ArchPa
             .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(|| Pacman::get(ctx).map(box_package_manager))
+            .or_else(|| Aura::get(ctx).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),
         config::ArchPackageManager::Pacman => Pacman::get(ctx).map(box_package_manager),
         config::ArchPackageManager::Pikaur => Pikaur::get().map(box_package_manager),
         config::ArchPackageManager::Pamac => Pamac::get().map(box_package_manager),
+        config::ArchPackageManager::Aura => Aura::get(ctx).map(box_package_manager),
     }
 }
 
 pub fn upgrade_arch_linux(ctx: &ExecutionContext) -> Result<()> {
     let package_manager =
-        get_arch_package_manager(ctx).ok_or_else(|| anyhow::Error::from(TopgradeError::FailedGettingPackageManager))?;
+        get_arch_package_manager(ctx).ok_or_else(|| eyre::Report::from(TopgradeError::FailedGettingPackageManager))?;
     package_manager.upgrade(ctx)
 }
 

src/steps/os/dragonfly.rs

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

src/steps/os/freebsd.rs

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

src/steps/os/linux.rs

@@ -1,13 +1,14 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use anyhow::Result;
+use color_eyre::eyre::Result;
 use ini::Ini;
-use log::{debug, warn};
+use tracing::{debug, warn};
 
+use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
+use crate::executor::RunType;
 use crate::steps::os::archlinux;
 use crate::terminal::{print_separator, print_warning};
 use crate::utils::{require, require_option, which, PathExt};
@@ -125,13 +126,12 @@ impl Distribution {
 fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
     let sudo = require_option(ctx.sudo().as_ref(), String::from("Sudo required"))?;
 
-    ctx.run_type().execute(sudo).args(&["brl", "update"]);
+    ctx.run_type().execute(sudo).args(["brl", "update"]);
 
-    let output = Command::new("brl").arg("list").output()?;
+    let output = Command::new("brl").arg("list").output_checked_utf8()?;
     debug!("brl list: {:?} {:?}", output.stdout, output.stderr);
 
-    let parsed_output = String::from_utf8(output.stdout).unwrap();
-    for distribution in parsed_output.trim().split('\n') {
+    for distribution in output.stdout.trim().lines() {
         debug!("Bedrock distribution {}", distribution);
         match distribution {
             "arch" => archlinux::upgrade_arch_linux(ctx)?,
@@ -148,7 +148,7 @@ fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn is_wsl() -> Result<bool> {
-    let output = Command::new("uname").arg("-r").check_output()?;
+    let output = Command::new("uname").arg("-r").output_checked_utf8()?.stdout;
     debug!("Uname output: {}", output);
     Ok(output.contains("microsoft"))
 }
@@ -157,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").check_run()?;
-    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").check_run()
+    ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
+    ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
 }
 
 fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
@@ -166,12 +166,12 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
         if ctx.config().rpm_ostree() {
             let mut command = ctx.run_type().execute(ostree);
             command.arg("upgrade");
-            return command.check_run();
+            return command.status_checked();
         }
     };
 
     if let Some(sudo) = &ctx.sudo() {
-        let mut command = ctx.run_type().execute(&sudo);
+        let mut command = ctx.run_type().execute(sudo);
         command
             .arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf()))
             .arg(if ctx.config().redhat_distro_sync() {
@@ -188,7 +188,7 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
             command.arg("-y");
         }
 
-        command.check_run()?;
+        command.status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -198,7 +198,7 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(&sudo).args(&["brl", "update"]).check_run()?;
+        ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -208,12 +208,15 @@ fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(&sudo).args(&["zypper", "refresh"]).check_run()?;
+        ctx.run_type()
+            .execute(sudo)
+            .args(["zypper", "refresh"])
+            .status_checked()?;
 
         ctx.run_type()
-            .execute(&sudo)
-            .args(&["zypper", "dist-upgrade"])
-            .check_run()?;
+            .execute(sudo)
+            .args(["zypper", "dist-upgrade"])
+            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -223,9 +226,9 @@ fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = &ctx.sudo() {
-        let mut command = ctx.run_type().execute(&sudo);
+        let mut command = ctx.run_type().execute(sudo);
 
-        command.arg(which("dnf").unwrap().to_path_buf()).arg("upgrade");
+        command.arg(&which("dnf").unwrap()).arg("upgrade");
 
         if let Some(args) = ctx.config().dnf_arguments() {
             command.args(args.split_whitespace());
@@ -235,7 +238,7 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
             command.arg("-y");
         }
 
-        command.check_run()?;
+        command.status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -245,19 +248,19 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        let mut command = ctx.run_type().execute(&sudo);
-        command.args(&["xbps-install", "-Su", "xbps"]);
+        let mut command = ctx.run_type().execute(sudo);
+        command.args(["xbps-install", "-Su", "xbps"]);
         if ctx.config().yes(Step::System) {
             command.arg("-y");
         }
-        command.check_run()?;
+        command.status_checked()?;
 
-        let mut command = ctx.run_type().execute(&sudo);
-        command.args(&["xbps-install", "-u"]);
+        let mut command = ctx.run_type().execute(sudo);
+        command.args(["xbps-install", "-u"]);
         if ctx.config().yes(Step::System) {
             command.arg("-y");
         }
-        command.check_run()?;
+        command.status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -270,27 +273,31 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
 
     if let Some(sudo) = &ctx.sudo() {
         if let Some(layman) = which("layman") {
-            run_type.execute(&sudo).arg(layman).args(&["-s", "ALL"]).check_run()?;
+            run_type
+                .execute(sudo)
+                .arg(layman)
+                .args(["-s", "ALL"])
+                .status_checked()?;
         }
 
         println!("Syncing portage");
         run_type
-            .execute(&sudo)
-            .args(&["emerge", "--sync"])
+            .execute(sudo)
+            .args(["emerge", "--sync"])
             .args(
                 ctx.config()
                     .emerge_sync_flags()
                     .map(|s| s.split_whitespace().collect())
                     .unwrap_or_else(|| vec!["-q"]),
             )
-            .check_run()?;
+            .status_checked()?;
 
         if let Some(eix_update) = which("eix-update") {
-            run_type.execute(&sudo).arg(eix_update).check_run()?;
+            run_type.execute(sudo).arg(eix_update).status_checked()?;
         }
 
         run_type
-            .execute(&sudo)
+            .execute(sudo)
             .arg("emerge")
             .args(
                 ctx.config()
@@ -298,7 +305,7 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
                     .map(|s| s.split_whitespace().collect())
                     .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
             )
-            .check_run()?;
+            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -314,10 +321,10 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
 
         let is_nala = apt.ends_with("nala");
         if !is_nala {
-            ctx.run_type().execute(&sudo).arg(&apt).arg("update").check_run()?;
+            ctx.run_type().execute(sudo).arg(&apt).arg("update").status_checked()?;
         }
 
-        let mut command = ctx.run_type().execute(&sudo);
+        let mut command = ctx.run_type().execute(sudo);
         command.arg(&apt);
         if is_nala {
             command.arg("upgrade");
@@ -330,17 +337,17 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
         if let Some(args) = ctx.config().apt_arguments() {
             command.args(args.split_whitespace());
         }
-        command.check_run()?;
+        command.status_checked()?;
 
         if ctx.config().cleanup() {
-            ctx.run_type().execute(&sudo).arg(&apt).arg("clean").check_run()?;
+            ctx.run_type().execute(sudo).arg(&apt).arg("clean").status_checked()?;
 
-            let mut command = ctx.run_type().execute(&sudo);
+            let mut command = ctx.run_type().execute(sudo);
             command.arg(&apt).arg("autoremove");
             if ctx.config().yes(Step::System) {
                 command.arg("-y");
             }
-            command.check_run()?;
+            command.status_checked()?;
         }
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -354,11 +361,11 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("deb-get");
 
-    ctx.execute_elevated(&deb_get, false)?.arg("update").check_run()?;
-    ctx.execute_elevated(&deb_get, false)?.arg("upgrade").check_run()?;
+    ctx.execute_elevated(&deb_get, false)?.arg("update").status_checked()?;
+    ctx.execute_elevated(&deb_get, false)?.arg("upgrade").status_checked()?;
 
     if ctx.config().cleanup() {
-        ctx.execute_elevated(&deb_get, false)?.arg("clean").check_run()?;
+        ctx.execute_elevated(&deb_get, false)?.arg("clean").status_checked()?;
     }
 
     Ok(())
@@ -366,7 +373,10 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 
 fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(&sudo).args(&["eopkg", "upgrade"]).check_run()?;
+        ctx.run_type()
+            .execute(sudo)
+            .args(["eopkg", "upgrade"])
+            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -379,10 +389,10 @@ pub fn run_pacdef(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("pacdef");
 
-    ctx.run_type().execute(&pacdef).arg("sync").check_run()?;
+    ctx.run_type().execute(&pacdef).arg("sync").status_checked()?;
 
     println!();
-    ctx.run_type().execute(&pacdef).arg("review").check_run()
+    ctx.run_type().execute(&pacdef).arg("review").status_checked()
 }
 
 pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
@@ -390,13 +400,16 @@ pub fn run_pacstall(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Pacstall");
 
-    ctx.run_type().execute(&pacstall).arg("-U").check_run()?;
-    ctx.run_type().execute(pacstall).arg("-Up").check_run()
+    ctx.run_type().execute(&pacstall).arg("-U").status_checked()?;
+    ctx.run_type().execute(pacstall).arg("-Up").status_checked()
 }
 
 fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = &ctx.sudo() {
-        ctx.run_type().execute(&sudo).args(&["swupd", "update"]).check_run()?;
+        ctx.run_type()
+            .execute(sudo)
+            .args(["swupd", "update"])
+            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -406,29 +419,29 @@ 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"]).check_run()?;
+        ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
 
         ctx.run_type()
-            .execute(&sudo)
-            .args(&["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
-            .check_run()?;
+            .execute(sudo)
+            .args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
+            .status_checked()?;
 
         if ctx.config().cleanup() {
             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"])
-            .check_run()?;
+            .execute(sudo)
+            .args(["cave", "fix-linkage", "-x", "--", "-Cs"])
+            .status_checked()?;
 
         ctx.run_type()
-            .execute(&sudo)
-            .args(&["eclectic", "config", "interactive"])
-            .check_run()?;
+            .execute(sudo)
+            .args(["eclectic", "config", "interactive"])
+            .status_checked()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
     }
@@ -439,15 +452,15 @@ fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
 fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
         ctx.run_type()
-            .execute(&sudo)
-            .args(&["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"])
-            .check_run()?;
+            .execute(sudo)
+            .args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"])
+            .status_checked()?;
 
         if ctx.config().cleanup() {
             ctx.run_type()
-                .execute(&sudo)
-                .args(&["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
-                .check_run()?;
+                .execute(sudo)
+                .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
+                .status_checked()?;
         }
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -465,8 +478,12 @@ 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().execute(&sudo).arg(&pkcon).arg("refresh").check_run()?;
-        let mut exe = ctx.run_type().execute(&sudo);
+        ctx.run_type()
+            .execute(sudo)
+            .arg(&pkcon)
+            .arg("refresh")
+            .status_checked()?;
+        let mut exe = ctx.run_type().execute(sudo);
         let cmd = exe.arg(&pkcon).arg("update");
         if ctx.config().yes(Step::System) {
             cmd.arg("-y");
@@ -475,7 +492,7 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
             cmd.arg("--autoremove");
         }
         // from pkcon man, exit code 5 is 'Nothing useful was done.'
-        cmd.check_run_with_codes(&[5])?;
+        cmd.status_checked_with_codes(&[5])?;
     }
 
     Ok(())
@@ -492,7 +509,7 @@ pub fn run_needrestart(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()>
 
     print_separator("Check for needed restarts");
 
-    run_type.execute(&sudo).arg(needrestart).check_run()?;
+    run_type.execute(sudo).arg(needrestart).status_checked()?;
 
     Ok(())
 }
@@ -509,7 +526,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(&fwupdmgr)
         .arg("refresh")
-        .check_run_with_codes(&[2])?;
+        .status_checked_with_codes(&[2])?;
 
     let mut updmgr = ctx.run_type().execute(&fwupdmgr);
 
@@ -521,7 +538,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
     } else {
         updmgr.arg("get-updates");
     }
-    updmgr.check_run_with_codes(&[2])
+    updmgr.status_checked_with_codes(&[2])
 }
 
 pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
@@ -536,14 +553,14 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
     if yes {
         update_args.push("-y");
     }
-    run_type.execute(&flatpak).args(&update_args).check_run()?;
+    run_type.execute(&flatpak).args(&update_args).status_checked()?;
 
     if cleanup {
         let mut cleanup_args = vec!["uninstall", "--user", "--unused"];
         if yes {
             cleanup_args.push("-y");
         }
-        run_type.execute(&flatpak).args(&cleanup_args).check_run()?;
+        run_type.execute(&flatpak).args(&cleanup_args).status_checked()?;
     }
 
     print_separator("Flatpak System Packages");
@@ -552,26 +569,34 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
         if yes {
             update_args.push("-y");
         }
-        run_type.execute(&sudo).arg(&flatpak).args(&update_args).check_run()?;
+        run_type
+            .execute(sudo)
+            .arg(&flatpak)
+            .args(&update_args)
+            .status_checked()?;
         if cleanup {
             let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
             if yes {
                 cleanup_args.push("-y");
             }
-            run_type.execute(sudo).arg(flatpak).args(&cleanup_args).check_run()?;
+            run_type
+                .execute(sudo)
+                .arg(flatpak)
+                .args(&cleanup_args)
+                .status_checked()?;
         }
     } else {
         let mut update_args = vec!["update", "--system"];
         if yes {
             update_args.push("-y");
         }
-        run_type.execute(&flatpak).args(&update_args).check_run()?;
+        run_type.execute(&flatpak).args(&update_args).status_checked()?;
         if cleanup {
             let mut cleanup_args = vec!["uninstall", "--system", "--unused"];
             if yes {
                 cleanup_args.push("-y");
             }
-            run_type.execute(flatpak).args(&cleanup_args).check_run()?;
+            run_type.execute(flatpak).args(&cleanup_args).status_checked()?;
         }
     }
 
@@ -587,7 +612,7 @@ pub fn run_snap(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     }
     print_separator("snap");
 
-    run_type.execute(sudo).arg(snap).arg("refresh").check_run()
+    run_type.execute(sudo).arg(snap).arg("refresh").status_checked()
 }
 
 pub fn run_pihole_update(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
@@ -597,7 +622,7 @@ pub fn run_pihole_update(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()
 
     print_separator("pihole");
 
-    run_type.execute(sudo).arg(pihole).arg("-up").check_run()
+    run_type.execute(sudo).arg(pihole).arg("-up").status_checked()
 }
 
 pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
@@ -605,10 +630,35 @@ pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("protonup");
 
-    ctx.run_type().execute(protonup).check_run()?;
+    ctx.run_type().execute(protonup).status_checked()?;
     Ok(())
 }
 
+pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
+    let distrobox = require("distrobox")?;
+
+    print_separator("Distrobox");
+    match (
+        match (
+            ctx.run_type().execute(distrobox).arg("upgrade"),
+            ctx.config().distrobox_containers(),
+        ) {
+            (r, Some(c)) => {
+                if c.is_empty() {
+                    return Err(SkipStep("You need to specify at least one container".to_string()).into());
+                }
+                r.args(c)
+            }
+            (r, None) => r.arg("--all"),
+        },
+        ctx.config().distrobox_root(),
+    ) {
+        (r, true) => r.arg("--root"),
+        (r, false) => r,
+    }
+    .status_checked()
+}
+
 pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
     let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
     if ctx.config().yes(Step::ConfigUpdate) {
@@ -617,14 +667,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).check_run()?;
+        ctx.run_type().execute(sudo).arg(etc_update).status_checked()?;
     } else if let Ok(pacdiff) = require("pacdiff") {
         if std::env::var("DIFFPROG").is_err() {
             require("vim")?;
         }
 
         print_separator("Configuration update");
-        ctx.execute_elevated(&pacdiff, false)?.check_run()?;
+        ctx.execute_elevated(&pacdiff, false)?.status_checked()?;
     }
 
     Ok(())

src/steps/os/macos.rs

@@ -1,26 +1,30 @@
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
+use crate::executor::RunType;
 use crate::terminal::{print_separator, prompt_yesno};
-use crate::{error::TopgradeError, utils::require, Step};
-use anyhow::Result;
-use log::debug;
+use crate::{utils::require, Step};
+use color_eyre::eyre::Result;
 use std::fs;
 use std::process::Command;
+use tracing::debug;
 
 pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
     require("port")?;
     let sudo = ctx.sudo().as_ref().unwrap();
     print_separator("MacPorts");
-    ctx.run_type().execute(sudo).args(&["port", "selfupdate"]).check_run()?;
     ctx.run_type()
         .execute(sudo)
-        .args(&["port", "-u", "upgrade", "outdated"])
-        .check_run()?;
+        .args(["port", "selfupdate"])
+        .status_checked()?;
+    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"])
-            .check_run()?;
+            .args(["port", "-N", "reclaim"])
+            .status_checked()?;
     }
 
     Ok(())
@@ -30,7 +34,7 @@ pub fn run_mas(run_type: RunType) -> Result<()> {
     let mas = require("mas")?;
     print_separator("macOS App Store");
 
-    run_type.execute(mas).arg("upgrade").check_run()
+    run_type.execute(mas).arg("upgrade").status_checked()
 }
 
 pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
@@ -52,26 +56,21 @@ 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.check_run()
+    command.status_checked()
 }
 
 fn system_update_available() -> Result<bool> {
-    let output = Command::new("softwareupdate").arg("--list").output()?;
+    let output = Command::new("softwareupdate").arg("--list").output_checked_utf8()?;
+
     debug!("{:?}", output);
 
-    let status = output.status;
-    if !status.success() {
-        return Err(TopgradeError::ProcessFailed(status).into());
-    }
-    let string_output = String::from_utf8(output.stderr)?;
-    debug!("{:?}", string_output);
-    Ok(!string_output.contains("No new software available"))
+    Ok(!output.stderr.contains("No new software available"))
 }
 
 pub fn run_sparkle(ctx: &ExecutionContext) -> Result<()> {
@@ -81,14 +80,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())
-            .check_output();
+            .output_checked_utf8();
         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.spawn()?.wait()?;
+            command.status_checked()?;
         }
     }
     Ok(())

src/steps/os/mod.rs

@@ -10,6 +10,8 @@ pub mod freebsd;
 pub mod linux;
 #[cfg(target_os = "macos")]
 pub mod macos;
+#[cfg(target_os = "openbsd")]
+pub mod openbsd;
 #[cfg(unix)]
 pub mod unix;
 #[cfg(target_os = "windows")]

src/steps/os/openbsd.rs

@@ -0,0 +1,23 @@
+use crate::executor::RunType;
+use crate::terminal::print_separator;
+use crate::utils::require_option;
+use color_eyre::eyre::Result;
+use std::path::PathBuf;
+
+pub fn upgrade_openbsd(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
+    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+    print_separator("OpenBSD Update");
+    run_type
+        .execute(sudo)
+        .args(&["/usr/sbin/sysupgrade", "-n"])
+        .status_checked()
+}
+
+pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
+    let sudo = require_option(sudo, String::from("No sudo detected"))?;
+    print_separator("OpenBSD Packages");
+    run_type
+        .execute(sudo)
+        .args(&["/usr/sbin/pkg_add", "-u"])
+        .status_checked()
+}

src/steps/os/os_release/debian

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

src/steps/os/unix.rs

@@ -1,32 +1,43 @@
-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 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 {
@@ -76,19 +87,37 @@ impl BrewVariant {
     }
 }
 
-pub fn run_fisher(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
+pub fn run_fisher(run_type: RunType) -> Result<()> {
     let fish = require("fish")?;
 
-    if env::var("fisher_path").is_err() {
-        base_dirs
-            .home_dir()
-            .join(".config/fish/functions/fisher.fish")
-            .require()?;
-    }
+    Command::new(&fish)
+        .args(["-c", "type -t fisher"])
+        .output_checked_utf8()
+        .map(|_| ())
+        .map_err(|_| SkipStep("`fisher` is not defined in `fish`".to_owned()))?;
+
+    Command::new(&fish)
+        .args(["-c", "echo \"$__fish_config_dir/fish_plugins\""])
+        .output_checked_utf8()
+        .and_then(|output| Path::new(&output.stdout.trim()).require().map(|_| ()))
+        .map_err(|err| SkipStep(format!("`fish_plugins` path doesn't exist: {err}")))?;
 
     print_separator("Fisher");
 
-    run_type.execute(&fish).args(&["-c", "fisher"]).check_run()
+    let version_str = run_type
+        .execute(&fish)
+        .args(["-c", "fisher --version"])
+        .output_checked_utf8()?
+        .stdout;
+    debug!("Fisher version: {}", version_str);
+
+    if version_str.starts_with("fisher version 3.") {
+        // v3 - see https://github.com/topgrade-rs/topgrade/pull/37#issuecomment-1283844506
+        run_type.execute(&fish).args(["-c", "fisher"]).status_checked()
+    } else {
+        // v4
+        run_type.execute(&fish).args(["-c", "fisher update"]).status_checked()
+    }
 }
 
 pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
@@ -98,8 +127,8 @@ pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
 
     ctx.run_type()
         .execute("bash")
-        .args(&["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
-        .check_run()
+        .args(["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
+        .status_checked()
 }
 
 pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
@@ -111,7 +140,7 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("oh-my-fish");
 
-    ctx.run_type().execute(&fish).args(&["-c", "omf update"]).check_run()
+    ctx.run_type().execute(fish).args(["-c", "omf update"]).status_checked()
 }
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
@@ -122,14 +151,14 @@ pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
-    command.check_run()?;
+    command.status_checked()?;
 
     let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
     command.arg(&pkgin).arg("upgrade");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
-    command.check_run()
+    command.status_checked()
 }
 
 pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
@@ -141,7 +170,27 @@ pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("fish-plug");
 
-    ctx.run_type().execute(&fish).args(&["-c", "plug update"]).check_run()
+    ctx.run_type()
+        .execute(fish)
+        .args(["-c", "plug update"])
+        .status_checked()
+}
+
+/// Upgrades `fundle` and `fundle` plugins.
+///
+/// `fundle` is a package manager for the Fish shell.
+///
+/// See: <https://github.com/danhper/fundle>
+pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
+    let fish = require("fish")?;
+    ctx.base_dirs().home_dir().join(".config/fish/fundle").require()?;
+
+    print_separator("fundle");
+
+    ctx.run_type()
+        .execute(fish)
+        .args(["-c", "fundle self-update && fundle update"])
+        .status_checked()
 }
 
 #[cfg(not(any(target_os = "android", target_os = "macos")))]
@@ -152,7 +201,7 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
         "Desktop doest not appear to be gnome".to_string(),
     )?;
     let output = Command::new("gdbus")
-        .args(&[
+        .args([
             "call",
             "--session",
             "--dest",
@@ -162,10 +211,10 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
             "--method",
             "org.freedesktop.DBus.ListActivatableNames",
         ])
-        .check_output()?;
+        .output_checked_utf8()?;
 
     debug!("Checking for gnome extensions: {}", output);
-    if !output.contains("org.gnome.Shell.Extensions") {
+    if !output.stdout.contains("org.gnome.Shell.Extensions") {
         return Err(SkipStep(String::from("Gnome shell extensions are unregistered in DBus")).into());
     }
 
@@ -173,7 +222,7 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
 
     ctx.run_type()
         .execute(gdbus)
-        .args(&[
+        .args([
             "call",
             "--session",
             "--dest",
@@ -183,9 +232,10 @@ pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
             "--method",
             "org.gnome.Shell.Extensions.CheckForUpdates",
         ])
-        .check_run()
+        .status_checked()
 }
 
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()> {
     #[allow(unused_variables)]
     let binary_name = require(variant.binary_name())?;
@@ -200,18 +250,18 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
     print_separator(variant.step_title());
     let run_type = ctx.run_type();
 
-    variant.execute(run_type).arg("update").check_run()?;
+    variant.execute(run_type).arg("update").status_checked()?;
     variant
         .execute(run_type)
-        .args(&["upgrade", "--ignore-pinned", "--formula"])
-        .check_run()?;
+        .args(["upgrade", "--ignore-pinned", "--formula"])
+        .status_checked()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").check_run()?;
+        variant.execute(run_type).arg("cleanup").status_checked()?;
     }
 
     if ctx.config().brew_autoremove() {
-        variant.execute(run_type).arg("autoremove").check_run()?;
+        variant.execute(run_type).arg("autoremove").status_checked()?;
     }
 
     Ok(())
@@ -228,28 +278,28 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
 
     let cask_upgrade_exists = variant
         .execute(RunType::Wet)
-        .args(&["--repository", "buo/cask-upgrade"])
-        .check_output()
-        .map(|p| Path::new(p.trim()).exists())?;
+        .args(["--repository", "buo/cask-upgrade"])
+        .output_checked_utf8()
+        .map(|p| Path::new(p.stdout.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).check_run()?;
+    variant.execute(run_type).args(&brew_args).status_checked()?;
 
     if ctx.config().cleanup() {
-        variant.execute(run_type).arg("cleanup").check_run()?;
+        variant.execute(run_type).arg("cleanup").status_checked()?;
     }
 
     Ok(())
@@ -260,7 +310,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
 
     let run_type = ctx.run_type();
 
-    let output = Command::new(&guix).arg("pull").check_output();
+    let output = Command::new(&guix).arg("pull").output_checked_utf8();
     debug!("guix pull output: {:?}", output);
     let should_upgrade = output.is_ok();
     debug!("Can Upgrade Guix: {:?}", should_upgrade);
@@ -268,7 +318,7 @@ pub fn run_guix(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Guix");
 
     if should_upgrade {
-        return run_type.execute(&guix).args(&["package", "-u"]).check_run();
+        return run_type.execute(&guix).args(["package", "-u"]).status_checked();
     }
     Err(SkipStep(String::from("Guix Pull Failed, Skipping")).into())
 }
@@ -277,8 +327,14 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     let nix = require("nix")?;
     let nix_channel = require("nix-channel")?;
     let nix_env = require("nix-env")?;
+    let profile_path = match home::home_dir() {
+        Some(home) => Path::new(&home).join(".nix-profile"),
+        None => Path::new("/nix/var/nix/profiles/per-user/default").into(),
+    };
+    debug!("nix profile: {:?}", profile_path);
+    let manifest_json_path = profile_path.join("manifest.json");
 
-    let output = Command::new(&nix_env).args(&["--query", "nix"]).check_output();
+    let output = Command::new(&nix_env).args(["--query", "nix"]).output_checked_utf8();
     debug!("nix-env output: {:?}", output);
     let should_self_upgrade = output.is_ok();
 
@@ -310,14 +366,24 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
 
     if should_self_upgrade {
         if multi_user {
-            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").check_run()?;
+            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").status_checked()?;
         } else {
-            run_type.execute(&nix).arg("upgrade-nix").check_run()?;
+            run_type.execute(&nix).arg("upgrade-nix").status_checked()?;
         }
     }
 
-    run_type.execute(&nix_channel).arg("--update").check_run()?;
-    run_type.execute(&nix_env).arg("--upgrade").check_run()
+    run_type.execute(nix_channel).arg("--update").status_checked()?;
+
+    if std::path::Path::new(&manifest_json_path).exists() {
+        run_type
+            .execute(&nix)
+            .arg("profile")
+            .arg("upgrade")
+            .arg(".*")
+            .status_checked()
+    } else {
+        run_type.execute(&nix_env).arg("--upgrade").status_checked()
+    }
 }
 
 pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
@@ -325,42 +391,40 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("yadm");
 
-    ctx.run_type().execute(&yadm).arg("pull").check_run()
+    ctx.run_type().execute(yadm).arg("pull").status_checked()
 }
 
 pub fn run_asdf(run_type: RunType) -> Result<()> {
     let asdf = require("asdf")?;
 
     print_separator("asdf");
-    let exit_status = run_type.execute(&asdf).arg("update").spawn()?.wait()?;
+    run_type.execute(&asdf).arg("update").status_checked_with_codes(&[42])?;
 
-    if let ExecutorExitStatus::Wet(e) = exit_status {
-        if !(e.success() || e.code().map(|c| c == 42).unwrap_or(false)) {
-            return Err(TopgradeError::ProcessFailed(e).into());
-        }
-    }
-    run_type.execute(&asdf).args(&["plugin", "update", "--all"]).check_run()
+    run_type
+        .execute(&asdf)
+        .args(["plugin", "update", "--all"])
+        .status_checked()
 }
 
 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").check_run()
+    run_type.execute(home_manager).arg("switch").status_checked()
 }
 
 pub fn run_tldr(run_type: RunType) -> Result<()> {
     let tldr = require("tldr")?;
 
     print_separator("TLDR");
-    run_type.execute(&tldr).arg("--update").check_run()
+    run_type.execute(tldr).arg("--update").status_checked()
 }
 
 pub fn run_pearl(run_type: RunType) -> Result<()> {
     let pearl = require("pearl")?;
     print_separator("pearl");
 
-    run_type.execute(&pearl).arg("update").check_run()
+    run_type.execute(pearl).arg("update").status_checked()
 }
 
 pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Result<()> {
@@ -393,31 +457,34 @@ pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Res
         let cmd_selfupdate = format!("source {} && sdk selfupdate", &sdkman_init_path);
         run_type
             .execute(&bash)
-            .args(&["-c", cmd_selfupdate.as_str()])
-            .check_run()?;
+            .args(["-c", cmd_selfupdate.as_str()])
+            .status_checked()?;
     }
 
     let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
-    run_type.execute(&bash).args(&["-c", cmd_update.as_str()]).check_run()?;
+    run_type
+        .execute(&bash)
+        .args(["-c", cmd_update.as_str()])
+        .status_checked()?;
 
     let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
     run_type
         .execute(&bash)
-        .args(&["-c", cmd_upgrade.as_str()])
-        .check_run()?;
+        .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()])
-            .check_run()?;
+            .args(["-c", cmd_flush_archives.as_str()])
+            .status_checked()?;
 
         let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
         run_type
             .execute(&bash)
-            .args(&["-c", cmd_flush_temp.as_str()])
-            .check_run()?;
+            .args(["-c", cmd_flush_temp.as_str()])
+            .status_checked()?;
     }
 
     Ok(())
@@ -428,10 +495,20 @@ pub fn run_bun(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Bun");
 
-    ctx.run_type().execute(&bun).arg("upgrade").check_run()
+    ctx.run_type().execute(bun).arg("upgrade").status_checked()
 }
 
-pub fn reboot() {
-    print!("Rebooting...");
-    Command::new("sudo").arg("reboot").spawn().unwrap().wait().unwrap();
+/// Update dotfiles with `rcm(7)`.
+///
+/// See: <https://github.com/thoughtbot/rcm>
+pub fn run_rcm(ctx: &ExecutionContext) -> Result<()> {
+    let rcup = require("rcup")?;
+
+    print_separator("rcm");
+    ctx.run_type().execute(rcup).arg("-v").status_checked()
+}
+
+pub fn reboot() -> Result<()> {
+    print!("Rebooting...");
+    Command::new("sudo").arg("reboot").status_checked()
 }

src/steps/os/windows.rs

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

src/steps/powershell.rs

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

src/steps/remote/ssh.rs

@@ -1,6 +1,8 @@
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
-use crate::{error::SkipStep, execution_context::ExecutionContext, terminal::print_separator, utils};
+use crate::{
+    command::CommandExt, error::SkipStep, execution_context::ExecutionContext, terminal::print_separator, utils,
+};
 
 fn prepare_async_ssh_command(args: &mut Vec<&str>) {
     args.insert(0, "ssh");
@@ -18,13 +20,13 @@ pub fn ssh_step(ctx: &ExecutionContext, hostname: &str) -> Result<()> {
     }
 
     let env = format!("TOPGRADE_PREFIX={}", hostname);
-    args.extend(&["env", &env, "$SHELL", "-lc", topgrade]);
+    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, &args.join(" "))?;
+            crate::tmux::run_command(ctx, hostname, &shell_words::join(args))?;
             Err(SkipStep(String::from("Remote Topgrade launched in Tmux")).into())
         }
 
@@ -42,11 +44,11 @@ pub fn ssh_step(ctx: &ExecutionContext, hostname: &str) -> Result<()> {
         }
 
         let env = format!("TOPGRADE_PREFIX={}", hostname);
-        args.extend(&["env", &env, "$SHELL", "-lc", topgrade]);
+        args.extend(["env", &env, "$SHELL", "-lc", topgrade]);
 
         print_separator(format!("Remote ({})", hostname));
         println!("Connecting to {}...", hostname);
 
-        ctx.run_type().execute(&ssh).args(&args).check_run()
+        ctx.run_type().execute(ssh).args(&args).status_checked()
     }
 }

src/steps/remote/vagrant.rs

@@ -2,13 +2,13 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::{fmt::Display, rc::Rc, str::FromStr};
 
-use anyhow::Result;
-use log::{debug, error};
+use color_eyre::eyre::Result;
 use regex::Regex;
 use strum::EnumString;
+use tracing::{debug, error};
 
+use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
-use crate::executor::CommandExt;
 use crate::terminal::print_separator;
 use crate::{error::SkipStep, utils, Step};
 
@@ -61,10 +61,11 @@ impl Vagrant {
         let output = Command::new(&self.path)
             .arg("status")
             .current_dir(directory)
-            .check_output()?;
+            .output_checked_utf8()?;
         debug!("Vagrant output in {}: {}", directory, output);
 
         let boxes = output
+            .stdout
             .split('\n')
             .skip(2)
             .take_while(|line| !(line.is_empty() || line.starts_with('\r')))
@@ -113,9 +114,9 @@ impl<'a> TemporaryPowerOn<'a> {
 
         ctx.run_type()
             .execute(vagrant)
-            .args(&[subcommand, &vagrant_box.name])
+            .args([subcommand, &vagrant_box.name])
             .current_dir(vagrant_box.path.clone())
-            .check_run()?;
+            .status_checked()?;
         Ok(TemporaryPowerOn {
             vagrant,
             vagrant_box,
@@ -140,9 +141,9 @@ impl<'a> Drop for TemporaryPowerOn<'a> {
         self.ctx
             .run_type()
             .execute(self.vagrant)
-            .args(&[subcommand, &self.vagrant_box.name])
+            .args([subcommand, &self.vagrant_box.name])
             .current_dir(self.vagrant_box.path.clone())
-            .check_run()
+            .status_checked()
             .ok();
     }
 }
@@ -198,8 +199,8 @@ pub fn topgrade_vagrant_box(ctx: &ExecutionContext, vagrant_box: &VagrantBox) ->
     ctx.run_type()
         .execute(&vagrant.path)
         .current_dir(&vagrant_box.path)
-        .args(&["ssh", "-c", &command])
-        .check_run()
+        .args(["ssh", "-c", &command])
+        .status_checked()
 }
 
 pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
@@ -207,28 +208,31 @@ pub fn upgrade_vagrant_boxes(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Vagrant boxes");
 
     let outdated = Command::new(&vagrant)
-        .args(&["box", "outdated", "--global"])
-        .check_output()?;
+        .args(["box", "outdated", "--global"])
+        .output_checked_utf8()?;
 
     let re = Regex::new(r"\* '(.*?)' for '(.*?)' is outdated").unwrap();
 
     let mut found = false;
-    for ele in re.captures_iter(&outdated) {
+    for ele in re.captures_iter(&outdated.stdout) {
         found = true;
         let _ = ctx
             .run_type()
             .execute(&vagrant)
-            .args(&["box", "update", "--box"])
-            .arg(&ele.get(1).unwrap().as_str())
+            .args(["box", "update", "--box"])
+            .arg(ele.get(1).unwrap().as_str())
             .arg("--provider")
             .arg(ele.get(2).unwrap().as_str())
-            .check_run();
+            .status_checked();
     }
 
     if !found {
         println!("No outdated boxes")
     } else {
-        ctx.run_type().execute(&vagrant).args(&["box", "prune"]).check_run()?;
+        ctx.run_type()
+            .execute(&vagrant)
+            .args(["box", "prune"])
+            .status_checked()?;
     }
 
     Ok(())

src/steps/tmux.rs

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

src/steps/toolbx.rs

@@ -1,17 +1,20 @@
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
+use crate::command::CommandExt;
 use crate::config::Step;
 use crate::terminal::print_separator;
 use crate::{execution_context::ExecutionContext, utils::require};
-use log::debug;
 use std::path::Path;
 use std::{path::PathBuf, process::Command};
+use tracing::debug;
 
 fn list_toolboxes(toolbx: &Path) -> Result<Vec<String>> {
-    let output = Command::new(toolbx).args(&["list", "--containers"]).output()?;
-    let output_str = String::from_utf8(output.stdout)?;
+    let output = Command::new(toolbx)
+        .args(["list", "--containers"])
+        .output_checked_utf8()?;
 
-    let proc: Vec<String> = output_str
+    let proc: Vec<String> = output
+        .stdout
         .lines()
         // Skip the first line since that contains only status information
         .skip(1)
@@ -33,7 +36,7 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
     debug!("Toolboxes to inspect: {:?}", toolboxes);
 
     let mut topgrade_path = PathBuf::from("/run/host");
-    // Path of the running topgrade executable
+    // Path of the running Topgrade executable
     // Skip 1 to eliminate the path root, otherwise push overwrites the path
     topgrade_path.push(std::env::current_exe()?.components().skip(1).collect::<PathBuf>());
     let topgrade_path = topgrade_path.to_str().unwrap();
@@ -54,7 +57,7 @@ pub fn run_toolbx(ctx: &ExecutionContext) -> Result<()> {
             args.push("--yes");
         }
 
-        let _output = ctx.run_type().execute(&toolbx).args(&args).check_run();
+        ctx.run_type().execute(&toolbx).args(&args).status_checked()?;
     }
 
     Ok(())

src/steps/upgrade.vim

@@ -18,11 +18,6 @@ if exists(":PlugUpgrade")
     endif
 endif
 
-if exists(":PackerUpdate")
-    echo "Packer"
-    PackerSync
-endif
-
 if exists("*dein#update()")
     echo "dein#update()"
     call dein#update()
@@ -43,4 +38,18 @@ if exists(":CocUpdateSync")
     CocUpdateSync
 endif
 
-quitall
+" TODO: Should this be after `PackerSync`?
+" Not sure how to sequence this after Packer without doing something weird
+" with that `PackerComplete` autocommand.
+if exists(":TSUpdate")
+    echo "TreeSitter Update"
+    TSUpdate
+endif
+
+if exists(':PackerSync')
+  echo "Packer"
+  autocmd User PackerComplete quitall
+  PackerSync
+else
+  quitall
+endif

src/steps/vim.rs

@@ -1,19 +1,20 @@
+use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
-use anyhow::Result;
+use color_eyre::eyre::Result;
 
-use crate::executor::{CommandExt, ExecutorOutput, RunType};
+use crate::executor::{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::{Path, PathBuf};
+use std::path::PathBuf;
 use std::{
     io::{self, Write},
     process::Command,
 };
+use tracing::debug;
 
 const UPGRADE_VIM: &str = include_str!("upgrade.vim");
 
@@ -40,19 +41,14 @@ fn nvimrc(base_dirs: &BaseDirs) -> Result<PathBuf> {
         .or_else(|_| base_dir.join("nvim/init.lua").require())
 }
 
-fn upgrade(vim: &Path, vimrc: &Path, ctx: &ExecutionContext) -> Result<()> {
+fn upgrade_script() -> Result<tempfile::NamedTempFile> {
     let mut tempfile = tempfile::NamedTempFile::new()?;
     tempfile.write_all(UPGRADE_VIM.replace('\r', "").as_bytes())?;
     debug!("Wrote vim script to {:?}", tempfile.path());
+    Ok(tempfile)
+}
 
-    let mut command = ctx.run_type().execute(&vim);
-
-    command
-        .args(&["-u"])
-        .arg(vimrc)
-        .args(&["-U", "NONE", "-V1", "-nNesS"])
-        .arg(tempfile.path());
-
+fn upgrade(command: &mut Executor, ctx: &ExecutionContext) -> Result<()> {
     if ctx.config().force_vim_plug_update() {
         command.env("TOPGRADE_FORCE_PLUGUPDATE", "true");
     }
@@ -68,7 +64,7 @@ fn upgrade(vim: &Path, vimrc: &Path, ctx: &ExecutionContext) -> Result<()> {
         }
 
         if !status.success() {
-            return Err(TopgradeError::ProcessFailed(status).into());
+            return Err(TopgradeError::ProcessFailed(command.get_program(), status).into());
         } else {
             println!("Plugins upgraded")
         }
@@ -88,23 +84,23 @@ pub fn upgrade_ultimate_vimrc(ctx: &ExecutionContext) -> Result<()> {
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
-        .args(&["reset", "--hard"])
-        .check_run()?;
+        .args(["reset", "--hard"])
+        .status_checked()?;
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
-        .args(&["clean", "-d", "--force"])
-        .check_run()?;
+        .args(["clean", "-d", "--force"])
+        .status_checked()?;
     ctx.run_type()
         .execute(&git)
         .current_dir(&config_dir)
-        .args(&["pull", "--rebase"])
-        .check_run()?;
+        .args(["pull", "--rebase"])
+        .status_checked()?;
     ctx.run_type()
         .execute(python)
         .current_dir(config_dir)
         .arg(update_plugins)
-        .check_run()?;
+        .status_checked()?;
 
     Ok(())
 }
@@ -112,15 +108,23 @@ 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").check_output()?;
-    if !output.starts_with("VIM") {
-        return Err(SkipStep(String::from("vim binary might by actually nvim")).into());
+    let output = Command::new(&vim).arg("--version").output_checked_utf8()?;
+    if !output.stdout.starts_with("VIM") {
+        return Err(SkipStep(String::from("vim binary might be actually nvim")).into());
     }
 
     let vimrc = vimrc(base_dirs)?;
 
     print_separator("Vim");
-    upgrade(&vim, &vimrc, ctx)
+    upgrade(
+        ctx.run_type()
+            .execute(&vim)
+            .args(["-u"])
+            .arg(vimrc)
+            .args(["-U", "NONE", "-V1", "-nNesS"])
+            .arg(upgrade_script()?.path()),
+        ctx,
+    )
 }
 
 pub fn upgrade_neovim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()> {
@@ -128,7 +132,15 @@ pub fn upgrade_neovim(base_dirs: &BaseDirs, ctx: &ExecutionContext) -> Result<()
     let nvimrc = nvimrc(base_dirs)?;
 
     print_separator("Neovim");
-    upgrade(&nvim, &nvimrc, ctx)
+    upgrade(
+        ctx.run_type()
+            .execute(nvim)
+            .args(["-u"])
+            .arg(nvimrc)
+            .args(["--headless", "-V1", "-nS"])
+            .arg(upgrade_script()?.path()),
+        ctx,
+    )
 }
 
 pub fn run_voom(_base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -136,5 +148,5 @@ pub fn run_voom(_base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     print_separator("voom");
 
-    run_type.execute(voom).arg("update").check_run()
+    run_type.execute(voom).arg("update").status_checked()
 }

src/steps/zsh.rs

@@ -1,16 +1,19 @@
-use crate::execution_context::ExecutionContext;
-use crate::executor::{CommandExt, RunType};
-use crate::git::Repositories;
-use crate::terminal::print_separator;
-use crate::utils::{require, PathExt};
-use anyhow::Result;
-use directories::BaseDirs;
-use log::debug;
 use std::env;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+
+use 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::git::Repositories;
+use crate::terminal::print_separator;
+use crate::utils::{require, PathExt};
+
 pub fn run_zr(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     let zsh = require("zsh")?;
 
@@ -19,7 +22,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()]).check_run()
+    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn zshrc(base_dirs: &BaseDirs) -> PathBuf {
@@ -34,7 +37,7 @@ pub fn run_antibody(run_type: RunType) -> Result<()> {
 
     print_separator("antibody");
 
-    run_type.execute(antibody).arg("update").check_run()
+    run_type.execute(antibody).arg("update").status_checked()
 }
 
 pub fn run_antigen(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -47,8 +50,8 @@ 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()]).check_run()
+    let cmd = format!("source {} && (antigen selfupdate ; antigen update)", zshrc.display());
+    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn run_zgenom(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -62,7 +65,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()]).check_run()
+    run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn run_zplug(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -76,7 +79,10 @@ pub fn run_zplug(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     print_separator("zplug");
 
-    run_type.execute(zsh).args(&["-i", "-c", "zplug update"]).check_run()
+    run_type
+        .execute(zsh)
+        .args(["-i", "-c", "zplug update"])
+        .status_checked()
 }
 
 pub fn run_zinit(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -91,7 +97,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()]).check_run()
+    run_type.execute(zsh).args(["-i", "-c", cmd.as_str()]).status_checked()
 }
 
 pub fn run_zi(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -103,7 +109,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]).check_run()
+    run_type.execute(zsh).args(["-i", "-c", &cmd]).status_checked()
 }
 
 pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
@@ -111,8 +117,10 @@ pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
     env::var("ZIM_HOME")
         .or_else(|_| {
             Command::new("zsh")
-                .args(&["-c", "[[ -n ${ZIM_HOME} ]] && print -n ${ZIM_HOME}"])
-                .check_output()
+                // TODO: Should these be quoted?
+                .args(["-c", "[[ -n ${ZIM_HOME} ]] && print -n ${ZIM_HOME}"])
+                .output_checked_utf8()
+                .map(|o| o.stdout)
         })
         .map(PathBuf::from)
         .unwrap_or_else(|_| base_dirs.home_dir().join(".zim"))
@@ -122,8 +130,8 @@ pub fn run_zim(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     run_type
         .execute(zsh)
-        .args(&["-i", "-c", "zimfw upgrade && zimfw update"])
-        .check_run()
+        .args(["-i", "-c", "zimfw upgrade && zimfw update"])
+        .status_checked()
 }
 
 pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
@@ -135,8 +143,10 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
     let custom_dir = env::var::<_>("ZSH_CUSTOM")
         .or_else(|_| {
             Command::new("zsh")
-                .args(&["-c", "test $ZSH_CUSTOM && echo -n $ZSH_CUSTOM"])
-                .check_output()
+                // TODO: Should these be quoted?
+                .args(["-c", "test $ZSH_CUSTOM && echo -n $ZSH_CUSTOM"])
+                .output_checked_utf8()
+                .map(|o| o.stdout)
         })
         .map(PathBuf::from)
         .unwrap_or_else(|e| {
@@ -168,5 +178,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"))
-        .check_run_with_codes(&[80])
+        .status_checked_with_codes(&[80])
 }

src/terminal.rs

@@ -8,14 +8,17 @@ use std::sync::Mutex;
 use std::time::Duration;
 
 use chrono::{Local, Timelike};
+use color_eyre::eyre;
+use color_eyre::eyre::Context;
 use console::{style, Key, Term};
 use lazy_static::lazy_static;
-use log::{debug, error};
 #[cfg(target_os = "macos")]
 use notify_rust::{Notification, Timeout};
+use tracing::{debug, error};
 #[cfg(windows)]
 use which_crate::which;
 
+use crate::command::CommandExt;
 use crate::report::StepResult;
 #[cfg(target_os = "linux")]
 use crate::utils::which;
@@ -34,13 +37,8 @@ pub fn shell() -> &'static str {
     which("pwsh").map(|_| "pwsh").unwrap_or("powershell")
 }
 
-pub fn run_shell() {
-    Command::new(shell())
-        .env("IN_TOPGRADE", "1")
-        .spawn()
-        .unwrap()
-        .wait()
-        .unwrap();
+pub fn run_shell() -> eyre::Result<()> {
+    Command::new(shell()).env("IN_TOPGRADE", "1").status_checked()
 }
 
 struct Terminal {
@@ -104,9 +102,11 @@ impl Terminal {
                         command.arg("-t");
                         command.arg(format!("{}", timeout.as_millis()));
                     }
-                    command.args(&["-a", "Topgrade", "Topgrade"]);
+                    command.args(["-a", "Topgrade", "Topgrade"]);
                     command.arg(message.as_ref());
-                    command.output().ok();
+                    if let Err(err) = command.output_checked() {
+                        tracing::error!("{err:?}");
+                    }
                 }
             }
         }
@@ -163,6 +163,19 @@ impl Terminal {
         }
     }
 
+    #[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!("{} failed:", key)).red().bold(),
+                message
+            ))
+            .ok();
+    }
+
     #[allow(dead_code)]
     fn print_warning<P: AsRef<str>>(&mut self, message: P) {
         let message = message.as_ref();
@@ -214,7 +227,7 @@ impl Terminal {
         }
     }
     #[allow(unused_variables)]
-    fn should_retry(&mut self, interrupted: bool, step_name: &str) -> Result<bool, io::Error> {
+    fn should_retry(&mut self, interrupted: bool, step_name: &str) -> eyre::Result<bool> {
         if self.width.is_none() {
             return Ok(false);
         }
@@ -223,31 +236,33 @@ impl Terminal {
             self.term.set_title("Topgrade - Awaiting user");
         }
 
-        self.notify_desktop(&format!("{} failed", step_name), None);
+        self.notify_desktop(format!("{} failed", step_name), None);
 
-        self.term
-            .write_fmt(format_args!(
-                "\n{}",
-                style(format!("{}Retry? (y)es/(N)o/(s)hell/(q)uit", self.prefix))
-                    .yellow()
-                    .bold()
-            ))
-            .ok();
+        let prompt_inner = style(format!("{}Retry? (y)es/(N)o/(s)hell/(q)uit", self.prefix))
+            .yellow()
+            .bold();
+
+        self.term.write_fmt(format_args!("\n{}", prompt_inner)).ok();
 
         let answer = loop {
             match self.term.read_key() {
                 Ok(Key::Char('y')) | Ok(Key::Char('Y')) => break Ok(true),
                 Ok(Key::Char('s')) | Ok(Key::Char('S')) => {
                     println!("\n\nDropping you to shell. Fix what you need and then exit the shell.\n");
-                    run_shell();
-                    break Ok(true);
+                    if let Err(err) = run_shell().context("Failed to run shell") {
+                        self.term.write_fmt(format_args!("{err:?}\n{}", prompt_inner)).ok();
+                    } else {
+                        break Ok(true);
+                    }
                 }
                 Ok(Key::Char('n')) | Ok(Key::Char('N')) | Ok(Key::Enter) => break Ok(false),
                 Err(e) => {
                     error!("Error reading from terminal: {}", e);
                     break Ok(false);
                 }
-                Ok(Key::Char('q')) | Ok(Key::Char('Q')) => return Err(io::Error::from(io::ErrorKind::Interrupted)),
+                Ok(Key::Char('q')) | Ok(Key::Char('Q')) => {
+                    return Err(io::Error::from(io::ErrorKind::Interrupted)).context("Quit from user input")
+                }
                 _ => (),
             }
         };
@@ -268,7 +283,7 @@ impl Default for Terminal {
     }
 }
 
-pub fn should_retry(interrupted: bool, step_name: &str) -> Result<bool, io::Error> {
+pub fn should_retry(interrupted: bool, step_name: &str) -> eyre::Result<bool> {
     TERMINAL.lock().unwrap().should_retry(interrupted, step_name)
 }
 
@@ -276,6 +291,11 @@ pub fn print_separator<P: AsRef<str>>(message: P) {
     TERMINAL.lock().unwrap().print_separator(message)
 }
 
+#[allow(dead_code)]
+pub fn print_error<P: AsRef<str>, Q: AsRef<str>>(key: Q, message: P) {
+    TERMINAL.lock().unwrap().print_error(key, message)
+}
+
 #[allow(dead_code)]
 pub fn print_warning<P: AsRef<str>>(message: P) {
     TERMINAL.lock().unwrap().print_warning(message)

src/utils.rs

@@ -1,46 +1,11 @@
-use crate::error::{SkipStep, TopgradeError};
-use anyhow::Result;
+use crate::error::SkipStep;
+use color_eyre::eyre::Result;
 
-use log::{debug, error};
 use std::env;
 use std::ffi::OsStr;
 use std::fmt::Debug;
 use std::path::{Path, PathBuf};
-use std::process::{ExitStatus, Output};
-
-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())
-        }
-    }
-}
+use tracing::{debug, error};
 
 pub trait PathExt
 where
@@ -142,3 +107,55 @@ 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

@@ -2,7 +2,7 @@
 .TH "topgrade" "8"
 .SH NAME
 .PP
-topgrade \- upgrade everything
+Topgrade \- Upgrade everything
 .SH SYNOPSIS
 .PP
 topgrade [\fIoptions\f[]]
@@ -10,7 +10,7 @@ topgrade [\fIoptions\f[]]
 .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.
+To remedy this, \fBTopgrade\fR detects which tools you use and runs the appropriate commands to update them.
 .SH OPTIONS
 .TP
 .B \-\-only <only>
@@ -75,6 +75,6 @@ A list of steps must be provided as a list of separate arguments, i.e. 'topgrade
 .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.
+\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>