separate dev and production instances and add visual indicators of dev mode

src-tauri/src/app.rs

@@ -15,7 +15,7 @@ use tauri::{
     RunEvent,
     WindowEvent,
 };
-use tauri::menu::MenuItem;
+use creddy_cli::GlobalArgs;
 
 use crate::{
     config::{self, AppConfig},
@@ -32,12 +32,13 @@ use crate::{
 pub static APP: OnceCell<AppHandle> = OnceCell::new();
 
 
-pub fn run() -> tauri::Result<()> {
+pub fn run(global_args: GlobalArgs) -> tauri::Result<()> {
+    if let Ok(_) = creddy_cli::show_window(global_args) {
+        // app is already running, so terminate
+        return Ok(());
+    }
+
     tauri::Builder::default()
-        .plugin(tauri_plugin_single_instance::init(|app, _argv, _cwd| {
-            show_main_window(app)
-                .error_popup("Failed to show main window")
-        }))
         .plugin(tauri_plugin_global_shortcut::Builder::default().build())
         .plugin(tauri_plugin_os::init())
         .plugin(tauri_plugin_dialog::init())
@@ -58,6 +59,7 @@ pub fn run() -> tauri::Result<()> {
             ipc::save_config,
             ipc::launch_terminal,
             ipc::get_setup_errors,
+            ipc::get_devmode,
             ipc::exit,
         ])
         .setup(|app| rt::block_on(setup(app)))
@@ -158,8 +160,8 @@ fn start_auto_locker(app: AppHandle) {
 pub fn show_main_window(app: &AppHandle) -> Result<(), WindowError> {
     let w = app.get_webview_window("main").ok_or(WindowError::NoMainWindow)?;
     w.show()?;
-    let show_hide = app.state::<MenuItem<tauri::Wry>>();
-    show_hide.set_text("Hide")?;
+    let menu = app.state::<tray::MenuItems>();
+    menu.after_show()?;
     Ok(())
 }
 
@@ -167,8 +169,8 @@ pub fn show_main_window(app: &AppHandle) -> Result<(), WindowError> {
 pub fn hide_main_window(app: &AppHandle) -> Result<(), WindowError> {
     let w = app.get_webview_window("main").ok_or(WindowError::NoMainWindow)?;
     w.hide()?;
-    let show_hide = app.state::<MenuItem<tauri::Wry>>();
-    show_hide.set_text("Show")?;
+    let menu = app.state::<tray::MenuItems>();
+    menu.after_hide()?;
     Ok(())
 }
 

src-tauri/src/ipc.rs

@@ -204,6 +204,12 @@ pub async fn get_setup_errors(app_state: State<'_, AppState>) -> Result<Vec<Stri
 }
 
 
+#[tauri::command]
+pub fn get_devmode() -> bool {
+    cfg!(debug_assertions)
+}
+
+
 #[tauri::command]
 pub fn exit(app_handle: AppHandle) {
     app_handle.exit(0)

src-tauri/src/main.rs

@@ -15,7 +15,7 @@ fn main() {
     let cli = Cli::parse();
     let res = match cli.action {
         None | Some(Action::Run) => {
-            app::run().error_popup("Creddy encountered an error");
+            app::run(cli.global_args).error_popup("Creddy encountered an error");
             Ok(())
         },
         Some(Action::Get(args)) => creddy_cli::get(args, cli.global_args),

src-tauri/src/state.rs

@@ -32,6 +32,7 @@ use crate::credentials::{
 use crate::ipc::{self, RequestResponse};
 use crate::errors::*;
 use crate::shortcuts;
+use crate::tray;
 
 
 #[derive(Debug)]
@@ -252,7 +253,11 @@ impl AppState {
 
     pub async fn unlock(&self, passphrase: &str) -> Result<(), UnlockError> {
         let mut session = self.app_session.write().await;
-        session.unlock(passphrase)
+        session.unlock(passphrase)?;
+        let app_handle = app::APP.get().unwrap();
+        let menu = app_handle.state::<tray::MenuItems>();
+        let _ = menu.after_unlock(); // we don't care if this fails, it's non-essential
+        Ok(())
     }
 
     pub async fn lock(&self) -> Result<(), LockError> {
@@ -266,6 +271,9 @@ impl AppState {
                 let app_handle = app::APP.get().unwrap();
                 app_handle.emit("locked", None::<usize>)?;
 
+                let menu = app_handle.state::<tray::MenuItems>();
+                let _ = menu.after_lock();
+
                 Ok(())
             }
         }

src-tauri/src/tray.rs

@@ -7,27 +7,74 @@ use tauri::{
 use tauri::menu::{
     MenuBuilder,
     MenuEvent,
+    MenuItem,
     MenuItemBuilder,
+    PredefinedMenuItem,
 };
 
 use crate::app;
 use crate::state::AppState;
 
 
+pub struct MenuItems {
+    pub status: MenuItem<tauri::Wry>,
+    pub show_hide: MenuItem<tauri::Wry>,
+}
+
+impl MenuItems {
+    pub fn after_show(&self) -> tauri::Result<()> {
+        self.show_hide.set_text("Hide")
+    }
+
+    pub fn after_hide(&self) -> tauri::Result<()> {
+        self.show_hide.set_text("Show")
+    }
+
+    pub fn after_lock(&self) -> tauri::Result<()> {
+        if cfg!(debug_assertions) {
+            self.status.set_text("Creddy (dev): Locked")
+        }
+        else {
+            self.status.set_text("Creddy: Locked")
+        }
+    }
+
+    pub fn after_unlock(&self) -> tauri::Result<()> {
+        if cfg!(debug_assertions) {
+            self.status.set_text("Creddy (dev): Unlocked")
+        }
+        else {
+            self.status.set_text("Creddy: Unlocked")
+        }
+    }
+}
+
+
 pub fn setup(app: &App) -> tauri::Result<()> {
+    let status_text =
+        if cfg!(debug_assertions) {
+            "Creddy (dev): Locked"
+        }
+        else {
+            "Creddy: Locked"
+        };
+
+    let status = MenuItemBuilder::with_id("status", status_text)
+        .enabled(false)
+        .build(app)?;
+    let sep = PredefinedMenuItem::separator(app)?;
     let show_hide = MenuItemBuilder::with_id("show_hide", "Show").build(app)?;
     let exit = MenuItemBuilder::with_id("exit", "Exit").build(app)?;
 
     let menu = MenuBuilder::new(app)
-        .items(&[&show_hide, &exit])
-        .build()?;
+        .items(&[&status, &sep, &show_hide, &exit]);
 
     let tray = app.tray_by_id("main").unwrap();
-    tray.set_menu(Some(menu))?;
+    tray.set_menu(Some(menu.build()?))?;
     tray.on_menu_event(handle_event);
 
-    // stash this so we can find it later to change the text
-    app.manage(show_hide);
+    // stash these so we can find them later to change the text
+    app.manage(MenuItems { status, show_hide });
 
     Ok(())
 }