This builds, I guess.

src/config/client.rs

@@ -0,0 +1,60 @@
+use clap::Parser;
+use crate::config::config_file::ConfigFile;
+use crate::config::error::ConfigurationError;
+use crate::config::logging::LoggingConfiguration;
+use crate::config::runtime::RuntimeConfiguration;
+use crate::config::command_line::ClientArguments;
+pub use crate::config::command_line::ClientCommand;
+use std::ffi::OsString;
+use tracing_core::LevelFilter;
+
+pub struct ClientConfiguration {
+    pub runtime: RuntimeConfiguration,
+    pub logging: LoggingConfiguration,
+    config_file: Option<ConfigFile>,
+    command: ClientCommand,
+}
+
+impl ClientConfiguration {
+    /// Load a basic client configuration for this run.
+    ///
+    /// This will parse the process's command line arguments, and parse
+    /// a config file if given, but will not interpret this information
+    /// beyond that required to understand the user's goals for the
+    /// runtime system and logging. For this reason, it is not async,
+    /// as it is responsible for determining all the information we
+    /// will use to generate the runtime.
+    pub fn new<I, T>(args: I) -> Result<Self, ConfigurationError>
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<OsString> + Clone,
+    {
+        let mut command_line_arguments = ClientArguments::try_parse_from(args)?;
+        let mut config_file = ConfigFile::new(command_line_arguments.arguments.config_file.take())?;
+        let mut runtime = RuntimeConfiguration::default();
+        let mut logging = LoggingConfiguration::default();
+
+        // we prefer the command line to the config file, so first merge
+        // in the config file so that when we later merge the command line,
+        // it overwrites any config file options.
+        if let Some(config_file) = config_file.as_mut() {
+            config_file.merge_standard_options_into(&mut runtime, &mut logging);
+        }
+        command_line_arguments.arguments.merge_standard_options_into(&mut runtime, &mut logging);
+        if command_line_arguments.command.is_list_command() {
+            logging.filter = LevelFilter::ERROR;
+        }
+
+        Ok(ClientConfiguration {
+            runtime,
+            logging,
+            config_file,
+            command: command_line_arguments.command,
+        })
+    }
+
+    // Returns the command we received from the user
+    pub fn command(&self) -> &ClientCommand {
+        &self.command
+    }
+}