improve start-minimized and start-on-login behavior

Previously, when Creddy was configured to start minimized, it would always start minimized, regardless of how it was launched. Really, though, when you use this setting what you probably want is for it to start minimized only when it's being launched automatically, i.e. on login. This update changes its behavior so that it will only start minimized when auto-launching.

Additionally, if Creddy detects on startup that its start-on-login configuration doesn't match the system, it will modify its own settings to match the system (unless it's the very first launch, of course.) That way if you disable Creddy's start-on-login behavior from your system dialog, it will respect your change.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "creddy",
-  "version": "0.6.0",
+  "version": "0.6.3",
   "scripts": {
     "dev": "vite",
     "build": "vite build",

src-tauri/Cargo.lock

@@ -218,30 +218,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "async-executor"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8828ec6e544c02b0d6691d21ed9f9218d0384a82542855073c2a3f58304aaf0"
-dependencies = [
- "async-task",
- "concurrent-queue",
- "fastrand",
- "futures-lite",
- "slab",
-]
-
-[[package]]
-name = "async-fs"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebcd09b382f40fcd159c2d695175b2ae620ffa5f3bd6f664131efff4e8b9e04a"
-dependencies = [
- "async-lock",
- "blocking",
- "futures-lite",
-]
-
 [[package]]
 name = "async-io"
 version = "2.3.3"
@@ -1241,7 +1217,7 @@ dependencies = [
 
 [[package]]
 name = "creddy"
-version = "0.6.0"
+version = "0.6.3"
 dependencies = [
  "argon2",
  "auto-launch",
@@ -1275,7 +1251,6 @@ dependencies = [
  "tauri-plugin-dialog",
  "tauri-plugin-global-shortcut",
  "tauri-plugin-os",
- "tauri-plugin-single-instance",
  "thiserror",
  "time",
  "tokio",
@@ -5647,21 +5622,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "tauri-plugin-single-instance"
-version = "2.0.0-beta.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ecafcc5214a5d3cd7a720c11e9c03cbd45ccaff721963485ec4ab481bdf4540"
-dependencies = [
- "log",
- "serde",
- "serde_json",
- "tauri",
- "thiserror",
- "windows-sys 0.52.0",
- "zbus",
-]
-
 [[package]]
 name = "tauri-runtime"
 version = "2.0.0-beta.18"
@@ -7042,15 +7002,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b8e3d6ae3342792a6cc2340e4394334c7402f3d793b390d2c5494a4032b3030"
 dependencies = [
  "async-broadcast",
- "async-executor",
- "async-fs",
- "async-io",
- "async-lock",
  "async-process",
  "async-recursion",
- "async-task",
  "async-trait",
- "blocking",
  "derivative",
  "enumflags2",
  "event-listener 5.3.1",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "creddy"
-version = "0.6.0"
+version = "0.6.3"
 description = "A friendly AWS credentials manager"
 authors = ["Joseph Montanaro"]
 license = ""
@@ -30,7 +30,7 @@ tauri-build = { version = "2.0.0-beta", features = [] }
 
 [dependencies]
 creddy_cli = { path = "./creddy_cli" }
-tauri = { version = "2.0.0-beta", features = ["tray-icon"] }
+tauri = { version = "2.0.0-beta", features = ["tray-icon", "test"] }
 sodiumoxide = "0.2.7"
 sysinfo = "0.26.8"
 aws-config = "1.5.3"
@@ -49,7 +49,6 @@ chacha20poly1305 = { version = "0.10.1", features = ["std"] }
 which = "4.4.0"
 windows = { version = "0.51.1", features = ["Win32_Foundation", "Win32_System_Pipes"] }
 time = "0.3.31"
-tauri-plugin-single-instance = "2.0.0-beta.9"
 tauri-plugin-global-shortcut = "2.0.0-beta.6"
 tauri-plugin-os = "2.0.0-beta.6"
 tauri-plugin-dialog = "2.0.0-beta.9"

src-tauri/creddy_cli/src/cli/docker.rs

@@ -29,11 +29,20 @@ pub fn docker_get(global_args: GlobalArgs) -> anyhow::Result<()> {
        server_url: server_url.trim().to_owned()
     };
 
-    match super::make_request(global_args.server_addr, &req)?? {
+    let server_resp = super::make_request(global_args.server_addr, &req)?;
-        CliResponse::Credential(CliCredential::Docker(d)) => {
+    match server_resp {
+        Ok(CliResponse::Credential(CliCredential::Docker(d))) => {
             println!("{}", serde_json::to_string(&d)?);
         },
-        r => bail!("Unexpected response from server: {r}"),
+        Err(e) if e.code == "NoCredentials" => {
+            // To indicate credentials are not found, a credential helper *must* print
+            // this message to stdout, then exit 1. Any other message/status will cause
+            // some builds to fail. This is, of course, not documented anywhere.
+            println!("credentials not found in native keychain");
+            std::process::exit(1);
+        },
+        Err(e) => Err(e)?,
+        Ok(r) => bail!("Unexpected response from server: {r}"),
     }
     Ok(())
 }

src-tauri/creddy_cli/src/cli/mod.rs

@@ -65,7 +65,7 @@ pub struct GlobalArgs {
 #[derive(Debug, Subcommand)]
 pub enum Action {
     /// Launch Creddy
-    Run,
+    Run(RunArgs),
     /// Request credentials from Creddy and output to stdout
     Get(GetArgs),
     /// Inject credentials into the environment of another command
@@ -78,6 +78,14 @@ pub enum Action {
 }
 
 
+#[derive(Debug, Args)]
+pub struct RunArgs {
+    /// Minimize to system tray on launch
+    #[arg(long, default_value_t = false)]
+    pub minimized: bool,
+}
+
+
 #[derive(Debug, Args)]
 pub struct GetArgs {
     /// If unspecified, use default credentials
@@ -102,7 +110,7 @@ pub struct ExecArgs {
 #[derive(Debug, Args)]
 pub struct InvokeArgs {
     #[arg(value_name = "ACTION", value_enum)]
-    shortcut_action: ShortcutAction,
+    pub shortcut_action: ShortcutAction,
 }
 
 

src-tauri/creddy_cli/src/lib.rs

@@ -1,19 +1,26 @@
 mod cli;
 pub use cli::{
-    Cli,
     Action,
+    Cli,
+    docker_credential_helper,
     exec,
     get,
+    GlobalArgs,
+    RunArgs,
     invoke_shortcut,
-    docker_credential_helper,
 };
 
-pub(crate) use platform::connect;
+pub use platform::{connect, server_addr};
-pub use platform::server_addr;
 
 pub mod proto;
 
 
+pub fn show_window(global_args: GlobalArgs) -> anyhow::Result<()> {
+    let invoke = cli::InvokeArgs { shortcut_action: proto::ShortcutAction::ShowWindow };
+    cli::invoke_shortcut(invoke, global_args)
+}
+
+
 #[cfg(unix)]
 mod platform {
     use std::path::PathBuf;
@@ -27,7 +34,12 @@ mod platform {
     pub fn server_addr(sock_name: &str) -> PathBuf {
         let mut path = dirs::runtime_dir()
             .unwrap_or_else(|| PathBuf::from("/tmp"));
-        path.push(format!("{sock_name}.sock"));
+        if cfg!(debug_assertions) {
+            path.push(format!("{sock_name}.dev.sock"))
+        }
+        else {
+            path.push(format!("{sock_name}.sock"));
+        }
         path
     }
 }
@@ -36,6 +48,11 @@ mod platform {
 #[cfg(windows)]
 mod platform {
     pub fn server_addr(sock_name: &str) -> String {
-        format!(r"\\.\pipe\{sock_name}")
+        if cfg!(debug_assertions) {
+            format!(r"\\.\pipe\{sock_name}.dev")
+        }
+        else {
+            format!(r"\\.\pipe\{sock_name}")
+        }
     }
 }

src-tauri/creddy_cli/src/main.rs

@@ -1,13 +1,17 @@
 use std::env;
 use std::process::{self, Command};
 
-use creddy_cli::{Action, Cli};
+use creddy_cli::{
-
+    Action,
+    Cli,
+    RunArgs,
+};
 
 fn main() {
     let cli = Cli::parse();
     let res = match cli.action {
-        None | Some(Action::Run)=> launch_gui(),
+        None => launch_gui(RunArgs { minimized: false }),
+        Some(Action::Run(run_args)) => launch_gui(run_args),
         Some(Action::Get(args)) => creddy_cli::get(args, cli.global_args),
         Some(Action::Exec(args)) => creddy_cli::exec(args, cli.global_args),
         Some(Action::Shortcut(args)) => creddy_cli::invoke_shortcut(args, cli.global_args),
@@ -21,7 +25,7 @@ fn main() {
 }
 
 
-fn launch_gui() -> anyhow::Result<()>  {
+fn launch_gui(run_args: RunArgs) -> anyhow::Result<()>  {
     let mut path = env::current_exe()?;
     path.pop(); // bin dir
 
@@ -31,6 +35,10 @@ fn launch_gui() -> anyhow::Result<()>  {
 
     path.push("creddy.exe"); // exe in main install dir (aka gui exe)
 
-    Command::new(path).spawn()?;
+    let mut cmd = Command::new(path);
+    if run_args.minimized {
+        cmd.arg("--minimized");
+    }
+    cmd.spawn()?;
     Ok(())
 }

src-tauri/creddy_cli/src/proto.rs

@@ -99,8 +99,8 @@ pub struct DockerCredential {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ServerError {
-    code: String,
+    pub code: String,
-    msg: String,
+    pub msg: String,
 }
 
 impl Display for ServerError {

src-tauri/src/app.rs

@@ -15,7 +15,7 @@ use tauri::{
     RunEvent,
     WindowEvent,
 };
-use tauri::menu::MenuItem;
+use creddy_cli::{GlobalArgs, RunArgs};
 
 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(run_args: RunArgs, 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,9 +59,10 @@ 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)))
+        .setup(|app| rt::block_on(setup(app, run_args)))
         .build(tauri::generate_context!())?
         .run(|app, run_event| {
             if let RunEvent::WindowEvent { event, .. } = run_event {
@@ -86,11 +88,11 @@ pub async fn connect_db() -> Result<SqlitePool, SetupError> {
 }
 
 
-async fn setup(app: &mut App) -> Result<(), Box<dyn Error>> {
+async fn setup(app: &mut App, run_args: RunArgs) -> Result<(), Box<dyn Error>> {
     APP.set(app.handle().clone()).unwrap();
     tray::setup(app)?;
     // get_or_create_db_path doesn't create the actual db file, just the directory
-    let is_first_launch = !config::get_or_create_db_path()?.exists();
+    let is_first_launch = !config::get_or_create_db_path()?.try_exists()?;
     let pool = connect_db().await?;
     let mut setup_errors: Vec<String> = vec![];
 
@@ -109,10 +111,16 @@ async fn setup(app: &mut App) -> Result<(), Box<dyn Error>> {
     creddy_server::serve(app.handle().clone())?;
     agent::serve(app.handle().clone())?;
 
-    config::set_auto_launch(conf.start_on_login)?;
+    // if this is the first launch, setup system with default auto-launch settings
-    if let Err(_e) = config::set_auto_launch(conf.start_on_login) {
+    if is_first_launch {
-        setup_errors.push("Error: Failed to manage autolaunch.".into());
+        if let Err(e) = conf.set_auto_launch() {
+            setup_errors.push(format!("Failed to manage autolaunch: {e}"));
+        }
     }
+    // otherwise, treat the system as the source of truth and ensure ours matches
+    else {
+        conf.match_auto_launch(&pool).await?;
+    };
 
     // if hotkeys fail to register, disable them so that this error doesn't have to keep showing up
     if let Err(_e) = shortcuts::register_hotkeys(&conf.hotkeys) {
@@ -125,7 +133,7 @@ async fn setup(app: &mut App) -> Result<(), Box<dyn Error>> {
         .map(|names| names.split(':').any(|n| n == "GNOME"))
         .unwrap_or(false);
 
-    if !conf.start_minimized || is_first_launch {
+    if !run_args.minimized {
         show_main_window(&app.handle())?;
     }
 
@@ -158,8 +166,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>>();
+    let menu = app.state::<tray::MenuItems>();
-    show_hide.set_text("Hide")?;
+    menu.after_show()?;
     Ok(())
 }
 
@@ -167,8 +175,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>>();
+    let menu = app.state::<tray::MenuItems>();
-    show_hide.set_text("Show")?;
+    menu.after_hide()?;
     Ok(())
 }
 

src-tauri/src/config.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 use std::time::Duration;
 
-use auto_launch::AutoLaunchBuilder;
+use auto_launch::{AutoLaunch, AutoLaunchBuilder};
 use is_terminal::IsTerminal;
 use serde::{Serialize, Deserialize};
 use sqlx::SqlitePool;
@@ -89,29 +89,49 @@ impl AppConfig {
     pub async fn save(&self, pool: &SqlitePool) -> Result<(), sqlx::error::Error> {
         kv::save(pool, "config", self).await
     }
-}
 
+    /// Configure system with auto-launch settings
+    pub fn set_auto_launch(&self) -> Result<(), SetupError> {
+        let mgr = self.auto_launch_manager()?;
 
-pub fn set_auto_launch(is_configured: bool) -> Result<(), SetupError> {
+        // if enabled, disabled regardless of desired end state because either:
-    let path_buf = std::env::current_exe()
+        // a) we are just going to leave it disabled, or
-        .map_err(|e| auto_launch::Error::Io(e))?;
+        // b) we need to disable-and-reenable in case args are different
-    let path = path_buf
+        if mgr.is_enabled()? {
-        .to_string_lossy();
+            mgr.disable()?;
+        }
+        if self.start_on_login {
+            mgr.enable()?;
+        }
 
-    let auto = AutoLaunchBuilder::new()
+        Ok(())
-        .set_app_name("Creddy")
-        .set_app_path(&path)
-        .build()?;
-
-    let is_enabled = auto.is_enabled()?;
-    if is_configured && !is_enabled {
-        auto.enable()?;
-    }
-    else if !is_configured && is_enabled {
-        auto.disable()?;
     }
 
-    Ok(())
+    /// Match own auto-launch settings to system
+    pub async fn match_auto_launch(&mut self, pool: &SqlitePool) -> Result<(), SetupError> {
+        let mgr = self.auto_launch_manager()?;
+        let is_enabled = mgr.is_enabled()?;
+        if is_enabled != self.start_on_login {
+            self.start_on_login = is_enabled;
+            self.save(pool).await?;
+        }
+        Ok(())
+    }
+
+    fn auto_launch_manager(&self) -> Result<AutoLaunch, SetupError> {
+        let path_buf = std::env::current_exe()
+            .map_err(|e| auto_launch::Error::Io(e))?;
+
+        let name = if cfg!(debug_assertions) { "Creddy" } else { "Creddy (dev)" };
+        let mut builder = AutoLaunchBuilder::new();
+        builder.set_app_name(name);
+        builder.set_app_path(&path_buf.to_string_lossy());
+        if self.start_minimized {
+            builder.set_args(&["run", "--minimized"]);
+        }
+
+        Ok(builder.build()?)
+    }
 }
 
 

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

@@ -8,14 +8,23 @@ use creddy::{
     app,
     errors::ShowError,
 };
-use creddy_cli::{Action, Cli};
+use creddy_cli::{
+    Action,
+    Cli,
+    RunArgs,
+};
 
 
 fn main() {
     let cli = Cli::parse();
     let res = match cli.action {
-        None | Some(Action::Run) => {
+        None => {
-            app::run().error_popup("Creddy encountered an error");
+            let run_args = RunArgs { minimized: false };
+            app::run(run_args, cli.global_args).error_popup("Creddy encountered an error");
+            Ok(())
+        }
+        Some(Action::Run(run_args)) => {
+            app::run(run_args, cli.global_args).error_popup("Creddy encountered an error");
             Ok(())
         },
         Some(Action::Get(args)) => creddy_cli::get(args, cli.global_args),

src-tauri/src/srv/mod.rs

@@ -4,6 +4,7 @@ use tauri::{
     AppHandle,
     async_runtime as rt,
     Manager,
+    Runtime,
 };
 use tokio::io::AsyncReadExt;
 use tokio::sync::oneshot;
@@ -80,9 +81,11 @@ impl<'s> CloseWaiter<'s> {
 }
 
 
-fn serve<H, F>(sock_name: &str, app_handle: AppHandle, handler: H) -> std::io::Result<()>
+// note: AppHandle is generic over `Runtime` for testing
-    where H: Copy + Send + Fn(Stream, AppHandle, u32) -> F + 'static,
+fn serve<H, F, R>(sock_name: &str, app_handle: AppHandle<R>, handler: H) -> std::io::Result<()>
+    where H: Copy + Send + Fn(Stream, AppHandle<R>, u32) -> F + 'static,
           F: Send + Future<Output = Result<(), HandlerError>>,
+          R: Runtime
 {
     let (mut listener, addr) = platform::bind(sock_name)?;
     rt::spawn(async move {
@@ -223,3 +226,31 @@ mod platform {
         Ok((stream, pid))
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::AsyncWriteExt;
+
+    #[tokio::test]
+    async fn test_server_connect() {
+        let app = tauri::test::mock_app();
+        serve("creddy_server_test", app.app_handle().clone(), |mut stream, _handle, _pid| {
+            async move {
+                let buf = serde_json::to_vec(&CliResponse::Empty).unwrap();
+                stream.write_all(&buf).await.unwrap();
+                Ok(())
+            }
+        }).unwrap();
+
+        let addr = creddy_cli::server_addr("creddy_server_test");
+        let mut stream = creddy_cli::connect(Some(addr)).await.unwrap();
+
+        let mut buf = Vec::new();
+        stream.read_to_end(&mut buf).await.unwrap();
+        let resp: CliResponse = serde_json::from_slice(&buf).unwrap();
+
+        assert!(matches!(resp, CliResponse::Empty))
+    }
+}

src-tauri/src/state.rs

@@ -22,7 +22,7 @@ use crate::credentials::{
     DockerCredential,
     SshKey,
 };
-use crate::{config, config::AppConfig};
+use crate::config::AppConfig;
 use crate::credentials::{
     AwsBaseCredential,
     Credential,
@@ -32,6 +32,7 @@ use crate::credentials::{
 use crate::ipc::{self, RequestResponse};
 use crate::errors::*;
 use crate::shortcuts;
+use crate::tray;
 
 
 #[derive(Debug)]
@@ -203,8 +204,9 @@ impl AppState {
         let mut live_config = self.config.write().await;
 
         // update autostart if necessary
-        if new_config.start_on_login != live_config.start_on_login {
+        if new_config.start_on_login != live_config.start_on_login
-            config::set_auto_launch(new_config.start_on_login)?;
+            || new_config.start_minimized != live_config.start_minimized {
+            new_config.set_auto_launch()?;
         }
 
         // re-register hotkeys if necessary
@@ -252,7 +254,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 +272,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])
+        .items(&[&status, &sep, &show_hide, &exit]);
-        .build()?;
 
     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
+    // stash these so we can find them later to change the text
-    app.manage(show_hide);
+    app.manage(MenuItems { status, show_hide });
 
     Ok(())
 }

src-tauri/tauri.conf.json

@@ -50,7 +50,7 @@
     }
   },
   "productName": "creddy",
-  "version": "0.6.0",
+  "version": "0.6.3",
   "identifier": "creddy",
   "plugins": {},
   "app": {

src/App.svelte

@@ -14,6 +14,7 @@ import Unlock from './views/Unlock.svelte';
 // set up app state
 invoke('get_config').then(config => $appState.config = config);
 invoke('get_session_status').then(status => $appState.sessionStatus = status);
+invoke('get_devmode').then(dm => $appState.devmode = dm)
 getVersion().then(version => $appState.appVersion = version);
 invoke('get_setup_errors')
     .then(errs => {
@@ -51,7 +52,7 @@ acceptRequest();
 </script>
 
 
-<svelte:window 
+<svelte:window
     on:click={() => invoke('signal_activity')}
     on:keydown={() => invoke('signal_activity')}
 />
@@ -70,3 +71,9 @@ acceptRequest();
     <!-- normal operation -->
     <svelte:component this="{$currentView}" />
 {/if}
+
+{#if $appState.devmode }
+    <div class="fixed left-0 bottom-0 right-0 py-1 bg-warning text-xs text-center text-warning-content">
+        This is a development build of Creddy.
+    </div>
+{/if}

src/views/ManageCredentials.svelte

@@ -144,7 +144,7 @@
         {:else if records !== null}
             <div class="flex flex-col gap-6 items-center rounded-box border-2 border-dashed border-neutral-content/30 p-6">
                 <div>You have no saved Docker credentials.</div>
-                <button class="btn btn-primary btn-wide mx-auto" on:click={newSsh}>
+                <button class="btn btn-primary btn-wide mx-auto" on:click={newDocker}>
                     <Icon name="plus-circle-mini" class="size-5" />
                     Add
                 </button>

src/views/Settings.svelte

@@ -20,7 +20,6 @@
     let error = null;
     async function save() {
         try {
-            throw('wtf');
             await invoke('save_config', {config});
             $appState.config = await invoke('get_config');
         }
@@ -41,18 +40,20 @@
 
 <form on:submit|preventDefault={save}>
     <div class="max-w-lg mx-auto my-1.5 p-4 space-y-16">
-        <SettingsGroup name="General">            
+        <SettingsGroup name="General">
             <ToggleSetting title="Start on login" bind:value={config.start_on_login}>
                 <svelte:fragment slot="description">
                     Start Creddy when you log in to your computer.
                 </svelte:fragment>
             </ToggleSetting>
 
-            <ToggleSetting title="Start minimized" bind:value={config.start_minimized}>
+            {#if config.start_on_login}
-                <svelte:fragment slot="description">
+                <ToggleSetting title="Start minimized" bind:value={config.start_minimized}>
-                    Minimize to the system tray at startup.
+                    <svelte:fragment slot="description">
-                </svelte:fragment>
+                        Minimize to the system tray when starting on login.
-            </ToggleSetting>
+                    </svelte:fragment>
+                </ToggleSetting>
+            {/if}
 
             <NumericSetting title="Re-hide delay" bind:value={config.rehide_ms} min={0} unit="Milliseconds">
                 <svelte:fragment slot="description">