Fix Windows tray stuck on "Waiting"; make idle reason visible

The Windows GUI build has no console (windows_subsystem = "windows"), so
every eprintln is discarded — a worker that dies or can't find work looks
identical to a healthy idle one: a permanent "Status: Waiting" with no
clue why. The likely trigger: the default workdir was CWD-relative
("decryptd-data"), and a tray app launched from Explorer/login often has
a non-writable CWD (System32, Program Files), so create_dir_all failed
and the worker thread died instantly while the (disk-free) GPU list still
rendered.

- GUI builds now default the workdir to a stable per-user data dir
  (%LOCALAPPDATA%\decryptd on Windows, ~/.local/share/decryptd on Linux),
  so launch CWD no longer matters. Console builds keep ./decryptd-data.
  Overridable via --workdir / DECRYPTD_WORKDIR.
- Surface why the worker is idle in the tray: "no open work", "pull
  error: …", or "stopped: …" instead of a bare "Waiting". A fatal worker
  stop also pops a desktop notification (the only channel that survives
  the GUI subsystem).

Tests for workdir resolution. Both feature sets build; verified the GUI
build now writes ~/.local/share/decryptd from any CWD. Bump to 0.1.12.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "decryptd"
-version = "0.1.11"
+version = "0.1.12"
 edition = "2024"
 license = "Proprietary"
 authors = ["Karpeles Lab Inc"]

Cargo.toml

