chore: release v13.0.0 (#579)

Bumps [webpki](https://github.com/briansmith/webpki) from 0.22.1 to 0.22.2.
- [Commits](https://github.com/briansmith/webpki/commits)

---
updated-dependencies:
- dependency-name: webpki
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -46,6 +46,18 @@ If you know the possible cause of the issue, please tell us.
 Execute the erroneous command directly to see if the problem persists
 -->
 - [ ] Yes
+- [ ] No
+
+## Did you run topgrade through `Remote Execution`
+
+- [ ] Yes
+- [ ] No
+
+If yes, does the issue still occur when you run topgrade directlly in your
+remote host
+
+- [ ] Yes
+- [ ] No
 
 ## Configuration file (Optional)
 <!-- 

.github/PULL_REQUEST_TEMPLATE.md

@@ -7,7 +7,12 @@
 - [ ] The code passes clippy (`cargo clippy`)
 - [ ] The code passes tests (`cargo test`)
 - [ ] *Optional:* I have tested the code myself
-    - [ ] I also tested that Topgrade skips the step where needed
+ 
+## For new steps
+- [ ] *Optional:* Topgrade skips this step where needed
+- [ ] *Optional:* The `--dry-run` option works with this step
+- [ ] *Optional:* The `--yes` option works with this step if it is supported by 
+  the underlying command
 
 If you developed a feature or a bug fix for someone else and you do not have the
 means to test it, please tag this person here.

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

@@ -7,7 +7,7 @@ on:
 name: CI
 
 env:
-  RUST_VER: '1.71.0'
+  RUST_VER: 'stable'
   CROSS_VER: '0.2.5'
   CARGO_NET_RETRY: 3
 

Cargo.lock

@@ -1657,9 +1657,9 @@ checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
 
 [[package]]
 name = "rustix"
-version = "0.37.20"
+version = "0.37.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b96e891d04aa506a6d1f318d2771bcb1c7dfda84e126660ace067c9b474bb2c0"
+checksum = "d4eb579851244c2c03e7c24f501c3432bed80b8f720af1d6e5b0e0f01555a035"
 dependencies = [
  "bitflags",
  "errno",
@@ -1692,9 +1692,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.100.1"
+version = "0.100.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6207cd5ed3d8dca7816f8f3725513a34609c0c765bf652b8c3cb4cfd87db46b"
+checksum = "e98ff011474fa39949b7e5c0428f9b4937eda7da7848bbb947786b7be0b27dab"
 dependencies = [
  "ring",
  "untrusted",
@@ -2164,7 +2164,7 @@ dependencies = [
 
 [[package]]
 name = "topgrade"
-version = "12.0.2"
+version = "13.0.0"
 dependencies = [
  "cfg-if",
  "chrono",
@@ -2477,9 +2477,9 @@ dependencies = [
 
 [[package]]
 name = "webpki"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+checksum = "07ecc0cd7cac091bf682ec5efa18b1cff79d617b84181f38b3951dbe135f607f"
 dependencies = [
  "ring",
  "untrusted",

Cargo.toml

@@ -5,7 +5,7 @@ categories = ["os"]
 keywords = ["upgrade", "update"]
 license = "GPL-3.0"
 repository = "https://github.com/topgrade-rs/topgrade"
-version = "12.0.2"
+version = "13.0.0"
 authors = ["Roey Darwish Dror <roey.ghost@gmail.com>", "Thomas Schönauer <t.schoenauer@hgs-wt.at>"]
 exclude = ["doc/screenshot.gif"]
 edition = "2021"

README.md

@@ -8,13 +8,9 @@
   <a href="https://aur.archlinux.org/packages/topgrade"><img alt="AUR" src="https://img.shields.io/aur/version/topgrade.svg"></a>
   <a href="https://formulae.brew.sh/formula/topgrade"><img alt="Homebrew" src="https://img.shields.io/homebrew/v/topgrade.svg"></a>
 
-  <img alt="Demo" src="doc/screenshot.gif" width="550px">
+  <img alt="Demo" src="doc/topgrade_demo.gif">
 </div>
 
-## Maintainers Wanted
-
-I currently have not enough time to maintain this project on the level required and which the project deserves. For this reason I'm asking the community to help supporting the project, to help and work on resolving issues and create new features. Thanks for all your help.
-
 
 ## Introduction
 

config.example.toml

@@ -2,168 +2,239 @@
 # [include] sections are processed in the order you write them
 # Files in $CONFIG_DIR/topgrade.d/ are automatically included before this file
 [include]
-#paths = ["/etc/topgrade.toml"]
+# paths = ["/etc/topgrade.toml"]
+
 
 [misc]
-# Don't ask for confirmations
-#assume_yes = true
-
-# Disable specific steps - same options as the command line flag
-#disable = ["system", "emacs"]
-
-# Ignore failures for these steps
-#ignore_failures = ["powershell"]
-
-# Run specific steps - same options as the command line flag
-#only = ["system", "emacs"]
-
-# Do not ask to retry failed steps (default: false)
-#no_retry = true
-
-# Sudo command to be used
-#sudo_command = "sudo"
-
 # Run `sudo -v` to cache credentials at the start of the run
 # This avoids a blocking password prompt in the middle of an unattended run
-#pre_sudo = false
+# (default: false)
+# pre_sudo = false
 
-# Run inside tmux
+# Sudo command to be used
-#run_in_tmux = true
+# sudo_command = "sudo"
+
+# Disable specific steps - same options as the command line flag
+# disable = ["system", "emacs"]
+
+# Ignore failures for these steps
+# ignore_failures = ["powershell"]
 
 # List of remote machines with Topgrade installed on them
-#remote_topgrades = ["toothless", "pi", "parnas"]
+# remote_topgrades = ["toothless", "pi", "parnas"]
-
-# Arguments to pass to SSH when upgrading remote systems
-#ssh_arguments = "-o ConnectTimeout=2"
 
 # Path to Topgrade executable on remote machines
-#remote_topgrade_path = ".cargo/bin/topgrade"
+# remote_topgrade_path = ".cargo/bin/topgrade"
+
+# Arguments to pass to SSH when upgrading remote systems
+# ssh_arguments = "-o ConnectTimeout=2"
 
 # Arguments to pass tmux when pulling Repositories
-#tmux_arguments = "-S /var/tmux.sock"
+# tmux_arguments = "-S /var/tmux.sock"
 
-# Do not set the terminal title
+# Do not set the terminal title (dfault: true)
-#set_title = false
+# set_title = true
 
-# Display the time in step titles
+# Display the time in step titles (default: true)
 # display_time = true
 
-# Cleanup temporary or old files
+# Don't ask for confirmations (no default value)
-#cleanup = true
+# assume_yes = true
 
-# Skip sending a notification at the end of a run
+# Do not ask to retry failed steps (default: false)
-#skip_notify = true
+# no_retry = true
 
-# Whether to self update (this is ignored if the binary has been built without self update support, available also via setting the environment variable TOPGRADE_NO_SELF_UPGRADE)
+# Run inside tmux (default: false)
-#no_self_update = true
+# run_in_tmux = true
+
+# Cleanup temporary or old files (default: false)
+# cleanup = true
+
+# Send a notification for every step (default: false)
+# notify_each_step = false
+
+# Skip sending a notification at the end of a run (default: false)
+# skip_notify = true
+
+# The Bash-it branch to update (default: "stable")
+# bashit_branch = "stable"
+
+# Run specific steps - same options as the command line flag
+# only = ["system", "emacs"]
+
+# Whether to self update
+#
+# this will be ignored if the binary is built without self update support
+#
+# available also via setting the environment variable TOPGRADE_NO_SELF_UPGRADE)
+# no_self_update = true
+
+# Extra tracing filter directives
+# These are prepended to the `--log-filter` argument
+# See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives
+# log_filters = ["topgrade::command=debug", "warn"]
 
-# Extra Home Manager arguments
-#home_manager_arguments = ["--flake", "file"]
 
 # Commands to run before anything
 [pre_commands]
-#"Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
+# "Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
+
 
 # Commands to run after anything
 [post_commands]
-#"Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
+# "Emacs Snapshot" = "rm -rf ~/.emacs.d/elpa.bak && cp -rl ~/.emacs.d/elpa ~/.emacs.d/elpa.bak"
+
 
 # Custom commands
 [commands]
-#"Python Environment" = "~/dev/.env/bin/pip install -i https://pypi.python.org/simple -U --upgrade-strategy eager jupyter"
+# "Python Environment" = "~/dev/.env/bin/pip install -i https://pypi.python.org/simple -U --upgrade-strategy eager jupyter"
-#"Custom command using interactive shell (unix)" = "-i vim_upgrade"
+# "Custom command using interactive shell (unix)" = "-i vim_upgrade"
+
 
 [python]
-#enable_pip_review = true                         ###disabled by default
+# enable_pip_review = true                         ###disabled by default
-#enable_pip_review_local = true                   ###disabled by default
+# enable_pip_review_local = true                   ###disabled by default
-#enable_pipupgrade = true                         ###disabled by default
+# enable_pipupgrade = true                         ###disabled by default
-#pipupgrade_arguments = "-y -u --pip-path pip"    ###disabled by default
+# pipupgrade_arguments = "-y -u --pip-path pip"    ###disabled by default
+
 
 [composer]
-#self_update = true
+# self_update = true
+
 
 [brew]
-#greedy_cask = true
+# greedy_cask = true
-#autoremove = true
+# autoremove = true
+
 
 [linux]
-# Arch Package Manager to use. Allowed values: autodetect, aura, garuda_update, pacman, pamac, paru, pikaur, trizen, yay.
+# Arch Package Manager to use.
-#arch_package_manager = "pacman"
+# Allowed values:
+#   autodetect, aura, garuda_update, pacman, pamac, paru, pikaur, trizen, yay
+# arch_package_manager = "pacman"
+
 # Arguments to pass yay (or paru) when updating packages
-#yay_arguments = "--nodevel"
+# yay_arguments = "--nodevel"
+
 # Arguments to pass dnf when updating packages
-#dnf_arguments = "--refresh"
+# dnf_arguments = "--refresh"
-#aura_aur_arguments = "-kx"
+
-#aura_pacman_arguments = ""
+# aura_aur_arguments = "-kx"
-#garuda_update_arguments = ""
+
-#show_arch_news = true
+# aura_pacman_arguments = ""
-#trizen_arguments = "--devel"
+# garuda_update_arguments = ""
-#pikaur_arguments = ""
+
-#pamac_arguments = "--no-devel"
+# show_arch_news = true
-#enable_tlmgr = true
+
-#emerge_sync_flags = "-q"
+# trizen_arguments = "--devel"
-#emerge_update_flags = "-uDNa --with-bdeps=y world"
+
-#redhat_distro_sync = false
+# pikaur_arguments = ""
-#suse_dup = false
+
-#rpm_ostree = false
+# pamac_arguments = "--no-devel"
-#nix_arguments = "--flake"
+
+# enable_tlmgr = true
+
+# emerge_sync_flags = "-q"
+
+# emerge_update_flags = "-uDNa --with-bdeps=y world"
+
+# redhat_distro_sync = false
+
+# suse_dup = false
+
+# rpm_ostree = false
+
+# nix_arguments = "--flake"
+
+# nix_env_arguments = "--prebuilt-only"
+
+# Extra Home Manager arguments
+# home_manager_arguments = ["--flake", "file"]
+
 
 [git]
-#max_concurrency = 5
+# max_concurrency = 5
-# Additional git repositories to pull
+
-#repos = [
+# Git repositories that you want to pull and push
-#    "~/src/*/",
+# repos = [
-#    "~/.config/something"
+#     "~/src/*/",
-#]
+#     "~/.config/something"
+# ]
+
+# Repositories that you only want to pull
+# pull_only_repos = [
+#     "~/.config/something_else"
+# ]
+
+# Repositories that you only want to push
+# push_only_repos = [
+#     "~/src/*/",
+#     "~/.config/something_third"
+# ]
 
 # Don't pull the predefined git repos
-#pull_predefined = false
+# pull_predefined = false
+
+# Arguments to pass Git when pulling repositories
+# pull_arguments = "--rebase --autostash"
+
+# Arguments to pass Git when pushing repositories
+# push_arguments = "--all"
 
-# Arguments to pass Git when pulling Repositories
-#arguments = "--rebase --autostash"
 
 [windows]
 # Manually select Windows updates
-#accept_all_updates = false
+# accept_all_updates = false
-#open_remotes_in_new_terminal = true
+
-#wsl_update_pre_release = true
+# open_remotes_in_new_terminal = true
-#wsl_update_use_web_download = true
+
+# wsl_update_pre_release = true
+
+# wsl_update_use_web_download = true
 
 # Causes Topgrade to rename itself during the run to allow package managers
 # to upgrade it. Use this only if you installed Topgrade by using a package
 # manager such as Scoop or Cargo
-#self_rename = true
+# self_rename = true
+
 
 [npm]
 # Use sudo if the NPM directory isn't owned by the current user
-#use_sudo = true
+# use_sudo = true
+
 
 [yarn]
 # Run `yarn global upgrade` with `sudo`
-#use_sudo = true
+# use_sudo = true
+
 
 [vim]
 # For `vim-plug`, execute `PlugUpdate!` instead of `PlugUpdate`
-#force_plug_update = true
+# force_plug_update = true
+
 
 [firmware]
 # Offer to update firmware; if false just check for and display available updates
-#upgrade = true
+# upgrade = true
+
 
 [vagrant]
 # Vagrant directories
-#directories = []
+# directories = []
 
 # power on vagrant boxes if needed
-#power_on = true
+# power_on = true
 
 # Always suspend vagrant boxes instead of powering off
-#always_suspend = true
+# always_suspend = true
+
 
 [flatpak]
 # Use sudo for updating the system-wide installation
-#use_sudo = true
+# use_sudo = true
+
 
 [distrobox]
-#use_root = false
+# use_root = false
-#containers = ["archlinux-latest"]
+
+# containers = ["archlinux-latest"]

src/command.rs

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

src/config.rs

@@ -17,17 +17,19 @@ use regex::Regex;
 use regex_split::RegexSplit;
 use serde::Deserialize;
 use strum::{EnumIter, EnumString, EnumVariantNames, IntoEnumIterator};
-use tracing::debug;
 use which_crate::which;
 
+use super::utils::{editor, hostname};
 use crate::command::CommandExt;
 use crate::sudo::SudoKind;
 use crate::utils::string_prepend_str;
-
+use tracing::{debug, error};
-use super::utils::{editor, hostname};
 
 pub static EXAMPLE_CONFIG: &str = include_str!("../config.example.toml");
 
+/// Topgrade's default log level.
+pub const DEFAULT_LOG_LEVEL: &str = "warn";
+
 #[allow(unused_macros)]
 macro_rules! str_value {
     ($section:ident, $value:ident) => {
@@ -40,57 +42,6 @@ macro_rules! str_value {
     };
 }
 
-macro_rules! check_deprecated {
-    ($config:expr, $old:ident, $section:ident, $new:ident) => {
-        if $config.$old.is_some() {
-            println!(concat!(
-                "'",
-                stringify!($old),
-                "' configuration option is deprecated. Rename it to '",
-                stringify!($new),
-                "' and put it under the section [",
-                stringify!($section),
-                "]",
-            ));
-        }
-    };
-}
-
-/// Get a deprecated option moved from a section to another
-macro_rules! get_deprecated_moved_opt {
-    ($old_section:expr, $old:ident, $new_section:expr, $new:ident) => {{
-        if let Some(old_section) = &$old_section {
-            if old_section.$old.is_some() {
-                return &old_section.$old;
-            }
-        }
-
-        if let Some(new_section) = &$new_section {
-            return &new_section.$new;
-        }
-
-        return &None;
-    }};
-}
-
-macro_rules! get_deprecated_moved_or_default_to {
-    ($old_section:expr, $old:ident, $new_section:expr, $new:ident, $default_ret:ident) => {{
-        if let Some(old_section) = &$old_section {
-            if let Some(old) = old_section.$old {
-                return old;
-            }
-        }
-
-        if let Some(new_section) = &$new_section {
-            if let Some(new) = new_section.$new {
-                return new;
-            }
-        }
-
-        return $default_ret;
-    }};
-}
-
 pub type Commands = BTreeMap<String, String>;
 
 #[derive(ArgEnum, EnumString, EnumVariantNames, Debug, Clone, PartialEq, Eq, Deserialize, EnumIter, Copy)]
@@ -143,8 +94,10 @@ pub enum Step {
     Kakoune,
     Helix,
     Krew,
+    Lure,
     Macports,
     Mamba,
+    Miktex,
     Mas,
     Maza,
     Micro,
@@ -174,6 +127,7 @@ pub enum Step {
     Rustup,
     Scoop,
     Sdkman,
+    SelfUpdate,
     Sheldon,
     Shell,
     Snap,
@@ -189,6 +143,7 @@ pub enum Step {
     Vagrant,
     Vcpkg,
     Vim,
+    Vscode,
     Winget,
     Wsl,
     WslUpdate,
@@ -209,10 +164,17 @@ pub struct Git {
     max_concurrency: Option<usize>,
 
     #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
-    arguments: Option<String>,
+    pull_arguments: Option<String>,
+
+    #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
+    push_arguments: Option<String>,
 
     #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
     repos: Option<Vec<String>>,
+    #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
+    pull_only_repos: Option<Vec<String>>,
+    #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
+    push_only_repos: Option<Vec<String>>,
 
     pull_predefined: Option<bool>,
 }
@@ -338,6 +300,9 @@ pub struct Linux {
     #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
     nix_arguments: Option<String>,
 
+    #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
+    nix_env_arguments: Option<String>,
+
     #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
     apt_arguments: Option<String>,
 
@@ -375,11 +340,6 @@ pub struct Misc {
 
     sudo_command: Option<SudoKind>,
 
-    #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
-    git_repos: Option<Vec<String>>,
-
-    predefined_git_repos: Option<bool>,
-
     #[merge(strategy = crate::utils::merge_strategies::vec_prepend_opt)]
     disable: Option<Vec<Step>>,
 
@@ -394,9 +354,6 @@ pub struct Misc {
     #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
     ssh_arguments: Option<String>,
 
-    #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
-    git_arguments: Option<String>,
-
     #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
     tmux_arguments: Option<String>,
 
@@ -406,15 +363,6 @@ pub struct Misc {
 
     assume_yes: Option<bool>,
 
-    #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
-    yay_arguments: Option<String>,
-
-    #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
-    aura_aur_arguments: Option<String>,
-
-    #[merge(strategy = crate::utils::merge_strategies::string_append_opt)]
-    aura_pacman_arguments: Option<String>,
-
     no_retry: Option<bool>,
 
     run_in_tmux: Option<bool>,
@@ -423,8 +371,6 @@ pub struct Misc {
 
     notify_each_step: Option<bool>,
 
-    accept_all_windows_updates: Option<bool>,
-
     skip_notify: Option<bool>,
 
     bashit_branch: Option<String>,
@@ -433,6 +379,8 @@ pub struct Misc {
     only: Option<Vec<Step>>,
 
     no_self_update: Option<bool>,
+
+    log_filters: Option<Vec<String>>,
 }
 
 #[derive(Deserialize, Default, Debug, Merge)]
@@ -592,11 +540,11 @@ impl ConfigFile {
             */
             for include in dir_include {
                 let include_contents = fs::read_to_string(&include).map_err(|e| {
-                    tracing::error!("Unable to read {}", include.display());
+                    error!("Unable to read {}", include.display());
                     e
                 })?;
                 let include_contents_parsed = toml::from_str(include_contents.as_str()).map_err(|e| {
-                    tracing::error!("Failed to deserialize {}", include.display());
+                    error!("Failed to deserialize {}", include.display());
                     e
                 })?;
 
@@ -613,7 +561,7 @@ impl ConfigFile {
         }
 
         let mut contents_non_split = fs::read_to_string(&config_path).map_err(|e| {
-            tracing::error!("Unable to read {}", config_path.display());
+            error!("Unable to read {}", config_path.display());
             e
         })?;
 
@@ -626,7 +574,7 @@ impl ConfigFile {
 
         for contents in contents_split {
             let config_file_include_only: ConfigFileIncludeOnly = toml::from_str(contents).map_err(|e| {
-                tracing::error!("Failed to deserialize an include section of {}", config_path.display());
+                error!("Failed to deserialize an include section of {}", config_path.display());
                 e
             })?;
 
@@ -639,38 +587,24 @@ impl ConfigFile {
                         let include_contents = match fs::read_to_string(&include_path) {
                             Ok(c) => c,
                             Err(e) => {
-                                tracing::error!("Unable to read {}: {}", include_path.display(), e);
+                                error!("Unable to read {}: {}", include_path.display(), e);
                                 continue;
                             }
                         };
                         match toml::from_str::<Self>(&include_contents) {
                             Ok(include_parsed) => result.merge(include_parsed),
                             Err(e) => {
-                                tracing::error!("Failed to deserialize {}: {}", include_path.display(), e);
+                                error!("Failed to deserialize {}: {}", include_path.display(), e);
                                 continue;
                             }
                         };
-
-                        debug!("Configuration include found: {}", include_path.display());
                     }
-                } else {
-                    debug!("No include paths found in {}", config_path.display());
                 }
             }
 
             match toml::from_str::<Self>(contents) {
                 Ok(contents) => result.merge(contents),
-                Err(e) => tracing::error!("Failed to deserialize {}: {}", config_path.display(), e),
+                Err(e) => error!("Failed to deserialize {}: {}", config_path.display(), e),
-            }
-        }
-
-        if let Some(misc) = &mut result.misc {
-            if let Some(ref mut paths) = &mut misc.git_repos {
-                for path in paths.iter_mut() {
-                    let expanded = shellexpand::tilde::<&str>(&path.as_ref()).into_owned();
-                    debug!("Path {} expanded to {}", path, expanded);
-                    *path = expanded;
-                }
             }
         }
 
@@ -682,7 +616,21 @@ impl ConfigFile {
             }
         }
 
-        debug!("Loaded configuration: {:?}", result);
+        if let Some(paths) = result.git.as_mut().and_then(|git| git.pull_only_repos.as_mut()) {
+            for path in paths.iter_mut() {
+                let expanded = shellexpand::tilde::<&str>(&path.as_ref()).into_owned();
+                debug!("Path {} expanded to {}", path, expanded);
+                *path = expanded;
+            }
+        }
+
+        if let Some(paths) = result.git.as_mut().and_then(|git| git.push_only_repos.as_mut()) {
+            for path in paths.iter_mut() {
+                let expanded = shellexpand::tilde::<&str>(&path.as_ref()).into_owned();
+                debug!("Path {} expanded to {}", path, expanded);
+                *path = expanded;
+            }
+        }
 
         Ok(result)
     }
@@ -801,7 +749,7 @@ pub struct CommandLineArgs {
     /// Tracing filter directives.
     ///
     /// See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/struct.EnvFilter.html
-    #[clap(long, default_value = "warn")]
+    #[clap(long, default_value = DEFAULT_LOG_LEVEL)]
     pub log_filter: String,
 
     /// Print completion script for the given shell and exit
@@ -830,12 +778,25 @@ impl CommandLineArgs {
         &self.env
     }
 
+    /// In Topgrade, filter directives come from 3 places:
+    ///     1. CLI option `--log-filter`
+    ///     2. Config file
+    ///     3. `debug` if the `--verbose` option is present
+    ///
+    /// Before loading the configuration file, we need our logger to work, so this
+    /// function will return directives coming from part 1 and 2.
+    ///
+    ///
+    /// When the configuration file is loaded, `Config::tracing_filter_directives()`
+    /// will return all the 3 parts.
     pub fn tracing_filter_directives(&self) -> String {
+        let mut ret = self.log_filter.clone();
         if self.verbose {
-            "debug".into()
+            ret.push(',');
-        } else {
+            ret.push_str("debug");
-            self.log_filter.clone()
         }
+
+        ret
     }
 }
 
@@ -844,6 +805,7 @@ impl CommandLineArgs {
 /// The struct holds the loaded configuration file, as well as the arguments parsed from the command line.
 /// Its provided methods decide the appropriate options based on combining the configuration file and the
 /// command line arguments.
+#[derive(Debug)]
 pub struct Config {
     opt: CommandLineArgs,
     config_file: ConfigFile,
@@ -860,7 +822,7 @@ impl Config {
             ConfigFile::read(opt.config.clone()).unwrap_or_else(|e| {
                 // Inform the user about errors when loading the configuration,
                 // but fallback to the default config to at least attempt to do something
-                tracing::error!("failed to load configuration: {}", e);
+                error!("failed to load configuration: {}", e);
                 ConfigFile::default()
             })
         } else {
@@ -868,14 +830,6 @@ impl Config {
             ConfigFile::default()
         };
 
-        if let Some(misc) = &config_file.misc {
-            check_deprecated!(misc, git_arguments, git, arguments);
-            check_deprecated!(misc, git_repos, git, repos);
-            check_deprecated!(misc, predefined_git_repos, git, pull_predefined);
-            check_deprecated!(misc, yay_arguments, linux, yay_arguments);
-            check_deprecated!(misc, accept_all_windows_updates, windows, accept_all_updates);
-        }
-
         let allowed_steps = Self::allowed_steps(&opt, &config_file);
 
         Ok(Self {
@@ -905,9 +859,23 @@ impl Config {
         &self.config_file.commands
     }
 
+    /// The list of git repositories to push and pull.
+    pub fn git_repos(&self) -> Option<&Vec<String>> {
+        self.config_file.git.as_ref().and_then(|git| git.repos.as_ref())
+    }
     /// The list of additional git repositories to pull.
-    pub fn git_repos(&self) -> &Option<Vec<String>> {
+    pub fn git_pull_only_repos(&self) -> Option<&Vec<String>> {
-        get_deprecated_moved_opt!(&self.config_file.misc, git_repos, &self.config_file.git, repos)
+        self.config_file
+            .git
+            .as_ref()
+            .and_then(|git| git.pull_only_repos.as_ref())
+    }
+    /// The list of git repositories to push.
+    pub fn git_push_only_repos(&self) -> Option<&Vec<String>> {
+        self.config_file
+            .git
+            .as_ref()
+            .and_then(|git| git.push_only_repos.as_ref())
     }
 
     /// Tell whether the specified step should run.
@@ -1018,9 +986,19 @@ impl Config {
             .and_then(|misc| misc.ssh_arguments.as_ref())
     }
 
-    /// Extra Git arguments
+    /// Extra Git arguments for when pushing
-    pub fn git_arguments(&self) -> &Option<String> {
+    pub fn push_git_arguments(&self) -> Option<&String> {
-        get_deprecated_moved_opt!(&self.config_file.misc, git_arguments, &self.config_file.git, arguments)
+        self.config_file
+            .git
+            .as_ref()
+            .and_then(|git| git.push_arguments.as_ref())
+    }
+    /// Extra Git arguments for when pulling
+    pub fn pull_git_arguments(&self) -> Option<&String> {
+        self.config_file
+            .git
+            .as_ref()
+            .and_then(|git| git.pull_arguments.as_ref())
     }
 
     /// Extra Tmux arguments
@@ -1093,13 +1071,11 @@ impl Config {
 
     /// Whether to accept all Windows updates
     pub fn accept_all_windows_updates(&self) -> bool {
-        get_deprecated_moved_or_default_to!(
+        self.config_file
-            &self.config_file.misc,
+            .windows
-            accept_all_windows_updates,
+            .as_ref()
-            &self.config_file.windows,
+            .and_then(|windows| windows.accept_all_updates)
-            accept_all_updates,
+            .unwrap_or(true)
-            true
-        )
     }
 
     /// Whether to self rename the Topgrade executable during the run
@@ -1278,6 +1254,14 @@ impl Config {
             .and_then(|linux| linux.nix_arguments.as_deref())
     }
 
+    /// Extra nix-env arguments
+    pub fn nix_env_arguments(&self) -> Option<&str> {
+        self.config_file
+            .linux
+            .as_ref()
+            .and_then(|linux| linux.nix_env_arguments.as_deref())
+    }
+
     /// Extra Home Manager arguments
     pub fn home_manager(&self) -> Option<&Vec<String>> {
         self.config_file
@@ -1374,19 +1358,39 @@ impl Config {
 
     pub fn use_predefined_git_repos(&self) -> bool {
         !self.opt.disable_predefined_git_repos
-            && get_deprecated_moved_or_default_to!(
+            && self
-                &self.config_file.misc,
+                .config_file
-                predefined_git_repos,
+                .git
-                &self.config_file.git,
+                .as_ref()
-                pull_predefined,
+                .and_then(|git| git.pull_predefined)
-                true
+                .unwrap_or(true)
-            )
     }
 
     pub fn verbose(&self) -> bool {
         self.opt.verbose
     }
 
+    /// After loading the config file, filter directives consist of 3 parts:
+    ///
+    ///     1. directives from the configuration file
+    ///     2. directives from the CLI options `--log-filter`
+    ///     3. `debug`, which would be enabled if the `--verbose` option is present
+    ///
+    /// Previous directive will be overwritten if a directive with the same target
+    /// appear later.
+    pub fn tracing_filter_directives(&self) -> String {
+        let mut ret = String::new();
+        if let Some(directives) = self.config_file.misc.as_ref().and_then(|m| m.log_filters.as_ref()) {
+            ret.push_str(&directives.join(","));
+        }
+        ret.push(',');
+        ret.push_str(&self.opt.log_filter);
+        if self.verbose() {
+            ret.push_str(",debug");
+        }
+        ret
+    }
+
     pub fn show_skipped(&self) -> bool {
         self.opt.show_skipped
     }

src/ctrlc/windows.rs

@@ -1,5 +1,6 @@
 //! A stub for Ctrl + C handling.
 use crate::ctrlc::interrupted::set_interrupted;
+use tracing::error;
 use winapi::shared::minwindef::{BOOL, DWORD, FALSE, TRUE};
 use winapi::um::consoleapi::SetConsoleCtrlHandler;
 use winapi::um::wincon::CTRL_C_EVENT;
@@ -16,6 +17,6 @@ extern "system" fn handler(ctrl_type: DWORD) -> BOOL {
 
 pub fn set_handler() {
     if 0 == unsafe { SetConsoleCtrlHandler(Some(handler), TRUE) } {
-        tracing::error!("Cannot set a control C handler")
+        error!("Cannot set a control C handler")
     }
 }

src/main.rs

@@ -17,6 +17,8 @@ use etcetera::base_strategy::{BaseStrategy, Xdg};
 use once_cell::sync::Lazy;
 use tracing::debug;
 
+use crate::steps::git::GitAction;
+
 use self::config::{CommandLineArgs, Config, Step};
 use self::error::StepFailed;
 #[cfg(all(windows, feature = "self-update"))]
@@ -24,6 +26,8 @@ use self::error::Upgraded;
 use self::steps::{remote::*, *};
 use self::terminal::*;
 
+use self::utils::{install_color_eyre, install_tracing, update_tracing};
+
 mod command;
 mod config;
 mod ctrlc;
@@ -47,10 +51,22 @@ pub static XDG_DIRS: Lazy<Xdg> = Lazy::new(|| Xdg::new().expect("No home directo
 pub static WINDOWS_DIRS: Lazy<Windows> = Lazy::new(|| Windows::new().expect("No home directory"));
 
 fn run() -> Result<()> {
-    color_eyre::install()?;
+    install_color_eyre()?;
     ctrlc::set_handler();
 
     let opt = CommandLineArgs::parse();
+    // Set up the logger with the filter directives from:
+    //     1. CLI option `--log-filter`
+    //     2. `debug` if the `--verbose` option is present
+    // We do this because we need our logger to work while loading the
+    // configuration file.
+    //
+    // When the configuration file is loaded, update the logger with the full
+    // filter directives.
+    //
+    // For more info, see the comments in `CommandLineArgs::tracing_filter_directives()`
+    // and `Config::tracing_filter_directives()`.
+    let reload_handle = install_tracing(&opt.tracing_filter_directives())?;
 
     if let Some(shell) = opt.gen_completion {
         let cmd = &mut CommandLineArgs::command();
@@ -64,8 +80,6 @@ fn run() -> Result<()> {
         return Ok(());
     }
 
-    install_tracing(&opt.tracing_filter_directives())?;
-
     for env in opt.env_variables() {
         let mut splitted = env.split('=');
         let var = splitted.next().unwrap();
@@ -84,6 +98,8 @@ fn run() -> Result<()> {
     }
 
     let config = Config::load(opt)?;
+    // Update the logger with the full filter directives.
+    update_tracing(&reload_handle, &config.tracing_filter_directives())?;
     set_title(config.set_title());
     display_time(config.display_time());
     set_desktop_notifications(config.notify_each_step());
@@ -92,7 +108,8 @@ fn run() -> Result<()> {
     debug!("OS: {}", env!("TARGET"));
     debug!("{:?}", std::env::args());
     debug!("Binary path: {:?}", std::env::current_exe());
-    debug!("Self Update: {:?}", cfg!(feature = "self-update"));
+    debug!("self-update Feature Enabled: {:?}", cfg!(feature = "self-update"));
+    debug!("Configuration: {:?}", config);
 
     if config.run_in_tmux() && env::var("TOPGRADE_INSIDE_TMUX").is_err() {
         #[cfg(unix)]
@@ -115,22 +132,15 @@ fn run() -> Result<()> {
     let ctx = execution_context::ExecutionContext::new(run_type, sudo, &git, &config);
     let mut runner = runner::Runner::new(&ctx);
 
+    // Self-Update step, this will execute only if:
+    // 1. the `self-update` feature is enabled
+    // 2. it is not disabled from configuration (env var/CLI opt/file)
     #[cfg(feature = "self-update")]
     {
-        let config_self_upgrade = env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !config.no_self_update();
+        let should_self_update = env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !config.no_self_update();
 
-        if !run_type.dry() && config_self_upgrade {
+        if should_self_update {
-            let result = self_update::self_update();
+            runner.execute(Step::SelfUpdate, "Self Update", || self_update::self_update(&ctx))?;
-
-            if let Err(e) = &result {
-                #[cfg(windows)]
-                {
-                    if e.downcast_ref::<Upgraded>().is_some() {
-                        return result;
-                    }
-                }
-                print_warning(format!("Self update error: {e}"));
-            }
         }
     }
 
@@ -187,15 +197,10 @@ fn run() -> Result<()> {
         }
         runner.execute(Step::ConfigUpdate, "config-update", || linux::run_config_update(&ctx))?;
 
-        runner.execute(Step::BrewFormula, "Brew", || {
-            unix::run_brew_formula(&ctx, unix::BrewVariant::Path)
-        })?;
-
         runner.execute(Step::AM, "am", || linux::run_am(&ctx))?;
         runner.execute(Step::AppMan, "appman", || linux::run_appman(&ctx))?;
         runner.execute(Step::DebGet, "deb-get", || linux::run_deb_get(&ctx))?;
         runner.execute(Step::Toolbx, "toolbx", || toolbx::run_toolbx(&ctx))?;
-        runner.execute(Step::Flatpak, "Flatpak", || linux::run_flatpak(&ctx))?;
         runner.execute(Step::Snap, "snap", || linux::run_snap(&ctx))?;
         runner.execute(Step::Pacstall, "pacstall", || linux::run_pacstall(&ctx))?;
         runner.execute(Step::Pacdef, "pacdef", || linux::run_pacdef(&ctx))?;
@@ -205,6 +210,12 @@ fn run() -> Result<()> {
         runner.execute(Step::System, "pihole", || linux::run_pihole_update(&ctx))?;
         runner.execute(Step::Firmware, "Firmware upgrades", || linux::run_fwupdmgr(&ctx))?;
         runner.execute(Step::Restarts, "Restarts", || linux::run_needrestart(&ctx))?;
+
+        runner.execute(Step::Flatpak, "Flatpak", || linux::run_flatpak(&ctx))?;
+        runner.execute(Step::BrewFormula, "Brew", || {
+            unix::run_brew_formula(&ctx, unix::BrewVariant::Path)
+        })?;
+        runner.execute(Step::Lure, "LURE", || linux::run_lure_update(&ctx))?;
     }
 
     #[cfg(target_os = "macos")]
@@ -320,8 +331,12 @@ fn run() -> Result<()> {
     runner.execute(Step::Opam, "opam", || generic::run_opam_update(&ctx))?;
     runner.execute(Step::Vcpkg, "vcpkg", || generic::run_vcpkg_update(&ctx))?;
     runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(&ctx))?;
+    runner.execute(Step::Vscode, "Visual Studio Code extensions", || {
+        generic::run_vscode_extensions_upgrade(&ctx)
+    })?;
     runner.execute(Step::Conda, "conda", || generic::run_conda_update(&ctx))?;
     runner.execute(Step::Mamba, "mamba", || generic::run_mamba_update(&ctx))?;
+    runner.execute(Step::Miktex, "miktex", || generic::run_miktex_packages_update(&ctx))?;
     runner.execute(Step::Pip3, "pip3", || generic::run_pip3_update(&ctx))?;
     runner.execute(Step::PipReview, "pip-review", || generic::run_pip_review_update(&ctx))?;
     runner.execute(Step::PipReviewLocal, "pip-review (local)", || {
@@ -369,35 +384,35 @@ fn run() -> Result<()> {
         if config.should_run(Step::Emacs) {
             if !emacs.is_doom() {
                 if let Some(directory) = emacs.directory() {
-                    git_repos.insert_if_repo(directory);
+                    git_repos.insert_if_repo(directory, GitAction::Pull);
                 }
             }
-            git_repos.insert_if_repo(HOME_DIR.join(".doom.d"));
+            git_repos.insert_if_repo(HOME_DIR.join(".doom.d"), GitAction::Pull);
         }
 
         if config.should_run(Step::Vim) {
-            git_repos.insert_if_repo(HOME_DIR.join(".vim"));
+            git_repos.insert_if_repo(HOME_DIR.join(".vim"), GitAction::Pull);
-            git_repos.insert_if_repo(HOME_DIR.join(".config/nvim"));
+            git_repos.insert_if_repo(HOME_DIR.join(".config/nvim"), GitAction::Pull);
         }
 
-        git_repos.insert_if_repo(HOME_DIR.join(".ideavimrc"));
+        git_repos.insert_if_repo(HOME_DIR.join(".ideavimrc"), GitAction::Pull);
-        git_repos.insert_if_repo(HOME_DIR.join(".intellimacs"));
+        git_repos.insert_if_repo(HOME_DIR.join(".intellimacs"), GitAction::Pull);
 
         if config.should_run(Step::Rcm) {
-            git_repos.insert_if_repo(HOME_DIR.join(".dotfiles"));
+            git_repos.insert_if_repo(HOME_DIR.join(".dotfiles"), GitAction::Pull);
         }
 
         #[cfg(unix)]
         {
-            git_repos.insert_if_repo(zsh::zshrc());
+            git_repos.insert_if_repo(zsh::zshrc(), GitAction::Pull);
             if config.should_run(Step::Tmux) {
-                git_repos.insert_if_repo(HOME_DIR.join(".tmux"));
+                git_repos.insert_if_repo(HOME_DIR.join(".tmux"), GitAction::Pull);
             }
-            git_repos.insert_if_repo(HOME_DIR.join(".config/fish"));
+            git_repos.insert_if_repo(HOME_DIR.join(".config/fish"), GitAction::Pull);
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("openbox"));
+            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("openbox"), GitAction::Pull);
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("bspwm"));
+            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("bspwm"), GitAction::Pull);
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("i3"));
+            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("i3"), GitAction::Pull);
-            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("sway"));
+            git_repos.insert_if_repo(XDG_DIRS.config_dir().join("sway"), GitAction::Pull);
         }
 
         #[cfg(windows)]
@@ -405,24 +420,39 @@ fn run() -> Result<()> {
             WINDOWS_DIRS
                 .cache_dir()
                 .join("Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState"),
+            GitAction::Pull,
         );
 
         #[cfg(windows)]
         windows::insert_startup_scripts(&mut git_repos).ok();
 
         if let Some(profile) = powershell.profile() {
-            git_repos.insert_if_repo(profile);
+            git_repos.insert_if_repo(profile, GitAction::Pull);
         }
     }
 
     if config.should_run(Step::GitRepos) {
         if let Some(custom_git_repos) = config.git_repos() {
             for git_repo in custom_git_repos {
-                git_repos.glob_insert(git_repo);
+                git_repos.glob_insert(git_repo, GitAction::Pull);
+                git_repos.glob_insert(git_repo, GitAction::Push);
             }
         }
+
+        if let Some(git_pull_only_repos) = config.git_pull_only_repos() {
+            for git_repo in git_pull_only_repos {
+                git_repos.glob_insert(git_repo, GitAction::Pull);
+            }
+        }
+
+        if let Some(git_push_only_repos) = config.git_push_only_repos() {
+            for git_repo in git_push_only_repos {
+                git_repos.glob_insert(git_repo, GitAction::Push);
+            }
+        }
+
         runner.execute(Step::GitRepos, "Git repositories", || {
-            git.multi_pull_step(&git_repos, &ctx)
+            git.multi_repo_step(&git_repos, &ctx)
         })?;
     }
 
@@ -544,26 +574,3 @@ fn main() {
         }
     }
 }
-
-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/self_update.rs

@@ -3,6 +3,7 @@ use std::env;
 use std::os::unix::process::CommandExt as _;
 use std::process::Command;
 
+use crate::config::Step;
 use color_eyre::eyre::{bail, Result};
 use self_update_crate::backends::github::Update;
 use self_update_crate::update::UpdateStatus;
@@ -11,52 +12,61 @@ use super::terminal::*;
 #[cfg(windows)]
 use crate::error::Upgraded;
 
-pub fn self_update() -> Result<()> {
+use crate::execution_context::ExecutionContext;
+
+pub fn self_update(ctx: &ExecutionContext) -> Result<()> {
     print_separator("Self update");
-    let current_exe = env::current_exe();
 
-    let target = self_update_crate::get_target();
+    if ctx.run_type().dry() {
-    let result = Update::configure()
+        println!("Would self-update");
-        .repo_owner("topgrade-rs")
+        Ok(())
-        .repo_name("topgrade")
-        .target(target)
-        .bin_name(if cfg!(windows) { "topgrade.exe" } else { "topgrade" })
-        .show_output(false)
-        .show_download_progress(true)
-        .current_version(self_update_crate::cargo_crate_version!())
-        .no_confirm(true)
-        .build()?
-        .update_extended()?;
-
-    if let UpdateStatus::Updated(release) = &result {
-        println!("\nTopgrade upgraded to {}:\n", release.version);
-        if let Some(body) = &release.body {
-            println!("{body}");
-        }
     } else {
-        println!("Topgrade is up-to-date");
+        let assume_yes = ctx.config().yes(Step::SelfUpdate);
-    }
+        let current_exe = env::current_exe();
 
-    {
+        let target = self_update_crate::get_target();
-        if result.updated() {
+        let result = Update::configure()
-            print_warning("Respawning...");
+            .repo_owner("topgrade-rs")
-            let mut command = Command::new(current_exe?);
+            .repo_name("topgrade")
-            command.args(env::args().skip(1)).env("TOPGRADE_NO_SELF_UPGRADE", "");
+            .target(target)
+            .bin_name(if cfg!(windows) { "topgrade.exe" } else { "topgrade" })
+            .show_output(true)
+            .show_download_progress(true)
+            .current_version(self_update_crate::cargo_crate_version!())
+            .no_confirm(assume_yes)
+            .build()?
+            .update_extended()?;
 
-            #[cfg(unix)]
+        if let UpdateStatus::Updated(release) = &result {
-            {
+            println!("\nTopgrade upgraded to {}:\n", release.version);
-                let err = command.exec();
+            if let Some(body) = &release.body {
-                bail!(err);
+                println!("{body}");
             }
+        } else {
+            println!("Topgrade is up-to-date");
+        }
 
-            #[cfg(windows)]
+        {
-            {
+            if result.updated() {
-                #[allow(clippy::disallowed_methods)]
+                print_info("Respawning...");
-                let status = command.status()?;
+                let mut command = Command::new(current_exe?);
-                bail!(Upgraded(status));
+                command.args(env::args().skip(1)).env("TOPGRADE_NO_SELF_UPGRADE", "");
+
+                #[cfg(unix)]
+                {
+                    let err = command.exec();
+                    bail!(err);
+                }
+
+                #[cfg(windows)]
+                {
+                    #[allow(clippy::disallowed_methods)]
+                    let status = command.status()?;
+                    bail!(Upgraded(status));
+                }
             }
         }
-    }
 
-    Ok(())
+        Ok(())
+    }
 }

src/steps/generic.rs

@@ -287,7 +287,13 @@ pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
     print_separator("OCaml Package Manager");
 
     ctx.run_type().execute(&opam).arg("update").status_checked()?;
-    ctx.run_type().execute(&opam).arg("upgrade").status_checked()?;
+
+    let mut command = ctx.run_type().execute(&opam);
+    command.arg("upgrade");
+    if ctx.config().yes(Step::Opam) {
+        command.arg("--yes");
+    }
+    command.status_checked()?;
 
     if ctx.config().cleanup() {
         ctx.run_type().execute(&opam).arg("clean").status_checked()?;
@@ -318,6 +324,30 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
     command.args(["upgrade", "--no-dry-run"]).status_checked()
 }
 
+pub fn run_vscode_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
+    let vscode = require("code")?;
+    print_separator("Visual Studio Code extensions");
+
+    // Vscode does not have CLI command to upgrade all extensions (see https://github.com/microsoft/vscode/issues/56578)
+    // Instead we get the list of installed extensions with `code --list-extensions` command (obtain a line-return separated list of installed extensions)
+    let extensions = Command::new(&vscode)
+        .arg("--list-extensions")
+        .output_checked_utf8()?
+        .stdout;
+
+    // Then we construct the upgrade command: `code --force --install-extension [ext0] --install-extension [ext1] ... --install-extension [extN]`
+    if !extensions.is_empty() {
+        let mut command_args = vec!["--force"];
+        for extension in extensions.split_whitespace() {
+            command_args.extend(["--install-extension", extension]);
+        }
+
+        ctx.run_type().execute(&vscode).args(command_args).status_checked()?;
+    }
+
+    Ok(())
+}
+
 pub fn run_pipx_update(ctx: &ExecutionContext) -> Result<()> {
     let pipx = require("pipx")?;
     print_separator("pipx");
@@ -367,6 +397,16 @@ pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
     command.status_checked()
 }
 
+pub fn run_miktex_packages_update(ctx: &ExecutionContext) -> Result<()> {
+    let miktex = require("miktex")?;
+    print_separator("miktex");
+
+    ctx.run_type()
+        .execute(miktex)
+        .args(["packages", "update"])
+        .status_checked()
+}
+
 pub fn run_pip3_update(ctx: &ExecutionContext) -> Result<()> {
     let py = require("python").and_then(check_is_python_2_or_shim);
     let py3 = require("python3").and_then(check_is_python_2_or_shim);
@@ -383,7 +423,7 @@ pub fn run_pip3_update(ctx: &ExecutionContext) -> Result<()> {
     Command::new(&python3)
         .args(["-m", "pip"])
         .output_checked_utf8()
-        .map_err(|_| SkipStep("pip does not exists".to_string()))?;
+        .map_err(|_| SkipStep("pip does not exist".to_string()))?;
 
     let check_externally_managed = "import sysconfig; from os import path; print('Y') if path.isfile(path.join(sysconfig.get_path('stdlib'), 'EXTERNALLY-MANAGED')) else print('N')";
     Command::new(&python3)
@@ -636,6 +676,10 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
         .run_type()
         .execute(&dotnet)
         .args(["tool", "list", "--global"])
+        // dotnet will print a greeting message on its first run, from this question:
+        // https://stackoverflow.com/q/70493706/14092446
+        // Setting `DOTNET_NOLOGO` to `true` should disable it
+        .env("DOTNET_NOLOGO", "true")
         .output_checked_utf8()
     {
         Ok(output) => output,

src/steps/git.rs

@@ -3,6 +3,7 @@ use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, Stdio};
 
+use color_eyre::eyre::Context;
 use color_eyre::eyre::{eyre, Result};
 use console::style;
 use futures::stream::{iter, FuturesUnordered};
@@ -26,21 +27,61 @@ pub struct Git {
     git: Option<PathBuf>,
 }
 
+#[derive(Clone, Copy)]
+pub enum GitAction {
+    Push,
+    Pull,
+}
+
+#[derive(Debug)]
 pub struct Repositories<'a> {
     git: &'a Git,
-    repositories: HashSet<String>,
+    pull_repositories: HashSet<String>,
+    push_repositories: HashSet<String>,
     glob_match_options: MatchOptions,
     bad_patterns: Vec<String>,
 }
 
+#[track_caller]
 fn output_checked_utf8(output: Output) -> Result<()> {
     if !(output.status.success()) {
-        let stderr = String::from_utf8(output.stderr).unwrap();
+        let stderr = String::from_utf8_lossy(&output.stderr);
-        Err(eyre!(stderr))
+        let stderr = stderr.trim();
+        Err(eyre!("{stderr}"))
     } else {
         Ok(())
     }
 }
+async fn push_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -> Result<()> {
+    let path = repo.to_string();
+
+    println!("{} {}", style("Pushing").cyan().bold(), path);
+
+    let mut command = AsyncCommand::new(git);
+
+    command
+        .stdin(Stdio::null())
+        .current_dir(&repo)
+        .args(["push", "--porcelain"]);
+    if let Some(extra_arguments) = ctx.config().push_git_arguments() {
+        command.args(extra_arguments.split_whitespace());
+    }
+
+    let output = command.output().await?;
+    let result = match output.status.success() {
+        true => Ok(()),
+        false => Err(format!("Failed to push {repo}")),
+    };
+
+    if result.is_err() {
+        println!("{} pushing {}", style("Failed").red().bold(), &repo);
+    };
+
+    match result {
+        Ok(_) => Ok(()),
+        Err(e) => Err(eyre!(e)),
+    }
+}
 
 async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -> Result<()> {
     let path = repo.to_string();
@@ -55,7 +96,7 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
         .current_dir(&repo)
         .args(["pull", "--ff-only"]);
 
-    if let Some(extra_arguments) = ctx.config().git_arguments() {
+    if let Some(extra_arguments) = ctx.config().pull_git_arguments() {
         command.args(extra_arguments.split_whitespace());
     }
 
@@ -66,11 +107,12 @@ async fn pull_repository(repo: String, git: &Path, ctx: &ExecutionContext<'_>) -
         .stdin(Stdio::null())
         .output()
         .await?;
-    let result = output_checked_utf8(pull_output).and_then(|_| output_checked_utf8(submodule_output));
+    let result = output_checked_utf8(pull_output)
+        .and_then(|_| output_checked_utf8(submodule_output))
+        .wrap_err_with(|| format!("Failed to pull {repo}"));
 
-    if let Err(message) = &result {
+    if result.is_err() {
         println!("{} pulling {}", style("Failed").red().bold(), &repo);
-        print!("{message}");
     } else {
         let after_revision = get_head_revision(git, &repo);
 
@@ -170,14 +212,14 @@ impl Git {
                 }
             }
             Err(e) => match e.kind() {
-                io::ErrorKind::NotFound => debug!("{} does not exists", path.as_ref().display()),
+                io::ErrorKind::NotFound => debug!("{} does not exist", path.as_ref().display()),
                 _ => error!("Error looking for {}: {}", path.as_ref().display(), e),
             },
         }
 
         None
     }
-    pub fn multi_pull_step(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
+    pub fn multi_repo_step(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
         // Warn the user about the bad patterns.
         //
         // NOTE: this should be executed **before** skipping the Git step or the
@@ -188,12 +230,15 @@ impl Git {
             .iter()
             .for_each(|pattern| print_warning(format!("Path {pattern} did not contain any git repositories")));
 
-        if repositories.repositories.is_empty() {
+        if repositories.is_empty() {
-            return Err(SkipStep(String::from("No repositories to pull")).into());
+            return Err(SkipStep(String::from("No repositories to pull or push")).into());
         }
 
         print_separator("Git repositories");
-        self.multi_pull(repositories, ctx)
+        self.multi_pull(repositories, ctx)?;
+        self.multi_push(repositories, ctx)?;
+
+        Ok(())
     }
 
     pub fn multi_pull(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
@@ -201,7 +246,7 @@ impl Git {
 
         if ctx.run_type().dry() {
             repositories
-                .repositories
+                .pull_repositories
                 .iter()
                 .for_each(|repo| println!("Would pull {}", &repo));
 
@@ -209,7 +254,7 @@ impl Git {
         }
 
         let futures_iterator = repositories
-            .repositories
+            .pull_repositories
             .iter()
             .filter(|repo| match has_remotes(git, repo) {
                 Some(false) => {
@@ -236,6 +281,47 @@ impl Git {
         let error = results.into_iter().find(|r| r.is_err());
         error.unwrap_or(Ok(()))
     }
+
+    pub fn multi_push(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
+        let git = self.git.as_ref().unwrap();
+
+        if ctx.run_type().dry() {
+            repositories
+                .push_repositories
+                .iter()
+                .for_each(|repo| println!("Would push {}", &repo));
+
+            return Ok(());
+        }
+
+        let futures_iterator = repositories
+            .push_repositories
+            .iter()
+            .filter(|repo| match has_remotes(git, repo) {
+                Some(false) => {
+                    println!(
+                        "{} {} because it has no remotes",
+                        style("Skipping").yellow().bold(),
+                        repo
+                    );
+                    false
+                }
+                _ => true, // repo has remotes or command to check for remotes has failed. proceed to pull anyway.
+            })
+            .map(|repo| push_repository(repo.clone(), git, ctx));
+
+        let stream_of_futures = if let Some(limit) = ctx.config().git_concurrency_limit() {
+            iter(futures_iterator).buffer_unordered(limit).boxed()
+        } else {
+            futures_iterator.collect::<FuturesUnordered<_>>().boxed()
+        };
+
+        let basic_rt = runtime::Runtime::new()?;
+        let results = basic_rt.block_on(async { stream_of_futures.collect::<Vec<Result<()>>>().await });
+
+        let error = results.into_iter().find(|r| r.is_err());
+        error.unwrap_or(Ok(()))
+    }
 }
 
 impl<'a> Repositories<'a> {
@@ -248,22 +334,27 @@ impl<'a> Repositories<'a> {
 
         Self {
             git,
-            repositories: HashSet::new(),
             bad_patterns: Vec::new(),
             glob_match_options,
+            pull_repositories: HashSet::new(),
+            push_repositories: HashSet::new(),
         }
     }
 
-    pub fn insert_if_repo<P: AsRef<Path>>(&mut self, path: P) -> bool {
+    pub fn insert_if_repo<P: AsRef<Path>>(&mut self, path: P, action: GitAction) -> bool {
         if let Some(repo) = self.git.get_repo_root(path) {
-            self.repositories.insert(repo);
+            match action {
+                GitAction::Push => self.push_repositories.insert(repo),
+                GitAction::Pull => self.pull_repositories.insert(repo),
+            };
+
             true
         } else {
             false
         }
     }
 
-    pub fn glob_insert(&mut self, pattern: &str) {
+    pub fn glob_insert(&mut self, pattern: &str, action: GitAction) {
         if let Ok(glob) = glob_with(pattern, self.glob_match_options) {
             let mut last_git_repo: Option<PathBuf> = None;
             for entry in glob {
@@ -279,7 +370,7 @@ impl<'a> Repositories<'a> {
                                 continue;
                             }
                         }
-                        if self.insert_if_repo(&path) {
+                        if self.insert_if_repo(&path, action) {
                             last_git_repo = Some(path);
                         }
                     }
@@ -297,14 +388,27 @@ impl<'a> Repositories<'a> {
         }
     }
 
-    #[cfg(unix)]
+    /// Return true if `pull_repos` and `push_repos` are both empty.
     pub fn is_empty(&self) -> bool {
-        self.repositories.is_empty()
+        self.pull_repositories.is_empty() && self.push_repositories.is_empty()
+    }
+
+    // The following 2 functions are `#[cfg(unix)]` because they are only used in
+    // the `oh-my-zsh` step, which is UNIX-only.
+
+    #[cfg(unix)]
+    /// Return true if `pull_repos` is empty.
+    pub fn pull_is_empty(&self) -> bool {
+        self.pull_repositories.is_empty()
     }
 
     #[cfg(unix)]
-    pub fn remove(&mut self, path: &str) {
+    /// Remove `path` from `pull_repos`
-        let _removed = self.repositories.remove(path);
+    ///
+    /// # Panic
+    /// Will panic if `path` is not in the `pull_repos` under a debug build.
+    pub fn remove_from_pull(&mut self, path: &str) {
+        let _removed = self.pull_repositories.remove(path);
         debug_assert!(_removed);
     }
 }

src/steps/os/archlinux.rs

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

src/steps/os/dragonfly.rs

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

src/steps/os/linux.rs

@@ -61,7 +61,7 @@ impl Distribution {
                     }
                 } else {
                     Ok(Distribution::Fedora)
-                }
+                };
             }
 
             Some("void") => Distribution::Void,
@@ -317,6 +317,7 @@ fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
 
     Ok(())
 }
+
 fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
     let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let mut command_update = ctx.run_type().execute(sudo);
@@ -708,14 +709,52 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
+/// `needrestart` should be skipped if:
+///
+/// 1. This is a redhat-based distribution
+/// 2. This is a debian-based distribution and it is using `nala` as the `apt`
+///    alternative
+fn should_skip_needrestart() -> Result<()> {
+    let distribution = Distribution::detect()?;
+    let msg = "needrestart will be ran by the package manager";
+
+    if distribution.redhat_based() {
+        return Err(SkipStep(String::from(msg)).into());
+    }
+
+    if matches!(distribution, Distribution::Debian) {
+        let apt = which("apt-fast")
+            .or_else(|| {
+                if which("mist").is_some() {
+                    Some(PathBuf::from("mist"))
+                } else {
+                    None
+                }
+            })
+            .or_else(|| {
+                if Path::new("/usr/bin/nala").exists() {
+                    Some(Path::new("/usr/bin/nala").to_path_buf())
+                } else {
+                    None
+                }
+            })
+            .unwrap_or_else(|| PathBuf::from("apt-get"));
+
+        let is_nala = apt.ends_with("nala");
+
+        if is_nala {
+            return Err(SkipStep(String::from(msg)).into());
+        }
+    }
+
+    Ok(())
+}
+
 pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
     let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let needrestart = require("needrestart")?;
-    let distribution = Distribution::detect()?;
 
-    if distribution.redhat_based() {
+    should_skip_needrestart()?;
-        return Err(SkipStep(String::from("needrestart will be ran by the package manager")).into());
-    }
 
     print_separator("Check for needed restarts");
 
@@ -840,7 +879,12 @@ pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("protonup");
 
-    ctx.run_type().execute(protonup).status_checked()?;
+    let mut cmd = ctx.run_type().execute(protonup);
+    if ctx.config().yes(Step::Protonup) {
+        cmd.arg("--yes");
+    }
+    cmd.status_checked()?;
+
     Ok(())
 }
 
@@ -913,6 +957,22 @@ pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
     Ok(())
 }
 
+pub fn run_lure_update(ctx: &ExecutionContext) -> Result<()> {
+    let lure = require("lure")?;
+
+    print_separator("LURE");
+
+    let mut exe = ctx.run_type().execute(lure);
+
+    if ctx.config().yes(Step::Lure) {
+        exe.args(["-i=false", "up"]);
+    } else {
+        exe.arg("up");
+    }
+
+    exe.status_checked()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/steps/os/unix.rs

@@ -11,6 +11,8 @@ use home;
 use ini::Ini;
 use tracing::debug;
 
+#[cfg(target_os = "linux")]
+use super::linux::Distribution;
 use crate::error::SkipStep;
 use crate::execution_context::ExecutionContext;
 #[cfg(any(target_os = "linux", target_os = "macos"))]
@@ -363,24 +365,23 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     debug!("nix profile: {:?}", profile_path);
     let manifest_json_path = profile_path.join("manifest.json");
 
-    let output = Command::new(&nix_env).args(["--query", "nix"]).output_checked_utf8();
+    // Should we attempt to upgrade Nix with `nix upgrade-nix`?
-    debug!("nix-env output: {:?}", output);
+    #[allow(unused_mut)]
-    let should_self_upgrade = output.is_ok();
+    let mut should_self_upgrade = cfg!(target_os = "macos");
+
+    #[cfg(target_os = "linux")]
+    {
+        // We can't use `nix upgrade-nix` on NixOS.
+        if let Ok(Distribution::NixOS) = Distribution::detect() {
+            should_self_upgrade = false;
+        }
+    }
 
     print_separator("Nix");
 
     let multi_user = fs::metadata(&nix)?.uid() == 0;
     debug!("Multi user nix: {}", multi_user);
 
-    #[cfg(target_os = "linux")]
-    {
-        use super::linux::Distribution;
-
-        if let Ok(Distribution::NixOS) = Distribution::detect() {
-            return Err(SkipStep(String::from("Nix on NixOS must be upgraded via nixos-rebuild switch")).into());
-        }
-    }
-
     #[cfg(target_os = "macos")]
     {
         if require("darwin-rebuild").is_ok() {
@@ -393,11 +394,20 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
 
     let run_type = ctx.run_type();
 
+    let nix_args = ["--extra-experimental-features", "nix-command"];
+
     if should_self_upgrade {
         if multi_user {
-            ctx.execute_elevated(&nix, true)?.arg("upgrade-nix").status_checked()?;
+            ctx.execute_elevated(&nix, true)?
+                .args(nix_args)
+                .arg("upgrade-nix")
+                .status_checked()?;
         } else {
-            run_type.execute(&nix).arg("upgrade-nix").status_checked()?;
+            run_type
+                .execute(&nix)
+                .args(nix_args)
+                .arg("upgrade-nix")
+                .status_checked()?;
         }
     }
 
@@ -406,12 +416,19 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
     if Path::new(&manifest_json_path).exists() {
         run_type
             .execute(&nix)
+            .args(nix_args)
             .arg("profile")
             .arg("upgrade")
             .arg(".*")
+            .arg("--verbose")
             .status_checked()
     } else {
-        run_type.execute(&nix_env).arg("--upgrade").status_checked()
+        let mut command = run_type.execute(nix_env);
+        command.arg("--upgrade");
+        if let Some(args) = ctx.config().nix_env_arguments() {
+            command.args(args.split_whitespace());
+        };
+        command.status_checked()
     }
 }
 

src/steps/os/windows.rs

@@ -8,6 +8,7 @@ use tracing::debug;
 
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
+use crate::steps::git::GitAction;
 use crate::terminal::{print_separator, print_warning};
 use crate::utils::{require, which};
 use crate::{error::SkipStep, steps::git::Repositories};
@@ -128,12 +129,45 @@ fn upgrade_wsl_distribution(wsl: &Path, dist: &str, ctx: &ExecutionContext) -> R
     let topgrade = Command::new(wsl)
         .args(["-d", dist, "bash", "-lc", "which topgrade"])
         .output_checked_utf8()
-        .map_err(|_| SkipStep(String::from("Could not find Topgrade installed in WSL")))?;
+        .map_err(|_| SkipStep(String::from("Could not find Topgrade installed in WSL")))?
+        .stdout // The normal output from `which topgrade` appends a newline, so we trim it here.
+        .trim_end()
+        .to_owned();
 
     let mut command = ctx.run_type().execute(wsl);
+
+    // The `arg` method automatically quotes its arguments.
+    // This means we can't append additional arguments to `topgrade` in WSL
+    // by calling `arg` successively.
+    //
+    // For example:
+    //
+    // ```rust
+    // command
+    //  .args(["-d", dist, "bash", "-c"])
+    //  .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade}"));
+    // ```
+    //
+    // creates a command string like:
+    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -c 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade'`
+    //
+    // Adding the following:
+    //
+    // ```rust
+    // command.arg("-v");
+    // ```
+    //
+    // appends the next argument like so:
+    // > `C:\WINDOWS\system32\wsl.EXE -d Ubuntu bash -c 'TOPGRADE_PREFIX=Ubuntu exec /bin/topgrade' -v`
+    // which means `-v` isn't passed to `topgrade`.
+    let mut args = String::new();
+    if ctx.config().verbose() {
+        args.push_str("-v");
+    }
+
     command
         .args(["-d", dist, "bash", "-c"])
-        .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade}"));
+        .arg(format!("TOPGRADE_PREFIX={dist} exec {topgrade} {args}"));
 
     if ctx.config().yes(Step::Wsl) {
         command.arg("-y");
@@ -206,7 +240,7 @@ pub fn insert_startup_scripts(git_repos: &mut Repositories) -> Result<()> {
             if let Ok(lnk) = parselnk::Lnk::try_from(Path::new(&path)) {
                 debug!("Startup link: {:?}", lnk);
                 if let Some(path) = lnk.relative_path() {
-                    git_repos.insert_if_repo(&startup_dir.join(path));
+                    git_repos.insert_if_repo(&startup_dir.join(path), GitAction::Pull);
                 }
             }
         }

src/steps/zsh.rs

@@ -181,10 +181,17 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
             .args([
                 "-c",
                 // ` > /dev/null` is used in case the user's zshrc will have some stdout output.
-                format!("source {} > /dev/null && echo $ZSH", zshrc_path.display()).as_str(),
+                format!(
+                    "source {} > /dev/null && export -p | grep ZSH > /dev/null && echo $ZSH",
+                    zshrc_path.display()
+                )
+                .as_str(),
             ])
             .output_checked_utf8()?;
-        env::set_var("ZSH", output.stdout.trim());
+        let zsh_env = output.stdout.trim();
+        if !zsh_env.is_empty() {
+            env::set_var("ZSH", zsh_env);
+        }
     }
 
     let oh_my_zsh = env::var("ZSH")
@@ -220,11 +227,11 @@ pub fn run_oh_my_zsh(ctx: &ExecutionContext) -> Result<()> {
 
     for entry in WalkDir::new(custom_dir).max_depth(2) {
         let entry = entry?;
-        custom_repos.insert_if_repo(entry.path());
+        custom_repos.insert_if_repo(entry.path(), crate::steps::git::GitAction::Pull);
     }
 
-    custom_repos.remove(&oh_my_zsh.to_string_lossy());
+    custom_repos.remove_from_pull(&oh_my_zsh.to_string_lossy());
-    if !custom_repos.is_empty() {
+    if !custom_repos.pull_is_empty() {
         println!("Pulling custom plugins and themes");
         ctx.git().multi_pull(&custom_repos, ctx)?;
     }

src/sudo.rs

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

src/utils.rs

@@ -5,9 +5,17 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use color_eyre::eyre::Result;
+
 use tracing::{debug, error};
+use tracing_subscriber::fmt::format::FmtSpan;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::reload::{Handle, Layer};
+use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::{fmt, Registry};
+use tracing_subscriber::{registry, EnvFilter};
 
 use crate::command::CommandExt;
+use crate::config::DEFAULT_LOG_LEVEL;
 use crate::error::SkipStep;
 
 pub trait PathExt
@@ -251,3 +259,49 @@ pub fn check_is_python_2_or_shim(python: PathBuf) -> Result<PathBuf> {
 
     Ok(python)
 }
+
+/// Set up the tracing logger
+///
+/// # Return value
+/// A reload handle will be returned so that we can change the log level at
+/// runtime.
+pub fn install_tracing(filter_directives: &str) -> Result<Handle<EnvFilter, Registry>> {
+    let env_filter = EnvFilter::try_new(filter_directives)
+        .or_else(|_| EnvFilter::try_from_default_env())
+        .or_else(|_| EnvFilter::try_new(DEFAULT_LOG_LEVEL))?;
+
+    let fmt_layer = fmt::layer()
+        .with_target(false)
+        .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
+        .without_time();
+
+    let (filter, reload_handle) = Layer::new(env_filter);
+
+    registry().with(filter).with(fmt_layer).init();
+
+    Ok(reload_handle)
+}
+
+/// Update the tracing logger with new `filter_directives`.
+pub fn update_tracing(reload_handle: &Handle<EnvFilter, Registry>, filter_directives: &str) -> Result<()> {
+    let new = EnvFilter::try_new(filter_directives)
+        .or_else(|_| EnvFilter::try_from_default_env())
+        .or_else(|_| EnvFilter::try_new(DEFAULT_LOG_LEVEL))?;
+    reload_handle.modify(|old| *old = new)?;
+
+    Ok(())
+}
+
+/// Set up the error handler crate
+pub fn install_color_eyre() -> Result<()> {
+    color_eyre::config::HookBuilder::new()
+        // Don't display the backtrace reminder by default:
+        //   Backtrace omitted. Run with RUST_BACKTRACE=1 environment variable to display it.
+        //   Run with RUST_BACKTRACE=full to include source snippets.
+        .display_env_section(false)
+        // Display location information by default:
+        //   Location:
+        //      src/steps.rs:92
+        .display_location_section(true)
+        .install()
+}