refactor(promise): change functions returning PromiseInterface to async fn

17 files changed, 289 insertions, 307 deletions

diff --git a/crates/shirabe/src/downloader/archive_downloader.rs b/crates/shirabe/src/downloader/archive_downloader.rs
index 3346275..4842b05 100644
--- a/crates/shirabe/src/downloader/archive_downloader.rs
+++ b/crates/shirabe/src/downloader/archive_downloader.rs
@@ -2,7 +2,6 @@
 
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_external_packages::symfony::component::finder::Finder;
 use shirabe_php_shim::{
     DIRECTORY_SEPARATOR, RuntimeException, bin2hex, file_exists, is_dir, random_bytes, realpath,
@@ -20,32 +19,32 @@ pub trait ArchiveDownloader {
     fn cleanup_executed(&self) -> &IndexMap<String, bool>;
     fn cleanup_executed_mut(&mut self) -> &mut IndexMap<String, bool>;
 
-    fn extract(
+    async fn extract(
         &self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>>;
+    ) -> Result<Option<PhpMixed>>;
 
-    fn prepare(
+    async fn prepare(
         &mut self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.cleanup_executed_mut().remove(package.get_name());
         self.inner_mut()
             .prepare(r#type, package, path, prev_package)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &mut self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.cleanup_executed_mut()
             .insert(package.get_name().to_string(), true);
         self.inner_mut()
@@ -56,12 +55,12 @@ pub trait ArchiveDownloader {
     ///
     /// @throws \RuntimeException
     /// @throws \UnexpectedValueException
-    fn install(
+    async fn install(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if output {
             self.inner().io.write_error(&format!(
                 "  - {}{}",
diff --git a/crates/shirabe/src/downloader/download_manager.rs b/crates/shirabe/src/downloader/download_manager.rs
index e81a6bb..3100e29 100644
--- a/crates/shirabe/src/downloader/download_manager.rs
+++ b/crates/shirabe/src/downloader/download_manager.rs
@@ -4,7 +4,6 @@ use crate::io::io_interface;
 use anyhow::Result;
 use indexmap::IndexMap;
 use shirabe_external_packages::composer::pcre::Preg;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::{
     InvalidArgumentException, LogicException, PhpMixed, RuntimeException, array_keys,
     array_reverse, array_shift, dirname, get_class, implode, in_array, preg_quote, rtrim, sprintf,
@@ -195,12 +194,12 @@ impl DownloadManager {
     ///
     /// @throws \InvalidArgumentException if package have no urls to download from
     /// @throws \RuntimeException
-    pub fn download(
+    pub async fn download(
         &self,
         package: &dyn PackageInterface,
         target_dir: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         self.filesystem
             .borrow_mut()
@@ -291,13 +290,13 @@ impl DownloadManager {
     /// @param string                $targetDir   target dir
     /// @param PackageInterface|null $prevPackage previous package instance in case of updates
     /// @phpstan-return PromiseInterface<void|null>
-    pub fn prepare(
+    pub async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         target_dir: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         if let Some(downloader) = self.get_downloader_for_package(package)? {
             return downloader.prepare(r#type, package, &target_dir, prev_package);
@@ -314,11 +313,11 @@ impl DownloadManager {
     ///
     /// @throws \InvalidArgumentException if package have no urls to download from
     /// @throws \RuntimeException
-    pub fn install(
+    pub async fn install(
         &self,
         package: &dyn PackageInterface,
         target_dir: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         if let Some(downloader) = self.get_downloader_for_package(package)? {
             return downloader.install2(package, &target_dir);
@@ -335,12 +334,12 @@ impl DownloadManager {
     /// @phpstan-return PromiseInterface<void|null>
     ///
     /// @throws \InvalidArgumentException if initial package is not installed
-    pub fn update(
+    pub async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         target_dir: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         let downloader = self.get_downloader_for_package(target)?;
         let initial_downloader = self.get_downloader_for_package(initial)?;
@@ -403,11 +402,11 @@ impl DownloadManager {
     /// @param PackageInterface $package   package instance
     /// @param string           $targetDir target dir
     /// @phpstan-return PromiseInterface<void|null>
-    pub fn remove(
+    pub async fn remove(
         &self,
         package: &dyn PackageInterface,
         target_dir: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         if let Some(downloader) = self.get_downloader_for_package(package)? {
             return downloader.remove2(package, &target_dir);
@@ -423,13 +422,13 @@ impl DownloadManager {
     /// @param string                $targetDir   target dir
     /// @param PackageInterface|null $prevPackage previous package instance in case of updates
     /// @phpstan-return PromiseInterface<void|null>
-    pub fn cleanup(
+    pub async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         target_dir: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let target_dir = self.normalize_target_dir(target_dir);
         if let Some(downloader) = self.get_downloader_for_package(package)? {
             return downloader.cleanup(r#type, package, &target_dir, prev_package);
diff --git a/crates/shirabe/src/downloader/downloader_interface.rs b/crates/shirabe/src/downloader/downloader_interface.rs
index 9ced979..7b333e6 100644
--- a/crates/shirabe/src/downloader/downloader_interface.rs
+++ b/crates/shirabe/src/downloader/downloader_interface.rs
@@ -1,84 +1,83 @@
 //! ref: composer/src/Composer/Downloader/DownloaderInterface.php
 
-use shirabe_external_packages::react::promise::PromiseInterface;
-
 use crate::package::PackageInterface;
+use shirabe_php_shim::PhpMixed;
 
 pub trait DownloaderInterface: std::fmt::Debug {
     fn get_installation_source(&self) -> String;
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>>;
+    ) -> anyhow::Result<Option<PhpMixed>>;
 
     /// Convenience for the PHP default `$output = true` overload.
-    fn download3(
+    async fn download3(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         self.download(package, path, prev_package, true)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>>;
+    ) -> anyhow::Result<Option<PhpMixed>>;
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>>;
+    ) -> anyhow::Result<Option<PhpMixed>>;
 
     /// Convenience for the PHP default `$output = true` overload.
-    fn install2(
+    async fn install2(
         &self,
         package: &dyn PackageInterface,
         path: &str,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         self.install(package, path, true)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>>;
+    ) -> anyhow::Result<Option<PhpMixed>>;
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>>;
+    ) -> anyhow::Result<Option<PhpMixed>>;
 
     /// Convenience for the PHP default `$output = true` overload.
-    fn remove2(
+    async fn remove2(
         &self,
         package: &dyn PackageInterface,
         path: &str,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         self.remove(package, path, true)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>>;
+    ) -> anyhow::Result<Option<PhpMixed>>;
 
     /// TODO(phase-b): runtime downcast helpers for PHP `instanceof` checks.
     fn as_change_report_interface(&self) -> Option<&dyn crate::downloader::ChangeReportInterface> {
diff --git a/crates/shirabe/src/downloader/file_downloader.rs b/crates/shirabe/src/downloader/file_downloader.rs
index ce5d275..0920342 100644
--- a/crates/shirabe/src/downloader/file_downloader.rs
+++ b/crates/shirabe/src/downloader/file_downloader.rs
@@ -6,7 +6,6 @@ use indexmap::IndexMap;
 use std::sync::{LazyLock, Mutex};
 
 use crate::util::Silencer;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_external_packages::react::promise::resolve as react_promise_resolve;
 use shirabe_php_shim::{
     DIRECTORY_SEPARATOR, InvalidArgumentException, PATHINFO_BASENAME, PATHINFO_EXTENSION,
@@ -148,13 +147,13 @@ impl DownloaderInterface for FileDownloader {
     }
 
     /// @inheritDoc
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         _prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if package.get_dist_url().is_none() {
             return Err(InvalidArgumentException {
                 message: "The given package is missing url information".to_string(),
@@ -212,24 +211,24 @@ impl DownloaderInterface for FileDownloader {
     }
 
     /// @inheritDoc
-    fn prepare(
+    async fn prepare(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         Ok(react_promise_resolve(Some(PhpMixed::Null)))
     }
 
     /// @inheritDoc
-    fn cleanup(
+    async fn cleanup(
         &self,
         _type: &str,
         package: &dyn PackageInterface,
         path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let file_name = self.get_file_name(package, path);
         if file_exists(&file_name) {
             self.filesystem.borrow_mut().unlink(&file_name)?;
@@ -278,12 +277,12 @@ impl DownloaderInterface for FileDownloader {
     }
 
     /// @inheritDoc
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if output {
             self.io
                 .write_error(&format!("  - {}", InstallOperation::format(package, false)));
@@ -338,12 +337,12 @@ impl DownloaderInterface for FileDownloader {
     }
 
     /// @inheritDoc
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.io.write_error(&format!(
             "  - {}{}",
             UpdateOperation::format(initial, target, false),
@@ -357,12 +356,12 @@ impl DownloaderInterface for FileDownloader {
     }
 
     /// @inheritDoc
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if output {
             self.io.write_error(&format!(
                 "  - {}",
diff --git a/crates/shirabe/src/downloader/fossil_downloader.rs b/crates/shirabe/src/downloader/fossil_downloader.rs
index 363fd50..fc3d0e8 100644
--- a/crates/shirabe/src/downloader/fossil_downloader.rs
+++ b/crates/shirabe/src/downloader/fossil_downloader.rs
@@ -9,8 +9,7 @@ use crate::util::Filesystem;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
 use shirabe_external_packages::composer::pcre::Preg;
-use shirabe_external_packages::react::promise::PromiseInterface;
-use shirabe_php_shim::RuntimeException;
+use shirabe_php_shim::{PhpMixed, RuntimeException};
 
 #[derive(Debug)]
 pub struct FossilDownloader {
@@ -29,22 +28,22 @@ impl FossilDownloader {
         }
     }
 
-    pub(crate) fn do_download(
+    pub(crate) async fn do_download(
         &self,
         _package: &dyn PackageInterface,
         _path: String,
         _url: String,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub(crate) fn do_install(
+    pub(crate) async fn do_install(
         &self,
         package: &dyn PackageInterface,
         path: String,
         url: String,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.config.borrow_mut().prohibit_url_by_config(
             &url,
             Some(self.inner.io.as_ref()),
@@ -99,13 +98,13 @@ impl FossilDownloader {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub(crate) fn do_update(
+    pub(crate) async fn do_update(
         &self,
         _initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: String,
         url: String,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.config.borrow_mut().prohibit_url_by_config(
             &url,
             Some(self.inner.io.as_ref()),
@@ -256,60 +255,60 @@ impl DownloaderInterface for FossilDownloader {
         todo!()
     }
 
-    fn download(
+    async fn download(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn install(
+    async fn install(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn update(
+    async fn update(
         &self,
         _initial: &dyn PackageInterface,
         _target: &dyn PackageInterface,
         _path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn remove(
+    async fn remove(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 }
diff --git a/crates/shirabe/src/downloader/git_downloader.rs b/crates/shirabe/src/downloader/git_downloader.rs
index 9c4c64d..e6bc16b 100644
--- a/crates/shirabe/src/downloader/git_downloader.rs
+++ b/crates/shirabe/src/downloader/git_downloader.rs
@@ -5,7 +5,6 @@ use anyhow::Result;
 use indexmap::IndexMap;
 use shirabe_external_packages::composer::pcre::{CaptureKey, Preg};
 use shirabe_external_packages::react::promise;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::{
     PhpMixed, RuntimeException, array_map, basename, dirname, implode, in_array, is_dir,
     preg_quote, realpath, rtrim, sprintf, strlen, strpos, substr, trim, version_compare,
@@ -58,13 +57,13 @@ impl GitDownloader {
         }
     }
 
-    pub(crate) fn do_download(
+    pub(crate) async fn do_download(
         &mut self,
         package: &dyn PackageInterface,
         _path: &str,
         url: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         // Do not create an extra local cache when repository is already local
         if Filesystem::is_local_path(url) {
             return Ok(promise::resolve(None));
@@ -133,12 +132,12 @@ impl GitDownloader {
         Ok(promise::resolve(None))
     }
 
-    pub(crate) fn do_install(
+    pub(crate) async fn do_install(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         url: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         GitUtil::clean_env(&self.inner.process);
         let path = self.normalize_path(path);
         let cache_path = format!(
@@ -286,13 +285,13 @@ impl GitDownloader {
         Ok(promise::resolve(None))
     }
 
-    pub(crate) fn do_update(
+    pub(crate) async fn do_update(
         &mut self,
         _initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
         url: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         GitUtil::clean_env(&self.inner.process);
         let path = self.normalize_path(path);
         if !self.has_metadata_repository(&path) {
@@ -685,12 +684,12 @@ impl GitDownloader {
         unpushed_changes
     }
 
-    pub(crate) fn clean_changes(
+    pub(crate) async fn clean_changes(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         update: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         GitUtil::clean_env(&self.inner.process);
         let path = self.normalize_path(path);
 
@@ -1224,7 +1223,7 @@ impl GitDownloader {
 
     /// @phpstan-return PromiseInterface<void|null>
     /// @throws \RuntimeException
-    pub(crate) fn discard_changes(&mut self, path: &str) -> Result<Box<dyn PromiseInterface>> {
+    pub(crate) async fn discard_changes(&mut self, path: &str) -> Result<Option<PhpMixed>> {
         let path = self.normalize_path(path);
         let mut output = String::new();
         if self.inner.process.borrow_mut().execute_args(
@@ -1260,7 +1259,7 @@ impl GitDownloader {
 
     /// @phpstan-return PromiseInterface<void|null>
     /// @throws \RuntimeException
-    pub(crate) fn stash_changes(&mut self, path: &str) -> Result<Box<dyn PromiseInterface>> {
+    pub(crate) async fn stash_changes(&mut self, path: &str) -> Result<Option<PhpMixed>> {
         let path = self.normalize_path(path);
         let mut output = String::new();
         if self.inner.process.borrow_mut().execute_args(
@@ -1365,60 +1364,60 @@ impl crate::downloader::DownloaderInterface for GitDownloader {
         todo!()
     }
 
-    fn download(
+    async fn download(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
         _output: bool,
-    ) -> anyhow::Result<Box<dyn shirabe_external_packages::react::promise::PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn shirabe_external_packages::react::promise::PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn install(
+    async fn install(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> anyhow::Result<Box<dyn shirabe_external_packages::react::promise::PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn update(
+    async fn update(
         &self,
         _initial: &dyn PackageInterface,
         _target: &dyn PackageInterface,
         _path: &str,
-    ) -> anyhow::Result<Box<dyn shirabe_external_packages::react::promise::PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn remove(
+    async fn remove(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> anyhow::Result<Box<dyn shirabe_external_packages::react::promise::PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn shirabe_external_packages::react::promise::PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 }
diff --git a/crates/shirabe/src/downloader/gzip_downloader.rs b/crates/shirabe/src/downloader/gzip_downloader.rs
index 557fe3a..a3fbb49 100644
--- a/crates/shirabe/src/downloader/gzip_downloader.rs
+++ b/crates/shirabe/src/downloader/gzip_downloader.rs
@@ -13,7 +13,6 @@ use crate::util::Platform;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::{
     DIRECTORY_SEPARATOR, PATHINFO_FILENAME, PHP_URL_PATH, PhpMixed, RuntimeException,
     extension_loaded, fclose, fopen, fwrite, gzclose, gzopen, gzread, implode, parse_url, pathinfo,
@@ -50,12 +49,12 @@ impl GzipDownloader {
         }
     }
 
-    pub(crate) fn extract(
+    pub(crate) async fn extract(
         &mut self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let filename = pathinfo(
             parse_url(
                 &strtr(&package.get_dist_url().unwrap_or_default(), "\\", "/"),
@@ -135,60 +134,60 @@ impl crate::downloader::DownloaderInterface for GzipDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }
diff --git a/crates/shirabe/src/downloader/hg_downloader.rs b/crates/shirabe/src/downloader/hg_downloader.rs
index 986a214..16cf73c 100644
--- a/crates/shirabe/src/downloader/hg_downloader.rs
+++ b/crates/shirabe/src/downloader/hg_downloader.rs
@@ -9,8 +9,7 @@ use crate::util::Filesystem;
 use crate::util::Hg as HgUtils;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
-use shirabe_external_packages::react::promise::PromiseInterface;
-use shirabe_php_shim::RuntimeException;
+use shirabe_php_shim::{PhpMixed, RuntimeException};
 
 #[derive(Debug)]
 pub struct HgDownloader {
@@ -29,13 +28,13 @@ impl HgDownloader {
         }
     }
 
-    pub(crate) fn do_download(
+    pub(crate) async fn do_download(
         &self,
         package: &dyn PackageInterface,
         path: String,
         url: String,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if HgUtils::get_version(&self.inner.process).is_none() {
             return Err(RuntimeException {
                 message: "hg was not found in your PATH, skipping source download".to_string(),
@@ -47,12 +46,12 @@ impl HgDownloader {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub(crate) fn do_install(
+    pub(crate) async fn do_install(
         &self,
         package: &dyn PackageInterface,
         path: String,
         url: String,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let hg_utils = HgUtils::new(
             &*self.inner.io,
             &*self.inner.config.borrow(),
@@ -101,13 +100,13 @@ impl HgDownloader {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub(crate) fn do_update(
+    pub(crate) async fn do_update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: String,
         url: String,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let hg_utils = HgUtils::new(
             &*self.inner.io,
             &*self.inner.config.borrow(),
@@ -226,60 +225,60 @@ impl DownloaderInterface for HgDownloader {
         todo!()
     }
 
-    fn download(
+    async fn download(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn install(
+    async fn install(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn update(
+    async fn update(
         &self,
         _initial: &dyn PackageInterface,
         _target: &dyn PackageInterface,
         _path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn remove(
+    async fn remove(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 }
diff --git a/crates/shirabe/src/downloader/path_downloader.rs b/crates/shirabe/src/downloader/path_downloader.rs
index 9003e81..3da4915 100644
--- a/crates/shirabe/src/downloader/path_downloader.rs
+++ b/crates/shirabe/src/downloader/path_downloader.rs
@@ -3,7 +3,6 @@
 use crate::io::io_interface;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_external_packages::symfony::component::filesystem::Filesystem as SymfonyFilesystem;
 use shirabe_external_packages::symfony::component::filesystem::exception::IOException;
 use shirabe_php_shim::{
@@ -61,13 +60,13 @@ impl PathDownloader {
         }
     }
 
-    pub fn download(
+    pub async fn download(
         &mut self,
         package: &dyn PackageInterface,
         path: String,
         _prev_package: Option<&dyn PackageInterface>,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let path = Filesystem::trim_trailing_slash(&path);
         let url = package.get_dist_url().ok_or_else(|| RuntimeException {
             message: format!(
@@ -123,12 +122,12 @@ impl PathDownloader {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub fn install(
+    pub async fn install(
         &mut self,
         package: &dyn PackageInterface,
         path: String,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let path = Filesystem::trim_trailing_slash(&path);
         let url = package.get_dist_url().ok_or_else(|| RuntimeException {
             message: format!(
@@ -294,12 +293,12 @@ impl PathDownloader {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub fn remove(
+    pub async fn remove(
         &mut self,
         package: &dyn PackageInterface,
         path: String,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let path = Filesystem::trim_trailing_slash(&path);
         // realpath() may resolve Windows junctions to the source path, so we'll check for a junction
         // first to prevent a false positive when checking if the dist and install paths are the same.
@@ -543,60 +542,60 @@ impl DownloaderInterface for PathDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }
diff --git a/crates/shirabe/src/downloader/perforce_downloader.rs b/crates/shirabe/src/downloader/perforce_downloader.rs
index 433ae8f..ae433ef 100644
--- a/crates/shirabe/src/downloader/perforce_downloader.rs
+++ b/crates/shirabe/src/downloader/perforce_downloader.rs
@@ -11,7 +11,6 @@ use crate::util::Perforce;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::PhpMixed;
 use std::any::Any;
 
@@ -34,22 +33,22 @@ impl PerforceDownloader {
         }
     }
 
-    pub(crate) fn do_download(
+    pub(crate) async fn do_download(
         &self,
         _package: &dyn PackageInterface,
         _path: String,
         _url: String,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    pub fn do_install(
+    pub async fn do_install(
         &mut self,
         package: &dyn PackageInterface,
         path: String,
         url: String,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let source_ref = package.get_source_reference().map(|s| s.to_string());
         let label = self.get_label_from_source_reference(source_ref.clone().unwrap_or_default());
 
@@ -112,13 +111,13 @@ impl PerforceDownloader {
         repository.get_repo_config().clone()
     }
 
-    pub(crate) fn do_update(
+    pub(crate) async fn do_update(
         &mut self,
         _initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: String,
         url: String,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.do_install(target, path, url)
     }
 
@@ -165,60 +164,60 @@ impl DownloaderInterface for PerforceDownloader {
         todo!()
     }
 
-    fn download(
+    async fn download(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn install(
+    async fn install(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn update(
+    async fn update(
         &self,
         _initial: &dyn PackageInterface,
         _target: &dyn PackageInterface,
         _path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn remove(
+    async fn remove(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         todo!()
     }
 }
diff --git a/crates/shirabe/src/downloader/phar_downloader.rs b/crates/shirabe/src/downloader/phar_downloader.rs
index ee87bd1..f3fffb9 100644
--- a/crates/shirabe/src/downloader/phar_downloader.rs
+++ b/crates/shirabe/src/downloader/phar_downloader.rs
@@ -13,8 +13,7 @@ use crate::util::HttpDownloader;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
-use shirabe_php_shim::Phar;
+use shirabe_php_shim::{Phar, PhpMixed};
 
 #[derive(Debug)]
 pub struct PharDownloader {
@@ -46,12 +45,12 @@ impl PharDownloader {
         }
     }
 
-    pub(crate) fn extract(
+    pub(crate) async fn extract(
         &self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         // Can throw an UnexpectedValueException
         let archive = Phar::new(file.to_string());
         archive.extract_to(path, None, true);
@@ -69,60 +68,60 @@ impl DownloaderInterface for PharDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }
diff --git a/crates/shirabe/src/downloader/rar_downloader.rs b/crates/shirabe/src/downloader/rar_downloader.rs
index fd45c7d..71efc29 100644
--- a/crates/shirabe/src/downloader/rar_downloader.rs
+++ b/crates/shirabe/src/downloader/rar_downloader.rs
@@ -14,7 +14,6 @@ use crate::util::Platform;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::{
     PhpMixed, RarArchive, RuntimeException, UnexpectedValueException, class_exists, implode,
 };
@@ -49,12 +48,12 @@ impl RarDownloader {
         }
     }
 
-    pub(crate) fn extract(
+    pub(crate) async fn extract(
         &mut self,
         _package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let mut process_error: Option<String> = None;
 
         if !Platform::is_windows() {
@@ -149,60 +148,60 @@ impl crate::downloader::DownloaderInterface for RarDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }
diff --git a/crates/shirabe/src/downloader/svn_downloader.rs b/crates/shirabe/src/downloader/svn_downloader.rs
index fc5bca7..65e3e37 100644
--- a/crates/shirabe/src/downloader/svn_downloader.rs
+++ b/crates/shirabe/src/downloader/svn_downloader.rs
@@ -4,7 +4,6 @@ use crate::io::io_interface;
 use indexmap::IndexMap;
 use shirabe_external_packages::composer::pcre::{CaptureKey, Preg};
 use shirabe_external_packages::react::promise;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::{PhpMixed, RuntimeException, is_dir, version_compare};
 
 use crate::config::Config;
@@ -36,13 +35,13 @@ impl SvnDownloader {
         }
     }
 
-    pub(crate) fn do_download(
+    pub(crate) async fn do_download(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         url: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         SvnUtil::clean_env();
         let mut util = SvnUtil::new(
             url.to_string(),
@@ -61,12 +60,12 @@ impl SvnDownloader {
         Ok(promise::resolve(None))
     }
 
-    pub(crate) fn do_install(
+    pub(crate) async fn do_install(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         url: &str,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         SvnUtil::clean_env();
         let r#ref = package.get_source_reference();
 
@@ -105,13 +104,13 @@ impl SvnDownloader {
         Ok(promise::resolve(None))
     }
 
-    pub(crate) fn do_update(
+    pub(crate) async fn do_update(
         &mut self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
         url: &str,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         SvnUtil::clean_env();
         let r#ref = target.get_source_reference();
 
@@ -203,12 +202,12 @@ impl SvnDownloader {
             })
     }
 
-    pub(crate) fn clean_changes(
+    pub(crate) async fn clean_changes(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         update: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         let changes = self.get_local_changes(package, path);
         if changes.is_none() {
             return Ok(promise::resolve(None));
@@ -404,7 +403,7 @@ impl SvnDownloader {
         }
     }
 
-    pub(crate) fn discard_changes(&self, path: &str) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    pub(crate) async fn discard_changes(&self, path: &str) -> anyhow::Result<Option<PhpMixed>> {
         let mut output = String::new();
         if self.inner.process.borrow_mut().execute_args(
             &["svn", "revert", "-R", "."].map(|s| s.to_string()).to_vec(),
@@ -438,60 +437,60 @@ impl DownloaderInterface for SvnDownloader {
         todo!()
     }
 
-    fn download(
+    async fn download(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
         _output: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn install(
+    async fn install(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn update(
+    async fn update(
         &self,
         _initial: &dyn PackageInterface,
         _target: &dyn PackageInterface,
         _path: &str,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn remove(
+    async fn remove(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _output: bool,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         _type: &str,
         _package: &dyn PackageInterface,
         _path: &str,
         _prev_package: Option<&dyn PackageInterface>,
-    ) -> anyhow::Result<Box<dyn PromiseInterface>> {
+    ) -> anyhow::Result<Option<PhpMixed>> {
         todo!()
     }
 }
diff --git a/crates/shirabe/src/downloader/tar_downloader.rs b/crates/shirabe/src/downloader/tar_downloader.rs
index b98b274..b65d0e3 100644
--- a/crates/shirabe/src/downloader/tar_downloader.rs
+++ b/crates/shirabe/src/downloader/tar_downloader.rs
@@ -13,8 +13,7 @@ use crate::util::HttpDownloader;
 use crate::util::ProcessExecutor;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
-use shirabe_php_shim::PharData;
+use shirabe_php_shim::{PharData, PhpMixed};
 
 #[derive(Debug)]
 pub struct TarDownloader {
@@ -46,12 +45,12 @@ impl TarDownloader {
         }
     }
 
-    pub(crate) fn extract(
+    pub(crate) async fn extract(
         &self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let archive = PharData::new(file.to_string());
         archive.extract_to(path, None, true);
 
@@ -64,60 +63,60 @@ impl DownloaderInterface for TarDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }
diff --git a/crates/shirabe/src/downloader/vcs_downloader.rs b/crates/shirabe/src/downloader/vcs_downloader.rs
index 31f4c7c..1219ab1 100644
--- a/crates/shirabe/src/downloader/vcs_downloader.rs
+++ b/crates/shirabe/src/downloader/vcs_downloader.rs
@@ -3,7 +3,6 @@
 use crate::io::io_interface;
 use anyhow::Result;
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::{
     InvalidArgumentException, PhpMixed, RuntimeException, array_map, array_shift, count, explode,
     get_class, get_class_err, implode, rawurldecode, realpath, str_replace, strlen, strpos, substr,
@@ -58,12 +57,12 @@ impl VcsDownloaderBase {
     /// call this when they need to invoke the base behavior. Since this lives on the data struct,
     /// it cannot consult subclass-specific `get_local_changes`; it assumes any callers have
     /// already verified that no local changes exist.
-    pub fn clean_changes(
+    pub async fn clean_changes(
         &self,
         _package: &dyn PackageInterface,
         _path: &str,
         _update: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         // TODO(phase-b): parent::cleanChanges() rechecks getLocalChanges via dynamic dispatch.
         // Callers in subclasses must do that check themselves (they already have).
         Ok(shirabe_external_packages::react::promise::resolve(None))
@@ -85,30 +84,30 @@ pub trait VcsDownloader:
     fn has_cleaned_changes_mut(&mut self) -> &mut IndexMap<String, bool>;
 
     /// Downloads data needed to run an install/update later
-    fn do_download(
+    async fn do_download(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         url: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>>;
+    ) -> Result<Option<PhpMixed>>;
 
     /// Downloads specific package into specific folder.
-    fn do_install(
+    async fn do_install(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         url: &str,
-    ) -> Result<Box<dyn PromiseInterface>>;
+    ) -> Result<Option<PhpMixed>>;
 
     /// Updates specific package in specific folder from initial to target version.
-    fn do_update(
+    async fn do_update(
         &mut self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
         url: &str,
-    ) -> Result<Box<dyn PromiseInterface>>;
+    ) -> Result<Option<PhpMixed>>;
 
     /// Fetches the commit logs between two commits
     fn get_commit_logs(&self, from_reference: &str, to_reference: &str, path: &str) -> String;
@@ -121,12 +120,12 @@ pub trait VcsDownloader:
         "source".to_string()
     }
 
-    fn download(
+    async fn download(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if package.get_source_reference().is_none() {
             return Err(InvalidArgumentException {
                 message: format!(
@@ -142,7 +141,7 @@ pub trait VcsDownloader:
 
         while let Some(url) = array_shift(&mut urls) {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
-            let attempt: Result<Box<dyn PromiseInterface>> =
+            let attempt: Result<Option<PhpMixed>> =
                 self.do_download(package, path, &url, prev_package);
             match attempt {
                 Ok(promise) => return Ok(promise),
@@ -186,13 +185,13 @@ pub trait VcsDownloader:
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    fn prepare(
+    async fn prepare(
         &mut self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if r#type == "update" {
             self.clean_changes(prev_package.unwrap(), path, true)?;
             self.has_cleaned_changes_mut()
@@ -208,13 +207,13 @@ pub trait VcsDownloader:
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    fn cleanup(
+    async fn cleanup(
         &mut self,
         r#type: &str,
         _package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if r#type == "update"
             && prev_package
                 .map(|p| {
@@ -231,11 +230,11 @@ pub trait VcsDownloader:
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    fn install(
+    async fn install(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if package.get_source_reference().is_none() {
             return Err(InvalidArgumentException {
                 message: format!(
@@ -256,7 +255,7 @@ pub trait VcsDownloader:
         let mut urls = self.prepare_urls(package.get_source_urls());
         while let Some(url) = array_shift(&mut urls) {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
-            let attempt: Result<Box<dyn PromiseInterface>> = self.do_install(package, path, &url);
+            let attempt: Result<Option<PhpMixed>> = self.do_install(package, path, &url);
             match attempt {
                 Ok(_) => break,
                 Err(e) => {
@@ -299,12 +298,12 @@ pub trait VcsDownloader:
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    fn update(
+    async fn update(
         &mut self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         if target.get_source_reference().is_none() {
             return Err(InvalidArgumentException {
                 message: format!(
@@ -327,8 +326,7 @@ pub trait VcsDownloader:
         let mut exception: Option<anyhow::Error> = None;
         while let Some(url) = array_shift(&mut urls) {
             // TODO(phase-b): use anyhow::Result<Result<T, E>> to model PHP try/catch
-            let attempt: Result<Box<dyn PromiseInterface>> =
-                self.do_update(initial, target, path, &url);
+            let attempt: Result<Option<PhpMixed>> = self.do_update(initial, target, path, &url);
             match attempt {
                 Ok(_) => {
                     exception = None;
@@ -409,11 +407,11 @@ pub trait VcsDownloader:
         Ok(shirabe_external_packages::react::promise::resolve(None))
     }
 
-    fn remove(
+    async fn remove(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.io_mut().write_error3(
             &format!("  - {}", UninstallOperation::format(package, false)),
             true,
@@ -467,12 +465,12 @@ pub trait VcsDownloader:
     ///
     /// @param  bool $update  if true (update) the changes can be stashed and reapplied after an update,
     ///                       if false (remove) the changes should be assumed to be lost if the operation is not aborted
-    fn clean_changes(
+    async fn clean_changes(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         _update: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         // the default implementation just fails if there are any changes, override in child classes to provide stash-ability
         if self.get_local_changes(package, path)?.is_some() {
             return Err(RuntimeException {
diff --git a/crates/shirabe/src/downloader/xz_downloader.rs b/crates/shirabe/src/downloader/xz_downloader.rs
index 7724e9a..6cc960e 100644
--- a/crates/shirabe/src/downloader/xz_downloader.rs
+++ b/crates/shirabe/src/downloader/xz_downloader.rs
@@ -12,7 +12,6 @@ use crate::util::HttpDownloader;
 use crate::util::ProcessExecutor;
 use anyhow::{Result, bail};
 use indexmap::IndexMap;
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_php_shim::PhpMixed;
 
 #[derive(Debug)]
@@ -45,12 +44,12 @@ impl XzDownloader {
         }
     }
 
-    pub(crate) fn extract(
+    pub(crate) async fn extract(
         &mut self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let command = vec!["tar", "-xJf", file, "-C", path];
 
         let mut ignored_output = PhpMixed::Null;
@@ -83,60 +82,60 @@ impl crate::downloader::DownloaderInterface for XzDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }
diff --git a/crates/shirabe/src/downloader/zip_downloader.rs b/crates/shirabe/src/downloader/zip_downloader.rs
index c51a9ea..ef18f95 100644
--- a/crates/shirabe/src/downloader/zip_downloader.rs
+++ b/crates/shirabe/src/downloader/zip_downloader.rs
@@ -9,13 +9,12 @@ use crate::util::Platform;
 use anyhow::Result;
 use indexmap::IndexMap;
 use shirabe_external_packages::composer::pcre::{CaptureKey, Preg};
-use shirabe_external_packages::react::promise::PromiseInterface;
 use shirabe_external_packages::symfony::component::process::ExecutableFinder;
 use shirabe_external_packages::symfony::component::process::Process;
 use shirabe_php_shim::{
-    DIRECTORY_SEPARATOR, ErrorException, RuntimeException, UnexpectedValueException, ZipArchive,
-    bin2hex, class_exists, file_exists, file_get_contents, filesize, function_exists, hash_file,
-    is_file, json_encode, random_int, version_compare,
+    DIRECTORY_SEPARATOR, ErrorException, PhpMixed, RuntimeException, UnexpectedValueException,
+    ZipArchive, bin2hex, class_exists, file_exists, file_get_contents, filesize, function_exists,
+    hash_file, is_file, json_encode, random_int, version_compare,
 };
 use std::sync::Mutex;
 
@@ -58,13 +57,13 @@ impl ZipDownloader {
         }
     }
 
-    pub fn download(
+    pub async fn download(
         &mut self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         {
             let mut unzip_commands = UNZIP_COMMANDS.lock().unwrap();
             if unzip_commands.is_none() {
@@ -196,12 +195,12 @@ impl ZipDownloader {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn extract_with_system_unzip(
+    async fn extract_with_system_unzip(
         &mut self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         static WARNED_7ZIP_LINUX: Mutex<bool> = Mutex::new(false);
 
         let is_last_chance = !HAS_ZIP_ARCHIVE.lock().unwrap().unwrap_or(false);
@@ -288,18 +287,18 @@ impl ZipDownloader {
         }
     }
 
-    fn extract_with_zip_archive(
+    async fn extract_with_zip_archive(
         &mut self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         let mut zip_archive = self
             .zip_archive_object
             .take()
             .unwrap_or_else(ZipArchive::new);
 
-        let result: Result<Box<dyn PromiseInterface>> = (|| {
+        let result: Result<Option<PhpMixed>> = (|| {
             let retval = if !file_exists(file) || filesize(file).map_or(true, |s| s == 0) {
                 Err(-1i64)
             } else {
@@ -387,12 +386,12 @@ impl ZipDownloader {
         })
     }
 
-    pub(crate) fn extract(
+    pub(crate) async fn extract(
         &mut self,
         package: &dyn PackageInterface,
         file: &str,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.extract_with_system_unzip(package, file, path)
     }
 
@@ -427,60 +426,60 @@ impl crate::downloader::DownloaderInterface for ZipDownloader {
         self.inner.get_installation_source()
     }
 
-    fn download(
+    async fn download(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.download(package, path, prev_package, output)
     }
 
-    fn prepare(
+    async fn prepare(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.prepare(r#type, package, path, prev_package)
     }
 
-    fn install(
+    async fn install(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.install(package, path, output)
     }
 
-    fn update(
+    async fn update(
         &self,
         initial: &dyn PackageInterface,
         target: &dyn PackageInterface,
         path: &str,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.update(initial, target, path)
     }
 
-    fn remove(
+    async fn remove(
         &self,
         package: &dyn PackageInterface,
         path: &str,
         output: bool,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.remove(package, path, output)
     }
 
-    fn cleanup(
+    async fn cleanup(
         &self,
         r#type: &str,
         package: &dyn PackageInterface,
         path: &str,
         prev_package: Option<&dyn PackageInterface>,
-    ) -> Result<Box<dyn PromiseInterface>> {
+    ) -> Result<Option<PhpMixed>> {
         self.inner.cleanup(r#type, package, path, prev_package)
     }
 }