diff --git a/src/actions/package/install.rs b/src/actions/package/install.rs
index 369c5074..64ca075a 100644
--- a/src/actions/package/install.rs
+++ b/src/actions/package/install.rs
@@ -26,7 +26,7 @@ impl Action for PackageInstall {
 
         // If the provider isn't available, see if we can bootstrap it
         if !provider.available() {
-            if provider.bootstrap().is_empty() {
+            if provider.bootstrap().unwrap().is_empty() {
                 error!(
                     "Package Provider, {}, isn't available. Skipping action",
                     provider.name()
@@ -34,16 +34,16 @@ impl Action for PackageInstall {
                 return vec![];
             }
 
-            atoms.append(&mut provider.bootstrap());
+            atoms.append(&mut provider.bootstrap().unwrap());
         }
 
         if let Some(ref _repo) = variant.repository {
             if !provider.has_repository(&variant) {
-                atoms.append(&mut provider.add_repository(&variant));
+                atoms.append(&mut provider.add_repository(&variant).unwrap());
             }
         }
 
-        atoms.append(&mut provider.install(&variant));
+        atoms.append(&mut provider.install(&variant).unwrap());
 
         span.exit();
 
diff --git a/src/actions/package/providers/aptitude.rs b/src/actions/package/providers/aptitude.rs
index d88e3f49..58569ea7 100644
--- a/src/actions/package/providers/aptitude.rs
+++ b/src/actions/package/providers/aptitude.rs
@@ -33,8 +33,8 @@ impl PackageProvider for Aptitude {
         }
     }
 
-    fn bootstrap(&self) -> Vec<Step> {
-        vec![Step {
+    fn bootstrap(&self) -> Option<Vec<Step>> {
+        Some(vec![Step {
             atom: Box::new(Exec {
                 command: String::from("apt"),
                 arguments: vec![
@@ -50,16 +50,16 @@ impl PackageProvider for Aptitude {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }])
     }
 
     fn has_repository(&self, _package: &PackageVariant) -> bool {
         false
     }
 
-    fn add_repository(&self, package: &PackageVariant) -> Vec<Step> {
+    fn add_repository(&self, package: &PackageVariant) -> Option<Vec<Step>> {
         if package.repository.is_none() {
-            return vec![];
+            return None;
         }
 
         let mut steps: Vec<Step> = vec![];
@@ -106,15 +106,15 @@ impl PackageProvider for Aptitude {
             },
         ]);
 
-        steps
+        Some(steps)
     }
 
-    fn query(&self, package: &PackageVariant) -> Vec<String> {
-        package.packages()
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>> {
+        Some(package.packages())
     }
 
-    fn install(&self, package: &PackageVariant) -> Vec<Step> {
-        vec![Step {
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>> {
+        Some(vec![Step {
             atom: Box::new(Exec {
                 command: String::from("apt"),
                 arguments: vec![String::from("install"), String::from("--yes")]
@@ -128,7 +128,7 @@ impl PackageProvider for Aptitude {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }])
     }
 }
 
@@ -150,7 +150,7 @@ mod test {
         let aptitude = Aptitude {};
         let steps = aptitude.add_repository(&package);
 
-        assert_eq!(steps.len(), 0);
+        assert_eq!(steps.unwrap().len(), 0);
     }
 
     #[test]
@@ -164,7 +164,7 @@ mod test {
         let aptitude = Aptitude {};
         let steps = aptitude.add_repository(&package);
 
-        assert_eq!(steps.len(), 2);
+        assert_eq!(steps.unwrap().len(), 2);
     }
 
     #[test]
@@ -179,6 +179,6 @@ mod test {
         let aptitude = Aptitude {};
         let steps = aptitude.add_repository(&package);
 
-        assert_eq!(steps.len(), 3);
+        assert_eq!(steps.unwrap().len(), 3);
     }
 }
diff --git a/src/actions/package/providers/bsdpkg.rs b/src/actions/package/providers/bsdpkg.rs
index 8cf1ac7d..4724bbbc 100644
--- a/src/actions/package/providers/bsdpkg.rs
+++ b/src/actions/package/providers/bsdpkg.rs
@@ -32,8 +32,8 @@ impl PackageProvider for BsdPkg {
     }
 
     #[instrument(name = "bootstrap", level = "info", skip(self))]
-    fn bootstrap(&self) -> Vec<Step> {
-        vec![Step {
+    fn bootstrap(&self) -> Option<Vec<Step>> {
+        Some(vec![Step {
             atom: Box::new(Exec {
                 command: String::from("/usr/sbin/pkg"),
                 arguments: vec![String::from("bootstrap")],
@@ -43,25 +43,25 @@ impl PackageProvider for BsdPkg {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }])
     }
 
     fn has_repository(&self, _package: &PackageVariant) -> bool {
         false
     }
 
-    fn add_repository(&self, _package: &PackageVariant) -> Vec<Step> {
-        vec![]
+    fn add_repository(&self, _package: &PackageVariant) -> Option<Vec<Step>> {
+        None
     }
 
-    fn query(&self, package: &PackageVariant) -> Vec<String> {
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>> {
         // Install all packages for now, don't get smart about which
         // already are
-        package.packages()
+        Some(package.packages())
     }
 
-    fn install(&self, package: &PackageVariant) -> Vec<Step> {
-        vec![
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>> {
+        Some(vec![
             Step {
                 atom: Box::new(Exec {
                     command: String::from("/usr/sbin/pkg"),
@@ -90,6 +90,6 @@ impl PackageProvider for BsdPkg {
                 initializers: vec![],
                 finalizers: vec![],
             },
-        ]
+        ])
     }
 }
diff --git a/src/actions/package/providers/homebrew.rs b/src/actions/package/providers/homebrew.rs
index d1bc5ed4..8ea76c04 100644
--- a/src/actions/package/providers/homebrew.rs
+++ b/src/actions/package/providers/homebrew.rs
@@ -18,15 +18,15 @@ impl PackageProvider for Homebrew {
         which("brew").is_ok()
     }
 
-    fn bootstrap(&self) -> Vec<Step> {
-        vec![Step { atom: Box::new(Exec {
+    fn bootstrap(&self) -> Option<Vec<Step>> {
+        Some(vec![Step { atom: Box::new(Exec {
             command: String::from("bash"),
             arguments: vec![
                 String::from("-c"),
                 String::from("$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)")
             ],
             ..Default::default()
-        }), initializers: vec![], finalizers: vec![] },]
+        }), initializers: vec![], finalizers: vec![] },])
     }
 
     fn has_repository(&self, _: &PackageVariant) -> bool {
@@ -36,10 +36,10 @@ impl PackageProvider for Homebrew {
         false
     }
 
-    fn add_repository(&self, package: &PackageVariant) -> Vec<Step> {
+    fn add_repository(&self, package: &PackageVariant) -> Option<Vec<Step>> {
         let repository = package.repository.clone().unwrap();
 
-        vec![Step {
+        Some(vec![Step {
             atom: Box::new(Exec {
                 command: String::from("brew"),
                 arguments: vec![String::from("tap"), repository],
@@ -47,10 +47,10 @@ impl PackageProvider for Homebrew {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }])
     }
 
-    fn query(&self, package: &PackageVariant) -> Vec<String> {
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>> {
         let prefix = String::from_utf8(
             Command::new("brew")
                 .arg("--prefix")
@@ -65,36 +65,43 @@ impl PackageProvider for Homebrew {
         let cellar = Path::new(&prefix).join("Cellar");
         let caskroom = Path::new(&prefix).join("Caskroom");
 
-        package
-            .packages()
-            .into_iter()
-            .filter(|p| {
-                if cellar.join(&p).is_dir() {
-                    trace!("{}: found in Cellar", p);
-                    false
-                } else if caskroom.join(&p).is_dir() {
-                    trace!("{}: found in Caskroom", p);
-                    false
-                } else {
-                    debug!("{}: doesn't appear to be installed", p);
-                    true
-                }
-            })
-            .map(|p| match &package.repository {
-                Some(repository) => format!("{}/{}", repository, p),
-                None => p,
-            })
-            .collect()
+        Some(
+            package
+                .packages()
+                .into_iter()
+                .filter(|p| {
+                    if cellar.join(&p).is_dir() {
+                        trace!("{}: found in Cellar", p);
+                        false
+                    } else if caskroom.join(&p).is_dir() {
+                        trace!("{}: found in Caskroom", p);
+                        false
+                    } else {
+                        debug!("{}: doesn't appear to be installed", p);
+                        true
+                    }
+                })
+                .map(|p| match &package.repository {
+                    Some(repository) => format!("{}/{}", repository, p),
+                    None => p,
+                })
+                .collect(),
+        )
     }
 
-    fn install(&self, package: &PackageVariant) -> Vec<Step> {
-        let need_installed = self.query(package);
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>> {
+        // let need_installed = self.query(package);
+
+        // if need_installed.unwrap().is_empty() {
+        // return None;
+        // }
 
-        if need_installed.is_empty() {
-            return vec![];
-        }
+        let need_installed: Vec<String> = match self.query(package) {
+            Some(packages) => packages,
+            None => return None,
+        };
 
-        vec![Step {
+        Some(vec![Step {
             atom: Box::new(Exec {
                 command: String::from("brew"),
                 arguments: [
@@ -107,6 +114,6 @@ impl PackageProvider for Homebrew {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }])
     }
 }
diff --git a/src/actions/package/providers/mod.rs b/src/actions/package/providers/mod.rs
index 1874ad47..bbea31a0 100644
--- a/src/actions/package/providers/mod.rs
+++ b/src/actions/package/providers/mod.rs
@@ -80,9 +80,9 @@ impl Default for PackageProviders {
 pub trait PackageProvider {
     fn name(&self) -> &str;
     fn available(&self) -> bool;
-    fn bootstrap(&self) -> Vec<Step>;
+    fn bootstrap(&self) -> Option<Vec<Step>>;
     fn has_repository(&self, package: &PackageVariant) -> bool;
-    fn add_repository(&self, package: &PackageVariant) -> Vec<Step>;
-    fn query(&self, package: &PackageVariant) -> Vec<String>;
-    fn install(&self, package: &PackageVariant) -> Vec<Step>;
+    fn add_repository(&self, package: &PackageVariant) -> Option<Vec<Step>>;
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>>;
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>>;
 }
diff --git a/src/actions/package/providers/pkgin.rs b/src/actions/package/providers/pkgin.rs
index 077a4ffe..57b10560 100644
--- a/src/actions/package/providers/pkgin.rs
+++ b/src/actions/package/providers/pkgin.rs
@@ -27,28 +27,30 @@ impl PackageProvider for Pkgin {
     }
 
     #[instrument(name = "bootstrap", level = "info", skip(self))]
-    fn bootstrap(&self) -> Vec<Step> {
+    fn bootstrap(&self) -> Option<Vec<Step>> {
         // TODO: Adjust for boot strapping pkgin
-        vec![]
+        // vec![]
+        None
     }
 
     fn has_repository(&self, _package: &PackageVariant) -> bool {
         false
     }
 
-    fn add_repository(&self, _package: &PackageVariant) -> Vec<Step> {
-        vec![]
+    fn add_repository(&self, _package: &PackageVariant) -> Option<Vec<Step>> {
+        // vec![]
+        None
     }
 
     // TODO: Handle query pkgs with pkgin search
-    fn query(&self, package: &PackageVariant) -> Vec<String> {
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>> {
         // Install all packages for now, don't get smart about which
         // already are
-        package.packages()
+        Some(package.packages())
     }
 
-    fn install(&self, package: &PackageVariant) -> Vec<Step> {
-        vec![
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>> {
+        Some(vec![
             Step {
                 atom: Box::new(Exec {
                     command: String::from("/usr/pkg/bin/pkgin"),
@@ -77,6 +79,6 @@ impl PackageProvider for Pkgin {
                 initializers: vec![],
                 finalizers: vec![],
             },
-        ]
+        ])
     }
 }
diff --git a/src/actions/package/providers/winget.rs b/src/actions/package/providers/winget.rs
index 662be97e..ae926514 100644
--- a/src/actions/package/providers/winget.rs
+++ b/src/actions/package/providers/winget.rs
@@ -23,41 +23,45 @@ impl PackageProvider for Winget {
         }
     }
 
-    fn bootstrap(&self) -> Vec<Step> {
-        vec![]
+    fn bootstrap(&self) -> Option<Vec<Step>> {
+        // vec![]
+        None
     }
 
     fn has_repository(&self, _package: &PackageVariant) -> bool {
         true
     }
 
-    fn add_repository(&self, _package: &PackageVariant) -> Vec<Step> {
-        vec![]
+    fn add_repository(&self, _package: &PackageVariant) -> Option<Vec<Step>> {
+        // vec![]
+        None
     }
 
-    fn query(&self, package: &PackageVariant) -> Vec<String> {
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>> {
         // Install all packages, make this smarter soon
-        package.packages()
+        Some(package.packages())
     }
 
-    fn install(&self, package: &PackageVariant) -> Vec<Step> {
-        package
-            .packages()
-            .iter()
-            .map::<Step, _>(|p| Step {
-                atom: Box::new(Exec {
-                    command: String::from("winget"),
-                    arguments: [
-                        vec![String::from("install"), String::from("--silent")],
-                        package.extra_args.clone(),
-                        vec![p.clone()],
-                    ]
-                    .concat(),
-                    ..Default::default()
-                }),
-                initializers: vec![],
-                finalizers: vec![],
-            })
-            .collect()
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>> {
+        Some(
+            package
+                .packages()
+                .iter()
+                .map::<Step, _>(|p| Step {
+                    atom: Box::new(Exec {
+                        command: String::from("winget"),
+                        arguments: [
+                            vec![String::from("install"), String::from("--silent")],
+                            package.extra_args.clone(),
+                            vec![p.clone()],
+                        ]
+                        .concat(),
+                        ..Default::default()
+                    }),
+                    initializers: vec![],
+                    finalizers: vec![],
+                })
+                .collect(),
+        )
     }
 }
diff --git a/src/actions/package/providers/yay.rs b/src/actions/package/providers/yay.rs
index 92e1f736..88382c36 100644
--- a/src/actions/package/providers/yay.rs
+++ b/src/actions/package/providers/yay.rs
@@ -27,8 +27,8 @@ impl PackageProvider for Yay {
         }
     }
 
-    fn bootstrap(&self) -> Vec<Step> {
-        vec![
+    fn bootstrap(&self) -> Option<Vec<Step>> {
+        Some(vec![
             Step {
                 atom: Box::new(Exec {
                     command: String::from("pacman"),
@@ -67,18 +67,19 @@ impl PackageProvider for Yay {
                 initializers: vec![],
                 finalizers: vec![],
             },
-        ]
+        ])
     }
 
     fn has_repository(&self, _package: &PackageVariant) -> bool {
         false
     }
 
-    fn add_repository(&self, _package: &PackageVariant) -> Vec<Step> {
-        vec![]
+    fn add_repository(&self, _package: &PackageVariant) -> Option<Vec<Step>> {
+        // vec![]
+        None
     }
 
-    fn query(&self, package: &PackageVariant) -> Vec<String> {
+    fn query(&self, package: &PackageVariant) -> Option<Vec<String>> {
         let requested_already_installed: HashSet<String> = String::from_utf8(
             Command::new("yay")
                 .args(
@@ -99,27 +100,36 @@ impl PackageProvider for Yay {
             "all requested installed packages: {:?}",
             requested_already_installed
         );
-        package
-            .packages()
-            .into_iter()
-            .filter(|p| {
-                if requested_already_installed.contains(p) {
-                    trace!("{}: already installed", p);
-                    false
-                } else {
-                    debug!("{}: doesn't appear to be installed", p);
-                    true
-                }
-            })
-            .collect()
+        Some(
+            package
+                .packages()
+                .into_iter()
+                .filter(|p| {
+                    if requested_already_installed.contains(p) {
+                        trace!("{}: already installed", p);
+                        false
+                    } else {
+                        debug!("{}: doesn't appear to be installed", p);
+                        true
+                    }
+                })
+                .collect(),
+        )
     }
 
-    fn install(&self, package: &PackageVariant) -> Vec<Step> {
-        let need_installed = self.query(package);
-        if need_installed.is_empty() {
-            return vec![];
-        }
-        vec![Step {
+    fn install(&self, package: &PackageVariant) -> Option<Vec<Step>> {
+        // let need_installed = self.query(package);
+
+        //if need_installed.unwrap().is_empty() {
+        // return None;
+        //}
+
+        let need_installed = match self.query(package) {
+            Some(packages) => packages,
+            None => return None,
+        };
+
+        Some(vec![Step {
             atom: Box::new(Exec {
                 command: String::from("yay"),
                 arguments: [
@@ -137,6 +147,6 @@ impl PackageProvider for Yay {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }])
     }
 }