feat: oauth improvements, scope/refreshtoken options

Author: Eveeifyeve

Cargo.toml

@@ -13,6 +13,13 @@ tauri = { version = "2.2.4" }
 serde = "1.0"
 thiserror = "2"
 minecraft-essentials = {git = "https://github.com/minecraft-essentials/minecraft-essentials", branch = "0.2.12"}
+tokio = { version = "1.45.1", features = ["sync"] }
+url = "2.5.4"
+open = {version = "5.3.2", optional = true }
 
 [build-dependencies]
 tauri-plugin = { version = "2.0.3", features = ["build"] }
+
+
+[features]
+open = ["dep:open"]

build.rs

@@ -1,6 +1,17 @@
 const COMMANDS: &[&str] = &["ping"];
 
 fn main() {
-  tauri_plugin::Builder::new(COMMANDS)
-    .build();
+    tauri_plugin::Builder::new(COMMANDS).build();
+
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let mobile = target_os == "ios" || target_os == "android";
+    alias("desktop", !mobile);
+    alias("mobile", mobile);
+}
+
+fn alias(alias: &str, has_feature: bool) {
+    println!("cargo:rustc-check-cfg=cfg({alias})");
+    if has_feature {
+        println!("cargo:rustc-cfg={alias}");
+    }
 }

guest-js/index.ts

@@ -1,18 +1,21 @@
 import { invoke } from '@tauri-apps/api/core'
 
