pake-cli 2.6.1 → 3.0.1

package/src-tauri/pake.json

@@ -8,8 +8,8 @@
       "width": 1200,
       "height": 780,
       "resizable": true,
-      "dark_mode": false,
       "always_on_top": false,
+      "dark_mode": false,
       "activation_shortcut": "",
       "disabled_web_shortcuts": false
     }
@@ -24,5 +24,7 @@
     "linux": true,
     "windows": true
   },
-  "inject": []
+  "system_tray_path": "icons/icon.png",
+  "inject": [],
+  "proxy_url": ""
 }

package/src-tauri/src/app/config.rs

@@ -52,6 +52,8 @@ pub struct PakeConfig {
     pub windows: Vec<WindowConfig>,
     pub user_agent: UserAgent,
     pub system_tray: FunctionON,
+    pub system_tray_path: String,
+    pub proxy_url: String,
 }
 
 impl PakeConfig {

package/src-tauri/src/app/invoke.rs

@@ -1,8 +1,10 @@
 use crate::util::{check_file_or_append, get_download_message, show_toast, MessageType};
 use std::fs::{self, File};
 use std::io::Write;
-use tauri::api::http::{ClientBuilder, HttpRequestBuilder, ResponseType};
-use tauri::{api, command, AppHandle, Manager, Window};
+use std::str::FromStr;
+use tauri::http::Method;
+use tauri::{command, AppHandle, Manager, Url, WebviewWindow};
+use tauri_plugin_http::reqwest::{ClientBuilder, Request};
 
 #[derive(serde::Deserialize)]
 pub struct DownloadFileParams {
@@ -18,24 +20,23 @@ pub struct BinaryDownloadParams {
 
 #[command]
 pub async fn download_file(app: AppHandle, params: DownloadFileParams) -> Result<(), String> {
-    let window: Window = app.get_window("pake").unwrap();
+    let window: WebviewWindow = app.get_webview_window("pake").unwrap();
     show_toast(&window, &get_download_message(MessageType::Start));
 
-    let output_path = api::path::download_dir().unwrap().join(params.filename);
+    let output_path = app.path().download_dir().unwrap().join(params.filename);
     let file_path = check_file_or_append(output_path.to_str().unwrap());
     let client = ClientBuilder::new().build().unwrap();
 
     let response = client
-        .send(
-            HttpRequestBuilder::new("GET", &params.url)
-                .unwrap()
-                .response_type(ResponseType::Binary),
-        )
+        .execute(Request::new(
+            Method::GET,
+            Url::from_str(&params.url).unwrap(),
+        ))
         .await;
 
     match response {
         Ok(res) => {
-            let bytes = res.bytes().await.unwrap().data;
+            let bytes = res.bytes().await.unwrap();
 
             let mut file = File::create(file_path).unwrap();
             file.write_all(&bytes).unwrap();
@@ -54,9 +55,9 @@ pub async fn download_file_by_binary(
     app: AppHandle,
     params: BinaryDownloadParams,
 ) -> Result<(), String> {
-    let window: Window = app.get_window("pake").unwrap();
+    let window: WebviewWindow = app.get_webview_window("pake").unwrap();
     show_toast(&window, &get_download_message(MessageType::Start));
-    let output_path = api::path::download_dir().unwrap().join(params.filename);
+    let output_path = app.path().download_dir().unwrap().join(params.filename);
     let file_path = check_file_or_append(output_path.to_str().unwrap());
     let download_file_result = fs::write(file_path, &params.binary);
     match download_file_result {

package/src-tauri/src/app/menu.rs

@@ -1,31 +1,36 @@
-use tauri::{CustomMenuItem, Manager, SystemTray, SystemTrayEvent, SystemTrayMenu};
+use tauri::{
+    menu::{MenuBuilder, MenuItemBuilder},
+    tray::TrayIconBuilder,
+    AppHandle, Manager,
+};
 use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
-pub fn get_system_tray() -> SystemTray {
-    let hide_app = CustomMenuItem::new("hide_app".to_string(), "Hide");
-    let show_app = CustomMenuItem::new("show_app".to_string(), "Show");
-    let quit = CustomMenuItem::new("quit".to_string(), "Quit");
-    let tray_menu = SystemTrayMenu::new()
-        .add_item(show_app)
-        .add_item(hide_app)
-        .add_item(quit);
-    SystemTray::new().with_menu(tray_menu)
-}
-
-pub fn system_tray_handle(app: &tauri::AppHandle, event: SystemTrayEvent) {
-    if let SystemTrayEvent::MenuItemClick { tray_id: _, id, .. } = event {
-        match id.as_str() {
+pub fn set_system_tray(app: &AppHandle) -> tauri::Result<()> {
+    let hide_app = MenuItemBuilder::with_id("hide_app", "Hide").build(app)?;
+    let show_app = MenuItemBuilder::with_id("show_app", "Show").build(app)?;
+    let quit = MenuItemBuilder::with_id("quit", "Quit").build(app)?;
+    let menu = MenuBuilder::new(app)
+        .items(&[&hide_app, &show_app, &quit])
+        .build()?;
+    app.app_handle().remove_tray_by_id("pake-tray");
+    let tray = TrayIconBuilder::new()
+        .menu(&menu)
+        .on_menu_event(move |app, event| match event.id().as_ref() {
             "hide_app" => {
-                app.get_window("pake").unwrap().minimize().unwrap();
+                app.get_webview_window("pake").unwrap().minimize().unwrap();
             }
             "show_app" => {
-                app.get_window("pake").unwrap().show().unwrap();
+                app.get_webview_window("pake").unwrap().show().unwrap();
             }
             "quit" => {
                 let _res = app.save_window_state(StateFlags::all());
                 std::process::exit(0);
             }
-            _ => {}
-        }
-    };
+            _ => (),
+        })
+        .icon(app.default_window_icon().unwrap().clone())
+        .build(app)?;
+
+    tray.set_icon_as_template(false)?;
+    Ok(())
 }

package/src-tauri/src/app/window.rs

@@ -1,11 +1,11 @@
 use crate::app::config::PakeConfig;
-use std::path::PathBuf;
-use tauri::{App, Window, WindowBuilder, WindowUrl};
+use std::{path::PathBuf, str::FromStr};
+use tauri::{App, Url, WebviewUrl, WebviewWindow, WebviewWindowBuilder};
 
 #[cfg(target_os = "macos")]
 use tauri::{Theme, TitleBarStyle};
 
-pub fn build_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Window {
+pub fn get_window(app: &mut App, config: &PakeConfig, _data_dir: PathBuf) -> WebviewWindow {
     let window_config = config
         .windows
         .first()
@@ -14,8 +14,8 @@ pub fn build_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Wi
     let user_agent = config.user_agent.get();
 
     let url = match window_config.url_type.as_str() {
-        "web" => WindowUrl::App(window_config.url.parse().unwrap()),
-        "local" => WindowUrl::App(PathBuf::from(&window_config.url)),
+        "web" => WebviewUrl::App(window_config.url.parse().unwrap()),
+        "local" => WebviewUrl::App(PathBuf::from(&window_config.url)),
         _ => panic!("url type can only be web or local"),
     };
 
@@ -24,7 +24,7 @@ pub fn build_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Wi
         serde_json::to_string(&window_config).unwrap()
     );
 
-    let mut window_builder = WindowBuilder::new(app, "pake", url)
+    let mut window_builder = WebviewWindowBuilder::new(app, "pake", url)
         .title("")
         .visible(false)
         .user_agent(user_agent)
@@ -32,12 +32,18 @@ pub fn build_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Wi
         .fullscreen(window_config.fullscreen)
         .inner_size(window_config.width, window_config.height)
         .always_on_top(window_config.always_on_top)
+        .disable_drag_drop_handler()
         .initialization_script(&config_script)
         .initialization_script(include_str!("../inject/component.js"))
         .initialization_script(include_str!("../inject/event.js"))
         .initialization_script(include_str!("../inject/style.js"))
         .initialization_script(include_str!("../inject/custom.js"));
 
+    if !config.proxy_url.is_empty() {
+        window_builder =
+            window_builder.proxy_url(Url::from_str(config.proxy_url.as_str()).unwrap());
+    }
+
     #[cfg(target_os = "macos")]
     {
         let title_bar_style = if window_config.hide_title_bar {
@@ -45,7 +51,6 @@ pub fn build_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Wi
         } else {
             TitleBarStyle::Visible
         };
-
         window_builder = window_builder.title_bar_style(title_bar_style);
 
         if window_config.dark_mode {
@@ -57,7 +62,7 @@ pub fn build_window(app: &mut App, config: PakeConfig, _data_dir: PathBuf) -> Wi
     {
         window_builder = window_builder
             .data_directory(_data_dir)
-            .title(app.package_info().name.clone())
+            .title(app.package_info().name.clone());
     }
 
     window_builder.build().expect("Failed to build window")

package/src-tauri/src/inject/custom.js

@@ -1,6 +0,0 @@
-/*
- * This file serves as a collection point for external JS and CSS dependencies.
- * It amalgamates these external resources for easier injection into the application.
- * Additionally, you can directly include any script files in this file
- * that you wish to attach to the application.
- */

package/src-tauri/src/inject/event.js

@@ -45,22 +45,16 @@ function isDownloadLink(url) {
     'jpg', 'm3u8', 'mov', 'mp3', 'mp4', 'mpa', 'mpg', 'mpeg', 'msi', 'odt',
     'ogg', 'ogv', 'pdf', 'png', 'ppt', 'pptx', 'psd', 'rar', 'raw',
     'svg', 'swf', 'tar', 'tif', 'tiff', 'ts', 'txt', 'wav', 'webm', 'webp',
-    'wma', 'wmv', 'xls', 'xlsx', 'xml', 'zip', 'json', 'yaml', '7zip', 'mkv'
+    'wma', 'wmv', 'xls', 'xlsx', 'xml', 'zip', 'json', 'yaml', '7zip', 'mkv',
   ];
   const downloadLinkPattern = new RegExp(`\\.(${fileExtensions.join('|')})$`, 'i');
   return downloadLinkPattern.test(url);
 }
 
-// No need to go to the download link.
-function externalDownLoadLink() {
-  return ['quickref.me'].indexOf(location.hostname) > -1;
-}
-
-
 document.addEventListener('DOMContentLoaded', () => {
   const tauri = window.__TAURI__;
-  const appWindow = tauri.window.appWindow;
-  const invoke = tauri.tauri.invoke;
+  const appWindow = tauri.window.getCurrentWindow();
+  const invoke = tauri.core.invoke;
 
   if (!document.getElementById('pake-top-dom')) {
     const topDom = document.createElement('div');
@@ -71,19 +65,19 @@ document.addEventListener('DOMContentLoaded', () => {
   const domEl = document.getElementById('pake-top-dom');
 
   domEl.addEventListener('touchstart', () => {
-    appWindow.startDragging().then();
+    appWindow.startDragging();
   });
 
   domEl.addEventListener('mousedown', e => {
     e.preventDefault();
     if (e.buttons === 1 && e.detail !== 2) {
-      appWindow.startDragging().then();
+      appWindow.startDragging();
     }
   });
 
   domEl.addEventListener('dblclick', () => {
     appWindow.isFullscreen().then(fullscreen => {
-      appWindow.setFullscreen(!fullscreen).then();
+      appWindow.setFullscreen(!fullscreen);
     });
   });
 
@@ -186,30 +180,38 @@ document.addEventListener('DOMContentLoaded', () => {
 
   const isDownloadRequired = (url, anchorElement, e) => anchorElement.download || e.metaKey || e.ctrlKey || isDownloadLink(url);
 
-  const handleExternalLink = (e, url) => {
-    e.preventDefault();
-    tauri.shell.open(url);
-  };
-
-  const handleDownloadLink = (e, url, filename) => {
-    e.preventDefault();
-    invoke('download_file', { params: { url, filename } });
+  const handleExternalLink = url => {
+    invoke('plugin:shell|open', {
+      path: url,
+    });
   };
 
   const detectAnchorElementClick = e => {
+
     const anchorElement = e.target.closest('a');
-    if (anchorElement && anchorElement.href) {
-      if (!anchorElement.target) {
-        anchorElement.target = '_self';
-      }
 
+    if (anchorElement && anchorElement.href) {
+      const target = anchorElement.target;
       const hrefUrl = new URL(anchorElement.href);
       const absoluteUrl = hrefUrl.href;
       let filename = anchorElement.download || getFilenameFromUrl(absoluteUrl);
 
+      // Handling external link redirection, _blank will automatically open.
+      if (target === '_blank') {
+        e.preventDefault();
+        return;
+      }
+
+      if (target === '_new') {
+        e.preventDefault();
+        handleExternalLink(absoluteUrl);
+        return;
+      }
+
       // Process download links for Rust to handle.
-      if (isDownloadRequired(absoluteUrl, anchorElement, e) && !externalDownLoadLink() && !isSpecialDownload(absoluteUrl)) {
-        handleDownloadLink(e, absoluteUrl, filename);
+      if (isDownloadRequired(absoluteUrl, anchorElement, e) && !isSpecialDownload(absoluteUrl)) {
+        e.preventDefault();
+        invoke('download_file', { params: { url: absoluteUrl, filename } });
       }
     }
   };
@@ -231,7 +233,7 @@ document.addEventListener('DOMContentLoaded', () => {
     } else {
       const baseUrl = window.location.origin + window.location.pathname;
       const hrefUrl = new URL(url, baseUrl);
-      tauri.shell.open(hrefUrl.href);
+      handleExternalLink(hrefUrl.href);
     }
     // Call the original window.open function to maintain its normal functionality.
     return originalWindowOpen.call(window, url, name, specs);

package/src-tauri/src/inject/style.js

@@ -119,7 +119,8 @@ window.addEventListener('DOMContentLoaded', _event => {
       display: none !important;
     }
 
-    #react-root [data-testid="DMDrawer"] {
+    #react-root [data-testid="DMDrawer"],
+    #root > main > footer.justify-center.ease-in {
       visibility: hidden !important;
     }
 
@@ -333,6 +334,14 @@ window.addEventListener('DOMContentLoaded', _event => {
     #__next>div>div>.flex.h-screen.w-full.flex-col.items-center {
       padding-top: 20px;
     }
+    
+    body > div.relative.flex.h-full.w-full.overflow-hidden.transition-colors.z-0 > div.z-\\[21\\].flex-shrink-0.overflow-x-hidden.bg-token-sidebar-surface-primary.max-md\\:\\!w-0 > div > div > div > nav > div.flex.justify-between.h-\\[60px\\].items-center.md\\:h-header-height {
+       padding-top: 25px;
+    }
+    
+    body > div.relative.flex.h-full.w-full.overflow-hidden.transition-colors.z-0 > div.relative.flex.h-full.max-w-full.flex-1.flex-col.overflow-hidden > main > div.composer-parent.flex.h-full.flex-col.focus-visible\\:outline-0 > div.flex-1.overflow-hidden.\\@container\\/thread > div > div.absolute.left-0.right-0 > div{
+      padding-top: 35px;
+    }
 
     #__next .sticky.left-0.right-0.top-0.z-20.bg-black{
       padding-top: 0px;
@@ -378,6 +387,10 @@ window.addEventListener('DOMContentLoaded', _event => {
     .lark > .main-wrapper [data-testid="aside"] {
       top: 15px;
     }
+    
+    #global > div.header-container > .mask-paper {
+      padding-top: 20px;
+    }
 
     #background.ytd-masthead {
       height: 68px;

package/src-tauri/src/lib.rs

@@ -0,0 +1,133 @@
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+mod app;
+mod util;
+
+use app::{invoke, menu::set_system_tray, window};
+use invoke::{download_file, download_file_by_binary};
+use std::str::FromStr;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use tauri::Manager;
+use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut};
+use tauri_plugin_window_state::Builder as windowStatePlugin;
+use util::{get_data_dir, get_pake_config};
+use window::get_window;
+
+pub fn run_app() {
+    let (pake_config, tauri_config) = get_pake_config();
+
+    let tauri_app = tauri::Builder::default();
+
+    let show_system_tray = pake_config.show_system_tray();
+
+    // Save the value of toggle_app_shortcut before pake_config is moved
+    let activation_shortcut = pake_config.windows[0].activation_shortcut.clone();
+    let init_fullscreen = pake_config.windows[0].fullscreen;
+
+    let window_state_plugin = if init_fullscreen {
+        windowStatePlugin::default()
+            .with_state_flags(tauri_plugin_window_state::StateFlags::FULLSCREEN)
+            .build()
+    } else {
+        windowStatePlugin::default().build()
+    };
+
+    tauri_app
+        .plugin(window_state_plugin)
+        .plugin(tauri_plugin_oauth::init())
+        .plugin(tauri_plugin_http::init())
+        .plugin(tauri_plugin_shell::init())
+        .invoke_handler(tauri::generate_handler![
+            download_file,
+            download_file_by_binary
+        ])
+        .setup(move |app| {
+            let data_dir = get_data_dir(app.app_handle(), tauri_config.clone());
+
+            let _window = get_window(app, &pake_config, data_dir);
+
+            // Prevent initial shaking
+            _window.show().unwrap();
+
+            if show_system_tray {
+                let _ = set_system_tray(app.app_handle());
+            } else {
+                app.app_handle().remove_tray_by_id("pake-tray");
+            }
+
+            if !activation_shortcut.is_empty() {
+                let app_handle = app.app_handle().clone();
+                let shortcut_hotkey = Shortcut::from_str(activation_shortcut.as_str()).unwrap();
+                let last_triggered = Arc::new(Mutex::new(Instant::now()));
+
+                app_handle
+                    .plugin(
+                        tauri_plugin_global_shortcut::Builder::new()
+                            .with_handler({
+                                let last_triggered = Arc::clone(&last_triggered);
+                                move |app, event, _shortcut| {
+                                    // Fixed the bug of tauri's hidden call, which caused repeated execution
+                                    let now = Instant::now();
+                                    let mut last = last_triggered.lock().unwrap();
+                                    if now.duration_since(*last) < Duration::from_millis(500) {
+                                        return;
+                                    }
+                                    *last = now;
+
+                                    if shortcut_hotkey.eq(event) {
+                                        let window = app.get_webview_window("pake").unwrap();
+                                        let is_visible = window.is_visible().unwrap();
+
+                                        match is_visible {
+                                            true => {
+                                                window.minimize().unwrap();
+                                            }
+                                            false => {
+                                                window.unminimize().unwrap();
+                                                window.set_focus().unwrap();
+                                            }
+                                        }
+                                    }
+                                }
+                            })
+                            .build(),
+                    )
+                    .expect("Error registering global evoke shortcuts!");
+
+                app.global_shortcut().register(shortcut_hotkey)?;
+            }
+
+            Ok(())
+        })
+        .on_window_event(|window, event| {
+            if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+                let window = window.clone();
+
+                #[cfg(target_os = "macos")]
+                {
+                    let window_handle = window.clone();
+                    tauri::async_runtime::spawn(async move {
+                        if window_handle.is_fullscreen().unwrap_or(false) {
+                            window_handle.set_fullscreen(false).unwrap();
+                            // Give a small delay to ensure the full-screen exit operation is completed.
+                            tokio::time::sleep(Duration::from_millis(900)).await;
+                        }
+                        window_handle.minimize().unwrap();
+                        window_handle.hide().unwrap();
+                    });
+                }
+
+                #[cfg(not(target_os = "macos"))]
+                window.close().unwrap();
+
+                api.prevent_close();
+            }
+        })
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+
+pub fn run() {
+    run_app()
+}

package/src-tauri/src/main.rs

@@ -3,93 +3,6 @@
     windows_subsystem = "windows"
 )]
 
-mod app;
-mod util;
-
-use app::{invoke, menu, window};
-use invoke::{download_file, download_file_by_binary};
-use menu::{get_system_tray, system_tray_handle};
-use tauri::{GlobalShortcutManager, Manager};
-use util::{get_data_dir, get_pake_config};
-use window::build_window;
-
-#[cfg(target_os = "macos")]
-use std::time::Duration;
-
-pub fn run_app() {
-    let (pake_config, tauri_config) = get_pake_config();
-    let data_dir = get_data_dir(tauri_config);
-
-    let mut tauri_app = tauri::Builder::default();
-
-    let show_system_tray = pake_config.show_system_tray();
-    let system_tray = get_system_tray();
-
-    if show_system_tray {
-        tauri_app = tauri_app
-            .system_tray(system_tray)
-            .on_system_tray_event(system_tray_handle);
-    }
-
-    // Save the value of toggle_app_shortcut before pake_config is moved
-    let activation_shortcut = pake_config.windows[0].activation_shortcut.clone();
-
-    tauri_app
-        .plugin(tauri_plugin_window_state::Builder::default().build())
-        .plugin(tauri_plugin_oauth::init())
-        .invoke_handler(tauri::generate_handler![
-            download_file,
-            download_file_by_binary
-        ])
-        .setup(move |app| {
-            let _window = build_window(app, pake_config, data_dir);
-            _window.show().unwrap();
-            if !activation_shortcut.is_empty() {
-                let app_handle = app.app_handle().clone();
-                app_handle
-                    .global_shortcut_manager()
-                    .register(activation_shortcut.as_str(), move || {
-                        match _window.is_visible().unwrap() {
-                            true => _window.hide().unwrap(),
-                            false => {
-                                _window.show().unwrap();
-                                _window.set_focus().unwrap();
-                            }
-                        }
-                    })
-                    .expect("Error registering global evoke shortcuts!");
-            }
-
-            Ok(())
-        })
-        .on_window_event(|event| {
-            if let tauri::WindowEvent::CloseRequested { api, .. } = event.event() {
-                let window = event.window();
-
-                #[cfg(target_os = "macos")]
-                {
-                    let window_handle = window.clone();
-                    tauri::async_runtime::spawn(async move {
-                        if window_handle.is_fullscreen().unwrap_or(false) {
-                            window_handle.set_fullscreen(false).unwrap();
-                            // Give a small delay to ensure the full-screen exit operation is completed.
-                            tokio::time::sleep(Duration::from_millis(900)).await;
-                        }
-                        window_handle.minimize().unwrap();
-                        window_handle.hide().unwrap();
-                    });
-                }
-
-                #[cfg(not(target_os = "macos"))]
-                window.close().unwrap();
-
-                api.prevent_close();
-            }
-        })
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
-
 fn main() {
-    run_app()
+    app_lib::run()
 }

package/src-tauri/src/util.rs

@@ -1,7 +1,7 @@
 use crate::app::config::PakeConfig;
 use std::env;
 use std::path::PathBuf;
-use tauri::{api, Config, Window};
+use tauri::{AppHandle, Config, Manager, WebviewWindow};
 
 pub fn get_pake_config() -> (PakeConfig, Config) {
     #[cfg(feature = "cli-build")]
@@ -23,10 +23,12 @@ pub fn get_pake_config() -> (PakeConfig, Config) {
     (pake_config, tauri_config)
 }
 
-pub fn get_data_dir(_tauri_config: Config) -> PathBuf {
+pub fn get_data_dir(app: &AppHandle, _tauri_config: Config) -> PathBuf {
     {
-        let package_name = _tauri_config.package.product_name.unwrap();
-        let data_dir = api::path::config_dir()
+        let package_name = _tauri_config.product_name.unwrap();
+        let data_dir = app
+            .path()
+            .config_dir()
             .expect("Failed to get data dirname")
             .join(package_name);
 
@@ -38,7 +40,7 @@ pub fn get_data_dir(_tauri_config: Config) -> PathBuf {
     }
 }
 
-pub fn show_toast(window: &Window, message: &str) {
+pub fn show_toast(window: &WebviewWindow, message: &str) {
     let script = format!(r#"pakeToast("{}");"#, message);
     window.eval(&script).unwrap();
 }