feat: gpauth support macos

apps/gpauth/src/cli.rs

@@ -1,21 +1,19 @@
-use std::borrow::Cow;
-
-use auth::{auth_prelogin, Authenticator, BrowserAuthenticator};
+use auth::{auth_prelogin, BrowserAuthenticator};
 use clap::Parser;
 use gpapi::{
   auth::{SamlAuthData, SamlAuthResult},
-  clap::{args::Os, handle_error, Args},
+  clap::{args::Os, handle_error, Args, InfoLevelVerbosity},
   gp_params::{ClientOs, GpParams},
   utils::{normalize_server, openssl},
   GP_USER_AGENT,
 };
-use log::{info, LevelFilter};
+use log::info;
 use serde_json::json;
 use tempfile::NamedTempFile;
 
 const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), " (", compile_time::date_str!(), ")");
 
-#[derive(Parser, Clone)]
+#[derive(Parser)]
 #[command(
   version = VERSION,
   author,
@@ -33,7 +31,7 @@ const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), " (", compile_time::dat
 See 'gpauth -h' for more information.
 "
 )]
-pub(crate) struct Cli {
+struct Cli {
   #[arg(help = "The portal server to authenticate")]
   server: String,
 
@@ -75,6 +73,9 @@ pub(crate) struct Cli {
   #[cfg(feature = "webview-auth")]
   #[arg(long, help = "Clean the cache of the embedded browser")]
   pub clean: bool,
+
+  #[command(flatten)]
+  verbose: InfoLevelVerbosity,
 }
 
 impl Args for Cli {
@@ -110,28 +111,26 @@ impl Cli {
     let openssl_conf = self.prepare_env()?;
 
     let server = normalize_server(&self.server)?;
-    let server: &'static str = Box::leak(server.into_boxed_str());
-    let gp_params: &'static GpParams = Box::leak(Box::new(self.build_gp_params()));
+    let gp_params = self.build_gp_params();
 
     let auth_request = match self.saml_request.as_deref() {
-      Some(auth_request) => Cow::Borrowed(auth_request),
-      None => Cow::Owned(auth_prelogin(server, gp_params).await?),
+      Some(auth_request) => auth_request.to_string(),
+      None => auth_prelogin(&server, &gp_params).await?,
     };
 
-    let auth_request: &'static str = Box::leak(auth_request.into_owned().into_boxed_str());
-    let authenticator = Authenticator::new(&server, gp_params).with_auth_request(&auth_request);
-
     #[cfg(feature = "webview-auth")]
     let browser = self
       .browser
       .as_deref()
-      .or_else(|| self.default_browser.then_some("default"));
+      .or_else(|| self.default_browser.then(|| "default"));
 
     #[cfg(not(feature = "webview-auth"))]
     let browser = self.browser.as_deref().or(Some("default"));
 
-    if browser.is_some() {
-      let auth_result = authenticator.browser_authenticate(browser).await;
+    if let Some(browser) = browser {
+      let authenticator = BrowserAuthenticator::new(&auth_request, browser);
+      let auth_result = authenticator.authenticate().await;
+
       print_auth_result(auth_result);
 
       // explicitly drop openssl_conf to avoid the unused variable warning
@@ -140,7 +139,7 @@ impl Cli {
     }
 
     #[cfg(feature = "webview-auth")]
-    crate::webview_auth::authenticate(&self, authenticator, openssl_conf)?;
+    crate::webview_auth::authenticate(server, gp_params, auth_request, self.clean, openssl_conf).await?;
 
     Ok(())
   }
@@ -158,14 +157,16 @@ impl Cli {
   }
 }
 
-fn init_logger() {
-  env_logger::builder().filter_level(LevelFilter::Info).init();
+fn init_logger(cli: &Cli) {
+  env_logger::builder()
+    .filter_level(cli.verbose.log_level_filter())
+    .init();
 }
 
 pub async fn run() {
   let cli = Cli::parse();
 
-  init_logger();
+  init_logger(&cli);
   info!("gpauth started: {}", VERSION);
 
   if let Err(err) = cli.run().await {

apps/gpauth/src/main.rs

@@ -1,6 +1,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 mod cli;
+
 #[cfg(feature = "webview-auth")]
 mod webview_auth;
 

apps/gpauth/src/webview_auth.rs

@@ -1,23 +1,28 @@
-use auth::{Authenticator, WebviewAuthenticator};
+use auth::WebviewAuthenticator;
+use gpapi::gp_params::GpParams;
 use log::info;
 use tauri::RunEvent;
 use tempfile::NamedTempFile;
 
-use crate::cli::{print_auth_result, Cli};
+use crate::cli::print_auth_result;
 
-pub fn authenticate(
-  cli: &Cli,
-  authenticator: Authenticator<'static>,
+pub async fn authenticate(
+  server: String,
+  gp_params: GpParams,
+  auth_request: String,
+  clean: bool,
   mut openssl_conf: Option<NamedTempFile>,
 ) -> anyhow::Result<()> {
-  let authenticator = authenticator.with_clean(cli.clean);
-
   tauri::Builder::default()
     .setup(move |app| {
       let app_handle = app.handle().clone();
 
       tauri::async_runtime::spawn(async move {
-        let auth_result = authenticator.webview_authenticate(&app_handle).await;
+        let authenticator = WebviewAuthenticator::new(&server, &gp_params)
+          .with_auth_request(&auth_request)
+          .with_clean(clean);
+
+        let auth_result = authenticator.authenticate(&app_handle).await;
         print_auth_result(auth_result);
 
         // Ensure the app exits after the authentication process