-interface CustomAuthData {
-	access_token: string,
-	uuid?: number,
-	expires_in: string,
-	xts_token?: string,
+interface OAuthParams {
+	client_id: string;
+	client_secret: string;
+	bedrock_rel: boolean;
+	refresh_token?: string;
+	scope?: string;
+	port?: number;
 }
 
+interface CustomAuthData {
+	access_token: string;
+	uuid?: number;
+	expires_in: string;
+	xts_token?: string;
+}
 
-export async function oauth(client_id: string, client_secret: string, bedrock_rel?: boolean, port?: number): Promise<CustomAuthData> {
-	return await invoke<CustomAuthData>('plugin:minecraft-essentails|oauth', {
-		client_id,
-		client_secret,
-		bedrock_rel,
-		port
-	}).then((r) => (r));
+export async function oauth(params: OAuthParams): Promise<CustomAuthData> {
+	return await invoke<CustomAuthData>('plugin:minecraft-essentials|oauth', { ...params });
 }

src/commands.rs

@@ -1,23 +1,87 @@
+use tauri::{command, AppHandle, Runtime};
 use tauri::{Url, WebviewWindowBuilder};
-use tauri::{AppHandle, command, Runtime};
 
 use minecraft_essentials::{AuthType, AuthenticationBuilder, CustomAuthData};
+#[cfg(feature = "open")]
+use open;
+
 use std::str::FromStr;
 
 #[command]
-pub async fn oauth<R: Runtime>(app: AppHandle<R>, client_id: &str, client_secret: &str, bedrock_rel: bool, port: Option<u16>) -> Result<CustomAuthData, String> {
-    let mut auth = AuthenticationBuilder::builder(); 
-    auth.of_type(AuthType::Oauth).client_id(client_id).client_secret(client_secret).bedrockrel(bedrock_rel).port(port);
-    
-    let get_info = auth.get_info().await.ouath_url.unwrap();
-    let url = Url::from_str(&get_info).map_err(|e| e.to_string())?;
-    let window = WebviewWindowBuilder::new(&app, "Minecraft Authentification", tauri::WebviewUrl::External(url)).closable(true).build().map_err(|e| e.to_string())?;
-
-    let auth_info: CustomAuthData = auth.launch().await.map_err(|e| e.to_string())?; 
-
-    if auth_info.access_token.is_some() {
-        let _ = window.close();
+#[cfg(desktop)]
+pub async fn oauth<R: Runtime>(
+    app: AppHandle<R>,
+    client_id: &str,
+    client_secret: &str,
+    bedrock_rel: bool,
+    refresh_token: Option<String>,
+    scope: Option<String>,
+    port: Option<u16>,
+) -> Result<CustomAuthData, String> {
+    let mut builder = AuthenticationBuilder::builder();
+
+    if let Some(token) = refresh_token {
+        let _ = builder
+            .of_type(AuthType::Refresh)
+            .refresh_token(Some(token))
+            .map_err(|e| e.to_string())?;
+    } else {
+        builder.of_type(AuthType::Oauth);
+    }
+
+    if scope.is_some() {
+        builder.scope(scope);
+    };
+
+    builder
+        .client_id(client_id)
+        .client_secret(client_secret)
+        .bedrockrel(bedrock_rel)
+        .port(port);
+
+    let get_info = builder.get_info().await;
+    let oauth_url_str = get_info.ouath_url.ok_or_else(|| {
+        "Could not retrieve the OAuth URL from the authentication provider.".to_string()
+    })?;
+
+    let webview_window_to_close: Option<tauri::WebviewWindow<R>> = {
+        #[cfg(not(feature = "open"))]
+        {
+            let url = Url::from_str(&oauth_url_str).map_err(|e| e.to_string())?;
+
+            let window = WebviewWindowBuilder::new(
+                &app,
+                "minecraft-authentication",
+                tauri::WebviewUrl::External(url),
+            )
+            .title("Minecraft Authentication")
+            .closable(true)
+            .inner_size(500.0, 650.0)
+            .build()
+            .map_err(|e| e.to_string())?;
+            Some(window) // Return the created window
+        }
+        #[cfg(feature = "open")]
+        {
+            open::that(&oauth_url_str)
+                .map_err(|e| format!("Failed to open URL in browser: {}", e))?;
+            None
+        }
     };
 
+    let auth_info =
+        tauri::async_runtime::spawn(
+            async move { builder.launch().await.map_err(|e| e.to_string()) },
+        )
+        .await
+        .map_err(|e| e.to_string())?
+        .map_err(|e| e.to_string())?;
+
+    if let Some(window) = webview_window_to_close {
+        if auth_info.access_token.is_some() {
+            let _ = window.close();
+        }
+    }
+
     Ok(auth_info)
-} 
+}

src/lib.rs

@@ -1,38 +1,28 @@
-use tauri::{
-  plugin::{Builder, TauriPlugin},
-  Manager, Runtime, AppHandle
-};
+pub use error::{Error, Result};
+use tauri::{plugin::TauriPlugin, AppHandle, Manager, Runtime};
 
 pub use minecraft_essentials::CustomAuthData;
 
 mod commands;
 mod error;
-mod models;
-
-pub use error::{Error, Result};
 
 /// Access to the minecraft-essentails APIs.
 pub struct MinecraftEssentails<R: Runtime>(AppHandle<R>);
 
 /// Extensions to [`tauri::App`], [`tauri::AppHandle`] and [`tauri::Window`] to access the minecraft-essentails APIs.
 pub trait MinecraftEssentailsExt<R: Runtime> {
-  fn minecraft_essentails(&self) -> &MinecraftEssentails<R>;
+    fn minecraft_essentails(&self) -> &MinecraftEssentails<R>;
 }
 
 impl<R: Runtime, T: Manager<R>> crate::MinecraftEssentailsExt<R> for T {
-  fn minecraft_essentails(&self) -> &MinecraftEssentails<R> {
-    self.state::<MinecraftEssentails<R>>().inner()
-  }
+    fn minecraft_essentails(&self) -> &MinecraftEssentails<R> {
+        self.state::<MinecraftEssentails<R>>().inner()
+    }
 }
 
 /// Initializes the plugin.
 pub fn init<R: Runtime>() -> TauriPlugin<R> {
-  Builder::new("minecraft-essentails")
-    .invoke_handler(tauri::generate_handler![commands::oauth])
-    .setup(|app, _api| {
-      #[cfg(desktop)]
-      app.manage(MinecraftEssentails(app.clone()));
-      Ok(())
-    })
-    .build()
+    tauri::plugin::Builder::new("minecraft-essentails")
+        .invoke_handler(tauri::generate_handler![commands::oauth])
+        .build()
 }