@@ -31,8 +31,13 @@ pub fn run_with_tray(args: RunArgs, status: Status) -> Result<()> {
 
     let worker_status = status.clone();
     let worker = std::thread::spawn(move || {
-        if let Err(e) = crate::run_worker(args, worker_status) {
-            eprintln!("[decryptd] worker error: {e:#}");
+        if let Err(e) = crate::run_worker(args, worker_status.clone()) {
+            let msg = format!("{e:#}");
+            eprintln!("[decryptd] worker error: {msg}");
+            // The GUI subsystem swallows stderr, so make a fatal stop visible:
+            // record it in the tray status and pop a desktop notification.
+            worker_status.set_note(format!("stopped: {msg}"));
+            notify_error(&msg);
         }
     });
 
@@ -74,15 +79,26 @@ fn load_icon() -> Result<Icon> {
 }
 
 /// The status line, refreshed each tick. Paused wins over running: while a paused
-/// fragment sits parked between tiles it still counts as "active".
-fn status_label(status: &Status) -> &'static str {
+/// fragment sits parked between tiles it still counts as "active". When idle, the
+/// worker's note (why it's waiting) is shown so a silent stall is legible.
+fn status_label(status: &Status) -> String {
     if status.is_paused() {
-        "Status: Paused"
-    } else if status.is_running() {
-        "Status: Running"
-    } else {
-        "Status: Waiting"
+        return "Status: Paused".to_string();
+    }
+    if status.is_running() {
+        return "Status: Running".to_string();
     }
+    let note = status.note();
+    if note.is_empty() {
+        return "Status: Waiting".to_string();
+    }
+    // Keep the menu from ballooning on a long error message.
+    let note = if note.chars().count() > 60 {
+        format!("{}…", note.chars().take(60).collect::<String>())
+    } else {
+        note
+    };
+    format!("Status: {note}")
 }
 
 /// The Pause/Resume toggle's label, refreshed each tick to match the flag.
@@ -158,6 +174,16 @@ fn notify_running() {
     }
 }
 
+/// Pop a desktop notification for a fatal worker stop. The GUI subsystem has no
+/// console, so this is the only way such an error reaches the user (the tray
+/// status line also carries it, but a notification is what draws the eye).
+fn notify_error(msg: &str) {
+    let _ = notify_rust::Notification::new()
+        .summary(&format!("decryptd v{VERSION} stopped"))
+        .body(msg)
+        .show();
+}
+
 /// Kick off a one-shot self-update from the tray. Reuses [`crate::build_updater`]
 /// — the same signed updater the hourly background task uses — so it shares the
 /// trust anchor and transport; `update()` fetches the latest signed manifest,

src/gui.rs

@@ -56,9 +56,11 @@ struct RunArgs {
     /// KarpelesLab platform host (pullOne/submitFragment are anonymous — no key needed).
     #[arg(long, env = "DECRYPTD_HOST", default_value = "www.atonline.com")]
     host: String,
-    /// Working directory for the blob cache and scratch.
-    #[arg(long, env = "DECRYPTD_WORKDIR", default_value = "decryptd-data")]
-    workdir: PathBuf,
+    /// Working directory for the blob cache, worker id, and scratch. Defaults to a
+    /// per-user data dir for the GUI build (it may be launched from a non-writable
+    /// CWD like System32) and to `./decryptd-data` for the console build.
+    #[arg(long, env = "DECRYPTD_WORKDIR")]
+    workdir: Option<PathBuf>,
     /// Claim a single fragment then exit (default: loop forever).
     #[arg(long)]
     once: bool,
@@ -81,6 +83,39 @@ struct RunArgs {
     cache_max_gb: u64,
 }
 
+impl RunArgs {
+    /// The resolved working directory: the `--workdir`/`DECRYPTD_WORKDIR` value if
+    /// given, else [`default_workdir`].
+    fn workdir(&self) -> PathBuf {
+        self.workdir.clone().unwrap_or_else(default_workdir)
+    }
+}
+
+/// Default working directory. The GUI build can be started from any CWD (an
+/// Explorer double-click, a login item, a service), and a CWD-relative folder may
+/// not be creatable there — a silent failure that strands the tray on "Waiting".
+/// So the GUI build defaults to a stable per-user data dir; the console build,
+/// run from an operator-chosen directory, keeps `./decryptd-data`.
+fn default_workdir() -> PathBuf {
+    #[cfg(feature = "gui")]
+    {
+        #[cfg(windows)]
+        if let Some(base) = std::env::var_os("LOCALAPPDATA") {
+            return PathBuf::from(base).join("decryptd");
+        }
+        #[cfg(not(windows))]
+        {
+            if let Some(base) = std::env::var_os("XDG_DATA_HOME") {
+                return PathBuf::from(base).join("decryptd");
+            }
+            if let Some(home) = std::env::var_os("HOME") {
+                return PathBuf::from(home).join(".local/share/decryptd");
+            }
+        }
+    }
+    PathBuf::from("decryptd-data")
+}
+
 // ------------------------------------------------------------- pullOne response
 /// `Decrypt/Job:pullOne` payload — a claimed fragment, its parent job's blobs, and
 /// the single-use key that authenticates this fragment's result submission.
@@ -228,7 +263,7 @@ fn fetch_blob(args: &RunArgs, downloads: &Downloads, d: &DataRef) -> Result<Vec<
         return Ok(bytes);
     }
 
-    let cache = args.workdir.join("cache");
+    let cache = args.workdir().join("cache");
     std::fs::create_dir_all(&cache)?;
     // `Hash` is the blob's content SHA-256, so it doubles as a cache key + checksum.
     let cache_path = (!d.hash.is_empty()).then(|| cache.join(&d.hash));
@@ -473,6 +508,10 @@ struct Status {
     active: Arc<AtomicUsize>,
     /// Set by the tray's Pause item; the worker parks at its gates while true.
     paused: Arc<AtomicBool>,
+    /// Why the worker is idle when not running — "no open work", a pull error, or
+    /// a fatal stop. Surfaced in the tray so a Windows user (whose console logs are
+    /// swallowed by the GUI subsystem) can tell an idle worker from a broken one.
+    note: Arc<Mutex<String>>,
 }
 
 impl Status {
@@ -513,6 +552,21 @@ impl Status {
         }
     }
 
+    /// Record why the worker is idle (shown in the tray). Set by the pipeline on
+    /// pull errors / no-work and by the GUI on a fatal worker stop.
+    fn set_note(&self, note: impl Into<String>) {
+        *self.note.lock().unwrap() = note.into();
+    }
+
+    /// The current idle note, or empty. Only read by the GUI tray.
+    #[cfg_attr(
+        not(all(feature = "gui", any(target_os = "linux", target_os = "windows"))),
+        allow(dead_code)
+    )]
+    fn note(&self) -> String {
+        self.note.lock().unwrap().clone()
+    }
+
     /// Mark a GPU run as started; the returned guard marks it finished on drop
     /// (so a panic in `run_on_gpu` can't strand the counter above zero).
     fn run_guard(&self) -> RunGuard {
@@ -777,16 +831,19 @@ fn prefetch_loop(
         status.wait_while_paused();
         match claim_and_fetch(&args, &downloads, &worker_id, &ctx, &inflight) {
             Ok(Some(job)) => {
+                status.set_note(""); // got work; clear any idle note
                 if ready.send(job).is_err() {
                     return; // pipeline shut down
                 }
             }
             Ok(None) => {
                 eprintln!("[decryptd] no work; sleeping {}s", args.idle_secs);
+                status.set_note("no open work");
                 thread::sleep(Duration::from_secs(args.idle_secs));
             }
             Err(e) => {
                 eprintln!("[decryptd] pull error: {e:#}");
+                status.set_note(format!("pull error: {e}"));
                 thread::sleep(Duration::from_secs(args.idle_secs));
             }
         }
@@ -952,11 +1009,13 @@ fn load_or_create_worker_id(workdir: &Path) -> Result<String> {
 }
 
 fn run_worker(args: RunArgs, status: Status) -> Result<()> {
-    std::fs::create_dir_all(&args.workdir)?;
+    let workdir = args.workdir();
+    std::fs::create_dir_all(&workdir)
+        .with_context(|| format!("creating workdir {}", workdir.display()))?;
     let ctx = RestContext::with_config(Config::new("https".to_string(), args.host.clone()))
         .with_debug(std::env::var("DECRYPTD_DEBUG").is_ok());
     let jobs = args.jobs.max(1);
-    let worker_id = load_or_create_worker_id(&args.workdir)?;
+    let worker_id = load_or_create_worker_id(&workdir)?;
 
     let count = cuda::device_count().map_err(|e| anyhow!("enumerating GPUs: {e}"))?;
     if count < 1 {
@@ -1073,6 +1132,17 @@ mod tests {
         assert_eq!(bytes, b"hello");
     }
 
+    #[test]
+    fn workdir_override_beats_default() {
+        // Explicit --workdir is always honored verbatim.
+        let a = RunArgs::parse_from(["decryptd", "--workdir", "/tmp/custom-wd"]);
+        assert_eq!(a.workdir(), PathBuf::from("/tmp/custom-wd"));
+        // In the (non-gui) test build the default is the CWD-relative folder.
+        let b = RunArgs::parse_from(["decryptd"]);
+        assert_eq!(b.workdir(), default_workdir());
+        assert_eq!(default_workdir(), PathBuf::from("decryptd-data"));
+    }
+
     #[test]
     fn worker_id_persists_and_is_reused() {
         let dir = std::env::temp_dir().join(format!("decryptd-wid-{}", std::process::id()));